自学教程：C++ HTTRACE函数代码示例

/*	Translate by rules**	------------------**	The most recently defined rules are applied last.**	This function walks through the list of rules and translates the**	reference when matches are found. The list is traversed in order**	starting from the head of the list. It returns the address of the**	equivalent string allocated from the heap which the CALLER MUST**	FREE.*/PUBLIC char * HTRule_translate (HTList * list, const char * token,				BOOL ignore_case){    HTRule * pres;    char * replace = NULL;    if (!token || !list) return NULL;    HTTRACE(APP_TRACE, "Check rules. for `%s/'/n" _ token);    while ((pres = (HTRule *) HTList_nextObject(list))) {	char * rest = ignore_case ? HTStrCaseMatch(pres->pattern, token) :	    HTStrMatch(pres->pattern, token);	if (!rest) continue;				  /* No match at all */    	/* We found a match for this entry, now do operation */	switch (pres->op) {          case HT_Pass:	  case HT_Map:	    if (!pres->replace) {			       /* No replace */		StrAllocCopy(replace, token);	    } else if (*rest && pres->insert >= 0) {		if ((replace = (char  *) HT_MALLOC(strlen(pres->replace)+strlen(rest))) == NULL)		    HT_OUTOFMEM("HTRule_translate");		strcpy(replace, pres->replace);		strcpy(replace+pres->insert, rest);	    } else {		       /* Perfect match or no insetion point */		StrAllocCopy(replace, pres->replace);	    }	    if (pres->op == HT_Pass) {		HTTRACE(APP_TRACE, "............ map into `%s'/n" _ replace);		return replace;	    }	    break;	    	  case HT_Fail:	  default:	    HTTRACE(APP_TRACE, "............ FAIL `%s'/n" _ token);	    return NULL;	}    }    if (!replace) StrAllocCopy(replace, token);    return replace;}

PRIVATE void Event_trace (HTEvent * event){    if (event) {	HTTRACE(ALL_TRACE, "%8p: %3d %6d %8p %8p %8p" _		event _ event->priority _ event->millis _ event->cbf _		event->param _ event->request);    }}

PUBLIC int HTEvent_unregister (SOCKET s, HTEventType type){    if (!UnregisterCBF) {	HTTRACE(CORE_TRACE, "Event....... No handler registered/n");        return -1;    }    return (*UnregisterCBF)(s, type);}

PUBLIC BOOL HTResponse_delete (HTResponse * me){    if (me) {        HTTRACE(CORE_TRACE, "Response.... Delete %p/n" _ me);        /* Access Authentication */        HT_FREE(me->realm);        HT_FREE(me->scheme);        if (me->challenge) HTAssocList_delete(me->challenge);        /* Connection headers */        if (me->connection) HTAssocList_delete(me->connection);        /* PEP Information */        if (me->protocol) HTAssocList_delete(me->protocol);        if (me->protocol_request) HTAssocList_delete(me->protocol_request);        if (me->protocol_info) HTAssocList_delete(me->protocol_info);        /* Cache control headers */        if (me->cache_control) HTAssocList_delete(me->cache_control);        /* Byte ranges */        if (me->byte_ranges) HTAssocList_delete(me->byte_ranges);        /* Transfer Encodings */        if (me->transfer_encoding) HTList_delete(me->transfer_encoding);        /* Trailers */        if (me->trailer) HTAssocList_delete(me->trailer);        /* Variants */        if (me->variants) HTAssocList_delete(me->variants);        /*        ** Only delete Content Type parameters and original headers if the        ** information is not used elsewhere, for example by the anchor        ** object.        */        if (!me->cached) {            /* Content type parameters */            if (me->type_parameters) HTAssocList_delete(me->type_parameters);            /* Content Encodings */            if (me->content_encoding) HTList_delete(me->content_encoding);            /* List of all headers */            if (me->headers) HTAssocList_delete(me->headers);        }        /* HTTP reason string */        if (me->reason)  HT_FREE (me->reason);        HT_FREE(me);        return YES;    }    return NO;}

PRIVATE int HTFWriter_abort (HTStream * me, HTList * e){    HTTRACE(STREAM_TRACE, "FileWriter.. ABORTING.../n");    if (me) {	if (me->leave_open != YES) fclose(me->fp);	HT_FREE(me);    }    return HT_ERROR;}

PUBLIC HTMuxSession * HTMuxSession_register (HTMuxChannel * muxch,					     HTMuxSessionId sid, HTProtocolId pid){    if (muxch) {	HTMuxSession * session = muxch->sessions[sid];	if (session == NULL) {	    session = session_new();	    session->sid = sid;	    session->pid = pid;	    muxch->sessions[sid] = session;	    HTTRACE(MUX_TRACE, "Mux Channel. Registered session %d on channel %p/n" _ 			sid _ muxch);	}	return session;    }    HTTRACE(MUX_TRACE, "Mux Channel. Can't register new session/n");    return NULL;}

