slp_message.c

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

        srvtyperqst->namingauth = buffer->curpos;
        buffer->curpos += srvtyperqst->namingauthlen;
    }

    /* 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;
    }
    srvtyperqst->scopelist = buffer->curpos;
    buffer->curpos += srvtyperqst->scopelistlen;    

    return 0;
}


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

    /* parse out the error code */
    srvtyperply->errorcode = AsUINT16(buffer->curpos);
    if(srvtyperply->errorcode)
    {
        /* We better not trust the rest of the packet */
        memset(srvtyperply,0,sizeof(SLPSrvTypeRply));
        srvtyperply->errorcode = AsUINT16(buffer->curpos);
        return 0;
    }
    buffer->curpos += 2;

    /* parse out the error srvtype-list length */
    srvtyperply->srvtypelistlen = AsUINT16(buffer->curpos);
    buffer->curpos += 2;

    if(srvtyperply->srvtypelistlen > buffer->end - buffer->curpos)
    {
        return SLP_ERROR_PARSE_ERROR;
    }
    srvtyperply->srvtypelist = buffer->curpos;

    return 0;
}

/*--------------------------------------------------------------------------*/
int ParseExtension(SLPBuffer buffer, SLPMessage message)
/* Parse extensions *after* all standard protocol fields are parsed         */
/*--------------------------------------------------------------------------*/
{
    int             extid;
    int             nextoffset;
    int             result  = SLP_ERROR_OK;

    nextoffset = message->header.extoffset;
    while(nextoffset)
    {
        buffer->curpos = buffer->start + nextoffset;
        if(buffer->curpos + 5 >= buffer->end)
        {
            /* Extension takes us past the end of the buffer */
            result = SLP_ERROR_PARSE_ERROR;
            goto CLEANUP;
        }
    
        extid = AsUINT16(buffer->curpos);
        buffer->curpos += 2;

        nextoffset = AsUINT24(buffer->curpos);
        buffer->curpos += 3;
        
        switch(extid)
        {
        case SLP_EXTENSION_ID_REG_PID:
            if(message->header.functionid == SLP_FUNCT_SRVREG)
            {
                /* check to see if buffer is large enough to contain the 4 byte pid */
                if(buffer->curpos + 4 > buffer->end)
                {
                    result = SLP_ERROR_PARSE_ERROR;
                    goto CLEANUP;
                }
                
                message->body.srvreg.pid = AsUINT32(buffer->curpos);
                buffer->curpos += 4;
            }
            break;

        default:
            if (extid >= 0x4000 && extid <= 0x7FFF )
            {
                /* This is a required extension.  We better error out */
                result = SLP_ERROR_MESSAGE_NOT_SUPPORTED;
                goto CLEANUP;
            }
            break;
        }
    }

CLEANUP:
    
    return result;
}

/*=========================================================================*/
void SLPMessageFreeInternals(SLPMessage message)
/*=========================================================================*/
{
    int i;

    switch(message->header.functionid)
    {
    case SLP_FUNCT_SRVRPLY:
        if(message->body.srvrply.urlarray)
        {
            for(i=0;i<message->body.srvrply.urlcount;i++)
            {
                if(message->body.srvrply.urlarray[i].autharray)
                {
                    xfree(message->body.srvrply.urlarray[i].autharray);
                    message->body.srvrply.urlarray[i].autharray = 0;
                }
            }

            xfree(message->body.srvrply.urlarray);
            message->body.srvrply.urlarray = 0;
        }
        break;

    case SLP_FUNCT_SRVREG:
        if(message->body.srvreg.urlentry.autharray)
        {
            xfree(message->body.srvreg.urlentry.autharray);
            message->body.srvreg.urlentry.autharray = 0;
        }
        if(message->body.srvreg.autharray)
        {
            xfree(message->body.srvreg.autharray);
            message->body.srvreg.autharray = 0;
        }
        break;


    case SLP_FUNCT_SRVDEREG:
        if(message->body.srvdereg.urlentry.autharray)
        {
            xfree(message->body.srvdereg.urlentry.autharray);
            message->body.srvdereg.urlentry.autharray = 0;
        }
        break;

    case SLP_FUNCT_ATTRRPLY:
        if(message->body.attrrply.autharray)
        {
            xfree(message->body.attrrply.autharray);
            message->body.attrrply.autharray = 0;
        }
        break;


    case SLP_FUNCT_DAADVERT:
        if(message->body.daadvert.autharray)
        {
            xfree(message->body.daadvert.autharray);
            message->body.daadvert.autharray = 0;
        }
        break; 

    case SLP_FUNCT_SAADVERT:
        if(message->body.saadvert.autharray)
        {
            xfree(message->body.saadvert.autharray);
            message->body.saadvert.autharray = 0;
        }
        break; 

    case SLP_FUNCT_ATTRRQST:
    case SLP_FUNCT_SRVACK:
    case SLP_FUNCT_SRVRQST:
    case SLP_FUNCT_SRVTYPERQST:
    case SLP_FUNCT_SRVTYPERPLY:
    default:
        /* don't do anything */
        break;
    }
}

