/* 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;
}
}
