slp_v1message.c

SLP协议在linux下的实现。此版本为1.2.1版。官方网站为www.openslp.org

        srvreg->scopelist = "default";
        srvreg->scopelistlen = 7;
    }

    /* we don't support auth blocks for SLPv1 - no one uses them anyway */
    srvreg->authcount = 0;
    srvreg->autharray = 0;

    return 0;
}


/*--------------------------------------------------------------------------*/
int v1ParseSrvDeReg(SLPBuffer buffer, SLPHeader* header, SLPSrvDeReg* srvdereg)
/*--------------------------------------------------------------------------*/
{
    int            result;

    /* make sure that min size is met */
    if(buffer->end - buffer->curpos < 4)
    {
        return SLP_ERROR_PARSE_ERROR;
    }

    /* SLPv1 deregistrations do not have a separate scope list */
    srvdereg->scopelistlen = 0;
    srvdereg->scopelist = 0;

    /* parse the url */
    srvdereg->urlentry.reserved = 0; /* not present in SLPv1 */
    srvdereg->urlentry.lifetime = 0; /* not present in SLPv1 */
    srvdereg->urlentry.urllen = AsUINT16(buffer->curpos);
    buffer->curpos += 2;
    if(srvdereg->urlentry.urllen + 2 > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    srvdereg->urlentry.url = buffer->curpos;
    buffer->curpos += srvdereg->urlentry.urllen;
    result = SLPv1AsUTF8(header->encoding, (char *) srvdereg->urlentry.url,
                         &srvdereg->urlentry.urllen);
    if(result)
    {
        return result;
    }

    /* parse the tag list */
    srvdereg->taglistlen = AsUINT16(buffer->curpos);
    buffer->curpos = buffer->curpos + 2;
    if(srvdereg->taglistlen > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    srvdereg->taglist = buffer->curpos;
    buffer->curpos = buffer->curpos + srvdereg->taglistlen;

    result = SLPv1AsUTF8(header->encoding, (char *) srvdereg->taglist,
                         &srvdereg->taglistlen);
    if(result)
        return result;
    return 0;
}


/*--------------------------------------------------------------------------*/
int v1ParseAttrRqst(SLPBuffer buffer, SLPHeader* header, SLPAttrRqst* attrrqst)
/*--------------------------------------------------------------------------*/
{
    int result;

    /* make sure that min size is met */
    if(buffer->end - buffer->curpos < 10)
    {
        return SLP_ERROR_PARSE_ERROR;
    }

    /* parse the prlist */
    attrrqst->prlistlen = AsUINT16(buffer->curpos);
    buffer->curpos = buffer->curpos + 2;
    if(attrrqst->prlistlen + 2 > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    attrrqst->prlist = buffer->curpos;
    buffer->curpos = buffer->curpos + attrrqst->prlistlen;

    result = SLPv1AsUTF8(header->encoding, (char *) attrrqst->prlist,
                         &attrrqst->prlistlen);
    if(result)
        return result;

    /* parse the url */
    attrrqst->urllen = AsUINT16(buffer->curpos);
    buffer->curpos = buffer->curpos + 2;
    if(attrrqst->urllen + 2 > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    attrrqst->url = buffer->curpos;
    buffer->curpos = buffer->curpos + attrrqst->urllen;    

    result = SLPv1AsUTF8(header->encoding, (char *) attrrqst->url,
                         &attrrqst->urllen);
    if(result)
        return result;

    /* parse the scope list */
    attrrqst->scopelistlen = AsUINT16(buffer->curpos);
    buffer->curpos = buffer->curpos + 2;
    if(attrrqst->scopelistlen + 2 > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    if(attrrqst->scopelistlen)
    {
        attrrqst->scopelist = buffer->curpos;
        buffer->curpos += attrrqst->scopelistlen;    
        result = SLPv1AsUTF8(header->encoding, (char *) attrrqst->scopelist,
                             &attrrqst->scopelistlen);
        if(result)
            return result;
    }
    else
    {
        attrrqst->scopelist = "default";
        attrrqst->scopelistlen = 7;
    }

    /* parse the taglist string */
    attrrqst->taglistlen = AsUINT16(buffer->curpos);
    buffer->curpos = buffer->curpos + 2;
    if(attrrqst->taglistlen > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    attrrqst->taglist = buffer->curpos;
    buffer->curpos = buffer->curpos + attrrqst->taglistlen;

    result = SLPv1AsUTF8(header->encoding, (char *) attrrqst->taglist,
                         &attrrqst->taglistlen);
    if(result)
        return result;

    /* SLPv1 service requests don't have SPI strings */
    attrrqst->spistrlen = 0;
    attrrqst->spistr = 0;

    return 0;
}


/*--------------------------------------------------------------------------*/
int v1ParseSrvTypeRqst(SLPBuffer buffer, SLPHeader* header,
                       SLPSrvTypeRqst* srvtyperqst) 
/*--------------------------------------------------------------------------*/
{
    int result;

    /* make sure that min size is met */
    if(buffer->end - buffer->curpos < 6)
    {
        return SLP_ERROR_PARSE_ERROR;
    }

    /* parse the prlist */
    srvtyperqst->prlistlen = AsUINT16(buffer->curpos);
    buffer->curpos += 2;
    if(srvtyperqst->prlistlen + 2 > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    srvtyperqst->prlist = srvtyperqst->prlistlen ? buffer->curpos : 0;
    buffer->curpos += srvtyperqst->prlistlen;

    result = SLPv1AsUTF8(header->encoding, (char *) srvtyperqst->prlist,
                         &srvtyperqst->prlistlen);
    if(result)
        return result;

    /* parse the naming authority if present */
    srvtyperqst->namingauthlen = AsUINT16(buffer->curpos);
    buffer->curpos += 2;
    if(!srvtyperqst->namingauthlen || srvtyperqst->namingauthlen == 0xffff)
    {
        srvtyperqst->namingauth = 0;
    }
    else
    {
        if(srvtyperqst->namingauthlen > buffer->end - buffer->curpos)
        {
            return SLP_ERROR_PARSE_ERROR;
        }
        srvtyperqst->namingauth = buffer->curpos;
        buffer->curpos += srvtyperqst->namingauthlen;
        result = SLPv1AsUTF8(header->encoding,
                             (char *) srvtyperqst->namingauth,
                             &srvtyperqst->namingauthlen);
        if(result)
            return result;
    }

    /* parse the scope list */
    if(buffer->end - buffer->curpos < 2)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    srvtyperqst->scopelistlen = AsUINT16(buffer->curpos);
    buffer->curpos += 2;
    if(srvtyperqst->scopelistlen > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    if(srvtyperqst->scopelistlen)
    {
        srvtyperqst->scopelist = buffer->curpos;
        buffer->curpos += srvtyperqst->scopelistlen;    
        result = SLPv1AsUTF8(header->encoding,
                             (char *) srvtyperqst->scopelist,
                             &srvtyperqst->scopelistlen);
        if(result)
            return result;
    }
    else
    {
        srvtyperqst->scopelist = "default";
        srvtyperqst->scopelistlen = 7;
    }

    return 0;
}

/*=========================================================================*/
int SLPv1MessageParseBuffer(struct sockaddr_in* peerinfo,
                            SLPBuffer buffer, 
                            SLPMessage message) 
/* Initializes a SLPv1 message descriptor by parsing the specified buffer. */
/*                                                                         */
/* peerinfo - (IN pointer to information about where buffer came from      */
/*                                                                         */
/* 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;

    /* Copy in the peer info */
    memcpy(&message->peer,peerinfo,sizeof(message->peer)); 
  
    /* Get ready to parse */
    SLPMessageFreeInternals(message);
    buffer->curpos = buffer->start;

    /* parse the header first */
    result = SLPv1MessageParseHeader(buffer,&(message->header));
    if(result == 0)
    {
        /* switch on the function id to parse the body */
        switch(message->header.functionid)
        {
        case SLP_FUNCT_SRVRQST:
            result = v1ParseSrvRqst(buffer, 
                                    &(message->header), 
                                    &(message->body.srvrqst));
            break;
    
        case SLP_FUNCT_SRVREG:
            result = v1ParseSrvReg(buffer,
                                   &(message->header),
                                   &(message->body.srvreg));
            break;
    
        case SLP_FUNCT_SRVDEREG:
            result = v1ParseSrvDeReg(buffer,
                                     &(message->header),
                                     &(message->body.srvdereg));
            break;
    
        case SLP_FUNCT_ATTRRQST:
            result = v1ParseAttrRqst(buffer, 
                                     &(message->header),
                                     &(message->body.attrrqst));
            break;
    
	case SLP_FUNCT_DAADVERT:
	    /* We are a SLPv2 DA, drop advertisements from other v1
	       DAs (including ourselves). The message will be ignored
	       by SLPDv1ProcessMessage(). */
	    result = 0;
	    break;

        case SLP_FUNCT_SRVTYPERQST:
            result = v1ParseSrvTypeRqst(buffer, 
                                        &(message->header),
                                        &(message->body.srvtyperqst));
            break;
    
        default:
            result = SLP_ERROR_MESSAGE_NOT_SUPPORTED;
        }
    }

    return result;
}