void CAParseURI(const char* uriInfo, coap_list_t **optlist) { OIC_LOG(DEBUG, TAG, "parse URI"); unsigned char portbuf[2]; unsigned char _buf[CA_BUFSIZE]; unsigned char *buf = _buf; coap_uri_t uri; size_t buflen; uint32_t res; OIC_LOG_V(DEBUG, TAG, "url : %s", uriInfo); /* split arg into Uri-* options */ coap_split_uri((unsigned char *) uriInfo, strlen(uriInfo), &uri); if (uri.port != COAP_DEFAULT_PORT) { coap_insert(optlist, CACreateNewOptionNode(COAP_OPTION_URI_PORT, coap_encode_var_bytes(portbuf, uri.port), portbuf), CAOrderOpts); } if (uri.path.length) { buflen = CA_BUFSIZE; res = coap_split_path(uri.path.s, uri.path.length, buf, &buflen); while (res--) { coap_insert(optlist, CACreateNewOptionNode(COAP_OPTION_URI_PATH, COAP_OPT_LENGTH(buf), COAP_OPT_VALUE(buf)), CAOrderOpts); buf += COAP_OPT_SIZE(buf); } } if (uri.query.length) { buflen = CA_BUFSIZE; buf = _buf; res = coap_split_query(uri.query.s, uri.query.length, buf, &buflen); while (res--) { coap_insert(optlist, CACreateNewOptionNode(COAP_OPTION_URI_QUERY, COAP_OPT_LENGTH(buf), COAP_OPT_VALUE(buf)), CAOrderOpts); buf += COAP_OPT_SIZE(buf); } } }
CAResult_t CAParseUriPartial(const unsigned char *str, size_t length, int target, coap_list_t **optlist) { if (!optlist) { OIC_LOG(ERROR, TAG, "optlist is null"); return CA_STATUS_INVALID_PARAM; } if ((target != COAP_OPTION_URI_PATH) && (target != COAP_OPTION_URI_QUERY)) { // should never occur. Log just in case. OIC_LOG(DEBUG, TAG, "Unexpected URI component."); return CA_NOT_SUPPORTED; } else if (str && length) { unsigned char uriBuffer[CA_BUFSIZE] = { 0 }; unsigned char *pBuf = uriBuffer; size_t buflen = sizeof(uriBuffer); int res = (target == COAP_OPTION_URI_PATH) ? coap_split_path(str, length, pBuf, &buflen) : coap_split_query(str, length, pBuf, &buflen); if (res > 0) { size_t prevIdx = 0; while (res--) { int ret = coap_insert(optlist, CACreateNewOptionNode(target, COAP_OPT_LENGTH(pBuf), (char *)COAP_OPT_VALUE(pBuf)), CAOrderOpts); if (ret <= 0) { return CA_STATUS_INVALID_PARAM; } size_t optSize = COAP_OPT_SIZE(pBuf); if ((prevIdx + optSize) < buflen) { pBuf += optSize; prevIdx += optSize; } } } else { OIC_LOG_V(ERROR, TAG, "Problem parsing URI : %d for %d", res, target); return CA_STATUS_FAILED; } } else { OIC_LOG(ERROR, TAG, "str or length is not available"); return CA_STATUS_FAILED; } return CA_STATUS_OK; }
void CAParseHeadOption(const uint32_t code, const CAInfo_t info, coap_list_t **optlist) { OIC_LOG_V(DEBUG, TAG, "start parse Head Option : %d", info.numOptions); uint32_t i; for (i = 0; i < info.numOptions; i++) { coap_insert(optlist, CACreateNewOptionNode(info.options->optionID, info.options->optionLength, info.options->optionData), CAOrderOpts); } }
coap_key_t coap_add_subscription(coap_context_t *context, coap_subscription_t *subscription) { coap_list_t *node; if ( !context || !subscription ) return COAP_INVALID_HASHKEY; if ( !(node = coap_new_listnode(subscription, NULL)) ) return COAP_INVALID_HASHKEY; if ( !coap_insert(&context->subscriptions, node, _order_subscription ) ) { coap_free( node ); /* do not call coap_delete(), so subscription object will survive */ return COAP_INVALID_HASHKEY; } return coap_subscription_hash(subscription); }
CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t **optlist) { (void)code; OIC_LOG(DEBUG, TAG, "IN"); VERIFY_NON_NULL_RET(info, TAG, "info is NULL", CA_STATUS_INVALID_PARAM); OIC_LOG_V(DEBUG, TAG, "parse Head Opt: %d", info->numOptions); if (!optlist) { OIC_LOG(ERROR, TAG, "optlist is null"); return CA_STATUS_INVALID_PARAM; } for (uint32_t i = 0; i < info->numOptions; i++) { if(!(info->options + i)) { OIC_LOG(ERROR, TAG, "options is not available"); return CA_STATUS_FAILED; } uint32_t id = (info->options + i)->optionID; if (COAP_OPTION_URI_PATH == id || COAP_OPTION_URI_QUERY == id) { OIC_LOG_V(DEBUG, TAG, "not Header Opt: %d", id); } else { if ((info->options + i)->optionData && (info->options + i)->optionLength > 0) { OIC_LOG_V(DEBUG, TAG, "Head opt ID: %d", id); OIC_LOG_V(DEBUG, TAG, "Head opt data: %s", (info->options + i)->optionData); OIC_LOG_V(DEBUG, TAG, "Head opt length: %d", (info->options + i)->optionLength); int ret = coap_insert(optlist, CACreateNewOptionNode(id, (info->options + i)->optionLength, (info->options + i)->optionData), CAOrderOpts); if (ret <= 0) { return CA_STATUS_INVALID_PARAM; } } } } // insert one extra header with the payload format if applicable. if (CA_FORMAT_UNDEFINED != info->payloadFormat) { coap_list_t* node = NULL; uint8_t buf[3] = {0}; switch (info->payloadFormat) { case CA_FORMAT_CBOR: node = CACreateNewOptionNode( COAP_OPTION_CONTENT_FORMAT, coap_encode_var_bytes(buf, (uint16_t)COAP_MEDIATYPE_APPLICATION_CBOR), (char *)buf); break; default: OIC_LOG_V(ERROR, TAG, "format option:[%d] not supported", info->payloadFormat); } if (!node) { OIC_LOG(ERROR, TAG, "format option not created"); return CA_STATUS_INVALID_PARAM; } int ret = coap_insert(optlist, node, CAOrderOpts); if (ret <= 0) { coap_delete(node); OIC_LOG(ERROR, TAG, "format option not inserted in header"); return CA_STATUS_INVALID_PARAM; } } OIC_LOG(DEBUG, TAG, "OUT"); return CA_STATUS_OK; }
CAResult_t CAParseURI(const char *uriInfo, coap_list_t **optlist) { OIC_LOG(DEBUG, TAG, "IN"); if (NULL == uriInfo) { OIC_LOG(ERROR, TAG, "uriInfo is null"); return CA_STATUS_INVALID_PARAM; } OIC_LOG_V(DEBUG, TAG, "url : %s", uriInfo); if (NULL == optlist) { OIC_LOG(ERROR, TAG, "optlist is null"); return CA_STATUS_INVALID_PARAM; } /* split arg into Uri-* options */ coap_uri_t uri; coap_split_uri((unsigned char *) uriInfo, strlen(uriInfo), &uri); if (uri.port != COAP_DEFAULT_PORT) { unsigned char portbuf[CA_PORT_BUFFER_SIZE] = { 0 }; int ret = coap_insert(optlist, CACreateNewOptionNode(COAP_OPTION_URI_PORT, coap_encode_var_bytes(portbuf, uri.port), (char *)portbuf), CAOrderOpts); if (ret <= 0) { return CA_STATUS_INVALID_PARAM; } } if (uri.path.s && uri.path.length) { CAResult_t ret = CAParseUriPartial(uri.path.s, uri.path.length, COAP_OPTION_URI_PATH, optlist); if (CA_STATUS_OK != ret) { OIC_LOG(ERROR, TAG, "CAParseUriPartial failed(uri path)"); return ret; } } if (uri.query.s && uri.query.length) { CAResult_t ret = CAParseUriPartial(uri.query.s, uri.query.length, COAP_OPTION_URI_QUERY, optlist); if (CA_STATUS_OK != ret) { OIC_LOG(ERROR, TAG, "CAParseUriPartial failed(uri query)"); return ret; } } OIC_LOG(DEBUG, TAG, "OUT"); return CA_STATUS_OK; }
int dia_dns_lookup(const char *server, void *dst) { struct addrinfo *res, *best; struct addrinfo hints; static char addrstr[256]; int error; coap_list_t *node; dns_cache_t *entry; if (server && *server) strcpy (addrstr, server); else strcpy (addrstr, "localhost"); // Already in cache ? for (node = gCache; node; node = node->next) { entry = (dns_cache_t *)node->data; if (!strcmp(addrstr, entry->host)) { rtl_trace (5, "dns_lookup : %s found in cache\n", addrstr); memcpy (dst, &entry->dst, entry->len); return entry->len; } } // rtl_trace (5, "dns_lookup : %s not found. search in DNS\n", addrstr); // DNS lookup memset ((char *)&hints, 0, sizeof(hints)); hints.ai_socktype = SOCK_DGRAM; hints.ai_family = AF_UNSPEC; #ifdef ANDROID error = getaddrinfo(addrstr, NULL, &hints, &res); #else error = getaddrinfo(addrstr, "", &hints, &res); #endif //error = getaddrinfo(addrstr, NULL, NULL, &res); if (error) { rtl_trace (4, "getaddrinfo: %s\n", gai_strerror(error)); return -1; } best = searchBest (res); if (!best) return 0; int len = best->ai_addrlen; memcpy(dst, best->ai_addr, len); // Create DNS cache entry entry = (dns_cache_t *)malloc(sizeof(dns_cache_t)); strcpy (entry->host, addrstr); memcpy(&entry->dst, best->ai_addr, len); entry->len = len; char tmp[100]; rtl_trace (5, "dns_lookup : %s found in DNS %s %s\n", addrstr, get_ip_fam(dst), get_ip_str(dst, tmp, sizeof(tmp))); // Add to the list node = coap_new_listnode((void *)entry, NULL); coap_insert( &gCache, node, _order_null); freeaddrinfo(res); return len; }
// Add unordered option. It will be ordered by 'order_opts' function void coap_prepare_option (unsigned short key, void *buf, int len) { coap_insert(&optlist, new_option_node(key, buf, len), order_opts); }