/*
** When deleting a channel we first look at if there are no more requests
** using the channel (the semaphore is <= 0). Then, if the socket supports
** persistent connections then we register the channel in the Host cache
** and wait until the other end closes it or we get a time out on our side
*/
PUBLIC BOOL HTChannel_delete (HTChannel * channel, int status)
{
if (channel) {
HTTRACE(PROT_TRACE, "Channel..... Delete %p with semaphore %d, status %d\n" _
channel _ channel->semaphore _ status);
/*
** We call the free methods on both the input stream and the output
** stream so that we can free up the stream pipes. However, note that
** this doesn't mean that we close the input stream and output stream
** them selves - only the generic streams
*/
HTChannel_deleteInput(channel, status);
HTChannel_deleteOutput(channel, status);
/*
** Check whether this channel is used by other objects or we can
** delete it and free memory.
*/
if (channel->semaphore <= 0 && channels && (
channel->sockfd != INVSOC || channel->fp != NULL)) {
int hash = HASH(channel->sockfd);
HTList * list = channels[hash];
if (list) {
HTList_removeObject(list, (void *) channel);
free_channel(channel);
return YES;
}
} else
HTChannel_downSemaphore(channel);
}
return NO;
}
PRIVATE BOOL delete_object (HTList * list, HTdns * me)
{
HTTRACE(PROT_TRACE, "DNS Delete.. object %p from list %p\n" _ me _ list);
HTList_removeObject(list, (void *) me);
free_object(me);
return YES;
}
/*
** Remove a conversion routine from the presentation list.
** The conversion routine must match up with the given args.
*/
PUBLIC void HTRemoveConversion ARGS3(
WWW_CONST char *, representation_in,
WWW_CONST char *, representation_out,
HTConverter*, converter
){
int numberOfPresentations;
HTPresentation * pres;
HTAtom *rep_in, *rep_out;
int x;
numberOfPresentations = HTList_count(HTPresentations);
rep_in = HTAtom_for(representation_in);
rep_out = HTAtom_for(representation_out);
for (x = 0; x < numberOfPresentations; x++) {
pres = HTList_objectAt(HTPresentations, x);
if (pres) {
if ((!strcmp(pres->rep->name,rep_in->name)) &&
(!strcmp(pres->rep_out->name,rep_out->name)) &&
(pres->converter == converter)) {
HTList_removeObject(HTPresentations,pres);
}
}
}
}
/*
** Removes link information from one anchor to another.
** Returns YES if OK, else NO
*/
PUBLIC BOOL HTLink_remove (HTAnchor * source, HTAnchor * destination)
{
if (!source || !destination) return NO;
HTTRACE(ANCH_TRACE, "Link delete. from anchor %p to anchor %p\n" _
(void *) source _ (void *) destination);
/* Remove if dest is the main link */
if (source->mainLink.dest == destination) {
source->mainLink.dest = NULL;
source->mainLink.type = NULL;
source->mainLink.method = METHOD_INVALID;
source->mainLink.result = HT_LINK_INVALID;
return YES;
}
/* Remove link information for other links */
if (source->links) {
HTList *cur = source->links;
HTLink *pres;
while ((pres = (HTLink *) HTList_nextObject(cur))) {
if (pres->dest == destination) {
HTList_removeObject(source->links, pres);
HT_FREE(pres);
return YES;
}
}
}
return NO;
}
PUBLIC BOOL HTHashtable_walk (HTHashtable *me,
int (*walkFunc)(HTHashtable *,char *, void *))
{
if(me) {
int i, j;
for(i = 0; i< me->size; i++) {
HTList *l = (HTList *)me->table[i];
if(l) {
HTList *cur = l;
keynode *kn, *nextkn;
for(kn = (keynode *)HTList_nextObject(cur); kn; kn = nextkn) {
j = walkFunc(me, kn->key, kn->object);
if(j == 0)
return YES;
nextkn = (keynode *)HTList_nextObject(cur);
if (j < 0) {
HTList_removeObject(l, kn);
me->count--;
}
}
}
}
return YES;
}
return NO;
}
PUBLIC BOOL HTStyleSheet_deleteStyle (HTStyleSheet * me, HTStyle * style)
{
if (me && style) {
HTList_removeObject(me->styles, style);
HTStyle_delete(style);
return YES;
}
return NO;
}
/*
** 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;
}
/* 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);
}
}
PUBLIC BOOL HTAA_deleteModule (const char * scheme)
{
if (scheme) {
HTAAModule * pres = find_module(scheme);
if (pres) {
HTList_removeObject(HTSchemes, pres);
HTTRACE(AUTH_TRACE, "Auth Engine. deleted %p\n" _ pres);
delete_module(pres);
return YES;
}
}
return NO;
}
PRIVATE void delete_links (HTAnchor * me)
{
if (! me)
return;
/* Recursively try to delete target anchors */
if (me->mainLink.dest) {
HTParentAnchor *parent = me->mainLink.dest->parent;
HTList_removeObject (parent->sources, me);
if (! parent->document) /* Test here to avoid calling overhead */
HTAnchor_delete (parent);
}
if (me->links) { /* Extra destinations */
HTLink *target;
while ((target = (HTLink *) HTList_removeLastObject (me->links))) {
HTParentAnchor *parent = target->dest->parent;
HTList_removeObject (parent->sources, me);
if (! parent->document) /* Test here to avoid calling overhead */
HTAnchor_delete (parent);
}
}
}
PUBLIC BOOL HTMuxChannel_delete (HTMuxChannel * me)
{
if (me) {
HTList * list = NULL;
HTTRACE(MUX_TRACE, "Mux Channel. Deleting %p\n" _ me);
if (muxchs && (list = muxchs[me->hash])) {
HTList_removeObject(list, (void *) me);
channel_delete(me);
return YES;
}
}
return NO;
}
PUBLIC BOOL HTMuxProtocol_delete (HTMuxChannel * muxch, HTProtocolId pid)
{
if (muxch && muxch->protocols) {
HTList * cur = muxch->protocols;
HTMuxProtocol * pres;
while ((pres = (HTMuxProtocol *) HTList_nextObject(cur))) {
if (pres->pid == pid) {
HTList_removeObject(muxch->protocols, pres);
HT_FREE(pres);
return YES;
}
}
}
return NO;
}
/*
** Deletes a Transport module
*/
PUBLIC BOOL HTTransport_delete (const char * name)
{
if (transports) {
HTList *cur = transports;
HTTransport *pres;
while ((pres = (HTTransport *) HTList_nextObject(cur))) {
if (!strcmp(pres->name, name)) {
BOOL status = HTList_removeObject(transports, (void *) pres);
HT_FREE(pres->name);
HT_FREE(pres);
return status;
}
}
}
return NO;
}
PRIVATE BOOL HTCookieHolder_delete (HTCookieHolder * me)
{
if (me) {
if (me->cookies) {
HTList * cookies = me->cookies;
HTCookie * cookie;
while ((cookie = (HTCookie *) HTList_nextObject(cookies)))
HTCookie_delete(cookie);
HTList_delete(me->cookies);
}
HTList_removeObject(cookie_holder, me);
HT_FREE(me);
return YES;
}
return NO;
}
/* HTAlertCall_delete
** ------------------
** Unregister a call back function from a list
*/
PUBLIC BOOL HTAlertCall_delete (HTList * list, HTAlertCallback *cbf)
{
HTTRACE(CORE_TRACE, "Alert Call.. Delete Alert Handler %p\n" _ (void *) cbf);
if (list && cbf) {
HTList *cur = list;
HTAlert *pres;
while ((pres = (HTAlert *) HTList_nextObject(cur))) {
if (pres->cbf == cbf) {
HTList_removeObject(list, (void *) pres);
HT_FREE(pres);
return YES;
}
}
}
return NO;
}
/* HTAlertCall_deleteOpcode
** ------------------------
** Unregister all handlers registered for a given opcode.
*/
PUBLIC BOOL HTAlertCall_deleteOpcode (HTList * list, HTAlertOpcode opcode)
{
HTTRACE(CORE_TRACE, "Alert Call.. Delete all handlers with opcode %d\n" _ opcode);
if (list) {
HTList * cur = list;
HTAlert * pres;
while ((pres = (HTAlert *) HTList_nextObject(cur))) {
if (pres->opcode == opcode) {
HTList_removeObject(list, (void *) pres);
HT_FREE(pres);
cur = list;
}
}
return YES;
}
return NO;
}
PUBLIC BOOL HTAnchor_setMainLink (HTAnchor * me, HTLink * movingLink)
{
if (!(me && me->links && movingLink &&
HTList_removeObject(me->links, movingLink)))
return NO;
else {
/* First push current main link onto top of links list */
HTLink * newLink = HTLink_new();
memcpy ((void *) newLink, & me->mainLink, sizeof (HTLink));
HTList_addObject (me->links, newLink);
/* Now make movingLink the new main link, and delete it */
memcpy ((void *) &me->mainLink, movingLink, sizeof (HTLink));
HTLink_delete(movingLink);
return YES;
}
}
/*
** Deletes a Protocol module as an active access method
*/
PUBLIC BOOL HTProtocol_delete (const char * name)
{
if (protocols) {
HTList *cur = protocols;
HTProtocol *pres;
while ((pres = (HTProtocol *) HTList_nextObject(cur))) {
if (!strcmp(pres->name, name)) {
BOOL status = HTList_removeObject(protocols, (void *) pres);
HT_FREE(pres->name);
HT_FREE(pres->transport);
HT_FREE(pres);
return status;
}
}
}
return NO;
}
/*
** Searches the whole list and removes all elements with this name
*/
PUBLIC BOOL HTAssocList_removeObject (HTAssocList * list, const char * name)
{
BOOL found = NO;
if (list && name) {
HTAssocList * cur = list;
HTAssoc * assoc;
int len = strlen(name);
while ((assoc = (HTAssoc *) HTList_nextObject(cur))) {
if (!strncasecomp(assoc->name, name, len)) {
HTList_removeObject(list, assoc);
HT_FREE(assoc);
found = YES;
cur = list;
}
}
}
return found;
}
/*
** 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);
}
}
PUBLIC BOOL HTHashtable_removeObject (HTHashtable *me, const char *key)
{
if(me) {
int size = me->size;
int i = hash_number(key,size);
HTList *l = (HTList *)me->table[i];
if(l) {
HTList *cur = l;
keynode *kn;
while ((kn = (keynode *) HTList_nextObject(cur))) {
if(!strcmp(key,kn->key)) {
HTList_removeObject(l,kn);
me->count--;
return YES;
}
}
}
}
return NO;
}
PUBLIC BOOL HTChannel_setSocket (HTChannel * channel, SOCKET sockfd)
{
if (channel) {
/*
** As we use the socket number as the hash entry then we have to
** update the hash table as well.
*/
int old_hash = HASH(channel->sockfd);
int new_hash = sockfd < 0 ? 0 : HASH(sockfd);
HTList * list = channels[old_hash];
if (list) HTList_removeObject(list, channel);
if (!channels[new_hash]) channels[new_hash] = HTList_new();
list = channels[new_hash];
HTList_addObject(list, channel);
channel->sockfd = sockfd;
return YES;
}
return NO;
}
/*
* Utility for listing shortcuts, making any repeated
* shortcut the most current in the list. - FM
*/
void LYAddJumpShortcut(HTList *historyp, char *shortcut)
{
char *tmp = NULL;
char *old;
HTList *cur = historyp;
if (!historyp || isEmpty(shortcut))
return;
StrAllocCopy(tmp, shortcut);
while (NULL != (old = (char *) HTList_nextObject(cur))) {
if (!strcmp(old, tmp)) {
HTList_removeObject(historyp, old);
FREE(old);
break;
}
}
HTList_addObject(historyp, tmp);
return;
}
PUBLIC BOOL HTAnchor_deleteEncoding (HTParentAnchor * me, HTEncoding encoding)
{
return (me && me->content_encoding && encoding) ?
HTList_removeObject(me->content_encoding, encoding) : NO;
}
PUBLIC BOOL HTAnchor_deleteVariant (HTParentAnchor * me,
HTParentAnchor * variant)
{
return (me && variant) ? HTList_removeObject(me->variants, variant) : NO;
}
/* HTMemoryCall_delete
** -------------------
** Unregister a call back function from a list
*/
PUBLIC BOOL HTMemoryCall_delete (HTMemoryCallback * cbf)
{
HTTRACE(MEM_TRACE, "Mem Delete.. Callback %p\n" _ (void *) cbf);
return (HTMemCall && cbf) ? HTList_removeObject(HTMemCall,(void*)cbf) : NO;
}
