/*=========================================================================*/
int SLPMessageParseBuffer(SLPBuffer buffer, SLPMessage message)
/* Initializes a message descriptor by parsing the specified buffer. */
/* */
/* buffer - (IN) pointer the SLPBuffer to parse */
/* */
/* message - (OUT) set to describe the message from the buffer */
/* */
/* Returns - Zero on success, SLP_ERROR_PARSE_ERROR, or */
/* SLP_ERROR_INTERNAL_ERROR if out of memory. SLPMessage is */
/* invalid return is not successful. */
/* */
/* WARNING - If successful, pointers in the SLPMessage reference memory in*/
/* the parsed SLPBuffer. If SLPBufferFree() is called then the */
/* pointers in SLPMessage will be invalidated. */
/*=========================================================================*/
{
int result;
/* Get ready to parse */
SLPMessageFreeInternals(message);
buffer->curpos = buffer->start;
/* parse the header first */
result = ParseHeader(buffer,&(message->header));
if(result == 0)
{
#if defined(ENABLE_SLPv1)
if(message->header.version == 1)
return SLPv1MessageParseBuffer(buffer, &(message->header),
message);
#endif
/* switch on the function id to parse the body */
switch(message->header.functionid)
{
case SLP_FUNCT_SRVRQST:
result = ParseSrvRqst(buffer,&(message->body.srvrqst));
break;
case SLP_FUNCT_SRVRPLY:
result = ParseSrvRply(buffer,&(message->body.srvrply));
break;
case SLP_FUNCT_SRVREG:
result = ParseSrvReg(buffer,&(message->body.srvreg));
break;
case SLP_FUNCT_SRVDEREG:
result = ParseSrvDeReg(buffer,&(message->body.srvdereg));
break;
case SLP_FUNCT_SRVACK:
result = ParseSrvAck(buffer,&(message->body.srvack));
break;
case SLP_FUNCT_ATTRRQST:
result = ParseAttrRqst(buffer,&(message->body.attrrqst));
break;
case SLP_FUNCT_ATTRRPLY:
result = ParseAttrRply(buffer,&(message->body.attrrply));
break;
case SLP_FUNCT_DAADVERT:
result = ParseDAAdvert(buffer,&(message->body.daadvert));
break;
case SLP_FUNCT_SRVTYPERQST:
result = ParseSrvTypeRqst(buffer,&(message->body.srvtyperqst));
break;
case SLP_FUNCT_SRVTYPERPLY:
result = ParseSrvTypeRply(buffer,&(message->body.srvtyperply));
break;
#if 0
case SLP_FUNCT_SAADVERT:
result = ParseSAAdvert(buffer,&(message->body.saadvert));
break;
#endif
default:
result = SLP_ERROR_MESSAGE_NOT_SUPPORTED;
}
}
return result;
}
/*=========================================================================*/
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;
}
