/* * Connect to MQTT broker. * * N.B. Non-blocking call. */ mqtt_status_t mqtt_connect(struct mqtt_connection *conn, char *host, uint16_t port, uint16_t keep_alive) { uip_ip6addr_t ip6addr; uip_ipaddr_t *ipaddr; ipaddr = &ip6addr; /* Check if we are already trying to connect */ if(conn->state > MQTT_CONN_STATE_NOT_CONNECTED) { return MQTT_STATUS_OK; } conn->server_host = host; conn->keep_alive = keep_alive; conn->server_port = port; conn->out_buffer_ptr = conn->out_buffer; conn->out_packet.qos_state = MQTT_QOS_STATE_NO_ACK; conn->connect_vhdr_flags |= MQTT_VHDR_CLEAN_SESSION_FLAG; /* convert the string IPv6 address to a numeric IPv6 address */ uiplib_ip6addrconv(host, &ip6addr); uip_ipaddr_copy(&(conn->server_ip), ipaddr); /* * Initiate the connection if the IP could be resolved. Otherwise the * connection will be initiated when the DNS lookup is finished, in the main * event loop. */ process_post(&mqtt_process, mqtt_do_connect_tcp_event, conn); return MQTT_STATUS_OK; }
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; }
/** * Connect to MQTT broker. * * N.B. None-blocking call. */ mqtt_status_t mqtt_connect(struct mqtt_connection* conn, const char* host, uint16_t port, uint16_t keep_alive) { uip_ip6addr_t ip6addr; uip_ip4addr_t ip4addr; uip_ipaddr_t *ipaddr; ipaddr = &ip6addr; /* Sanity check */ assert(conn != NULL && host != NULL); /* Check if we are already trying to connect */ if(conn->state > MQTT_CONN_STATE_NOT_CONNECTED) { return MQTT_STATUS_OK; } conn->server_host = host; conn->keep_alive = keep_alive; conn->server_port = port; conn->out_buffer_ptr = conn->out_buffer; conn->out_packet.qos_state = MQTT_QOS_STATE_NO_ACK; /* First check if the host is an IP address. If not, try to look it up. */ if(uiplib_ip6addrconv(host, &ip6addr) == 0) { if(uiplib_ip4addrconv(host, &ip4addr) != 0) { ip64_addr_4to6(&ip4addr, &ip6addr); } else { #if UIP_UDP ipaddr = mdns_lookup(host); if(ipaddr == NULL) { printf("MQTT - Resolving host...\r\n"); mdns_query(host); conn->state = MQTT_CONN_STATE_DNS_LOOKUP; return MQTT_STATUS_OK; } #else /* UIP_UDP */ DBG("Error looking up hostname when mDNS is not used due to UIP_UDP = 0."); conn->state = MQTT_CONN_STATE_ERROR; return MQTT_STATUS_DNS_ERROR; #endif /* UIP_UDP */ } } uip_ipaddr_copy(&(conn->server_ip), ipaddr); /* Initiate the connection if the IP could be resolved. Otherwise the * connection will be initiated when the DNS lookup is finished, in the main * event loop. */ process_post(&mqtt_process, mqtt_do_connect_tcp_event, conn); return MQTT_STATUS_OK; }
/*---------------------------------------------------------------------------*/ 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; } }
SOL_API const struct sol_network_link_addr * sol_network_link_addr_from_str(struct sol_network_link_addr *addr, const char *buf) { SOL_NULL_CHECK(addr, NULL); SOL_NULL_CHECK(buf, NULL); if (sol_bluetooth_is_addr_str(buf)) return sol_bluetooth_addr_from_str(addr, buf); if (addr->family != SOL_NETWORK_FAMILY_INET6) return NULL; uiplib_ip6addrconv(buf, (uip_ip6addr_t *)&addr->addr.in6); return addr; }
/*-----------------------------------------------------------------------------------*/ unsigned char websocket_http_client_get(struct websocket_http_client_state *s, const char *host, uint16_t port, const char *file, const char *subprotocol) { struct uip_conn *conn; uip_ip6addr_t ip6addr; uip_ip4addr_t ip4addr; uip_ipaddr_t *ipaddr; ipaddr = &ip6addr; /* First check if the host is an IP address. */ if(uiplib_ip6addrconv(host, &ip6addr) == 0) { if(uiplib_ip4addrconv(host, &ip4addr) != 0) { ip64_addr_4to6(&ip4addr, &ip6addr); } else { #if UIP_UDP ipaddr = mdns_lookup(host); if(ipaddr == NULL) { return 0; } #else /* UIP_UDP */ return 0; #endif /* UIP_UDP */ } } conn = tcp_connect(ipaddr, uip_htons(port), NULL); if(conn == NULL) { return 0; } tcp_markconn(conn, s); s->conn = conn; s->port = port; strncpy(s->file, file, sizeof(s->file)); strncpy(s->host, host, sizeof(s->host)); strncpy(s->subprotocol, subprotocol, sizeof(s->subprotocol)); init_connection(s); return 1; }
/* * \brief Attempts to convert a string representation of an IPv6 address to a * numeric one. * \param buf The buffer with the string to be converted. * \return ADDRESS_CONVERSION_OK or ADDRESS_CONVERSION_ERROR * * ToDo: Add support for NAT64 conversion in case the incoming address is a v4 * This is now supported in the current master, so when we pull it in this will * be very straightforward. */ static int set_new_ip_address(char *buf) { /* * uiplib_ip6addrconv will immediately start writing into the supplied buffer * even if it subsequently fails. Thus, pass an intermediate buffer */ uip_ip6addr_t tmp_addr; int rv = uiplib_ip6addrconv(buf, &tmp_addr); if(rv == ADDRESS_CONVERSION_OK) { /* Conversion OK, copy to our main buffer */ memcpy(&remote_addr, &tmp_addr, sizeof(remote_addr)); PRINTF("Updated remote address "); PRINT6ADDR(&remote_addr); PRINTF("\n"); } return rv; }
/*---------------------------------------------------------------------------*/ 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; if(parse_url(s->url, host, &port, path)) { printf("url %s host %s port %d path %s\n\r", s->url, host, port, path); /* First check if the host is an IP address. */ if(uiplib_ip6addrconv(host, &ip6addr) == 0) { 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. */ addr = mdns_lookup(host); if(addr == NULL) { mdns_query(host); puts("Resolving host..."); return HTTP_SOCKET_OK; } tcp_socket_connect(&s->s, addr, port); return HTTP_SOCKET_OK; } } tcp_socket_connect(&s->s, &ip6addr, port); return HTTP_SOCKET_OK; } else { return HTTP_SOCKET_ERR; } }
/*---------------------------------------------------------------------------*/ static int start_request(struct http_socket *s) { uip_ip4addr_t ip4addr; uip_ip6addr_t ip6addr; uip_ipaddr_t *addr; char host[MAX_HOSTLEN]; char path[MAX_PATHLEN]; uint16_t port; if(parse_url(s->url, host, &port, path)) { PRINTF("%s url %s host %s port %d path %s\n", HTTP_METHOD_STR(s->method), s->url, host, port, path); /* First check if the host is an IP address. */ if(uiplib_ip6addrconv(host, &ip6addr) == 0) { 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. */ if(resolv_lookup(host, &addr) != RESOLV_STATUS_CACHED) { resolv_query(host); PRINTF("Resolving host...\n"); return HTTP_SOCKET_OK; } tcp_socket_connect(&s->s, addr, port); return HTTP_SOCKET_OK; } } tcp_socket_connect(&s->s, (uip_ipaddr_t *)&ip6addr, port); return HTTP_SOCKET_OK; } else { return HTTP_SOCKET_ERR; } }