aolserver/nsd/urlspace.c

/*
 * The contents of this file are subject to the AOLserver Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://aolserver.com/.
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is AOLserver Code and related documentation
 * distributed by AOL.
 * 
 * The Initial Developer of the Original Code is America Online,
 * Inc. Portions created by AOL are Copyright (C) 1999 America Online,
 * Inc. All Rights Reserved.
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the GNU General Public License (the "GPL"), in which case the
 * provisions of GPL are applicable instead of those above.  If you wish
 * to allow use of your version of this file only under the terms of the
 * GPL and not to allow others to use your version of this file under the
 * License, indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by the GPL.
 * If you do not delete the provisions above, a recipient may use your
 * version of this file under either the License or the GPL.
 */


/* 
 * urlspace.c --
 *
 *      This file implements a Trie data structure. It is used
 *      for "UrlSpecificData"; for example, when one registers
 *      a handler for all GET /foo/bar/ *.html requests, the data
 *      structure that holds that information is implemented herein.
 *      For full details see the file doc/urlspace.txt.
 */

static const char *RCSID = "@(#) $Header: /cvsroot-fuse/aolserver/aolserver/nsd/urlspace.c,v 1.11 2003/11/03 19:23:26 pkhincha Exp $, compiled: " __DATE__ " " __TIME__;

#include "nsd.h"

/*
 * This optimization, when turned on, prevents the server from doing a
 * whole lot of calls to Tcl_StringMatch on every lookup in urlspace.
 * Instead, a strcmp is done. This hasn't been thoroughly tested, so
 * it is off by default.
 *
 *  #define __URLSPACE_OPTIMIZE__
 */

/*
 * This structure defines a Node. It is the lowest-level structure in
 * urlspace and contains the data the the user puts in. It holds data
 * whose scope is a set of URLs, such as /foo/bar/ *.html.
 * Data/cleanup functions are kept seperately for inheriting and non-
 * inheriting URLs, as there could be overlap.
 */

typedef struct {
    int    id;                          /* Handle from <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificAlloc">Ns_UrlSpecificAlloc</a> */
    void  *dataInherit;                 /* User's data */
    void  *dataNoInherit;               /* User's data */
    void   (*deletefuncInherit) (void *);    /* Cleanup function */
    void   (*deletefuncNoInherit) (void *);  /* Cleanup function */
} Node;

/*
 * This structure defines a trie. A trie is a tree whose nodes are
 * branches and channels. It is an inherently recursive data structure,
 * and each node is itself a trie. Each node represents one "part" of
 * a URL; in this case, a "part" is server name, method, directory, or
 * wildcard.
 */

typedef struct {
    Ns_Index   branches;
    Ns_Index  *indexnode;
} Trie;

/*
 * A branch is a typical node in a Trie. The "word" is the part of the
 * URL that the branch represents, and "node" is the sub-trie.
 */

typedef struct {
    char  *word;
    Trie   node;
} Branch;

/*
 * A channel is much like a branch. It exists only at the second level
 * (Channels come out of Junctions, which are top-level structures).
 * The filter is a copy of the very last part of the URLs matched by
 * branches coming out of this channel (only branches come out of channels).
 * When looking for a URL, the filename part of the target URL is compared
 * with the filter in each channel, and the channel is traversed only if
 * there is a match
 */

typedef struct {
    char  *filter;
    Trie   trie;
} Channel;

/*
 * A Junction is the top-level structure. Channels come out of a junction.
 * Currently, only one junction is defined--the static global urlspace.
 */

typedef struct {
    Ns_Index byname;
    /* 
     * We've experimented with getting rid of this index because
     * it is like byname but in semi-reverse lexicographical
     * order.  This optimization seems to work in all cases, but
     * we need a thorough way of testing all cases.
     */
#ifndef __URLSPACE_OPTIMIZE__
    Ns_Index byuse;
#endif
} Junction;

/*
 * Local functions defined in this file
 */

static void  <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDestroy">TrieDestroy</a>(Trie *trie);
static void  <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_NodeDestroy">NodeDestroy</a>(Node *nodePtr);
static int   <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpNodes">CmpNodes</a>(Node **leftPtrPtr, Node **rightPtrPtr);
static int   <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpIdWithNode">CmpIdWithNode</a>(int id, Node **nodePtrPtr);
static Ns_Index * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeCreate">IndexNodeCreate</a>(void);
static void  <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeDestroy">IndexNodeDestroy</a>(Ns_Index *indexPtr);
static int   <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpBranches">CmpBranches</a>(Branch **leftPtrPtr, Branch **rightPtrPtr);
static int   <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithBranch">CmpKeyWithBranch</a>(char *key, Branch **branchPtrPtr);
static void  <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_BranchDestroy">BranchDestroy</a>(Branch *branchPtr);

/*
 * Utility functions
 */

static void <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_MkSeq">MkSeq</a>(Ns_DString *dsPtr, char *server, char *method, char *url);
#ifdef DEBUG
static void <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_indentspace">indentspace</a>(int n);
static void <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintTrie">PrintTrie</a>(Trie *triePtr, int indent);
static void <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintJunction">PrintJunction</a>(Junction *junctionPtr);
static void <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintSeq">PrintSeq</a>(char *seq);
#endif

/*
 * Trie functions
 */

static void  <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieInit">TrieInit</a>(Trie *triePtr);
static void  <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieAdd">TrieAdd</a>(Trie *triePtr, char *seq, int id, void *data, int flags, 
                     void (*deletefunc) (void *));
static void  <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieTrunc">TrieTrunc</a>(Trie *triePtr, int id);
static void  <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDestroy">TrieDestroy</a>(Trie *triePtr);
static int   <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieBranchTrunc">TrieBranchTrunc</a>(Trie *triePtr, char *seq, int id);
static void *<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFind">TrieFind</a>(Trie *triePtr, char *seq, int id, int *depthPtr);
static void *<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a>(Trie *triePtr, char *seq, int id, int flags);
static void *<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDelete">TrieDelete</a>(Trie *triePtr, char *seq, int id, int flags);

/*
 * Channel functions
 */

#ifndef __URLSPACE_OPTIMIZE__
static int <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpChannels">CmpChannels</a>(Channel **leftPtrPtr, Channel **rightPtrPtr);
static int <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithChannel">CmpKeyWithChannel</a>(char *key, Channel **channelPtrPtr);
#endif

