/** Thread start procedure for asynchronous service type request.
*
* @param[in,out] handle - Contains the request parameters, returns the
* request result.
*
* @return An SLPError code.
*
* @internal
*/
static SLPError AsyncProcessSrvTypeRqst(SLPHandleInfo * handle)
{
SLPError result = ProcessSrvTypeRqst(handle);
xfree((void *)handle->params.findsrvtypes.namingauth);
xfree((void *)handle->params.findsrvtypes.scopelist);
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;
}
/** 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;
}
/*=========================================================================*/
SLPError SLPFindSrvTypes(SLPHandle hSLP,
const char *pcNamingAuthority,
const char *pcScopeList,
SLPSrvTypeCallback callback,
void *pvCookie)
/* */
/* Issue the query for service types 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 service types. */
/* */
/* pcNamingAuthority The Naming Authority string for which service types */
/* for which service types are returned */
/* */
/* 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. */
/* */
/* 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 ||
!pcNamingAuthority ||
strcmp(pcNamingAuthority, "IANA") == 0 ||
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.findsrvtypes.namingauthlen = strlen(pcNamingAuthority);
handle->params.findsrvtypes.namingauth = pcNamingAuthority;
if(pcScopeList && *pcScopeList)
{
handle->params.findsrvtypes.scopelist = pcScopeList;
}
else
{
handle->params.findsrvtypes.scopelist =
SLPGetProperty("net.slp.useScopes");
}
handle->params.findsrvtypes.scopelistlen =
strlen(handle->params.findsrvtypes.scopelist);
handle->params.findsrvtypes.callback = callback;
handle->params.findsrvtypes.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.findsrvtypes.namingauth = xstrdup(handle->params.findsrvtypes.namingauth);
handle->params.findsrvtypes.scopelist = xstrdup(handle->params.findsrvtypes.scopelist);
/* make sure strdups did not fail */
if(handle->params.findsrvtypes.namingauth &&
handle->params.findsrvtypes.scopelist)
{
result = ThreadCreate((ThreadStartProc)AsyncProcessSrvTypeRqst,handle);
}
else
{
result = SLP_MEMORY_ALLOC_FAILED;
}
if(result)
{
if(handle->params.findsrvtypes.namingauth) xfree((void*)handle->params.findsrvtypes.namingauth);
if(handle->params.findsrvtypes.scopelist) xfree((void*)handle->params.findsrvtypes.scopelist);
handle->inUse = SLP_FALSE;
}
}
else
#endif /*ifdef ENABLE_ASYNC_API*/
{
/* Leave all parameters REFERENCED */
result = ProcessSrvTypeRqst(handle);
handle->inUse = SLP_FALSE;
}
return result;
}
/*=========================================================================*/
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;
}
/** Return a list of service types available on the network.
*
* The SLPFindSrvType function issues an SLP service type request for
* service types in the scopes indicated by the @p pcScopeList. The
* results are returned through the @p callback parameter. The service
* types are independent of language locale, but only for services
* registered in one of scopes and for the indicated naming authority.
*
* @par
* If the naming authority is "*", then results are returned for all
* naming authorities. If the naming authority is the empty string,
* i.e. "", then the default naming authority, "IANA", is used. "IANA"
* is not a valid naming authority name, and it is a PARAMETER_BAD error
* to include it explicitly.
*
* @par
* The service type names are returned with the naming authority intact.
* If the naming authority is the default (i.e. empty string) then it
* is omitted, as is the separating ".". Service type names from URLs
* of the service: scheme are returned with the "service:" prefix
* intact. [RFC 2608] See [RFC 2609] for more information on the
* syntax of service type names.
*
* @param[in] hSLP - The SLPHandle on which to search for types.
* @param[in] pcNamingAuthority - The naming authority to search. Use "*"
* for all naming authorities and the empty string, "", for the default
* naming authority.
* @param[in] pcScopeList - A pointer to a char containing comma separated
* list of scope names to search for service types. May not be the empty
* string, "".
* @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.
*/
SLPError SLPAPI SLPFindSrvTypes(
SLPHandle hSLP,
const char * pcNamingAuthority,
const char * pcScopeList,
SLPSrvTypeCallback 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(pcNamingAuthority != 0);
SLP_ASSERT(strcmp(pcNamingAuthority, "IANA") != 0);
SLP_ASSERT(callback != 0);
if (handle == 0 || handle->sig != SLP_HANDLE_SIG
|| pcNamingAuthority == 0
|| strcmp(pcNamingAuthority, "IANA") == 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 none was specified. */
if (pcScopeList == 0 || *pcScopeList == 0)
pcScopeList = SLPPropertyGet("net.slp.useScopes", 0, 0);
/* Set the handle up to reference parameters. */
handle->params.findsrvtypes.namingauthlen = strlen(pcNamingAuthority);
handle->params.findsrvtypes.namingauth = pcNamingAuthority;
handle->params.findsrvtypes.scopelistlen = strlen(pcScopeList);
handle->params.findsrvtypes.scopelist = pcScopeList;
handle->params.findsrvtypes.callback = callback;
handle->params.findsrvtypes.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.findsrvtypes.namingauth =
xstrdup(handle->params.findsrvtypes.namingauth);
handle->params.findsrvtypes.scopelist =
xstrdup(handle->params.findsrvtypes.scopelist);
/* Ensure strdups and thread create succeed. */
if (handle->params.findsrvtypes.namingauth == 0
|| handle->params.findsrvtypes.scopelist == 0
|| (handle->th = SLPThreadCreate((SLPThreadStartProc)
AsyncProcessSrvTypeRqst, handle)) == 0)
{
serr = SLP_MEMORY_ALLOC_FAILED;
xfree((void *)handle->params.findsrvtypes.namingauth);
xfree((void *)handle->params.findsrvtypes.scopelist);
SLPSpinLockRelease(&handle->inUse);
}
return serr;
}
#endif
/* Reference all parameters. */
serr = ProcessSrvTypeRqst(handle);
SLPSpinLockRelease(&handle->inUse);
return serr;
}