generic-library/libupnp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge of trunk into branch-1.6.x.

Browse Source 
git-svn-id: https://pupnp.svn.sourceforge.net/svnroot/pupnp/branches/branch-1.6.x@322 119443c7-1b9e-41f8-b6fc-b9c35fce742c
This commit is contained in:
Marcelo Roberto Jimenez 2008-02-08 02:29:26 +00:00
parent 078f3f8faf
commit a785465222
9 changed files with 174 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
ChangeLog
View File

@ -1,3 +1,16 @@
*******************************************************************************
Version 1.6.6
*******************************************************************************
2008-02-06 Marcelo Jimenez <mroberto(at)users.sourceforge.net>
* Slightly improved error report by showing the sys_errlist string
corresponding to errno.
2008-02-06 Marcelo Jimenez <mroberto(at)users.sourceforge.net>
* Got rid of two useless constants: UPNP_SOCKETERROR and
UPNP_INVALID_SOCKET. They both mean the same, that a network API
function has failed. -1 is the value to check, not an invented constant.
******************************************************************************* *******************************************************************************
Version 1.6.5 Version 1.6.5
******************************************************************************* *******************************************************************************

15
configure.ac
View File

@ -9,7 +9,7 @@
AC_PREREQ(2.60) AC_PREREQ(2.60)
AC_INIT([libupnp], [1.6.5], [mroberto@users.sourceforge.net]) AC_INIT([libupnp], [1.6.6], [mroberto@users.sourceforge.net])
dnl ############################################################################ dnl ############################################################################
dnl # *Independently* of the above libupnp package version, the libtool version dnl # *Independently* of the above libupnp package version, the libtool version
dnl # of the 3 libraries need to be updated whenever there is a change released: dnl # of the 3 libraries need to be updated whenever there is a change released:
@ -131,9 +131,20 @@ dnl #AC_SUBST([LT_VERSION_THREADUTIL], [4:2:2])
dnl #AC_SUBST([LT_VERSION_UPNP], [3:4:0]) dnl #AC_SUBST([LT_VERSION_UPNP], [3:4:0])
dnl # dnl #
dnl ############################################################################ dnl ############################################################################
dnl # Release 1.6.6:
dnl # "current:revision:age"
dnl #
dnl # - Code has changed in upnp
dnl # revision: 4 -> 5
dnl #
dnl #AC_SUBST([LT_VERSION_IXML], [2:4:0])
dnl #AC_SUBST([LT_VERSION_THREADUTIL], [4:2:2])
dnl #AC_SUBST([LT_VERSION_UPNP], [3:5:0])
dnl #
dnl ############################################################################
AC_SUBST([LT_VERSION_IXML], [2:4:0]) AC_SUBST([LT_VERSION_IXML], [2:4:0])
AC_SUBST([LT_VERSION_THREADUTIL], [4:2:2]) AC_SUBST([LT_VERSION_THREADUTIL], [4:2:2])
AC_SUBST([LT_VERSION_UPNP], [3:4:0]) AC_SUBST([LT_VERSION_UPNP], [3:5:0])
dnl ############################################################################ dnl ############################################################################
dnl # Repeating the algorithm to place it closer to the modificatin place: dnl # Repeating the algorithm to place it closer to the modificatin place:
dnl # - library code modified: revision++ dnl # - library code modified: revision++

2
libupnp.spec
View File

@ -1,4 +1,4 @@
Version: 1.6.5 Version: 1.6.6
Summary: Universal Plug and Play (UPnP) SDK Summary: Universal Plug and Play (UPnP) SDK
Name: libupnp Name: libupnp
Release: 1%{?dist} Release: 1%{?dist}

2
upnp/inc/upnp.h
View File

@ -102,8 +102,6 @@
#define UpnpCloseSocket closesocket #define UpnpCloseSocket closesocket
#define fseeko fseek #define fseeko fseek
#endif #endif
#define UPNP_SOCKETERROR -1
#define UPNP_INVALID_SOCKET -1
#ifndef WIN32 #ifndef WIN32
#define SOCKET int #define SOCKET int
#endif #endif

6
upnp/src/api/upnpapi.c
View File

