libslp_reg.c

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

    curpos = curpos + handle->params.reg.attrlistlen;
    /* attribute auth block */
#ifdef ENABLE_SLPv2_SECURITY
    if(attrauth)
    {
        /* authcount */
        *curpos = 1;
        curpos = curpos + 1;
        /* authblock */
        memcpy(curpos,attrauth,attrauthlen);
        curpos = curpos + attrauthlen;
    }
    else
#endif
    {
        /* authcount */
        *curpos = 0;
        curpos = curpos + 1;
    }

    /* Put in the SLP_EXTENSION_ID_REG_PID */
    if(SLPPropertyAsBoolean(SLPGetProperty("net.slp.watchRegistrationPID")))
    {
        extoffset = curpos - buf;
        ToUINT16(curpos,SLP_EXTENSION_ID_REG_PID);
        curpos += 2;
        ToUINT24(curpos,0);
        curpos += 3;
        ToUINT32(curpos,SLPPidGet());
        curpos += 4;
    }

    /*--------------------------*/
    /* Call the RqstRply engine */
    /*--------------------------*/
    sock = NetworkConnectToSA(handle,
                              handle->params.reg.scopelist,
                              handle->params.reg.scopelistlen,
                              &peeraddr);
    if(sock >= 0)
    {
        result = NetworkRqstRply(sock,
				 &peeraddr,
				 handle->langtag,
				 extoffset,
				 buf,
				 SLP_FUNCT_SRVREG,
				 bufsize,
				 CallbackSrvReg,
				 handle);
        if (result)
        {
            NetworkDisconnectSA(handle);
        }   
    }
    else
    {
        result = SLP_NETWORK_INIT_FAILED;    
    }

   
    FINISHED:
    if(buf) xfree(buf);
    
#ifdef ENABLE_SLPv2_SECURITY
    if(urlauth) xfree(urlauth);
    if(attrauth) xfree(attrauth);
#endif 

    return result;
}

#ifdef ENABLE_ASYNC_API
/*-------------------------------------------------------------------------*/ 
SLPError AsyncProcessSrvReg(PSLPHandleInfo handle)
/*-------------------------------------------------------------------------*/
{
    SLPError result = ProcessSrvReg(handle);

    xfree((void*)handle->params.reg.url);
    xfree((void*)handle->params.reg.srvtype);
    xfree((void*)handle->params.reg.scopelist);
    xfree((void*)handle->params.reg.attrlist);

    handle->inUse = SLP_FALSE;

    return result;
}
#endif


/*=========================================================================*/
SLPError SLPAPI SLPReg(SLPHandle   hSLP,
                const char  *srvUrl,
                const unsigned short lifetime,
                const char  *srvType,
                const char  *attrList,
                SLPBoolean fresh,
                SLPRegReport callback,
                void *cookie)
/*                                                                         */
/* See slplib.h for detailed documentation                                 */
/*=========================================================================*/
{
    PSLPHandleInfo      handle      = 0;
    SLPError            result      = SLP_OK;
    SLPSrvURL*          parsedurl   = 0;

    /*------------------------------*/
    /* check for invalid parameters */
    /*------------------------------*/
    if(hSLP        == 0 ||
       *(unsigned int*)hSLP != SLP_HANDLE_SIG ||
       srvUrl      == 0 ||
       *srvUrl     == 0 ||  /* srvUrl can't be empty string */
       lifetime    == 0 ||  /* lifetime can not be zero */
       attrList    == 0 ||
       callback    == 0)
    {
        return SLP_PARAMETER_BAD;
    }

    /*---------------------------------------------*/
    /* We don't handle non-fresh registrations     */
    /*---------------------------------------------*/
    if(fresh == SLP_FALSE)
    {
        return SLP_NOT_IMPLEMENTED;
    }

    /*-----------------------------------------*/
    /* cast the SLPHandle into a SLPHandleInfo */
    /*-----------------------------------------*/
    handle = (PSLPHandleInfo)hSLP;

    /*-----------------------------------------*/
    /* Check to see if the handle is in use    */
    /*-----------------------------------------*/
    if(handle->inUse == SLP_TRUE)
    {
        return SLP_HANDLE_IN_USE;
    }
    handle->inUse = SLP_TRUE;

    /*------------------*/
    /* Parse the srvurl */
    /*------------------*/
    result = SLPParseSrvURL(srvUrl,&parsedurl);
    if(result)
    {
        if(result == SLP_PARSE_ERROR)
        {
            result = SLP_INVALID_REGISTRATION;
        }

        if(parsedurl) SLPFree(parsedurl);
        handle->inUse = SLP_FALSE;
        return result;
    }

    /*-------------------------------------------*/
    /* Set the handle up to reference parameters */
    /*-------------------------------------------*/
    handle->params.reg.fresh         = fresh;
    handle->params.reg.lifetime      = lifetime;
    handle->params.reg.urllen        = strlen(srvUrl);
    handle->params.reg.url           = srvUrl;
    handle->params.reg.srvtype       = parsedurl->s_pcSrvType;
    handle->params.reg.srvtypelen    = strlen(handle->params.reg.srvtype);
    handle->params.reg.scopelist     = SLPGetProperty("net.slp.useScopes");
    if(handle->params.reg.scopelist)
    {
        handle->params.reg.scopelistlen  = strlen(handle->params.reg.scopelist);
    }
    handle->params.reg.attrlistlen   = strlen(attrList);
    handle->params.reg.attrlist      = attrList;
    handle->params.reg.callback      = callback;
    handle->params.reg.cookie        = cookie; 

#ifdef ENABLE_ASYNC_API
    /*----------------------------------------------*/
    /* Check to see if we should be async or sync   */
    /*----------------------------------------------*/
    if(handle->isAsync)
    {
        /* Copy all of the referenced parameters before making thread */
        handle->params.reg.url = xstrdup(handle->params.reg.url);
        handle->params.reg.srvtype = xstrdup(handle->params.reg.url);
        handle->params.reg.scopelist = xstrdup(handle->params.reg.scopelist);
        handle->params.reg.attrlist = xstrdup(handle->params.reg.attrlist);

        /* make sure that the strdups did not fail */
        if(handle->params.reg.url &&
           handle->params.reg.srvtype &&
           handle->params.reg.scopelist &&
           handle->params.reg.attrlist)
        {
            result = ThreadCreate((ThreadStartProc)AsyncProcessSrvReg,handle);
        }
        else
        {
            result = SLP_MEMORY_ALLOC_FAILED;    
        }

        if(result)
        {
            if(handle->params.reg.url) xfree((void*)handle->params.reg.url);
            if(handle->params.reg.srvtype) xfree((void*)handle->params.reg.srvtype);
            if(handle->params.reg.scopelist) xfree((void*)handle->params.reg.scopelist);
            if(handle->params.reg.attrlist) xfree((void*)handle->params.reg.attrlist);
            handle->inUse = SLP_FALSE;
        }
    }
    else
#endif //ffdef ENABLE_ASYNC_API    
    {
        result = ProcessSrvReg(handle);            
        handle->inUse = SLP_FALSE;
    }

    if(parsedurl) SLPFree(parsedurl);

    return result;
}