libslp_knownda.c

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

    memcpy(curpos,scopelist,scopelistlen);
    /* predicate zero length */
    /* spi list zero length */
    
    if(sock == -1)
    {

#ifndef MI_NOT_SUPPORTED
        NetworkMcastRqstRply(handle,
#else
        NetworkMcastRqstRply("en",
#endif /* MI_NOT_SUPPORTED */
                             buf,
                             SLP_FUNCT_DASRVRQST,
                             bufsize,
                             KnownDADiscoveryCallback,
                             &result);

    }
    else
    {
        NetworkRqstRply(sock,
                        peeraddr,
                        "en",
                        0,
                        buf,
                        SLP_FUNCT_DASRVRQST,
                        bufsize,
                        KnownDADiscoveryCallback,
                        &result);
    }

    xfree(buf);

    return result;
}


/*-------------------------------------------------------------------------*/
#ifndef MI_NOT_SUPPORTED
int KnownDADiscoverFromMulticast(int scopelistlen, const char* scopelist, PSLPHandleInfo handle)
#else
int KnownDADiscoverFromMulticast(int scopelistlen, const char* scopelist)
#endif /* MI_NOT_SUPPORTED */
/* Locates  DAs via multicast convergence                                  */
/*                                                                         */
/* Returns: number of *new* DAs found                                      */
/*-------------------------------------------------------------------------*/
{
    int result = 0;

    if(SLPPropertyAsBoolean(SLPGetProperty("net.slp.activeDADetection")) &&
       SLPPropertyAsInteger(SLPGetProperty("net.slp.DADiscoveryMaximumWait")))
    {
        result = KnownDADiscoveryRqstRply(-1,
                                          NULL,
                                          scopelistlen,
#ifndef MI_NOT_SUPPORTED
                                          scopelist,
                                          handle);
#else
                                          scopelist);
#endif /* MI_NOT_SUPPORTED */
    }

    return result;
}

/*-------------------------------------------------------------------------*/
#ifndef MI_NOT_SUPPORTED
int KnownDADiscoverFromDHCP(PSLPHandleInfo handle)
#else
int KnownDADiscoverFromDHCP()
#endif /* MI_NOT_SUPPORTED */
/* Locates  DAs via DHCP                                                   */
/*                                                                         */
/* Returns: number of *new* DAs found via DHCP.                            */
/*-------------------------------------------------------------------------*/
{
	int count = 0;
	int scopelistlen;
	DHCPContext ctx;
	unsigned char *alp;
	struct timeval timeout;
	struct sockaddr_in peeraddr;
	unsigned char dhcpOpts[] = {TAG_SLP_SCOPE, TAG_SLP_DA};

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

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

	if(!*ctx.scopelist)
	{
		const char *slp = SLPGetProperty("net.slp.useScopes");
		if(slp)
			strcpy(ctx.scopelist, slp);
	}
	scopelistlen = strlen(ctx.scopelist);

	memset(&peeraddr,0,sizeof(peeraddr));
	peeraddr.sin_family = AF_INET;
	peeraddr.sin_port = htons(SLP_RESERVED_PORT);

	timeout.tv_sec = SLPPropertyAsInteger(SLPGetProperty("net.slp.DADiscoveryMaximumWait"));
	timeout.tv_usec = (timeout.tv_sec % 1000) * 1000;
	timeout.tv_sec = timeout.tv_sec / 1000;

	alp = ctx.addrlist;

	while(ctx.addrlistlen >= 4)
	{
		memcpy(&peeraddr.sin_addr.s_addr, alp, 4);
		if(peeraddr.sin_addr.s_addr)
		{
			int sockfd;
			if((sockfd = SLPNetworkConnectStream(&peeraddr, &timeout)) >= 0)
			{
				count = KnownDADiscoveryRqstRply(sockfd, 
                                                                 &peeraddr, 
                                                                 scopelistlen, 
#ifndef MI_NOT_SUPPORTED
                                                                 ctx.scopelist,
                                                                 handle);
#else
                                                                 ctx.scopelist);
#endif /* MI_NOT_SUPPORTED  */
				closesocket(sockfd);
				if(scopelistlen && count)
					break;	/* stop after the first set found */
			}
		}
		ctx.addrlistlen -= 4;
		alp += 4;
	}
	return count;
}


/*-------------------------------------------------------------------------*/
int KnownDADiscoverFromProperties(int scopelistlen,
#ifndef MI_NOT_SUPPORTED
                                  const char* scopelist,
                                  PSLPHandleInfo handle)
#else
                                  const char* scopelist)