/*=========================================================================*/
SLPMessage SLPMessageAlloc()
/* Allocates memory for a SLP message descriptor                           */
/*                                                                         */
/* Returns   - A newly allocated SLPMessage pointer of NULL on ENOMEM      */
/*=========================================================================*/
{
    SLPMessage result = (SLPMessage)xmalloc(sizeof(struct _SLPMessage));
    if(result)
    {
        memset(result,0,sizeof(struct _SLPMessage));
    }

    return result;
}


/*=========================================================================*/
SLPMessage SLPMessageRealloc(SLPMessage msg)
/* Reallocates memory for a SLP message descriptor                         */
/*                                                                         */
/* Returns   - A newly allocated SLPMessage pointer of NULL on ENOMEM      */
/*=========================================================================*/
{
    if(msg == 0)
    {
        msg = SLPMessageAlloc();
        if(msg == 0)
        {
            return 0;
        }
    }
    else
    {
        SLPMessageFreeInternals(msg);
    }

    return msg;
}


/*=========================================================================*/
void SLPMessageFree(SLPMessage message)
/* Frees memory that might have been allocated by the SLPMessage for       */
/* UrlEntryLists or AuthBlockLists.                                        */
/*                                                                         */
/* message  - (IN) the SLPMessage to free                                  */
/*=========================================================================*/
{
    if(message)
    {
        SLPMessageFreeInternals(message);
        xfree(message);
    }
}


/*=========================================================================*/
int SLPMessageParseBuffer(struct sockaddr_in* peerinfo,
                          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;

    /* 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 = SLPMessageParseHeader(buffer,&(message->header));
    if(result == 0)
    {
        /* 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;

        case SLP_FUNCT_SAADVERT:
            result = ParseSAAdvert(buffer,&(message->body.saadvert));
            break;
        default:
            result = SLP_ERROR_MESSAGE_NOT_SUPPORTED;
        }
    }

    if(result == 0 && message->header.extoffset)
    {
        result = ParseExtension(buffer,message);
    }

    return result;
}

/*=========================================================================*/
/* Functions used to parse buffers                                         */

/*-------------------------------------------------------------------------*/
unsigned short AsUINT16(const char *charptr)
/*-------------------------------------------------------------------------*/
{
    unsigned char *ucp = (unsigned char *) charptr;
    return(ucp[0] << 8) | ucp[1];
}

/*-------------------------------------------------------------------------*/
unsigned int AsUINT24(const char *charptr)
/*-------------------------------------------------------------------------*/
{
    unsigned char *ucp = (unsigned char *) charptr;
    return(ucp[0] << 16) | (ucp[1] << 8) |  ucp[2];
}

/*-------------------------------------------------------------------------*/
unsigned int AsUINT32(const char *charptr)
/*-------------------------------------------------------------------------*/
{
    unsigned char *ucp = (unsigned char *) charptr;
    return(ucp[0] << 24) | (ucp[1] << 16) | (ucp[2] << 8) | ucp[3]; 
}

/*=========================================================================*/
/* Functions used to set buffers                                           */

/*-------------------------------------------------------------------------*/
void ToUINT16(char *charptr, unsigned int val)
/*-------------------------------------------------------------------------*/
{
    charptr[0] = (val >> 8) & 0xff;
    charptr[1] = val & 0xff;
}

/*-------------------------------------------------------------------------*/
void ToUINT24(char *charptr, unsigned int val)
/*-------------------------------------------------------------------------*/
{
    charptr[0] = (val >> 16) & 0xff;
    charptr[1] = (val >> 8) & 0xff;
    charptr[2] = val & 0xff;
}

/*-------------------------------------------------------------------------*/
void ToUINT32(char *charptr, unsigned int val)
/*-------------------------------------------------------------------------*/
{
    charptr[0] = (val >> 24) & 0xff;
    charptr[1] = (val >> 16) & 0xff;
    charptr[2] = (val >> 8) & 0xff;
    charptr[3] = val & 0xff;
}