slpd_process.c

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

                         SLP_DA_SERVICE_TYPE) == 0)
    {
        errorcode = ProcessDASrvRqst(message, sendbuf, errorcode);
        if (errorcode == 0)
        {
            // Since we have an errorcode of 0, we were successful,
            // and have already formed a response packet; return now.
            return errorcode;
        }

        goto RESPOND;

    }
    if (SLPCompareString(message->body.srvrqst.srvtypelen,
                         message->body.srvrqst.srvtype,
                         21,
                         SLP_SA_SERVICE_TYPE) == 0)
    {
        errorcode = ProcessSASrvRqst(message, sendbuf, errorcode);
        if (errorcode == 0)
        {
            // Since we have an errorcode of 0, we were successful,
            // and have already formed a response packet; return now.
            return errorcode;
        }

        goto RESPOND;
    }

    /*------------------------------------*/
    /* Make sure that we handle the scope */
    /*------ -----------------------------*/
    if (SLPIntersectStringList(message->body.srvrqst.scopelistlen,
                               message->body.srvrqst.scopelist,
                               G_SlpdProperty.useScopesLen,
                               G_SlpdProperty.useScopes) != 0)
    {
        /*-------------------------------*/
        /* Find services in the database */
        /*-------------------------------*/
        errorcode = SLPDDatabaseSrvRqstStart(message, &db);
    }
    else
    {
        errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
    }

    RESPOND:
    /*----------------------------------------------------------------*/
    /* Do not send error codes or empty replies to multicast requests */
    /*----------------------------------------------------------------*/
    if (errorcode != 0 || db->urlcount == 0)
    {
        if (message->header.flags & SLP_FLAG_MCAST ||
            ISMCAST(message->peer.sin_addr))
        {
            result->end = result->start;
            goto FINISHED;  
        }
    }

    /*-------------------------------------------------------------*/
    /* ensure the buffer is big enough to handle the whole srvrply */
    /*-------------------------------------------------------------*/
    size = message->header.langtaglen + 18; /* 14 bytes for header     */
                                            /*  2 bytes for error code */
                                            /*  2 bytes for url count  */
    if (errorcode == 0)
    {
        for (i=0;i<db->urlcount;i++)
        {
            /* urlentry is the url from the db result */
            urlentry = db->urlarray[i];

            size += urlentry->urllen + 6; /*  1 byte for reserved  */
                                          /*  2 bytes for lifetime */
                                          /*  2 bytes for urllen   */
                                          /*  1 byte for authcount */
#ifdef ENABLE_SLPv2_SECURITY

            /* make room to include the authblock that was asked for */
            if (G_SlpdProperty.securityEnabled &&
                message->body.srvrqst.spistrlen )
            {
                for (j=0; j<urlentry->authcount;j++)
                {
                    if (SLPCompareString(urlentry->autharray[j].spistrlen,
                                         urlentry->autharray[j].spistr,
                                         message->body.srvrqst.spistrlen,
                                         message->body.srvrqst.spistr) == 0)
                    {
                        authblock = &(urlentry->autharray[j]);
                        size += authblock->length;
                        break;
                    }
                }
            }
#endif 
        }
    }

    /*------------------------------*/
    /* Reallocate the result buffer */
    /*------------------------------*/
    result = SLPBufferRealloc(result,size);
    if (result == 0)
    {
        errorcode = SLP_ERROR_INTERNAL_ERROR;
        goto FINISHED;
    }

    /*----------------*/
    /* Add the header */
    /*----------------*/
    /*version*/
    *(result->start)       = 2;
    /*function id*/
    *(result->start + 1)   = SLP_FUNCT_SRVRPLY;
    /*length*/
    ToUINT24(result->start + 2, size);
    /*flags*/
    ToUINT16(result->start + 5,
             (size > SLP_MAX_DATAGRAM_SIZE ? SLP_FLAG_OVERFLOW : 0));
    /*ext offset*/
    ToUINT24(result->start + 7,0);
    /*xid*/
    ToUINT16(result->start + 10,message->header.xid);
    /*lang tag len*/
    ToUINT16(result->start + 12,message->header.langtaglen);
    /*lang tag*/
    memcpy(result->start + 14,
           message->header.langtag,
           message->header.langtaglen);

    /*-------------------------*/
    /* Add rest of the SrvRply */
    /*-------------------------*/
    result->curpos = result->start + 14 + message->header.langtaglen;
    /* error code*/
    ToUINT16(result->curpos, errorcode);
    result->curpos = result->curpos + 2;
    if (errorcode == 0)
    {
        /* urlentry count */
        ToUINT16(result->curpos, db->urlcount);
        result->curpos = result->curpos + 2;

        for (i=0;i<db->urlcount;i++)
        {
            /* urlentry is the url from the db result */
            urlentry = db->urlarray[i]; 

#ifdef ENABLE_SLPv1
            if (urlentry->opaque == 0)
            {
                /* url-entry reserved */
                *result->curpos = 0;        
                result->curpos = result->curpos + 1;
                /* url-entry lifetime */
                ToUINT16(result->curpos,urlentry->lifetime);
                result->curpos = result->curpos + 2;
                /* url-entry urllen */
                ToUINT16(result->curpos,urlentry->urllen);
                result->curpos = result->curpos + 2;
                /* url-entry url */
                memcpy(result->curpos,urlentry->url,urlentry->urllen);
                result->curpos = result->curpos + urlentry->urllen;
                /* url-entry auths */
                *result->curpos = 0;
                result->curpos = result->curpos + 1;
            }
            else
#endif
            {
                /* Use an opaque copy if available (and authentication is not being used)*/
                /* TRICKY: fix up the lifetime */
                ToUINT16(urlentry->opaque + 1,urlentry->lifetime);
                memcpy(result->curpos,urlentry->opaque,urlentry->opaquelen);
                result->curpos = result->curpos + urlentry->opaquelen;
            }
        }
    }
    else
    {
        /* set urlentry count to 0*/
        ToUINT16(result->curpos, 0);
        result->curpos = result->curpos + 2;
    }

    FINISHED:   
    if (db) SLPDDatabaseSrvRqstEnd(db);

    *sendbuf = result;

    return errorcode;
}