#endif /* MI_NOT_SUPPORTED */
/* Locates DAs from the property list of DA hostnames                      */
/*                                                                         */
/* Returns: number of *new* DAs found                                      */
/*-------------------------------------------------------------------------*/
{
    char*               temp;
    char*               tempend;
    char*               slider1;
    char*               slider2;
    int                 sockfd;
    struct hostent*     he;
    struct sockaddr_in  peeraddr;
    struct timeval      timeout;
    int                 result      = 0;

    memset(&peeraddr,0,sizeof(peeraddr));
    peeraddr.sin_family = AF_INET;
    peeraddr.sin_port = htons(SLP_RESERVED_PORT);

    slider1 = slider2 = temp = xstrdup(SLPGetProperty("net.slp.DAAddresses"));
    if(temp)
    {
        tempend = temp + strlen(temp);
        while(slider1 != tempend)
        {
            timeout.tv_sec = SLPPropertyAsInteger(SLPGetProperty("net.slp.DADiscoveryMaximumWait"));
            timeout.tv_usec = (timeout.tv_sec % 1000) * 1000;
            timeout.tv_sec = timeout.tv_sec / 1000;

            while(*slider2 && *slider2 != ',') slider2++;
            *slider2 = 0;

            peeraddr.sin_addr.s_addr = 0;
            if(inet_aton(slider1, &(peeraddr.sin_addr)) == 0)
            {
                he = gethostbyname(slider1);
                if(he)
                {
                    peeraddr.sin_addr.s_addr = *((unsigned int*)(he->h_addr_list[0]));
                }
            }
            
            if (peeraddr.sin_addr.s_addr)
            {
                sockfd = SLPNetworkConnectStream(&peeraddr,&timeout);
                if(sockfd >= 0)
                {
                    result = KnownDADiscoveryRqstRply(sockfd,
                                                      &peeraddr,
                                                      scopelistlen,
#ifndef MI_NOT_SUPPORTED
                                                      scopelist,
                                                      handle);
#else                                                 
			                              scopelist);
#endif		    
                    closesocket(sockfd);
                    if(scopelistlen && result)
                    {
                        /* return if we found at least one DA */
                        break;
                    }
                }
            }

            slider1 = slider2;
            slider2++;
        }

        xfree(temp);
    }

    return result;
}


/*-------------------------------------------------------------------------*/
#ifndef MI_NOT_SUPPORTED
int KnownDADiscoverFromIPC(PSLPHandleInfo handle)
#else
int KnownDADiscoverFromIPC()
#endif
/* Ask Slpd if it knows about a DA                                         */ 
/*                                                                         */
/* Returns: number of *new* DAs found                                      */
/*-------------------------------------------------------------------------*/
{
    struct sockaddr_in peeraddr;
    int sockfd; 
    int result = 0;

    sockfd = NetworkConnectToSlpd(&peeraddr);
    if(sockfd >= 0)
    {
#ifndef MI_NOT_SUPPORTED
        result = KnownDADiscoveryRqstRply(sockfd, &peeraddr, 0, "", handle);
#else
        result = KnownDADiscoveryRqstRply(sockfd, &peeraddr, 0, "");
#endif
        closesocket(sockfd);
    }

    return result;
}

/*-------------------------------------------------------------------------*/
SLPBoolean KnownDAFromCache(int scopelistlen,
                            const char* scopelist,
                            int spistrlen,
                            const char* spistr,
#ifndef MI_NOT_SUPPORTED
                            struct in_addr* daaddr,
                            PSLPHandleInfo handle)
#else
                            struct in_addr* daaddr)
#endif /* MI_NOT_SUPPORTED */
/* Ask Slpd if it knows about a DA                                         */ 
/*                                                                         */
/* Returns: non-zero on success, zero if DA can not be found               */
/*-------------------------------------------------------------------------*/
{
    time_t          curtime;
    
    if(KnownDAListFind(scopelistlen,
                       scopelist,
                       spistrlen,
                       spistr,
                       daaddr) == SLP_FALSE)
    {
        curtime = time(&curtime);
        if(G_KnownDALastCacheRefresh == 0 ||
           curtime - G_KnownDALastCacheRefresh > MINIMUM_DISCOVERY_INTERVAL)
        {
            G_KnownDALastCacheRefresh = curtime;

            /* discover DAs */
#ifndef MI_NOT_SUPPORTED
            if(KnownDADiscoverFromIPC(handle) == 0)
                if(KnownDADiscoverFromProperties(scopelistlen, scopelist, handle) == 0)
                    if(KnownDADiscoverFromDHCP(handle) == 0)
                        KnownDADiscoverFromMulticast(scopelistlen, scopelist, handle);
#else
            if(KnownDADiscoverFromIPC() == 0)
                if(KnownDADiscoverFromProperties(scopelistlen, scopelist) == 0)
                    if(KnownDADiscoverFromDHCP() == 0)
                        KnownDADiscoverFromMulticast(scopelistlen, scopelist);
#endif		
        }

        return KnownDAListFind(scopelistlen,
                               scopelist,
                               spistrlen,
                               spistr,
                               daaddr);
    }

    return SLP_TRUE; 
}


/*=========================================================================*/
int KnownDAConnect(PSLPHandleInfo handle,
                   int scopelistlen,
                   const char* scopelist,
                   struct sockaddr_in* peeraddr)
/* Get a connected socket to a DA that supports the specified scope        */
/*                                                                         */
/* scopelistlen (IN) stringlen of the scopelist                            */
/*                                                                         */
/* scopelist (IN) DA must support this scope                               */
/*                                                                         */
/* peeraddr (OUT) the peer that was connected to                           */
/*                                                                         */
/*                                                                         */