slpd_knownda.c

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

                        {
                            SLPListLinkTail(&(sock->sendlist),(SLPListItem*)dup);
                            if ( sock->state == STREAM_CONNECT_IDLE )
                            {
                                sock->state = STREAM_WRITE_FIRST;
                            }
                        }
                        else
                        {
                            sock->state = SOCKET_CLOSE;
                        }
                    }
                }
            }
        }
        SLPDatabaseClose(dh);
    }
}


/*=========================================================================*/
void SLPDKnownDAActiveDiscovery(int seconds)
/* Add a socket to the outgoing list to do active DA discovery SrvRqst     */
/*									                                       */
/* seconds (IN) number of seconds that expired since last call             */
/*                                                                         */
/* Returns:  none                                                          */
/*=========================================================================*/
{
    struct in_addr  peeraddr;
    SLPDSocket*     sock;

    /* Check to see if we should perform active DA detection */
    if ( G_SlpdProperty.DAActiveDiscoveryInterval == 0 )
    {
        return;
    }
    /* When activeDiscoveryXmits is < 0 then we should not xmit any more */
    if (G_SlpdProperty.activeDiscoveryXmits < 0)
    {
        return ;
    }

    if ( G_SlpdProperty.nextActiveDiscovery <= 0 )
    {
        if ( G_SlpdProperty.activeDiscoveryXmits == 0)
        {
            if (G_SlpdProperty.DAActiveDiscoveryInterval == 1)
            {/* ensures xmit on first call */
                /* don't xmit any more */
                G_SlpdProperty.activeDiscoveryXmits = -1;
            }
            else
            {
                G_SlpdProperty.nextActiveDiscovery = G_SlpdProperty.DAActiveDiscoveryInterval;
                G_SlpdProperty.activeDiscoveryXmits = 3;
            }
        }

        G_SlpdProperty.activeDiscoveryXmits --;

        /*--------------------------------------------------*/
        /* Create new DATAGRAM socket with appropriate peer */
        /*--------------------------------------------------*/
        if ( G_SlpdProperty.isBroadcastOnly == 0 )
        {
            peeraddr.s_addr = htonl(SLP_MCAST_ADDRESS);
            sock = SLPDSocketCreateDatagram(&peeraddr,DATAGRAM_MULTICAST);
        }
        else
        {
            peeraddr.s_addr = htonl(SLP_BCAST_ADDRESS);
            sock = SLPDSocketCreateDatagram(&peeraddr,DATAGRAM_BROADCAST);
        }

        if ( sock )
        {
            /*----------------------------------------------------------*/
            /* Make the srvrqst and add the socket to the outgoing list */
            /*----------------------------------------------------------*/
            MakeActiveDiscoveryRqst(1,&(sock->sendbuf));
            SLPDOutgoingDatagramWrite(sock); 
        }
    }
    else
    {
        G_SlpdProperty.nextActiveDiscovery = G_SlpdProperty.nextActiveDiscovery - seconds;
    }
}


/*=========================================================================*/
void SLPDKnownDAPassiveDAAdvert(int seconds, int dadead)
/* Send passive daadvert messages if properly configured and running as    */
/* a DA                                                                    */
/*	                                                                       */
/* seconds (IN) number seconds that elapsed since the last call to this    */
/*              function                                                   */
/*                                                                         */
/* dadead  (IN) nonzero if the DA is dead and a bootstamp of 0 should be   */
/*              sent                                                       */
/*                                                                         */
/* Returns:  none                                                          */
/*=========================================================================*/
{
    struct in_addr  peeraddr;
    SLPDSocket*     sock;
#ifdef ENABLE_SLPv1
    SLPDSocket*     v1sock;
#endif


    /* SAs don't send passive DAAdverts */
    if ( G_SlpdProperty.isDA == 0)
    {
        return;
    }

    /* Check to see if we should perform passive DA detection */
    if ( G_SlpdProperty.passiveDADetection == 0 )
    {
        return;
    }

    if ( G_SlpdProperty.nextPassiveDAAdvert <= 0 || dadead )
    {
        G_SlpdProperty.nextPassiveDAAdvert = G_SlpdProperty.DAHeartBeat;

        /*--------------------------------------------------*/
        /* Create new DATAGRAM socket with appropriate peer */
        /*--------------------------------------------------*/
        if ( G_SlpdProperty.isBroadcastOnly == 0 )
        {
            peeraddr.s_addr = htonl(SLP_MCAST_ADDRESS);
            sock = SLPDSocketCreateDatagram(&peeraddr,DATAGRAM_MULTICAST);

#ifdef ENABLE_SLPv1
            if ( !dadead )
            {
                peeraddr.s_addr = htonl(SLPv1_DA_MCAST_ADDRESS);
                v1sock = SLPDSocketCreateDatagram(&peeraddr,
                                                  DATAGRAM_MULTICAST);
            }
            else
            {
                v1sock = NULL;
            }
#endif  
        }
        else
        {
            peeraddr.s_addr = htonl(SLP_BCAST_ADDRESS);
            sock = SLPDSocketCreateDatagram(&peeraddr,DATAGRAM_BROADCAST);

#ifdef ENABLE_SLPv1
            if ( !dadead )
            {
                v1sock = SLPDSocketCreateDatagram(&peeraddr,DATAGRAM_BROADCAST);
            }
            else
            {
                v1sock = NULL;
            }
#endif
        }

        /* Generate the DAAdvert and link it to the write list */
        if ( sock )
        {
            if (SLPDKnownDAGenerateMyDAAdvert(0,dadead,0,&(sock->sendbuf)) == 0)
            {
                SLPDOutgoingDatagramWrite(sock);
            }
            else
            {
                SLPDSocketFree(sock);
            }
        }

#ifdef ENABLE_SLPv1
        if ( v1sock )
        {
            /* SLPv1 does not support shutdown messages */

            /* Generate the DAAdvert and write it */
            if (SLPDKnownDAGenerateMyV1DAAdvert(0,
                                                SLP_CHAR_UTF8,
                                                SLPXidGenerate(),
                                                &(v1sock->sendbuf)) == 0)
            {
                SLPDOutgoingDatagramWrite(v1sock);
            }
            else
            {
                SLPDSocketFree(v1sock);
            }
        }
#endif
    }
    else
    {
        G_SlpdProperty.nextPassiveDAAdvert = G_SlpdProperty.nextPassiveDAAdvert - seconds;
    }
}