/*-------------------------------------------------------------------------*/
int ProcessSrvReg(SLPMessage message,
                  SLPBuffer recvbuf,
                  SLPBuffer* sendbuf,
                  int errorcode)
/*                                                                         */
/* Returns: non-zero if message should be silently dropped                 */
/*-------------------------------------------------------------------------*/
{
    SLPBuffer       result  = *sendbuf;

    /*--------------------------------------------------------------*/
    /* If errorcode is set, we can not be sure that message is good */
    /* Go directly to send response code  also do not process mcast */
    /* srvreg or srvdereg messages                                  */
    /*--------------------------------------------------------------*/
    if (errorcode || 
        message->header.flags & SLP_FLAG_MCAST ||
        ISMCAST(message->peer.sin_addr))
    {
        goto RESPOND;
    }

    /*------------------------------------*/
    /* Make sure that we handle the scope */
    /*------ -----------------------------*/
    if (SLPIntersectStringList(message->body.srvreg.scopelistlen,
                               message->body.srvreg.scopelist,
                               G_SlpdProperty.useScopesLen,
                               G_SlpdProperty.useScopes))
    {

#ifdef ENABLE_SLPv2_SECURITY

        /*-------------------------------*/
        /* Validate the authblocks       */
        /*-------------------------------*/
        errorcode = SLPAuthVerifyUrl(G_SlpdSpiHandle,
                                     0,
                                     &(message->body.srvreg.urlentry));
        if (errorcode == 0)
        {
            errorcode = SLPAuthVerifyString(G_SlpdSpiHandle,
                                            0,
                                            message->body.srvreg.attrlistlen,
                                            message->body.srvreg.attrlist,
                                            message->body.srvreg.authcount,
                                            message->body.srvreg.autharray);
        }
        if (errorcode == 0)
#endif
        {
            /*--------------------------------------------------------------*/
            /* Put the registration in the                                  */
            /*--------------------------------------------------------------*/
            /* TRICKY: Remember the recvbuf was duplicated back in          */
            /*         SLPDProcessMessage()                                 */

            if (ISLOCAL(message->peer.sin_addr))
            {
                message->body.srvreg.source= SLP_REG_SOURCE_LOCAL;
            }
            else
            {
                message->body.srvreg.source = SLP_REG_SOURCE_REMOTE;
            }

            errorcode = SLPDDatabaseReg(message, recvbuf);
        }
    }
    else
    {
        errorcode = SLP_ERROR_SCOPE_NOT_SUPPORTED;
    }

    RESPOND:    
    /*--------------------------------------------------------------------*/
    /* don't send back reply anything multicast SrvReg (set result empty) */
    /*--------------------------------------------------------------------*/
    if (message->header.flags & SLP_FLAG_MCAST ||
        ISMCAST(message->peer.sin_addr))
    {
        result->end = result->start;
        goto FINISHED;
    }


    /*------------------------------------------------------------*/
    /* ensure the buffer is big enough to handle the whole srvack */
    /*------------------------------------------------------------*/
    result = SLPBufferRealloc(result,message->header.langtaglen + 16);
    if (result == 0)
    {
        errorcode = SLP_ERROR_INTERNAL_ERROR;
        goto FINISHED;
    }

    /*----------------*/
    /* Add the header */
    /*----------------*/
    /*version*/
    *(result->start)       = 2;
    /*function id*/
    *(result->start + 1)   = SLP_FUNCT_SRVACK;
    /*length*/
    ToUINT24(result->start + 2,message->header.langtaglen + 16);
    /*flags*/
    ToUINT16(result->start + 5,0);
    /*ext offset*/
    ToUINT24(result->start + 7,0);
    /*xid*/
    ToUINT16(result->start + 10,message->header.xid);
    /*lang tag len*/
    ToUINT16(result->start + 12,message->header.langtaglen);
    /*lang tag*/
    memcpy(result->start + 14,
           message->header.langtag,
           message->header.langtaglen);

    /*-------------------*/
    /* Add the errorcode */
    /*-------------------*/
    ToUINT16(result->start + 14 + message->header.langtaglen, errorcode);

    FINISHED:
    *sendbuf = result;
    return errorcode;
}


