コード例 #1
0
ファイル: udp_address.cpp プロジェクト: jcfr/libzmq
int zmq::udp_address_t::resolve (const char *name_)
{
    //  Find the ':' at end that separates address from the port number.
    const char *delimiter = strrchr (name_, ':');
    if (!delimiter) {
        errno = EINVAL;
        return -1;
    }

    //  Separate the address/port.
    std::string addr_str (name_, delimiter - name_);
    std::string port_str (delimiter + 1);

    //  Remove square brackets around the address, if any, as used in IPv6
    if (addr_str.size () >= 2 && addr_str [0] == '[' &&
          addr_str [addr_str.size () - 1] == ']')
        addr_str = addr_str.substr (1, addr_str.size () - 2);

    //  Parse the port number (0 is not a valid port).
    uint16_t port = (uint16_t) atoi (port_str.c_str ());
    if (port == 0) {
        errno = EINVAL;
        return -1;
    }

    dest_address.sin_family = AF_INET;
    dest_address.sin_port = htons (port);
    dest_address.sin_addr.s_addr = inet_addr (addr_str.c_str ());

    if (dest_address.sin_addr.s_addr == INADDR_NONE) {
        errno = EINVAL;
        return -1;
    }

    // we will check only first byte of IP
    // and if it from 224 to 239, then it can
    // represent multicast IP.
    int i = dest_address.sin_addr.s_addr & 0xFF;
    if(i >=  224 && i <= 239) {
        multicast = dest_address.sin_addr;
        is_mutlicast = true;
    }
    else
        is_mutlicast = false;

    interface.s_addr = htons (INADDR_ANY);
    if (interface.s_addr == INADDR_NONE) {
        errno = EINVAL;
        return -1;
    }

    bind_address.sin_family = AF_INET;
    bind_address.sin_port = htons (port);
    bind_address.sin_addr.s_addr = htons (INADDR_ANY);

    address = name_;

    return 0;
}
コード例 #2
0
ファイル: misc.c プロジェクト: bgiori/incubator-mynewt-core
/**
 * Logs information about a connection to the console.
 */