PUBLIC HTMuxSessionId HTMuxSession_accept (HTMuxChannel * muxch, HTNet * net,					   HTProtocolId pid){    if (muxch && net) {	HTMuxSession * session;	HTMuxSessionId sid = SID_BASE + RECEIVER_OFFSET;	for (; sid<MAX_SESSIONS; sid+=2) {	    if ((session = muxch->sessions[sid]) &&		session->net == NULL && session->pid == pid) {		HTTRACE(MUX_TRACE, "Mux Channel. Accepting session %d on channel %p/n" _ 			    sid _ muxch);		return sid;	    }	}    }    HTTRACE(MUX_TRACE, "Mux Channel. Can't accept new session/n");    return INVSID;}

PUBLIC BOOL HTTimer_registerDeleteTimerCallback (HTTimerSetCallback * cbf){    HTTRACE(CORE_TRACE, "Timer....... registering %p as timer delete cbf/n" _ cbf);    if (cbf) {	DeletePlatformTimer = cbf;	return YES;    }    return NO;}

PRIVATE int HTXParse_free (HTStream * me){    HTTRACE(STREAM_TRACE, "HTXParse_free/n");    me->eps->finished = YES;    (*(me->eps->call_client))(me->eps);           /* client will free buffer */    HT_FREE(me->eps);    HT_FREE(me);    return HT_OK;}

PUBLIC BOOL HTCookie_deleteCallbacks (void){    HTTRACE(APP_TRACE, "Cookie...... Unregistering cookie callbacks/n");    SetCookie = NULL;    SetCookieContext = NULL;    FindCookie = NULL;    FindCookieContext = NULL;    return YES;}

/*							HTCleanTelnetString() *	Make sure that the given string doesn't contain characters that *	could cause security holes, such as newlines in ftp, gopher, *	news or telnet URLs; more specifically: allows everything between *	ASCII 20-7E, and also A0-FE, inclusive. Also TAB ('/t') allowed! * * On entry, *	str	the string that is *modified* if necessary.  The *		string will be truncated at the first illegal *		character that is encountered. * On exit, *	returns	YES, if the string was modified. *		NO, otherwise. */PUBLIC BOOL HTCleanTelnetString (char * str){    char * cur = str;    if (!str) return NO;    while (*cur) {	int a = TOASCII((unsigned char) *cur);	if (a != 0x9 && (a < 0x20 || (a > 0x7E && a < 0xA0) ||  a > 0xFE)) {	    HTTRACE(URI_TRACE, "Illegal..... character in URL: /"%s/"/n" _ str);	    *cur = 0;	    HTTRACE(URI_TRACE, "Truncated... /"%s/"/n" _ str);	    return YES;	}	cur++;    }    return NO;}

PRIVATE int HTBoundary_abort (HTStream * me, HTList * e){    int status = HT_ERROR;    if (me->target) status = (*me->target->isa->abort)(me->target, e);    HTTRACE(PROT_TRACE, "Boundary.... ABORTING.../n");    HT_FREE(me->boundary);    HT_FREE(me);    return status;}

PUBLIC BOOL HTEvent_delete (HTEvent * me){    if (me) {	HT_FREE(me);	HTTRACE(CORE_TRACE, "Event....... Deleted event %p/n" _ me);	return YES;    }    return NO;}

PRIVATE int HTZLibInflate_abort (HTStream * me, HTList * e){    HTTRACE(STREAM_TRACE, "Zlib Inflate ABORTING.../n");    ZLib_terminate(me);    (*me->target->isa->abort)(me->target, NULL);    HT_FREE(me->zstream);    HT_FREE(me);    return HT_ERROR;}

/***	Explicitly set the semaphore for this channel*/PUBLIC void HTChannel_setSemaphore (HTChannel * channel, int semaphore){    if (channel) {        channel->semaphore = semaphore;        if (channel->semaphore <= 0) channel->semaphore = 0;        HTTRACE(PROT_TRACE, "Channel..... Semaphore set to %d for channel %p/n" _                channel->semaphore _ channel);    }}

/***	Decrease the semaphore for this channel*/PUBLIC void HTChannel_downSemaphore (HTChannel * channel){    if (channel) {        channel->semaphore--;        if (channel->semaphore <= 0) channel->semaphore = 0;        HTTRACE(PROT_TRACE, "Channel..... Semaphore decreased to %d for channel %p/n" _                channel->semaphore _ channel);    }}