/*-------------------------------------------------------------------------*/
int ProcessSrvDeReg(SLPMessage message,
                    SLPBuffer* sendbuf,
                    int errorcode)
/*                                                                         */
/* Returns: non-zero if message should be silently dropped                 */
/*-------------------------------------------------------------------------*/
{
    SLPBuffer result = *sendbuf;

    /*--------------------------------------------------------------*/
    /* If errorcode is set, we can not be sure that message is good */
    /* Go directly to send response code  also do not process mcast */
    /* srvreg or srvdereg messages                                  */
    /*--------------------------------------------------------------*/
    if (errorcode || message->header.flags & SLP_FLAG_MCAST)
    {
        goto RESPOND;
    }


    /*------------------------------------*/
    /* Make sure that we handle the scope */
    /*------------------------------------*/
    if (SLPIntersectStringList(message->body.srvdereg.scopelistlen,
                               message->body.srvdereg.scopelist,
                               G_SlpdProperty.useScopesLen,
                               G_SlpdProperty.useScopes))
    {
#ifdef ENABLE_SLPv2_SECURITY

        /*-------------------------------*/
        /* Validate the authblocks       */
        /*-------------------------------*/
        errorcode = SLPAuthVerifyUrl(G_SlpdSpiHandle,
                                     0,
                                     &(message->body.srvdereg.urlentry));
        if (errorcode == 0)
#endif
        {
            /*--------------------------------------*/
            /* remove the service from the database */
            /*--------------------------------------*/
            errorcode = SLPDDatabaseDeReg(message);
        }
    }
    else
    {