/*=========================================================================*/ 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; }