/*	Delete a AA context from the URL tree**	-------------------------------------**	Each node in the AA URL tree is a list of the modules we must call**	for this particular node.*/PUBLIC BOOL HTAA_deleteNode (BOOL proxy_access, char const * scheme,			     const char * realm, const char * url){    HTUTree * tree = NULL;    HTAAModule * module = NULL;    if (!scheme || !url) {	HTTRACE(AUTH_TRACE, "Auth Engine. Bad argument/n");	return NO;    }    HTTRACE(AUTH_TRACE, "Auth Engine. Deleting info for `%s'/n" _ url);    /* Find the AA module with this name */    if ((module = HTAA_findModule(scheme)) == NULL) {	HTTRACE(AUTH_TRACE, "Auth Engine. Module `%s/' not registered/n" _ 			       scheme ? scheme : "<null>");	return NO;    }    /* Find an existing URL Tree or create a new one */    {	char * host = HTParse(url, "", PARSE_HOST);	char * colon = strchr(host, ':');	int port = DEFAULT_PORT;	if (colon ) {	    *(colon++) = '/0';			     /* Chop off port number */	    port = atoi(colon);	}	tree = HTUTree_new(proxy_access ? AA_PROXY_TREE : AA_TREE,			   host, port, HTAA_deleteElement);	HT_FREE(host);	if (!tree) {	    HTTRACE(AUTH_TRACE, "Auth Engine. Can't create tree/n");	    return NO;	}    }    /* Delete any existing node */    {	char * path = HTParse(url, "", PARSE_PATH | PARSE_PUNCTUATION);	BOOL status = HTUTree_deleteNode(tree, realm, path);	HT_FREE(path);	return status;    }}

/***	Searches for NNTP header line until buffer fills up or a CRLF or LF**	is found*/PRIVATE int HTNewsStatus_put_block (HTStream * me, const char * b, int l){    int status;    HTHost_setConsumed(me->host, l);    while (!me->semi_trans && l-- > 0) {	if (me->EOLstate == EOL_FCR) {	    if (*b == LF) {		if (me->junk) me->junk = NO;		me->EOLstate = EOL_BEGIN;		if ((status = ScanResponse(me)) != HT_LOADED) return status;	    }	} else if (*b == CR) {	    me->EOLstate = EOL_FCR;	} else if (*b == LF) {	    if (me->junk) me->junk = NO;	    me->EOLstate = EOL_BEGIN;	    if ((status = ScanResponse(me)) != HT_LOADED) return status;	} else {	    *(me->buffer+me->buflen++) = *b;	    if (me->buflen >= MAX_NEWS_LINE) {		HTTRACE(PROT_TRACE, "News Status. Line too long - chopped/n");		me->junk = YES;		if ((status = ScanResponse(me)) != HT_LOADED) return status;	    }	}	b++;    }	    /*    ** Now see if we have parts of the body to put down the stream pipe.    ** At this point we are looking for CRLF.CRLF. We are guaranteed a stream    */    if (l > 0) {	int rest = l;	const char *ptr = b;	while (rest-- > 0) {	    if (*ptr == CR) {		me->EOLstate = me->EOLstate==EOL_DOT ? EOL_SCR : EOL_FCR;	    } else if (*ptr == '.') {		me->EOLstate = me->EOLstate==EOL_FLF ? EOL_DOT : EOL_BEGIN;	    } else if (*ptr == LF) {		me->EOLstate = me->EOLstate>EOL_DOT ? EOL_SLF : EOL_FLF;	    } else		me->EOLstate = EOL_BEGIN;	    ptr++;	}	if (me->EOLstate == EOL_SLF) {	    int status = PUTBLOCK(b, l-5);	    return status != HT_OK ? status : HT_LOADED;	} else {	    int status = PUTBLOCK(b, l);	    return status;	}    }    return HT_LOADED;}

/*	HTRequest_dup**	-------------**	Creates a new HTRequest object as a duplicate of the src request.**	Returns YES if OK, else NO*/PUBLIC HTRequest * HTRequest_dup (HTRequest * src){    HTRequest * me;    if (!src) return NULL;    if ((me = (HTRequest  *) HT_MALLOC(sizeof(HTRequest))) == NULL)        HT_OUTOFMEM("HTRequest_dup");    memcpy(me, src, sizeof(HTRequest));    HTTRACE(CORE_TRACE, "Request..... Duplicated %p to %p/n" _ src _ me);    return me;}

