CgDictionaryElement *cg_dictionary_getelement(CgDictionary *dir, char *key)
{
CgDictionaryElement *dirElem;
char *dirElemKey;
cg_log_debug_l4("Entering...\n");
if (NULL == dir || cg_strlen(key) <= 0 )
return NULL;
for (dirElem = cg_dictionary_gets(dir); dirElem != NULL; dirElem = cg_dictionary_element_next(dirElem)) {
dirElemKey = cg_dictionary_element_getkey(dirElem);
if (cg_strlen(dirElemKey) <= 0)
continue;
if (cg_streq(dirElemKey, key) == TRUE)
return dirElem;
}
cg_log_debug_l4("Leaving...\n");
return NULL;
}
CgUpnpArgument *cg_upnp_argumentlist_get(CgUpnpArgumentList *argList, char *name)
{
CgUpnpArgument *arg;
char *argName;
cg_log_debug_l4("Entering...\n");
if (name == NULL)
return NULL;
for (arg = cg_upnp_argumentlist_gets(argList); arg != NULL; arg = cg_upnp_argument_next(arg)) {
argName = cg_upnp_argument_getname(arg);
if (argName == NULL)
continue;
if (cg_strcasecmp(argName, name) == 0)
return arg;
}
return NULL;
cg_log_debug_l4("Leaving...\n");
}
static void cg_http_server_thread(CgThread *thread)
{
CgHttpServer *httpServer;
CgThread *httpClientThread;
CgHttpServerClientData *clientData;
CgSocket *serverSock;
CgSocket *clientSock;
cg_log_debug_l4("Entering...\n");
httpServer = (CgHttpServer *)cg_thread_getuserdata(thread);
if (cg_http_server_isopened(httpServer) == FALSE)
return;
serverSock = httpServer->sock;
while (cg_thread_isrunnable(thread) == TRUE) {
clientSock = cg_socket_stream_new();
if (cg_socket_accept(serverSock, clientSock) == FALSE) {
cg_socket_delete(clientSock);
break;
}
cg_socket_settimeout(clientSock, cg_http_server_gettimeout(httpServer));
clientData = cg_http_server_clientdata_new(httpServer, clientSock);
httpClientThread = cg_thread_new();
cg_thread_setaction(httpClientThread, cg_http_server_clientthread);
cg_thread_setuserdata(httpClientThread, clientData);
/**** Thanks for Makela Aapo (10/31/05) ****/
cg_http_server_lock(httpServer);
cg_threadlist_add(httpServer->clientThreads, httpClientThread);
cg_http_server_unlock(httpServer);
cg_thread_start(httpClientThread);
}
cg_log_debug_l4("Leaving...\n");
}
void cg_socket_cleanup()
{
cg_log_debug_l4("Entering...\n");
socketCnt--;
if (socketCnt <= 0) {
#if (defined(WIN32) || defined(__CYGWIN__)) && !defined (ITRON)
WSACleanup( );
#endif
#if (!defined(WIN32) || defined(__CYGWIN__)) && !defined(BTRON) && !defined(ITRON) && !defined(TENGINE)
// Thanks for Brent Hills (10/26/04)
signal(SIGPIPE,SIG_DFL);
#endif
#if defined(CG_NET_USE_SOCKET_LIST)
cg_socketlist_delete(socketList);
#endif
}
cg_log_debug_l4("Leaving...\n");
}
CgNetworkInterface *cg_net_interface_new()
{
CgNetworkInterface *netIf;
cg_log_debug_l4("Entering...\n");
netIf = (CgNetworkInterface *)malloc(sizeof(CgNetworkInterface));
if ( NULL != netIf )
{
cg_list_node_init((CgList *)netIf);
netIf->name = cg_string_new();
netIf->ipaddr = cg_string_new();
netIf->netmask = cg_string_new();
cg_net_interface_setindex(netIf, 0);
memset(netIf->macaddr, 0, (size_t)CG_NET_MACADDR_SIZE);
}
cg_log_debug_l4("Leaving...\n");
return netIf;
}
static CgUpnpDevice *cg_upnp_controlpoint_createdevicefromssdkpacket(CgUpnpSSDPPacket *ssdpPkt)
{
const char *location;
CgNetURL *url;
CgUpnpDevice *dev;
BOOL parseSuccess;
cg_log_debug_l4("Entering...\n");
location = cg_upnp_ssdp_packet_getlocation(ssdpPkt);
if (cg_strlen(location) <= 0)
return NULL;
dev = cg_upnp_device_new();
url = cg_net_url_new();
cg_net_url_set(url, location);
parseSuccess = cg_upnp_device_parsedescriptionurl(dev, url);
cg_net_url_delete(url);
if (parseSuccess == FALSE) {
cg_upnp_device_delete(dev);
return NULL;
}
cg_upnp_device_setssdppacket(dev, ssdpPkt);
#ifndef CG_OPTIMIZED_CP_MODE
if (cg_upnp_controlpoint_parseservicesfordevice(dev, ssdpPkt) == FALSE)
{
cg_upnp_device_delete(dev);
return NULL;
}
#endif
cg_log_debug_l4("Leaving...\n");
return dev;
}
int cg_net_getipv6scopeid(char *addr)
{
int addrLen;
int perIdx;
char scopeIDBuf[8+1];
cg_log_debug_l4("Entering...\n");
if (cg_net_isipv6address(addr) == FALSE)
return 0;
addrLen = cg_strlen(addr);
perIdx = cg_strchr(addr, "%", 1);
if (perIdx < 0)
return 0;
cg_strncpy(scopeIDBuf, (addr+perIdx+1), sizeof(scopeIDBuf)-1);
scopeIDBuf[sizeof(scopeIDBuf)-1] = '\0';
cg_log_debug_l4("Leaving...\n");
return atoi(scopeIDBuf);
}
void cg_net_uri_delete(CgNetURI *uri)
{
cg_log_debug_l4("Entering...\n");
cg_string_delete(uri->uri);
cg_string_delete(uri->protocol);
cg_string_delete(uri->user);
cg_string_delete(uri->password);
cg_string_delete(uri->host);
cg_string_delete(uri->path);
cg_string_delete(uri->query);
cg_string_delete(uri->fragment);
if (uri->request != NULL)
cg_string_delete(uri->request);
if (uri->queryDictionary != NULL)
cg_dictionary_delete(uri->queryDictionary);
free(uri);
cg_log_debug_l4("Leaving...\n");
}
void cg_http_packet_copy(CgHttpPacket *destHttpPkt, CgHttpPacket *srcHttpPkt)
{
CgHttpHeader *srcHeader;
CgHttpHeader *destHeader;
cg_log_debug_l4("Entering...\n");
cg_http_packet_clear(destHttpPkt);
/**** copy headers ****/
for (srcHeader = cg_http_packet_getheaders(srcHttpPkt); srcHeader != NULL; srcHeader = cg_http_header_next(srcHeader)) {
destHeader = cg_http_header_new();
cg_http_header_setname(destHeader, cg_http_header_getname(srcHeader));
cg_http_header_setvalue(destHeader, cg_http_header_getvalue(srcHeader));
cg_http_packet_addheader(destHttpPkt, destHeader);
}
/**** copy content ****/
cg_http_packet_setcontent(destHttpPkt, cg_http_packet_getcontent(srcHttpPkt));
cg_log_debug_l4("Leaving...\n");
}
CgHttpHeader *cg_http_headerlist_get(CgHttpHeaderList *headerList, const char *name)
{
CgHttpHeader *header;
const char *headerName;
cg_log_debug_l4("Entering...\n");
if (name == NULL)
return NULL;
for (header = cg_http_headerlist_gets(headerList); header != NULL; header = cg_http_header_next(header)) {
headerName = cg_http_header_getname(header);
if (headerName == NULL)
continue;
if (cg_strcasecmp(headerName, name) == 0)
return header;
}
return NULL;
cg_log_debug_l4("Leaving...\n");
}
static char *cg_xml_node_attribute_tostring(CgXmlNode *node, CgString *str)
{
CgXmlAttribute *attr;
char *name;
char *value;
CgString *valueStr;
cg_log_debug_l4("Entering...\n");
valueStr = cg_string_new();
if (valueStr == NULL) return NULL;
for (attr = cg_xml_node_getattributes(node); attr != NULL; attr = cg_xml_attribute_next(attr)) {
name = cg_xml_attribute_getname(attr);
value = cg_xml_attribute_getvalue(attr);
cg_string_setvalue(valueStr, value);
cg_xml_escapechars(valueStr);
/* All the following functions return NULL only when memory
allocation fails, so we can check them all */
if (!cg_string_naddvalue(str, " ", 1) ||
!cg_string_addvalue(str, name) ||
!cg_string_naddvalue(str, "=\"", 2) ||
!cg_string_addvalue(str, cg_string_getvalue(valueStr)) ||
!cg_string_naddvalue(str, "\"", 1))
{
/* Memory allocation failed */
cg_string_delete(valueStr);
return NULL;
}
}
cg_string_delete(valueStr);
cg_log_debug_l4("Leaving...\n");
return cg_string_getvalue(str);
}
BOOL cg_socket_setreuseaddress(CgSocket *sock, BOOL flag)
{
int sockOptRet;
#if defined(BTRON) || (defined(TENGINE) && !defined(CG_TENGINE_NET_KASAGO))
B optval
#elif defined(TENGINE) && defined(CG_TENGINE_NET_KASAGO)
int optval;
#elif defined (WIN32)
BOOL optval;
#else
int optval;
#endif
cg_log_debug_l4("Entering...\n");
#if defined(BTRON) || (defined(TENGINE) && !defined(CG_TENGINE_NET_KASAGO))
optval = (flag == TRUE) ? 1 : 0;
sockOptRet = so_setsockopt(sock->id, SOL_SOCKET, SO_REUSEADDR, (B *)&optval, sizeof(optval));
#elif defined(TENGINE) && defined(CG_TENGINE_NET_KASAGO)
optval = (flag == TRUE) ? 1 : 0;
sockOptRet = ka_setsockopt(sock->id, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof(optval));
#elif defined (ITRON)
/**** Not Implemented for NORTi ***/
sockOptRet = -1;
#elif defined (WIN32)
optval = (flag == TRUE) ? 1 : 0;
sockOptRet = setsockopt(sock->id, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof(optval));
#else
optval = (flag == TRUE) ? 1 : 0;
sockOptRet = setsockopt(sock->id, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof(optval));
#if defined(USE_SO_REUSEPORT) || defined(TARGET_OS_MAC) || defined(TARGET_OS_IPHONE)
setsockopt(sock->id, SOL_SOCKET, SO_REUSEPORT, (const char *)&optval, sizeof(optval));
#endif
#endif
cg_log_debug_l4("Leaving...\n");
return (sockOptRet == 0) ? TRUE : FALSE;
}
CgHttpServerList *cg_http_serverlist_new()
{
CgHttpServerList *httpServerList;
cg_log_debug_l4("Entering...\n");
httpServerList = (CgHttpServerList *)malloc(sizeof(CgHttpServerList));
if ( NULL != httpServerList )
{
cg_list_header_init((CgList *)httpServerList);
httpServerList->sock = NULL;
httpServerList->acceptThread = NULL;
httpServerList->listener = NULL;
httpServerList->userData = NULL;
httpServerList->mutex = NULL;
}
cg_log_debug_l4("Leaving...\n");
return httpServerList;
}
BOOL cg_upnp_ssdp_server_open(CgUpnpSSDPServer *server, char *bindAddr)
{
const char *ssdpAddr = CG_UPNP_SSDP_ADDRESS;
cg_log_debug_l4("Entering...\n");
if (cg_upnp_ssdp_server_isopened(server) == TRUE)
return FALSE;
if (cg_net_isipv6address(bindAddr) == TRUE)
ssdpAddr = cg_upnp_ssdp_getipv6address();
server->httpmuSock = cg_upnp_httpmu_socket_new();
if (cg_upnp_httpmu_socket_bind(server->httpmuSock, ssdpAddr, CG_UPNP_SSDP_PORT, bindAddr) == FALSE) {
cg_upnp_httpmu_socket_delete(server->httpmuSock);
server->httpmuSock = NULL;
return FALSE;
}
cg_log_debug_l4("Leaving...\n");
return TRUE;
}
CgUpnpSSDPServer *cg_upnp_ssdp_server_new()
{
CgUpnpSSDPServer *server;
cg_log_debug_l4("Entering...\n");
server = (CgUpnpSSDPServer *)malloc(sizeof(CgUpnpSSDPServer));
if ( NULL != server )
{
cg_list_node_init((CgList *)server);
server->httpmuSock = NULL;
server->recvThread = NULL;
cg_upnp_ssdp_server_setlistener(server, NULL);
cg_upnp_ssdp_server_setuserdata(server, NULL);
}
cg_log_debug_l4("Leaving...\n");
return server;
}
char *cg_xml_unescapechars(CgString *str)
{
char *fromChars[5];
char *toChars[5];
cg_log_debug_l4("Entering...\n");
fromChars[0] = "&";
fromChars[1] = ">";
fromChars[2] = "<";
fromChars[3] = """;
fromChars[4] = "'";
toChars[0] = "&";
toChars[1] = ">";
toChars[2] = "<";
toChars[3] = "\"";
toChars[4] = "'";
cg_log_debug_l4("Leaving...\n");
return cg_string_replace(str, fromChars, toChars, (sizeof(fromChars)/sizeof(fromChars[0])));
}
/**
* When an event is received, update also the associated service's
* state table to include the evented state variable.
*
* @param service The service, whose state table to update
* @param prop The evented property from which to update
*/
void cg_upnp_controlpoint_updatestatetablefromproperty(CgUpnpService* service,
CgUpnpProperty* prop)
{
CgUpnpStateVariable* var = NULL;
cg_log_debug_l4("Entering...\n");
if (service == NULL || prop == NULL)
{
return;
}
var = cg_upnp_service_getstatevariablebyname(service,
cg_upnp_property_getname(prop));
if (var)
{
cg_upnp_statevariable_setvalue(var,
cg_upnp_property_getvalue(prop));
}
cg_log_debug_l4("Leaving...\n");
}
/**
* cg_upnp_device_advertiser_stop
*
* Stop the advertiser thread for the given device
*
* \param dev Device that is being advertised
*/
BOOL cg_upnp_device_advertiser_stop(CgUpnpDevice *dev)
{
CgThread *advertiser;
cg_log_debug_l4("Entering...\n");
/* Get the advertiser thread from the device struct */
advertiser = cg_upnp_device_getadvertiserthead(dev);
//Theo Beisch
if (advertiser != NULL)
return cg_thread_stop(advertiser);
return FALSE;
}
void cg_upnp_control_soap_response_setfaultresponse(CgSoapResponse *soapRes, int errCode, char *errDescr)
{
CgHttpResponse *httpRes;
CgXmlNode *bodyNode;
CgXmlNode *faultNode;
CgXmlNode *envNode;
cg_log_debug_l4("Entering...\n");
httpRes = cg_soap_response_gethttpresponse(soapRes);
cg_http_response_setstatuscode(httpRes, CG_HTTP_STATUS_INTERNAL_SERVER_ERROR);
cg_upnp_control_soap_response_initializeenvelopenode(soapRes);
bodyNode = cg_soap_response_getbodynode(soapRes);
faultNode = cg_upnp_control_soap_response_createfaultresponsenode(errCode, errDescr);
cg_xml_node_addchildnode(bodyNode, faultNode);
envNode = cg_soap_response_getenvelopenode(soapRes);
cg_soap_response_setcontent(soapRes, envNode);
cg_log_debug_l4("Leaving...\n");
}
CgXmlNode *cg_upnp_event_notify_request_getvariablenode(CgUpnpNotifyRequest *nofityReq)
{
CgXmlNode *propSetNode;
CgXmlNode *propNode;
cg_log_debug_l4("Entering...\n");
propSetNode = cg_upnp_event_notify_request_getpropertysetnode(nofityReq);
if (propSetNode == NULL)
return NULL;
if (cg_xml_node_haschildnodes(propSetNode) == FALSE)
return NULL;
propNode = cg_xml_node_getchildnodes(propSetNode);
if (propNode == NULL)
return NULL;
if (cg_xml_node_haschildnodes(propNode) == FALSE)
return NULL;
cg_log_debug_l4("Leaving...\n");
return cg_xml_node_getchildnodes(propNode);
}
BOOL cg_http_server_open(CgHttpServer *httpServer, int bindPort, char *bindAddr)
{
cg_log_debug_l4("Entering...\n");
if (cg_http_server_isopened(httpServer) == TRUE)
return FALSE;
httpServer->sock = cg_socket_stream_new();
if (cg_socket_bind(httpServer->sock, bindPort, bindAddr, TRUE, FALSE) == FALSE) {
cg_socket_delete(httpServer->sock);
httpServer->sock = NULL;
return FALSE;
}
if (cg_socket_listen(httpServer->sock) == FALSE) {
cg_socket_delete(httpServer->sock);
httpServer->sock = NULL;
return FALSE;
}
cg_log_debug_l4("Leaving...\n");
return TRUE;
}
CgUpnpProperty *cg_upnp_property_new()
{
CgUpnpProperty *prop;
cg_log_debug_l4("Entering...\n");
prop = (CgUpnpProperty *)malloc(sizeof(CgUpnpProperty));
if ( NULL != prop )
{
cg_list_node_init((CgList *)prop);
prop->name = cg_string_new();
prop->value = cg_string_new();
prop->sid = cg_string_new();
cg_upnp_property_setseq(prop, 0);
}
return prop;
cg_log_debug_l4("Leaving...\n");
}
int cg_socket_read(CgSocket *sock, char *buffer, int bufferLen)
{
int recvLen;
#if defined(CG_USE_OPENSSL)
if (cg_socket_isssl(sock) == FALSE) {
#endif
#if defined(BTRON) || (defined(TENGINE) && !defined(CG_TENGINE_NET_KASAGO))
recvLen = so_recv(sock->id, buffer, bufferLen, 0);
#elif defined(TENGINE) && defined(CG_TENGINE_NET_KASAGO)
recvLen = ka_recv(sock->id, buffer, bufferLen, 0);
#elif defined(ITRON)
recvLen = tcp_rcv_dat(sock->id, buffer, bufferLen, TMO_FEVR);
#else
recvLen = recv(sock->id, buffer, bufferLen, 0);
#endif
#if defined(CG_USE_OPENSSL)
}
else {
recvLen = SSL_read(sock->ssl, buffer, bufferLen);
}
#endif
cg_log_debug_l4("Entering...\n");
#ifdef SOCKET_DEBUG
if (0 <= recvLen)
buffer[recvLen] = '\0';
cg_log_debug_s("r %d : %s\n", recvLen, (0 <= recvLen) ? buffer : "");
#endif
cg_log_debug_l4("Leaving...\n");
return recvLen;
}
BOOL cg_socket_setmulticastinterface(CgSocket *sock, char *ifaddr)
{
struct sockaddr_in sockaddr;
BOOL sockAddrSuccess;
int optSuccess;
CgNetworkInterfaceList *netIfList;
CgNetworkInterface *netIf;
int netIfCnt;
cg_log_debug_l4("Entering...\n");
netIfList = NULL;
if (cg_strlen(ifaddr) <= 0) {
netIfList = cg_net_interfacelist_new();
netIfCnt = cg_net_gethostinterfaces(netIfList);
if (netIfCnt <= 0) {
cg_net_interfacelist_delete(netIfList);
return FALSE;
}
netIf = cg_net_interfacelist_gets(netIfList);
ifaddr = cg_net_interface_getaddress(netIf);
}
sockAddrSuccess = cg_socket_tosockaddrin(ifaddr, 0, &sockaddr, TRUE);
if (netIfList != NULL)
cg_net_interfacelist_delete(netIfList);
if (sockAddrSuccess == FALSE)
return FALSE;
optSuccess = ka_setsockopt(sock->id, IP_PROTOIP, IPO_MULTICAST_IF, (const char *)&sockaddr.sin_addr, sizeof(sockaddr.sin_addr));
if (optSuccess != 0)
return FALSE;
cg_log_debug_l4("Leaving...\n");
return TRUE;
}
void cg_soap_request_setcontent(CgSoapRequest *soapReq, CgXmlNode *node)
{
CgHttpRequest *httpReq;
cg_log_debug_l4("Entering...\n");
httpReq = cg_soap_request_gethttprequest(soapReq);
/**** content type ****/
cg_http_request_setcontenttype(httpReq, CG_XML_CONTENT_TYPE);
/**** content ****/
cg_http_request_appendncontent(httpReq, CG_SOAP_VERSION_HEADER,
cg_strlen(CG_SOAP_VERSION_HEADER));
cg_http_request_appendncontent(httpReq, CG_XML_CONTENT_LF,
cg_strlen(CG_XML_CONTENT_LF));
cg_xml_node_tostring(node, TRUE, httpReq->content);
/**** content length ****/
cg_http_request_setcontentlength(httpReq,
cg_string_length(httpReq->content));
cg_log_debug_l4("Leaving...\n");
}
char *cg_upnp_usn_getudn(char *usn, char *udnBuf, int udnBufLen)
{
int idx;
cg_log_debug_l4("Entering...\n");
if (usn == NULL) {
udnBuf[0] = '\0';
return udnBuf;
}
idx = cg_strstr(usn, "::");
if (idx < 0) {
cg_strncpy(udnBuf, usn, udnBufLen);
udnBuf[udnBufLen-1] = '\0';
cg_strtrim(udnBuf, " ", 1);
return udnBuf;
}
if ( idx < udnBufLen ) {
cg_strncpy(udnBuf, usn, (idx));
udnBuf[idx] = '\0';
}
else {
cg_strncpy(udnBuf, usn, udnBufLen);
udnBuf[udnBufLen-1] = '\0';
}
cg_strtrim(udnBuf, " ", 1);
cg_log_debug("UDN: %s\n", udnBuf);
return udnBuf;
cg_log_debug_l4("Leaving...\n");
}
BOOL cg_socket_settimeout(CgSocket *sock, int sec)
{
int sockOptRet;
#if defined(BTRON) || (defined(TENGINE) && !defined(CG_TENGINE_NET_KASAGO))
sockOptRet = -1; /* TODO: Implement this */
#elif defined(TENGINE) && defined(CG_TENGINE_NET_KASAGO)
sockOptRet = -1; /* TODO: Implement this */
#elif defined (ITRON)
/**** Not Implemented for NORTi ***/
sockOptRet = -1;
#elif defined (WIN32)
struct timeval timeout;
timeout.tv_sec = sec;
timeout.tv_usec = 0;
cg_log_debug_l4("Entering...\n");
sockOptRet = setsockopt(sock->id, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
if (sockOptRet == 0)
sockOptRet = setsockopt(sock->id, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(timeout));
#else
struct timeval timeout;
timeout.tv_sec = (time_t)sec;
timeout.tv_usec = 0;
cg_log_debug_l4("Entering...\n");
sockOptRet = setsockopt(sock->id, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
if (sockOptRet == 0)
sockOptRet = setsockopt(sock->id, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(timeout));
#endif
cg_log_debug_l4("Leaving...\n");
return (sockOptRet == 0) ? TRUE : FALSE;
}
BOOL cg_mutex_unlock(CgMutex *mutex)
{
if (!mutex)
return FALSE;
cg_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
ReleaseMutex(mutex->mutexID);
#elif defined(BTRON)
sig_sem(mutex->mutexID);
#elif defined(ITRON)
sig_sem(mutex->mutexID);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_sig_sem(mutex->mutexID, 1);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_sig_sem(mutex->mutexID);
#else
pthread_mutex_unlock(&mutex->mutexID);
#endif
return TRUE;
cg_log_debug_l4("Leaving...\n");
}
/**
* cg_upnp_device_advertiser_action
*
* Function run as a UPnP device advertisement
* thread.
*
* \param thread The thread context that this function is running in
*/
static void cg_upnp_device_advertiser_action(CgThread *thread)
{
CgUpnpDevice *dev;
CgTime leaseTime;
CgTime notifyInterval;
cg_log_debug_l4("Entering...\n");
/**
* Get the device struct that this function is advertising.
*/
dev = (CgUpnpDevice *)cg_thread_getuserdata(thread);
/**
* Lease time
*/
leaseTime = cg_upnp_device_getleasetime(dev);
/* Run this thread until it is stopped from outside */
while ( cg_thread_isrunnable(thread) == TRUE )
{
notifyInterval = (leaseTime/4) + (long)((float)leaseTime * (cg_random() * 0.25f));
notifyInterval *= 1000;
/* Sleep *notifyInterval* msecs */
cg_wait(notifyInterval);
/* Check if we must exit before sending new announce */
if ( cg_thread_isrunnable(thread) == FALSE ) break;
/* Initiate advertise routine after sleeping */
cg_upnp_device_announce(dev);
}
cg_log_debug_l4("Leaving...\n");
}
static int cg_socket_getavailableport()
{
CgSocket *sock;
int port;
BOOL isPortUsed;
cg_log_debug_l4("Entering...\n");
port = CG_NET_SOCKET_MIN_SOCKET_PORT - 1;
do {
port++;
isPortUsed = FALSE;
for (sock = cg_socketlist_gets(socketList); sock != NULL; sock = cg_socket_next(sock)) {
if (cg_socket_getport(sock) == port) {
isPortUsed = TRUE;
break;
}
}
} while (isPortUsed != FALSE);
cg_log_debug_l4("Leaving...\n");
return port;
}