void
print_conn_desc(const struct ble_gap_conn_desc *desc)
{
    BSNCENT_LOG(DEBUG, "handle=%d our_ota_addr_type=%d our_ota_addr=%s ",
                desc->conn_handle, desc->our_ota_addr.type,
                addr_str(desc->our_ota_addr.val));
    BSNCENT_LOG(DEBUG, "our_id_addr_type=%d our_id_addr=%s ",
                desc->our_id_addr.type, addr_str(desc->our_id_addr.val));
    BSNCENT_LOG(DEBUG, "peer_ota_addr_type=%d peer_ota_addr=%s ",
                desc->peer_ota_addr.type, addr_str(desc->peer_ota_addr.val));
    BSNCENT_LOG(DEBUG, "peer_id_addr_type=%d peer_id_addr=%s ",
                desc->peer_id_addr.type, addr_str(desc->peer_id_addr.val));
    BSNCENT_LOG(DEBUG, "conn_itvl=%d conn_latency=%d supervision_timeout=%d "
                "encrypted=%d authenticated=%d bonded=%d",
                desc->conn_itvl, desc->conn_latency,
                desc->supervision_timeout,
                desc->sec_state.encrypted,
                desc->sec_state.authenticated,
                desc->sec_state.bonded);
}
コード例 #3
0
ファイル: tcp_address.cpp プロジェクト: Artesian/libzmq
int zmq::tcp_address_t::resolve (const char *name_, bool local_, bool ipv4only_)
{
    //  Find the ':' at end that separates address from the port number.
    const char *delimiter = strrchr (name_, ':');
    if (!delimiter) {
        errno = EINVAL;
        return -1;
    }

    //  Separate the address/port.
    std::string addr_str (name_, delimiter - name_);
    std::string port_str (delimiter + 1);

    //  Remove square brackets around the address, if any.
    if (addr_str.size () >= 2 && addr_str [0] == '[' &&
          addr_str [addr_str.size () - 1] == ']')
        addr_str = addr_str.substr (1, addr_str.size () - 2);

    uint16_t port;
    //  Allow 0 specifically, to detect invalid port error in atoi if not
    if (port_str == "*" || port_str == "0")
        //  Resolve wildcard to 0 to allow autoselection of port
        port = 0;
    else {
        //  Parse the port number (0 is not a valid port).
        port = (uint16_t) atoi (port_str.c_str ());
        if (port == 0) {
            errno = EINVAL;
            return -1;
        }
    }

    //  Resolve the IP address.
    int rc;
    if (local_)
        rc = resolve_interface (addr_str.c_str (), ipv4only_);
    else
        rc = resolve_hostname (addr_str.c_str (), ipv4only_);
    if (rc != 0)
        return -1;

    //  Set the port into the address structure.
    if (address.generic.sa_family == AF_INET6)
        address.ipv6.sin6_port = htons (port);
    else
        address.ipv4.sin_port = htons (port);

    return 0;
}
コード例 #4
0
ファイル: SCTP_SEQ.cpp プロジェクト: binary42/OCI
int
TAO_AV_SCTP_SEQ_Base_Acceptor::acceptor_open (TAO_AV_SCTP_SEQ_Acceptor *acceptor,
        ACE_Reactor *reactor,
        const ACE_INET_Addr &local_addr,
        TAO_FlowSpec_Entry *entry)
{
    ORBSVCS_DEBUG ((LM_DEBUG,
                    "In base acceptor open"));

    this->acceptor_ = acceptor;
    this->reactor_ = reactor;
    this->entry_ = entry;

    ACE_Auto_Array_Ptr<ACE_UINT32> local_ip_addr
    (new ACE_UINT32[entry->num_local_sec_addrs ()]);
    ACE_INET_Addr ip_addr;
    char** addrs = entry->get_local_sec_addr ();
    for (int i = 0; i < entry->num_local_sec_addrs (); i++)
    {
        ACE_CString addr_str (addrs[i]);
        addr_str += ":";
        ip_addr.set (addr_str.c_str ());
        local_ip_addr[i] = ip_addr.get_ip_address ();
    }


    ACE_Multihomed_INET_Addr multi_addr;
    multi_addr.set (local_addr.get_port_number (),
                    local_addr.get_ip_address (),
                    1,
                    local_ip_addr.get(),
                    entry->num_local_sec_addrs ());

    char buf[BUFSIZ];
    multi_addr.addr_to_string (buf, BUFSIZ);

    if (TAO_debug_level > 0)
        ORBSVCS_DEBUG ((LM_DEBUG,
                        "TAO_AV_SCTP_SEQ_Base_Acceptor::open: %s",
                        buf));

    if (this->open (multi_addr,reactor) < 0)
        ORBSVCS_ERROR_RETURN ((LM_ERROR,"TAO_AV_SCTP_SEQ_Base_Acceptor::open failed\n"),-1);

    return 0;
}
コード例 #5
0
ファイル: udp_engine.cpp プロジェクト: zhouxinlzu/libzmq
int zmq::udp_engine_t::resolve_raw_address (char *name_, size_t length_)
{
    memset (&raw_address, 0, sizeof raw_address);

    const char *delimiter = NULL;

    // Find delimiter, cannot use memrchr as it is not supported on windows
    if (length_ != 0) {
        int chars_left = (int) length_;
        char *current_char = name_ + length_;
        do {
            if (*(--current_char) == ':') {
                delimiter = current_char;
                break;
            }
        } while (--chars_left != 0);
    }

    if (!delimiter) {
        errno = EINVAL;
        return -1;
    }

    std::string addr_str (name_, delimiter - name_);
    std::string port_str (delimiter + 1, name_ + length_ - delimiter - 1);

    //  Parse the port number (0 is not a valid port).
    uint16_t port = (uint16_t) atoi (port_str.c_str ());
    if (port == 0) {
        errno = EINVAL;
        return -1;
    }

    raw_address.sin_family = AF_INET;
    raw_address.sin_port = htons (port);
    raw_address.sin_addr.s_addr = inet_addr (addr_str.c_str ());

    if (raw_address.sin_addr.s_addr == INADDR_NONE) {
        errno = EINVAL;
        return -1;
    }

    return 0;
}
コード例 #6
0
ファイル: SCTP_SEQ.cpp プロジェクト: binary42/OCI
int
TAO_AV_SCTP_SEQ_Connector::connect (TAO_FlowSpec_Entry *entry,
                                    TAO_AV_Transport *&transport,
                                    TAO_AV_Core::Flow_Component flow_comp)
{
    this->entry_ = entry;
    if (flow_comp == TAO_AV_Core::TAO_AV_CONTROL)
        this->flowname_ = TAO_AV_Core::get_control_flowname (entry->flowname ());
    else
        this->flowname_ = entry->flowname ();
    ACE_Addr *remote_addr = entry->address ();
    ACE_INET_Addr *inet_addr = dynamic_cast<ACE_INET_Addr *> (remote_addr);
    TAO_AV_SCTP_SEQ_Flow_Handler *handler = 0;

    ACE_Multihomed_INET_Addr remote_multi_addr;
    remote_multi_addr.set (inet_addr->get_port_number (),
                           inet_addr->get_ip_address (),
                           1,
                           0,
                           0);

    ACE_Multihomed_INET_Addr local_addr; //This can be a multihomed address
    ACE_INET_Addr *addr;
    if (entry->get_peer_addr () != 0)
    {
        addr = dynamic_cast<ACE_INET_Addr *> (entry->get_peer_addr ());
    }
    else
    {
        ACE_NEW_RETURN (addr,
                        ACE_INET_Addr ("0"),
                        -1);
    }

    ACE_Auto_Array_Ptr<ACE_UINT32> local_ip_addr
    (new ACE_UINT32[entry->num_peer_sec_addrs ()]);
    ACE_INET_Addr ip_addr;
    char** addrs = entry->get_peer_sec_addr ();
    for (int i = 0; i < entry->num_peer_sec_addrs (); i++)
    {
        ACE_CString addr_str (addrs[i]);
        addr_str += ":";
        ip_addr.set (addr_str.c_str ());
        local_ip_addr[i] = ip_addr.get_ip_address ();
    }

    if (entry->num_peer_sec_addrs () != 0)
        local_addr.set (addr->get_port_number (),
                        addr->get_ip_address (),
                        1,
                        local_ip_addr.get(),
                        entry->num_peer_sec_addrs ());
    else
        local_addr.set (addr->get_port_number (),
                        addr->get_ip_address (),
                        1,
                        0,
                        entry->num_peer_sec_addrs ());


    int result = this->connector_.connector_connect (handler,
                 remote_multi_addr,
                 local_addr);

    if (result < 0)
        ORBSVCS_ERROR_RETURN ((LM_ERROR,"TAO_AV_SCTP_SEQ_connector::connect failed\n"),-1);
    entry->handler (handler);
    transport = handler->transport ();

    if (TAO_debug_level > 0)
    {
        ORBSVCS_DEBUG ((LM_DEBUG,
                        "Local Addrs\n"));
        char buf [BUFSIZ];
        size_t size = BUFSIZ;
        ACE_INET_Addr *peer_addrs = 0;
        ACE_NEW_RETURN (peer_addrs,ACE_INET_Addr [size], -1);
        handler->peer ().get_local_addrs (peer_addrs, size);
        for (unsigned int i=0; i < size; i++)
        {
            peer_addrs [i].addr_to_string (buf,
                                           BUFSIZ);
            ORBSVCS_DEBUG ((LM_DEBUG,
                            "%s %d\n",
                            buf,
                            size));
        }

        ORBSVCS_DEBUG ((LM_DEBUG,
                        "Remote Addrs\n"));

        size = BUFSIZ;
        handler->peer ().get_remote_addrs (peer_addrs, size);
        for (unsigned int i=0; i < size; i++)
        {
            peer_addrs [i].addr_to_string (buf,
                                           BUFSIZ);
            ORBSVCS_DEBUG ((LM_DEBUG,
                            "%s %d\n",
                            buf,
                            size));
        }
        //delete peer_addrs;
    }

    return 0;
}
コード例 #7
0
ファイル: tcp_address.cpp プロジェクト: chsticksel/ocamlczmq
int zmq::tcp_address_t::resolve (const char *name_, bool local_, bool ipv6_, bool is_src_)
{
    if (!is_src_) {
        // Test the ';' to know if we have a source address in name_
        const char *src_delimiter = strrchr (name_, ';');
        if (src_delimiter) {
            std::string src_name (name_, src_delimiter - name_);
            const int rc = resolve (src_name.c_str (), local_, ipv6_, true);
            if (rc != 0)
                return -1;
            name_ = src_delimiter + 1;
            _has_src_addr = true;
        }
    }

    //  Find the ':' at end that separates address from the port number.
    const char *delimiter = strrchr (name_, ':');
    if (!delimiter) {
        errno = EINVAL;
        return -1;
    }

    //  Separate the address/port.
    std::string addr_str (name_, delimiter - name_);
    std::string port_str (delimiter + 1);

    //  Remove square brackets around the address, if any, as used in IPv6
    if (addr_str.size () >= 2 && addr_str [0] == '[' &&
          addr_str [addr_str.size () - 1] == ']')
        addr_str = addr_str.substr (1, addr_str.size () - 2);

    // Test the '%' to know if we have an interface name / zone_id in the address
    // Reference: https://tools.ietf.org/html/rfc4007
    std::size_t pos = addr_str.rfind("%");
    uint32_t zone_id = 0;
    if (pos != std::string::npos) {
        std::string if_str = addr_str.substr(pos + 1);
        addr_str = addr_str.substr(0, pos);
        if (isalpha (if_str.at (0)))
            zone_id = if_nametoindex(if_str.c_str());
        else
            zone_id = (uint32_t) atoi (if_str.c_str ());
        if (zone_id == 0) {
            errno = EINVAL;
            return -1;
        }
    }

    //  Allow 0 specifically, to detect invalid port error in atoi if not
    uint16_t port;
    if (port_str == "*" || port_str == "0")
        //  Resolve wildcard to 0 to allow autoselection of port
        port = 0;
    else {
        //  Parse the port number (0 is not a valid port).
        port = (uint16_t) atoi (port_str.c_str ());
        if (port == 0) {
            errno = EINVAL;
            return -1;
        }
    }

    //  Resolve the IP address.
    int rc;
    if (local_ || is_src_)
        rc = resolve_interface (addr_str.c_str (), ipv6_, is_src_);
    else
        rc = resolve_hostname (addr_str.c_str (), ipv6_, is_src_);
    if (rc != 0)
        return -1;

    //  Set the port into the address structure.
    if (is_src_) {
        if (source_address.generic.sa_family == AF_INET6) {
            source_address.ipv6.sin6_port = htons (port);
            source_address.ipv6.sin6_scope_id = zone_id;
        }
        else
            source_address.ipv4.sin_port = htons (port);
    }
    else {
        if (address.generic.sa_family == AF_INET6) {
            address.ipv6.sin6_port = htons (port);
            address.ipv6.sin6_scope_id = zone_id;
        }
        else
            address.ipv4.sin_port = htons (port);
    }

    return 0;
}
コード例 #8
0
ファイル: masala-web.c プロジェクト: houstar/masala
void* web_loop( void* _ ) {

	int rc;
	int val;
	struct addrinfo hints, *servinfo, *p;
	struct timeval tv;

	UCHAR id[SHA_DIGEST_LENGTH];
	char hexbuf[HEX_LEN+1];

	int sockfd, clientfd;
	IP sockaddr, clientaddr;
	char clientbuf[1500];
	struct request *request;
	char *hex_start, *hex_end;
	socklen_t addr_len = sizeof(IP);
	char addrbuf[FULL_ADDSTRLEN+1];

	const char *addr = _main->conf->web_addr;
	const char *ifce = _main->conf->web_ifce;
	const char *port = _main->conf->web_port;

	memset( &hints, 0, sizeof(hints) );
	hints.ai_flags = AI_PASSIVE;
	hints.ai_family = AF_INET6;
	hints.ai_socktype = SOCK_STREAM;

	if( (rc = getaddrinfo( addr, port, &hints, &servinfo ) ) == 0 ) {
		for( p = servinfo; p != NULL; p = p->ai_next ) {
			memset( &sockaddr, 0, sizeof(IP) );
			sockaddr = *((IP*) p->ai_addr);
			freeaddrinfo(servinfo);
			break;
		}
    } else {
		log_err( "Web: getaddrinfo failed: %s", gai_strerror( rc ) );
        return NULL;
	}

	if( (sockfd = socket( PF_INET6, SOCK_STREAM, IPPROTO_TCP )) < 0 ) {
		log_err( "Web: Failed to create socket: %s", strerror( errno ) );
		return NULL;
	}

	if( ifce && setsockopt( sockfd, SOL_SOCKET, SO_BINDTODEVICE, ifce, strlen( ifce )) ) {
		log_err( "Web: Unable to set interface '%s': %s", ifce, strerror( errno ) );
		return NULL;
	}

	val = 1;
	if( (rc = setsockopt( sockfd, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &val, sizeof(val) )) < 0 ) {
		log_err( "Web: Failed to set socket options: %s", strerror( errno ) );
		return NULL;
	}

	val = 1;
	setsockopt( sockfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val) );

	/* Set receive timeout */
	tv.tv_sec = 1;
	tv.tv_usec = 0;

	if( (rc = setsockopt( sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv) )) < 0 ) {
		log_err( "Web: Failed to set socket options: %s", strerror( errno ) );
		return NULL;
	}

	if( (rc = bind( sockfd, (struct sockaddr*) &sockaddr, sizeof(IP) )) < 0 ) {
		log_err( "Web: Failed to bind socket to address: %s", strerror( errno ) );
		return NULL;
	}

	listen( sockfd, ntohs( sockaddr.sin6_port ) );

	log_info( "Web: Bind socket to %s, interface %s.",
		addr ? addr_str( &sockaddr, addrbuf ) : "<any>",
		ifce ? ifce : "<any>"
	);

	clientfd = 0;
	while( _main->status == MAIN_ONLINE ) {

		/* Close file descriptor that has not been used previously */
		if( clientfd > 0 ) {
			close( clientfd );
		}

		clientfd = accept( sockfd, (struct sockaddr*)&clientaddr, &addr_len );
		rc = recv( clientfd, clientbuf, sizeof(clientbuf) - 1, 0 );

		if( rc < 0 ) {
			continue;
		}

		/* Only handle GET requests. */
		if( rc < 6 || strncmp( "GET /", clientbuf, 5 ) != 0 ) {
			continue;
		}

		/* Jump after slash */
		hex_start = clientbuf + 5;

		clientbuf[rc] = ' ';
		hex_end = strchr( hex_start, ' ' );
		if( hex_end == NULL ) {
			continue;
		}

		*hex_end = '\0';
		if( strlen( hex_start ) == 0 || strcmp( hex_start, "favicon.ico" ) == 0 ) {
			continue;
		}

		/* That is the lookup key */
		p2p_compute_id( id, hex_start );
		log_debug( "Web: Lookup '%s' as '%s'.", hex_start, id_str( id, hexbuf ) );

		request = (struct request *) myalloc( sizeof(struct request), "masalla-web" );
		memcpy( &request->clientaddr, &clientaddr, sizeof(IP) );
		request->clientfd = clientfd;

		web_lookup( &web_reply, request, id );

		/* File descriptor is closed in callback */
		clientfd = 0;
	}

	return NULL;
}
コード例 #9
0
ファイル: masala-nss.c プロジェクト: houstar/masala
/*
listen for local connection
*/
void* nss_loop( void* _ ) {

	ssize_t rc;
	struct addrinfo hints, *servinfo, *p;
	struct timeval tv;

	int sockfd;
	IP clientaddr, sockaddr;
	char hostname[256];
	UCHAR host_id[SHA_DIGEST_LENGTH];
	char addrbuf[FULL_ADDSTRLEN+1];
	socklen_t addr_len = sizeof(IP);

	memset( &hints, 0, sizeof(hints) );
	hints.ai_flags = AI_PASSIVE;
	hints.ai_family = AF_INET6;
	hints.ai_socktype = SOCK_DGRAM;

	if( (rc = getaddrinfo( "::1", NULL, &hints, &servinfo )) == 0 ) {
		for( p = servinfo; p != NULL; p = p->ai_next ) {
			memset( &sockaddr, 0, sizeof(IP) );
			sockaddr = *((IP*) p->ai_addr);
			sockaddr.sin6_port = htons( MASALA_NSS_PORT );
			freeaddrinfo( servinfo );
			break;
		}
    } else {
		log_err( "NSS: getaddrinfo failed: %s", gai_strerror( rc ) );
        return NULL;
	}

	sockfd = socket( PF_INET6, SOCK_DGRAM, IPPROTO_UDP );
	if( sockfd < 0 ) {
		log_err( "NSS: Failed to create socket: %s", strerror( errno ) );
		return NULL;
	}

	/* Set receive timeout */
	tv.tv_sec = 1;
	tv.tv_usec = 0;
	rc = setsockopt( sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv) );
	if( rc < 0 ) {
		log_err( "NSS: Failed to set socket option: %s", strerror( errno ) );
		return NULL;
	}

	rc = bind( sockfd, (struct sockaddr*) &sockaddr, sizeof(IP) );
	if( rc < 0 ) {
		log_err( "NSS: Failed to bind socket to address: %s", strerror( errno ) );
		return NULL;
	}

	log_info( "NSS: Bind socket to %s.",
		addr_str( &sockaddr, addrbuf )
	);

	while( _main->status == MAIN_ONLINE ) {

		rc = recvfrom( sockfd, hostname, sizeof( hostname ), 0, (struct sockaddr *) &clientaddr, &addr_len );

		if( rc <= 0 || rc >= sizeof( hostname ) ) {
			continue;
		}

		hostname[rc] = '\0';

		/* Validate hostname */
		if ( !str_isValidHostname( (char*) hostname, strlen( hostname ) ) ) {
			log_warn( "NSS: Invalid hostname for lookup: '%s'", hostname );
			continue;
		}

		/* That is the lookup key */
		p2p_compute_id( host_id, hostname );

		nss_lookup( sockfd, &clientaddr, host_id );
	}

	return NULL;
}
コード例 #10
0
ファイル: udp_address.cpp プロジェクト: AmesianX/libzmq
int zmq::udp_address_t::resolve (const char *name_, bool bind_)
{
    //  Find the ':' at end that separates address from the port number.
    const char *delimiter = strrchr (name_, ':');
    if (!delimiter) {
        errno = EINVAL;
        return -1;
    }

    //  Separate the address/port.
    std::string addr_str (name_, delimiter - name_);
    std::string port_str (delimiter + 1);

    //  Parse the port number (0 is not a valid port).
    uint16_t port = (uint16_t) atoi (port_str.c_str ());
    if (port == 0) {
        errno = EINVAL;
        return -1;
    }

    dest_address.sin_family = AF_INET;
    dest_address.sin_port = htons (port);

    //  Only when the udp should bind we allow * as the address
    if (addr_str == "*" && bind_)
        dest_address.sin_addr.s_addr = htonl (INADDR_ANY);
    else
        dest_address.sin_addr.s_addr = inet_addr (addr_str.c_str ());

    if (dest_address.sin_addr.s_addr == INADDR_NONE) {
        errno = EINVAL;
        return -1;
    }

    // we will check only first byte of IP
    // and if it from 224 to 239, then it can
    // represent multicast IP.
    int i = dest_address.sin_addr.s_addr & 0xFF;
    if(i >=  224 && i <= 239) {
        multicast = dest_address.sin_addr;
        is_multicast = true;
    }
    else
        is_multicast = false;

    iface.s_addr = htonl (INADDR_ANY);
    if (iface.s_addr == INADDR_NONE) {
        errno = EINVAL;
        return -1;
    }

    //  If a should bind and not a multicast, the dest address
    //  is actually the bind address
    if (bind_ && !is_multicast)
        bind_address = dest_address;
    else {
        bind_address.sin_family = AF_INET;
        bind_address.sin_port = htons (port);
        bind_address.sin_addr.s_addr = htonl (INADDR_ANY);
    }

    address = name_;

    return 0;
}
コード例 #11
0
ファイル: misc.c プロジェクト: bgiori/incubator-mynewt-core
void
print_adv_fields(const struct ble_hs_adv_fields *fields)
{
    char s[BLE_HS_ADV_MAX_SZ];
    const uint8_t *u8p;
    int i;

    if (fields->flags != 0) {
        BSNCENT_LOG(DEBUG, "    flags=0x%02x\n", fields->flags);
    }

    if (fields->uuids16 != NULL) {
        BSNCENT_LOG(DEBUG, "    uuids16(%scomplete)=",
                    fields->uuids16_is_complete ? "" : "in");
        for (i = 0; i < fields->num_uuids16; i++) {
            print_uuid(&fields->uuids16[i].u);
            BSNCENT_LOG(DEBUG, " ");
        }
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->uuids32 != NULL) {
        BSNCENT_LOG(DEBUG, "    uuids32(%scomplete)=",
                    fields->uuids32_is_complete ? "" : "in");
        for (i = 0; i < fields->num_uuids32; i++) {
            print_uuid(&fields->uuids32[i].u);
            BSNCENT_LOG(DEBUG, " ");
        }
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->uuids128 != NULL) {
        BSNCENT_LOG(DEBUG, "    uuids128(%scomplete)=",
                    fields->uuids128_is_complete ? "" : "in");
        for (i = 0; i < fields->num_uuids128; i++) {
            print_uuid(&fields->uuids128[i].u);
            BSNCENT_LOG(DEBUG, " ");
        }
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->name != NULL) {
        assert(fields->name_len < sizeof s - 1);
        memcpy(s, fields->name, fields->name_len);
        s[fields->name_len] = '\0';
        BSNCENT_LOG(DEBUG, "    name(%scomplete)=%s\n",
                    fields->name_is_complete ? "" : "in", s);
    }

    if (fields->tx_pwr_lvl_is_present) {
        BSNCENT_LOG(DEBUG, "    tx_pwr_lvl=%d\n", fields->tx_pwr_lvl);
    }

    if (fields->slave_itvl_range != NULL) {
        BSNCENT_LOG(DEBUG, "    slave_itvl_range=");
        print_bytes(fields->slave_itvl_range, BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN);
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->svc_data_uuid16 != NULL) {
        BSNCENT_LOG(DEBUG, "    svc_data_uuid16=");
        print_bytes(fields->svc_data_uuid16, fields->svc_data_uuid16_len);
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->public_tgt_addr != NULL) {
        BSNCENT_LOG(DEBUG, "    public_tgt_addr=");
        u8p = fields->public_tgt_addr;
        for (i = 0; i < fields->num_public_tgt_addrs; i++) {
            BSNCENT_LOG(DEBUG, "public_tgt_addr=%s ", addr_str(u8p));
            u8p += BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN;
        }
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->appearance_is_present) {
        BSNCENT_LOG(DEBUG, "    appearance=0x%04x\n", fields->appearance);
    }

    if (fields->adv_itvl_is_present) {
        BSNCENT_LOG(DEBUG, "    adv_itvl=0x%04x\n", fields->adv_itvl);
    }

    if (fields->svc_data_uuid32 != NULL) {
        BSNCENT_LOG(DEBUG, "    svc_data_uuid32=");
        print_bytes(fields->svc_data_uuid32, fields->svc_data_uuid32_len);
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->svc_data_uuid128 != NULL) {
        BSNCENT_LOG(DEBUG, "    svc_data_uuid128=");
        print_bytes(fields->svc_data_uuid128, fields->svc_data_uuid128_len);
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->uri != NULL) {
        BSNCENT_LOG(DEBUG, "    uri=");
        print_bytes(fields->uri, fields->uri_len);
        BSNCENT_LOG(DEBUG, "\n");
    }

    if (fields->mfg_data != NULL) {
        BSNCENT_LOG(DEBUG, "    mfg_data=");
        print_bytes(fields->mfg_data, fields->mfg_data_len);
        BSNCENT_LOG(DEBUG, "\n");
    }
}