/*	HTMemoryCall_deleteAll**	----------------------**	Unregisters all call back functions*/PUBLIC BOOL HTMemoryCall_deleteAll (void){    HTTRACE(MEM_TRACE, "Mem Delete.. All Callback functions/n");    if (HTMemCall) {	HTList_delete(HTMemCall);	HTMemCall = NULL;	return YES;    }    return NO;}

PUBLIC BOOL HTMLUseCharacterSet (HTMLCharacterSet i){    if (i == HTML_ISO_LATIN1) {	CurrentEntityValues = ISO_Latin1;	return YES;    } else {	HTTRACE(SGML_TRACE, "HTML Parser. Doesn't support this character set/n");	return NO;    }}

PUBLIC HTStream * HTBlackHoleConverter (HTRequest *	request,					void *		param,					HTFormat	input_format,					HTFormat	output_format,					HTStream *	output_stream){    HTTRACE(STREAM_TRACE, "BlackHole... Converter Created/n");    HTBaseConverterStreamInstance.isa = &HTBlackHoleConverterClass;    return &HTBaseConverterStreamInstance;}

PRIVATE int HTSSLReader_abort (HTInputStream * me, HTList * e){    HTNet * net = HTHost_getReadNet(me->host);    HTTRACE(PROT_TRACE, "HTSSLReader. Abort %p/n" _ me);    if (net && net->readStream) {	int status = (*net->readStream->isa->abort)(net->readStream, NULL);	if (status != HT_IGNORE) net->readStream = NULL;    }    return HT_ERROR;}

/*** Destroy HTSSL object if no references to it remain in application*/PUBLIC void HTSSL_free (HTSSL * htssl){    (htssl->ref_count)--;    HTTRACE(PROT_TRACE, "HTSSL Free.. ref_count = %d/n" _ htssl->ref_count);    if (htssl->ref_count == 0) {        HTTRACE(PROT_TRACE, "HTSSL.Free.. FINAL RELEASE/n");        if (htssl->ssl) {            SSL_free(htssl->ssl);            htssl->ssl = NULL;        }               HTList_removeObject(ssl_list, htssl);                  /* releases itself */        HT_FREE(htssl);    }}

PRIVATE int CSUserList_abort (HTStream * me, HTList * e){    int status = HT_ERROR;    if (me->target) status = (*me->target->isa->abort)(me->target, e);    HTTRACE(APP_TRACE, "Rules....... ABORTING.../n");    HTChunkFree(me->buffer);    /*    HTList_delete(me->URLs); */    HT_FREE(me);    return status;}

/***	Allocates memory using calloc*/PUBLIC void * HTMemory_calloc (size_t nobj, size_t size){    void * ptr;    ptr = calloc(nobj, LastAllocSize = size);    if (ptr != NULL) return ptr;    if (HTMemCall) {	HTMemoryCallback * pres;	size_t total = size * nobj;	while ((pres = (HTMemoryCallback *) HTList_nextObject(HTMemCall))) {	    HTTRACE(MEM_TRACE, "Mem Calling. %p (size %d)/n" _ 				   (void *) pres _ total);	    (*pres)(total);	    if ((ptr = calloc(nobj, size)) != NULL) return ptr;	}    }    HTTRACE(MEM_TRACE, "Memory...... Couldn't allocate %d objects of size %d/n" _ 		 nobj _ size);    return NULL;}

PRIVATE int HTBufferWriter_abort (HTOutputStream * me, HTList * e){    HTTRACE(STREAM_TRACE, "Buffer...... ABORTING.../n");    if (me->timer) {	HTTimer_delete(me->timer);	me->timer = NULL;    }    if (me->target) (*me->target->isa->abort)(me->target, e);    return HT_ERROR;}

/*	End writing*/PRIVATE int HTMIME_abort (HTStream * me, HTList * e){    int status = HT_ERROR;    if (me->target) status = (*me->target->isa->abort)(me->target, e);    HTTRACE(PROT_TRACE, "MIME........ ABORTING.../n");    HTChunk_delete(me->token);    HTChunk_delete(me->value);    HT_FREE(me);    return status;}

PUBLIC HTStream * HTCacheCopyHeaders   (HTRequest *	request,					void *		param,					HTFormat	input_format,					HTFormat	output_format,					HTStream *	output_stream){    HTTRACE(STREAM_TRACE, "Cache Copy Headers.. Copying headers into the response object/n");    HTMIME_anchor2response (request);    return HT_OK;}

PUBLIC BOOL HText_select (HText * text){    if (text) {        HTMainText = text;	HTMainAnchor = text->node_anchor;	display_page(text, text->top_of_screen);	return YES;    }    HTTRACE(SGML_TRACE, "Rendering... Nothing to select!/n");    return NO;}