slpd_knownda.c

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

    }
    size += srvreg->scopelistlen;
    /* taglistlen is always 0 */

    *outbuf = sendbuf = SLPBufferAlloc(size);
    if (*outbuf == NULL)
    {
        return SLP_ERROR_INTERNAL_ERROR;
    }

    /*----------------------*/
    /* Construct a SrvDereg */
    /*----------------------*/
    /*version*/
    *(sendbuf->start)       = 2;
    /*function id*/
    *(sendbuf->start + 1)   = SLP_FUNCT_SRVDEREG;
    /*length*/
    ToUINT24(sendbuf->start + 2, size);
    /*flags*/
    ToUINT16(sendbuf->start + 5,
             (size > SLP_MAX_DATAGRAM_SIZE ? SLP_FLAG_OVERFLOW : 0));
    /*ext offset*/
    ToUINT24(sendbuf->start + 7,0);
    /*xid*/
    ToUINT16(sendbuf->start + 10,SLPXidGenerate());
    /*lang tag len*/
    ToUINT16(sendbuf->start + 12,msg->header.langtaglen);
    /*lang tag*/
    memcpy(sendbuf->start + 14,
           msg->header.langtag,
           msg->header.langtaglen);
    sendbuf->curpos = sendbuf->start + 14 + msg->header.langtaglen;

    /* scope list */
    ToUINT16(sendbuf->curpos, srvreg->scopelistlen);
    sendbuf->curpos = sendbuf->curpos + 2;
    memcpy(sendbuf->curpos,srvreg->scopelist,srvreg->scopelistlen);
    sendbuf->curpos = sendbuf->curpos + srvreg->scopelistlen;
    /* the urlentry */
#ifdef ENABLE_SLPv1
    if ( srvreg->urlentry.opaque == 0 )
    {
        /* url-entry reserved */
        *sendbuf->curpos = 0;        
        sendbuf->curpos += 1;
        /* url-entry lifetime */
        ToUINT16(sendbuf->curpos,srvreg->urlentry.lifetime);
        sendbuf->curpos = sendbuf->curpos + 2;
        /* url-entry urllen */
        ToUINT16(sendbuf->curpos,srvreg->urlentry.urllen);
        sendbuf->curpos += 2;
        /* url-entry url */
        memcpy(sendbuf->curpos,
               srvreg->urlentry.url,
               srvreg->urlentry.urllen);
        sendbuf->curpos += srvreg->urlentry.urllen;                        
        /* url-entry authcount */
        *sendbuf->curpos = 0;        
        sendbuf->curpos += 1;
    }
    else
#endif /* ENABLE_SLPv1 */
    {
        memcpy(sendbuf->curpos,
               srvreg->urlentry.opaque,
               srvreg->urlentry.opaquelen);
        sendbuf->curpos += srvreg->urlentry.opaquelen;
    }

    /* taglist (always 0) */
    ToUINT16(sendbuf->curpos,0);
    sendbuf->curpos += 1;

    return 0;
}


/*-------------------------------------------------------------------------*/
void SLPDKnownDADeregisterAll(SLPMessage daadvert)
/* de-registers all services with specified DA                             */
/*-------------------------------------------------------------------------*/
{
    SLPBuffer           buf;
    SLPMessage          msg;
    SLPSrvReg*          srvreg;
    SLPDSocket*         sock;
    SLPBuffer           sendbuf     = 0;
    void*               handle      = 0;

    /*---------------------------------------------------------------*/
    /* Check to see if the database is empty and open an enumeration */
    /* handle if it is not empty                                     */
    /*---------------------------------------------------------------*/
    if ( SLPDDatabaseIsEmpty() )
    {
        return;
    }
    handle = SLPDDatabaseEnumStart();
    if ( handle == 0 )
    {
        return;
    }

    /* Establish a new connection with the known DA */
    sock = SLPDOutgoingConnect(&(daadvert->peer.sin_addr));
    if ( sock )
    {
        while ( 1 )
        {
            msg = SLPDDatabaseEnum(handle, &msg, &buf);
            if ( msg == NULL ) break;
            srvreg = &(msg->body.srvreg);

            /*-------------------------------------------------*/
            /* Deregister all local (and static) registrations */
            /*-------------------------------------------------*/
            if ( srvreg->source == SLP_REG_SOURCE_LOCAL || 
                 srvreg->source == SLP_REG_SOURCE_STATIC )
            {
                if(MakeSrvderegFromSrvReg(msg,buf,&sendbuf) == 0)
                {
                    /*--------------------------------------------------*/
                    /* link newly constructed buffer to socket sendlist */
                    /*--------------------------------------------------*/
                    SLPListLinkTail(&(sock->sendlist),(SLPListItem*)sendbuf);
                    if ( sock->state == STREAM_CONNECT_IDLE )
                    {
                        sock->state = STREAM_WRITE_FIRST;
                    }
                }
            }
        }
    }

    SLPDDatabaseEnumEnd(handle);
}


