static int print_thread_id(char *buf, size_t bs, int thread_id) { #if CFG_NUM_THREADS > 9 int num_thread_digits = 2; #else int num_thread_digits = 1; #endif if (thread_id >= 0) return snprintk(buf, bs, "%0*d ", num_thread_digits, thread_id); else return snprintk(buf, bs, "%*s ", num_thread_digits, ""); }
static int storage_clear(const bt_addr_le_t *addr) { char path[STORAGE_PATH_MAX]; int err; if (addr) { #if MAX_FILE_NAME >= STORAGE_FILE_NAME_LEN snprintk(path, STORAGE_PATH_MAX, STORAGE_ROOT "/%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%u", addr->a.val[5], addr->a.val[4], addr->a.val[3], addr->a.val[2], addr->a.val[1], addr->a.val[0], addr->type); return unlink_recursive(path); #else return -ENAMETOOLONG; #endif } /* unlink_recursive() uses the given path as a buffer for * constructing sub-paths, so we can't give it a string literal * such as STORAGE_ROOT directly. */ strcpy(path, STORAGE_ROOT); err = unlink_recursive(path); if (err) { return err; } return fs_mkdir(STORAGE_ROOT); }
void panic_dump_nested_interrupts(void) { VERIFY(in_panic()); ASSERT(!are_interrupts_enabled()); char buf[128]; int written = 0; written += snprintk(buf + written, sizeof(buf), "Interrupts: [ "); for (int i = nested_interrupts_count - 1; i >= 0; i--) { written += snprintk(buf + written, sizeof(buf) - (u32)written, "%i ", nested_interrupts[i]); } /* written += */ snprintk(buf + written, sizeof(buf) - (u32) written, "]\n"); printk("%s", buf); }
void printk_test(void) { int count; _old_char_out = _char_out; _char_out = ram_console_out; printk("%zu %hhu %hu %u %lu %llu\n", stv, uc, usi, ui, ul, ull); printk("%c %hhd %hd %d %ld %lld\n", c, c, ssi, si, sl, sll); printk("0x%x %p\n", hex, ptr); printk("0x%x 0x%02x 0x%04x 0x%08x\n", 1, 1, 1, 1); printk("0x%x 0x%2x 0x%4x 0x%8x\n", 1, 1, 1, 1); printk("%d %02d %04d %08d\n", 42, 42, 42, 42); printk("%d %02d %04d %08d\n", -42, -42, -42, -42); printk("%u %2u %4u %8u\n", 42, 42, 42, 42); printk("%u %02u %04u %08u\n", 42, 42, 42, 42); ram_console[pos] = '\0'; assert_true((strcmp(ram_console, expected) == 0), "printk failed"); memset(ram_console, 0, sizeof(ram_console)); count = 0; count += snprintk(ram_console + count, sizeof(ram_console) - count, "%zu %hhu %hu %u %lu %llu\n", stv, uc, usi, ui, ul, ull); count += snprintk(ram_console + count, sizeof(ram_console) - count, "%c %hhd %hd %d %ld %lld\n", c, c, ssi, si, sl, sll); count += snprintk(ram_console + count, sizeof(ram_console) - count, "0x%x %p\n", hex, ptr); count += snprintk(ram_console + count, sizeof(ram_console) - count, "0x%x 0x%02x 0x%04x 0x%08x\n", 1, 1, 1, 1); count += snprintk(ram_console + count, sizeof(ram_console) - count, "0x%x 0x%2x 0x%4x 0x%8x\n", 1, 1, 1, 1); count += snprintk(ram_console + count, sizeof(ram_console) - count, "%d %02d %04d %08d\n", 42, 42, 42, 42); count += snprintk(ram_console + count, sizeof(ram_console) - count, "%d %02d %04d %08d\n", -42, -42, -42, -42); count += snprintk(ram_console + count, sizeof(ram_console) - count, "%u %2u %4u %8u\n", 42, 42, 42, 42); count += snprintk(ram_console + count, sizeof(ram_console) - count, "%u %02u %04u %08u\n", 42, 42, 42, 42); ram_console[count] = '\0'; assert_true((strcmp(ram_console, expected) == 0), "snprintk failed"); }
static int storage_open(const bt_addr_le_t *addr, uint16_t key, enum storage_access access, fs_file_t *file) { char path[STORAGE_PATH_MAX]; if (addr) { #if MAX_FILE_NAME >= STORAGE_FILE_NAME_LEN int len; len = snprintk(path, sizeof(path), STORAGE_ROOT "/%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%u", addr->a.val[5], addr->a.val[4], addr->a.val[3], addr->a.val[2], addr->a.val[1], addr->a.val[0], addr->type); /* Create the subdirectory if necessary */ if (access == STORAGE_WRITE) { struct fs_dirent entry; int err; err = fs_stat(path, &entry); if (err) { err = fs_mkdir(path); if (err) { return err; } } } snprintk(path + len, sizeof(path) - len, "/%04x", key); #else return -ENAMETOOLONG; #endif } else { snprintk(path, sizeof(path), STORAGE_ROOT "/%04x", key); } return fs_open(file, path); }
static int unlink_recursive(char path[STORAGE_PATH_MAX]) { size_t path_len; fs_dir_t dir; int err; err = fs_opendir(&dir, path); if (err) { return err; } /* We calculate this up-front so we can keep reusing the same * buffer for the path when recursing. */ path_len = strlen(path); while (1) { struct fs_dirent entry; err = fs_readdir(&dir, &entry); if (err) { break; } if (entry.name[0] == '\0') { break; } snprintk(path + path_len, STORAGE_PATH_MAX - path_len, "/%s", entry.name); if (entry.type == FS_DIR_ENTRY_DIR) { err = unlink_recursive(path); } else { err = fs_unlink(path); } if (err) { break; } } fs_closedir(&dir); /* Return to the original value */ path[path_len] = '\0'; fs_unlink(path); return err; }
static int set_endpoint_name(char *ep_name, sa_family_t family) { int ret; ret = snprintk(ep_name, ENDPOINT_LEN, "%s-%s-%u", CONFIG_BOARD, (family == AF_INET6 ? "ipv6" : "ipv4"), sys_rand32_get()); if (ret < 0 || ret >= ENDPOINT_LEN) { SYS_LOG_ERR("Can't fill name buffer"); return -EINVAL; } return 0; }
static char *get_mqtt_payload(enum mqtt_qos qos) { #if APP_BLUEMIX_TOPIC static char payload[30]; snprintk(payload, sizeof(payload), "{d:{temperature:%d}}", (u8_t)sys_rand32_get()); #else static char payload[] = "DOORS:OPEN_QoSx"; payload[strlen(payload) - 1] = '0' + qos; #endif return payload; }
static void print_header_field(size_t len, const char *str) { #if defined(CONFIG_NET_DEBUG_HTTP) #define MAX_OUTPUT_LEN 128 char output[MAX_OUTPUT_LEN]; /* The value of len does not count \0 so we need to increase it * by one. */ if ((len + 1) > sizeof(output)) { len = sizeof(output) - 1; } snprintk(output, len + 1, "%s", str); NET_DBG("[%zd] %s", len, output); #endif }
static void sysview_api_send_task_list(void) { struct k_thread *thr; for (thr = _kernel.threads; thr; thr = thr->next_thread) { char name[20]; snprintk(name, sizeof(name), "T%xE%x", (uintptr_t)thr, (uintptr_t)thr->entry); /* NOTE: struct k_thread is inside the stack on Zephyr 1.7. * This is not guaranteed by the API, and is likely to change * in the future. Hence, StackBase/StackSize are not set here; * these could be stored as part of the kernel event. */ SEGGER_SYSVIEW_SendTaskInfo(&(SEGGER_SYSVIEW_TASKINFO) { .TaskID = (u32_t)(uintptr_t)thr, .sName = name, .Prio = thr->base.prio, }); }
static void tcp_received(struct net_context *context, struct net_pkt *pkt, int status, void *user_data) { static char dbg[MAX_DBG_PRINT + 1]; struct net_pkt *reply_pkt; sa_family_t family; int ret; if (!pkt) { /* EOF condition */ return; } family = net_pkt_family(pkt); snprintk(dbg, MAX_DBG_PRINT, "TCP IPv%c", family == AF_INET6 ? '6' : '4'); reply_pkt = build_reply_pkt(dbg, context, pkt); net_pkt_unref(pkt); if (!reply_pkt) { return; } ret = net_context_send(reply_pkt, pkt_sent, K_NO_WAIT, UINT_TO_POINTER(net_pkt_get_len(reply_pkt)), NULL); if (ret < 0) { NET_ERR("Cannot send data to peer (%d)", ret); net_pkt_unref(reply_pkt); quit(); } }
static void udp_received(struct net_context *context, struct net_pkt *pkt, int status, void *user_data) { struct net_pkt *reply_pkt; struct sockaddr dst_addr; sa_family_t family = net_pkt_family(pkt); static char dbg[MAX_DBG_PRINT + 1]; int ret; snprintk(dbg, MAX_DBG_PRINT, "UDP IPv%c", family == AF_INET6 ? '6' : '4'); set_dst_addr(family, pkt, &dst_addr); reply_pkt = build_reply_pkt(dbg, context, pkt); net_pkt_unref(pkt); if (!reply_pkt) { return; } ret = net_context_sendto(reply_pkt, &dst_addr, family == AF_INET6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in), pkt_sent, 0, UINT_TO_POINTER(net_pkt_get_len(reply_pkt)), user_data); if (ret < 0) { NET_ERR("Cannot send data to peer (%d)", ret); net_pkt_unref(reply_pkt); } }
enum net_verdict net_ipv4_process_pkt(struct net_pkt *pkt) { struct net_ipv4_hdr *hdr = NET_IPV4_HDR(pkt); int real_len = net_pkt_get_len(pkt); int pkt_len = (hdr->len[0] << 8) + hdr->len[1]; enum net_verdict verdict = NET_DROP; if (real_len != pkt_len) { NET_DBG("IPv4 packet size %d pkt len %d", pkt_len, real_len); goto drop; } #if defined(CONFIG_NET_DEBUG_IPV4) do { char out[sizeof("xxx.xxx.xxx.xxx")]; snprintk(out, sizeof(out), "%s", net_sprint_ipv4_addr(&hdr->dst)); NET_DBG("IPv4 packet received from %s to %s", net_sprint_ipv4_addr(&hdr->src), out); } while (0); #endif /* CONFIG_NET_DEBUG_IPV4 */ net_pkt_set_ip_hdr_len(pkt, sizeof(struct net_ipv4_hdr)); if (!net_is_my_ipv4_addr(&hdr->dst)) { #if defined(CONFIG_NET_DHCPV4) if (hdr->proto == IPPROTO_UDP && net_ipv4_addr_cmp(&hdr->dst, net_ipv4_broadcast_address())) { verdict = net_conn_input(IPPROTO_UDP, pkt); if (verdict != NET_DROP) { return verdict; } } #endif NET_DBG("IPv4 packet in pkt %p not for me", pkt); goto drop; } switch (hdr->proto) { case IPPROTO_ICMP: verdict = process_icmpv4_pkt(pkt, hdr); break; case IPPROTO_UDP: verdict = net_conn_input(IPPROTO_UDP, pkt); break; case IPPROTO_TCP: verdict = net_conn_input(IPPROTO_TCP, pkt); break; } if (verdict != NET_DROP) { return verdict; } drop: net_stats_update_ipv4_drop(); return NET_DROP; }
static int tester_send(struct net_if *iface, struct net_pkt *pkt) { struct net_eth_hdr *hdr; if (!pkt->frags) { printk("No data to send!\n"); return -ENODATA; } if (net_pkt_ll_reserve(pkt) != sizeof(struct net_eth_hdr)) { printk("No ethernet header in pkt %p", pkt); send_status = -EINVAL; return send_status; } hdr = (struct net_eth_hdr *)net_pkt_ll(pkt); if (ntohs(hdr->type) == NET_ETH_PTYPE_ARP) { struct net_arp_hdr *arp_hdr = NET_ARP_HDR(pkt); if (ntohs(arp_hdr->opcode) == NET_ARP_REPLY) { if (!req_test && pkt != pending_pkt) { printk("Pending data but to be sent is wrong, " "expecting %p but got %p\n", pending_pkt, pkt); return -EINVAL; } if (!req_test && memcmp(&hdr->dst, &hwaddr, sizeof(struct net_eth_addr))) { char out[sizeof("xx:xx:xx:xx:xx:xx")]; snprintk(out, sizeof(out), "%s", net_sprint_ll_addr( (u8_t *)&hdr->dst, sizeof(struct net_eth_addr))); printk("Invalid hwaddr %s, should be %s\n", out, net_sprint_ll_addr( (u8_t *)&hwaddr, sizeof(struct net_eth_addr))); send_status = -EINVAL; return send_status; } } else if (ntohs(arp_hdr->opcode) == NET_ARP_REQUEST) { if (memcmp(&hdr->src, &hwaddr, sizeof(struct net_eth_addr))) { char out[sizeof("xx:xx:xx:xx:xx:xx")]; snprintk(out, sizeof(out), "%s", net_sprint_ll_addr( (u8_t *)&hdr->src, sizeof(struct net_eth_addr))); printk("Invalid hwaddr %s, should be %s\n", out, net_sprint_ll_addr( (u8_t *)&hwaddr, sizeof(struct net_eth_addr))); send_status = -EINVAL; return send_status; } } } printk("Data was sent successfully\n"); net_pkt_unref(pkt); send_status = 0; return 0; }
static bool run_tests(void) { struct net_pkt *pkt, *pkt2; struct net_buf *frag; struct net_if *iface; struct net_if_addr *ifaddr; struct net_arp_hdr *arp_hdr; struct net_ipv4_hdr *ipv4; struct net_eth_hdr *eth_hdr; int len; struct in_addr dst = { { { 192, 168, 0, 2 } } }; struct in_addr dst_far = { { { 10, 11, 12, 13 } } }; struct in_addr dst_far2 = { { { 172, 16, 14, 186 } } }; struct in_addr src = { { { 192, 168, 0, 1 } } }; struct in_addr netmask = { { { 255, 255, 255, 0 } } }; struct in_addr gw = { { { 192, 168, 0, 42 } } }; net_arp_init(); iface = net_if_get_default(); net_if_ipv4_set_gw(iface, &gw); net_if_ipv4_set_netmask(iface, &netmask); /* Unicast test */ ifaddr = net_if_ipv4_addr_add(iface, &src, NET_ADDR_MANUAL, 0); ifaddr->addr_state = NET_ADDR_PREFERRED; /* Application data for testing */ pkt = net_pkt_get_reserve_tx(sizeof(struct net_eth_hdr), K_FOREVER); if (!pkt) { printk("Out of mem TX\n"); return false; } frag = net_pkt_get_frag(pkt, K_FOREVER); if (!frag) { printk("Out of mem DATA\n"); return false; } net_pkt_frag_add(pkt, frag); net_pkt_set_iface(pkt, iface); setup_eth_header(iface, pkt, &hwaddr, NET_ETH_PTYPE_IP); len = strlen(app_data); if (net_pkt_ll_reserve(pkt) != sizeof(struct net_eth_hdr)) { printk("LL reserve invalid, should be %zd was %d\n", sizeof(struct net_eth_hdr), net_pkt_ll_reserve(pkt)); return false; } ipv4 = (struct net_ipv4_hdr *)net_buf_add(frag, sizeof(struct net_ipv4_hdr)); net_ipaddr_copy(&ipv4->src, &src); net_ipaddr_copy(&ipv4->dst, &dst); memcpy(net_buf_add(frag, len), app_data, len); pkt2 = net_arp_prepare(pkt); /* pkt2 is the ARP packet and pkt is the IPv4 packet and it was * stored in ARP table. */ if (pkt2 == pkt) { /* The packets cannot be the same as the ARP cache has * still room for the pkt. */ printk("ARP cache should still have free space\n"); return false; } if (!pkt2) { printk("ARP pkt is empty\n"); return false; } /* The ARP cache should now have a link to pending net_pkt * that is to be sent after we have got an ARP reply. */ if (!pkt->frags) { printk("Pending pkt fragment is NULL\n"); return false; } pending_pkt = pkt; /* pkt2 should contain the arp header, verify it */ if (memcmp(net_pkt_ll(pkt2), net_eth_broadcast_addr(), sizeof(struct net_eth_addr))) { printk("ARP ETH dest address invalid\n"); net_hexdump("ETH dest wrong ", net_pkt_ll(pkt2), sizeof(struct net_eth_addr)); net_hexdump("ETH dest correct", (u8_t *)net_eth_broadcast_addr(), sizeof(struct net_eth_addr)); return false; } if (memcmp(net_pkt_ll(pkt2) + sizeof(struct net_eth_addr), iface->link_addr.addr, sizeof(struct net_eth_addr))) { printk("ARP ETH source address invalid\n"); net_hexdump("ETH src correct", iface->link_addr.addr, sizeof(struct net_eth_addr)); net_hexdump("ETH src wrong ", net_pkt_ll(pkt2) + sizeof(struct net_eth_addr), sizeof(struct net_eth_addr)); return false; } arp_hdr = NET_ARP_HDR(pkt2); eth_hdr = NET_ETH_HDR(pkt2); if (eth_hdr->type != htons(NET_ETH_PTYPE_ARP)) { printk("ETH type 0x%x, should be 0x%x\n", eth_hdr->type, htons(NET_ETH_PTYPE_ARP)); return false; } if (arp_hdr->hwtype != htons(NET_ARP_HTYPE_ETH)) { printk("ARP hwtype 0x%x, should be 0x%x\n", arp_hdr->hwtype, htons(NET_ARP_HTYPE_ETH)); return false; } if (arp_hdr->protocol != htons(NET_ETH_PTYPE_IP)) { printk("ARP protocol 0x%x, should be 0x%x\n", arp_hdr->protocol, htons(NET_ETH_PTYPE_IP)); return false; } if (arp_hdr->hwlen != sizeof(struct net_eth_addr)) { printk("ARP hwlen 0x%x, should be 0x%zx\n", arp_hdr->hwlen, sizeof(struct net_eth_addr)); return false; } if (arp_hdr->protolen != sizeof(struct in_addr)) { printk("ARP IP addr len 0x%x, should be 0x%zx\n", arp_hdr->protolen, sizeof(struct in_addr)); return false; } if (arp_hdr->opcode != htons(NET_ARP_REQUEST)) { printk("ARP opcode 0x%x, should be 0x%x\n", arp_hdr->opcode, htons(NET_ARP_REQUEST)); return false; } if (!net_ipv4_addr_cmp(&arp_hdr->dst_ipaddr, &NET_IPV4_HDR(pkt)->dst)) { char out[sizeof("xxx.xxx.xxx.xxx")]; snprintk(out, sizeof(out), "%s", net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr)); printk("ARP IP dest invalid %s, should be %s", out, net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)); return false; } if (!net_ipv4_addr_cmp(&arp_hdr->src_ipaddr, &NET_IPV4_HDR(pkt)->src)) { char out[sizeof("xxx.xxx.xxx.xxx")]; snprintk(out, sizeof(out), "%s", net_sprint_ipv4_addr(&arp_hdr->src_ipaddr)); printk("ARP IP src invalid %s, should be %s", out, net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)); return false; } /* We could have send the new ARP request but for this test we * just free it. */ net_pkt_unref(pkt2); if (pkt->ref != 2) { printk("ARP cache should own the original packet\n"); return false; } /* Then a case where target is not in the same subnet */ net_ipaddr_copy(&ipv4->dst, &dst_far); pkt2 = net_arp_prepare(pkt); if (pkt2 == pkt) { printk("ARP cache should not find anything\n"); return false; } if (!pkt2) { printk("ARP pkt2 is empty\n"); return false; } arp_hdr = NET_ARP_HDR(pkt2); if (!net_ipv4_addr_cmp(&arp_hdr->dst_ipaddr, &iface->ipv4.gw)) { char out[sizeof("xxx.xxx.xxx.xxx")]; snprintk(out, sizeof(out), "%s", net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr)); printk("ARP IP dst invalid %s, should be %s\n", out, net_sprint_ipv4_addr(&iface->ipv4.gw)); return false; } net_pkt_unref(pkt2); /* Try to find the same destination again, this should fail as there * is a pending request in ARP cache. */ net_ipaddr_copy(&ipv4->dst, &dst_far); /* Make sure prepare will not free the pkt because it will be * needed in the later test case. */ net_pkt_ref(pkt); pkt2 = net_arp_prepare(pkt); if (!pkt2) { printk("ARP cache is not sending the request again\n"); return false; } net_pkt_unref(pkt2); /* Try to find the different destination, this should fail too * as the cache table should be full. */ net_ipaddr_copy(&ipv4->dst, &dst_far2); /* Make sure prepare will not free the pkt because it will be * needed in the next test case. */ net_pkt_ref(pkt); pkt2 = net_arp_prepare(pkt); if (!pkt2) { printk("ARP cache did not send a req\n"); return false; } /* Restore the original address so that following test case can * work properly. */ net_ipaddr_copy(&ipv4->dst, &dst); /* The arp request packet is now verified, create an arp reply. * The previous value of pkt is stored in arp table and is not lost. */ pkt = net_pkt_get_reserve_rx(sizeof(struct net_eth_hdr), K_FOREVER); if (!pkt) { printk("Out of mem RX reply\n"); return false; } printk("%d pkt %p\n", __LINE__, pkt); frag = net_pkt_get_frag(pkt, K_FOREVER); if (!frag) { printk("Out of mem DATA reply\n"); return false; } printk("%d frag %p\n", __LINE__, frag); net_pkt_frag_add(pkt, frag); net_pkt_set_iface(pkt, iface); arp_hdr = NET_ARP_HDR(pkt); net_buf_add(frag, sizeof(struct net_arp_hdr)); net_ipaddr_copy(&arp_hdr->dst_ipaddr, &dst); net_ipaddr_copy(&arp_hdr->src_ipaddr, &src); pkt2 = prepare_arp_reply(iface, pkt, &hwaddr); if (!pkt2) { printk("ARP reply generation failed."); return false; } /* The pending packet should now be sent */ switch (net_arp_input(pkt2)) { case NET_OK: case NET_CONTINUE: break; case NET_DROP: break; } /* Yielding so that network interface TX thread can proceed. */ k_yield(); if (send_status < 0) { printk("ARP reply was not sent\n"); return false; } if (pkt->ref != 1) { printk("ARP cache should no longer own the original packet\n"); return false; } net_pkt_unref(pkt); /* Then feed in ARP request */ pkt = net_pkt_get_reserve_rx(sizeof(struct net_eth_hdr), K_FOREVER); if (!pkt) { printk("Out of mem RX request\n"); return false; } frag = net_pkt_get_frag(pkt, K_FOREVER); if (!frag) { printk("Out of mem DATA request\n"); return false; } net_pkt_frag_add(pkt, frag); net_pkt_set_iface(pkt, iface); send_status = -EINVAL; arp_hdr = NET_ARP_HDR(pkt); net_buf_add(frag, sizeof(struct net_arp_hdr)); net_ipaddr_copy(&arp_hdr->dst_ipaddr, &src); net_ipaddr_copy(&arp_hdr->src_ipaddr, &dst); setup_eth_header(iface, pkt, &hwaddr, NET_ETH_PTYPE_ARP); pkt2 = prepare_arp_request(iface, pkt, &hwaddr); if (!pkt2) { printk("ARP request generation failed."); return false; } req_test = true; switch (net_arp_input(pkt2)) { case NET_OK: case NET_CONTINUE: break; case NET_DROP: break; } /* Yielding so that network interface TX thread can proceed. */ k_yield(); if (send_status < 0) { printk("ARP req was not sent\n"); return false; } net_pkt_unref(pkt); printk("Network ARP checks passed\n"); return true; }
int http_request(struct http_client_ctx *ctx, struct http_client_request *req, s32_t timeout) { const char *method = http_method_str(req->method); struct net_pkt *pkt; int ret = -ENOMEM; pkt = net_pkt_get_tx(ctx->tcp.ctx, timeout); if (!pkt) { return -ENOMEM; } if (!net_pkt_append_all(pkt, strlen(method), (u8_t *)method, timeout)) { goto out; } /* Space after method string. */ if (!net_pkt_append_all(pkt, 1, (u8_t *)" ", timeout)) { goto out; } if (!net_pkt_append_all(pkt, strlen(req->url), (u8_t *)req->url, timeout)) { goto out; } if (!net_pkt_append_all(pkt, strlen(req->protocol), (u8_t *)req->protocol, timeout)) { goto out; } if (req->host) { if (!net_pkt_append_all(pkt, strlen(HTTP_HOST), (u8_t *)HTTP_HOST, timeout)) { goto out; } if (!net_pkt_append_all(pkt, strlen(req->host), (u8_t *)req->host, timeout)) { goto out; } if (!net_pkt_append_all(pkt, strlen(HTTP_CRLF), (u8_t *)HTTP_CRLF, timeout)) { goto out; } } if (req->header_fields) { if (!net_pkt_append_all(pkt, strlen(req->header_fields), (u8_t *)req->header_fields, timeout)) { goto out; } } if (req->content_type_value) { if (!net_pkt_append_all(pkt, strlen(HTTP_CONTENT_TYPE), (u8_t *)HTTP_CONTENT_TYPE, timeout)) { goto out; } if (!net_pkt_append_all(pkt, strlen(req->content_type_value), (u8_t *)req->content_type_value, timeout)) { goto out; } } if (req->payload && req->payload_size) { char content_len_str[HTTP_CONT_LEN_SIZE]; ret = snprintk(content_len_str, HTTP_CONT_LEN_SIZE, HTTP_CRLF "Content-Length: %u" HTTP_CRLF HTTP_CRLF, req->payload_size); if (ret <= 0 || ret >= HTTP_CONT_LEN_SIZE) { ret = -ENOMEM; goto out; } if (!net_pkt_append_all(pkt, ret, (u8_t *)content_len_str, timeout)) { ret = -ENOMEM; goto out; } if (!net_pkt_append_all(pkt, req->payload_size, (u8_t *)req->payload, timeout)) { ret = -ENOMEM; goto out; } } else { if (!net_pkt_append_all(pkt, strlen(HTTP_EOF), (u8_t *)HTTP_EOF, timeout)) { goto out; } } #if defined(CONFIG_NET_IPV6) if (net_pkt_family(pkt) == AF_INET6) { net_pkt_set_appdatalen(pkt, net_pkt_get_len(pkt) - net_pkt_ip_hdr_len(pkt) - net_pkt_ipv6_ext_opt_len(pkt)); } else #endif { net_pkt_set_appdatalen(pkt, net_pkt_get_len(pkt) - net_pkt_ip_hdr_len(pkt)); } ret = ctx->tcp.send_data(pkt, NULL, timeout, NULL, ctx); if (ret == 0) { return 0; } out: net_pkt_unref(pkt); return ret; }
static int piggyback_get(struct zoap_resource *resource, struct zoap_packet *request, const struct sockaddr *from) { struct net_pkt *pkt; struct net_buf *frag; struct zoap_packet response; u8_t *payload, code, type; u16_t len, id; int r; code = zoap_header_get_code(request); type = zoap_header_get_type(request); id = zoap_header_get_id(request); printk("*******\n"); printk("type: %u code %u id %u\n", type, code, id); printk("*******\n"); pkt = net_pkt_get_reserve(&zoap_pkt_slab, 0, K_NO_WAIT); if (!pkt) { return -ENOMEM; } frag = net_buf_alloc(&zoap_data_pool, K_NO_WAIT); if (!frag) { return -ENOMEM; } net_pkt_frag_add(pkt, frag); r = zoap_packet_init(&response, pkt); if (r < 0) { return -EINVAL; } zoap_header_set_version(&response, 1); zoap_header_set_type(&response, ZOAP_TYPE_ACK); zoap_header_set_code(&response, ZOAP_RESPONSE_CODE_CONTENT); zoap_header_set_id(&response, id); payload = zoap_packet_get_payload(&response, &len); if (!payload) { return -EINVAL; } /* The response that coap-client expects */ r = snprintk((char *)payload, len, "Type: %u\nCode: %u\nMID: %u\n", type, code, id); if (r < 0 || r > len) { return -EINVAL; } r = zoap_packet_set_used(&response, r); if (r) { return -EINVAL; } do { r = mbedtls_ssl_write(curr_ctx, frag->data, frag->len); } while (r == MBEDTLS_ERR_SSL_WANT_READ || r == MBEDTLS_ERR_SSL_WANT_WRITE); if (r >= 0) { r = 0; } net_pkt_unref(pkt); return r; }
/* Format trace of user ta. Inline with kernel ta */ void trace_printf(const char *function, int line, int level, bool level_ok, const char *fmt, ...) { va_list ap; char buf[MAX_PRINT_SIZE]; size_t boffs = 0; int res; int thread_id; if (level_ok && level > trace_level) return; /* Print the type of message */ res = snprintk(buf, sizeof(buf), "%c/", trace_level_to_string(level, level_ok)); if (res < 0) return; boffs += res; /* Print the location, i.e., TEE core or TA */ res = snprintk(buf + boffs, sizeof(buf) - boffs, "%s:", trace_ext_prefix); if (res < 0) return; boffs += res; /* Print the Thread ID */ if (level_ok && !(BIT(level) & CFG_MSG_LONG_PREFIX_MASK)) thread_id = -1; else thread_id = trace_ext_get_thread_id(); res = print_thread_id(buf + boffs, sizeof(buf) - boffs, thread_id); if (res < 0) return; boffs += res; /* Print the function and line */ if (level_ok && !(BIT(level) & CFG_MSG_LONG_PREFIX_MASK)) function = NULL; if (function) { res = snprintk(buf + boffs, sizeof(buf) - boffs, "%s:%d ", function, line); if (res < 0) return; boffs += res; } va_start(ap, fmt); res = vsnprintk(buf + boffs, sizeof(buf) - boffs, fmt, ap); va_end(ap); if (res > 0) boffs += res; if (boffs >= (sizeof(buf) - 1)) boffs = sizeof(buf) - 2; buf[boffs] = '\n'; while (boffs && buf[boffs] == '\n') boffs--; boffs++; buf[boffs + 1] = '\0'; trace_ext_puts(buf); }
static int query_get(struct zoap_resource *resource, struct zoap_packet *request, const struct sockaddr *from) { struct zoap_option options[4]; struct net_pkt *pkt; struct net_buf *frag; struct zoap_packet response; u8_t *payload, code, type; u16_t len, id; int i, r; code = zoap_header_get_code(request); type = zoap_header_get_type(request); id = zoap_header_get_id(request); r = zoap_find_options(request, ZOAP_OPTION_URI_QUERY, options, 4); if (r <= 0) { return -EINVAL; } printk("*******\n"); printk("type: %u code %u id %u\n", type, code, id); printk("num queries: %d\n", r); for (i = 0; i < r; i++) { char str[16]; if (options[i].len + 1 > sizeof(str)) { printk("Unexpected length of query: " "%d (expected %zu)\n", options[i].len, sizeof(str)); break; } memcpy(str, options[i].value, options[i].len); str[options[i].len] = '\0'; printk("query[%d]: %s\n", i + 1, str); } printk("*******\n"); pkt = net_pkt_get_reserve(&zoap_pkt_slab, 0, K_NO_WAIT); if (!pkt) { return -ENOMEM; } frag = net_buf_alloc(&zoap_data_pool, K_NO_WAIT); if (!frag) { return -ENOMEM; } net_pkt_frag_add(pkt, frag); r = zoap_packet_init(&response, pkt); if (r < 0) { return -EINVAL; } /* FIXME: Could be that zoap_packet_init() sets some defaults */ zoap_header_set_version(&response, 1); zoap_header_set_type(&response, ZOAP_TYPE_ACK); zoap_header_set_code(&response, ZOAP_RESPONSE_CODE_CONTENT); zoap_header_set_id(&response, id); payload = zoap_packet_get_payload(&response, &len); if (!payload) { return -EINVAL; } /* The response that coap-client expects */ r = snprintk((char *)payload, len, "Type: %u\nCode: %u\nMID: %u\n", type, code, id); if (r < 0 || r > len) { return -EINVAL; } r = zoap_packet_set_used(&response, r); if (r) { return -EINVAL; } do { r = mbedtls_ssl_write(curr_ctx, frag->data, frag->len); } while (r == MBEDTLS_ERR_SSL_WANT_READ || r == MBEDTLS_ERR_SSL_WANT_WRITE); if (r >= 0) { r = 0; } net_pkt_unref(pkt); return r; }