Socket library functions

Collaboration diagram for Socket library functions:

Classes
struct	SocketOptions
class	Udp

Functions
int32_t	socket_open (socket_channel *channel, NetworkType ntype, const char *address, uint16_t port, uint16_t direction, bool blocking=true, uint32_t usectimeo=0, uint32_t rcvbuf=0, uint32_t sndbuf=0)
	Open UDP socket. More...
int32_t	socket_open (socket_channel &channel, NetworkType ntype, const char *address, uint16_t port, uint16_t direction, bool blocking=true, uint32_t usectimeo=0, uint32_t rcvbuf=0, uint32_t sndbuf=0)
int32_t	socket_accept (socket_channel server, socket_channel &client)
uint16_t	socket_calc_udp_checksum (vector< uint8_t > packet)
	Calculate UDP Checksum. More...
int32_t	socket_check_udp_checksum (vector< uint8_t > packet)
	Check UDP checksum. More...
int32_t	socket_set_udp_checksum (vector< uint8_t > &packet)
	Set UDP checksum. More...
int32_t	socket_blocking (socket_channel *channel, bool blocking)
int32_t	socket_blocking (socket_channel &channel, bool blocking)
int32_t	socket_close (socket_channel *channel)
	Close socket. More...
int32_t	socket_close (socket_channel &channel)
int32_t	socket_recvfrom (socket_channel &channel, vector< uint8_t > &buffer, size_t maxlen, int flags=0)
int32_t	socket_recvfrom (socket_channel &channel, string &buffer, size_t maxlen, int flags=0)
int32_t	socket_sendto (socket_channel &channel, const string buffer, int flags=0)
int32_t	socket_sendto (socket_channel &channel, const vector< uint8_t > buffer, int flags=0)
vector< socket_channel >	socket_find_addresses (NetworkType ntype)
	Discover interfaces. More...

Detailed Description

Function Documentation

int32_t socket_open	(	socket_channel *	channel,
		NetworkType	ntype,
		const char *	address,
		uint16_t	port,
		uint16_t	role,
		bool	blocking,
		uint32_t	usectimeo,
		uint32_t	rcvbuf,
		uint32_t	sndbuf
	)

Open UDP socket.

Open a UDP socket and configure it for the specified use. Various flags are set, and the socket is bound, if necessary. Support is provided for the extra steps necessary for MS Windows.

Parameters

channel	Pointer to socket_channel holding final configuration.
ntype	type of casting (NetworkType::BROADCAST, NetworkType::MULTICAST, NetworkType::TCP)
address	Destination address
port	Source port. If zero, automatically assigned.
role	Publish, subscribe, communicate.
blocking	True or false.
usectimeo	Blocking read timeout in micro seconds.
rcvbuf	Optional size of buffer for setsockopt SO_RCVBUF.
sndbuf	Optional size of buffer for setsockopt SO_SNDBUF.

Returns

Zero, or negative error.

{
    int32_t iretn;

    iretn = socket_open(*channel, ntype, address, port, role, blocking, usectimeo, rcvbuf, sndbuf);

    return iretn;
}

int32_t socket_open	(	socket_channel &	channel,
		NetworkType	ntype,
		const char *	address,
		uint16_t	port,
		uint16_t	direction,
		bool	blocking = true,
		uint32_t	usectimeo = 0,
		uint32_t	rcvbuf = 0,
		uint32_t	sndbuf = 0
	)

1. Join multicast

