/* Link me Anchor to another given one ** ------------------------------------- */ PUBLIC BOOL HTLink_add (HTAnchor * source, HTAnchor * destination, HTLinkType type, HTMethod method) { if (source && destination) { HTTRACE(ANCH_TRACE, "Link create. from anchor %p to %p with type %s, method %s\n" _ (void *) source _ (void *) destination _ type ? HTAtom_name(type) : "NONE" _ method != METHOD_INVALID ? HTMethod_name(method) : "NONE"); if (!source->mainLink.dest) { source->mainLink.dest = destination; source->mainLink.type = type; source->mainLink.method = method; } else { HTLink * newLink = HTLink_new(); newLink->dest = destination; newLink->type = type; newLink->method = method; if (!source->links) source->links = HTList_new(); HTList_addObject (source->links, newLink); } if (!destination->parent->sources) destination->parent->sources = HTList_new(); HTList_addObject (destination->parent->sources, source); return YES; } else HTTRACE(ANCH_TRACE, "Link........ Bad argument\n"); return NO; }
HTAnchor * HTHistory_moveBy ARGS1 (int,offset) { HTAnchor * last = HTList_objectAt (history, 1); if (! last) return NULL; /* No last visited node */ if (last != (HTAnchor *) last->parent) { /* Was a child */ HTList * kids = last->parent->children; int i = HTList_indexOf (kids, last); HTAnchor * nextOne = HTList_objectAt (kids, i - offset); if (nextOne) { HTAnchor * destination = HTAnchor_followMainLink (nextOne); if (destination) { HTList_removeLastObject (history); HTList_removeLastObject (history); HTList_addObject (history, nextOne); HTList_addObject (history, destination); } return destination; } else { if (TRACE) fprintf(stderr, "HTHistory_moveBy: offset by %+d goes out of list %p.\n", offset, kids); return NULL; } } else { /* Was a parent */ return NULL; /* FIXME we could possibly follow the next link... */ } }
PRIVATE BOOL HTCookieHolder_addCookie (HTRequest * request, HTCookie * cookie) { if (request && cookie) { HTList * cur = cookie_holder; HTCookieHolder * pres = NULL; /* Make sure that we have a cookie holder list */ if (!cookie_holder) cookie_holder = HTList_new(); /* See if we already have a cookie holder for this request */ while ((pres = (HTCookieHolder *) HTList_nextObject(cur))) { if (pres->request == request) break; } /* If found then use existing cookie holder, otherwise create new one */ if (!pres) { if ((pres = (HTCookieHolder *) HT_CALLOC(1, sizeof(HTCookieHolder))) == NULL) HT_OUTOFMEM("HTCookieHolder_newCookie"); pres->request = request; pres->cookies = HTList_new(); /* Add to cookie holder list */ HTList_addObject(cookie_holder, pres); } /* Now add the cookie */ HTList_addObject(pres->cookies, cookie); return YES; } return NO; }
/* ParseGroup ** ---------- ** Extract the index number, subject etc, from a XOVER command. Expects ** the following format of the line: ** ** <index> <subject> <from> <data> <msgid> [*<thread>] ... ** ** Returns YES if OK, NO on error */ PRIVATE BOOL ParseGroup (HTRequest * request, HTNewsDir *dir, char * line) { int index; int refcnt=0; time_t t=0; char *subject = line; char *from; char *date; char *msgid; char *ptr=NULL; HTList* reflist = NULL; /* Added by MP. */ while (*subject && *subject != DELIMITER) subject++; *subject++ = '\0'; /* Index */ index = atoi(line); from = subject; while (*from && *from != DELIMITER) from++; *from++ = '\0'; /* Subject */ date = from; while (*date && *date != DELIMITER) { if (*date=='<' || *date=='(') { ptr = date+1; *date = '\0'; } if (*date=='>' || *date==')') *date = '\0'; date++; } *date++ = '\0'; if (strchr(from, ATSIGN) && ptr) from = ptr; /* From */ msgid = date; while (*msgid && *msgid != DELIMITER) msgid++; *msgid++ = '\0'; /* Date */ if (*msgid=='<') msgid++; t = HTParseTime(date, HTRequest_userProfile(request), YES); ptr = msgid; while (*ptr && *ptr != DELIMITER) { if (*ptr=='>') *ptr = '\0'; ptr++; } *ptr++ = '\0'; /* MsgId */ while (ptr && *ptr && !isdigit((int) *ptr)) { char* refstart = ptr; /* Added by MP. */ char* refcopy = NULL; char* refstop; while (*ptr && *ptr != DELIMITER && *ptr != ' ') ptr++; refstop = ptr - 1; *ptr++ = '\0'; if (strlen(refstart) > 0) /* Added by MP. */ { refcnt++; if (*refstart == '<') refstart++; if (*refstop == '>') *refstop = '\0'; if (reflist == NULL) reflist = HTList_new(); StrAllocCopy (refcopy, refstart); HTList_addObject (reflist, (void*) refcopy); } } /* Changed by MP. */ return (HTNewsDir_addElement(dir, index, subject, from, t, msgid, refcnt, reflist) != NULL); }
void HText_beginAnchor (HText * text, HTChildAnchor * anchor) { TextAnchor * a; if (text && anchor) { Robot * mr = (Robot *) HTRequest_context(text->request); HTAnchor * dest = HTAnchor_followMainLink((HTAnchor *) anchor); HTParentAnchor * dest_parent = HTAnchor_parent(dest); char * uri = HTAnchor_address((HTAnchor *) dest_parent); #if 0 if (SHOW_MSG) HTTrace("Robot....... Found `%s\' \n", uri ? uri : "NULL"); #endif if (uri) { HTList_addObject(mr->urilist, (void *) uri); mr->count++; } if ((a = (TextAnchor *) HT_MALLOC(sizeof(*a))) == NULL) HT_OUTOFMEM("HText_beginAnchor"); if (text->last_anchor) { text->last_anchor->next = a; } else { text->first_anchor = a; } a->next = 0; a->anchor = anchor; text->last_anchor = a; if (HTAnchor_followMainLink((HTAnchor*)anchor)) { a->number = ++(text->anchors); } else { a->number = 0; } } }
/* ** Register a Protocol module as an active access method */ PUBLIC BOOL HTProtocol_add (const char * name, const char * transport, HTProtocolId protocolId, BOOL preemptive, HTProtCallback * client, HTProtCallback * server) { if (name && (client || server)) { HTProtocol *newProt; if ((newProt=(HTProtocol *) HT_CALLOC(1, sizeof(HTProtocol))) == NULL) HT_OUTOFMEM("HTProtocol_add"); StrAllocCopy(newProt->name, name); { char *ptr = newProt->name; while ((*ptr = TOLOWER(*ptr))) ptr++; } StrAllocCopy(newProt->transport, transport); { char *ptr = newProt->transport; while ((*ptr = TOLOWER(*ptr))) ptr++; } newProt->id = protocolId; newProt->preemptive = preemptive; newProt->client = client; newProt->server = server; if (!protocols) protocols = HTList_new(); else HTProtocol_delete(name); /* Ensure not listed twice */ HTTRACE(CORE_TRACE, "Protocol.... Adding `%s'\n" _ name); return HTList_addObject(protocols, (void *) newProt); } return NO; }
/* Define a presentation system command for a content-type ** ------------------------------------------------------- ** INPUT: ** conversions: The list of conveters and presenters ** representation: the MIME-style format name ** command: the MAILCAP-style command template ** quality: A degradation faction [0..1] ** maxbytes: A limit on the length acceptable as input (0 infinite) ** maxsecs: A limit on the time user will wait (0 for infinity) */ PUBLIC void HTPresentation_add (HTList * conversions, const char * representation, const char * command, const char * test_command, double quality, double secs, double secs_per_byte) { HTPresentation * pres; if (presentation_converter) { if ((pres = (HTPresentation *) HT_CALLOC(1,sizeof(HTPresentation))) == NULL) HT_OUTOFMEM("HTSetPresentation"); pres->rep = HTAtom_for(representation); pres->rep_out = WWW_PRESENT; /* Fixed for now ... :-) */ pres->converter = presentation_converter; pres->quality = quality; pres->secs = secs; pres->secs_per_byte = secs_per_byte; pres->rep = HTAtom_for(representation); pres->command = NULL; StrAllocCopy(pres->command, command); pres->test_command = NULL; StrAllocCopy(pres->test_command, test_command); HTTRACE(CORE_TRACE, "Presentation Adding `%s\' with quality %.2f\n" _ command _ quality); HTList_addObject(conversions, pres); } }
/* Define the representation associated with a file suffix ** ------------------------------------------------------- ** ** Calling this with suffix set to "*" will set the default ** representation. ** Calling this with suffix set to "*.*" will set the default ** representation for unknown suffix files which contain a ".". */ PUBLIC void HTSetSuffix ARGS4( WWW_CONST char *, suffix, WWW_CONST char *, representation, WWW_CONST char *, encoding, float, value) { HTSuffix * suff; if (strcmp(suffix, "*")==0) suff = &no_suffix; else if (strcmp(suffix, "*.*")==0) suff = &unknown_suffix; else { suff = (HTSuffix*) calloc(1, sizeof(HTSuffix)); if (suff == NULL) outofmem(__FILE__, "HTSetSuffix"); if (!HTSuffixes) HTSuffixes = HTList_new(); HTList_addObject(HTSuffixes, suff); StrAllocCopy(suff->suffix, suffix); } suff->rep = HTAtom_for(representation); { char *enc = NULL, *p; StrAllocCopy(enc, encoding); for (p=enc; *p; p++) *p = TOLOWER(*p); suff->encoding = HTAtom_for(enc); free (enc); } suff->quality = value; }
PUBLIC HTAAModule * HTAA_newModule (const char * scheme, HTNetBefore * before, HTNetAfter * after, HTNetAfter * update, HTUTree_gc * gc) { if (scheme) { HTAAModule * pres = find_module(scheme); /* If found then update entry - else create a new one */ if (!pres) { if (!(pres = (HTAAModule *) HT_CALLOC(1, sizeof(HTAAModule)))) HT_OUTOFMEM("HTAA_newModule"); StrAllocCopy(pres->scheme, scheme); pres->before = before; pres->after = after; pres->update = update; pres->gc = gc; /* Add the new AA Module to the list */ HTList_addObject(HTSchemes, (void *) pres); HTTRACE(AUTH_TRACE, "Auth Engine. Created module %p\n" _ pres); } else { HTTRACE(AUTH_TRACE, "Auth Engine. Found module %p\n" _ pres); } return pres; } else { HTTRACE(AUTH_TRACE, "Auth Engine. Bad argument\n"); return NULL; } }
PUBLIC HTMuxChannel * HTMuxChannel_new (HTHost * host) { if (host) { HTMuxChannel * me = NULL; /* Create new object */ if ((me = (HTMuxChannel *) HT_CALLOC(1, sizeof(HTMuxChannel))) == NULL) HT_OUTOFMEM("HTMuxChannel_new"); me->hash = HTHost_hash(host); me->host = host; /* ** Make sure that we are in interleave mode */ HTHost_setMode(host, HT_TP_INTERLEAVE); /* ** Get a special MUX Net object that we keep to our selves. We don't ** associate a request object as the Net object lives longer. */ me->net = HTNet_new(NULL); HTNet_setReadStream(me->net, HTDemux_new(host, me)); /* Insert into hash table */ if (!muxchs) { if ((muxchs=(HTList **) HT_CALLOC(HOST_HASH_SIZE, sizeof(HTList *))) == NULL) HT_OUTOFMEM("HTMuxChannel_new"); } if (!muxchs[me->hash]) muxchs[me->hash] = HTList_new(); HTList_addObject(muxchs[me->hash], (void *) me); HTTRACE(MUX_TRACE, "Mux Channel. %p created with hash %d\n" _ me _ me->hash); return me; } return NULL; }
/* Add an entry to a list of host names ** ------------------------------------ ** Existing entries are replaced with new ones */ PRIVATE BOOL add_hostname (HTList * list, const char * host, const char * access, unsigned port, BOOL regex, int regex_flags) { HTHostList *me; if (!list || !host || !*host) return NO; if ((me = (HTHostList *) HT_CALLOC(1, sizeof(HTHostList))) == NULL) HT_OUTOFMEM("add_hostname"); #ifdef HT_POSIX_REGEX if (regex) me->regex = get_regex_t(host, regex_flags < 0 ? W3C_DEFAULT_REGEX_FLAGS : regex_flags); #endif if (access) { char *ptr; StrAllocCopy(me->access, access); /* Access method */ ptr = me->access; while ((*ptr = TOLOWER(*ptr))) ptr++; } StrAllocCopy(me->host, host); /* Host name */ { char *ptr = me->host; while ((*ptr = TOLOWER(*ptr))) ptr++; } me->port = port; /* Port number */ HTTRACE(PROT_TRACE, "HTHostList.. adding `%s\' to list\n" _ me->host); HTList_addObject(list, (void *) me); return YES; }
PRIVATE HTChildAnchor * HTAnchor_findChild ARGS2 (HTParentAnchor *,parent, CONST char *,tag) { HTChildAnchor *child; HTList *kids; if (! parent) { if (TRACE) printf ("HTAnchor_findChild called with NULL parent.\n"); return NULL; } if (kids = parent->children) { /* parent has children : search them */ if (tag && *tag) { /* TBL */ while (child = HTList_nextObject (kids)) { if (equivalent(child->tag, tag)) { /* Case sensitive 920226 */ if (TRACE) printf ( "Child anchor %p of parent %p with name `%s' already exists.\n", child, parent, tag); return child; } } } /* end if tag is void */ } else /* parent doesn't have any children yet : create family */ parent->children = HTList_new (); child = HTChildAnchor_new (); if (TRACE) fprintf(stderr, "new Anchor %p named `%s' is child of %p\n", child, (int)tag ? tag : (CONST char *)"" , parent); /* int for apollo */ HTList_addObject (parent->children, child); child->parent = parent; StrAllocCopy(child->tag, tag); return child; }
/* HTDNS_add ** --------- ** Add an element to the cache of visited hosts. Note that this function ** requires the system implemented structure hostent and not our own ** host_info. The homes variable indicates the number of IP addresses ** found. A host name must NOT contain a port number. ** Returns address of new HTdns object */ PUBLIC HTdns * HTDNS_add (HTList * list, struct hostent * element, char *host, int *homes) { HTdns *me; char *addr = NULL; char **index = element->h_addr_list; int cnt = 1; while(*index++) cnt++; if ((me = (HTdns *) HT_CALLOC(1, sizeof(HTdns))) == NULL || (me->addrlist = (char **) HT_CALLOC(1, cnt*sizeof(char*))) == NULL || (addr = (char *) HT_CALLOC(1, cnt*element->h_length)) == NULL) HT_OUTOFMEM("HTDNS_add"); StrAllocCopy(me->hostname, host); me->ntime = time(NULL); index = element->h_addr_list; cnt = 0; while (*index) { *(me->addrlist+cnt) = addr+cnt*element->h_length; memcpy((void *) *(me->addrlist+cnt++), *index++, element->h_length); } me->homes = cnt; *homes = cnt; if ((me->weight = (double *) HT_CALLOC(me->homes, sizeof(double))) == NULL) HT_OUTOFMEM("HTDNS_add"); me->addrlength = element->h_length; HTTRACE(PROT_TRACE, "DNS Add..... `%s\' with %d home(s) to %p\n" _ host _ *homes _ list); HTList_addObject(list, (void *) me); return me; }
/* Define a built-in function for a content-type ** --------------------------------------------- */ PUBLIC void HTSetConversion ARGS6( WWW_CONST char *, representation_in, WWW_CONST char *, representation_out, HTConverter*, converter, float, quality, float, secs, float, secs_per_byte ){ HTPresentation * pres = (HTPresentation *)malloc(sizeof(HTPresentation)); pres->rep = HTAtom_for(representation_in); pres->rep_out = HTAtom_for(representation_out); pres->converter = converter; pres->command = NULL; /* Fixed */ pres->quality = quality; pres->secs = secs; pres->secs_per_byte = secs_per_byte; pres->command = 0; if (!HTPresentations) HTPresentations = HTList_new(); if (strcmp(representation_in, "*")==0) { if (default_presentation) free(default_presentation); default_presentation = pres; } else { HTList_addObject(HTPresentations, pres); } }
PRIVATE ItemList *parse_item_list ARGS1(FILE *, fp) { ItemList *item_list = HTList_new(); Item *item; LexItem lex_item; for(;;) { if (!(item = parse_item(fp))) { HTList_delete(item_list); /* @@@@ */ item_list = NULL; return NULL; } HTList_addObject(item_list, (void*)item); lex_item = lex(fp); if (lex_item != LEX_ITEM_SEP) { unlex(lex_item); return item_list; } /* ** Here lex_item == LEX_ITEM_SEP; after item separator it ** is ok to have one or more newlines (LEX_REC_SEP) and ** they are ignored (continuation line). */ do { lex_item = lex(fp); } while (lex_item == LEX_REC_SEP); unlex(lex_item); } }
/* Define a built-in function for a content-type ** --------------------------------------------- */ PUBLIC void HTSetConversion ARGS7( HTList *, conversions, CONST char *, representation_in, CONST char *, representation_out, HTConverter*, converter, float, quality, float, secs, float, secs_per_byte ){ HTPresentation * pres = (HTPresentation *)malloc(sizeof(HTPresentation)); if (pres == NULL) outofmem(__FILE__, "HTSetPresentation"); pres->rep = HTAtom_for(representation_in); pres->rep_out = HTAtom_for(representation_out); pres->converter = converter; pres->command = NULL; /* Fixed */ pres->quality = quality; pres->secs = secs; pres->secs_per_byte = secs_per_byte; pres->command = 0; /* if (!HTPresentations) HTPresentations = HTList_new(); */ #ifdef OLD_CODE if (strcmp(representation_in, "*")==0) { if (default_presentation) free(default_presentation); default_presentation = pres; } else #endif HTList_addObject(conversions, pres); }
/* Define a presentation system command for a content-type ** ------------------------------------------------------- */ PUBLIC void HTSetPresentation ARGS6( HTList *, conversions, CONST char *, representation, CONST char *, command, float, quality, float, secs, float, secs_per_byte ){ HTPresentation * pres = (HTPresentation *)malloc(sizeof(HTPresentation)); if (pres == NULL) outofmem(__FILE__, "HTSetPresentation"); pres->rep = HTAtom_for(representation); pres->rep_out = WWW_PRESENT; /* Fixed for now ... :-) */ pres->converter = HTSaveAndExecute; /* Fixed for now ... */ pres->quality = quality; pres->secs = secs; pres->secs_per_byte = secs_per_byte; pres->rep = HTAtom_for(representation); pres->command = 0; StrAllocCopy(pres->command, command); /* if (!HTPresentations) HTPresentations = HTList_new(); */ #ifdef OLD_CODE if (strcmp(representation, "*")==0) { if (default_presentation) free(default_presentation); default_presentation = pres; } else #endif HTList_addObject(conversions, pres); }
PUBLIC BOOL HTAnchor_addLanguage (HTParentAnchor * me, HTLanguage language) { if (me && language) { if (!me->content_language) me->content_language = HTList_new(); return HTList_addObject(me->content_language, language); } return NO; }
void HTHistory_leavingFrom ARGS1 (HTAnchor *,anchor) { if (HTList_removeLastObject (history)) HTList_addObject (history, anchor); else if (TRACE) fprintf(stderr, "HTHistory_leavingFrom: empty history !\n"); }
PUBLIC BOOL HTAnchor_addEncoding (HTParentAnchor * me, HTEncoding encoding) { if (me && encoding) { if (!me->content_encoding) me->content_encoding = HTList_new(); return HTList_addObject(me->content_encoding, encoding); } return NO; }
PUBLIC BOOL HTList_appendObject (HTList * me, void * newObject) { if (me) { while (me->next) me = me->next; return HTList_addObject(me, newObject); } return NO; }
/* ** Content Encoding */ PUBLIC BOOL HTResponse_addEncoding (HTResponse * me, HTEncoding encoding) { if (me && encoding) { if (!me->content_encoding) me->content_encoding = HTList_new(); return HTList_addObject(me->content_encoding, encoding); } return NO; }
/* ** Transfer Encoding */ PUBLIC BOOL HTResponse_addTransfer (HTResponse * me, HTEncoding transfer) { if (me && transfer) { if (!me->transfer_encoding) me->transfer_encoding = HTList_new(); return HTList_addObject(me->transfer_encoding, transfer); } return NO; }
void HTHistory_record ARGS1 (HTAnchor *,destination) { if (destination) { if (! history) history = HTList_new(); HTList_addObject (history, destination); } }
HTAnchor * HTHistory_recall ARGS1 (int,number) { HTAnchor * destination = HTList_objectAt (history, HTList_count (history) - number); if (destination && destination != HTList_lastObject (history)) HTList_addObject (history, destination); return destination; }
/* ** Existing entries are replaced with new ones */ PRIVATE BOOL add_object (HTList * list, const char * access, const char * url, BOOL regex, int regex_flags) { HTProxy *me; if (!list || !access || !url || !*url) return NO; if ((me = (HTProxy *) HT_CALLOC(1, sizeof(HTProxy))) == NULL) HT_OUTOFMEM("add_object"); StrAllocCopy(me->access, access); /* Access method */ #ifdef HT_POSIX_REGEX /* ** If we support regular expressions then compile one up for ** this regular expression. Otherwise use is as a normal ** access scheme. */ if (regex) { me->regex = get_regex_t(access, regex_flags < 0 ? W3C_DEFAULT_REGEX_FLAGS : regex_flags); } else #endif { char *ptr = me->access; while ((*ptr = TOLOWER(*ptr))) ptr++; } me->url = HTParse(url, "", PARSE_ACCESS+PARSE_HOST+PARSE_PUNCTUATION); if (*(me->url+strlen(me->url)-1) != '/') StrAllocCat(me->url, "/"); me->url = HTSimplify(&me->url); /* See if we already have this one */ { HTList *cur = list; HTProxy *pres; while ((pres = (HTProxy *) HTList_nextObject(cur)) != NULL) { if (!strcmp(pres->access, me->access)) break; /* We already have it */ } if (pres) { HTTRACE(PROT_TRACE, "HTProxy..... replacing for `%s\' access %s\n" _ me->url _ me->access); HT_FREE(pres->access); HT_FREE(pres->url); #ifdef HT_POSIX_REGEX if (pres->regex) regfree(pres->regex); #endif HTList_removeObject(list, (void *) pres); HT_FREE(pres); } HTTRACE(PROT_TRACE, "HTProxy..... adding for `%s\' access %s\n" _ me->url _ me->access); HTList_addObject(list, (void *) me); } return YES; }
PUBLIC BOOL HTAnchor_addVariant (HTParentAnchor * me, HTParentAnchor * variant) { if (me && variant) { if (!me->variants) me->variants = HTList_new(); return HTList_addObject(me->variants, variant); } return NO; }
/* Put a presentation near start of list ** ------------------------------------- ** ** Look up a presentation (exact match only) and, if found, reorder ** it to the start of the HTPresentations list. - kw */ PUBLIC void HTReorderPresentation ARGS2( HTFormat, rep_in, HTFormat, rep_out) { HTPresentation *match; if ((match = HTFindPresentation(rep_in, rep_out, NULL))) { HTList_removeObject(HTPresentations, match); HTList_addObject(HTPresentations, match); } }
static void remember_alloced(void *ptr) { if (!alloced) { alloced = HTList_new(); #ifdef LY_FIND_LEAKS atexit(free_alloced_lynxcgi); #endif } HTList_addObject(alloced, ptr); }
/* Create new or find old named anchor ** ----------------------------------- ** ** Me one is for a reference which is found in a document, and might ** not be already loaded. ** Note: You are not guaranteed a new anchor -- you might get an old one, ** like with fonts. */ PUBLIC HTAnchor * HTAnchor_findAddress (const char * address) { char *tag = HTParse (address, "", PARSE_VIEW); /* Any tags? */ /* If the address represents a sub-anchor, we recursively load its parent, then we create a child anchor within that document. */ if (*tag) { char *addr = HTParse(address, "", PARSE_ACCESS | PARSE_HOST | PARSE_PATH | PARSE_PUNCTUATION); HTParentAnchor * parent = (HTParentAnchor*) HTAnchor_findAddress(addr); HTChildAnchor * child = HTAnchor_findChild(parent, tag); HT_FREE(addr); HT_FREE(tag); return (HTAnchor *) child; } else { /* Else check whether we have this node */ int hash; const char *p; HTList * adults; HTList *grownups; HTParentAnchor * foundAnchor; char *newaddr = NULL; StrAllocCopy(newaddr, address); /* Get our own copy */ HT_FREE(tag); newaddr = HTSimplify(&newaddr); /* Select list from hash table */ for(p=newaddr, hash=0; *p; p++) hash = (int) ((hash * 3 + (*(unsigned char*)p)) % PARENT_HASH_SIZE); if (!adult_table) { if ((adult_table = (HTList* *) HT_CALLOC(PARENT_HASH_SIZE, sizeof(HTList*))) == NULL) HT_OUTOFMEM("HTAnchor_findAddress"); } if (!adult_table[hash]) adult_table[hash] = HTList_new(); adults = adult_table[hash]; /* Search list for anchor */ grownups = adults; while ((foundAnchor = (HTParentAnchor *) HTList_nextObject(grownups))){ if (!strcmp(foundAnchor->address, newaddr)) { HTTRACE(ANCH_TRACE, "Find Parent. %p with address `%s' already exists.\n" _ (void*) foundAnchor _ newaddr); HT_FREE(newaddr); /* We already have it */ return (HTAnchor *) foundAnchor; } } /* Node not found : create new anchor. */ foundAnchor = HTParentAnchor_new(); foundAnchor->address = newaddr; /* Remember our copy */ HTList_addObject (adults, foundAnchor); HTTRACE(ANCH_TRACE, "Find Parent. %p with hash %d and address `%s' created\n" _ (void*)foundAnchor _ hash _ newaddr); return (HTAnchor *) foundAnchor; } }