static int <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpChannelsAsStrings">CmpChannelsAsStrings</a>(Channel **leftPtrPtr, Channel **rightPtrPtr);
static int <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithChannelAsStrings">CmpKeyWithChannelAsStrings</a>(char *key, Channel **channelPtrPtr);

/*
 * Juntion functions
 */

static void <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionInit">JunctionInit</a>(Junction *juncPtr);
static void <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionAdd">JunctionAdd</a>(Junction *juncPtr, char *seq, int id, void *data,
                        int flags, void (*deletefunc) (void *));
static void <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionBranchTrunc">JunctionBranchTrunc</a>(Junction *juncPtr, char *seq, int id);
static void *<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFind">JunctionFind</a>(Junction *juncPtr, char *seq, int id, int fast);
static void *<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFindExact">JunctionFindExact</a>(Junction *juncPtr, char *seq, int id, int flags,
                               int fast);
static void *<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionDelete">JunctionDelete</a>(Junction *juncPtr, char *seq, int id, int flags);

/*
 * Static variables defined in this file
 */

static Junction urlspace;    /* All URL-specific data stored here */
static Ns_Mutex lock;


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_NsInitUrlSpace">NsInitUrlSpace</a> --
 *
 *      Initialize the urlspace API.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_NsInitUrlSpace">NsInitUrlSpace</a>(void)
{
    Ns_MutexSetName(&lock, "ns:urlspace");
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionInit">JunctionInit</a>(&urlspace);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificAlloc">Ns_UrlSpecificAlloc</a> --
 *
 *      Allocate a unique ID to create a seperate virtual URL-space. 
 *
 * Results:
 *      An integer handle 
 *
 * Side effects:
 *      nextid will be incremented; don't call after server startup.
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificAlloc">Ns_UrlSpecificAlloc</a>(void)
{
    int        id;
    static int nextid = 0;

    Ns_MutexLock(&lock);
    id = nextid++;
    Ns_MutexUnlock(&lock);
    return id;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificSet">Ns_UrlSpecificSet</a> --
 *
 *      Associate data with a set of URLs matching a wildcard, or 
 *      that are simply sub-URLs.
 *
 *      Flags can be NS_OP_NOINHERIT or NS_OP_NODELETE.
 *
 * Results:
 *      None 
 *
 * Side effects:
 *      Will set data in the urlspace trie. 
 *
 *----------------------------------------------------------------------
 */

void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificSet">Ns_UrlSpecificSet</a>(char *server, char *method, char *url, int id, void *data,
                  int flags, void (*deletefunc) (void *))
{
    Ns_DString ds;

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_MkSeq">MkSeq</a>(&ds, server, method, url);
    Ns_MutexLock(&lock);
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionAdd">JunctionAdd</a>(&urlspace, ds.string, id, data, flags, deletefunc);
    Ns_MutexUnlock(&lock);
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGet">Ns_UrlSpecificGet</a> --
 *
 *      Find URL-specific data in the subspace identified by id that 
 *      the passed-in URL matches 
 *
 * Results:
 *      A pointer to user data, set with <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificSet">Ns_UrlSpecificSet</a> 
 *
 * Side effects:
 *      None 
 *
 *----------------------------------------------------------------------
 */

void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGet">Ns_UrlSpecificGet</a>(char *server, char *method, char *url, int id)
{
    Ns_DString  ds;
    void       *data;

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_MkSeq">MkSeq</a>(&ds, server, method, url);
    Ns_MutexLock(&lock);
    data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFind">JunctionFind</a>(&urlspace, ds.string, id, 0);
    Ns_MutexUnlock(&lock);
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);

    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGetFast">Ns_UrlSpecificGetFast</a> --
 *
 *      Similar to <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGet">Ns_UrlSpecificGet</a>, but doesn't support wildcards; 
 *      on the other hand, it's a lot faster. 
 *
 * Results:
 *      See <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGet">Ns_UrlSpecificGet</a> 
 *
 * Side effects:
 *      None 
 *
 *----------------------------------------------------------------------
 */

void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGetFast">Ns_UrlSpecificGetFast</a>(char *server, char *method, char *url, int id)
{
    Ns_DString  ds;
    void       *data;

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_MkSeq">MkSeq</a>(&ds, server, method, url);
    Ns_MutexLock(&lock);
    data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFind">JunctionFind</a>(&urlspace, ds.string, id, 1);
    Ns_MutexUnlock(&lock);
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);
    
    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGetExact">Ns_UrlSpecificGetExact</a> --
 *      Similar to <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGet">Ns_UrlSpecificGet</a>, but does not support URL
 *      inheritance
 *
 * Results:
 *      See <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGet">Ns_UrlSpecificGet</a> 
 *
 * Side effects:
 *      None 
 *
 *----------------------------------------------------------------------
 */

void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGetExact">Ns_UrlSpecificGetExact</a>(char *server, char *method, char *url, int id,
                       int flags)
{
    Ns_DString  ds;
    void       *data;

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_MkSeq">MkSeq</a>(&ds, server, method, url);
    Ns_MutexLock(&lock);
    data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFindExact">JunctionFindExact</a>(&urlspace, ds.string, id, flags, 0);
    Ns_MutexUnlock(&lock);
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);
    
    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificDestroy">Ns_UrlSpecificDestroy</a> --
 *
 *      Delete some urlspecific data.
 *
 *      flags can be NS_OP_NODELETE, NS_OP_NOINHERIT and/or NS_OP_RECURSE
 *
 * Results:
 *      None 
 *
 * Side effects:
 *      Will remove data from urlspace; don't call this after server 
 *      startup. 
 *
 *----------------------------------------------------------------------
 */

void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificDestroy">Ns_UrlSpecificDestroy</a>(char *server, char *method, char *url, int id, int flags)
{
    Ns_DString  ds;
    void       *data = NULL;

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_MkSeq">MkSeq</a>(&ds, server, method, url);
    Ns_MutexLock(&lock);
    if (flags & NS_OP_RECURSE) {
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionBranchTrunc">JunctionBranchTrunc</a>(&urlspace, ds.string, id);
        data = NULL;
    } else {
        data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionDelete">JunctionDelete</a>(&urlspace, ds.string, id, flags);
    }
    Ns_MutexUnlock(&lock);
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);
    
    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_ServerSpecificAlloc">Ns_ServerSpecificAlloc</a> --
 *
 *      Allocate a unique integer to be used with Ns_ServerSpecific* 
 *      calls 
 *
 * Results:
 *      An integer handle 
 *
 * Side effects:
 *      None 
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_ServerSpecificAlloc">Ns_ServerSpecificAlloc</a>(void)
{
    return <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificAlloc">Ns_UrlSpecificAlloc</a>();
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_ServerSpecificSet">Ns_ServerSpecificSet</a> --
 *
 *      Set server-specific data 
 *
 * Results:
 *      None 
 *
 * Side effects:
 *      See <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificSet">Ns_UrlSpecificSet</a> 
 *
 *----------------------------------------------------------------------
 */

void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_ServerSpecificSet">Ns_ServerSpecificSet</a>(char *handle, int id, void *data, int flags,
                     void (*deletefunc) (void *))
{
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificSet">Ns_UrlSpecificSet</a>(handle, NULL, NULL, id, data, flags, deletefunc);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_ServerSpecificGet">Ns_ServerSpecificGet</a> --
 *
 *      Get server-specific data.
 *
 * Results:
 *      User server-specific data.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_ServerSpecificGet">Ns_ServerSpecificGet</a>(char *handle, int id)
{
    return <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificGet">Ns_UrlSpecificGet</a>(handle, NULL, NULL, id);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_ServerSpecificDestroy">Ns_ServerSpecificDestroy</a> --
 *
 *      Destroy server-specific data. 
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Will remove data from urlspace.
 *
 *----------------------------------------------------------------------
 */

void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_ServerSpecificDestroy">Ns_ServerSpecificDestroy</a>(char *handle, int id, int flags)
{
    return <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificDestroy">Ns_UrlSpecificDestroy</a>(handle, NULL, NULL, id, flags);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_NodeDestroy">NodeDestroy</a> --
 *
 *      Free a node and its data 
 *
 * Results:
 *      None 
 *
 * Side effects:
 *      The delete function is called and the node is freed 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_NodeDestroy">NodeDestroy</a>(Node *nodePtr)
{
    if (nodePtr == NULL) {
        goto done;
    }
    if (nodePtr->deletefuncNoInherit != NULL) {
        (*nodePtr->deletefuncNoInherit) (nodePtr->dataNoInherit);
    }
    if (nodePtr->deletefuncInherit != NULL) {
        (*nodePtr->deletefuncInherit) (nodePtr->dataInherit);
    }
    ns_free(nodePtr);

 done:
    return;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpNodes">CmpNodes</a> --
 *
 *      Compare two Nodes by id. Ns_Index calls use this as a callback.
 *
 * Results:
 *      0 if equal, 1 if left is greater, -1 if left is less.
 *
 * Side effects:
 *      None 
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpNodes">CmpNodes</a>(Node **leftPtrPtr, Node **rightPtrPtr)
{
    if ((*leftPtrPtr)->id != (*rightPtrPtr)->id) {
        return ((*leftPtrPtr)->id > (*rightPtrPtr)->id) ? 1 : -1;
    } else {
        return 0;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpIdWithNode">CmpIdWithNode</a> --
 *
 *      Compare a node's ID to a passed-in ID; called by Ns_Index*
 *
 * Results:
 *      0 if equal; 1 if id is too high; -1 if id is too low 
 *
 * Side effects:
 *      None 
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpIdWithNode">CmpIdWithNode</a>(int id, Node **nodePtrPtr)
{
    if (id != (*nodePtrPtr)->id) {
        return (id > (*nodePtrPtr)->id) ? 1 : -1;
    } else {
        return 0;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeCreate">IndexNodeCreate</a> --
 *
 *      Initialize a trie->indexnode structure 
 *
 * Results:
 *      A pointer to an appropriately initialized index 
 *
 * Side effects:
 *      Memory alloacted. 
 *
 *----------------------------------------------------------------------
 */

static Ns_Index *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeCreate">IndexNodeCreate</a>(void)
{
    Ns_Index *indexPtr;

    indexPtr = ns_malloc(sizeof(Ns_Index));
    <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexInit">Ns_IndexInit</a>(indexPtr, 5, (int (*) (const void *, const void *)) <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpNodes">CmpNodes</a>,
        (int (*) (const void *, const void *)) <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpIdWithNode">CmpIdWithNode</a>);
    
    return indexPtr;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeDestroy">IndexNodeDestroy</a> --
 *
 *      Wipe out a trie->indexnode structure.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Memory freed.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeDestroy">IndexNodeDestroy</a>(Ns_Index *indexPtr)
{
    int i;

    i = Ns_IndexCount(indexPtr);
    while (i--) {
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_NodeDestroy">NodeDestroy</a>(<a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(indexPtr, i));
    }
    <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexDestroy">Ns_IndexDestroy</a>(indexPtr);
    ns_free(indexPtr);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpBranches">CmpBranches</a> --
 *
 *      Compare two branches' word members. Called by Ns_Index* 
 *
 * Results:
 *      0 if equal, -1 if left is greater; 1 if right is greater 
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpBranches">CmpBranches</a>(Branch **leftPtrPtr, Branch **rightPtrPtr)
{
    return strcmp((*leftPtrPtr)->word, (*rightPtrPtr)->word);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpBranches">CmpBranches</a> --
 *
 *      Compare a branch's word to a passed-in key; called by 
 *      Ns_Index*.
 *
 * Results:
 *      0 if equal, -1 if left is greater; 1 if right is greater.
 *
 * Side effects:
 *      None. 
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithBranch">CmpKeyWithBranch</a>(char *key, Branch ** branchPtrPtr)
{
    return strcmp(key, (*branchPtrPtr)->word);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_BranchDestroy">BranchDestroy</a> --
 *
 *      Free a branch structure 
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      Will free memory. 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_BranchDestroy">BranchDestroy</a>(Branch *branchPtr)
{
    ns_free(branchPtr->word);
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDestroy">TrieDestroy</a>(&branchPtr->node);
    ns_free(branchPtr);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieInit">TrieInit</a> --
 *
 *      Initialize a Trie data structure with 25 branches and set the 
 *      Cmp functions for Ns_Index*. 
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      The trie is initialized and memory is allocated; memory is 
 *      allocated. 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieInit">TrieInit</a>(Trie *triePtr)
{
    <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexInit">Ns_IndexInit</a>(&triePtr->branches, 25,
                 (int (*) (const void *, const void *)) <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpBranches">CmpBranches</a>,
                 (int (*) (const void *, const void *)) <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithBranch">CmpKeyWithBranch</a>);
    triePtr->indexnode = NULL;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieAdd">TrieAdd</a> --
 *
 *      Add something to the Trie data structure, usually to the 
 *      variable urlspace. 
 *
 *      seq is a null-delimited string of words, terminated with
 *      two nulls.
 *      id is allocated with <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificAlloc">Ns_UrlSpecificAlloc</a>.
 *      flags is a bitmask; optionally OR NS_OP_NODELETE,
 *      NS_OP_NOINHERIT for desired behavior.
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      Memory is allocated. If a node is found and the 
 *      NS_OP_NODELETE is not set, the current node's data is deleted. 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieAdd">TrieAdd</a>(Trie *triePtr, char *seq, int id, void *data, int flags,
        void (*deletefunc) (void *))
{
    if (*seq == '\0') {
        Node *nodePtr;

        /*
         * The entire sequence has been traversed, creating a branch
         * for each word. Now it is time to make a Node.
         *
         * First, allocate a new node or find a matching one in existance.
         */
        
        if (triePtr->indexnode == NULL) {
            triePtr->indexnode = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeCreate">IndexNodeCreate</a>();
            nodePtr = NULL;
        } else {
            nodePtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(triePtr->indexnode, (void *) id);
        }

        if (nodePtr == NULL) {

            /*
             * Create and initialize a new node.
             */
            
            nodePtr = ns_malloc(sizeof(Node));
            nodePtr->id = id;
            <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexAdd">Ns_IndexAdd</a>(triePtr->indexnode, nodePtr);
            nodePtr->dataInherit = NULL;
            nodePtr->dataNoInherit = NULL;
            nodePtr->deletefuncInherit = NULL;
            nodePtr->deletefuncNoInherit = NULL;
        } else {

            /*
             * If NS_OP_NODELETE is NOT set, then delete the current node
             * because one already exists.
             */
            
            if ((flags & NS_OP_NODELETE) == 0) {
                if ((flags & NS_OP_NOINHERIT) != 0) {
                    if (nodePtr->deletefuncNoInherit != NULL) {
                        (*nodePtr->deletefuncNoInherit)
                            (nodePtr->dataNoInherit);
                    }
                } else {
                    if (nodePtr->deletefuncInherit != NULL) {
                        (*nodePtr->deletefuncInherit) (nodePtr->dataInherit);
                    }
                }
            }
        }

        if (flags & NS_OP_NOINHERIT) {
            nodePtr->dataNoInherit = data;
            nodePtr->deletefuncNoInherit = deletefunc;
        } else {
            nodePtr->dataInherit = data;
            nodePtr->deletefuncInherit = deletefunc;
        }
    } else {
        Branch *branchPtr;

        /*
         * We are parsing the middle of a sequence, such as "foo" in:
         * "server1\0GET\0foo\0*.html\0"
         *
         * Create a new branch and recurse to add the next word in the
         * sequence.
         */

        branchPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(&triePtr->branches, seq);
        if (branchPtr == NULL) {
            branchPtr = ns_malloc(sizeof(Branch));
            branchPtr->word = ns_strdup(seq);
            <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieInit">TrieInit</a>(&branchPtr->node);

            <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexAdd">Ns_IndexAdd</a>(&triePtr->branches, branchPtr);
        }
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieAdd">TrieAdd</a>(&branchPtr->node, seq + strlen(seq) + 1, id, data, flags,
                deletefunc);
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieTrunc">TrieTrunc</a> --
 *
 *      Wipes out all references to id. If id==-1 then it wipes out 
 *      everything. 
 *
 * Results:
 *      None 
 *
 * Side effects:
 *      Nodes and branches may be destroyed/freed. 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieTrunc">TrieTrunc</a>(Trie *triePtr, int id)
{
    int n;

    n = Ns_IndexCount(&triePtr->branches);

    if (n > 0) {
        /*
         * Loop over each branch and recurse.
         */
        
        int             i;

        for (i = 0; i < n; i++) {
            Branch *branchPtr;

            branchPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&triePtr->branches, i);
            <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieTrunc">TrieTrunc</a>(&branchPtr->node, id);
        }
    }
    if (triePtr->indexnode != NULL) {
        if (id != -1) {
            Node *nodePtr;

            /*
             * Destroy just the node for this ID
             */
            
            nodePtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(triePtr->indexnode, (void *) id);
            if (nodePtr != NULL) {
                <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_NodeDestroy">NodeDestroy</a>(nodePtr);
                <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexDel">Ns_IndexDel</a>(triePtr->indexnode, nodePtr);
            }
        } else {

            /*
             * Destroy the whole index of nodes.
             */
            
            <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeDestroy">IndexNodeDestroy</a>(triePtr->indexnode);
            triePtr->indexnode = NULL;
        }
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDestroy">TrieDestroy</a> --
 *
 *      Delete an entire Trie.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Will free all the elements of the trie.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDestroy">TrieDestroy</a>(Trie *triePtr)
{
    int n;

    n = Ns_IndexCount(&triePtr->branches);

    if (n > 0) {
        int i;

        /*
         * Loop over each branch and delete it
         */
        
        for (i = 0; i < n; i++) {
            Branch *branchPtr;

            branchPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&triePtr->branches, i);
            <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_BranchDestroy">BranchDestroy</a>(branchPtr);
        }
        <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexDestroy">Ns_IndexDestroy</a>(&triePtr->branches);
    }
    if (triePtr->indexnode != NULL) {
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_IndexNodeDestroy">IndexNodeDestroy</a>(triePtr->indexnode);
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieBranchTrunc">TrieBranchTrunc</a> --
 *
 *      Cut off a branch from a trie 
 *
 * Results:
 *      0 on success, -1 on failure 
 *
 * Side effects:
 *      Will delete a branch. 
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieBranchTrunc">TrieBranchTrunc</a>(Trie *triePtr, char *seq, int id)
{
    if (*seq != '\0') {
        Branch *branchPtr;

        branchPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(&triePtr->branches, seq);

        /*
         * If this sequence exists, recursively delete it; otherwise
         * return an error.
         */
        
        if (branchPtr != NULL) {
            return <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieBranchTrunc">TrieBranchTrunc</a>(&branchPtr->node, seq + strlen(seq) + 1,
                                   id);
        } else {
            return -1;
        }
    } else {
        /*
         * The end of the sequence has been reached. Finish up the job
         * and return success.
         */
        
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieTrunc">TrieTrunc</a>(triePtr, id);
        return 0;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFind">TrieFind</a> --
 *
 *      Find a node in a trie matching a sequence.
 *
 * Results:
 *      Return the appropriate node's data.
 *
 * Side effects:
 *      The depth variable will be set-by-reference to the depth of
 *      the returned node. If no node is set, it will not be changed.
 *
 *----------------------------------------------------------------------
 */

static void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFind">TrieFind</a>(Trie *triePtr, char *seq, int id, int *depthPtr)
{
    void *data;
    int   ldepth;

    data = NULL;
    ldepth = *depthPtr;
    if (triePtr->indexnode != NULL) {
        Node *nodePtr;

        /*
         * We've reached a trie with an indexnode, which means that our
         * data may be here. (If node is null that means that there
         * is data at this branch, but not with this particular ID).
         */

        nodePtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(triePtr->indexnode, (void *) id);
        
        if (nodePtr != NULL) {
            if ((*seq == '\0') && (nodePtr->dataNoInherit != NULL)) {
                data = nodePtr->dataNoInherit;
            } else {
                data = nodePtr->dataInherit;
            }
        }
    }
    if (*seq != '\0') {
        Branch *branchPtr;

        /*
         * We have not yet reached the end of the sequence, so
         * recurse if there are any sub-branches
         */

        branchPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(&triePtr->branches, seq);
        ldepth += 1;
        if (branchPtr != NULL) {
            void *p = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFind">TrieFind</a>(&branchPtr->node, seq + strlen(seq) + 1, id,
                               &ldepth);

            if (p != NULL) {
                data = p;
                *depthPtr = ldepth;
            }
        }
    }
    
    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a> --
 *
 *      Similar to <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFind">TrieFind</a>, but will not do inheritance.
 *      if (flags & NS_OP_NOINHERIT) then data set with
 *      that flag will be returned; otherwise only data set without that
 *      flag will be returned.
 *
 * Results:
 *      See <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFind">TrieFind</a>.
 *
 * Side effects:
 *      None. 
 *
 *----------------------------------------------------------------------
 */

static void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a>(Trie *triePtr, char *seq, int id, int flags)
{
    void *data;

    data = NULL;
    if (*seq != '\0') {
        Branch *branchPtr;

        /*
         * We have not reached the end of the sequence yet, so
         * we must recurse.
         */

        branchPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(&triePtr->branches, seq);
        if (branchPtr != NULL) {
            data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a>(&branchPtr->node, seq + strlen(seq) + 1, id,
                                 flags);
        }
    } else if (triePtr->indexnode != NULL) {
        Node *nodePtr;

        /*
         * We reached the end of the sequence. Grab the data from
         * this node. If the flag specifies NOINHERIT, then return
         * the non-inheriting data, otherwise return the inheriting
         * data.
         */

        nodePtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(triePtr->indexnode, (void *) id);
        if (nodePtr != NULL) {
            if (flags & NS_OP_NOINHERIT) {
                data = nodePtr->dataNoInherit;
            } else {
                data = nodePtr->dataInherit;
            }
        }
    }
    
    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDelete">TrieDelete</a> --
 *
 *      Delete a url, defined by a sequence, from a trie.
 *
 *      The NS_OP_NOINHERIT bit may be set in flags to use
 *      noninheriting data; NS_OP_NODELETE may be set to
 *      skip calling the delete function.
 *
 * Results:
 *      A pointer to the now-deleted data. 
 *
 * Side effects:
 *      Data may be deleted. 
 *
 *----------------------------------------------------------------------
 */

static void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDelete">TrieDelete</a>(Trie *triePtr, char *seq, int id, int flags)
{
    void *data;

    data = NULL;
    if (*seq != '\0') {
        Branch *branchPtr;

        /*
         * We have not yet reached the end of the sequence. So
         * recurse.
         */

        branchPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(&triePtr->branches, seq);
        if (branchPtr != NULL) {
            data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDelete">TrieDelete</a>(&branchPtr->node, seq + strlen(seq) + 1, id,
                              flags);
        }
    } else if (triePtr->indexnode != NULL) {
        Node *nodePtr;

        /*
         * We've reached the end of the sequence; if a node exists for
         * this ID then delete the inheriting/noninheriting data (as
         * specified in flags) and call the delte func if requested.
         * The data will be set to null either way.
         */

        nodePtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(triePtr->indexnode, (void *) id);
        if (nodePtr != NULL) {
            if (flags & NS_OP_NOINHERIT) {
                data = nodePtr->dataNoInherit;
                nodePtr->dataNoInherit = NULL;
                if (nodePtr->deletefuncNoInherit != NULL) {
                    if (!(flags & NS_OP_NODELETE)) {
                        (*nodePtr->deletefuncNoInherit) (data);
                    }
                    nodePtr->deletefuncNoInherit = NULL;
                }
            } else {
                data = nodePtr->dataInherit;
                nodePtr->dataInherit = NULL;
                if (nodePtr->deletefuncInherit != NULL) {
                    if (!(flags & NS_OP_NODELETE)) {
                        (*nodePtr->deletefuncInherit) (data);
                    }
                    nodePtr->deletefuncInherit = NULL;
                }
            }
        }
    }
    
    return data;
}

#ifndef __URLSPACE_OPTIMIZE__

/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpChannels">CmpChannels</a> --
 *
 *      Compare the filters of two channels. 
 *
 * Results:
 *      0: Not the case that one contains the other OR they both 
 *      contain each other; 1: left contains right; -1: right contans 
 *      left. 
 *
 * Side effects:
 *      None. 
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpChannels">CmpChannels</a>(Channel **leftPtrPtr, Channel **rightPtrPtr)
{
    int lcontainsr, rcontainsl;

    lcontainsr = Tcl_StringMatch((*rightPtrPtr)->filter,
                                 (*leftPtrPtr)->filter);
    rcontainsl = Tcl_StringMatch((*leftPtrPtr)->filter,
                                 (*rightPtrPtr)->filter);

    if (lcontainsr && rcontainsl) {
        return 0;
    } else if (lcontainsr) {
        return 1;
    } else if (rcontainsl) {
        return -1;
    } else {
        return 0;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithChannel">CmpKeyWithChannel</a> --
 *
 *      Compare a key to a channel's filter 
 *
 * Results:
 *      0: Not the case that one contains the other OR they both 
 *      contain each other; 1: key contains filter; -1: filter 
 *      contains key 
 *
 * Side effects:
 *      None 
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithChannel">CmpKeyWithChannel</a>(char *key, Channel **channelPtrPtr)
{
    int lcontainsr, rcontainsl;

    lcontainsr = Tcl_StringMatch((*channelPtrPtr)->filter, key);
    rcontainsl = Tcl_StringMatch(key, (*channelPtrPtr)->filter);
    if (lcontainsr && rcontainsl) {
        return 0;
    } else if (lcontainsr) {
        return 1;
    } else if (rcontainsl) {
        return -1;
    } else {
        /*
         * Neither is the case
         */

        return 0;
    }
}
#endif


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpChannelsAsStrings">CmpChannelsAsStrings</a> --
 *
 *      Compare the filters of two channels.
 *
 * Results:
 *      Same as strcmp.
 *
 * Side effects:
 *      None. 
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpChannelsAsStrings">CmpChannelsAsStrings</a>(Channel **leftPtrPtr, Channel **rightPtrPtr)
{
    return strcmp((*leftPtrPtr)->filter, (*rightPtrPtr)->filter);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithChannelAsStrings">CmpKeyWithChannelAsStrings</a> --
 *
 *      Compare a string key to a channel's filter 
 *
 * Results:
 *      Same as strcmp. 
 *
 * Side effects:
 *      None. 
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithChannelAsStrings">CmpKeyWithChannelAsStrings</a>(char *key, Channel **channelPtrPtr)
{
    return strcmp(key, (*channelPtrPtr)->filter);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionInit">JunctionInit</a> --
 *
 *      Initialize a junction.
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      Will set up the index in a junction. 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionInit">JunctionInit</a>(Junction *juncPtr)
{
#ifndef __URLSPACE_OPTIMIZE__
    <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexInit">Ns_IndexInit</a>(&juncPtr->byuse, 5,
        (int (*) (const void *, const void *)) <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpChannels">CmpChannels</a>,
        (int (*) (const void *, const void *)) <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithChannel">CmpKeyWithChannel</a>);
#endif
    <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexInit">Ns_IndexInit</a>(&juncPtr->byname, 5,
        (int (*) (const void *, const void *)) <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpChannelsAsStrings">CmpChannelsAsStrings</a>,
        (int (*) (const void *, const void *)) <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_CmpKeyWithChannelAsStrings">CmpKeyWithChannelAsStrings</a>);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionBranchTrunc">JunctionBranchTrunc</a> --
 *
 *      Truncate a branch, defined by a sequence and ID, in a 
 *      junction 
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      See <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieBranchTrunc">TrieBranchTrunc</a> 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionBranchTrunc">JunctionBranchTrunc</a>(Junction *juncPtr, char *seq, int id)
{
    int i;
    int n;

    /*
     * Loop over every channel in a junction and <a href="/cvs/aolserver/aolserver/nsd/nswin32.c#A_truncate">truncate</a> the sequence in
     * each.
     */
    
#ifndef __URLSPACE_OPTIMIZE__
    n = Ns_IndexCount(&juncPtr->byuse);
    for (i = 0; i < n; i++) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byuse, i);
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieBranchTrunc">TrieBranchTrunc</a>(&channelPtr->trie, seq, id);
    }
#else
    n = Ns_IndexCount(&juncPtr->byname);
    for (i = (n - 1); i >= 0; i--) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byname, i);
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieBranchTrunc">TrieBranchTrunc</a>(&channelPtr->trie, seq, id);
    }
#endif
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionAdd">JunctionAdd</a> --
 *
 *      This function is called from <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_Ns_UrlSpecificSet">Ns_UrlSpecificSet</a> which is 
 *      usually called from <a href="/cvs/aolserver/aolserver/nsd/op.c#A_Ns_RegisterRequest">Ns_RegisterRequest</a>, 
 *      <a href="/cvs/aolserver/aolserver/nsd/op.c#A_Ns_RegisterProxyRequest">Ns_RegisterProxyRequest</a>, InitAliases for mapping aliases, and 
 *      the nsperm functions TribeAlloc and Ns_AddPermission for 
 *      adding permissions. It adds a sequence, terminating in a new 
 *      node, to a junction.
 *
 *      Flags may be a bit-combination of NS_OP_NOINHERIT, NS_OP_NODELETE.
 *      NOINHERIT sets the data as noninheriting, so only an exact sequence
 *      will match in the future; NODELETE means that if a node already
 *      exists with this sequence/ID it will not be deleted but replaced.
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      Modifies seq, assuming
 *      seq = "handle\0method\0urltoken\0urltoken\0..\0\0\"
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionAdd">JunctionAdd</a>(Junction *juncPtr, char *seq, int id, void *data, int flags,
    void (*deletefunc) (void *))
{
    Channel    *channelPtr;
    Ns_DString  dsWord;
    char       *p;
    int         l;
    int         depth;

    depth = 0;

    /*
     * Find out how deep the sequence is, and position p at the
     * beginning of the last word in the sequence.
     */
    
    for (p = seq; p[l = strlen(p) + 1] != '\0'; p += l) {
        depth++;
    }

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&dsWord);

    /*
     * If it's a valid sequence that has a wildcard in its last element,
     * append the whole string to dsWord, then cut off the last word from
     * p.
     * Otherwise, set dsWord to "*" because there is an implicit * wildcard
     * at the end of URLs like /foo/bar
     *
     * dsWord will eventually be used to set or find&reuse a channel filter.
     */
    
    if ((p != NULL) && (depth > 1) && (strchr(p, '*') || strchr(p, '?'))) {
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&dsWord, p);
        *p = '\0';
    } else {
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&dsWord, "*");
    }

    /*
     * Find a channel whose filter matches what the filter on this URL
     * should be.
     */
    
    channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexFind">Ns_IndexFind</a>(&juncPtr->byname, dsWord.string);

    /* 
     * If no channel is found, create a new channel and add it to the
     * list of channels in the junction.
     */

    if (channelPtr == NULL) {
        channelPtr = (Channel *) ns_malloc(sizeof(Channel));
        channelPtr->filter = ns_strdup(dsWord.string);
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieInit">TrieInit</a>(&channelPtr->trie);

#ifndef __URLSPACE_OPTIMIZE__
        <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexAdd">Ns_IndexAdd</a>(&juncPtr->byuse, channelPtr);
#endif
        <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexAdd">Ns_IndexAdd</a>(&juncPtr->byname, channelPtr);
    }
    
    /* 
     * Now we need to create a sequence of branches in the trie (if no
     * appropriate sequence already exists) and a node at the end of it.
     * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieAdd">TrieAdd</a> will do that.
     */
    
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieAdd">TrieAdd</a>(&channelPtr->trie, seq, id, data, flags, deletefunc);

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&dsWord);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFind">JunctionFind</a> --
 *
 *      Locate a node for a given sequence in a junction.
 *      As usual sequence is "handle\0method\0urltoken\0...\0\0".
 *
 *      The "fast" boolean switch makes it do strcmp instead of
 *      Tcl string matches on the filters. Not useful for wildcard
 *      matching.
 *
 * Results:
 *      User data
 *
 * Side effects:
 *      None. 
 *
 *----------------------------------------------------------------------
 */

static void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFind">JunctionFind</a>(Junction *juncPtr, char *seq, int id, int fast)
{
    char *p;
    int   l;
    int   i, n;
    void *data;
    int   depth;

    n = 0;

    /*
     * After this loop, p will point at the last element in the sequence.
     * n will be the number of elements in the sequence.
     */
    
    for (p = seq; p[l = strlen(p) + 1] != '\0'; p += l) {
        n++;
    }

    if (n < 2) {
        /*
         * If there are fewer than 2 elements then advance p to the
         * end of the string.
         */
        p += strlen(p) + 1;
    }

    /*
     * Check filters from most restrictive to least restrictive
     */
    
    data = NULL;
#ifndef __URLSPACE_OPTIMIZE__
    l = Ns_IndexCount(&juncPtr->byuse);
#else
    l = Ns_IndexCount(&juncPtr->byname);
#endif

#ifdef DEBUG
    if (n >= 2) {
        fprintf(stderr, "Checking Id=%d, Seq=", id);
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintSeq">PrintSeq</a>(seq);
        fputs("\n", stderr);
    }
#endif

    /* 
     * For __URLSPACE_OPTIMIZE__
     * Basically if we use the optimize, let's reverse the order
     * by which we search because the byname is in "almost" exact
     * reverse lexicographical order.
     *
     * Loop over all the channels in the index.
     */
    
#ifndef __URLSPACE_OPTIMIZE__
    for (i = 0; i < l; i++) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byuse, i);
#else
    for (i = (l - 1); i >= 0; i--) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byname, i);
#endif
        int doit;

        if (fast) {
            doit = !strcmp(p, channelPtr->filter);
        } else {
            doit = Tcl_StringMatch(p, channelPtr->filter);
        }
        if (doit) {
            /*
             * We got here because this url matches the filter
             * (for example, it's *.adp).
             */
            
            if (data == NULL) {
                /*
                 * Nothing has been found so far. Traverse the channel
                 * and find the node; set data to that. Depth will be
                 * set to the level of the node.
                 */
                
                depth = 0;
                data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFind">TrieFind</a>(&channelPtr->trie, seq, id, &depth);
            } else {
                void *candidate;
                int   cdepth;

                /*
                 * Let's see if this channel has a node that also matches
                 * the sequence but is more specific (has a greater depth)
                 * that the previously found node.
                 */
                
                cdepth = 0;
                candidate = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFind">TrieFind</a>(&channelPtr->trie, seq, id, &cdepth);
                if ((candidate != NULL) && (cdepth > depth)) {
                    data = candidate;
                    depth = cdepth;
                }
            }
        }

#ifdef DEBUG
        if (n >= 2) {
            if (data == NULL) {
                fprintf(stderr, "Channel %s: No match\n",
                    channelPtr->filter);
            } else {
                fprintf(stderr, "Channel %s: depth=%d, data=%p\n",
                    channelPtr->filter, depth, data);
            }
        }
#endif
    }

#ifdef DEBUG
    if (n >= 2) {
        fprintf(stderr, "Done.\n");
    }
#endif
    
    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFindExact">JunctionFindExact</a> --
 *
 *      Find a node in a junction that exactly matches a sequence.
 *
 * Results:
 *      User data.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionFindExact">JunctionFindExact</a>(Junction *juncPtr, char *seq, int id, int flags, int fast)
{
    char *p;
    int   l;
    int   i;
    int   depth;
    void *data;

    depth = 0;

    /*
     * Set p to the last element of the sequence, and
     * depth to the number of elements in the sequence.
     */
    
    for (p = seq; p[l = strlen(p) + 1] != '\0'; p += l) {
        depth++;
    }

    data = NULL;

    /*
     * First, loop through all the channels that have non-"*"
     * filters looking for an exact match
     */

#ifndef __URLSPACE_OPTIMIZE__
    l = Ns_IndexCount(&juncPtr->byuse);

    for (i = 0; i < l; i++) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byuse, i);
#else
    l = Ns_IndexCount(&juncPtr->byname);

    for (i = (l - 1); i >= 0; i--) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byname, i);
#endif
        if (strcmp(p, channelPtr->filter) == 0) {
            /*
             * The last element of the sequence exactly matches the
             * filter, so this is the one. Wipe out the last word and
             * return whatever node coems out of <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a>.
             */
            
            *p = '\0';
            data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a>(&channelPtr->trie, seq, id, flags);
            goto done;
        }
    }
    
    /*
     * Now go to the channel with the "*" filter and look there for 
     * an exact match:
     */
    
#ifndef __URLSPACE_OPTIMIZE__
    for (i = 0; i < l; i++) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byuse, i);
#else
    for (i = (l - 1); i >= 0; i--) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byname, i);
#endif
        if (strcmp("*", channelPtr->filter) == 0) {
            data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a>(&channelPtr->trie, seq, id, flags);
            break;
        }
    }
    
  done:
    
    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionDelete">JunctionDelete</a> --
 *
 *      Delete a node from a junction matching a sequence 
 *
 * Results:
 *      A pointer to the deleted node 
 *
 * Side effects:
 *      The node will be deleted if NS_OP_NODELETE isn't set in flags 
 *
 *----------------------------------------------------------------------
 */

static void *
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_JunctionDelete">JunctionDelete</a>(Junction *juncPtr, char *seq, int id, int flags)
{
    char *p;
    int   l;
    int   i;
    int   depth;
    void *data;

    /*
     * Set p to the last element of the sequence, and
     * depth to the number of elements in the sequence.
     */

    depth = 0;
    for (p = seq; p[l = strlen(p) + 1] != '\0'; p += l) {
        depth++;
    }

    data = NULL;

#ifndef __URLSPACE_OPTIMIZE__
    l = Ns_IndexCount(&juncPtr->byuse);
    for (i = 0; (i < l) && (data == NULL); i++) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byuse, i);
#else
    l = Ns_IndexCount(&juncPtr->byname);
    for (i = (l - 1); (i >= 0) && (data == NULL); i--) {
        Channel *channelPtr = <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&juncPtr->byname, i);
#endif
        if ((depth == 2) && (strcmp(p, channelPtr->filter) == 0)) {
            /*
             * This filter exactly matches the last element of the
             * sequence, so get the node and delete it. (This is
             * server-specific data because depth is 2).
             */
            
            *p = '\0';
            data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a>(&channelPtr->trie, seq, id, flags);
            if (data != NULL) {
                <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDelete">TrieDelete</a>(&channelPtr->trie, seq, id, flags);
            }
        } else if (Tcl_StringMatch(p, channelPtr->filter)) {
            /*
             * The filter matches, so get the node and delete it.
             */
            
            data = <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieFindExact">TrieFindExact</a>(&channelPtr->trie, seq, id, flags);
            if (data != NULL) {
                <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_TrieDelete">TrieDelete</a>(&channelPtr->trie, seq, id, flags);
            }
        }
    }
    
    return data;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_MkSeq">MkSeq</a> --
 *
 *      Build a "sequence" out of a server/method/url; turns it into 
 *      "server\0method\0urltoken\0...\0\0" 
 *
 * Results:
 *      None 
 *
 * Side effects:
 *      Sequence goes into ds 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_MkSeq">MkSeq</a>(Ns_DString *dsPtr, char *server, char *method, char *url)
{
    if ((method != NULL) && (url != NULL)) {
        char *p;
        int   done;

        /*
         * It is URLspecific data, not serverspecific data
         * if we get here.
         */
        
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringNAppend">Ns_DStringNAppend</a>(dsPtr, server, (int)(strlen(server) + 1));
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringNAppend">Ns_DStringNAppend</a>(dsPtr, method, (int)(strlen(method) + 1));

        /*
         * Loop over each directory in the URL and turn the slashes
         * into nulls.
         */
        
        done = 0;
        while (!done && *url != '\0') {
            if (*url != '/') {
                int l;

                p = strchr(url, '/');
                if (p != NULL) {
                    l = p - url;
                } else {
                    l = strlen(url);
                    done = 1;
                }

                <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringNAppend">Ns_DStringNAppend</a>(dsPtr, url, l++);
                <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringNAppend">Ns_DStringNAppend</a>(dsPtr, "\0", 1);
                url += l;
            } else {
                url++;
            }
        }

        /*
         * Put another null on the end to mark the end of the
         * string.
         */
        
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringNAppend">Ns_DStringNAppend</a>(dsPtr, "\0", 1);
    } else {
        /*
         * This is Server-specific data, so there's only going to
         * be one element.
         */
        
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringNAppend">Ns_DStringNAppend</a>(dsPtr, server, (int)(strlen(server) + 1));
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringNAppend">Ns_DStringNAppend</a>(dsPtr, "\0", 1);
    }
}

#ifdef DEBUG

/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_indentspace">indentspace</a> --
 *
 *      Print n spaces.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Will print to stderr.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_indentspace">indentspace</a>(int n)
{
    int i;

    fputc('\n', stderr);
    for (i = 0; i < n; i++) {
        fputc(' ', stderr);
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintTrie">PrintTrie</a> --
 *
 *      Output the trie to standard error.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Will write to stderr. 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintTrie">PrintTrie</a>(Trie *triePtr, int indent)
{
    int i;

    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_indentspace">indentspace</a>(indent);
    fprintf(stderr, "Branches:");
    for (i = 0; i < (&(triePtr->branches))->n; i++) {
        Branch *branch;

        branch = (Branch *) <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&(triePtr->branches), i);
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_indentspace">indentspace</a>(indent + 2);
        fprintf(stderr, "(%s):", branch->word);
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintTrie">PrintTrie</a>(&(branch->node), indent + 4);
    }
    <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_indentspace">indentspace</a>(indent);
    fprintf(stderr, "IndexNodes:");
    if (triePtr->indexnode != NULL) {
        for (i = 0; i < triePtr->indexnode->n; i++) {
            Node *nodePtr;

            nodePtr = (Node *) <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(triePtr->indexnode, i);
            <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_indentspace">indentspace</a>(indent + 2);
            if (nodePtr->dataInherit != NULL) {
                fprintf(stderr, "(Id: %d, inherit): %p", 
                        nodePtr->id, nodePtr->dataInherit);
            }
            if (nodePtr->dataNoInherit != NULL) {
                fprintf(stderr, "(Id: %d, noinherit): %p",
                        nodePtr->id, nodePtr->dataNoInherit);
            }
        }
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintJunction">PrintJunction</a> --
 *
 *      Print a junction to std error. 
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      Will write to stderr. 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintJunction">PrintJunction</a>(Junction *junctionPtr)
{
    int i;

    fprintf(stderr, "Junction:");

#ifndef __URLSPACE_OPTIMIZE__
    for (i = 0; i < (&(junctionPtr->byuse))->n; i++) {
        Channel *channelPtr;
        channelPtr = (Channel *) <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&(junctionPtr->byuse), i);
#else
    for (i = ((&(junctionPtr->byname))->n - 1); i >= 0; i--) {
        Channel *channelPtr;
        channelPtr = (Channel *) <a href="/cvs/aolserver/aolserver/nsd/index.c#A_Ns_IndexEl">Ns_IndexEl</a>(&(junctionPtr->byname), i);
#endif
        fprintf(stderr, "\n  Channel[%d]:\n", i);
        fprintf(stderr, "    Filter: %s\n", channelPtr->filter);
        fprintf(stderr, "    Trie:");
        <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintTrie">PrintTrie</a>(&(channelPtr->trie), 4);
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintSeq">PrintSeq</a> --
 *
 *      Print a null-delimited sequence to stderr.
 *
 * Results:
 *      None. 
 *
 * Side effects:
 *      Will write to stderr. 
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsd/urlspace.c#A_PrintSeq">PrintSeq</a>(char *seq)
{
    char *p;

    for (p = seq; *p != '\0'; p += strlen(p) + 1) {
        if (p != seq) {
            fputs(", ", stderr);
        }
        fputs(p, stderr);
    }
}

#endif