Пример #1
0
/*=========================================================================*/
SLPDAEntry* SLPDKnownDAAdd(struct in_addr* addr,
                           unsigned long bootstamp,
                           const char* scopelist,
                           int scopelistlen)
/* Adds a DA to the known DA list.  If DA already exists, entry is updated */
/*                                                                         */
/* addr     (IN) pointer to in_addr of the DA to add                       */
/*                                                                         */
/* scopelist (IN) scope list of the DA to add                              */
/*                                                                         */
/* scopelistlen (IN) the length of the scope list                          */
/*                                                                         */
/* returns  Pointer to the added or updated                                */
/*=========================================================================*/
{
    SLPDAEntry* entry;

    /* Iterate through the list looking for an identical entry */
    entry = (SLPDAEntry*)G_KnownDAList.head;
    while (entry)
    {
        /* for now assume entries are the same if in_addrs match */
        if (memcmp(&entry->daaddr,addr,sizeof(struct in_addr)) == 0)
        {
            /* Update an existing entry */
            if (entry->bootstamp < bootstamp)
            {
                entry->bootstamp = bootstamp;
            }
            else
            {
                /* set bootstamp to zero so that slpd will re-register with */
                /* this DA                                                  */
                bootstamp = 0;
            }
            entry->scopelist = realloc(entry->scopelist,scopelistlen);
            if (entry->scopelist)
            {
                memcpy(entry->scopelist,scopelist,scopelistlen);
                entry->scopelistlen = scopelistlen;
            }
            else
            {
                free(entry);
                entry = 0;
            }

            return entry;
        }

        entry = (SLPDAEntry*)entry->listitem.next;
    }

    /* Create and link in a new entry */    
    bootstamp = 0;  /* make sure we re-register with new entries */
    entry = SLPDAEntryCreate(addr,bootstamp,scopelist,scopelistlen);
    SLPListLinkHead(&G_KnownDAList,(SLPListItem*)entry);

    return entry;
}
Пример #2
0
/*-------------------------------------------------------------------------*/
SLPBoolean KnownDADiscoveryCallback(SLPError errorcode, 
                                    SLPMessage msg, 
                                    void* cookie)
/*-------------------------------------------------------------------------*/
{
    SLPSrvURL*      srvurl;
    SLPDAEntry*     entry;
    struct hostent* he;
    int*            count = (int*)cookie;
    
    if(msg->header.functionid == SLP_FUNCT_DAADVERT)
    {
        if(msg->body.srvrply.errorcode == 0)
        {
            /* NULL terminate scopelist */ 
            *((char*)msg->body.daadvert.scopelist + msg->body.daadvert.scopelistlen) = 0;
            if(SLPParseSrvURL(msg->body.daadvert.url, &srvurl) == 0)
            {
                he = gethostbyname(srvurl->s_pcHost);
                if(he)
                {
                    entry = SLPDAEntryCreate((struct in_addr*)(he->h_addr_list[0]),
                                             msg->body.daadvert.scopelist,
                                             msg->body.daadvert.scopelistlen);
                    ListLink((PListItem*)&G_KnownDAListHead,(PListItem)entry);
                    *count = *count + 1;
                }
                
                SLPFree(srvurl);
            }
        }                
    }
    
    return 1;
}
Пример #3
0
/*-------------------------------------------------------------------------*/
SLPBoolean KnownDADiscoveryCallback(SLPError errorcode, 
                                    SLPMessage msg, 
                                    void* cookie)
/*-------------------------------------------------------------------------*/
{
    SLPSrvURL*      srvurl;
    SLPDAEntry      daentry;
    SLPDAEntry*     entry;
    int*            result;
    struct in_addr  addr;
    struct hostent* he;

    result = (int*)cookie;

    if(errorcode == 0)
    {
        if(msg && msg->header.functionid == SLP_FUNCT_DAADVERT)
        {
            if(msg->body.daadvert.errorcode == 0)
            {
                /* NULL terminate scopelist */
                *((char*)msg->body.daadvert.scopelist + msg->body.daadvert.scopelistlen) = 0;
                if(SLPParseSrvURL(msg->body.daadvert.url, &srvurl) == 0)
                {
                    he = gethostbyname(srvurl->s_pcHost);
                    if(he)
                    {
                        /* create a daentry and add it to the knownda list */
                        daentry.langtaglen = msg->header.langtaglen;
                        daentry.langtag = msg->header.langtag;
                        daentry.bootstamp = msg->body.daadvert.bootstamp;
                        daentry.urllen = msg->body.daadvert.urllen;
                        daentry.url = msg->body.daadvert.url;
                        daentry.scopelistlen = msg->body.daadvert.scopelistlen;
                        daentry.scopelist = msg->body.daadvert.scopelist;
                        daentry.attrlistlen = msg->body.daadvert.attrlistlen;
                        daentry.attrlist = msg->body.daadvert.attrlist;
                        daentry.spilistlen = msg->body.daadvert.spilistlen;
                        daentry.spilist = msg->body.daadvert.spilist;
                        addr.s_addr = *((unsigned int*)(he->h_addr_list[0]));
                        entry = SLPDAEntryCreate(&addr, &daentry);
                        if(entry)
                        {
                            KnownDAListAdd(&G_KnownDACache,
                                           entry);
                            (*result) = (*result) + 1;
                        }

                        if(msg->header.flags & SLP_FLAG_MCAST)
                        {
                            return 0;
                        }
                    }

                    SLPFree(srvurl);
                }
            }
            else if(msg->body.daadvert.errorcode == SLP_ERROR_INTERNAL_ERROR)
            {
                /* SLP_ERROR_INTERNAL_ERROR is a "end of stream marker for */
                /* loobpack IPC                                            */
                return 0;
            }
        }
    }


    return 1;
}