void* ILibCreateAsyncSocketModule(void *Chain, int initialBufferSize, void(*OnData)(void* socketModule,char* buffer,int *p_beginPointer, int endPointer, void (**InterruptPtr)(void *socketModule, void *user),void **user, int *PAUSE), void(*OnConnect)(void* socketModule, int Connected, void *user),void(*OnDisconnect)(void* socketModule, void *user),void(*OnSendOK)(void *socketModule, void *user))
{
struct AsyncSocketModule *RetVal = (struct AsyncSocketModule*)MALLOC(sizeof(struct AsyncSocketModule));
memset(RetVal,0,sizeof(struct AsyncSocketModule));
RetVal->PreSelect = &ILibAsyncSocket_PreSelect;
RetVal->PostSelect = &ILibAsyncSocket_PostSelect;
RetVal->Destroy = &ILibAsyncSocket_Destroy;
RetVal->IsFree = 1;
RetVal->internalSocket = -1;
RetVal->OnData = OnData;
RetVal->OnConnect = OnConnect;
RetVal->OnDisconnect = OnDisconnect;
RetVal->OnSendOK = OnSendOK;
RetVal->buffer = (char*)MALLOC(initialBufferSize);
RetVal->InitialSize = initialBufferSize;
RetVal->MallocSize = initialBufferSize;
sem_init(&(RetVal->SendLock),0,1);
RetVal->Chain = Chain;
ILibAddToChain(Chain,RetVal);
return((void*)RetVal);
}
/*! \fn ILibCreateAsyncSocketModule(void *Chain, int initialBufferSize, ILibAsyncSocket_OnData OnData, ILibAsyncSocket_OnConnect OnConnect, ILibAsyncSocket_OnDisconnect OnDisconnect,ILibAsyncSocket_OnSendOK OnSendOK)
\brief Creates a new AsyncSocketModule
\param Chain The chain to add this module to. (Chain must <B>not</B> be running)
\param initialBufferSize The initial size of the receive buffer
\param OnData Function Pointer that triggers when Data is received
\param OnConnect Function Pointer that triggers upon successfull connection establishment
\param OnDisconnect Function Pointer that triggers upon disconnect
\param OnSendOK Function Pointer that triggers when pending sends are complete
\returns An ILibAsyncSocket token
*/
ILibAsyncSocket_SocketModule ILibCreateAsyncSocketModule(void *Chain, int initialBufferSize, ILibAsyncSocket_OnData OnData, ILibAsyncSocket_OnConnect OnConnect, ILibAsyncSocket_OnDisconnect OnDisconnect,ILibAsyncSocket_OnSendOK OnSendOK)
{
struct ILibAsyncSocketModule *RetVal = (struct ILibAsyncSocketModule*)malloc(sizeof(struct ILibAsyncSocketModule));
memset(RetVal,0,sizeof(struct ILibAsyncSocketModule));
RetVal->PreSelect = &ILibAsyncSocket_PreSelect;
RetVal->PostSelect = &ILibAsyncSocket_PostSelect;
RetVal->Destroy = &ILibAsyncSocket_Destroy;
RetVal->internalSocket = -1;
RetVal->OnData = OnData;
RetVal->OnConnect = OnConnect;
RetVal->OnDisconnect = OnDisconnect;
RetVal->OnSendOK = OnSendOK;
RetVal->buffer = (char*)malloc(initialBufferSize);
RetVal->InitialSize = initialBufferSize;
RetVal->MallocSize = initialBufferSize;
RetVal->LifeTime = ILibCreateLifeTime(Chain);
RetVal->TimeoutTimer = ILibCreateLifeTime(Chain);
sem_init(&(RetVal->SendLock),0,1);
RetVal->Chain = Chain;
ILibAddToChain(Chain,RetVal);
return((void*)RetVal);
}
void *ILibWebServer_Create(void *Chain, int MaxConnections, int PortNumber,ILibWebServer_Session_OnSession OnSession, void *User)
{
struct ILibWebServer_StateModule *RetVal = (struct ILibWebServer_StateModule*)MALLOC(sizeof(struct ILibWebServer_StateModule));
memset(RetVal,0,sizeof(struct ILibWebServer_StateModule));
RetVal->Destroy = &ILibWebServer_Destroy;
RetVal->Chain = Chain;
RetVal->OnSession = OnSession;
RetVal->ServerSocket = ILibCreateAsyncServerSocketModule(
Chain,
MaxConnections,
PortNumber,
INITIAL_BUFFER_SIZE,
&ILibWebServer_OnConnect, // OnConnect
&ILibWebServer_OnDisconnect, // OnDisconnect
&ILibWebServer_OnReceive, // OnReceive
&ILibWebServer_OnInterrupt, // OnInterrupt
&ILibWebServer_OnSendOK // OnSendOK
);
ILibAsyncServerSocket_SetTag(RetVal->ServerSocket,RetVal);
RetVal->LifeTime = ILibCreateLifeTime(Chain);
RetVal->User = User;
ILibAddToChain(Chain,RetVal);
return(RetVal);
}
void* ILibCreateMiniWebServer(void *chain,int MaxConnections,void (*OnReceivePtr) (void *ReaderObject, struct packetheader *header, char* buffer, int *BeginPointer, int BufferSize, int done, void* user),void* user)
{
struct MiniWebServerObject *RetVal = (struct MiniWebServerObject*)MALLOC(sizeof(struct MiniWebServerObject));
int i;
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD( 1, 1 );
if (WSAStartup( wVersionRequested, &wsaData ) != 0) {exit(1);}
RetVal->MaxConnections = MaxConnections;
RetVal->Readers = (struct ILibMWSHTTPReaderObject*)MALLOC(MaxConnections*sizeof(struct ILibMWSHTTPReaderObject));
RetVal->Terminate = 0;
RetVal->PreSelect = &ILibMiniWebServerModule_PreSelect;
RetVal->PostSelect = &ILibMiniWebServerModule_PostSelect;
RetVal->Destroy = &ILibMiniWebServerModule_Destroy;
memset(RetVal->Readers,0,MaxConnections*sizeof(struct ILibMWSHTTPReaderObject));
for(i=0;i<MaxConnections;++i)
{
RetVal->Readers[i].ClientSocket = ~0;
RetVal->Readers[i].FunctionCallback = OnReceivePtr;
RetVal->Readers[i].Parent = RetVal;
RetVal->Readers[i].user = user;
}
RetVal->PortNumber = 0;
RetVal->TimerObject = ILibCreateLifeTime(chain);
ILibAddToChain(chain,RetVal);
return((void*)RetVal);
}
// PUBLIC - Creates a Remote I/O Client Device Stack. This stack does not include the UPnP stack
// one must be build into the project with the "Upnp" prefix using Intel Device Builder. All
// callbacks must be externs. Remote I/O can be a root or embedded device.
void* CreateRemoteIO(void* Chain, void* UpnpStack)
{
if (RemoteIO_RefCounter == 0) sem_init(&RemoteIOLock,0,1);
RemoteIO_RefCounter++;
RIO = (struct RIODataObject*)RIO_MALLOC(sizeof(struct RIODataObject));
memset(RIO,0,sizeof(struct RIODataObject));
// Start the new Remote IO session
RIO->Destroy = &RemoteIODestroyChain;
RIO->Session = ILibCreateAsyncSocketModule(650000,&OnRemoteIODataSink,&OnRemoteIOConnectSink,&OnRemoteIODisconnectSink);
#ifdef _WIN32_WCE
CreateThread(NULL,0,RemoteIOSessionThreadEntry,NULL,0,NULL);
#elif WIN32
CreateThread(NULL,0,RemoteIOSessionThreadEntry,NULL,0,NULL);
#elif _POSIX
pthread_create(&RIOWorkerThread,NULL,RemoteIOSessionThreadEntry,NULL);
#endif
RIO->RIOmicroStack = UpnpStack;
/* All evented state variables MUST be initialized before UPnPStart is called. */
UpnpSetState_RemoteIO_PeerConnection(RIO->RIOmicroStack,"");
UpnpSetState_ChannelManager_RegisteredChannelList(RIO->RIOmicroStack,"");
RIO->RIOLifeTime = ILibCreateLifeTime(Chain);
//ILibAddToChain(Chain,RIO->RIOLifeTime);
ILibAddToChain(Chain,RIO);
return RIO;
}
/* see header file */
void *MSL_CreateMediaServer(void *chain, void *upnpStack, void* lifetimeMonitor, const char *sinkProtocolInfo, const char *sourceProtocolInfo, const char *sortFields, const char *searchFields)
{
struct MSL_MediaServerObject *mslObj;
int size;
mslObj = NULL;
if (MSL_TheMslObj == NULL)
{
mslObj = MSL_TheMslObj = (struct MSL_MediaServerObject*) MSL_MALLOC(sizeof(struct MSL_MediaServerObject));
memset(mslObj, 0, sizeof(struct MSL_MediaServerObject));
mslObj->UpnpStack = upnpStack;
mslObj->Destroy = MSL_DestroyMediaServer;
mslObj->LifeTimeMonitor = lifetimeMonitor;
sem_init(&(mslObj->Lock), 0, 1);
UpnpSetState_ContentDirectory_SystemUpdateID(upnpStack, mslObj->SystemUpdateID);
UpnpSetState_ContentDirectory_ContainerUpdateIDs(upnpStack, "");
/* set initial sourceProtocolInfo */
size = (int) strlen(sourceProtocolInfo)+1;
mslObj->SourceProtocolInfo = (char*) malloc(size);
memcpy(mslObj->SourceProtocolInfo, sourceProtocolInfo, size);
UpnpSetState_ConnectionManager_SourceProtocolInfo(upnpStack, mslObj->SourceProtocolInfo);
/* set initial sinkProtocolInfo */
size = (int) strlen(sinkProtocolInfo)+1;
mslObj->SinkProtocolInfo = (char*) malloc(size);
memcpy(mslObj->SinkProtocolInfo, sinkProtocolInfo, size);
UpnpSetState_ConnectionManager_SinkProtocolInfo(upnpStack,mslObj->SinkProtocolInfo);
/* no connections */
UpnpSetState_ConnectionManager_CurrentConnectionIDs(upnpStack, "");
/* set sort capabilities */
size = (int) strlen(sortFields)+1;
MSL_TheMslObj->SortCapabilitiesString = (char*) MSL_MALLOC(size);
memcpy(MSL_TheMslObj->SortCapabilitiesString , sortFields, size);
/* set search cabilities */
size = (int) strlen(searchFields)+1;
MSL_TheMslObj->SearchCapabilitiesString = (char*) MSL_MALLOC(size);
memcpy(MSL_TheMslObj->SearchCapabilitiesString, searchFields, size);
ILibAddToChain(chain, mslObj);
}
return mslObj;
}
ILibWrapper_WebRTC_ConnectionFactory ILibWrapper_WebRTC_ConnectionFactory_CreateConnectionFactory(void* chain, unsigned short localPort)
{
ILibWrapper_WebRTC_ConnectionFactoryStruct *retVal = (ILibWrapper_WebRTC_ConnectionFactoryStruct*)malloc(sizeof(ILibWrapper_WebRTC_ConnectionFactoryStruct));
if(retVal==NULL){ILIBCRITICALEXIT(254);}
memset(retVal, 0, sizeof(ILibWrapper_WebRTC_ConnectionFactoryStruct));
ILibAddToChain(chain, retVal);
retVal->Destroy = &ILibWrapper_WebRTC_ConnectionFactory_OnDestroy;
ILibWrapper_WebRTC_InitializeCrypto(retVal);
retVal->mStunModule = ILibStunClient_Start(chain, localPort, &ILibWrapper_WebRTC_OnStunResult);
ILibStunClient_SetOptions(retVal->mStunModule, retVal->ctx, retVal->tlsServerCertThumbprint);
ILibSCTP_SetCallbacks(retVal->mStunModule, &ILibWrapper_WebRTC_OnConnectSink, &ILibWrapper_WebRTC_OnDataSink, &ILibWrapper_WebRTC_OnSendOKSink);
ILibWebRTC_SetCallbacks(retVal->mStunModule, &ILibWrapper_WebRTC_OnDataChannel, &ILibWrapper_WebRTC_OnDataChannelClosed, &ILibWrapper_WebRTC_OnDataChannelAck, &ILibWrapper_WebRTC_OnOfferUpdated);
retVal->Connections = ILibSparseArray_Create(ILibWrapper_WebRTC_ConnectionFactory_ConnectionBucketSize, &ILibWrapper_WebRTC_ConnectionFactory_Bucketizer);
retVal->mChain = chain;
return(retVal);
}
void* ILibCreateSSDPClientModule(void *chain, char* DeviceURN, int DeviceURNLength, void (*CallbackPtr)(void *sender, char* UDN, int Alive, char* LocationURL, int Timeout, UPnPSSDP_MESSAGE m,void *user),void *user)
{
int i;
struct SSDPClientModule *RetVal = (struct SSDPClientModule*)malloc(sizeof(struct SSDPClientModule));
unsigned char TTL = 4;
struct parser_result *pr;
RetVal->Destroy = &ILibSSDPClientModule_Destroy;
RetVal->PreSelect = &ILibSSDPClientModule_PreSelect;
RetVal->PostSelect = NULL;
RetVal->Reserved = user;
RetVal->Terminate = 0;
RetVal->FunctionCallback = CallbackPtr;
RetVal->DeviceURN = (char*)malloc(DeviceURNLength+1);
memcpy(RetVal->DeviceURN,DeviceURN,DeviceURNLength);
RetVal->DeviceURN[DeviceURNLength] = '\0';
RetVal->DeviceURNLength = DeviceURNLength;
// Populate the Prefix portion of the URN, for matching purposes
RetVal->DeviceURN_Prefix = RetVal->DeviceURN;
pr = ILibParseString(RetVal->DeviceURN,0,RetVal->DeviceURNLength,":",1);
RetVal->DeviceURN_PrefixLength = (int)((pr->LastResult->data)-(RetVal->DeviceURN));
pr->LastResult->data[pr->LastResult->datalength]=0;
RetVal->BaseDeviceVersionNumber = atoi(pr->LastResult->data);
ILibDestructParserResults(pr);
RetVal->IPAddress=NULL;
RetVal->SSDPListenSocket = ILibAsyncUDPSocket_Create(chain, 4096, 0, 1900, ILibAsyncUDPSocket_Reuse_SHARED, ILibSSDPClient_OnData , NULL, RetVal);
RetVal->MSEARCH_Response_Socket = ILibAsyncUDPSocket_Create(chain, 4096, 0, 0, ILibAsyncUDPSocket_Reuse_EXCLUSIVE, ILibSSDPClient_OnData , NULL, RetVal);
ILibAddToChain(chain,RetVal);
ILibAsyncUDPSocket_SetMulticastTTL(RetVal->MSEARCH_Response_Socket, TTL);
return(RetVal);
}
ILibAsyncServerSocket_ServerModule ILibCreateAsyncServerSocketModule(void *Chain, int MaxConnections, int PortNumber, int initialBufferSize, ILibAsyncServerSocket_OnConnect OnConnect,ILibAsyncServerSocket_OnDisconnect OnDisconnect,ILibAsyncServerSocket_OnReceive OnReceive,ILibAsyncServerSocket_OnInterrupt OnInterrupt, ILibAsyncServerSocket_OnSendOK OnSendOK)
{
struct ILibAsyncServerSocketModule * RetVal;
int i;
// Instantiate a new AsyncServer module
RetVal = (struct ILibAsyncServerSocketModule*)malloc(sizeof(struct ILibAsyncServerSocketModule));
memset(RetVal,0,sizeof(struct ILibAsyncServerSocketModule));
RetVal->PreSelect = &ILibAsyncServerSocket_PreSelect;
RetVal->PostSelect = &ILibAsyncServerSocket_PostSelect;
RetVal->Destroy = &ILibAsyncServerSocket_Destroy;
RetVal->Chain = Chain;
RetVal->OnConnect = OnConnect;
RetVal->OnDisconnect = OnDisconnect;
RetVal->OnInterrupt = OnInterrupt;
RetVal->OnSendOK = OnSendOK;
RetVal->OnReceive = OnReceive;
RetVal->MaxConnection = MaxConnections;
RetVal->AsyncSockets = (void**)malloc(MaxConnections * sizeof(void*));
RetVal->portNumber = PortNumber;
// Create our socket pool
for (i = 0; i < MaxConnections; ++i) {
RetVal->AsyncSockets[i] = ILibCreateAsyncSocketModule(Chain, initialBufferSize, &ILibAsyncServerSocket_OnData, NULL, &ILibAsyncServerSocket_OnDisconnectSink, &ILibAsyncServerSocket_OnSendOKSink);
// We want to know about any buffer reallocations, because anything above us may want to know
ILibAsyncSocket_SetReAllocateNotificationCallback(RetVal->AsyncSockets[i], &ILibAsyncServerSocket_OnBufferReAllocated);
}
ILibAddToChain(Chain,RetVal);
// Get our listening socket
#if defined(WIN32) || defined(_WIN32_WCE)
RetVal->portNumber = ILibGetStreamSocket(htonl(INADDR_ANY),RetVal->portNumber,(HANDLE*)&(RetVal->ListenSocket));
#else
RetVal->portNumber = ILibGetStreamSocket(htonl(INADDR_ANY),RetVal->portNumber,&(RetVal->ListenSocket));
#endif
return(RetVal);
}
void *ILibCreateAsyncServerSocketModule(void *Chain, int MaxConnections, int PortNumber, int initialBufferSize, void (*OnConnect)(void *AsyncServerSocketModule, void *ConnectionToken,void **user),void (*OnDisconnect)(void *AsyncServerSocketModule, void *ConnectionToken, void *user),void (*OnReceive)(void *AsyncServerSocketModule, void *ConnectionToken,char* buffer,int *p_beginPointer, int endPointer,void (**OnInterrupt)(void *AsyncServerSocketMoudle, void *ConnectionToken, void *user), void **user, int *PAUSE),void (*OnInterrupt)(void *AsyncServerSocketModule, void *ConnectionToken, void *user), void (*OnSendOK)(void *AsyncServerSocketModule, void *ConnectionToken, void *user))
{
struct AsyncServerSocketModule *RetVal;
int i;
RetVal = (struct AsyncServerSocketModule*)MALLOC(sizeof(struct AsyncServerSocketModule));
RetVal->PreSelect = &ILibAsyncServerSocket_PreSelect;
RetVal->PostSelect = &ILibAsyncServerSocket_PostSelect;
RetVal->Destroy = &ILibAsyncServerSocket_Destroy;
RetVal->Chain = Chain;
RetVal->OnConnect = OnConnect;
RetVal->OnDisconnect = OnDisconnect;
RetVal->OnInterrupt = OnInterrupt;
RetVal->OnSendOK = OnSendOK;
RetVal->OnReceive = OnReceive;
RetVal->MaxConnection = MaxConnections;
RetVal->AsyncSockets = (void**)MALLOC(MaxConnections*sizeof(void*));
RetVal->portNumber = PortNumber;
RetVal->Tag = NULL;
RetVal->listening = 0;
for(i=0;i<MaxConnections;++i)
{
RetVal->AsyncSockets[i] = ILibCreateAsyncSocketModule(Chain,initialBufferSize,&ILibAsyncServerSocket_OnData,NULL,&ILibAsyncServerSocket_OnDisconnect, &ILibAsyncServerSocket_OnSendOK);
//RetVal->AsyncSockets[i] = ILibCreateAsyncSocketModule(Chain,initialBufferSize,&ILibAsyncServerSocket_OnData,NULL,&ILibAsyncServerSocket_OnDisconnect, &ILibAsyncServerSocket_OnSendOK);
}
ILibAddToChain(Chain,RetVal);
#ifdef WINSOCK2
RetVal->portNumber = ILibGetStreamSocket(htonl(INADDR_ANY),RetVal->portNumber,(HANDLE*)&(RetVal->ListenSocket));
#else
RetVal->portNumber = ILibGetStreamSocket(htonl(INADDR_ANY),RetVal->portNumber,&(RetVal->ListenSocket));
#endif
return(RetVal);
}
void* ILibCreateSSDPClientModule(void *chain, char* DeviceURN, int DeviceURNLength, void (*CallbackPtr)(void *sender, char* UDN, int Alive, char* LocationURL, int Timeout, void *user),void *user)
{
int i;
struct sockaddr_in addr;
struct sockaddr_in dest_addr;
struct SSDPClientModule *RetVal = (struct SSDPClientModule*)MALLOC(sizeof(struct SSDPClientModule));
int ra = 1;
struct ip_mreq mreq;
char* buffer;
int bufferlength;
char* _DeviceURN;
struct in_addr interface_addr;
unsigned char TTL = 4;
memset((char *)&addr, 0, sizeof(addr));
memset((char *)&interface_addr, 0, sizeof(interface_addr));
memset((char *)&(addr), 0, sizeof(dest_addr));
dest_addr.sin_family = AF_INET;
dest_addr.sin_addr.s_addr = inet_addr(UPNP_GROUP);
dest_addr.sin_port = htons(UPNP_PORT);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(UPNP_PORT);
RetVal->Destroy = &ILibSSDPClientModule_Destroy;
RetVal->PreSelect = &ILibSSDPClientModule_PreSelect;
RetVal->PostSelect = &ILibSSDPClientModule_PostSelect;
RetVal->Reserved = user;
RetVal->Terminate = 0;
RetVal->FunctionCallback = CallbackPtr;
RetVal->DeviceURN = (char*)MALLOC(DeviceURNLength+1);
memcpy(RetVal->DeviceURN,DeviceURN,DeviceURNLength);
RetVal->DeviceURN[DeviceURNLength] = '\0';
RetVal->DeviceURNLength = DeviceURNLength;
RetVal->NumIPAddress = ILibGetLocalIPAddressList(&(RetVal->IPAddress));
RetVal->SSDPListenSocket = socket(AF_INET, SOCK_DGRAM, 0);
ILibGetDGramSocket(htonl(INADDR_ANY), &(RetVal->MSEARCH_Response_Socket));
if (setsockopt(RetVal->MSEARCH_Response_Socket, IPPROTO_IP, IP_MULTICAST_TTL,(char*)&TTL, sizeof(TTL)) < 0)
{
/* Ignore this case */
}
if (setsockopt(RetVal->SSDPListenSocket, SOL_SOCKET, SO_REUSEADDR,(char*)&ra, sizeof(ra)) < 0)
{
DEBUGSTATEMENT(printf("Setting SockOpt SO_REUSEADDR failed\r\n"));
exit(1);
}
if (bind(RetVal->SSDPListenSocket, (struct sockaddr *) &(addr), sizeof(addr)) < 0)
{
printf("SSDPListenSocket bind");
exit(1);
}
for(i=0;i<RetVal->NumIPAddress;++i)
{
mreq.imr_multiaddr.s_addr = inet_addr(UPNP_GROUP);
mreq.imr_interface.s_addr = RetVal->IPAddress[i];
if (setsockopt(RetVal->SSDPListenSocket, IPPROTO_IP, IP_ADD_MEMBERSHIP,(char*)&mreq, sizeof(mreq)) < 0)
{
printf("SSDPListenSocket setsockopt mreq");
exit(1);
}
}
ILibAddToChain(chain,RetVal);
_DeviceURN = (char*)MALLOC(DeviceURNLength+1);
memcpy(_DeviceURN,DeviceURN,DeviceURNLength);
_DeviceURN[DeviceURNLength] = '\0';
buffer = (char*)MALLOC(105+DeviceURNLength);
bufferlength = sprintf(buffer,"M-SEARCH * HTTP/1.1\r\nMX: 3\r\nST: %s\r\nHOST: 239.255.255.250:1900\r\nMAN: \"ssdp:discover\"\r\n\r\n",_DeviceURN);
for(i=0;i<RetVal->NumIPAddress;++i)
{
interface_addr.s_addr = RetVal->IPAddress[i];
/* This is commented out, because setting MULTICAST_IF does not work on PPC2002 because of bug in kernal */
//if (setsockopt(RetVal->MSEARCH_Response_Socket, IPPROTO_IP, IP_MULTICAST_IF,(char*)&interface_addr, sizeof(interface_addr)) == 0)
//{
sendto(RetVal->MSEARCH_Response_Socket, buffer, bufferlength, 0, (struct sockaddr *) &dest_addr, sizeof(dest_addr));
//}
}
FREE(_DeviceURN);
FREE(buffer);
return(RetVal);
}
void* FSE_InitFSEState(void *chain, const char *rootDir, const char* virtualDir)
{
struct FSE_State* fse = (struct FSE_State*) malloc (sizeof(struct FSE_State));
int i;
char* tempPtr;
memset(fse, 0, sizeof(struct FSE_State));
fse->Destroy = FSE_DestroyFSE;
fse->RootPath = (char*)malloc((int)strlen(rootDir) + 2); /* add 2 extra bytes for delimiter and null */
strcpy(fse->RootPath, rootDir);
fse->RootPathLen = (int) strlen(fse->RootPath);
fse->VirtualDirPath = (char*)malloc((int)strlen(virtualDir) + 2);
strcpy(fse->VirtualDirPath, virtualDir);
fse->VirtualDirPathLen = (int) strlen(fse->VirtualDirPath);
fse->DirDelimiter = NULL;
/*
* Set fse->DirDelimiter
*/
for (i = 0; i < fse->RootPathLen; i++)
{
if (FSE_BACKSLASH_CHR == fse->RootPath[i])
{
fse->DirDelimiter = FSE_BACKSLASH_STR;
fse->DirDelimiterChr = FSE_BACKSLASH_CHR;
fse->BadDirDelimiterChr = FSE_FORSLASH_CHR;
}
else if (FSE_FORSLASH_CHR == fse->RootPath[i])
{
fse->DirDelimiter = FSE_FORSLASH_STR;
fse->DirDelimiterChr = FSE_FORSLASH_CHR;
fse->BadDirDelimiterChr = FSE_BACKSLASH_CHR;
}
}
if (fse->DirDelimiter == NULL)
{
fse->DirDelimiter = FSE_FORSLASH_STR;
fse->DirDelimiterChr = FSE_FORSLASH_CHR;
fse->BadDirDelimiterChr = FSE_BACKSLASH_CHR;
}
#ifdef WIN32
fse->DirDelimiter = FSE_BACKSLASH_STR;
fse->DirDelimiterChr = FSE_BACKSLASH_CHR;
fse->BadDirDelimiterChr = FSE_FORSLASH_CHR;
#endif
/*
* Ensure all directory delimiters are consistent.
*/
tempPtr = ILibString_Replace(fse->RootPath, fse->RootPathLen, &fse->BadDirDelimiterChr, 1, &fse->DirDelimiterChr, 1);
strcpy(fse->RootPath, tempPtr);
free(tempPtr);
/*
* Appropriately acquire the root path with a trailing delimiter.
*/
if (fse->RootPath[fse->RootPathLen-1] != fse->DirDelimiterChr)
{
/* no traling delimiter, so go ahead and add one */
fse->RootPath[fse->RootPathLen] = fse->DirDelimiterChr;
fse->RootPathLen++;
fse->RootPath[fse->RootPathLen] = '\0';
}
ILibAddToChain(chain, fse);
return fse;
}
/*! \fn ILibCreateAsyncServerSocketModule(void *Chain, int MaxConnections, int PortNumber, int initialBufferSize, ILibAsyncServerSocket_OnConnect OnConnect,ILibAsyncServerSocket_OnDisconnect OnDisconnect,ILibAsyncServerSocket_OnReceive OnReceive,ILibAsyncServerSocket_OnInterrupt OnInterrupt, ILibAsyncServerSocket_OnSendOK OnSendOK)
\brief Instantiates a new ILibAsyncServerSocket
\param Chain The chain to add this module to. (Chain must <B>not</B> be running)
\param MaxConnections The max number of simultaneous connections that will be allowed
\param PortNumber The port number to bind to. 0 will select a random port
\param initialBufferSize The initial size of the receive buffer
\param OnConnect Function Pointer that triggers when a connection is established
\param OnDisconnect Function Pointer that triggers when a connection is closed
\param OnReceive Function Pointer that triggers when data is received
\param OnInterrupt Function Pointer that triggers when connection interrupted
\param OnSendOK Function Pointer that triggers when pending sends are complete
\returns An ILibAsyncServerSocket module
*/
ILibAsyncServerSocket_ServerModule ILibCreateAsyncServerSocketModule(void *Chain, int MaxConnections, unsigned short PortNumber, int initialBufferSize, int loopbackFlag, ILibAsyncServerSocket_OnConnect OnConnect, ILibAsyncServerSocket_OnDisconnect OnDisconnect, ILibAsyncServerSocket_OnReceive OnReceive, ILibAsyncServerSocket_OnInterrupt OnInterrupt, ILibAsyncServerSocket_OnSendOK OnSendOK)
{
int i;
int ra = 1;
int off = 0;
int receivingAddressLength = sizeof(struct sockaddr_in6);
struct sockaddr_in6 localif;
struct sockaddr_in6 localAddress;
struct ILibAsyncServerSocketModule *RetVal;
memset(&localif, 0, sizeof(struct sockaddr_in6));
if (loopbackFlag != 2 && ILibDetectIPv6Support())
{
// Setup the IPv6 any or loopback address, this socket will also work for IPv4 traffic on IPv6 stack
localif.sin6_family = AF_INET6;
localif.sin6_addr = (loopbackFlag != 0?in6addr_loopback:in6addr_any);
localif.sin6_port = htons(PortNumber);
}
else
{
// IPv4-only detected
localif.sin6_family = AF_INET;
#ifdef WINSOCK2
((struct sockaddr_in*)&localif)->sin_addr.S_un.S_addr = htonl((loopbackFlag != 0?INADDR_LOOPBACK:INADDR_ANY));
#else
((struct sockaddr_in*)&localif)->sin_addr.s_addr = htonl((loopbackFlag != 0?INADDR_LOOPBACK:INADDR_ANY));
#endif
((struct sockaddr_in*)&localif)->sin_port = htons(PortNumber);
}
// Instantiate a new AsyncServer module
RetVal = (struct ILibAsyncServerSocketModule*)malloc(sizeof(struct ILibAsyncServerSocketModule));
if (RetVal == NULL) { ILIBMARKPOSITION(253); return NULL; }
memset(RetVal, 0, sizeof(struct ILibAsyncServerSocketModule));
RetVal->PreSelect = &ILibAsyncServerSocket_PreSelect;
RetVal->PostSelect = &ILibAsyncServerSocket_PostSelect;
RetVal->Destroy = &ILibAsyncServerSocket_Destroy;
RetVal->Chain = Chain;
RetVal->OnConnect = OnConnect;
RetVal->OnDisconnect = OnDisconnect;
RetVal->OnInterrupt = OnInterrupt;
RetVal->OnSendOK = OnSendOK;
RetVal->OnReceive = OnReceive;
RetVal->MaxConnection = MaxConnections;
RetVal->AsyncSockets = (void**)malloc(MaxConnections * sizeof(void*));
if (RetVal->AsyncSockets == NULL) { free(RetVal); ILIBMARKPOSITION(253); return NULL; }
RetVal->portNumber = (unsigned short)PortNumber;
// Get our listening socket
if ((RetVal->ListenSocket = socket(localif.sin6_family, SOCK_STREAM, IPPROTO_TCP)) == -1) { free(RetVal->AsyncSockets); free(RetVal); return 0; }
// Setup the IPv6 & IPv4 support on same socket
if (localif.sin6_family == AF_INET6) if (setsockopt(RetVal->ListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&off, sizeof(off)) != 0) ILIBCRITICALERREXIT(253);
#if defined(WIN32)
// On Windows. Lets make sure no one else can bind to this addr/port. This stops socket hijacking (not a problem on Linux).
if (setsockopt(RetVal->ListenSocket, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&ra, sizeof(ra)) != 0) ILIBCRITICALERREXIT(253);
#else
// On Linux. Setting the re-use on a TCP socket allows reuse of the socket even in timeout state. Allows for fast stop/start (Not a problem on Windows).
if (setsockopt(RetVal->ListenSocket, SOL_SOCKET, SO_REUSEADDR, (char*)&ra, sizeof(ra)) != 0) ILIBCRITICALERREXIT(253);
#endif
// Bind the socket
#if defined(WIN32)
if (bind(RetVal->ListenSocket, (struct sockaddr*)&localif, INET_SOCKADDR_LENGTH(localif.sin6_family)) != 0) { closesocket(RetVal->ListenSocket); free(RetVal->AsyncSockets); free(RetVal); return 0; }
#else
if (bind(RetVal->ListenSocket, (struct sockaddr*)&localif, INET_SOCKADDR_LENGTH(localif.sin6_family)) != 0) { close(RetVal->ListenSocket); free(RetVal->AsyncSockets); free(RetVal); return 0; }
#endif
// Fetch the local port number
#if defined(WINSOCK2)
getsockname(RetVal->ListenSocket, (struct sockaddr*)&localAddress, (int*)&receivingAddressLength);
#else
getsockname(RetVal->ListenSocket, (struct sockaddr*)&localAddress, (socklen_t*)&receivingAddressLength);
#endif
if (localAddress.sin6_family == AF_INET6) RetVal->portNumber = ntohs(localAddress.sin6_port); else RetVal->portNumber = ntohs(((struct sockaddr_in*)&localAddress)->sin_port);
// Create our socket pool
for(i = 0; i < MaxConnections; ++i)
{
RetVal->AsyncSockets[i] = ILibCreateAsyncSocketModule(Chain, initialBufferSize, &ILibAsyncServerSocket_OnData, &ILibAsyncServerSocket_OnConnectSink, &ILibAsyncServerSocket_OnDisconnectSink, &ILibAsyncServerSocket_OnSendOKSink);
//
// We want to know about any buffer reallocations, because anything above us may want to know
//
ILibAsyncSocket_SetReAllocateNotificationCallback(RetVal->AsyncSockets[i], &ILibAsyncServerSocket_OnBufferReAllocated);
}
ILibAddToChain(Chain,RetVal);
return(RetVal);
}
APW APW_Method_Create(void * chain, ILibThreadPool thread_pool, unsigned short port, char* friendly_name, char * mac_addr, char * pwd)
{
APW apw = NULL;
APWInternalState inner_state = NULL;
apw = (APW)MALLOC(sizeof(struct _APW));
if (apw == NULL) {
return NULL;
}
inner_state = (APWInternalState)MALLOC(sizeof(struct _APWInternalState));
if (inner_state == NULL) {
FREE(apw);
return NULL;
}
inner_state->chain = chain;
inner_state->airplay_token = AirplayCreate(chain, port, friendly_name, mac_addr, pwd);
if (inner_state->airplay_token == NULL) { // 发现服务创建失败
FREE(apw);
FREE(inner_state);
return NULL;
}
AirplaySetTag(inner_state->airplay_token, (void *)apw);
inner_state->apw_monitor = ILibCreateLifeTime(inner_state->chain);
ILibLifeTime_AddEx(inner_state->apw_monitor, apw, 0, &apw_last_change_timer_event, NULL);
sem_init(&inner_state->resource_lock, 0, 1);
apw->ILib1 = NULL;
apw->ILib2 = NULL;
apw->ILib3 = apw_destroy_from_chain;
apw->internal_state = (void *)inner_state;
apw->thread_pool = thread_pool;
AirplayCallbackGetCurrentTransportActions = (AirplayHandlerGetCurrentTransportActions )&APW_GetCurrentTransportActions;
AirplayCallbackGetDeviceCapabilities = (AirplayHandlerGetDeviceCapabilities )&APW_GetDeviceCapabilities;
AirplayCallbackGetMediaInfo = (AirplayHandlerGetMediaInfo )&APW_GetMediaInfo;
AirplayCallbackGetPositionInfo = (AirplayHandlerGetPositionInfo )&APW_GetPositionInfo;
AirplayCallbackGetTransportInfo = (AirplayHandlerGetTransportInfo )&APW_GetTransportInfo;
AirplayCallbackGetTransportSettings = (AirplayHandlerGetTransportSettings )&APW_GetTransportSettings;
AirplayCallbackNext = (AirplayHandlerNext )&APW_Next;
AirplayCallbackPause = (AirplayHandlerPause )&APW_Pause;
AirplayCallbackPlay = (AirplayHandlerPlay )&APW_Play;
AirplayCallbackPrevious = (AirplayHandlerPrevious )&APW_Previous;
AirplayCallbackSeek = (AirplayHandlerSeek )&APW_Seek;
AirplayCallbackSetAVTransportURI = (AirplayHandlerSetAVTransportURI )&APW_SetAVTransportURI;
AirplayCallbackSetPlayMode = (AirplayHandlerSetPlayMode )&APW_SetPlayMode;
AirplayCallbackStop = (AirplayHandlerStop )&APW_Stop;
AirplayCallbackGetCurrentConnectionIDs = (AirplayHandlerGetCurrentConnectionIDs )&APW_GetCurrentConnectionIDs;
AirplayCallbackGetCurrentConnectionInfo = (AirplayHandlerGetCurrentConnectionInfo )&APW_GetCurrentConnectionInfo;
AirplayCallbackGetProtocolInfo = (AirplayHandlerGetProtocolInfo )&APW_GetProtocolInfo;
AirplayCallbackListPresets = (AirplayHandlerListPresets )&APW_ListPresets;
AirplayCallbackSelectPreset = (AirplayHandlerSelectPreset )&APW_SelectPreset;
AirplayCallbackGetBrightness = (AirplayHandlerGetBrightness )&APW_GetBrightness;
AirplayCallbackGetContrast = (AirplayHandlerGetContrast )&APW_GetContrast;
AirplayCallbackSetBrightness = (AirplayHandlerSetBrightness )&APW_SetBrightness;
AirplayCallbackSetContrast = (AirplayHandlerSetContrast )&APW_SetContrast;
AirplayCallbackGetMute = (AirplayHandlerGetMute )&APW_GetMute;
AirplayCallbackGetVolume = (AirplayHandlerGetVolume )&APW_GetVolume;
AirplayCallbackSetMute = (AirplayHandlerSetMute )&APW_SetMute;
AirplayCallbackSetVolume = (AirplayHandlerSetVolume )&APW_SetVolume;
AirplayCallbackGetPlayStatus = (AirplayGetPlayStatus )&APW_GetStatus;
ILibAddToChain(chain, apw);
return apw;
}