/*=========================================================================*/
int SLPDKnownDAFromDHCP()
/* Queries DHCP for configured DA's.													*/
/*                                                                         */
/* returns  zero on success, Non-zero on failure                           */
/*=========================================================================*/
{
	SLPBuffer			buf;
	DHCPContext			ctx;
	SLPDSocket*			sock;
	struct in_addr		daaddr;
	unsigned char *	alp;
	unsigned char		dhcpOpts[] = {TAG_SLP_SCOPE, TAG_SLP_DA};

	*ctx.scopelist = 0;
	ctx.addrlistlen = 0;

	DHCPGetOptionInfo(dhcpOpts, sizeof(dhcpOpts), DHCPParseSLPTags, &ctx);

	alp = ctx.addrlist;
	while(ctx.addrlistlen >= 4)
	{
		memcpy(&daaddr.s_addr, alp, 4);
		if (daaddr.s_addr)
		{
			/*--------------------------------------------------------
				Get an outgoing socket to the DA and set it up to make
				the service:directoryagent request
			  --------------------------------------------------------*/
			sock = SLPDOutgoingConnect(&daaddr);
			if (sock)
			{
			   buf = 0;
			   if (MakeActiveDiscoveryRqst(0,&buf) == 0)
			   {
					if (sock->state == STREAM_CONNECT_IDLE)
						sock->state = STREAM_WRITE_FIRST;
					SLPListLinkTail(&(sock->sendlist),(SLPListItem*)buf);
					if (sock->state == STREAM_CONNECT_IDLE)
						sock->state = STREAM_WRITE_FIRST;
			   }
			}
		}
		ctx.addrlistlen -= 4;
		alp += 4;
	}
	return 0;
}

/*=========================================================================*/
int SLPKnownDAFromProperties()
/* Queries static configuration for DA's.												*/
/*                                                                         */
/* returns  zero on success, Non-zero on failure                           */
/*=========================================================================*/
{
	char*               temp;
	char*               tempend;
	char*               slider1;
	char*               slider2;
	struct hostent*     he;
	struct in_addr      daaddr;
	SLPDSocket*         sock;
	SLPBuffer           buf;

	if (G_SlpdProperty.DAAddresses && *G_SlpdProperty.DAAddresses)
	{
		temp = slider1 = xstrdup(G_SlpdProperty.DAAddresses);
		if (temp)
		{
			tempend = temp + strlen(temp);
			while (slider1 < tempend)
			{
				while (*slider1 && *slider1 == ' ') slider1++;
				slider2 = slider1;
				while (*slider2 && *slider2 != ',') slider2++;
				*slider2++ = 0;

				daaddr.s_addr = 0;
				if(inet_aton(slider1, &daaddr) == 0)
				{
					he = gethostbyname(slider1);
					if (he)
						daaddr.s_addr = *((unsigned int*)(he->h_addr_list[0]));
				}
			    
				if(daaddr.s_addr)
				{
					/*--------------------------------------------------------*/
					/* Get an outgoing socket to the DA and set it up to make */
					/* the service:directoryagent request                     */
					/*--------------------------------------------------------*/
					sock = SLPDOutgoingConnect(&daaddr);
					if (sock)
					{
						buf = 0;
						if (MakeActiveDiscoveryRqst(0,&buf) == 0)
						{
							if (sock->state == STREAM_CONNECT_IDLE)
								sock->state = STREAM_WRITE_FIRST;
							SLPListLinkTail(&(sock->sendlist),(SLPListItem*)buf);
							if (sock->state == STREAM_CONNECT_IDLE)
								sock->state = STREAM_WRITE_FIRST;
						}
					}
				}
				slider1 = slider2;
			}
			xfree(temp);
		}
	}
	return 0;
}

/*=========================================================================*/
int SLPDKnownDAInit()
/* Initializes the KnownDA list.  Removes all entries and adds entries     */
/* that are statically configured.  Adds entries configured through DHCP.  */
/*                                                                         */
/* returns  zero on success, Non-zero on failure                           */
/*=========================================================================*/
{
    /*--------------------------------------*/
    /* Set initialize the DAAdvert database */
    /*--------------------------------------*/
    SLPDatabaseInit(&G_SlpdKnownDAs);

    /*-----------------------------------------------------------------*/
    /* Added statically configured DAs to the Known DA List by sending */
    /* active DA discovery requests directly to them                   */
    /*-----------------------------------------------------------------*/
    SLPKnownDAFromProperties();

    /*-----------------------------------------------------------------*/
    /* Discover DHCP DA's and add them to the active discovery list.	  */
    /*-----------------------------------------------------------------*/
    SLPDKnownDAFromDHCP();

    /*----------------------------------------*/
    /* Lastly, Perform first active discovery */
    /*----------------------------------------*/
    SLPDKnownDAActiveDiscovery(0);

    return 0;
}


/*=========================================================================*/
int SLPDKnownDADeinit()
/* Deinitializes the KnownDA list.  Removes all entries and deregisters    */
/* all services.                                                           */
/*                                                                         */
/* returns  zero on success, Non-zero on failure                           */
/*=========================================================================*/
{
    SLPDatabaseHandle   dh;
    SLPDatabaseEntry*   entry;
    dh = SLPDatabaseOpen(&G_SlpdKnownDAs);
    if ( dh )
    {
        /*------------------------------------*/
        /* Unregister all local registrations */
        /*------------------------------------*/
        while ( 1 )
        {
            entry = SLPDatabaseEnum(dh);
            if ( entry == NULL ) break;

            SLPDKnownDADeregisterAll(entry->msg);
        }
        SLPDatabaseClose(dh);
    }

    SLPDatabaseDeinit(&G_SlpdKnownDAs);

    return 0;
} 


/*=========================================================================*/
int SLPDKnownDAAdd(SLPMessage msg, SLPBuffer buf)
/* Adds a DA to the known DA list if it is new, removes it if DA is going  */
/* down or adjusts entry if DA changed.                                    */
/*                                                                         */
/* msg     (IN) DAAdvert Message descriptor                                */
/*                                                                         */
/* buf     (IN) The DAAdvert message buffer                                */
/*                                                                         */
/* returns  Zero on success, Non-zero on error                             */
/*=========================================================================*/
{
    SLPDatabaseEntry*   entry;
    SLPDAAdvert*        entrydaadvert;
    SLPDAAdvert*        daadvert;
    struct in_addr      daaddr;
    SLPParsedSrvUrl*    parsedurl       = NULL;
    int                 result          = 0;