@ -206,7 +206,7 @@ int UpnpInit( IN const char *HostIP,
return UPNP_E_INIT_FAILED; return UPNP_E_INIT_FAILED;
} }
UpnpPrintf( UPNP_INFO, API, __FILE__, __LINE__, "Inside UpnpInit \n" ); UpnpPrintf( UPNP_INFO, API, __FILE__, __LINE__, "Inside UpnpInit\n" );
// initialize mutex // initialize mutex
#ifdef __CYGWIN__ #ifdef __CYGWIN__
/* On Cygwin, pthread_mutex_init() fails without this memset. */ /* On Cygwin, pthread_mutex_init() fails without this memset. */
@ -313,7 +313,7 @@ int UpnpInit( IN const char *HostIP,
"Host Ip: %s Host Port: %d\n", LOCAL_HOST, "Host Ip: %s Host Port: %d\n", LOCAL_HOST,
LOCAL_PORT ); LOCAL_PORT );
UpnpPrintf( UPNP_INFO, API, __FILE__, __LINE__, "Exiting UpnpInit \n" ); UpnpPrintf( UPNP_INFO, API, __FILE__, __LINE__, "Exiting UpnpInit\n" );
return UPNP_E_SUCCESS; return UPNP_E_SUCCESS;
@ -330,7 +330,7 @@ PrintThreadPoolStats(
ThreadPoolStats stats; ThreadPoolStats stats;
ThreadPoolGetStats(tp, &stats); ThreadPoolGetStats(tp, &stats);
UpnpPrintf(UPNP_INFO, API, DbgFileName, DbgLineNo, UpnpPrintf(UPNP_INFO, API, DbgFileName, DbgLineNo,
"%s \n" "%s\n"
"High Jobs pending: %d\n" "High Jobs pending: %d\n"
"Med Jobs Pending: %d\n" "Med Jobs Pending: %d\n"
"Low Jobs Pending: %d\n" "Low Jobs Pending: %d\n"

130
upnp/src/genlib/miniserver/miniserver.c
View File

@ -393,6 +393,7 @@ RunMiniServer( MiniServerSockArray * miniSock )
unsigned int maxMiniSock; unsigned int maxMiniSock;
int byteReceived; int byteReceived;
char requestBuf[256]; char requestBuf[256];
int ret = 0;
maxMiniSock = max( miniServSock, miniServStopSock) ; maxMiniSock = max( miniServSock, miniServStopSock) ;
maxMiniSock = max( maxMiniSock, (SOCKET)(ssdpSock) ); maxMiniSock = max( maxMiniSock, (SOCKET)(ssdpSock) );
@ -414,10 +415,11 @@ RunMiniServer( MiniServerSockArray * miniSock )
FD_SET( ssdpReqSock, &rdSet ); FD_SET( ssdpReqSock, &rdSet );
#endif #endif
if( select( maxMiniSock, &rdSet, NULL, &expSet, NULL ) == ret = select( maxMiniSock, &rdSet, NULL, &expSet, NULL );
UPNP_SOCKETERROR ) { if ( ret == -1 ) {
UpnpPrintf( UPNP_CRITICAL, SSDP, __FILE__, __LINE__, UpnpPrintf( UPNP_CRITICAL, SSDP, __FILE__, __LINE__,
"Error in select call!\n" ); "Error in select(): %s\n",
sys_errlist[errno] );
/* Avoid 100% CPU in case of repeated error in select() */ /* Avoid 100% CPU in case of repeated error in select() */
isleep( 1 ); isleep( 1 );
continue; continue;
@ -426,9 +428,10 @@ RunMiniServer( MiniServerSockArray * miniSock )
clientLen = sizeof( struct sockaddr_in ); clientLen = sizeof( struct sockaddr_in );
connectHnd = accept( miniServSock, connectHnd = accept( miniServSock,
( struct sockaddr * )&clientAddr, &clientLen ); ( struct sockaddr * )&clientAddr, &clientLen );
if( connectHnd == UPNP_INVALID_SOCKET ) { if( connectHnd == -1 ) {
UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__, UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__,
"miniserver: Error in accepting connection\n" ); "miniserver: Error in accept(): %s\n",
sys_errlist[errno] );
continue; continue;
} }
schedule_request_job( connectHnd, &clientAddr ); schedule_request_job( connectHnd, &clientAddr );
@ -444,8 +447,7 @@ RunMiniServer( MiniServerSockArray * miniSock )
} }
if( FD_ISSET( miniServStopSock, &rdSet ) ) { if( FD_ISSET( miniServStopSock, &rdSet ) ) {
clientLen = sizeof( struct sockaddr_in ); clientLen = sizeof( struct sockaddr_in );
memset( ( char * )&clientAddr, 0, memset( (char *)&clientAddr, 0, sizeof (struct sockaddr_in) );
sizeof( struct sockaddr_in ) );
byteReceived = byteReceived =
recvfrom( miniServStopSock, requestBuf, 25, 0, recvfrom( miniServStopSock, requestBuf, 25, 0,
( struct sockaddr * )&clientAddr, ( struct sockaddr * )&clientAddr,
@ -453,7 +455,7 @@ RunMiniServer( MiniServerSockArray * miniSock )
if( byteReceived > 0 ) { if( byteReceived > 0 ) {
requestBuf[byteReceived] = '\0'; requestBuf[byteReceived] = '\0';
UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__, UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__,
"Received response !!! %s From host %s \n", "Received response: %s From host %s \n",
requestBuf, inet_ntoa( clientAddr.sin_addr ) ); requestBuf, inet_ntoa( clientAddr.sin_addr ) );
UpnpPrintf( UPNP_PACKET, MSERV, __FILE__, __LINE__, UpnpPrintf( UPNP_PACKET, MSERV, __FILE__, __LINE__,
"Received multicast packet: \n %s\n", "Received multicast packet: \n %s\n",
@ -552,9 +554,10 @@ get_miniserver_sockets( MiniServerSockArray * out,
int sockError = UPNP_E_SUCCESS; int sockError = UPNP_E_SUCCESS;
int errCode = 0; int errCode = 0;
int miniServerStopSock; int miniServerStopSock;
int ret = 0;
listenfd = socket( AF_INET, SOCK_STREAM, 0 ); listenfd = socket( AF_INET, SOCK_STREAM, 0 );
if( listenfd < 0 ) { if ( listenfd == -1 ) {
return UPNP_E_OUTOF_SOCKET; // error creating socket return UPNP_E_OUTOF_SOCKET; // error creating socket
} }
// As per the IANA specifications for the use of ports by applications // As per the IANA specifications for the use of ports by applications
@ -571,51 +574,51 @@ get_miniserver_sockets( MiniServerSockArray * out,
// Keeping the re-use address code as an optional behaviour that can be // Keeping the re-use address code as an optional behaviour that can be
// turned on if necessary. // turned on if necessary.
// TURN ON the reuseaddr_on option to use the option. // TURN ON the reuseaddr_on option to use the option.
if( reuseaddr_on ) { if ( reuseaddr_on ) {
//THIS IS ALLOWS US TO BIND AGAIN IMMEDIATELY // THIS IS ALLOWS US TO BIND AGAIN IMMEDIATELY
//AFTER OUR SERVER HAS BEEN CLOSED // AFTER OUR SERVER HAS BEEN CLOSED
//THIS MAY CAUSE TCP TO BECOME LESS RELIABLE // THIS MAY CAUSE TCP TO BECOME LESS RELIABLE
//HOWEVER IT HAS BEEN SUGESTED FOR TCP SERVERS // HOWEVER IT HAS BEEN SUGESTED FOR TCP SERVERS
UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__, UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__,
"mserv start: resuseaddr set\n" ); "mserv start: resuseaddr set\n" );
sockError = setsockopt( listenfd, SOL_SOCKET, SO_REUSEADDR, sockError = setsockopt( listenfd, SOL_SOCKET, SO_REUSEADDR,
( const char * )&reuseaddr_on, sizeof( int )); (const char *)&reuseaddr_on, sizeof (int) );
if( sockError == UPNP_SOCKETERROR ) { if ( sockError == -1 ) {
shutdown( listenfd, SD_BOTH ); shutdown( listenfd, SD_BOTH );
UpnpCloseSocket( listenfd ); UpnpCloseSocket( listenfd );
return UPNP_E_SOCKET_BIND; return UPNP_E_SOCKET_BIND;
} }
sockError = bind( listenfd, sockError = bind( listenfd, (struct sockaddr *)&serverAddr,
( struct sockaddr * )&serverAddr, sizeof (struct sockaddr_in) );
sizeof( struct sockaddr_in )
);
} else { } else {
do { do {
serverAddr.sin_port = htons( listen_port++ ); serverAddr.sin_port = htons( listen_port++ );
sockError = bind( listenfd, sockError = bind( listenfd, (struct sockaddr *)&serverAddr,
( struct sockaddr * )&serverAddr, sizeof (struct sockaddr_in) );
sizeof( struct sockaddr_in ) if ( sockError == -1 ) {
);
if( sockError == UPNP_SOCKETERROR ) {
#ifdef WIN32 #ifdef WIN32
errCode = WSAGetLastError(); errCode = WSAGetLastError();
#else #else
errCode = errno; errCode = errno;
#endif #endif
if( errno == EADDRINUSE ) if( errno == EADDRINUSE ) {
errCode = 1; errCode = 1;
}
} else } else
errCode = 0; errCode = 0;
} while( errCode != 0 ); } while ( errCode != 0 );
} }
if( sockError == UPNP_SOCKETERROR ) { if ( sockError == -1 ) {
perror( "mserv start: bind failed" ); UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__,
"mserv start: Error in bind(): %s\n",
sys_errlist[errno] );
shutdown( listenfd, SD_BOTH ); shutdown( listenfd, SD_BOTH );
UpnpCloseSocket( listenfd ); UpnpCloseSocket( listenfd );
return UPNP_E_SOCKET_BIND; // bind failed return UPNP_E_SOCKET_BIND; // bind failed
} }
@ -623,28 +626,35 @@ get_miniserver_sockets( MiniServerSockArray * out,
"mserv start: bind success\n" ); "mserv start: bind success\n" );
success = listen( listenfd, SOMAXCONN ); success = listen( listenfd, SOMAXCONN );
if( success == UPNP_SOCKETERROR ) { if ( success == -1 ) {
UpnpPrintf( UPNP_INFO, MSERV, __FILE__, __LINE__,
"mserv start: Error in listen(): %s\n",
sys_errlist[errno] );
shutdown( listenfd, SD_BOTH ); shutdown( listenfd, SD_BOTH );
UpnpCloseSocket( listenfd ); UpnpCloseSocket( listenfd );
return UPNP_E_LISTEN; // listen failed
return UPNP_E_LISTEN;
} }
actual_port = get_port( listenfd ); actual_port = get_port( listenfd );
if( actual_port <= 0 ) { if( actual_port <= 0 ) {
shutdown( listenfd, SD_BOTH ); shutdown( listenfd, SD_BOTH );
UpnpCloseSocket( listenfd ); UpnpCloseSocket( listenfd );
return UPNP_E_INTERNAL_ERROR; return UPNP_E_INTERNAL_ERROR;
} }
out->miniServerPort = actual_port; out->miniServerPort = actual_port;
if( ( miniServerStopSock = socket( AF_INET, SOCK_DGRAM, 0 ) ) == miniServerStopSock = socket( AF_INET, SOCK_DGRAM, 0 );
UPNP_INVALID_SOCKET ) { if ( miniServerStopSock == -1 ) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
MSERV, __FILE__, __LINE__, MSERV, __FILE__, __LINE__,
"Error in socket operation !!!\n" ); "Error in socket(): %s\n",
sys_errlist[errno] );
shutdown( listenfd, SD_BOTH ); shutdown( listenfd, SD_BOTH );
UpnpCloseSocket( listenfd ); UpnpCloseSocket( listenfd );
return UPNP_E_OUTOF_SOCKET; return UPNP_E_OUTOF_SOCKET;
} }
@ -652,10 +662,9 @@ get_miniserver_sockets( MiniServerSockArray * out,
memset( ( char * )&serverAddr, 0, sizeof( struct sockaddr_in ) ); memset( ( char * )&serverAddr, 0, sizeof( struct sockaddr_in ) );
serverAddr.sin_family = AF_INET; serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = inet_addr( "127.0.0.1" ); serverAddr.sin_addr.s_addr = inet_addr( "127.0.0.1" );
ret = bind( miniServerStopSock, (struct sockaddr *)&serverAddr,
if( bind( miniServerStopSock, ( struct sockaddr * )&serverAddr, sizeof (serverAddr) );
sizeof( serverAddr ) ) == UPNP_SOCKETERROR ) { if ( ret == -1 ) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
MSERV, __FILE__, __LINE__, MSERV, __FILE__, __LINE__,
"Error in binding localhost!!!\n" ); "Error in binding localhost!!!\n" );
@ -663,20 +672,21 @@ get_miniserver_sockets( MiniServerSockArray * out,
UpnpCloseSocket( listenfd ); UpnpCloseSocket( listenfd );
shutdown( miniServerStopSock, SD_BOTH ); shutdown( miniServerStopSock, SD_BOTH );
UpnpCloseSocket( miniServerStopSock ); UpnpCloseSocket( miniServerStopSock );
return UPNP_E_SOCKET_BIND; return UPNP_E_SOCKET_BIND;
} }
miniStopSockPort = get_port( miniServerStopSock ); miniStopSockPort = get_port( miniServerStopSock );
if( miniStopSockPort <= 0 ) { if ( miniStopSockPort <= 0 ) {
shutdown( miniServerStopSock, SD_BOTH ); shutdown( miniServerStopSock, SD_BOTH );
UpnpCloseSocket( miniServerStopSock ); UpnpCloseSocket( miniServerStopSock );
shutdown( listenfd, SD_BOTH ); shutdown( listenfd, SD_BOTH );
UpnpCloseSocket( listenfd ); UpnpCloseSocket( listenfd );
return UPNP_E_INTERNAL_ERROR; return UPNP_E_INTERNAL_ERROR;
} }
out->stopPort = miniStopSockPort; out->stopPort = miniStopSockPort;
out->miniServerSock = listenfd; out->miniServerSock = listenfd;
out->miniServerStopSock = miniServerStopSock; out->miniServerStopSock = miniServerStopSock;
@ -718,18 +728,19 @@ StartMiniServer( unsigned short listen_port )
return UPNP_E_INTERNAL_ERROR; // miniserver running return UPNP_E_INTERNAL_ERROR; // miniserver running
} }
miniSocket = miniSocket = (MiniServerSockArray *) malloc( sizeof (MiniServerSockArray) );
( MiniServerSockArray * ) malloc( sizeof( MiniServerSockArray ) ); if( miniSocket == NULL ) {
if( miniSocket == NULL )
return UPNP_E_OUTOF_MEMORY; return UPNP_E_OUTOF_MEMORY;
}
if( ( success = get_miniserver_sockets( miniSocket, listen_port ) ) success = get_miniserver_sockets( miniSocket, listen_port );
!= UPNP_E_SUCCESS ) { if( success != UPNP_E_SUCCESS ) {
free( miniSocket ); free( miniSocket );
return success; return success;
} }
if( ( success = get_ssdp_sockets( miniSocket ) ) != UPNP_E_SUCCESS ) { success = get_ssdp_sockets( miniSocket );
if( success != UPNP_E_SUCCESS ) {
shutdown( miniSocket->miniServerSock, SD_BOTH ); shutdown( miniSocket->miniServerSock, SD_BOTH );
UpnpCloseSocket( miniSocket->miniServerSock ); UpnpCloseSocket( miniSocket->miniServerSock );
shutdown( miniSocket->miniServerStopSock, SD_BOTH ); shutdown( miniSocket->miniServerStopSock, SD_BOTH );
@ -739,15 +750,12 @@ StartMiniServer( unsigned short listen_port )
return success; return success;
} }
TPJobInit( &job, ( start_routine ) RunMiniServer, TPJobInit( &job, (start_routine)RunMiniServer, (void *)miniSocket );
( void * )miniSocket );
TPJobSetPriority( &job, MED_PRIORITY ); TPJobSetPriority( &job, MED_PRIORITY );
TPJobSetFreeFunction( &job, ( free_routine ) free ); TPJobSetFreeFunction( &job, ( free_routine ) free );
success = ThreadPoolAddPersistent( &gMiniServerThreadPool, &job, NULL ); success = ThreadPoolAddPersistent( &gMiniServerThreadPool, &job, NULL );
if ( success < 0 ) {
if( success < 0 ) {
shutdown( miniSocket->miniServerSock, SD_BOTH ); shutdown( miniSocket->miniServerSock, SD_BOTH );
UpnpCloseSocket( miniSocket->miniServerSock ); UpnpCloseSocket( miniSocket->miniServerSock );
shutdown( miniSocket->miniServerStopSock, SD_BOTH ); shutdown( miniSocket->miniServerStopSock, SD_BOTH );
@ -763,13 +771,13 @@ StartMiniServer( unsigned short listen_port )
} }
// wait for miniserver to start // wait for miniserver to start
count = 0; count = 0;
while( gMServState != MSERV_RUNNING && count < max_count ) { while ( gMServState != MSERV_RUNNING && count < max_count ) {
usleep( 50 * 1000 ); // 0.05s usleep( 50 * 1000 ); // 0.05s
count++; count++;
} }
// taking too long to start that thread // taking too long to start that thread
if( count >= max_count ) { if ( count >= max_count ) {
shutdown( miniSocket->miniServerSock, SD_BOTH ); shutdown( miniSocket->miniServerSock, SD_BOTH );
UpnpCloseSocket( miniSocket->miniServerSock ); UpnpCloseSocket( miniSocket->miniServerSock );
shutdown( miniSocket->miniServerStopSock, SD_BOTH ); shutdown( miniSocket->miniServerStopSock, SD_BOTH );
@ -801,7 +809,7 @@ StartMiniServer( unsigned short listen_port )
* Always returns 0 * Always returns 0
************************************************************************/ ************************************************************************/
int int
StopMiniServer( void ) StopMiniServer()
{ {
int socklen = sizeof( struct sockaddr_in ); int socklen = sizeof( struct sockaddr_in );
@ -817,9 +825,10 @@ StopMiniServer( void )
} }
sock = socket( AF_INET, SOCK_DGRAM, 0 ); sock = socket( AF_INET, SOCK_DGRAM, 0 );
if( sock == UPNP_INVALID_SOCKET ) { if ( sock == -1 ) {
UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__, UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__,
"SSDP_SERVER:StopSSDPServer: Error in socket operation !!!\n" ); "SSDP_SERVER: StopSSDPServer: Error in socket() %s\n",
sys_errlist[errno] );
return 0; return 0;
} }
@ -827,15 +836,16 @@ StopMiniServer( void )
ssdpAddr.sin_family = AF_INET; ssdpAddr.sin_family = AF_INET;
ssdpAddr.sin_addr.s_addr = inet_addr( "127.0.0.1" ); ssdpAddr.sin_addr.s_addr = inet_addr( "127.0.0.1" );
ssdpAddr.sin_port = htons( miniStopSockPort ); ssdpAddr.sin_port = htons( miniStopSockPort );
sendto( sock, buf, bufLen, 0, ( struct sockaddr * )&ssdpAddr, sendto( sock, buf, bufLen, 0, (struct sockaddr *)&ssdpAddr, socklen );
socklen );
usleep( 1000 ); usleep( 1000 );
if( gMServState == MSERV_IDLE ) if( gMServState == MSERV_IDLE ) {
break; break;
}
isleep( 1 ); isleep( 1 );
} }
shutdown( sock, SD_BOTH ); shutdown( sock, SD_BOTH );
UpnpCloseSocket( sock ); UpnpCloseSocket( sock );
return 0; return 0;
} }

