/*=========================================================================*/
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;
}
/** 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 SLPDv1ProcessMessage(struct sockaddr_in* peeraddr,
SLPBuffer recvbuf,
SLPBuffer* sendbuf)
/* Processes the SLPv1 message and places the results in sendbuf */
/* */
/* peeraddr - 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. */
/*=========================================================================*/
{
SLPHeader header;
SLPMessage message;
int errorcode = 0;
if (!G_SlpdProperty.isDA)
{
/* SLPv1 messages are handled only by DAs */
errorcode = SLP_ERROR_VER_NOT_SUPPORTED;
}
/* Parse just the message header the reset the buffer "curpos" pointer */
recvbuf->curpos = recvbuf->start;
errorcode = SLPv1MessageParseHeader(recvbuf, &header);
/* TRICKY: Duplicate SRVREG recvbufs *before* parsing them */
/* it because we are going to keep them in the */
if (header.functionid == SLP_FUNCT_SRVREG)
{
recvbuf = SLPBufferDup(recvbuf);
if (recvbuf == NULL)
{
return SLP_ERROR_INTERNAL_ERROR;
}
}
/* Allocate the message descriptor */
message = SLPMessageAlloc();
if (message)
{
/* Parse the message and fill out the message descriptor */
errorcode = SLPv1MessageParseBuffer(peeraddr,recvbuf, message);
if (errorcode == 0)
{
/* Process messages based on type */
switch (message->header.functionid)
{
case SLP_FUNCT_SRVRQST:
errorcode = v1ProcessSrvRqst(peeraddr, message, sendbuf, errorcode);
break;
case SLP_FUNCT_SRVREG:
errorcode = v1ProcessSrvReg(peeraddr,
message,
recvbuf,
sendbuf,
errorcode);
if (errorcode == 0)
{
SLPDKnownDAEcho(message, recvbuf);
}
break;
case SLP_FUNCT_SRVDEREG:
errorcode = v1ProcessSrvDeReg(peeraddr, message, sendbuf, errorcode);
if (errorcode == 0)
{
SLPDKnownDAEcho(message, recvbuf);
}
break;
case SLP_FUNCT_ATTRRQST:
errorcode = v1ProcessAttrRqst(peeraddr, message, sendbuf, errorcode);
break;
case SLP_FUNCT_SRVTYPERQST:
errorcode = v1ProcessSrvTypeRqst(peeraddr, message, sendbuf, errorcode);
break;
case SLP_FUNCT_DAADVERT:
/* we are a SLPv2 DA, ignore other v1 DAs */
(*sendbuf)->end = (*sendbuf)->start;
break;
default:
/* Should never happen... but we're paranoid */
errorcode = SLP_ERROR_PARSE_ERROR;
break;
}
}
if (header.functionid == SLP_FUNCT_SRVREG)
{
/* TRICKY: Do not free the message descriptor for SRVREGs */
/* because we are keeping them in the database */
/* unless there is an error then we free memory */
if (errorcode)
{
SLPMessageFree(message);
SLPBufferFree(recvbuf);
}
}
else
{
SLPMessageFree(message);
}
}
else
{
/* out of memory */
errorcode = SLP_ERROR_INTERNAL_ERROR;
}
return errorcode;
}
