/* * Validates encoded message ID byte order and put/get URI option. */ static void test_nanocoap__hdr(void) { uint8_t buf[_BUF_SIZE]; uint16_t msgid = 0xABCD; char path[] = "/test/abcd/efgh"; char loc_path[] = "/foo/bar"; unsigned char path_tmp[64] = {0}; uint8_t *pktpos = &buf[0]; pktpos += coap_build_hdr((coap_hdr_t *)pktpos, COAP_TYPE_CON, NULL, 0, COAP_METHOD_GET, msgid); pktpos += coap_opt_put_location_path(pktpos, 0, loc_path); pktpos += coap_opt_put_uri_path(pktpos, COAP_OPT_LOCATION_PATH, path); coap_pkt_t pkt; coap_parse(&pkt, &buf[0], pktpos - &buf[0]); TEST_ASSERT_EQUAL_INT(msgid, coap_get_id(&pkt)); int res = coap_get_uri_path(&pkt, path_tmp); TEST_ASSERT_EQUAL_INT(sizeof(path), res); TEST_ASSERT_EQUAL_STRING((char *)path, (char *)path_tmp); res = coap_get_location_path(&pkt, path_tmp, 64); TEST_ASSERT_EQUAL_INT(sizeof(loc_path), res); TEST_ASSERT_EQUAL_STRING((char *)loc_path, (char *)path_tmp); }
/* * Validates encoded message ID byte order and put/get URI option. */ static void test_nanocoap__hdr(void) { uint8_t buf[128]; uint16_t msgid = 0xABCD; char path[] = "/test/abcd/efgh"; unsigned char path_tmp[64] = {0}; uint8_t *pktpos = &buf[0]; pktpos += coap_build_hdr((coap_hdr_t *)pktpos, COAP_REQ, NULL, 0, COAP_METHOD_GET, msgid); pktpos += coap_put_option_uri(pktpos, 0, path, COAP_OPT_URI_PATH); coap_pkt_t pkt; coap_parse(&pkt, &buf[0], pktpos - &buf[0]); TEST_ASSERT_EQUAL_INT(msgid, coap_get_id(&pkt)); int res = coap_get_uri(&pkt, path_tmp); TEST_ASSERT_EQUAL_INT(sizeof(path), res); TEST_ASSERT_EQUAL_STRING((char *)path, (char *)path_tmp); }
/* * Response callback. */ static void _resp_handler(unsigned req_state, coap_pkt_t* pdu, sock_udp_ep_t *remote) { (void)remote; /* not interested in the source currently */ if (req_state == GCOAP_MEMO_TIMEOUT) { printf("gcoap: timeout for msg ID %02u\n", coap_get_id(pdu)); return; } else if (req_state == GCOAP_MEMO_ERR) { printf("gcoap: error in response\n"); return; } char *class_str = (coap_get_code_class(pdu) == COAP_CLASS_SUCCESS) ? "Success" : "Error"; printf("gcoap: response %s, code %1u.%02u", class_str, coap_get_code_class(pdu), coap_get_code_detail(pdu)); if (pdu->payload_len) { if (pdu->content_type == COAP_FORMAT_TEXT || pdu->content_type == COAP_FORMAT_LINK || coap_get_code_class(pdu) == COAP_CLASS_CLIENT_FAILURE || coap_get_code_class(pdu) == COAP_CLASS_SERVER_FAILURE) { /* Expecting diagnostic payload in failure cases */ printf(", %u bytes\n%.*s\n", pdu->payload_len, pdu->payload_len, (char *)pdu->payload); } else { printf(", %u bytes\n", pdu->payload_len); od_hex_dump(pdu->payload, pdu->payload_len, OD_WIDTH_DEFAULT); } } else { printf(", empty payload\n"); } }
/* Listen for an incoming CoAP message. */ static void _listen(sock_udp_t *sock) { coap_pkt_t pdu; uint8_t buf[GCOAP_PDU_BUF_SIZE]; sock_udp_ep_t remote; gcoap_request_memo_t *memo = NULL; uint8_t open_reqs = gcoap_op_state(); /* We expect a -EINTR response here when unlimited waiting (SOCK_NO_TIMEOUT) * is interrupted when sending a message in gcoap_req_send2(). While a * request is outstanding, sock_udp_recv() is called here with limited * waiting so the request's timeout can be handled in a timely manner in * _event_loop(). */ ssize_t res = sock_udp_recv(sock, buf, sizeof(buf), open_reqs > 0 ? GCOAP_RECV_TIMEOUT : SOCK_NO_TIMEOUT, &remote); if (res <= 0) { #if ENABLE_DEBUG if (res < 0 && res != -ETIMEDOUT) { DEBUG("gcoap: udp recv failure: %d\n", res); } #endif return; } res = coap_parse(&pdu, buf, res); if (res < 0) { DEBUG("gcoap: parse failure: %d\n", (int)res); /* If a response, can't clear memo, but it will timeout later. */ return; } if (pdu.hdr->code == COAP_CODE_EMPTY) { DEBUG("gcoap: empty messages not handled yet\n"); return; } /* validate class and type for incoming */ switch (coap_get_code_class(&pdu)) { /* incoming request */ case COAP_CLASS_REQ: if (coap_get_type(&pdu) == COAP_TYPE_NON || coap_get_type(&pdu) == COAP_TYPE_CON) { size_t pdu_len = _handle_req(&pdu, buf, sizeof(buf), &remote); if (pdu_len > 0) { ssize_t bytes = sock_udp_send(sock, buf, pdu_len, &remote); if (bytes <= 0) { DEBUG("gcoap: send response failed: %d\n", (int)bytes); } } } else { DEBUG("gcoap: illegal request type: %u\n", coap_get_type(&pdu)); } break; /* incoming response */ case COAP_CLASS_SUCCESS: case COAP_CLASS_CLIENT_FAILURE: case COAP_CLASS_SERVER_FAILURE: _find_req_memo(&memo, &pdu, &remote); if (memo) { switch (coap_get_type(&pdu)) { case COAP_TYPE_NON: case COAP_TYPE_ACK: xtimer_remove(&memo->response_timer); memo->state = GCOAP_MEMO_RESP; if (memo->resp_handler) { memo->resp_handler(memo->state, &pdu, &remote); } if (memo->send_limit >= 0) { /* if confirmable */ *memo->msg.data.pdu_buf = 0; /* clear resend PDU buffer */ } memo->state = GCOAP_MEMO_UNUSED; break; case COAP_TYPE_CON: DEBUG("gcoap: separate CON response not handled yet\n"); break; default: DEBUG("gcoap: illegal response type: %u\n", coap_get_type(&pdu)); break; } } else { DEBUG("gcoap: msg not found for ID: %u\n", coap_get_id(&pdu)); } break; default: DEBUG("gcoap: illegal code class: %u\n", coap_get_code_class(&pdu)); } }
int gcoap_cli_cmd(int argc, char **argv) { /* Ordered like the RFC method code numbers, but off by 1. GET is code 0. */ char *method_codes[] = {"get", "post", "put"}; uint8_t buf[GCOAP_PDU_BUF_SIZE]; coap_pkt_t pdu; size_t len; if (argc == 1) { /* show help for main commands */ goto end; } for (size_t i = 0; i < sizeof(method_codes) / sizeof(char*); i++) { if (strcmp(argv[1], method_codes[i]) == 0) { if (argc == 5 || argc == 6) { if (argc == 6) { gcoap_req_init(&pdu, &buf[0], GCOAP_PDU_BUF_SIZE, i+1, argv[4]); memcpy(pdu.payload, argv[5], strlen(argv[5])); len = gcoap_finish(&pdu, strlen(argv[5]), COAP_FORMAT_TEXT); } else { len = gcoap_request(&pdu, &buf[0], GCOAP_PDU_BUF_SIZE, i+1, argv[4]); } printf("gcoap_cli: sending msg ID %u, %u bytes\n", coap_get_id(&pdu), (unsigned) len); if (!_send(&buf[0], len, argv[2], argv[3])) { puts("gcoap_cli: msg send failed"); } else { /* send Observe notification for /cli/stats */ switch (gcoap_obs_init(&pdu, &buf[0], GCOAP_PDU_BUF_SIZE, &_resources[0])) { case GCOAP_OBS_INIT_OK: DEBUG("gcoap_cli: creating /cli/stats notification\n"); size_t payload_len = fmt_u16_dec((char *)pdu.payload, req_count); len = gcoap_finish(&pdu, payload_len, COAP_FORMAT_TEXT); gcoap_obs_send(&buf[0], len, &_resources[0]); break; case GCOAP_OBS_INIT_UNUSED: DEBUG("gcoap_cli: no observer for /cli/stats\n"); break; case GCOAP_OBS_INIT_ERR: DEBUG("gcoap_cli: error initializing /cli/stats notification\n"); break; } } return 0; } else { printf("usage: %s <get|post|put> <addr> <port> <path> [data]\n", argv[0]); return 1; } } } if (strcmp(argv[1], "info") == 0) { if (argc == 2) { uint8_t open_reqs = gcoap_op_state(); printf("CoAP server is listening on port %u\n", GCOAP_PORT); printf(" CLI requests sent: %u\n", req_count); printf("CoAP open requests: %u\n", open_reqs); return 0; } } end: printf("usage: %s <get|post|put|info>\n", argv[0]); return 1; }