slp_xcast.c

SLP协议在linux下的实现。此版本为1.2.1版。官方网站为www.openslp.org

        if (xferbytes <= 0)
        {
            /* error sending */
            return -1;
        }
    }
    
    return 0;

}


/*========================================================================*/
int SLPXcastSocketsClose(SLPXcastSockets* socks)
/* Description:
 *    Closes sockets that were opened by calls to SLPMulticastSend() and
 *    SLPBroadcastSend()
 *
 * Parameters:
 *    socks (IN) Pointer to the SLPXcastSockets structure being close
 *
 * Returns:
 *    Zero on sucess.  Non-zero with errno set on error
 *========================================================================*/
{
    while(socks->sock_count)
    {
        socks->sock_count = socks->sock_count - 1;
		#ifdef _WIN32 
			closesocket(socks->sock[socks->sock_count]);
		#else
        close(socks->sock[socks->sock_count]);
		#endif
    }

    return 0;
}



/*=========================================================================*/
int SLPXcastRecvMessage(const SLPXcastSockets* sockets,
                        SLPBuffer* buf,
                        struct sockaddr_in* peeraddr,
                        struct timeval* timeout)
/* Description: 
 * 	Receives datagram messages from one of the sockets in the specified 
 * 	SLPXcastsSockets structure
 * 
 * Parameters:
 * 	sockets (IN) Pointer to the SOPXcastSockets structure that describes
 * 		       which sockets to read messages from.
 * 	buf (OUT) Pointer to SLPBuffer that will contain the message upon
 * 		       successful return.
 * 	peeraddr (OUT) Pointer to struc sockaddr_in that will contain the
 * 		       address of the peer that sent the received message.
 * 	timeout (IN/OUT) pointer to the struct timeval that indicates how much
 * 		       time to wait for a message to arrive
 *
 * Returns:
 * 	Zero on success, non-zero with errno set on failure.
 *==========================================================================*/ 
{
    fd_set  readfds;
    int     highfd;
    int     i;
    int     readable;
    size_t  bytesread;
    int     recvloop;
    int     peeraddrlen = sizeof(struct sockaddr_in);
    char    peek[16];
    int     result;

    /* recv loop */
    result = -1;
    recvloop = 1;
    while(recvloop)
    {
        /* Set the readfds */
        FD_ZERO(&readfds);
        highfd = 0;
        for (i=0; i<sockets->sock_count; i++)
        {
            FD_SET(sockets->sock[i],&readfds);
            if(sockets->sock[i] > highfd)
            {
                highfd = sockets->sock[i];
            }
        }
    
        /* Select */
        readable = select(highfd + 1,&readfds,NULL,NULL,timeout);
        if(readable > 0)
        {
            /* Read the datagram */
            for (i=0; i<sockets->sock_count; i++)
            {
                if(FD_ISSET(sockets->sock[i],&readfds))
                {
                    /* Peek at the first 16 bytes of the header */
                    bytesread = recvfrom(sockets->sock[i],
                                         peek,
                                         16,
                                         MSG_PEEK,
                                         (struct sockaddr *)peeraddr,
                                         &peeraddrlen);
                    if(bytesread == 16
#ifdef _WIN32
                    /* Win32 returns WSAEMSGSIZE if the message is larger than
                     * the requested size, even with MSG_PEEK. But if this is the
                     * error code we can be sure that the message is at least 16
                     * bytes */
                       || (bytesread == (size_t)-1 && WSAGetLastError() == WSAEMSGSIZE)
#endif
                       )
                    {
                        if(AsUINT24(peek + 2) <=  SLP_MAX_DATAGRAM_SIZE)
                        {
                            *buf = SLPBufferRealloc(*buf, AsUINT24(peek + 2));
                            bytesread = recv(sockets->sock[i],
                                             (*buf)->curpos,
                                             (*buf)->end - (*buf)->curpos,
                                             0);
                            if(bytesread != AsUINT24(peek + 2))
                            {
                                /* This should never happen but we'll be paranoid*/
                                (*buf)->end = (*buf)->curpos + bytesread;
                            }
                            
                            /* Message read. We're done! */
                            result = 0; 
                            recvloop = 0;
                            break;
                        }
                        else
                        {
                            /* we got a bad message, or one that is too big! */
#ifndef UNICAST_NOT_SUPPORTED
                            /* Reading SLP_MAX_DATAGRAM_SIZE bytes on the socket */
		            *buf = SLPBufferRealloc(*buf, SLP_MAX_DATAGRAM_SIZE);
		            bytesread = recv(sockets->sock[i],
		                              (*buf)->curpos,
					      (*buf)->end - (*buf)->curpos,
					      0);
			    if(bytesread != SLP_MAX_DATAGRAM_SIZE)
			    {
			        /* This should never happen but we'll be paranoid*/
			        (*buf)->end = (*buf)->curpos + bytesread;
			    }
			    result = SLP_RETRY_UNICAST;
			    recvloop = 0;
			    return result;
#endif
                        }
                    }
                    else
                    {
                        /* Not even 16 bytes available */
                    }
                }
            }   
        }
        else if(readable == 0)
        {
            result = -1;
            errno = ETIMEDOUT;
            recvloop = 0;
        }
        else
        {
            result = -1;
            recvloop = 0;
        }
    }

    return result;
}

/*===========================================================================
 * TESTING CODE may be compiling with the following command line:
 *
 * $ gcc -g -DDEBUG -DSLP_XMIT_TEST slp_xcast.c slp_iface.c slp_buffer.c 
 *   slp_linkedlist.c slp_compare.c slp_xmalloc.c
 *==========================================================================*/ 
#ifdef SLP_XMIT_TEST
main()
{
    SLPIfaceInfo    ifaceinfo;
    SLPXcastSockets      socks;
    SLPBuffer           buffer;
    #ifdef _WIN32
    WSADATA wsadata;
    WSAStartup(MAKEWORD(2,2), &wsadata);
    #endif

    buffer = SLPBufferAlloc(SLP_MAX_DATAGRAM_SIZE);
    if(buffer)
    {
        
        strcpy(buffer->start,"testdata");
    
        SLPIfaceGetInfo(NULL,&ifaceinfo);
    
        if (SLPBroadcastSend(&ifaceinfo, buffer,&socks) !=0)
            printf("\n SLPBroadcastSend failed \n");
        SLPXcastSocketsClose(&socks);
    
        if (SLPMulticastSend(&ifaceinfo, buffer, &socks) !=0)
            printf("\n SLPMulticast failed \n");
        SLPXcastSocketsClose(&socks);

        printf("Success\n");

        SLPBufferFree(buffer);
    }
    #ifdef _WIN32
    WSACleanup();
    #endif
}

#endif