/*=========================================================================*/
void SLPDKnownDAImmortalRefresh(int seconds)
/* Refresh all SLP_LIFETIME_MAXIMUM services                               */
/* 																		   */
/* seconds (IN) time in seconds since last call                            */
/*=========================================================================*/
{
    SLPDatabaseHandle   dh;
    SLPDatabaseEntry*   entry;
    SLPDAAdvert*        entrydaadvert;

    G_KnownDATimeSinceLastRefresh += seconds;

    if ( G_KnownDATimeSinceLastRefresh >= SLP_LIFETIME_MAXIMUM - seconds )
    {
        /* Refresh all SLP_LIFETIME_MAXIMUM registrations */
        dh = SLPDatabaseOpen(&G_SlpdKnownDAs);
        if(dh)
        {

            /*-----------------------------------------------------*/
            /* Check to see if there is already an identical entry */
            /*-----------------------------------------------------*/
            while ( 1 )
            {
                entry = SLPDatabaseEnum(dh);
                if ( entry == NULL ) break;

                /* entrydaadvert is the DAAdvert message from the database */
                entrydaadvert = &(entry->msg->body.daadvert);

                /* Assume DAs are identical if their URLs match */
                if ( SLPCompareString(entrydaadvert->urllen,
                                      entrydaadvert->url,
                                      G_SlpdProperty.myUrlLen,
                                      G_SlpdProperty.myUrl) )
                {
                    SLPDKnownDARegisterAll(entry->msg,1);
                }
            }   

            SLPDatabaseClose(dh);
        }

        G_KnownDATimeSinceLastRefresh = 0;
    }
}


/*=========================================================================*/
void SLPDKnownDADeRegisterWithAllDas(SLPMessage msg, SLPBuffer buf)
/* Deregister the registration described by the specified message          */
/*                                                                         */
/* msg (IN) A message descriptor for a SrvReg or SrvDereg message to       */
/*          deregister                                                     */
/*                                                                         */
/* buf (IN) Message buffer associated with msg                             */
/*                                                                         */
/* Returns: None                                                           */
/*=========================================================================*/
{
    SLPBuffer  sendbuf;
    
    if(msg->header.functionid == SLP_FUNCT_SRVREG)
    {
        if(MakeSrvderegFromSrvReg(msg,buf, &sendbuf) == 0)
        {
            SLPDKnownDAEcho(msg,sendbuf);
            SLPBufferFree(sendbuf); 
        }
    }
    else if (msg->header.functionid == SLP_FUNCT_SRVDEREG)
    {
        /* Simply echo the message through as is */
        SLPDKnownDAEcho(msg,buf);
    }
}


/*=========================================================================*/
void SLPDKnownDARegisterWithAllDas(SLPMessage msg, SLPBuffer buf)
/* Register the registration described by the specified message with all   */
/* known DAs                                                               */
/*                                                                         */
/* msg (IN) A message descriptor for a SrvReg or SrvDereg message to       */
/*          register                                                       */
/*                                                                         */
/* buf (IN) Message buffer associated with msg                             */
/*                                                                         */
/* Returns: None                                                           */
/*=========================================================================*/
{
    if (msg->header.functionid == SLP_FUNCT_SRVREG)
    {
        /* Simply echo the message through as is */
        SLPDKnownDAEcho(msg,buf);
    }
}


#ifdef DEBUG
/*=========================================================================*/
void SLPDKnownDADump()
/*=========================================================================*/
{
    SLPMessage      msg;
    SLPBuffer       buf;
    void* eh;

    eh = SLPDKnownDAEnumStart();
    if ( eh )
    {
        SLPDLog("========================================================================\n");
        SLPDLog("Dumping KnownDAs \n");
        SLPDLog("========================================================================\n");
        while ( SLPDKnownDAEnum(eh, &msg, &buf) )
        {
            SLPDLogMessageInternals(msg);
            SLPDLog("\n");
        }

        SLPDKnownDAEnumEnd(eh);
    }
}
#endif