slpd_process.c

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

        goto RESPOND;
    } 

    /*-------------------------------*/
    /* Validate the authblocks       */
    /*-------------------------------*/
#ifdef ENABLE_SLPv2_SECURITY
    errorcode = SLPAuthVerifyDAAdvert(G_SlpdSpiHandle,
                                      0,
                                      &(message->body.daadvert));
    if (errorcode == 0);
#endif
    {
        /* Only process if errorcode is not set */
        if (message->body.daadvert.errorcode == SLP_ERROR_OK)
        {
            errorcode = SLPDKnownDAAdd(message,recvbuf);
        }
    }

    RESPOND:
    /* DAAdverts should never be replied to.  Set result buffer to empty*/
    result->end = result->start;  

    *sendbuf = result;

    return errorcode;
}


/*-------------------------------------------------------------------------*/
int ProcessSrvTypeRqst(SLPMessage message,
                       SLPBuffer* sendbuf,
                       int errorcode)
/*-------------------------------------------------------------------------*/
{
    int                             size    = 0;
    SLPDDatabaseSrvTypeRqstResult*  db      = 0;
    SLPBuffer                       result  = *sendbuf;

    /*--------------------------------------------------------------*/
    /* If errorcode is set, we can not be sure that message is good */
    /* Go directly to send response code                            */
    /*--------------------------------------------------------------*/
    if (errorcode)
    {
        goto RESPOND;
    }


    /*-------------------------------------------------*/
    /* Check for one of our IP addresses in the prlist */
    /*-------------------------------------------------*/
    if (SLPIntersectStringList(message->body.srvtyperqst.prlistlen,
                               message->body.srvtyperqst.prlist,
                               G_SlpdProperty.interfacesLen,
                               G_SlpdProperty.interfaces))
    {
        /* Silently ignore */
        result->end = result->start;
        goto FINISHED;  
    }

    /*------------------------------------*/
    /* Make sure that we handle the scope */
    /*------ -----------------------------*/
    if (SLPIntersectStringList(message->body.srvtyperqst.scopelistlen,
                               message->body.srvtyperqst.scopelist,
                               G_SlpdProperty.useScopesLen,
                               G_SlpdProperty.useScopes) != 0)
    {
        /*------------------------------------*/
        /* Find service types in the database */
        /*------------------------------------*/
        errorcode = SLPDDatabaseSrvTypeRqstStart(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->srvtypelistlen == 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 srvtyperply */
    /*-----------------------------------------------------------------*/
    size = message->header.langtaglen + 18; /* 14 bytes for header     */
                                            /*  2 bytes for error code */
                                            /*  2 bytes for srvtype
                                                list length  */
    if(errorcode == 0)
    {
        size += db->srvtypelistlen;
    }


    /*------------------------------*/
    /* 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_SRVTYPERPLY;
    /*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 SrvTypeRply */
    /*-----------------------------*/
    result->curpos = result->start + 14 + message->header.langtaglen;

    /* error code*/
    ToUINT16(result->curpos, errorcode);
    result->curpos += 2;

    if (errorcode == 0)
    {
        /* length of srvtype-list */
        ToUINT16(result->curpos, db->srvtypelistlen);
        result->curpos += 2;     
        memcpy(result->curpos, 
               db->srvtypelist,
               db->srvtypelistlen);
        result->curpos += db->srvtypelistlen;
    }


    FINISHED:   
    if (db) SLPDDatabaseSrvTypeRqstEnd(db);

    *sendbuf = result;

    return errorcode;
}

/*-------------------------------------------------------------------------*/
int ProcessSAAdvert(SLPMessage message,
                    SLPBuffer* sendbuf,
                    int errorcode)
/*-------------------------------------------------------------------------*/
{
    /* Ignore all SAADVERTS */
    (*sendbuf)->end = (*sendbuf)->start;
    return errorcode;
}


/*=========================================================================*/
int SLPDProcessMessage(struct sockaddr_in* peerinfo,
                       SLPBuffer recvbuf,
                       SLPBuffer* sendbuf)
/* Processes the recvbuf and places the results in sendbuf                 */
/*                                                                         */
/* peerinfo   - the socket the message was received on                     */
/*                                                                         */
/* recvbuf  - message to process                                           */
/*                                                                         */
/* sendbuf  - results of the processed message                             */
/*                                                                         */
/* Returns  - zero on success if sendbuf contains a response to send.      */
/*           non-zero if sendbuf does not contain a response to send       */
/*=========================================================================*/
{
    SLPHeader   header;
    SLPMessage  message     = 0;
    int         errorcode   = 0;

    SLPDLogMessage(SLPDLOG_TRACEMSG_IN,peerinfo,recvbuf);

    if(!*sendbuf)
    {
	*sendbuf = SLPBufferAlloc(SLP_MAX_DATAGRAM_SIZE);
	if (!*sendbuf)
	    return SLP_ERROR_PARSE_ERROR;
    }
    /* set the sendbuf empty */
    (*sendbuf)->end = (*sendbuf)->start;

    /* zero out the header before parsing it */
    memset(&header,0,sizeof(header));

    /* Parse just the message header */
    recvbuf->curpos = recvbuf->start;
    errorcode = SLPMessageParseHeader(recvbuf,&header);

    /* Reset the buffer "curpos" pointer so that full message can be 
     * parsed later
     */
    recvbuf->curpos = recvbuf->start;

#if defined(ENABLE_SLPv1)   
    /* if version == 1 then parse message as a version 1 message */
    if (errorcode == SLP_ERROR_VER_NOT_SUPPORTED &&
        header.version == 1)
    {
        errorcode = SLPDv1ProcessMessage(peerinfo, 
                                         recvbuf, 
                                         sendbuf);
    }
    else
#endif
    if (errorcode == 0)
    {
        /* TRICKY: Duplicate SRVREG recvbufs *before* parsing them     */
        /*         we do this because we are going to keep track of    */
        /*         in the registration database                        */
        if (header.functionid == SLP_FUNCT_SRVREG ||
            header.functionid == SLP_FUNCT_DAADVERT )
        {
            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 = SLPMessageParseBuffer(peerinfo,recvbuf, message);
            if (errorcode == 0)
            {
                /* Process messages based on type */
                switch (message->header.functionid)
                {
                case SLP_FUNCT_SRVRQST:
                    errorcode = ProcessSrvRqst(message,sendbuf,errorcode);
                    break;

                case SLP_FUNCT_SRVREG:
                    errorcode = ProcessSrvReg(message,recvbuf,sendbuf,errorcode);
                    if (errorcode == 0)
                    {
                        SLPDKnownDAEcho(message, recvbuf);         
                    }
                    break;

                case SLP_FUNCT_SRVDEREG:
                    errorcode = ProcessSrvDeReg(message,sendbuf,errorcode);
                    if (errorcode == 0)
                    {
                        SLPDKnownDAEcho(message, recvbuf);         
                    }
                    break;

                case SLP_FUNCT_SRVACK:
                    errorcode = ProcessSrvAck(message,sendbuf, errorcode);        
                    break;

                case SLP_FUNCT_ATTRRQST:
                    errorcode = ProcessAttrRqst(message,sendbuf, errorcode);
                    break;

                case SLP_FUNCT_DAADVERT:
                    errorcode = ProcessDAAdvert(message,
                                                recvbuf,
                                                sendbuf,
                                                errorcode);
                    break;

                case SLP_FUNCT_SRVTYPERQST:
                    errorcode = ProcessSrvTypeRqst(message, sendbuf, errorcode);
                    break;

                case SLP_FUNCT_SAADVERT:
                    errorcode = ProcessSAAdvert(message, sendbuf, errorcode);
                    break;

                default:
                    /* Should never happen... but we're paranoid */
                    errorcode = SLP_ERROR_PARSE_ERROR;
                    break;
                }
            }
            else
            {
                SLPDLogParseWarning(peerinfo, recvbuf);
            }
                            
            if (header.functionid == SLP_FUNCT_SRVREG ||
                header.functionid == SLP_FUNCT_DAADVERT )
            {
                /* TRICKY: If this is a reg or daadvert message we do not
                * free the message descriptor or duplicated recvbuf 
                * because they are being kept in the database!
                *
                */
                if (errorcode == 0)
                {
                    goto FINISHED;
                }

                /* TRICKY: If there is an error we need to free the 
                 * duplicated recvbuf,
                 */
                SLPBufferFree(recvbuf);                    
            }

            SLPMessageFree(message);
        }
        else
        {
            /* out of memory */
            errorcode = SLP_ERROR_INTERNAL_ERROR;
        }
    }
    else
    {
        SLPDLogParseWarning(peerinfo,recvbuf);
    }

    FINISHED:

#ifdef DEBUG
    if (errorcode)
    {
        SLPDLog("\n*** DEBUG *** errorcode %i during processing of message from %s\n",
                errorcode,
                inet_ntoa(peerinfo->sin_addr));
    }
#endif
 
    /* Log message silently ignored because of an error */
    if(errorcode)
    {
        if (*sendbuf == 0 ||
            (*sendbuf)->end == (*sendbuf)->start )
        {
            SLPDLogMessage(SLPDLOG_TRACEDROP,peerinfo,recvbuf);
        }
    } 
    
    /* Log trace message */
    SLPDLogMessage(SLPDLOG_TRACEMSG_OUT, peerinfo, *sendbuf);

    return errorcode;
}