{
//    socklen_t namelen;
    int32_t iretn;
    struct ip_mreq mreq;
    int on = 1;

#ifdef COSMOS_WIN_OS
    unsigned long nonblocking = 1;
    WORD wVersionRequested;
    WSADATA wsaData;
    static bool started=false;

    if (!started)
    {
        wVersionRequested = MAKEWORD( 1, 1 );
        iretn = WSAStartup( wVersionRequested, &wsaData );
        if (iretn != 0)
        {
            return SOCKET_ERROR_OPEN;
        }
        started = true;
    }
#endif

    switch (ntype)
    {
    case NetworkType::MULTICAST:
        {
            if ((channel.cudp = socket(AF_INET,SOCK_DGRAM,IPPROTO_IP)) <0)
            {
                return (-errno);
            }
        }
        break;
    case NetworkType::BROADCAST:
    case NetworkType::UDP:
        {
            if ((channel.cudp = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) <0)
            {
                return (-errno);
            }
        }
        break;
    case NetworkType::TCP:
        {
            if ((channel.cudp = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)) <0)
            {
                return (-errno);
            }
        }
        break;
    default:
        return (SOCKET_ERROR_PROTOCOL);
        break;
    }

    if (blocking == SOCKET_NONBLOCKING)
    {
        iretn = 0;
#ifdef COSMOS_WIN_OS
        if (ioctlsocket(channel.cudp, FIONBIO, &nonblocking) != 0)
        {
            iretn = -WSAGetLastError();
        }
#else
        if (fcntl(channel.cudp, F_SETFL,O_NONBLOCK) < 0)
        {
            iretn = -errno;
        }
#endif
        if (iretn < 0)
        {
            CLOSE_SOCKET(channel.cudp);
            channel.cudp = iretn;
            return iretn;
        }
    }

    // this defines the wait time for a response from a request
    if (usectimeo)
    {
#ifdef COSMOS_WIN_OS
        int msectimeo = usectimeo/1000;
        iretn = setsockopt(channel.cudp,SOL_SOCKET,SO_RCVTIMEO,(const char *)&msectimeo,sizeof(msectimeo));
#else
        struct timeval tv;
        tv.tv_sec = usectimeo/1000000;
        tv.tv_usec = usectimeo%1000000;
        iretn = setsockopt(channel.cudp,SOL_SOCKET,SO_RCVTIMEO,(char*)&tv,sizeof(tv));
#endif
    }

    memset(&channel.caddr,0,sizeof(struct sockaddr_in));
    channel.caddr.sin_family = AF_INET;
    channel.caddr.sin_port = htons(port);

    switch (role)
    {
    case SOCKET_LISTEN:
#ifdef COSMOS_MAC_OS
        if (setsockopt(channel.cudp,SOL_SOCKET,SO_REUSEPORT,(char*)&on,sizeof(on)) < 0)
#else
        if (setsockopt(channel.cudp,SOL_SOCKET,SO_REUSEADDR,(char*)&on,sizeof(on)) < 0)
#endif
        {
            CLOSE_SOCKET(channel.cudp);
            channel.cudp = -errno;
            return (-errno);
        }

        switch (ntype)
        {
        case NetworkType::MULTICAST:
        case NetworkType::BROADCAST:
        case NetworkType::UDP:
            {
                channel.caddr.sin_addr.s_addr = htonl(INADDR_ANY);
                if (::bind(channel.cudp,(struct sockaddr *)&channel.caddr, sizeof(struct sockaddr_in)) < 0)
                {
                    CLOSE_SOCKET(channel.cudp);
                    channel.cudp = -errno;
                    return (-errno);
                }
            }
            break;
        case NetworkType::TCP:
            {
                channel.caddr.sin_addr.s_addr = htonl(INADDR_ANY);
                channel.caddr.sin_port = htons(port);
                if (::bind(channel.cudp,(struct sockaddr *)&channel.caddr, sizeof(struct sockaddr_in)) < 0)
                {
                    CLOSE_SOCKET(channel.cudp);
                    channel.cudp = -errno;
                    return (-errno);
                }

                if (listen(channel.cudp, 1) < 0)
                {
                    CLOSE_SOCKET(channel.cudp);
                    channel.cudp = -errno;
                    return (-errno);
                }
            }
            break;
        default:
            return (SOCKET_ERROR_PROTOCOL);
            break;
        }

        if (ntype == NetworkType::MULTICAST)
        {
            inet_pton(AF_INET,address,&mreq.imr_multiaddr.s_addr);
//            inte_pton(AF_INET, , &mreq.imr_interface.s_addr);
            //          mreq.imr_multiaddr.s_addr = inet_addr(address);
                        mreq.imr_interface.s_addr = htonl(INADDR_ANY);
            if (setsockopt(channel.cudp, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq)) < 0)
            {
                CLOSE_SOCKET(channel.cudp);
                channel.cudp = -errno;
                return (-errno);
            }
        }
        break;
    case SOCKET_JABBER:
        switch (ntype)
        {
        case NetworkType::BROADCAST:
            if ((iretn=setsockopt(channel.cudp,SOL_SOCKET,SO_BROADCAST,(char*)&on,sizeof(on))) < 0)
            {
                CLOSE_SOCKET(channel.cudp);
                channel.cudp = -errno;
                return (-errno);
            }
            channel.caddr.sin_addr.s_addr = 0xffffffff;
            break;
        case NetworkType::MULTICAST:
            inet_pton(AF_INET,address,&channel.caddr.sin_addr);
            break;
        default:
            return (SOCKET_ERROR_PROTOCOL);
            break;
        }
        channel.cport = port;
        break;
    case SOCKET_TALK:
        inet_pton(AF_INET,address,&channel.caddr.sin_addr);
        channel.cport = port;

        if (ntype == NetworkType::TCP)
        {
            if (connect(channel.cudp,(struct sockaddr *)&channel.caddr, sizeof(struct sockaddr_in)) < 0 && errno != EINPROGRESS)
            {
                CLOSE_SOCKET(channel.cudp);
                channel.cudp = -errno;
                return (-errno);
            }
        }
        break;
    }

    // Find assigned port, place in cport, and set caddr to requested port
    channel.baddr = channel.caddr;
    channel.baddr.sin_addr.s_addr |= 0xff;

    switch (ntype)
    {
    case NetworkType::TCP:
        channel.cport = ntohs(channel.caddr.sin_port);
        break;
    default:
        iretn = sendto(channel.cudp, (const char *)nullptr, 0, 0, (struct sockaddr *)&channel.baddr, sizeof(struct sockaddr_in));
        sockaddr_in taddr = channel.caddr;
        socklen_t namelen = sizeof(struct sockaddr_in);
        if ((iretn = getsockname(channel.cudp, (sockaddr*)&channel.caddr, &namelen)) == -1)
        {
            CLOSE_SOCKET(channel.cudp);
            channel.cudp = -errno;
            return (-errno);
        }
        channel.cport = ntohs(channel.caddr.sin_port);
        channel.caddr = taddr;
        break;
    }

    if (rcvbuf)
    {
        setsockopt(channel.cudp, SOL_SOCKET, SO_RCVBUF, (char *)&rcvbuf, 4);
    }

    if (sndbuf)
    {
        setsockopt(channel.cudp, SOL_SOCKET, SO_SNDBUF, (char *)&sndbuf, 4);
    }

    strncpy(channel.address,address,17);
    channel.type = ntype;
    channel.addrlen = sizeof(struct sockaddr_in);

    return 0;
}

