/*=========================================================================*/
int SLPDIncomingInit()
/* Initialize incoming socket list to have appropriate sockets for all */
/* network interfaces */
/* */
/* Returns Zero on success non-zero on error */
/*=========================================================================*/
{
char* begin = NULL;
char* beginSave = NULL;
char* end = NULL;
int finished;
struct in_addr myaddr;
struct in_addr mcastaddr;
struct in_addr bcastaddr;
struct in_addr loaddr;
SLPDSocket* sock;
/*------------------------------------------------------------*/
/* First, remove all of the sockets that might be in the list */
/*------------------------------------------------------------*/
while (G_IncomingSocketList.count)
{
SLPDSocketFree((SLPDSocket*)SLPListUnlink(&G_IncomingSocketList,G_IncomingSocketList.head));
}
/*--------------------------------------------------*/
/* set up address to use for loopback and broadcast */
/*--------------------------------------------------*/
loaddr.s_addr = htonl(LOOPBACK_ADDRESS);
bcastaddr.s_addr = htonl(SLP_BCAST_ADDRESS);
mcastaddr.s_addr = htonl(SLP_MCAST_ADDRESS);
/*--------------------------------------------------------------------*/
/* Create SOCKET_LISTEN socket for LOOPBACK for the library to talk to*/
/*--------------------------------------------------------------------*/
sock = SLPDSocketCreateListen(&loaddr);
if (sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPDLog("Listening on loopback...\n");
}
else
{
SLPDLog("NETWORK_ERROR - Could not listen on loopback\n");
SLPDLog("INTERNAL_ERROR - No SLPLIB support will be available\n");
}
/*---------------------------------------------------------------------*/
/* Create sockets for all of the interfaces in the interfaces property */
/*---------------------------------------------------------------------*/
/*---------------------------------------------------------------------*/
/* Copy G_SlpdProperty.interfaces to a temporary buffer to parse the */
/* string in a safety way */
/*---------------------------------------------------------------------*/
if (G_SlpdProperty.interfaces != NULL)
{
begin = xstrdup((char *) G_SlpdProperty.interfaces);
beginSave = begin; /* save pointer for free() operation later */
end = begin;
finished = 0;
}
else
{
finished = 1; /* if no interface is defined, */
/* don't even enter the parsing loop */
}
for (; (finished == 0); begin = ++end)
{
while (*end && *end != ',') end ++;
if (*end == 0) finished = 1;
*end = 0; /* Terminate string. */
if (end <= begin) continue; /* Skip empty entries */
/* begin now points to a null terminated ip address string */
myaddr.s_addr = inet_addr(begin);
/*------------------------------------------------*/
/* Create TCP_LISTEN that will handle unicast TCP */
/*------------------------------------------------*/
sock = SLPDSocketCreateListen(&myaddr);
if (sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPDLog("Listening on %s ...\n",inet_ntoa(myaddr));
}
/*----------------------------------------------------------------*/
/* Create socket that will handle multicast UDP. */
/*----------------------------------------------------------------*/
sock = SLPDSocketCreateBoundDatagram(&myaddr,
&mcastaddr,
DATAGRAM_MULTICAST);
if (sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPDLog("Multicast socket on %s ready\n",inet_ntoa(myaddr));
}
else
{
SLPDLog("Couldn't bind to multicast for interface %s (%s)\n",
inet_ntoa(myaddr), strerror(errno));
}
#if defined(ENABLE_SLPv1)
if (G_SlpdProperty.isDA)
{
/*------------------------------------------------------------*/
/* Create socket that will handle multicast UDP for SLPv1 DA */
/* Discovery. */
/*------------------------------------------------------------*/
mcastaddr.s_addr = htonl(SLPv1_DA_MCAST_ADDRESS);
sock = SLPDSocketCreateBoundDatagram(&myaddr,
&mcastaddr,
DATAGRAM_MULTICAST);
if (sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPDLog("SLPv1 DA Discovery Multicast socket on %s ready\n",
inet_ntoa(myaddr));
}
}
#endif
/*--------------------------------------------*/
/* Create socket that will handle unicast UDP */
/*--------------------------------------------*/
sock = SLPDSocketCreateBoundDatagram(&myaddr,
&myaddr,
DATAGRAM_UNICAST);
if (sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPDLog("Unicast socket on %s ready\n",inet_ntoa(myaddr));
}
}
if (beginSave) xfree(beginSave);
/*--------------------------------------------------------*/
/* Create socket that will handle broadcast UDP */
/*--------------------------------------------------------*/
sock = SLPDSocketCreateBoundDatagram(&myaddr,
&bcastaddr,
DATAGRAM_BROADCAST);
if (sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPDLog("Broadcast socket for %s ready\n", inet_ntoa(bcastaddr));
}
if (G_IncomingSocketList.count == 0)
{
SLPDLog("No usable interfaces\n");
return 1;
}
return 0;
}
/*=========================================================================*/
int SLPDIncomingInit()
/* Initialize incoming socket list to have appropriate sockets for all */
/* network interfaces */
/* */
/* Returns Zero on success non-zero on error */
/*=========================================================================*/
{
char* begin;
char* end;
int finished;
struct in_addr myaddr;
struct in_addr mcastaddr;
struct in_addr bcastaddr;
struct in_addr loaddr;
SLPDSocket* sock;
/*------------------------------------------------------------*/
/* First, remove all of the sockets that might be in the list */
/*------------------------------------------------------------*/
while(G_IncomingSocketList.count)
{
SLPDSocketFree((SLPDSocket*)SLPListUnlink(&G_IncomingSocketList,G_IncomingSocketList.head));
}
/*-----------------------------------------------*/
/* set up address to use for multicast/broadcast */
/*-----------------------------------------------*/
mcastaddr.s_addr = htonl(SLP_MCAST_ADDRESS);
loaddr.s_addr = htonl(LOOPBACK_ADDRESS);
bcastaddr.s_addr = htonl(SLP_BCAST_ADDRESS);
/*-----------------------------------------------------------------*/
/* Create SOCKET_LISTEN socket for LOOPBACK for the library to talk to*/
/*-----------------------------------------------------------------*/
sock = SLPDSocketCreateListen(&loaddr);
if(sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPLog("Listening on loopback...\n");
}
else
{
SLPLog("ERROR: Could not listen on loopback\n");
SLPLog("ERROR: No SLPLIB support will be available\n");
}
/*---------------------------------------------------------------------*/
/* Create sockets for all of the interfaces in the interfaces property */
/*---------------------------------------------------------------------*/
begin = (char*)G_SlpdProperty.interfaces;
end = begin;
finished = 0;
while( finished == 0)
{
while(*end && *end != ',') end ++;
if(*end == 0) finished = 1;
while(*end <=0x2f)
{
*end = 0;
end--;
}
/* begin now points to a null terminated ip address string */
myaddr.s_addr = inet_addr(begin);
/*------------------------------------------------*/
/* Create TCP_LISTEN that will handle unicast TCP */
/*------------------------------------------------*/
sock = SLPDSocketCreateListen(&myaddr);
if(sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPLog("Listening on %s ...\n",inet_ntoa(myaddr));
}
/*--------------------------------------------------------*/
/* Create socket that will handle multicast UDP */
/*--------------------------------------------------------*/
sock = SLPDSocketCreateBoundDatagram(&myaddr,
&mcastaddr,
DATAGRAM_MULTICAST);
if(sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPLog("Multicast socket on %s ready\n",inet_ntoa(myaddr));
}
/*--------------------------------------------*/
/* Create socket that will handle unicast UDP */
/*--------------------------------------------*/
sock = SLPDSocketCreateBoundDatagram(&myaddr,
&myaddr,
DATAGRAM_UNICAST);
if(sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPLog("Unicast socket on %s ready\n",inet_ntoa(myaddr));
}
begin = end + 1;
}
/*--------------------------------------------------------*/
/* Create socket that will handle broadcast UDP */
/*--------------------------------------------------------*/
sock = SLPDSocketCreateBoundDatagram(&myaddr,
&bcastaddr,
DATAGRAM_BROADCAST);
if(sock)
{
SLPListLinkTail(&G_IncomingSocketList,(SLPListItem*)sock);
SLPLog("Broadcast socket for %s ready\n", inet_ntoa(bcastaddr));
}
return 0;
}
