/** Thread start procedure for asynchronous find services request. * * @param[in,out] handle - Contains the request parameters, returns the * request result. * * @return An SLPError code. * * @internal */ static SLPError AsyncProcessSrvRqst(SLPHandleInfo * handle) { SLPError serr = ProcessSrvRqst(handle); xfree((void *)handle->params.findsrvs.srvtype); xfree((void *)handle->params.findsrvs.scopelist); xfree((void *)handle->params.findsrvs.predicate); SLPSpinLockRelease(&handle->inUse); return serr; }
/*-------------------------------------------------------------------------*/ SLPError AsyncProcessSrvRqst(PSLPHandleInfo handle) /*-------------------------------------------------------------------------*/ { SLPError result = ProcessSrvRqst(handle); xfree((void*)handle->params.findsrvs.srvtype); xfree((void*)handle->params.findsrvs.scopelist); xfree((void*)handle->params.findsrvs.predicate); handle->inUse = SLP_FALSE; return result; }
/*=========================================================================*/ int SLPDProcessMessage(SLPDPeerInfo* peerinfo, SLPBuffer recvbuf, SLPBuffer sendbuf) /* Processes the recvbuf and places the results in sendbuf */ /* */ /* recvfd - the socket the message was received on */ /* */ /* recvbuf - message to process */ /* */ /* sendbuf - results of the processed message */ /* */ /* Returns - zero on success SLP_ERROR_PARSE_ERROR or */ /* SLP_ERROR_INTERNAL_ERROR on ENOMEM. */ /*=========================================================================*/ { SLPMessage message = 0; int result = 0; message = SLPMessageAlloc(); if(message == 0) { return SLP_ERROR_INTERNAL_ERROR; } result = SLPMessageParseBuffer(recvbuf, message); if(result == 0) { switch(message->header.functionid) { case SLP_FUNCT_SRVRQST: ProcessSrvRqst(peerinfo,message,sendbuf); break; case SLP_FUNCT_SRVREG: ProcessSrvReg(peerinfo,message,sendbuf); break; case SLP_FUNCT_SRVDEREG: ProcessSrvDeReg(peerinfo,message,sendbuf); break; case SLP_FUNCT_SRVACK: ProcessSrvAck(peerinfo,message,sendbuf); break; case SLP_FUNCT_ATTRRQST: ProcessAttrRqst(peerinfo,message,sendbuf); break; case SLP_FUNCT_DAADVERT: ProcessDAAdvert(peerinfo,message,sendbuf); break; case SLP_FUNCT_SRVTYPERQST: ProcessSrvTypeRqst(peerinfo,message,sendbuf); break; case SLP_FUNCT_SAADVERT: ProcessSAAdvert(peerinfo,message,sendbuf); break; default: /* this will NEVER happen */ break; } /* Log traceMsg of message was received and the one that will be sent */ if(G_SlpdProperty.traceMsg) { SLPDLogTraceMsg(peerinfo,recvbuf,sendbuf); } } else { /* TODO: Log here? */ } SLPMessageFree(message); return result; }
/*=========================================================================*/ SLPError SLPAPI SLPFindSrvs(SLPHandle hSLP, const char *pcServiceType, const char *pcScopeList, const char *pcSearchFilter, SLPSrvURLCallback callback, void *pvCookie) /* */ /* Issue the query for services on the language specific SLPHandle and */ /* return the results through the callback. The parameters determine */ /* the results */ /* */ /* hSLP The language specific SLPHandle on which to search for */ /* services. */ /* */ /* pcServiceType The Service Type String, including authority string if */ /* any, for the request, such as can be discovered using */ /* SLPSrvTypes(). This could be, for example */ /* "service:printer:lpr" or "service:nfs". May not be */ /* the empty string or NULL. */ /* */ /* */ /* pcScopeList A pointer to a char containing comma separated list of */ /* scope names. Pass in the NULL or the empty string "" */ /* to find services in all the scopes the local host is */ /* configured query. */ /* */ /* pcSearchFilter A query formulated of attribute pattern matching */ /* expressions in the form of a LDAPv3 Search Filter. */ /* If this filter is NULL or empty, i.e. "", all */ /* services of the requested type in the specified scopes */ /* are returned. */ /* */ /* callback A callback function through which the results of the */ /* operation are reported. May not be NULL */ /* */ /* pvCookie Memory passed to the callback code from the client. */ /* May be NULL. */ /* */ /* Returns: If an error occurs in starting the operation, one of */ /* the SLPError codes is returned. */ /* */ /*=========================================================================*/ { PSLPHandleInfo handle; SLPError result; /*------------------------------*/ /* check for invalid parameters */ /*------------------------------*/ if(hSLP == 0 || *(unsigned int*)hSLP != SLP_HANDLE_SIG || pcServiceType == 0 || *pcServiceType == 0 || /* srvtype can't be empty string */ callback == 0) { return SLP_PARAMETER_BAD; } /*-----------------------------------------*/ /* cast the SLPHandle into a SLPHandleInfo */ /*-----------------------------------------*/ handle = (PSLPHandleInfo)hSLP; /*-----------------------------------------*/ /* Check to see if the handle is in use */ /*-----------------------------------------*/ if(handle->inUse == SLP_TRUE) { return SLP_HANDLE_IN_USE; } handle->inUse = SLP_TRUE; /*-------------------------------------------*/ /* Set the handle up to reference parameters */ /*-------------------------------------------*/ handle->params.findsrvs.srvtypelen = strlen(pcServiceType); handle->params.findsrvs.srvtype = pcServiceType; if(pcScopeList && *pcScopeList) { handle->params.findsrvs.scopelistlen = strlen(pcScopeList); handle->params.findsrvs.scopelist = pcScopeList; } else { handle->params.findsrvs.scopelist = SLPGetProperty("net.slp.useScopes"); handle->params.findsrvs.scopelistlen = strlen(handle->params.findsrvs.scopelist); } if(pcSearchFilter) { handle->params.findsrvs.predicatelen = strlen(pcSearchFilter); handle->params.findsrvs.predicate = pcSearchFilter; } else { handle->params.findsrvs.predicatelen = 0; handle->params.findsrvs.predicate = (char*)&handle->params.findsrvs.predicatelen; } handle->params.findsrvs.callback = callback; handle->params.findsrvs.cookie = pvCookie; /*----------------------------------------------*/ /* Check to see if we should be async or sync */ /*----------------------------------------------*/ #ifdef ENABLE_ASYNC_API if(handle->isAsync) { /* COPY all the referenced parameters */ handle->params.findsrvs.srvtype = xstrdup(handle->params.findsrvs.srvtype); handle->params.findsrvs.scopelist = xstrdup(handle->params.findsrvs.scopelist); handle->params.findsrvs.predicate = xstrdup(handle->params.findsrvs.predicate); /* make sure strdups did not fail */ if(handle->params.findsrvs.srvtype && handle->params.findsrvs.scopelist && handle->params.findsrvs.predicate) { result = ThreadCreate((ThreadStartProc)AsyncProcessSrvRqst,handle); } else { result = SLP_MEMORY_ALLOC_FAILED; } if(result) { if(handle->params.findsrvs.srvtype) xfree((void*)handle->params.findsrvs.srvtype); if(handle->params.findsrvs.scopelist) xfree((void*)handle->params.findsrvs.scopelist); if(handle->params.findsrvs.predicate) xfree((void*)handle->params.findsrvs.predicate); handle->inUse = SLP_FALSE; } } else #endif /* ifdef ENABLE_ASYNC_API */ { /* Leave all parameters REFERENCED */ result = ProcessSrvRqst(handle); handle->inUse = SLP_FALSE; } return result; }
/** Return a list of service matching a query specification. * * Issue the query for services on the language specific SLPHandle and * return the results through the @p callback. The parameters determine * the results. * * @param[in] hSLP - The language specific SLPHandle on which to search * for services. * @param[in] pcServiceType - The Service Type String, including authority * string if any, for the request, such as can be discovered using * SLPSrvTypes. This could be, for example "service:printer:lpr" or * "service:nfs". May not be the empty string or NULL. * @param[in] pcScopeList - A pointer to a char containing a comma-separated * list of scope names. Pass in NULL or the empty string ("") to find * services in all the scopes the local host is configured to query. * @param[in] pcSearchFilter - A query formulated of attribute pattern * matching expressions in the form of a LDAPv3 Search Filter, see * [RFC 2254]. If this filter is empty, i.e. "" or NULL, all services * of the requested type in the specified scopes are returned. * @param[in] callback - A callback function through which the results of * the operation are reported. * @param[in] pvCookie - Memory passed to the @p callback code from the * client. May be NULL. * * @return If an error occurs in starting the operation, one of the SLPError * codes is returned. */ SLPEXP SLPError SLPAPI SLPFindSrvs( SLPHandle hSLP, const char * pcServiceType, const char * pcScopeList, const char * pcSearchFilter, SLPSrvURLCallback callback, void * pvCookie) { bool inuse; SLPError serr = 0; SLPHandleInfo * handle = hSLP; /* Check for invalid parameters. */ SLP_ASSERT(handle != 0); SLP_ASSERT(handle->sig == SLP_HANDLE_SIG); SLP_ASSERT(pcServiceType != 0); SLP_ASSERT(*pcServiceType != 0); SLP_ASSERT(callback != 0); if (handle == 0 || handle->sig != SLP_HANDLE_SIG || pcServiceType == 0 || *pcServiceType == 0 || callback == 0) return SLP_PARAMETER_BAD; /* Check to see if the handle is in use. */ inuse = SLPSpinLockTryAcquire(&handle->inUse); SLP_ASSERT(!inuse); if (inuse) return SLP_HANDLE_IN_USE; /* Get a scope list if not supplied. */ if (pcScopeList == 0 || *pcScopeList == 0) pcScopeList = SLPPropertyGet("net.slp.useScopes", 0, 0); /* Ensure there's a scope list of some sort... */ if (pcScopeList == 0) pcScopeList = ""; /* Get a search filter if not supplied */ if (pcSearchFilter == 0) pcSearchFilter = ""; /* Set the handle up to reference parameters. */ handle->params.findsrvs.srvtypelen = strlen(pcServiceType); handle->params.findsrvs.srvtype = pcServiceType; handle->params.findsrvs.scopelistlen = strlen(pcScopeList); handle->params.findsrvs.scopelist = pcScopeList; handle->params.findsrvs.predicatelen = strlen(pcSearchFilter); handle->params.findsrvs.predicate = pcSearchFilter; handle->params.findsrvs.callback = callback; handle->params.findsrvs.cookie = pvCookie; /* Check to see if we should be async or sync. */ #ifdef ENABLE_ASYNC_API if (handle->isAsync) { /* Copy all of the referenced parameters before creating thread. */ handle->params.findsrvs.srvtype = xstrdup(handle->params.findsrvs.srvtype); handle->params.findsrvs.scopelist = xstrdup(handle->params.findsrvs.scopelist); handle->params.findsrvs.predicate = xstrdup(handle->params.findsrvs.predicate); /* Ensure strdups and thread create succeed. */ if (handle->params.findsrvs.srvtype == 0 || handle->params.findsrvs.scopelist == 0 || handle->params.findsrvs.predicate == 0 || (handle->th = SLPThreadCreate((SLPThreadStartProc) AsyncProcessSrvRqst, handle)) == 0) { serr = SLP_MEMORY_ALLOC_FAILED; xfree((void *)handle->params.findsrvs.srvtype); xfree((void *)handle->params.findsrvs.scopelist); xfree((void *)handle->params.findsrvs.predicate); SLPSpinLockRelease(&handle->inUse); } } else #endif { /* Leave all parameters referenced. */ serr = ProcessSrvRqst(handle); SLPSpinLockRelease(&handle->inUse); } return serr; }
/** Processes the recvbuf and places the results in sendbuf * * @param[in] peerinfo - The remote address the message was received from. * @param[in] localaddr - The local address the message was received on. * @param[in] recvbuf - The message to process. * @param[out] sendbuf - The address of storage for the results of the * processed message. * @param[out] sendlist - if non-0, this function will prune the message * with the processed xid from the sendlist. * * @return Zero on success if @p sendbuf contains a response to send, * or a non-zero value if @p sendbuf does not contain a response * to send. */ int SLPDProcessMessage(struct sockaddr_storage * peerinfo, struct sockaddr_storage * localaddr, SLPBuffer recvbuf, SLPBuffer * sendbuf, SLPList * psendlist) { SLPHeader header; SLPMessage * message = 0; int errorcode = 0; #ifdef DEBUG char addr_str[INET6_ADDRSTRLEN]; #endif SLPDLogMessage(SLPDLOG_TRACEMSG_IN, peerinfo, localaddr, recvbuf); /* set the sendbuf empty */ if (*sendbuf) (*sendbuf)->end = (*sendbuf)->start; /* zero out the header before parsing it */ memset(&header, 0, sizeof(header)); /* Parse just the message header */ recvbuf->curpos = recvbuf->start; errorcode = SLPMessageParseHeader(recvbuf, &header); /* Reset the buffer "curpos" pointer so that full message can be parsed later */ recvbuf->curpos = recvbuf->start; #if defined(ENABLE_SLPv1) /* if version == 1 and the header was correct then parse message as a version 1 message */ if ((errorcode == 0) && (header.version == 1)) errorcode = SLPDv1ProcessMessage(peerinfo, recvbuf, sendbuf); else #endif if (errorcode == 0) { /* TRICKY: Duplicate SRVREG recvbufs *before* parsing them * we do this because we are going to keep track of in the * registration database. */ if (header.functionid == SLP_FUNCT_SRVREG || header.functionid == SLP_FUNCT_DAADVERT) { recvbuf = SLPBufferDup(recvbuf); if (recvbuf == 0) return SLP_ERROR_INTERNAL_ERROR; } /* Allocate the message descriptor */ message = SLPMessageAlloc(); if (message) { /* Parse the message and fill out the message descriptor */ errorcode = SLPMessageParseBuffer(peerinfo, localaddr, recvbuf, message); if (errorcode == 0) { /* Process messages based on type */ switch (message->header.functionid) { case SLP_FUNCT_SRVRQST: errorcode = ProcessSrvRqst(message, sendbuf, errorcode); break; case SLP_FUNCT_SRVREG: errorcode = ProcessSrvReg(message, recvbuf, sendbuf, errorcode); if (errorcode == 0) SLPDKnownDAEcho(message, recvbuf); break; case SLP_FUNCT_SRVDEREG: errorcode = ProcessSrvDeReg(message, sendbuf, errorcode); if (errorcode == 0) SLPDKnownDAEcho(message, recvbuf); break; case SLP_FUNCT_SRVACK: errorcode = ProcessSrvAck(message, sendbuf, errorcode); break; case SLP_FUNCT_ATTRRQST: errorcode = ProcessAttrRqst(message, sendbuf, errorcode); break; case SLP_FUNCT_DAADVERT: errorcode = ProcessDAAdvert(message, recvbuf, sendbuf, errorcode); break; case SLP_FUNCT_SRVTYPERQST: errorcode = ProcessSrvTypeRqst(message, sendbuf, errorcode); break; case SLP_FUNCT_SAADVERT: errorcode = ProcessSAAdvert(message, sendbuf, errorcode); break; default: /* Should never happen... but we're paranoid */ errorcode = SLP_ERROR_PARSE_ERROR; break; } } else SLPDLogParseWarning(peerinfo, recvbuf); /*If there was a send list, prune the xid, since the request has been processed*/ if(psendlist) { SLPHeader bufhead; SLPBuffer pnext; SLPBuffer pbuf = (SLPBuffer) psendlist->head; while(pbuf) { pnext = (SLPBuffer) pbuf->listitem.next; if((0 == SLPMessageParseHeader(pbuf, &bufhead)) && (bufhead.xid == header.xid)) SLPBufferFree((SLPBuffer)SLPListUnlink(psendlist, (SLPListItem*)pbuf)); else pbuf->curpos = pbuf->start; /*We parsed the buffer enough to attempt the xid check, we need to reset it for the next parse*/ pbuf = pnext; } } if (header.functionid == SLP_FUNCT_SRVREG || header.functionid == SLP_FUNCT_DAADVERT) { /* TRICKY: If this is a reg or daadvert message we do not free * the message descriptor or duplicated recvbuf because they are * being kept in the database! */ if (errorcode == 0) goto FINISHED; /* TRICKY: If there is an error we need to free the * duplicated recvbuf */ SLPBufferFree(recvbuf); } SLPMessageFree(message); } else errorcode = SLP_ERROR_INTERNAL_ERROR; /* out of memory */ } else SLPDLogParseWarning(peerinfo,recvbuf); FINISHED: #ifdef DEBUG if (errorcode) SLPDLog("\n*** DEBUG *** errorcode %i during processing " "of message from %s\n", errorcode, SLPNetSockAddrStorageToString( peerinfo, addr_str, sizeof(addr_str))); #endif /* Log message silently ignored because of an error */ if (errorcode) if (*sendbuf == 0 || (*sendbuf)->end == (*sendbuf)->start) SLPDLogMessage(SLPDLOG_TRACEDROP,peerinfo,localaddr,recvbuf); /* Log trace message */ SLPDLogMessage(SLPDLOG_TRACEMSG_OUT, peerinfo, localaddr, *sendbuf); return errorcode; }
/*=========================================================================*/ int SLPDProcessMessage(struct sockaddr_in* peerinfo, SLPBuffer recvbuf, SLPBuffer* sendbuf) /* Processes the recvbuf and places the results in sendbuf */ /* */ /* recvfd - the socket the message was received on */ /* */ /* recvbuf - message to process */ /* */ /* sendbuf - results of the processed message */ /* */ /* Returns - zero on success SLP_ERROR_PARSE_ERROR or */ /* SLP_ERROR_INTERNAL_ERROR on ENOMEM. */ /*=========================================================================*/ { SLPMessage message = 0; int errorcode = 0; message = SLPMessageAlloc(); if(message == 0) { return SLP_ERROR_INTERNAL_ERROR; } errorcode = SLPMessageParseBuffer(recvbuf, message); #if defined(ENABLE_SLPv1) if(message->header.version == 1) return SLPDv1ProcessMessage(peerinfo, recvbuf, sendbuf, message, errorcode); #endif /* Log trace message */ SLPDLogTraceMsg("IN",peerinfo,recvbuf); switch(message->header.functionid) { case SLP_FUNCT_SRVRQST: errorcode = ProcessSrvRqst(peerinfo, message, sendbuf, errorcode); break; case SLP_FUNCT_SRVREG: errorcode = ProcessSrvReg(peerinfo, message,sendbuf, errorcode); if(errorcode == 0) { SLPDKnownDAEcho(peerinfo, message, recvbuf); } break; case SLP_FUNCT_SRVDEREG: errorcode = ProcessSrvDeReg(peerinfo, message,sendbuf, errorcode); if(errorcode == 0) { SLPDKnownDAEcho(peerinfo, message, recvbuf); } break; case SLP_FUNCT_SRVACK: errorcode = ProcessSrvAck(peerinfo, message,sendbuf, errorcode); break; case SLP_FUNCT_ATTRRQST: errorcode = ProcessAttrRqst(peerinfo, message,sendbuf, errorcode); break; case SLP_FUNCT_DAADVERT: errorcode = ProcessDAAdvert(peerinfo, message, sendbuf, errorcode); /* If necessary log that we received a DAAdvert */ SLPDLogDATrafficMsg("IN", peerinfo, message); break; case SLP_FUNCT_SRVTYPERQST: errorcode = ProcessSrvTypeRqst(peerinfo, message, sendbuf, errorcode); break; case SLP_FUNCT_SAADVERT: errorcode = ProcessSAAdvert(peerinfo, message, sendbuf, errorcode); break; default: /* This may happen on a really early parse error or version not */ /* supported error */ /* TODO log errorcode here */ break; } /* Log traceMsg of message was received and the one that will be sent */ SLPDLogTraceMsg("OUT",peerinfo,*sendbuf); SLPMessageFree(message); /* Log reception of important errors */ switch(errorcode) { case SLP_ERROR_DA_BUSY_NOW: SLPLog("DA_BUSY from %s\n", inet_ntoa(peerinfo->sin_addr)); break; case SLP_ERROR_INTERNAL_ERROR: SLPLog("INTERNAL_ERROR from %s\n", inet_ntoa(peerinfo->sin_addr)); break; case SLP_ERROR_PARSE_ERROR: SLPLog("PARSE_ERROR from %s\n", inet_ntoa(peerinfo->sin_addr)); break; case SLP_ERROR_VER_NOT_SUPPORTED: SLPLog("VER_NOT_SUPPORTED from %s\n", inet_ntoa(peerinfo->sin_addr)); break; } return errorcode; }