42
upnp/src/ssdp/ssdp_ctrlpt.c
View File

@ -516,6 +516,7 @@ SearchByTarget( IN int Mx,
{ {
int socklen = sizeof( struct sockaddr_in ); int socklen = sizeof( struct sockaddr_in );
int *id = NULL; int *id = NULL;
int ret = 0;
char *ReqBuf; char *ReqBuf;
struct sockaddr_in destAddr; struct sockaddr_in destAddr;
fd_set wrSet; fd_set wrSet;
@ -534,9 +535,10 @@ SearchByTarget( IN int Mx,
return UPNP_E_INVALID_PARAM; return UPNP_E_INVALID_PARAM;
} }
ReqBuf = ( char * )malloc( BUFSIZE ); ReqBuf = (char *)malloc( BUFSIZE );
if( ReqBuf == NULL ) if( ReqBuf == NULL ) {
return UPNP_E_OUTOF_MEMORY; return UPNP_E_OUTOF_MEMORY;
}
UpnpPrintf(UPNP_INFO, SSDP, __FILE__, __LINE__, ">>> SSDP SEND >>>\n"); UpnpPrintf(UPNP_INFO, SSDP, __FILE__, __LINE__, ">>> SSDP SEND >>>\n");
@ -558,7 +560,7 @@ SearchByTarget( IN int Mx,
FD_ZERO( &wrSet ); FD_ZERO( &wrSet );
FD_SET( gSsdpReqSocket, &wrSet ); FD_SET( gSsdpReqSocket, &wrSet );
//add search criteria to list // add search criteria to list
HandleLock(); HandleLock();
if( GetClientHandleInfo( &handle, &ctrlpt_info ) != HND_CLIENT ) { if( GetClientHandleInfo( &handle, &ctrlpt_info ) != HND_CLIENT ) {
HandleUnlock(); HandleUnlock();
@ -576,7 +578,7 @@ SearchByTarget( IN int Mx,
TPJobSetPriority( &job, MED_PRIORITY ); TPJobSetPriority( &job, MED_PRIORITY );
TPJobSetFreeFunction( &job, ( free_routine ) free ); TPJobSetFreeFunction( &job, ( free_routine ) free );
//Schdule a timeout event to remove search Arg // Schedule a timeout event to remove search Arg
TimerThreadSchedule( &gTimerThread, timeTillRead, TimerThreadSchedule( &gTimerThread, timeTillRead,
REL_SEC, &job, SHORT_TERM, id ); REL_SEC, &job, SHORT_TERM, id );
newArg->timeoutEventId = ( *id ); newArg->timeoutEventId = ( *id );
@ -584,37 +586,24 @@ SearchByTarget( IN int Mx,
ListAddTail( &ctrlpt_info->SsdpSearchList, newArg ); ListAddTail( &ctrlpt_info->SsdpSearchList, newArg );
HandleUnlock(); HandleUnlock();
setsockopt( gSsdpReqSocket, IPPROTO_IP, IP_MULTICAST_IF, ret = setsockopt( gSsdpReqSocket, IPPROTO_IP, IP_MULTICAST_IF,
( char * )&addr, sizeof( addr ) ); (char *)&addr, sizeof (addr) );
if( select( gSsdpReqSocket + 1, NULL, &wrSet, NULL, NULL ) ret = select( gSsdpReqSocket + 1, NULL, &wrSet, NULL, NULL );
== UPNP_SOCKETERROR ) { if( ret == -1 ) {
if( errno == EBADF ) { UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__,
UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__, "SSDP_LIB: Error in select(): %s\n",
"SSDP_LIB :RequestHandler:An invalid file descriptor" sys_errlist[errno] );
" was givenin one of the sets. \n" );
} else if( errno == EINTR ) {
UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__,
"SSDP_LIB :RequestHandler: A non blocked "
"signal was caught. \n" );
} else if( errno == EINVAL ) {
UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__,
"SSDP_LIB :RequestHandler: n is negative. \n" );
} else if( errno == ENOMEM ) {
UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__,
"SSDP_LIB : RequestHandler:select was unable to "
"allocate memory for internal tables.\n" );
}
shutdown( gSsdpReqSocket, SD_BOTH ); shutdown( gSsdpReqSocket, SD_BOTH );
UpnpCloseSocket( gSsdpReqSocket ); UpnpCloseSocket( gSsdpReqSocket );
free( ReqBuf ); free( ReqBuf );
return UPNP_E_INTERNAL_ERROR; return UPNP_E_INTERNAL_ERROR;
} else if( FD_ISSET( gSsdpReqSocket, &wrSet ) ) { } else if( FD_ISSET( gSsdpReqSocket, &wrSet ) ) {
int NumCopy = 0; int NumCopy = 0;
while( NumCopy < NUM_SSDP_COPY ) { while( NumCopy < NUM_SSDP_COPY ) {
sendto( gSsdpReqSocket, ReqBuf, strlen( ReqBuf ), 0, sendto( gSsdpReqSocket, ReqBuf, strlen( ReqBuf ), 0,
( struct sockaddr * )&destAddr, socklen ); (struct sockaddr *)&destAddr, socklen );
NumCopy++; NumCopy++;
imillisleep( SSDP_PAUSE ); imillisleep( SSDP_PAUSE );
} }
@ -626,3 +615,4 @@ SearchByTarget( IN int Mx,
#endif // EXCLUDE_SSDP #endif // EXCLUDE_SSDP
#endif // INCLUDE_CLIENT_APIS #endif // INCLUDE_CLIENT_APIS

20
upnp/src/ssdp/ssdp_device.c
View File

@ -213,26 +213,27 @@ NewRequestHandler( IN struct sockaddr_in *DestAddr,
IN int NumPacket, IN int NumPacket,
IN char **RqPacket ) IN char **RqPacket )
{ {
int ReplySock, int ReplySock;
socklen = sizeof( struct sockaddr_in ); int socklen = sizeof( struct sockaddr_in );
int NumCopy, int NumCopy;
Index; int Index;
unsigned long replyAddr = inet_addr( LOCAL_HOST ); unsigned long replyAddr = inet_addr( LOCAL_HOST );
int ttl = 4; //a/c to UPNP Spec int ttl = 4; // a/c to UPNP Spec
ReplySock = socket( AF_INET, SOCK_DGRAM, 0 ); ReplySock = socket( AF_INET, SOCK_DGRAM, 0 );
if( ReplySock == UPNP_INVALID_SOCKET ) { if ( ReplySock == -1 ) {
UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__, UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__,
"SSDP_LIB: New Request Handler:" "SSDP_LIB: New Request Handler:"
"Error in socket operation !!!\n" ); "Error in socket(): %s\n",
sys_errlist[errno] );
return UPNP_E_OUTOF_SOCKET; return UPNP_E_OUTOF_SOCKET;
} }
setsockopt( ReplySock, IPPROTO_IP, IP_MULTICAST_IF, setsockopt( ReplySock, IPPROTO_IP, IP_MULTICAST_IF,
( char * )&replyAddr, sizeof( replyAddr ) ); (char *)&replyAddr, sizeof (replyAddr) );
setsockopt( ReplySock, IPPROTO_IP, IP_MULTICAST_TTL, setsockopt( ReplySock, IPPROTO_IP, IP_MULTICAST_TTL,
( char * )&ttl, sizeof( int ) ); (char *)&ttl, sizeof (int) );
for( Index = 0; Index < NumPacket; Index++ ) { for( Index = 0; Index < NumPacket; Index++ ) {
int rc; int rc;
@ -262,6 +263,7 @@ NewRequestHandler( IN struct sockaddr_in *DestAddr,
shutdown( ReplySock, SD_BOTH ); shutdown( ReplySock, SD_BOTH );
UpnpCloseSocket( ReplySock ); UpnpCloseSocket( ReplySock );
return UPNP_E_SUCCESS; return UPNP_E_SUCCESS;
} }

75
upnp/src/ssdp/ssdp_server.c
View File

@ -861,28 +861,34 @@ get_ssdp_sockets( MiniServerSockArray * out )
struct ip_mreq ssdpMcastAddr; struct ip_mreq ssdpMcastAddr;
struct sockaddr_in ssdpAddr; struct sockaddr_in ssdpAddr;
int option = 1; int option = 1;
int ret = 0;
struct in_addr addr; struct in_addr addr;
SOCKET ssdpSock; SOCKET ssdpSock;
#if INCLUDE_CLIENT_APIS #if INCLUDE_CLIENT_APIS
SOCKET ssdpReqSock; SOCKET ssdpReqSock;
if( ( ssdpReqSock = socket( AF_INET, SOCK_DGRAM, 0 ) ) == UPNP_INVALID_SOCKET ) { ssdpReqSock = socket( AF_INET, SOCK_DGRAM, 0 );
if ( ssdpReqSock == -1 ) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
SSDP, __FILE__, __LINE__, SSDP, __FILE__, __LINE__,
"Error in socket operation !!!\n" ); "Error in socket(): %s\n",
sys_errlist[errno] );
return UPNP_E_OUTOF_SOCKET; return UPNP_E_OUTOF_SOCKET;
} }
setsockopt( ssdpReqSock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof( ttl ) ); ret = setsockopt( ssdpReqSock, IPPROTO_IP, IP_MULTICAST_TTL,
&ttl, sizeof (ttl) );
// just do it, regardless if fails or not. // just do it, regardless if fails or not.
Make_Socket_NoBlocking( ssdpReqSock ); Make_Socket_NoBlocking( ssdpReqSock );
gSsdpReqSocket = ssdpReqSock; gSsdpReqSocket = ssdpReqSock;
#endif /* INCLUDE_CLIENT_APIS */ #endif /* INCLUDE_CLIENT_APIS */
if( ( ssdpSock = socket( AF_INET, SOCK_DGRAM, 0 ) ) == UPNP_INVALID_SOCKET ) { ssdpSock = socket( AF_INET, SOCK_DGRAM, 0 );
if ( ssdpSock == -1 ) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
SSDP, __FILE__, __LINE__, SSDP, __FILE__, __LINE__,
"Error in socket operation !!!\n" ); "Error in socket(): %s\n",
sys_errlist[errno] );
CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); ) CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); )
CLIENTONLY( UpnpCloseSocket( ssdpReqSock ); ) CLIENTONLY( UpnpCloseSocket( ssdpReqSock ); )
@ -890,11 +896,13 @@ get_ssdp_sockets( MiniServerSockArray * out )
} }
onOff = 1; onOff = 1;
if( setsockopt( ssdpSock, SOL_SOCKET, SO_REUSEADDR, ret = setsockopt( ssdpSock, SOL_SOCKET, SO_REUSEADDR,
( char * )&onOff, sizeof( onOff ) ) != 0 ) { (char *)&onOff, sizeof(onOff) );
if ( ret == -1) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
SSDP, __FILE__, __LINE__, SSDP, __FILE__, __LINE__,
"Error in set reuse addr !!!\n" ); "Error in setsockopt() SO_REUSEADDR: %s\n",
sys_errlist[errno] );
CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); ) CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); )
CLIENTONLY( UpnpCloseSocket( ssdpReqSock ); ) CLIENTONLY( UpnpCloseSocket( ssdpReqSock ); )
shutdown( ssdpSock, SD_BOTH ); shutdown( ssdpSock, SD_BOTH );
@ -904,11 +912,13 @@ get_ssdp_sockets( MiniServerSockArray * out )
} }
#if defined(__FreeBSD__) || defined(__OSX__) || defined(__APPLE__) #if defined(__FreeBSD__) || defined(__OSX__) || defined(__APPLE__)
if( setsockopt( ssdpSock, SOL_SOCKET, SO_REUSEPORT, ret = setsockopt( ssdpSock, SOL_SOCKET, SO_REUSEPORT,
( char * )&onOff, sizeof( onOff ) ) != 0 ) { (char *)&onOff, sizeof (onOff) );
if ( ret == -1 ) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
SSDP, __FILE__, __LINE__, SSDP, __FILE__, __LINE__,
"Error in set reuse port !!!\n" ); "Error in setsockopt() SO_REUSEPORT: %s\n",
sys_errlist[errno] );
CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); ) CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); )
CLIENTONLY( UpnpCloseSocket( ssdpReqSock ); ) CLIENTONLY( UpnpCloseSocket( ssdpReqSock ); )
shutdown( ssdpSock, SD_BOTH ); shutdown( ssdpSock, SD_BOTH );
@ -918,16 +928,18 @@ get_ssdp_sockets( MiniServerSockArray * out )
} }
#endif /* __FreeBSD__ */ #endif /* __FreeBSD__ */
memset( ( void * )&ssdpAddr, 0, sizeof( struct sockaddr_in ) ); memset( (void *)&ssdpAddr, 0, sizeof( struct sockaddr_in ) );
ssdpAddr.sin_family = AF_INET; ssdpAddr.sin_family = AF_INET;
// ssdpAddr.sin_addr.s_addr = inet_addr(LOCAL_HOST); // ssdpAddr.sin_addr.s_addr = inet_addr(LOCAL_HOST);
ssdpAddr.sin_addr.s_addr = htonl( INADDR_ANY ); ssdpAddr.sin_addr.s_addr = htonl( INADDR_ANY );
ssdpAddr.sin_port = htons( SSDP_PORT ); ssdpAddr.sin_port = htons( SSDP_PORT );
if( bind( ssdpSock, ( struct sockaddr * )&ssdpAddr, ret = bind( ssdpSock, (struct sockaddr *)&ssdpAddr, sizeof (ssdpAddr) );
sizeof( ssdpAddr ) ) != 0 ) { if ( ret == -1 ) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
SSDP, __FILE__, __LINE__, SSDP, __FILE__, __LINE__,
"Error in binding !!!\n" ); "Error in bind(), addr=0x%08X, port=%d: %s\n",
INADDR_ANY, SSDP_PORT,
sys_errlist[errno] );
shutdown( ssdpSock, SD_BOTH ); shutdown( ssdpSock, SD_BOTH );
UpnpCloseSocket( ssdpSock ); UpnpCloseSocket( ssdpSock );
CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); ) CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); )
@ -936,14 +948,16 @@ get_ssdp_sockets( MiniServerSockArray * out )
return UPNP_E_SOCKET_BIND; return UPNP_E_SOCKET_BIND;
} }
memset( ( void * )&ssdpMcastAddr, 0, sizeof( struct ip_mreq ) ); memset( (void *)&ssdpMcastAddr, 0, sizeof (struct ip_mreq) );
ssdpMcastAddr.imr_interface.s_addr = inet_addr( LOCAL_HOST ); ssdpMcastAddr.imr_interface.s_addr = inet_addr( LOCAL_HOST );
ssdpMcastAddr.imr_multiaddr.s_addr = inet_addr( SSDP_IP ); ssdpMcastAddr.imr_multiaddr.s_addr = inet_addr( SSDP_IP );
if( setsockopt( ssdpSock, IPPROTO_IP, IP_ADD_MEMBERSHIP, ret = setsockopt( ssdpSock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
( char * )&ssdpMcastAddr, sizeof( struct ip_mreq ) ) != 0 ) { (char *)&ssdpMcastAddr, sizeof (struct ip_mreq) );
if ( ret == -1 ) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
SSDP, __FILE__, __LINE__, SSDP, __FILE__, __LINE__,
"Error in joining" " multicast group !!!\n" ); "Error in setsockopt() IP_ADD_MEMBERSHIP (join multicast group): %s\n",
sys_errlist[errno] );
shutdown( ssdpSock, SD_BOTH ); shutdown( ssdpSock, SD_BOTH );
CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); ) CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); )
UpnpCloseSocket( ssdpSock ); UpnpCloseSocket( ssdpSock );
@ -953,23 +967,28 @@ get_ssdp_sockets( MiniServerSockArray * out )
} }
/* Set multicast interface. */ /* Set multicast interface. */
memset( ( void * )&addr, 0, sizeof( struct in_addr )); memset( (void *)&addr, 0, sizeof (struct in_addr) );
addr.s_addr = inet_addr(LOCAL_HOST); addr.s_addr = inet_addr(LOCAL_HOST);
if ( setsockopt(ssdpSock, IPPROTO_IP, IP_MULTICAST_IF, ret = setsockopt(ssdpSock, IPPROTO_IP, IP_MULTICAST_IF,
(char *)&addr, sizeof addr) != 0) { (char *)&addr, sizeof addr);
if ( ret == -1 ) {
UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__, UpnpPrintf( UPNP_INFO, SSDP, __FILE__, __LINE__,
"Couldn't set multicast interface.\n" ); "Error in setsockopt() IP_MULTICAST_IF (set multicast interface): %s\n",
sys_errlist[errno] );
/* This is probably not a critical error, so let's continue. */ /* This is probably not a critical error, so let's continue. */
} }
/* result is not checked becuase it will fail in WinMe and Win9x. */ /* result is not checked becuase it will fail in WinMe and Win9x. */
setsockopt( ssdpSock, IPPROTO_IP, ret = setsockopt( ssdpSock, IPPROTO_IP,
IP_MULTICAST_TTL, &ttl, sizeof( ttl ) ); IP_MULTICAST_TTL, &ttl, sizeof (ttl) );
if( setsockopt( ssdpSock, SOL_SOCKET, SO_BROADCAST,
(char *)&option, sizeof(option) ) != 0) { ret = setsockopt( ssdpSock, SOL_SOCKET, SO_BROADCAST,
(char *)&option, sizeof (option) );
if( ret == -1) {
UpnpPrintf( UPNP_CRITICAL, UpnpPrintf( UPNP_CRITICAL,
SSDP, __FILE__, __LINE__, SSDP, __FILE__, __LINE__,
"Error in setting broadcast !!!\n" ); "Error in setsockopt() SO_BROADCAST (set broadcast): %s\n",
sys_errlist[errno] );
shutdown( ssdpSock, SD_BOTH ); shutdown( ssdpSock, SD_BOTH );
CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); ) CLIENTONLY( shutdown( ssdpReqSock, SD_BOTH ); )
UpnpCloseSocket( ssdpSock ); UpnpCloseSocket( ssdpSock );