| /* |
| // Copyright (c) 2016 Intel Corporation |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| */ |
| |
| #include "os/mynewt.h" |
| |
| #include "oic/port/mynewt/config.h" |
| #ifdef OC_CLIENT |
| #include "oic/oc_client_state.h" |
| #endif /* OC_CLIENT */ |
| |
| #include "oic/messaging/coap/oc_coap.h" |
| #include "oic/oc_api.h" |
| #include "oic/oc_core_res.h" |
| #include "oic/port/mynewt/ip.h" |
| |
| static bool |
| filter_resource(oc_resource_t *resource, const char *rt, int rt_len, |
| CborEncoder *links) |
| { |
| int i; |
| bool match = true; |
| if (rt_len > 0) { |
| match = false; |
| for (i = 0; i < oc_string_array_get_allocated_size(resource->types); i++) { |
| int size = oc_string_array_get_item_size(resource->types, i); |
| const char *t = |
| (const char *)oc_string_array_get_item(resource->types, i); |
| if (rt_len == size && strncmp(rt, t, rt_len) == 0) { |
| match = true; |
| break; |
| } |
| } |
| } |
| |
| if (!match) { |
| return false; |
| } |
| |
| oc_rep_start_object(*links, res); |
| |
| // uri |
| oc_rep_set_text_string(res, href, oc_string(resource->uri)); |
| |
| // rt |
| oc_rep_set_array(res, rt); |
| for (i = 0; i < oc_string_array_get_allocated_size(resource->types); i++) { |
| int size = oc_string_array_get_item_size(resource->types, i); |
| const char *t = (const char *)oc_string_array_get_item(resource->types, i); |
| if (size > 0) |
| oc_rep_add_text_string(rt, t); |
| } |
| oc_rep_close_array(res, rt); |
| |
| // if |
| oc_core_encode_interfaces_mask(oc_rep_object(res), resource->interfaces); |
| |
| // p |
| oc_rep_set_object(res, p); |
| oc_rep_set_uint(p, bm, resource->properties & ~OC_PERIODIC); |
| #ifdef OC_SECURITY |
| if (resource->properties & OC_SECURE) { |
| oc_rep_set_boolean(p, sec, true); |
| oc_rep_set_uint(p, port, oc_connectivity_get_dtls_port()); |
| } |
| #endif /* OC_SECURITY */ |
| |
| oc_rep_close_object(res, p); |
| |
| oc_rep_end_object(*links, res); |
| return true; |
| } |
| |
| static int |
| process_device_object(CborEncoder *device, const char *uuid, const char *rt, |
| int rt_len) |
| { |
| int dev, matches = 0; |
| #ifdef OC_SERVER |
| oc_resource_t *resource; |
| #endif |
| oc_rep_start_object(*device, links); |
| oc_rep_set_text_string(links, di, uuid); |
| oc_rep_set_array(links, links); |
| |
| if (filter_resource(oc_core_get_resource_by_index(OCF_P), rt, rt_len, |
| oc_rep_array(links))) |
| matches++; |
| |
| for (dev = 0; dev < oc_core_get_num_devices(); dev++) { |
| if (filter_resource( |
| oc_core_get_resource_by_index(NUM_OC_CORE_RESOURCES - 1 - dev), rt, |
| rt_len, oc_rep_array(links))) |
| matches++; |
| } |
| |
| #ifdef OC_SERVER |
| for (resource = oc_ri_get_app_resources(); resource; |
| resource = SLIST_NEXT(resource, next)) { |
| if (!(resource->properties & OC_DISCOVERABLE)) { |
| continue; |
| } |
| if (filter_resource(resource, rt, rt_len, oc_rep_array(links))) { |
| matches++; |
| } |
| } |
| #endif |
| |
| #ifdef OC_SECURITY |
| if (filter_resource(oc_core_get_resource_by_index(OCF_SEC_DOXM), rt, rt_len, |
| oc_rep_array(links))) |
| matches++; |
| #endif |
| |
| oc_rep_close_array(links, links); |
| oc_rep_end_object(*device, links); |
| |
| return matches; |
| } |
| |
| static void |
| oc_core_discovery_handler(oc_request_t *req, oc_interface_mask_t interface) |
| { |
| char *rt = NULL; |
| int rt_len = 0, matches = 0; |
| char uuid[37]; |
| |
| rt_len = oc_ri_get_query_value(req->query, req->query_len, "rt", &rt); |
| |
| oc_uuid_to_str(oc_core_get_device_id(0), uuid, sizeof(uuid)); |
| |
| switch (interface) { |
| case OC_IF_LL: { |
| oc_rep_start_links_array(); |
| matches = process_device_object(oc_rep_array(links), uuid, rt, rt_len); |
| oc_rep_end_links_array(); |
| } break; |
| case OC_IF_BASELINE: { |
| oc_rep_start_root_object(); |
| oc_process_baseline_interface(req->resource); |
| oc_rep_set_array(root, links); |
| matches = process_device_object(oc_rep_array(links), uuid, rt, rt_len); |
| oc_rep_close_array(root, links); |
| oc_rep_end_root_object(); |
| } break; |
| default: |
| break; |
| } |
| |
| int response_length = oc_rep_finalize(); |
| |
| if (matches && response_length > 0) { |
| req->response->response_buffer->response_length = response_length; |
| req->response->response_buffer->code = oc_status_code(OC_STATUS_OK); |
| } else { |
| /* There were rt/if selections and there were no matches, so ignore */ |
| req->response->response_buffer->code = OC_IGNORE; |
| } |
| } |
| |
| void |
| oc_create_discovery_resource(void) |
| { |
| oc_core_populate_resource(OCF_RES, "/oic/res", "oic.wk.res", |
| OC_IF_LL | OC_IF_BASELINE, OC_IF_LL, OC_ACTIVE, |
| oc_core_discovery_handler, 0, 0, 0, 0); |
| } |
| |
| #ifdef OC_CLIENT |
| #if MYNEWT_VAL(OC_CLIENT_DISCOVERY_ENABLE) |
| oc_discovery_flags_t |
| oc_ri_process_discovery_payload(struct coap_packet_rx *rsp, |
| oc_discovery_cb_t *handler, |
| oc_endpoint_t *endpoint) |
| { |
| oc_discovery_flags_t ret = OC_CONTINUE_DISCOVERY; |
| oc_string_t uri = { |
| .os_sz = 0, |
| .os_str = NULL |
| }; |
| oc_string_t di = { |
| .os_sz = 0, |
| .os_str = NULL |
| }; |
| bool secure = false; |
| uint16_t dtls_port = 0, default_port = 0; |
| oc_string_array_t types = {}; |
| oc_interface_mask_t interfaces = 0; |
| oc_server_handle_t handle; |
| uint16_t data_off; |
| struct os_mbuf *m; |
| int len; |
| struct oc_endpoint_ip *ip; |
| |
| memcpy(&handle.endpoint, endpoint, oc_endpoint_size(endpoint)); |
| if (oc_endpoint_is_ip(endpoint)) { |
| default_port = ((struct oc_endpoint_ip *)endpoint)->port; |
| } |
| |
| oc_rep_t *array = 0, *rep; |
| |
| len = coap_get_payload(rsp, &m, &data_off); |
| int s = oc_parse_rep(m, data_off, len, &rep); |
| if (s == 0) |
| array = rep; |
| while (array != NULL) { |
| oc_rep_t *device_map = array->value_object; |
| while (device_map != NULL) { |
| switch (device_map->type) { |
| case STRING: |
| if (oc_string_len(device_map->name) == 2 && |
| strncmp(oc_string(device_map->name), "di", 2) == 0) |
| di = device_map->value_string; |
| break; |
| default: |
| break; |
| } |
| device_map = device_map->next; |
| } |
| device_map = array->value_object; |
| while (device_map != NULL) { |
| switch (device_map->type) { |
| case OBJECT_ARRAY: { |
| oc_rep_t *links = device_map->value_object_array; |
| while (links != NULL) { |
| switch (links->type) { |
| case OBJECT: { |
| oc_rep_t *resource_info = links->value_object; |
| while (resource_info != NULL) { |
| switch (resource_info->type) { |
| case STRING: |
| uri = resource_info->value_string; |
| break; |
| case STRING_ARRAY: |
| if (oc_string_len(resource_info->name) == 2 && |
| strncmp(oc_string(resource_info->name), "rt", 2) == 0) |
| types = resource_info->value_array; |
| else { |
| interfaces = 0; |
| int i; |
| for (i = 0; i < oc_string_array_get_allocated_size( |
| resource_info->value_array); |
| i++) { |
| interfaces |= oc_ri_get_interface_mask( |
| oc_string_array_get_item(resource_info->value_array, i), |
| oc_string_array_get_item_size(resource_info->value_array, |
| i)); |
| } |
| } |
| break; |
| case OBJECT: { |
| oc_rep_t *policy_info = resource_info->value_object; |
| while (policy_info != NULL) { |
| if (policy_info->type == INT && |
| oc_string_len(policy_info->name) == 4 && |
| strncmp(oc_string(policy_info->name), "port", 4) == 0) { |
| dtls_port = policy_info->value_int; |
| } |
| if (policy_info->type == BOOL && |
| oc_string_len(policy_info->name) == 3 && |
| strncmp(oc_string(policy_info->name), "sec", 3) == 0 && |
| policy_info->value_boolean == true) { |
| secure = true; |
| } |
| policy_info = policy_info->next; |
| } |
| } break; |
| default: |
| break; |
| } |
| resource_info = resource_info->next; |
| } |
| if (default_port) { |
| ip = (struct oc_endpoint_ip *)&handle.endpoint; |
| if (secure) { |
| ip->port = dtls_port; |
| ip->ep.oe_flags |= OC_ENDPOINT_SECURED; |
| } else { |
| ip->port = default_port; |
| ip->ep.oe_flags &= ~OC_ENDPOINT_SECURED; |
| } |
| } |
| if (handler(oc_string(di), oc_string(uri), types, interfaces, |
| &handle) == OC_STOP_DISCOVERY) { |
| ret = OC_STOP_DISCOVERY; |
| goto done; |
| } |
| dtls_port = 0; |
| secure = false; |
| } break; |
| default: |
| break; |
| } |
| links = links->next; |
| } |
| } break; |
| default: |
| break; |
| } |
| device_map = device_map->next; |
| } |
| array = array->next; |
| } |
| done: |
| oc_free_rep(rep); |
| return ret; |
| } |
| #endif /* OC_CLIENT_DISCOVERY_ENABLE */ |
| #endif /* OC_CLIENT */ |
