src/common/trans.c

/*
 * Copyright (C) 2004  CreepLord (creeplord@pvpgn.org)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#define TRANS_INTERNAL_ACCESS
#include "common/setup_before.h"
#include <stdio.h>
#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#include "compat/strrchr.h"
#include <errno.h>
#include "compat/strerror.h"
#include "common/eventlog.h"
#include "common/list.h"
#include "common/addr.h"
#include "common/util.h"
#include "common/xalloc.h"
#include "trans.h"
#include "common/setup_after.h"

#define DEBUG_TRANS

static t_list * trans_head=NULL;

extern int trans_load(char const * filename, int program)
{
    FILE                *fp;
    unsigned int        line;
    unsigned int        pos;
    char                *buff;
    char                *temp;
    char const          *input;
    char const          *output;
    char const          *exclude;
    char const          *include;
    unsigned int        npos;
    char                *network;
    char                *tmp;
    char                tmp1[32];
    char                tmp2[32];
    char                tmp3[32];
    t_trans             *entry;
    
    if (!filename) {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL filename");
        return -1;
    }
    if (!(fp = fopen(filename,"r"))) {
        eventlog(eventlog_level_error,__FUNCTION__,"could not open file \"%s\" for reading (fopen: %s)",filename,pstrerror(errno));
        return -1;
    }
    trans_head = list_create();
    for (line=1; (buff = file_get_line(fp)); line++) {
        for (pos=0; buff[pos]=='\t' || buff[pos]==' '; pos++);
        if (buff[pos]=='\0' || buff[pos]=='#') {
            continue;
        }
        if ((temp = strrchr(buff,'#'))) {
            unsigned int len;
            unsigned int endpos;
            
            *temp = '\0';
            len = strlen(buff)+1;
            for (endpos=len-1; buff[endpos]=='\t' || buff[endpos]==' '; endpos--);
            buff[endpos+1] = '\0';
        }
        if (!(input = strtok(buff," \t"))) { /* strtok modifies the string it is passed */
            eventlog(eventlog_level_error,__FUNCTION__,"missing input line %u of file \"%s\"",line,filename);
            continue;
        }
        /* check for port number - this tells us what programs will use this entry */
        if (!(temp = strrchr(input,':'))) {
            eventlog(eventlog_level_error,__FUNCTION__,"missing port # on input line %u of file \"%s\"",line,filename);
            continue;
        }
        temp++;
        /* bnetd doesn't want the port 4000 entries */
        if (program==TRANS_BNETD  && strcmp(temp,"4000")==0) {
#ifdef DEBUG_TRANS
            eventlog(eventlog_level_debug,__FUNCTION__,"d2gs input (ignoring) \"%s\"",input);
#endif
            continue;
        }
        /* d2cs only wants the port 4000 entries */
        if (program==TRANS_D2CS && strcmp(temp,"4000")!=0) {
#ifdef DEBUG_TRANS
            eventlog(eventlog_level_debug,__FUNCTION__,"non d2gs input (ignoring) \"%s\"",input);
#endif
            continue;
        }
        if (!(output = strtok(NULL," \t"))) {
            eventlog(eventlog_level_error,__FUNCTION__,"missing output on line %u of file \"%s\"",line,filename);
            continue;
        }
        if (!(exclude = strtok(NULL," \t"))) {
            eventlog(eventlog_level_error,__FUNCTION__,"missing exclude on line %u of file \"%s\"",line,filename);
            continue;
        }
        if (!(include = strtok(NULL," \t"))) {
            eventlog(eventlog_level_error,__FUNCTION__,"missing include on line %u of file \"%s\"",line,filename);
            continue;
        }
        /* add exlude networks */
        tmp = xstrdup(exclude);
        npos=0;
        while (tmp[npos]) {
            network = &tmp[npos];
            for (; tmp[npos]!=',' && tmp[npos]!='\0'; npos++);
            if (tmp[npos]=='\0')
                npos--;
            else
                tmp[npos]='\0';
            if (strcmp(network,"NONE")==0) {
                npos++;
                continue;
            }
            entry = xmalloc(sizeof(t_trans));
            if (!(entry->input = addr_create_str(input,0,0))) {
                eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for input address");
                xfree(entry);
                npos++;
                continue;
            }
            if (!(entry->output = addr_create_str(input,0,0))) {
                eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for output address");
                addr_destroy(entry->input);
                xfree(entry);
                npos++;
                continue;
            }
            if (strcmp(network,"ANY")==0) {
                if (!(entry->network = netaddr_create_str("0.0.0.0/0"))) {
                    eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for network address");
                    addr_destroy(entry->output);
                    addr_destroy(entry->input);
                    xfree(entry);
                    npos++;
                    continue;
                }
            } else { 
                if (!(entry->network = netaddr_create_str(network))) {
                    eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for network address");
                    addr_destroy(entry->output);
                    addr_destroy(entry->input);
                    xfree(entry);
                    npos++;
                    continue;
                }
            }
#ifdef DEBUG_TRANS
            eventlog(eventlog_level_debug,__FUNCTION__,
                "Adding Host -> %s, Output -> %s, Network %s - (exclude)",
                addr_get_addr_str(entry->input,tmp1,sizeof(tmp1)),
                addr_get_addr_str(entry->output,tmp2,sizeof(tmp2)),
                netaddr_get_addr_str(entry->network,tmp3,sizeof(tmp3)));
#endif
            list_append_data(trans_head,entry);
            npos++;
        }
        xfree(tmp);
        /* add include networks */
        tmp = xstrdup(include);
        npos=0;
        while (tmp[npos]) {
            network = &tmp[npos];
            for (; tmp[npos]!=',' && tmp[npos]!='\0'; npos++);
            if (tmp[npos]=='\0')
                npos--;
            else
                tmp[npos]='\0';
            if (strcmp(network,"NONE")==0) {
                npos++;
                continue;
            }
            entry = xmalloc(sizeof(t_trans));
            if (!(entry->input = addr_create_str(input,0,0))) {
                eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for input address");
                xfree(entry);
                npos++;
                continue;
            }
            if (!(entry->output = addr_create_str(output,0,0))) {
                eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for output address");
                addr_destroy(entry->input);
                xfree(entry);
                npos++;
                continue;
            }
            if (strcmp(network,"ANY")==0) {
                if (!(entry->network = netaddr_create_str("0.0.0.0/0"))) {
                    eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for network address");
                    addr_destroy(entry->output);
                    addr_destroy(entry->input);
                    xfree(entry);
                    npos++;
                    continue;
                }
            } else { 
                if (!(entry->network = netaddr_create_str(network))) {
                    eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for network address");
                    addr_destroy(entry->output);
                    addr_destroy(entry->input);
                    xfree(entry);
                    npos++;
                    continue;
                }
            }
#ifdef DEBUG_TRANS
            eventlog(eventlog_level_debug,__FUNCTION__,
                "Adding Host -> %s, Output -> %s, Network %s - (include)",
                addr_get_addr_str(entry->input,tmp1,sizeof(tmp1)),
                addr_get_addr_str(entry->output,tmp2,sizeof(tmp2)),
                netaddr_get_addr_str(entry->network,tmp3,sizeof(tmp3)));
#endif
            list_append_data(trans_head,entry);
            npos++;
        }
        xfree(tmp);
    }
    file_get_line(NULL); // clear file_get_line buffer
    fclose(fp);
    eventlog(eventlog_level_info,__FUNCTION__,"trans file loaded");
    return 0;
}

