/*---------------------------------------------------------------------------*/
static int prepare_and_send_buf(coap_context_t *ctx, session_t *session,
uint8_t *data, size_t len)
{
struct net_buf *buf;
int max_data_len;
/* This net_buf gets sent to network, so it is not released
* by this function unless there was an error and buf was
* not actually sent.
*/
buf = ip_buf_get_tx(ctx->net_ctx);
if (!buf) {
len = -ENOBUFS;
goto out;
}
max_data_len = IP_BUF_MAX_DATA - UIP_IPUDPH_LEN;
PRINTF("%s: reply to peer data %p len %d\n", __FUNCTION__, data, len);
if (len > max_data_len) {
PRINTF("%s: too much (%d bytes) data to send (max %d bytes)\n",
__FUNCTION__, len, max_data_len);
ip_buf_unref(buf);
len = -EINVAL;
goto out;
}
/* Note that we have reversed the addresses here
* because net_reply() will reverse them again.
*/
#ifdef CONFIG_NETWORKING_WITH_IPV6
uip_ip6addr_copy(&NET_BUF_IP(buf)->destipaddr, (uip_ip6addr_t *)&ctx->my_addr.in6_addr);
uip_ip6addr_copy(&NET_BUF_IP(buf)->srcipaddr,
(uip_ip6addr_t *)&session->addr.ipaddr);
#else
uip_ip4addr_copy(&NET_BUF_IP(buf)->destipaddr,
(uip_ip4addr_t *)&ctx->my_addr.in_addr);
uip_ip4addr_copy(&NET_BUF_IP(buf)->srcipaddr,
(uip_ip4addr_t *)&session->addr.ipaddr);
#endif
NET_BUF_UDP(buf)->destport = uip_ntohs(ctx->my_port);
NET_BUF_UDP(buf)->srcport = session->addr.port;
uip_set_udp_conn(buf) = net_context_get_udp_connection(ctx->net_ctx);
memcpy(net_buf_add(buf, len), data, len);
ip_buf_appdatalen(buf) = len;
ip_buf_appdata(buf) = buf->data + ip_buf_reserve(buf);
if (net_reply(ctx->net_ctx, buf)) {
ip_buf_unref(buf);
}
out:
return len;
}
int ip_from_string (const char *name, const char *uri, const char *s)
{
/* Returns 1 if successful, only copy valid address */
if (uiplib_ip6addrconv (s, &tmp_addr)) {
uip_ip6addr_copy (&server_ipaddr, &tmp_addr);
return 0;
}
return -1;
}
/*---------------------------------------------------------------------------*/
struct ip64_addrmap_entry *
ip64_addrmap_create(const uip_ip6addr_t *ip6addr,
uint16_t ip6port,
const uip_ip4addr_t *ip4addr,
uint16_t ip4port,
uint8_t protocol)
{
struct ip64_addrmap_entry *m;
check_age();
m = memb_alloc(&entrymemb);
if(m == NULL) {
/* We could not allocate an entry, try to recycle one and try to
allocate again. */
if(recycle()) {
m = memb_alloc(&entrymemb);
}
}
if(m != NULL) {
uip_ip4addr_copy(&m->ip4addr, ip4addr);
m->ip4port = ip4port;
uip_ip6addr_copy(&m->ip6addr, ip6addr);
m->ip6port = ip6port;
m->protocol = protocol;
m->flags = FLAGS_NONE;
m->ip6to4 = 1;
m->ip4to6 = 0;
timer_set(&m->timer, 0);
/* Pick a new, unused local port. First make sure that the
mapped_port number does not belong to any active connection. If
so, we keep increasing the mapped_port until we're free. */
{
struct ip64_addrmap_entry *n;
n = list_head(entrylist);
while(n != NULL) {
if(n->mapped_port == mapped_port) {
increase_mapped_port();
n = list_head(entrylist);
} else {
n = list_item_next(m);
}
}
}
m->mapped_port = mapped_port;
increase_mapped_port();
list_add(entrylist, m);
return m;
}
return NULL;
}
/*---------------------------------------------------------------------------*/
static int
start_request(struct http_socket *s)
{
uip_ip4addr_t ip4addr;
uip_ip6addr_t ip6addr;
uip_ip6addr_t *addr;
char host[MAX_HOSTLEN];
char path[MAX_PATHLEN];
uint16_t port;
int ret;
if(parse_url(s->url, host, &port, path)) {
printf("url %s host %s port %d path %s\n",
s->url, host, port, path);
/* Check if we are to route the request through a proxy. */
if(s->proxy_port != 0) {
/* The proxy address should be an IPv6 address. */
uip_ip6addr_copy(&ip6addr, &s->proxy_addr);
port = s->proxy_port;
} else if(uiplib_ip6addrconv(host, &ip6addr) == 0) {
/* First check if the host is an IP address. */
if(uiplib_ip4addrconv(host, &ip4addr) != 0) {
ip64_addr_4to6(&ip4addr, &ip6addr);
} else {
/* Try to lookup the hostname. If it fails, we initiate a hostname
lookup. */
ret = resolv_lookup(host, &addr);
if(ret == RESOLV_STATUS_UNCACHED ||
ret == RESOLV_STATUS_EXPIRED) {
resolv_query(host);
puts("Resolving host...");
return HTTP_SOCKET_OK;
}
if(addr != NULL) {
s->did_tcp_connect = 1;
tcp_socket_connect(&s->s, addr, port);
return HTTP_SOCKET_OK;
} else {
return HTTP_SOCKET_ERR;
}
}
}
tcp_socket_connect(&s->s, &ip6addr, port);
return HTTP_SOCKET_OK;
} else {
return HTTP_SOCKET_ERR;
}
}
void uip_neighbor_add(struct uip_stack *ustack,
struct in6_addr *addr6, struct uip_eth_addr *addr)
{
int i, oldest;
u8_t oldest_time;
char buf[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, addr6, buf, sizeof(buf));
pthread_mutex_lock(&ustack->lock);
/* Find the first unused entry or the oldest used entry. */
oldest_time = 0;
oldest = 0;
for (i = 0; i < UIP_NEIGHBOR_ENTRIES; ++i) {
if (ustack->neighbor_entries[i].time == MAX_TIME) {
oldest = i;
break;
}
if (uip_ip6addr_cmp
(ustack->neighbor_entries[i].ipaddr.s6_addr, addr6)) {
oldest = i;
break;
}
if (ustack->neighbor_entries[i].time > oldest_time) {
oldest = i;
oldest_time = ustack->neighbor_entries[i].time;
}
}
/* Use the oldest or first free entry (either pointed to by the
"oldest" variable). */
ustack->neighbor_entries[oldest].time = 0;
uip_ip6addr_copy(ustack->neighbor_entries[oldest].ipaddr.s6_addr,
addr6);
memcpy(&ustack->neighbor_entries[oldest].mac_addr, addr,
sizeof(struct uip_eth_addr));
LOG_DEBUG("Adding neighbor %s with "
"mac address %02x:%02x:%02x:%02x:%02x:%02x at %d",
buf, addr->addr[0], addr->addr[1], addr->addr[2],
addr->addr[3], addr->addr[4], addr->addr[5], oldest);
pthread_mutex_unlock(&ustack->lock);
}