int32_t socket_accept	(	socket_channel	server,
		socket_channel &	client
	)

Accept TCP Client connection If socket_channel is a TCP connection, accept the next client and make it available for socket_recvfrom call.

Parameters

server	socket_channel for existing server connection.
client	socket_channel with new client information.

Returns

Zero or negative error.

{
    int32_t iretn=0;
    if (server.type != NetworkType::TCP)
    {
        return SOCKET_ERROR_PROTOCOL;
    }

    iretn = accept(server.cudp, reinterpret_cast<struct sockaddr *>(&client.caddr), reinterpret_cast<socklen_t *>(&client.addrlen));
    if (iretn < 0)
    {
        return -errno;
    }

    client.cudp = iretn;

    return iretn;
}

uint16_t socket_calc_udp_checksum

(

vector< uint8_t >

packet

)

Calculate UDP Checksum.

Calculate UDP Checksum, as detailed in RFC 768, based on the provided IP packet.

Parameters

packet

IP packet

Returns

Calculated checksum.

{
    union
    {
        uint8_t* bytes;
        uint16_t* ints;
    } ;

    bytes = &packet[0];

    uint32_t csum32;
    csum32 = 0;
    // Pseudo header
    // Source Address
    csum32 += ints[6];
    csum32 += ints[7];
    // Destination Address
    csum32 += ints[8];
    csum32 += ints[9];
    // Protocol byte
    csum32 += bytes[SOCKET_IP_BYTE_PROTOCOL]*256U;
    // UDP Length
    csum32 += ints[12];

    // UDP header
    // UDP Source Port
    csum32 += ints[10];
    // UDP Destination Port
    csum32 += ints[11];
    // UDP Length
    csum32 += ints[12];
    // UDP Checksum
    csum32 += ints[13];

    // Actual data bytes. Do any even number, then special treatment for any odd byte.
    uint16_t udpl = (bytes[24]*256U + bytes[25]) - 8;
    if (udpl)
    {
        for (uint16_t i=0; i<udpl/2; ++i)
        {
            csum32 += ints[14+i];
        }

        if (2*(udpl/2) != udpl)
        {
            csum32 += bytes[27+udpl];
        }
    }

    // Perform end around carry
    while (csum32 > 0xffff)
    {
        csum32 = (csum32 & 0xffff) + (csum32 >> 16);
    }

    csum32 = ~csum32;

    if ((uint16_t)csum32 == 0)
    {
        return 0xffff;
    }
    else
    {
        return (uint16_t)csum32;
    }
}