extern int trans_unload(void)
{
    t_elem      *curr;
    t_trans     *entry;
    
    if (trans_head) {
        LIST_TRAVERSE(trans_head,curr)
        {
            if (!(entry = elem_get_data(curr))) {
                eventlog(eventlog_level_error,__FUNCTION__,"found NULL entry in list");
            } else {
                netaddr_destroy(entry->network);
                addr_destroy(entry->output);
                addr_destroy(entry->input);
                xfree(entry);
            }
            list_remove_elem(trans_head,&curr);
        }
        list_destroy(trans_head);
        trans_head = NULL;
    }
    return 0;
}

extern int trans_reload(char const * filename, int program)
{
    trans_unload();
    if(trans_load(filename,program)<0) return -1;
    return 0;
}

extern int trans_net(unsigned int clientaddr, unsigned int *addr, unsigned short *port)
{
    t_elem const *curr;
    t_trans      *entry;
    char         temp1[32];
    char         temp2[32];
    char         temp3[32];
    char         temp4[32];
    
#ifdef DEBUG_TRANS
    eventlog(eventlog_level_debug,__FUNCTION__,"checking %s for client %s ...",
        addr_num_to_addr_str(*addr, *port),
        addr_num_to_ip_str(clientaddr));
#endif

    if (trans_head) {
        LIST_TRAVERSE_CONST(trans_head,curr)
        {
            if (!(entry = elem_get_data(curr))) {
                eventlog(eventlog_level_error,__FUNCTION__,"found NULL entry in list");
                continue;
            }
            
#ifdef DEBUG_TRANS
            eventlog(eventlog_level_debug,__FUNCTION__,"against entry -> %s output %s network %s",
                addr_get_addr_str(entry->input,temp1,sizeof(temp1)),
                addr_get_addr_str(entry->output,temp2,sizeof(temp2)),
                netaddr_get_addr_str(entry->network,temp3,sizeof(temp3)));
#endif          
            if (addr_get_ip(entry->input)!=*addr || addr_get_port(entry->input)!=*port) {
#ifdef DEBUG_TRANS
                eventlog(eventlog_level_debug,__FUNCTION__,"entry does match input address");
#endif
                continue;
            }
            if (netaddr_contains_addr_num(entry->network,clientaddr)==0) {
#ifdef DEBUG_TRANS
                eventlog(eventlog_level_debug,__FUNCTION__,"client is not in the correct network");
#endif
                continue;
            }
#ifdef DEBUG_TRANS
            eventlog(eventlog_level_debug,__FUNCTION__,"%s translated to %s",
                addr_num_to_addr_str(*addr, *port),
                addr_get_addr_str(entry->output,temp4,sizeof(temp4)));
#endif
            *addr = addr_get_ip(entry->output);
            *port = addr_get_port(entry->output);
            return 1; /* match found in list */
        }
    }
#ifdef DEBUG_TRANS
    eventlog(eventlog_level_debug,__FUNCTION__,"no match found for %s (not translated)",
        addr_num_to_addr_str(*addr, *port));
#endif
    return 0; /* no match found in list */
}
1	sysadm	1.1	/*
2			* Copyright (C) 2004 CreepLord (creeplord@pvpgn.org)
3			*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU General Public License
6			* as published by the Free Software Foundation; either version 2
7			* of the License, or (at your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the Free Software
16			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17			*/
18			#define TRANS_INTERNAL_ACCESS
19			#include "common/setup_before.h"
20			#include <stdio.h>
21			#ifdef HAVE_STDDEF_H
22			# include <stddef.h>
23			#else
24			# ifndef NULL
25			# define NULL ((void *)0)
26			# endif
27			#endif
28			#ifdef STDC_HEADERS
29			# include <stdlib.h>
30			#else
31			# ifdef HAVE_MALLOC_H
32			# include <malloc.h>
33			# endif
34			#endif
35			#ifdef HAVE_STRING_H
36			# include <string.h>
37			#else
38			# ifdef HAVE_STRINGS_H
39			# include <strings.h>
40			# endif
41			#endif
42			#include "compat/strrchr.h"
43			#include <errno.h>
44			#include "compat/strerror.h"
45			#include "common/eventlog.h"
46			#include "common/list.h"
47			#include "common/addr.h"
48			#include "common/util.h"
49			#include "common/xalloc.h"
50			#include "trans.h"
51			#include "common/setup_after.h"
52
53			#define DEBUG_TRANS
54
55			static t_list * trans_head=NULL;
56
57			extern int trans_load(char const * filename, int program)
58			{
59			FILE *fp;
60			unsigned int line;
61			unsigned int pos;
62			char *buff;
63			char *temp;
64			char const *input;
65			char const *output;
66			char const *exclude;
67			char const *include;
68			unsigned int npos;
69			char *network;
70			char *tmp;
71			char tmp1[32];
72			char tmp2[32];
73			char tmp3[32];
74			t_trans *entry;
75
76			if (!filename) {
77			eventlog(eventlog_level_error,__FUNCTION__,"got NULL filename");
78			return -1;
79			}
80			if (!(fp = fopen(filename,"r"))) {
81			eventlog(eventlog_level_error,__FUNCTION__,"could not open file \"%s\" for reading (fopen: %s)",filename,pstrerror(errno));
82			return -1;
83			}
84			trans_head = list_create();
85			for (line=1; (buff = file_get_line(fp)); line++) {
86			for (pos=0; buff[pos]=='\t' \|\| buff[pos]==' '; pos++);
87			if (buff[pos]=='\0' \|\| buff[pos]=='#') {
88			continue;
89			}
90			if ((temp = strrchr(buff,'#'))) {
91			unsigned int len;
92			unsigned int endpos;
93
94			*temp = '\0';
95			len = strlen(buff)+1;
96			for (endpos=len-1; buff[endpos]=='\t' \|\| buff[endpos]==' '; endpos--);
97			buff[endpos+1] = '\0';
98			}
99			if (!(input = strtok(buff," \t"))) { /* strtok modifies the string it is passed */
100			eventlog(eventlog_level_error,__FUNCTION__,"missing input line %u of file \"%s\"",line,filename);
101			continue;
102			}
103			/* check for port number - this tells us what programs will use this entry */
104			if (!(temp = strrchr(input,':'))) {
105			eventlog(eventlog_level_error,__FUNCTION__,"missing port # on input line %u of file \"%s\"",line,filename);
106			continue;
107			}
108			temp++;
109			/* bnetd doesn't want the port 4000 entries */
110			if (program==TRANS_BNETD && strcmp(temp,"4000")==0) {
111			#ifdef DEBUG_TRANS
112			eventlog(eventlog_level_debug,__FUNCTION__,"d2gs input (ignoring) \"%s\"",input);
113			#endif
114			continue;
115			}
116			/* d2cs only wants the port 4000 entries */
117			if (program==TRANS_D2CS && strcmp(temp,"4000")!=0) {
118			#ifdef DEBUG_TRANS
119			eventlog(eventlog_level_debug,__FUNCTION__,"non d2gs input (ignoring) \"%s\"",input);
120			#endif
121			continue;
122			}
123			if (!(output = strtok(NULL," \t"))) {
124			eventlog(eventlog_level_error,__FUNCTION__,"missing output on line %u of file \"%s\"",line,filename);
125			continue;
126			}
127			if (!(exclude = strtok(NULL," \t"))) {
128			eventlog(eventlog_level_error,__FUNCTION__,"missing exclude on line %u of file \"%s\"",line,filename);
129			continue;
130			}
131			if (!(include = strtok(NULL," \t"))) {
132			eventlog(eventlog_level_error,__FUNCTION__,"missing include on line %u of file \"%s\"",line,filename);
133			continue;
134			}
135			/* add exlude networks */
136			tmp = xstrdup(exclude);
137			npos=0;
138			while (tmp[npos]) {
139			network = &tmp[npos];
140			for (; tmp[npos]!=',' && tmp[npos]!='\0'; npos++);
141			if (tmp[npos]=='\0')
142			npos--;
143			else
144			tmp[npos]='\0';
145			if (strcmp(network,"NONE")==0) {
146			npos++;
147			continue;
148			}
149			entry = xmalloc(sizeof(t_trans));
150			if (!(entry->input = addr_create_str(input,0,0))) {
151			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for input address");
152			xfree(entry);
153			npos++;
154			continue;
155			}
156			if (!(entry->output = addr_create_str(input,0,0))) {
157			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for output address");
158			addr_destroy(entry->input);
159			xfree(entry);
160			npos++;
161			continue;
162			}
163			if (strcmp(network,"ANY")==0) {
164			if (!(entry->network = netaddr_create_str("0.0.0.0/0"))) {
165			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for network address");
166			addr_destroy(entry->output);
167			addr_destroy(entry->input);
168			xfree(entry);
169			npos++;
170			continue;
171			}
172			} else {
173			if (!(entry->network = netaddr_create_str(network))) {
174			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for network address");
175			addr_destroy(entry->output);
176			addr_destroy(entry->input);
177			xfree(entry);
178			npos++;
179			continue;
180			}
181			}
182			#ifdef DEBUG_TRANS
183			eventlog(eventlog_level_debug,__FUNCTION__,
184			"Adding Host -> %s, Output -> %s, Network %s - (exclude)",
185			addr_get_addr_str(entry->input,tmp1,sizeof(tmp1)),
186			addr_get_addr_str(entry->output,tmp2,sizeof(tmp2)),
187			netaddr_get_addr_str(entry->network,tmp3,sizeof(tmp3)));
188			#endif
189			list_append_data(trans_head,entry);
190			npos++;
191			}
192			xfree(tmp);
193			/* add include networks */
194			tmp = xstrdup(include);
195			npos=0;
196			while (tmp[npos]) {
197			network = &tmp[npos];
198			for (; tmp[npos]!=',' && tmp[npos]!='\0'; npos++);
199			if (tmp[npos]=='\0')
200			npos--;
201			else
202			tmp[npos]='\0';
203			if (strcmp(network,"NONE")==0) {
204			npos++;
205			continue;
206			}
207			entry = xmalloc(sizeof(t_trans));
208			if (!(entry->input = addr_create_str(input,0,0))) {
209			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for input address");
210			xfree(entry);
211			npos++;
212			continue;
213			}
214			if (!(entry->output = addr_create_str(output,0,0))) {
215			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for output address");
216			addr_destroy(entry->input);
217			xfree(entry);
218			npos++;
219			continue;
220			}
221			if (strcmp(network,"ANY")==0) {
222			if (!(entry->network = netaddr_create_str("0.0.0.0/0"))) {
223			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for network address");
224			addr_destroy(entry->output);
225			addr_destroy(entry->input);
226			xfree(entry);
227			npos++;
228			continue;
229			}
230			} else {
231			if (!(entry->network = netaddr_create_str(network))) {
232			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for network address");
233			addr_destroy(entry->output);
234			addr_destroy(entry->input);
235			xfree(entry);
236			npos++;
237			continue;
238			}
239			}
240			#ifdef DEBUG_TRANS
241			eventlog(eventlog_level_debug,__FUNCTION__,
242			"Adding Host -> %s, Output -> %s, Network %s - (include)",
243			addr_get_addr_str(entry->input,tmp1,sizeof(tmp1)),
244			addr_get_addr_str(entry->output,tmp2,sizeof(tmp2)),
245			netaddr_get_addr_str(entry->network,tmp3,sizeof(tmp3)));
246			#endif
247			list_append_data(trans_head,entry);
248			npos++;
249			}
250			xfree(tmp);
251			}
252			file_get_line(NULL); // clear file_get_line buffer
253			fclose(fp);
254			eventlog(eventlog_level_info,__FUNCTION__,"trans file loaded");
255			return 0;
256			}
257
258			extern int trans_unload(void)
259			{
260			t_elem *curr;
261			t_trans *entry;
262
263			if (trans_head) {
264			LIST_TRAVERSE(trans_head,curr)
265			{
266			if (!(entry = elem_get_data(curr))) {
267			eventlog(eventlog_level_error,__FUNCTION__,"found NULL entry in list");
268			} else {
269			netaddr_destroy(entry->network);
270			addr_destroy(entry->output);
271			addr_destroy(entry->input);
272			xfree(entry);
273			}
274			list_remove_elem(trans_head,&curr);
275			}
276			list_destroy(trans_head);
277			trans_head = NULL;
278			}
279			return 0;
280			}
281
282			extern int trans_reload(char const * filename, int program)
283			{
284			trans_unload();
285			if(trans_load(filename,program)<0) return -1;
286			return 0;
287			}
288
289			extern int trans_net(unsigned int clientaddr, unsigned int addr, unsigned short port)
290			{
291			t_elem const *curr;
292			t_trans *entry;
293			char temp1[32];
294			char temp2[32];
295			char temp3[32];
296			char temp4[32];
297
298			#ifdef DEBUG_TRANS
299			eventlog(eventlog_level_debug,__FUNCTION__,"checking %s for client %s ...",
300			addr_num_to_addr_str(addr, port),
301			addr_num_to_ip_str(clientaddr));
302			#endif
303
304			if (trans_head) {
305			LIST_TRAVERSE_CONST(trans_head,curr)
306			{
307			if (!(entry = elem_get_data(curr))) {
308			eventlog(eventlog_level_error,__FUNCTION__,"found NULL entry in list");
309			continue;
310			}
311
312			#ifdef DEBUG_TRANS
313			eventlog(eventlog_level_debug,__FUNCTION__,"against entry -> %s output %s network %s",
314			addr_get_addr_str(entry->input,temp1,sizeof(temp1)),
315			addr_get_addr_str(entry->output,temp2,sizeof(temp2)),
316			netaddr_get_addr_str(entry->network,temp3,sizeof(temp3)));
317			#endif
318			if (addr_get_ip(entry->input)!=addr \|\| addr_get_port(entry->input)!=port) {
319			#ifdef DEBUG_TRANS
320			eventlog(eventlog_level_debug,__FUNCTION__,"entry does match input address");
321			#endif
322			continue;
323			}
324			if (netaddr_contains_addr_num(entry->network,clientaddr)==0) {
325			#ifdef DEBUG_TRANS
326			eventlog(eventlog_level_debug,__FUNCTION__,"client is not in the correct network");
327			#endif
328			continue;
329			}
330			#ifdef DEBUG_TRANS
331			eventlog(eventlog_level_debug,__FUNCTION__,"%s translated to %s",
332			addr_num_to_addr_str(addr, port),
333			addr_get_addr_str(entry->output,temp4,sizeof(temp4)));
334			#endif
335			*addr = addr_get_ip(entry->output);
336			*port = addr_get_port(entry->output);
337			return 1; /* match found in list */
338			}
339			}
340			#ifdef DEBUG_TRANS
341			eventlog(eventlog_level_debug,__FUNCTION__,"no match found for %s (not translated)",
342			addr_num_to_addr_str(addr, port));
343			#endif
344			return 0; /* no match found in list */
345			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1