PRIVATE HTStream * HTNewsStatus_new (HTRequest * request, news_info * news, HTHost * host) { HTStream *me; if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL) HT_OUTOFMEM("HTNewsStatus_new"); me->isa = &HTNewsStatusClass; me->request = request; me->news = news; me->EOLstate = EOL_BEGIN; me->host = host; return me; }
PUBLIC HTBTree * HTBTree_new (HTComparer * comp) /********************************************************* ** This function returns an HTBTree with memory allocated ** for it when given a mean to compare things */ { HTBTree * tree; if ((tree = (HTBTree *) HT_CALLOC(1, sizeof(HTBTree))) == NULL) HT_OUTOFMEM("HTBTree_new"); tree->compare = comp; tree->top = NULL; return tree; }
/* Tee Stream creation ** ------------------- ** You can create a T stream using this method. Each stream returns a ** return value and in order to resolve conflicts in the return code ** you can specify a resolver callback function. Each time any of the ** data methods are called the resolver function is then called with ** the return codes from the two streams. The return code of the T stream ** itself will be the result of the resolver function. If you pass NULL ** as the resolver routine then a default resolver is used. */ PUBLIC HTStream * HTTee(HTStream * s1, HTStream * s2, HTComparer * resolver) { HTStream * me; if ((me = (HTStream *) HT_CALLOC(1, sizeof(*me))) == NULL) HT_OUTOFMEM("HTTee"); me->isa = &HTTeeClass; me->s1 = s1 ? s1 : HTBlackHole(); me->s2 = s2 ? s2 : HTBlackHole(); me->resolver = resolver ? resolver : default_resolver; HTTRACE(STREAM_TRACE, "Tee......... Created stream %p with resolver %p\n" _ me _ me->resolver); return me; }
/* ** A channel is uniquely identified by a socket. ** Note that we don't create the input and output stream - they are ** created later. ** ** We only keep a hash on sockfd's as we don't have to look for channels ** for ANSI file descriptors. */ PUBLIC HTChannel * HTChannel_new (SOCKET sockfd, FILE * fp, BOOL active) { HTList * list = NULL; HTChannel * ch = NULL; int hash = sockfd < 0 ? 0 : HASH(sockfd); HTTRACE(PROT_TRACE, "Channel..... Hash value is %d\n" _ hash); if (!channels) { if (!(channels = (HTList **) HT_CALLOC(HT_M_HASH_SIZE,sizeof(HTList*)))) HT_OUTOFMEM("HTChannel_new"); } if (!channels[hash]) channels[hash] = HTList_new(); list = channels[hash]; if ((ch = (HTChannel *) HT_CALLOC(1, sizeof(HTChannel))) == NULL) HT_OUTOFMEM("HTChannel_new"); ch->sockfd = sockfd; ch->fp = fp; ch->active = active; ch->semaphore = 1; ch->channelIStream.isa = &ChannelIStreamIsa; ch->channelOStream.isa = &ChannelOStreamIsa; ch->channelIStream.channel = ch; ch->channelOStream.channel = ch; HTList_addObject(list, (void *) ch); #ifdef HT_MUX /* ** Create a MUX channel and do a connect on this channel with a ** new session. */ { HTProtocol * protocol = HTNet_protocol(net); HTMuxChannel * muxch = HTMuxChannel_new(me); net->session = HTMuxSession_connect(muxch, net, HTProtocol_id(protocol)); } #endif /* HT_MUX */ HTTRACE(PROT_TRACE, "Channel..... Added %p to list %p\n" _ ch _ list); return ch; }
/* ** Set up the list of suffix bindings. Done by HTLibInit */ PUBLIC BOOL HTBind_init (void) { if (!HTBindings) { if (!(HTBindings = (HTList **) HT_CALLOC(HT_L_HASH_SIZE, sizeof(HTList *)))) HT_OUTOFMEM("HTBind_init"); } StrAllocCopy(HTDelimiters, DEFAULT_SUFFIXES); no_suffix.type = WWW_UNKNOWN; no_suffix.encoding = WWW_CODING_BINARY; unknown_suffix.type = WWW_UNKNOWN; unknown_suffix.encoding = WWW_CODING_BINARY; return YES; }
/* ** A AA element is a particular AA procotol associated with a ** particular point in the URL tree. The scheme is the name of the ** AA protocol known to be able to handle this context. This protocol ** must have been registered as a AA module. */ PRIVATE HTAAElement * HTAA_newElement (const char * scheme, void * context) { if (scheme) { HTAAElement * me; if ((me = (HTAAElement *) HT_CALLOC(1, sizeof(HTAAElement))) == NULL) HT_OUTOFMEM("HTAAElement_new"); StrAllocCopy(me->scheme, scheme); me->context = context; HTTRACE(AUTH_TRACE, "Auth Engine. Created element %p\n" _ me); return me; } return NULL; }
PRIVATE HTStream * HTTPReceive_new (HTRequest * request, https_info * http) { HTStream * me; if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL) HT_OUTOFMEM("HTTPReceive_new"); me->isa = &HTTPReceiveClass; me->request = request; me->http = http; me->state = EOL_BEGIN; me->buffer = HTChunk_new(128); /* Sufficiant for most URLs */ HTTRACE(STREAM_TRACE, "HTTP Request Stream %p created\n" _ me); return me; }
PRIVATE HTStream * HTTPReply_new (HTRequest * request, https_info * http, HTStream * target) { HTStream * me; if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL) HT_OUTOFMEM("HTTPReply_new"); me->isa = &HTTPReplyClass; me->request = request; me->http = http; me->target = target; HTTRACE(STREAM_TRACE, "HTTP Reply.. Stream %p created\n" _ me); return me; }
/* Create new or find old child anchor ** ----------------------------------- ** ** Me one is for a new anchor being edited into an existing ** document. The parent anchor must already exist. All ** children without tags (no NAME attribut) points to the same NULL ** child. ** Children are now hashed for performance reasons. Thanks to ** Michael Farrar */ PUBLIC HTChildAnchor * HTAnchor_findChild (HTParentAnchor * parent, const char * tag) { HTChildAnchor * child = NULL; HTList * kids = NULL; if (!parent) { HTTRACE(ANCH_TRACE, "Child Anchor Bad argument\n"); return NULL; } /* Find a hash for this tag (if any) */ { int hash = 0; /* ** If tag is empty then use hash value 0 */ if (tag) { const char * ptr = tag; for(; *ptr; ptr++) hash = (int) ((hash*3 + (*(unsigned char*)ptr)) % CHILD_HASH_SIZE); } if (!parent->children) { if (!(parent->children = (HTList **) HT_CALLOC(CHILD_HASH_SIZE, sizeof(HTList *)))) HT_OUTOFMEM("HTAnchor_findChild"); } if (!parent->children[hash]) parent->children[hash] = HTList_new(); kids = parent->children[hash]; } /* First search list of children to see if tag is already there */ if (tag && *tag) { HTList * cur = kids; while ((child = (HTChildAnchor *) HTList_nextObject(cur))) { if (child->tag && !strcmp(child->tag, tag)) { HTTRACE(ANCH_TRACE, "Child Anchor %p of parent %p with name `%s' already exists.\n" _ (void *) child _ (void *) parent _ tag); return child; } } } /* If not found then create a new child anchor */ child = HTChildAnchor_new(); HTList_addObject(kids, (void *) child); child->parent = parent; if (tag) StrAllocCopy(child->tag, tag); HTTRACE(ANCH_TRACE, "Child Anchor New Anchor %p named `%s' is child of %p\n" _ (void *) child _ tag ? tag : (const char *) "" _ (void *)parent); return child; }
/* HTAlertCall_add ** --------------- ** Register a call back function that is to be called when generating ** messages, dialog, prompts, progress reports etc. ** ** The opcode signifies which call back function to call depending of the ** type of the message. Opcode can be one of the enumerations defined ** by HTAlertOpcode. */ PUBLIC BOOL HTAlertCall_add (HTList * list, HTAlertCallback * cbf, HTAlertOpcode opcode) { HTTRACE(CORE_TRACE, "Alert Call.. Add Alert Handler %p\n" _ (void *) cbf); if (list && cbf) { HTAlert *me; if ((me = (HTAlert *) HT_CALLOC(1, sizeof(HTAlert))) == NULL) HT_OUTOFMEM("HTAlertCall_add"); me->cbf = cbf; me->opcode = opcode; return HTList_addObject(list, (void *) me); } return NO; }
PUBLIC HTStream* HTPlainPresent (HTRequest * request, void * param, HTFormat input_format, HTFormat output_format, HTStream * output_stream) { HTStream * me; if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL) HT_OUTOFMEM("HTPlain_new"); me->isa = &HTPlain; me->text = HTextImp_new(request, HTRequest_anchor(request), output_stream); HTextImp_build(me->text, HTEXT_BEGIN); return me; }
PUBLIC BOOL HTMuxProtocol_add (HTMuxChannel * muxch, HTProtocolId pid, const char * protocol) { if (muxch && protocol) { HTMuxProtocol * ms; if ((ms = (HTMuxProtocol *) HT_CALLOC(1, sizeof(HTMuxProtocol))) == NULL) HT_OUTOFMEM("HTMuxProtocol_new"); ms->name = HTAtom_caseFor(protocol); ms->pid = pid; if (!muxch->protocols) muxch->protocols = HTList_new(); return HTList_addObject(muxch->protocols, ms); } return NO; }
PUBLIC HTStream* HTXParse (HTRequest * request, void * param, HTFormat input_format, HTFormat output_format, HTStream * output_stream) { HTStream* me; #ifdef HTDEBUG if (STREAM_TRACE) { HTTRACE(STREAM_TRACE, "HTXConvert.."); if (input_format && input_format->name) HTTRACE(STREAM_TRACE, ".. input format is %s" _ input_format->name); if (output_format && output_format->name) HTTRACE(STREAM_TRACE, ".. output format is %s" _ output_format->name); HTTRACE(STREAM_TRACE, "\n"); } #endif /* HTDEBUG */ if ((me = (HTStream *) HT_CALLOC(1, sizeof(*me))) == NULL) HT_OUTOFMEM("HTXConvert"); me->isa = &HTXParseClass; if ((me->eps = (HTXParseStruct *) HT_CALLOC(1, sizeof(HTXParseStruct))) == NULL) HT_OUTOFMEM("HTXConvert"); if (input_format) me->eps->content_type = input_format->name; me->eps->call_client = HTCallClient; if ((me->eps->buffer = (char *) HT_CALLOC(INPUT_BUFFER_SIZE,1)) == NULL) HT_OUTOFMEM("HTXParse"); me->eps->used = 0; me->eps->finished = NO; me->eps->length = INPUT_BUFFER_SIZE; me->eps->request = request; return me; }
/* ** Create a new host profile object and initialize it with what we can ** find on this host. */ PUBLIC HTUserProfile * HTUserProfile_new (const char * name, void * context) { HTUserProfile * me = NULL; if (name) { if ((me = (HTUserProfile *) HT_CALLOC(1, sizeof(HTUserProfile)))==NULL) HT_OUTOFMEM("HTUserProfile_new"); HTTRACE(CORE_TRACE, "User Profile Adding `%s\'\n" _ name); StrAllocCopy(me->user, name); /* Set the context */ me->context = context; } return me; }
/* ** Do not use "new" by itself outside this module. In order to enforce ** consistency, we insist that you furnish more information about the ** anchor you are creating : use newWithParent or newWithAddress. */ PRIVATE HTParentAnchor * HTParentAnchor_new (void) { HTParentAnchor *newAnchor; if ((newAnchor = (HTParentAnchor *) HT_CALLOC(1, sizeof (HTParentAnchor))) == NULL) HT_OUTOFMEM("HTParentAnchor_new"); newAnchor->parent = newAnchor; newAnchor->content_type = WWW_UNKNOWN; newAnchor->mainLink.method = METHOD_INVALID; newAnchor->content_length = -1; /* howcome 6 dec 95 */ newAnchor->date = (time_t) -1; newAnchor->expires = (time_t) -1; newAnchor->last_modified = (time_t) -1; newAnchor->age = (time_t) -1; return newAnchor; }
PUBLIC HTStream * HTFWriter_new (HTRequest * request, FILE * fp, BOOL leave_open) { HTStream * me = NULL; if (!fp) { HTTRACE(STREAM_TRACE, "FileWriter.. Bad file descriptor\n"); return HTErrorStream(); } if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL) HT_OUTOFMEM("HTFWriter_new"); me->isa = &HTFWriter; me->fp = fp; me->leave_open = leave_open; return me; }
PUBLIC BOOL HTAssocList_addObject (HTAssocList * list, const char * name, const char * value) { if (list && name) { HTAssoc * assoc; if ((assoc = (HTAssoc *) HT_CALLOC(1, sizeof(HTAssoc))) == NULL) HT_OUTOFMEM("HTAssoc_add"); StrAllocCopy(assoc->name, name); if (value) StrAllocCopy(assoc->value, value); return HTList_addObject(list, (void *) assoc); } else { HTTRACE(UTIL_TRACE, "HTAssoc_add: ERROR: assoc list NULL!!\n"); } return NO; }
PUBLIC HTList * HTList_addList (HTList * me, void * newObject) { if (me) { HTList *newNode; if ((newNode = (HTList *) HT_CALLOC(1, sizeof(HTList))) == NULL) HT_OUTOFMEM("HTList_addObject"); newNode->object = newObject; newNode->next = me->next; me->next = newNode; return newNode; } else { HTTRACE(CORE_TRACE, "HTList...... Can not add object %p to nonexisting List\n" _ newObject); } return (HTList *) NULL; }
PUBLIC HTStream * HTBuffer_new (HTStream * target, HTRequest * request, int max_size) { HTStream * me; if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL) HT_OUTOFMEM("HTBufferStream"); me->isa = &HTBufferClass; me->target = target; me->request = request; me->max_size = (max_size > 0) ? max_size : HT_MAX_SIZE; me->mode = HT_BM_PLAIN; HTTRACE(STREAM_TRACE, "Buffer...... Created with size %d\n" _ me->max_size); return me; }
PUBLIC HTOutputStream * HTWriter_new (HTHost * host, HTChannel * ch, void * param, int mode) { if (host && ch) { HTOutputStream * me = HTChannel_output(ch); if (!me) { if ((me=(HTOutputStream *) HT_CALLOC(1, sizeof(HTOutputStream)))==NULL) HT_OUTOFMEM("HTWriter_new"); me->isa = &HTWriter; me->ch = ch; me->host = host; } return me; } return NULL; }
PRIVATE void append_buf (HTStream * me) { HTBufItem * b; if ((b = (HTBufItem *) HT_CALLOC(1, sizeof(HTBufItem))) == NULL) HT_OUTOFMEM("append_buf"); b->len = me->tmp_ind; b->buf = me->tmp_buf; me->tmp_ind = 0; me->tmp_max = 0; me->tmp_buf = 0; if (me->tail) me->tail->next = b; else me->head = b; me->tail = b; }
PUBLIC void HTCharset_add (HTList * list, const char * charset, double quality) { HTAcceptNode * node; if (!list || !charset || !*charset) { HTTRACE(CORE_TRACE, "Charset..... Bad argument\n"); return; } if ((node = (HTAcceptNode *) HT_CALLOC(1, sizeof(HTAcceptNode))) == NULL) HT_OUTOFMEM("HTAcceptCharsetuage"); HTList_addObject(list, (void*)node); node->atom = HTAtom_for(charset); node->quality = quality; }
PRIVATE regex_t * get_regex_t (const char * regex_str, int cflags) { regex_t * regex = NULL; if (regex_str && *regex_str) { int status; if ((regex = (regex_t *) HT_CALLOC(1, sizeof(regex_t))) == NULL) HT_OUTOFMEM("get_regex_t"); if ((status = regcomp(regex, regex_str, cflags))) { char * err_msg = get_regex_error(status, regex); HTTRACE(PROT_TRACE, "HTProxy..... Regular expression error: %s\n" _ err_msg); HT_FREE(err_msg); HT_FREE(regex); } } return regex; }
PUBLIC void HTLanguage_add (HTList * list, const char * lang, double quality) { HTAcceptNode * node; if (!list || !lang || !*lang) { HTTRACE(CORE_TRACE, "Languages... Bad argument\n"); return; } if ((node = (HTAcceptNode *) HT_CALLOC(1, sizeof(HTAcceptNode))) == NULL) HT_OUTOFMEM("HTAcceptLanguage"); HTList_addObject(list, (void*)node); node->atom = HTAtom_for(lang); node->quality = quality; }
/* Create a Command Line Object ** ---------------------------- */ PRIVATE ComLine * ComLine_new (void) { ComLine * me; if ((me = (ComLine *) HT_CALLOC(1, sizeof(ComLine))) == NULL) HT_OUTOFMEM("ComLine_new"); me->timer = DEFAULT_TIMEOUT*MILLIES; me->cwd = HTGetCurrentDirectoryURL(); me->output = OUTPUT; /* Bind the ConLine object together with the Request Object */ me->request = HTRequest_new(); HTRequest_setOutputFormat(me->request, DEFAULT_FORMAT); HTRequest_setContext (me->request, me); return me; }
/* Converter from WAIS Source to whatever ** -------------------------------------- */ PUBLIC HTStream* HTWSRCConvert (HTRequest * request, void * param, HTFormat input_format, HTFormat output_format, HTStream * output_stream) { HTStream * me; if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL) HT_OUTOFMEM("HTWSRCConvert"); me->isa = &WSRCParserClass; me->target = HTMLGenerator(request, param, input_format, output_format, output_stream); me->request = request; me->state = beginning; return me; }
/* Append a character ** ------------------ */ PUBLIC void HTChunk_putc (HTChunk * ch, char c) { if (ch) { if (!ch->data || ch->size >= ch->allocated-1) { /* [SIC] bobr */ if (ch->data) { if ((ch->data = (char *) HT_REALLOC(ch->data,ch->allocated+ch->growby)) == NULL) HT_OUTOFMEM("HTChunk_putc"); memset((void *) (ch->data + ch->allocated), '\0', ch->growby); } else { if ((ch->data = (char *) HT_CALLOC(1, ch->allocated+ch->growby)) == NULL) HT_OUTOFMEM("HTChunk_putc"); } ch->allocated += ch->growby; } *(ch->data+ch->size++) = c; } }
PUBLIC HTEvent * HTEvent_new (HTEventCallback * cbf, void * context, HTPriority priority, int millis) { if (cbf) { HTEvent * me; if ((me = (HTEvent *) HT_CALLOC(1, sizeof(HTEvent))) == NULL) HT_OUTOFMEM("HTEvent_new"); me->cbf = cbf; me->param = context; me->priority = priority; me->millis = millis; HTTRACE(CORE_TRACE, "Event....... Created event %p with context %p, priority %d, and timeout %d\n" _ me _ context _ priority _ millis); return me; } return NULL; }
PUBLIC HTStream * HTGuess_new (HTRequest * request, void * param, HTFormat input_format, HTFormat output_format, HTStream * output_stream) { HTStream * me; if ((me = (HTStream *) HT_CALLOC(1,sizeof(HTStream))) == NULL) HT_OUTOFMEM("HTGuess_new"); me->isa = &HTGuessClass; me->request = request; me->response = HTRequest_response(request); me->output_format = output_format; me->output_stream = output_stream; me->write_ptr = me->buffer; return me; }
HText * HText_new2 (HTRequest * request, HTParentAnchor * anchor, HTStream * stream) { HText * me; Robot * mr = (Robot *) HTRequest_context(request); if ((me = (HText *) HT_CALLOC(1, sizeof(HText))) == NULL) HT_OUTOFMEM("HText_new2"); /* Bind the HText object together with the Request Object */ me->request = request; me->first_anchor = me->last_anchor = 0; me->anchors = 0; /* Add this HText object to our list */ mr->htext = me; return me; }