int32_t socket_check_udp_checksum

(

vector< uint8_t >

packet

)

Check UDP checksum.

Calculate UDP checksum for provided UDP packet and return whether it is valid or not.

Parameters

packet

UDP packet

Returns

Zero or negative error.

{
    uint16_t csum = socket_calc_udp_checksum(packet);

    //  if (csum == uint16from(&packet[26], ByteOrder::NETWORK))
    if (csum == 0xffff)
    {
        return 0;
    }
    else
    {
        return SOCKET_ERROR_CS;
    }
}

int32_t socket_set_udp_checksum

(

vector< uint8_t > &

packet

)

Set UDP checksum.

Clear UDP checksum field, calculate UDP checksum, and set UDP checksum field in provided UDP packet.

Parameters

packet

UDP packet

Returns

Zero or negative error.

{
    // Check if this is UDP packet
    if (packet[SOCKET_IP_BYTE_PROTOCOL] != 17)
    {
        return SOCKET_ERROR_PROTOCOL;
    }

    // Set UDP checksum bytes to zero.
    packet[SOCKET_IP_BYTE_UDP_CS] = packet[SOCKET_IP_BYTE_UDP_CS+1] = 0;

    // Calculate checksum
    uint16_t csum = socket_calc_udp_checksum(packet);

    // Place it in checksum bytes
    uint16to(csum, &packet[SOCKET_IP_BYTE_UDP_CS], ByteOrder::LITTLEENDIAN);

    return 0;
}

int32_t socket_blocking	(	socket_channel *	channel,
		bool	blocking
	)

{
    int32_t iretn;

    iretn = socket_blocking(*channel, blocking);

    return iretn;
}

int32_t socket_blocking	(	socket_channel &	channel,
		bool	blocking
	)

{
    int32_t iretn;

    if (blocking == SOCKET_NONBLOCKING)
    {
        iretn = 0;
#ifdef COSMOS_WIN_OS
        unsigned long nonblocking = 1;
        if (ioctlsocket(channel.cudp, FIONBIO, &nonblocking) != 0)
        {
            iretn = -WSAGetLastError();
        }
#else
        if (fcntl(channel.cudp, F_SETFL,O_NONBLOCK) < 0)
        {
            iretn = -errno;
        }
#endif
    }
    else
    {
        iretn = 0;
#ifdef COSMOS_WIN_OS
        unsigned long nonblocking = 0;
        if (ioctlsocket(channel.cudp, FIONBIO, &nonblocking) != 0)
        {
            iretn = -WSAGetLastError();
        }
#else
        int oldfl;
        if ((oldfl = fcntl(channel.cudp, F_GETFL)) == -1)
        {
            iretn = -errno;
        }
        else
        {
            if (fcntl(channel.cudp, F_SETFL, oldfl & ~O_NONBLOCK) < 0)
            {
                iretn = -errno;
            }
        }
#endif
    }
    return iretn;
}

int32_t socket_close

(

socket_channel *

channel

)

Close socket.

Close down open socket connectiom.

Parameters

channel

Pointer to socket_channel holding final configuration.

Returns

Zero or negative error.

{
    int32_t iretn;

    iretn = socket_close(*channel);

    return iretn;
}

int32_t socket_close

(

socket_channel &

channel

)

{
    int32_t iretn = 0;

    if (channel.cudp >= 0)
    {
#ifdef COSMOS_WIN_OS
        if (closesocket(channel.cudp) < 0)
        {
            iretn = -WSAGetLastError();
        }
#else
        if (close(channel.cudp) < 0)
        {
            iretn = -errno;
        }
#endif
        //    channel.address[0] = 0;
        channel.cudp = -1;
    }
    return iretn;
}

int32_t socket_recvfrom	(	socket_channel &	channel,
		vector< uint8_t > &	buffer,
		size_t	maxlen,
		int	flags = 0
	)

    {
    int32_t nbytes;
    buffer.resize(maxlen);
    if ((nbytes = recvfrom(channel.cudp, (char *)buffer.data(), maxlen, flags, (struct sockaddr *)&channel.caddr, (socklen_t *)&channel.addrlen)) > 0)
    {
        buffer.resize(nbytes);
        inet_ntop(channel.caddr.sin_family, &channel.caddr.sin_addr, channel.address, sizeof(channel.address));
    }
    else
    {
        buffer.clear();
        nbytes = -errno;
    }
    return nbytes;
}

int32_t socket_recvfrom	(	socket_channel &	channel,
		string &	buffer,
		size_t	maxlen,
		int	flags = 0
	)

{
    int32_t iretn;
    vector<uint8_t> data;
    iretn = socket_recvfrom(channel, data, maxlen, flags);
    string str(data.begin(), data.end());
    buffer = str;
    return iretn;
}

int32_t socket_sendto	(	socket_channel &	channel,
		const string	buffer,
		int	flags = 0
	)

{
    vector<uint8_t> data(buffer.begin(), buffer.end());
    return socket_sendto(channel, data, flags);
}

int32_t socket_sendto	(	socket_channel &	channel,
		const vector< uint8_t >	buffer,
		int	flags = 0
	)

{
    int32_t nbytes;
#if defined(COSMOS_WIN_OS)
    nbytes = sendto(channel.cudp, (const char *)(buffer.data()), buffer.size(), flags, (struct sockaddr *)&channel.caddr, channel.addrlen);
#else
    if ((nbytes = sendto(channel.cudp, const_cast<uint8_t*>(buffer.data()), buffer.size(), flags, reinterpret_cast<struct sockaddr *>(&channel.caddr), static_cast<socklen_t>(channel.addrlen))) < 0)
    {
        nbytes = -errno;
    }
#endif
    return nbytes;
}

vector<socket_channel> socket_find_addresses

(

NetworkType

ntype

)

Discover interfaces.

Return a vector of socket_channel containing info on each valid interface. For IPV4 this will include the address and broadcast address, in both string sockaddr_in format.

Parameters

ntype

Type of network (Multicast, Broadcast UDP, CSP)

Returns

Vector of interfaces

{
    vector<socket_channel> iface;
    socket_channel tiface;

#ifdef COSMOS_WIN_OS
    INTERFACE_INFO ilist[20];
    unsigned long nbytes;
    uint32_t nif;
    uint32_t ip, net, bcast;
#else
    struct ifconf confa;
    struct ifreq *ifra;
    char data[512];
#endif // COSMOS_WIN_OS
    int32_t iretn;
    int on = 1;
    int32_t cudp;

    switch (ntype)
    {
    case NetworkType::MULTICAST:
    case NetworkType::UDP:
        {
            if ((cudp=socket(AF_INET,SOCK_DGRAM,0)) < 0)
            {
                return (iface);
            }

            // Use above socket to find available interfaces and establish
            // publication on each.
#ifdef COSMOS_WIN_OS
            if (WSAIoctl(cudp, SIO_GET_INTERFACE_LIST, 0, 0, &ilist,sizeof(ilist), &nbytes, 0, 0) == SOCKET_ERROR)
            {
                CLOSE_SOCKET(cudp);
                return (iface);
            }

            nif = nbytes / sizeof(INTERFACE_INFO);
            PIP_ADAPTER_ADDRESSES pAddresses = NULL;
            PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
            pAddresses = (IP_ADAPTER_ADDRESSES *) calloc(sizeof(IP_ADAPTER_ADDRESSES), 2*nif);
            ULONG outBufLen = sizeof(IP_ADAPTER_ADDRESSES) * 2 * nif;
            DWORD dwRetVal;
            if ((dwRetVal=GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, NULL, pAddresses, &outBufLen)) == ERROR_BUFFER_OVERFLOW)
            {
                free(pAddresses);
                return (iface);
            }

            for (uint32_t i=0; i<nif; i++)
            {
                inet_ntop(ilist[i].iiAddress.AddressIn.sin_family,&ilist[i].iiAddress.AddressIn.sin_addr,tiface.address,sizeof(tiface.address));
                //          strncpy(tiface.address, inet_ntoa(((struct sockaddr_in*)&(ilist[i].iiAddress))->sin_addr), 17);
                if (!strcmp(tiface.address,"127.0.0.1"))
                {
                    continue;
                }

                pCurrAddresses = pAddresses;
                while (pAddresses)
                {
                    if (((struct sockaddr_in *)(pCurrAddresses->FirstUnicastAddress->Address.lpSockaddr))->sin_addr.s_addr == ((struct sockaddr_in*)&(ilist[i].iiAddress))->sin_addr.s_addr)
                    {
                        strcpy(tiface.name, pCurrAddresses->AdapterName);
                        break;
                    }
                    pCurrAddresses = pCurrAddresses->Next;
                }
                memset(&tiface.caddr,0,sizeof(struct sockaddr_in));
                memset(&tiface.baddr,0,sizeof(struct sockaddr_in));
                tiface.caddr.sin_family = AF_INET;
                tiface.baddr.sin_family = AF_INET;
                if (ntype == NetworkType::MULTICAST)
                {
                    inet_pton(AF_INET,(char *)COSMOSMCAST,&tiface.caddr.sin_addr);
                    inet_pton(AF_INET,(char *)COSMOSMCAST,&tiface.baddr.sin_addr);
                    //              struct sockaddr_storage ss;
                    //              int sslen;
                    //              sslen = sizeof(ss);
                    //              WSAStringToAddressA((char *)COSMOSMCAST,AF_INET,NULL,(struct sockaddr*)&ss,&sslen);
                    //              tiface.caddr.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
                    //              tiface.baddr.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
                }
                else
                {
                    if ((iretn = setsockopt(cudp,SOL_SOCKET,SO_BROADCAST,(char*)&on,sizeof(on))) < 0)
                    {
                        continue;
                    }
                    ip = ((struct sockaddr_in*)&(ilist[i].iiAddress))->sin_addr.S_un.S_addr;
                    net = ((struct sockaddr_in*)&(ilist[i].iiNetmask))->sin_addr.S_un.S_addr;
                    bcast = ip | (~net);

                    tiface.caddr.sin_addr = ((struct sockaddr_in *)&ilist[i].iiAddress)->sin_addr;
                    tiface.caddr.sin_addr.S_un.S_addr = ip;
                    tiface.baddr.sin_addr = ((struct sockaddr_in *)&ilist[i].iiAddress)->sin_addr;
                    tiface.baddr.sin_addr.S_un.S_addr = bcast;
                }
                //          struct sockaddr_storage ss;
                //          ((struct sockaddr_in *)&ss)->sin_addr = tiface.caddr.sin_addr;
                //          ssize = strlen(tiface.address);
                //          WSAAddressToStringA((struct sockaddr *)&tiface.caddr.sin_addr, sizeof(struct sockaddr_in), 0, tiface.address, (LPDWORD)&ssize);
                inet_ntop(tiface.caddr.sin_family,&tiface.caddr.sin_addr,tiface.address,sizeof(tiface.address));
                //          ssize = strlen(tiface.baddress);
                //          WSAAddressToStringA((struct sockaddr *)&tiface.baddr.sin_addr, sizeof(struct sockaddr_in), 0, tiface.baddress, (LPDWORD)&ssize);
                inet_ntop(tiface.baddr.sin_family,&tiface.baddr.sin_addr,tiface.baddress,sizeof(tiface.baddress));
                tiface.type = ntype;
                iface.push_back(tiface);
            }
#else
            confa.ifc_len = sizeof(data);
            confa.ifc_buf = (caddr_t)data;
            if (ioctl(cudp,SIOCGIFCONF,&confa) < 0)
            {
                CLOSE_SOCKET(cudp);
                return (iface);
            }
            // Use result to discover interfaces.
            ifra = confa.ifc_req;
            for (int32_t n=confa.ifc_len/sizeof(struct ifreq); --n >= 0; ifra++)
            {
                if (ifra->ifr_addr.sa_family != AF_INET) continue;
                inet_ntop(ifra->ifr_addr.sa_family,&((struct sockaddr_in*)&ifra->ifr_addr)->sin_addr,tiface.address,sizeof(tiface.address));

                if (ioctl(cudp,SIOCGIFFLAGS, (char *)ifra) < 0) continue;

                if ((ifra->ifr_flags & IFF_UP) == 0 || (ifra->ifr_flags & IFF_LOOPBACK) || (ifra->ifr_flags & (IFF_BROADCAST)) == 0) continue;

                if (ntype == NetworkType::MULTICAST)
                {
                    inet_pton(AF_INET,COSMOSMCAST,&tiface.caddr.sin_addr);\
                    strncpy(tiface.baddress, COSMOSMCAST, 17);
                    inet_pton(AF_INET,COSMOSMCAST,&tiface.baddr.sin_addr);\
                }
                else
                {
                    if ((iretn = setsockopt(cudp,SOL_SOCKET,SO_BROADCAST,(char*)&on,sizeof(on))) < 0)
                    {
                        continue;
                    }

                    strncpy(tiface.name, ifra->ifr_name, COSMOS_MAX_NAME);
                    if (ioctl(cudp,SIOCGIFBRDADDR,(char *)ifra) < 0) continue;
                    memcpy((char *)&tiface.baddr, (char *)&ifra->ifr_broadaddr, sizeof(ifra->ifr_broadaddr));
                    if (ioctl(cudp,SIOCGIFADDR,(char *)ifra) < 0) continue;
                    memcpy((char *)&tiface.caddr, (char *)&ifra->ifr_addr, sizeof(ifra->ifr_addr));
                    inet_ntop(tiface.baddr.sin_family,&tiface.baddr.sin_addr,tiface.baddress,sizeof(tiface.baddress));
                }
                tiface.type = ntype;
                iface.push_back(tiface);
            }

#endif // COSMOS_WIN_OS
        }
        break;
    default:
        break;
    }

    return (iface);
}