[flow-tools] added code to flow-tag for alternate file format

Fri, 31 Jan 2003 16:40:44 -0600 (CST)

Here is the code for anyone who wants it.  As mentioned, it may make
more sense to put the time and energy into improving the documentation
on flow-tag and the tag rather than incorporating this code.

The code has not been formatted or named to existing styles as I
intended it for internal use only.

============================================================
new flow-tag.c
============================================================
/*
 * Copyright (c) 2001 Mark Fullmer and The Ohio State University
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *      $Id: flow-tag.c,v 1.12 2002/08/26 02:24:38 maf Exp $
 */

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <ftlib.h>

#if HAVE_STRINGS_H
 #include <strings.h>
#endif

#if HAVE_STRING_H
  #include <string.h>
#endif

#include "ftbuild.h"

/*--finseth, 2003-01-20: added declarations--*/
#ifndef NULL
#define NULL		((void *) 0)
#endif
#define NUL		'\0'
void do_alternate_tag(struct fts3rec_v1005 *rec);
void load_alternate_tag(char *alttag);
/*--end change--*/

int debug;
void usage(void);

int main(int argc, char **argv)
{
  struct ftio ftio_in, ftio_out;
  struct ftprof ftp;
  struct ftver ftv_in, ftv_out;
  struct ftset ftset;
  struct fts3rec_v1005 xl_rec;
  struct fts3rec_offsets fo;
  struct fttag fttag;
  struct fttag_def *ftd;
  int i, keep_input_time;
  u_int32 total_flows, cap_start, cap_end;
  u_int32 time_start, time_end;
  char *tag_defs, *tag_active;
  char *rec_in, *rec_out;
/*--finseth, 2003-01-20: added "alttag"--*/
  char *alttag;
  alttag = "";
/*--end change--*/

  /* init fterr */
  fterr_setid(argv[0]);

  bzero(&ftv_in, sizeof ftv_in);
  bzero(&ftv_out, sizeof ftv_out);
  bzero(&fttag, sizeof fttag);
  tag_defs = FT_PATH_CFG_TAG;
  tag_active = "";

  total_flows = 0;

  keep_input_time = 0;

  /* profile */
  ftprof_start (&ftp);

  /* defaults + no compression */
  ftset_init(&ftset, 0);

/*--finseth, 2003-01-20: added "a:"--*/
  while ((i = getopt(argc, argv, "a:b:C:d:fh?klm:s:t:T:V:z:")) != -1)
/*--end change--*/

    switch (i) {

/*--finseth, 2003-01-20: added "a:"--*/
    case 'a': /* alternate tag file */
      alttag = optarg;
      break;
/*--end change--*/

    case 'b': /* output byte order */
      if (!strcasecmp(optarg, "little"))
        ftset.byte_order = FT_HEADER_LITTLE_ENDIAN;
      else if (!strcasecmp(optarg, "big"))
        ftset.byte_order = FT_HEADER_BIG_ENDIAN;
      else
        fterr_errx(1, "expecting \"big\" or \"little\"");
      break;

    case 'C': /* comment field */
      ftset.comments = optarg;
      break;

    case 'd': /* debug */
      debug = atoi(optarg);
      break;

    case 'k': /* keep the start/end time from the input */
      keep_input_time = 1;
      break;

    case 't': /* tag filename */
      tag_defs = optarg;
      break;

    case 'T': /* active tags */
      tag_active = optarg;
      break;

    case 'z': /* compress level */
      ftset.z_level = atoi(optarg);
      if ((ftset.z_level < 0) || (ftset.z_level > 9))
        fterr_errx(1, "Compression level must be between 0 and 9");
      break;

    case 'h': /* help */
    case '?': 
    default:
      usage();
      exit (1);
      break;

    } /* switch */

  i = optind;

/*--finseth, 2003-01-20: added alttag option--*/
  if (*alttag != 0) {
    load_alternate_tag(alttag);
  } else {
    /* read config file */
    if (fttag_load(&fttag, tag_defs) < 0)
      fterr_errx(1, "fttag_load(): failed");

    if (!(ftd = fttag_def_find(&fttag, tag_active))) 
      fterr_errx(1, "fttag_def_find(): failed");
  }
/*--end change--*/

  /* input is stdin */
  if (ftio_init(&ftio_in, 0, FT_IO_FLAG_READ) < 0)
    fterr_errx(1, "ftio_init(): failed");

  ftio_get_ver(&ftio_in, &ftv_in);

  /* need at least the v5 fields plus tags */
  if (ftio_check_xfield(&ftio_in, FT_XFIELD_TAGGING_MASK))
    fterr_errx(1, "Flow record missing required field for tagging.");

  /* output is stdout */
  if (ftio_init(&ftio_out, 1, FT_IO_FLAG_WRITE |
    ((ftset.z_level) ? FT_IO_FLAG_ZINIT : 0) ) < 0)
    fterr_errx(1, "ftio_init(): failed");

  /* preserve start/end time from input stream? */
  if (keep_input_time) {  

    time_start = ftio_get_cap_start(&ftio_in);
    time_end = ftio_get_cap_end(&ftio_in);

    if (time_start && time_end) {

      ftio_set_preloaded(&ftio_out, 1);
      ftio_set_cap_time(&ftio_out, time_start, time_end);

    }

  } /* keep_input_time */

  ftv_in.s_version = FT_IO_SVERSION;

  if (!ftv_out.set)
    bcopy(&ftv_in, &ftv_out, sizeof ftv_in);

  ftv_out.d_version = 1005;

  /* set the version information in the io stream */
  if (ftio_set_ver(&ftio_out, &ftv_out) < 0)
    fterr_errx(1, "ftio_set_ver(): failed");

  ftio_set_comment(&ftio_out, ftset.comments);
  ftio_set_byte_order(&ftio_out, ftset.byte_order);
  ftio_set_z_level(&ftio_out, ftset.z_level);
  ftio_set_streaming(&ftio_out, 1);
  ftio_set_debug(&ftio_out, debug);
  ftio_set_cap_time(&ftio_out, cap_start, cap_end);
  ftio_set_flows_count(&ftio_out, total_flows);

  if (ftio_write_header(&ftio_out) < 0)
    fterr_errx(1, "ftio_write_header(): failed");

  fts3rec_compute_offsets(&fo, &ftv_in);

  rec_out = (void*)&xl_rec;

  while ((rec_in = ftio_read(&ftio_in))) {

    ++total_flows;

    /* make a v1005 rec */
    if (ftv_in.d_version != 1005)
      ftrec_xlate(rec_in, &ftv_in, &xl_rec, &ftv_out);
    else
      rec_out = rec_in;

/*--finseth, 2003-01-20: added alttag check--*/
    if (*alttag != NUL) {
      /* code at end of this file */
      do_alternate_tag((struct fts3rec_v1005*)rec_out);
    } else {
      /* tag evaluation */
      fttag_def_eval(ftd, (struct fts3rec_v1005*)rec_out);
    }
/*--end change--*/

    if (ftio_write(&ftio_out, rec_out) < 0)
      fterr_errx(1, "ftio_write(): failed");

  } /* while */

  if (ftio_close(&ftio_out) < 0)
    fterr_errx(1, "ftio_close(): failed");

  if (ftio_close(&ftio_in) < 0)
    fterr_errx(1, "ftio_close(): failed");

  if (debug > 0) {
    ftprof_end (&ftp, total_flows);
    ftprof_print(&ftp, argv[0], stderr);
  }

  fttag_free(&fttag);

  return 0;

} /* main */

void usage(void)
{
  fprintf(stderr, "Usage: flow-tag [-hk] [-b big|little] [-C comment] [-d debug_level]\n");
  fprintf(stderr, "       [-t tag_fname ] [-T tag_active ] [-z z_level]\n");
  fprintf(stderr, "\n%s version %s: built by %s\n", PACKAGE, VERSION, FT_PROG_BUILD);

} /* usage */

/* ============================================================ */
/* This section has all new code for handling the alternate tag */
/* file.  The code is placed here to minimize the number of files */
/* that are changed. */

/* #define DEBUG	1 */
#if defined(DEBUG)
FILE *dfptr;
#endif

#define FLAG		char
#define INET_T		unsigned long

#define TAB		'\11'
#define LF		'\12'
#define CR		'\15'
#define SP		' '

#define TRUE		1
#define FALSE		0

#define BUFFSIZE	1024
#define INPMAX		256		/* size of user input buffer */

#define xstrncpy(d,s)		{ (void)strncpy((d),(s),sizeof(d)); (d)[sizeof(d)-1]=NUL; }

struct alttagrec {
	INET_T	ipaddr;
	int	masklen;
	INET_T	mask;
	int	sval;
	int	dval;
	};

void do_alternate_block(struct alttagrec altptr[], int blockcount, FLAG in,
	 struct fts3rec_v1005 *rec);
int load_block(FILE *fptr, char *alttag, int blockcount, int line);
int load_compare_alttagrec(const void *a, const void *b);
int load_line(FILE *fptr, char *alttag, int blockcount, int line, int which);

void InetToS(char *str, INET_T inet);
FLAG is_inside(INET_T innerip, INET_T outerip, INET_T outermask);
char *sfindnotin(char *str, char *any);
char *sindex(char *str, char chr);
FLAG SToInet(char *str, INET_T *inetptr);
FLAG SToN(char *str, int *n, int base);
FLAG xisalpha(int c);
FLAG xisdigit(int c);
FLAG xislower(int c);
FLAG xisupper(int c);
FLAG xiswhite(char c);
int xtoupper(int c);

struct alttagrec **aptr;
int *bptr;
FLAG *inptr;		/* true if matches are within the block */
int altcount;

/* ------------------------------------------------------------ */
/* This is the replacement for fttag_def_eval. */

void do_alternate_tag(struct fts3rec_v1005 *rec) {
	int i;

	rec->src_tag = 0;
	rec->dst_tag = 0;

	for (i = 0; i < altcount; i++) {
		do_alternate_block(aptr[i], bptr[i], inptr[i], rec);
		}
	}

/* ------------------------------------------------------------ */

void do_alternate_block(struct alttagrec altptr[], int blockcount, FLAG in,
	 struct fts3rec_v1005 *rec) {
	struct alttagrec *ap;

	if (in) {
		if (rec->srcaddr < altptr[0].ipaddr) {
			/* before the first, so skip */
			}
		else	{
			for (ap = &altptr[blockcount - 1]; ap >= altptr;
				 ap--) {
				if ((rec->srcaddr & ap->mask) == ap->ipaddr) {
					rec->src_tag |= ap->sval;
					break;
					}
				if (rec->srcaddr > ap->ipaddr) {
					/* in gap between entries */
					break;
					}
				}
			}
		if (rec->dstaddr < altptr[0].ipaddr) {
			/* before the first, so skip */
			}
		else	{
			for (ap = &altptr[blockcount - 1]; ap >= altptr;
				 ap--) {
				if ((rec->dstaddr & ap->mask) == ap->ipaddr) {
					rec->dst_tag |= ap->dval;
					break;
					}
				if (rec->dstaddr > ap->ipaddr) {
					/* in gap between entries */
					break;
					}
				}
			}
		}
	else	{
		if (rec->srcaddr < altptr[0].ipaddr) {
			rec->src_tag |= altptr[0].sval;
			}
		else	{
			for (ap = &altptr[blockcount - 1]; ap >= altptr;
				 ap--) {
				if ((rec->srcaddr & ap->mask) == ap->ipaddr) {
					break;
					}
				if (rec->srcaddr > ap->ipaddr) {
					/* in gap between entries */
					rec->src_tag |= ap->sval;
					break;
					}
				}
			}
		if (rec->dstaddr < altptr[0].ipaddr) {
			/* before the first, so skip */
			rec->dst_tag |= altptr[0].dval;
			}
		else	{
			for (ap = &altptr[blockcount - 1]; ap >= altptr;
				 ap--) {
				if ((rec->dstaddr & ap->mask) == ap->ipaddr) {
					break;
					}
				if (rec->dstaddr > ap->ipaddr) {
					/* in gap between entries */
					rec->dst_tag |= ap->dval;
					break;
					}
				}
			}
		}
	}		

/* ------------------------------------------------------------ */
/* Load the alternate tag file. */

void load_alternate_tag(char *alttag) {
#if defined(DEBUG)
	struct alttagrec *atrptr;
	char b1[BUFFSIZE];
	char b2[BUFFSIZE];
#endif
	FILE *fptr;
	char buf[BUFFSIZE];
	char *begptr, *endptr;
	int i;
	int line;

	if ((fptr = fopen(alttag, "r")) == NULL) {
		fprintf(stderr, "Unable to access file '%s'.\n", alttag);
		exit(1);
		}
	line = 1;
	if (fgets(buf, BUFFSIZE, fptr) <= 0) {
		fprintf(stderr, "File %s: read error on line 1.\n", alttag);
		fclose(fptr);
		exit(1);
		}
	begptr = buf;
	endptr = sfindnotin(begptr, "0123456789");
	*endptr = NUL;
	if (!SToN(begptr, &altcount, 10)) {
		fprintf(stderr, "Alternate tag file '%s' does not begin with a block count.\n",
			alttag);
		fclose(fptr);
		exit(1);
		}
	aptr = (struct alttagrec **)malloc(sizeof(struct alttagrec *) *
		altcount);
	if (aptr == NULL) {
		fprintf(stderr, "Unable to allocate memory for alt tag array.\n");
		fclose(fptr);
		exit(1);
		}
	inptr = (FLAG *)malloc(sizeof(FLAG) * altcount);
	if (inptr == NULL) {
		fprintf(stderr, "Unable to allocate memory for alt flag array.\n");
		fclose(fptr);
		exit(1);
		}
	bptr = (int *)malloc(sizeof(int) * altcount);
	if (bptr == NULL) {
		fprintf(stderr, "Unable to allocate memory for alt count array.\n");
		fclose(fptr);
		exit(1);
		}
#if defined(DEBUG)
	dfptr = fopen("/tmp/debug.out", "w");
	fprintf(dfptr, "file '%s' opened, altcount=%d\n", alttag, altcount);
#endif
	for (i = 1; i <= altcount; i++) {
		line = load_block(fptr, alttag, i, line);
		}
	fclose(fptr);

#if defined(DEBUG)
	for (i = 0; i < altcount; i++) {
		fprintf(dfptr, "block #%d, size %d, in %s:\n", i + 1, bptr[i],
			inptr[i] ? "in" : "out");
		for (atrptr = aptr[i]; atrptr->ipaddr != 0; atrptr++) {
			InetToS(b1, atrptr->ipaddr),
			InetToS(b2, atrptr->mask),
			fprintf(dfptr, "%s\t%d\t%s\t%08x\t%08x\n",
				b1,
				atrptr->masklen,
				b2,
				atrptr->sval,
				atrptr->dval);
			}
		}
	fprintf(dfptr, "file loaded\n");
	fclose(dfptr);
#endif
	}

/* ------------------------------------------------------------ */
/* Load a block. Return the new line number. */

int load_block(FILE *fptr, char *alttag, int blockcount, int line) {
	char buf[BUFFSIZE];
	char *begptr, *endptr;
	int cnt;
	int i;

	line++;
	if (fgets(buf, BUFFSIZE, fptr) <= 0) {
		fprintf(stderr, "File %s: read error on line %d.\n", alttag,
			line);
		fclose(fptr);
		exit(1);
		}
	begptr = buf;
	endptr = sfindnotin(begptr, "-0123456789");
	*endptr = NUL;
	if (!SToN(begptr, &cnt, 10)) {
		fprintf(stderr, "File %s line %d block %d does not begin with a block count.\n",
			alttag, line, blockcount);
		fclose(fptr);
		exit(1);
		}
	inptr[blockcount - 1] = cnt > 0;
	if (cnt < 0) cnt = -cnt;
	aptr[blockcount - 1] = (struct alttagrec *)
		malloc(sizeof(struct alttagrec) * (cnt + 1));
	if (aptr[blockcount - 1] == NULL) {
		fprintf(stderr, "File %s line %d block %d: unable to allocate memory.\n",
				alttag, line, blockcount);
		fclose(fptr);
		exit(1);
		}
	for (i = 0; i < cnt; i++) {
		line = load_line(fptr, alttag, blockcount, line, i);
		}
	aptr[blockcount - 1][cnt].ipaddr = 0;
	bptr[blockcount - 1] = cnt;

	/**sort*/
	qsort((aptr[blockcount - 1]),
		cnt,
		sizeof(struct alttagrec),
		load_compare_alttagrec);

	/**verify*/
	for (i = cnt - 1; i > 0; i--) {
		if (is_inside((aptr[blockcount - 1])[i].ipaddr,
			 (aptr[blockcount - 1])[i - 1].ipaddr,
			 (aptr[blockcount - 1])[i - 1].mask)) {
			fprintf(stderr, "File %s block %d: overlapping networks.\n",
				alttag, blockcount);
			fclose(fptr);
			exit(1);
			}
		}
	return(line);
	}

/* ------------------------------------------------------------ */
/* Compare two records for qsort. */

int load_compare_alttagrec(const void *av, const void *bv) {
	struct alttagrec *a = (struct alttagrec *)av;
	struct alttagrec *b = (struct alttagrec *)bv;

	if (a->ipaddr > b->ipaddr) {
		return(1);
		}
	else if (a->ipaddr < b->ipaddr) {
		return(-1);
		}

	if (a->masklen > b->masklen) {
		return(1);
		}
	else if (a->masklen < b->masklen) {
		return(-1);
		}
	return(0);
	}

/* ------------------------------------------------------------ */
/* Load a line for a block. Return the new line number. */

int load_line(FILE *fptr, char *alttag, int blockcount, int line, int which) {
	char buf[BUFFSIZE];
	char *begptr, *endptr;
	int i;
	struct alttagrec a;

	do	{
		line++;
		if (fgets(buf, BUFFSIZE, fptr) <= 0) {
			fprintf(stderr, "File %s: read error on line %d.\n",
				alttag, line);
			fclose(fptr);
			exit(1);
			}
		} while (!xisdigit(buf[0]));

	/* parse IP addr */
	begptr = buf;
	endptr = sfindnotin(begptr, "0123456789.");
	if (*endptr == NUL) {
		fprintf(stderr, "File %s line %d block %d: no data after network number.\n",
			alttag, line, blockcount);
		fclose(fptr);
		exit(1);
		}
	*endptr = NUL;
	if (!SToInet(begptr, &a.ipaddr)) {
		fprintf(stderr, "File %s line %d block %d: '%s' is not valid IP address.\n",
			alttag, line, blockcount, begptr);
		fclose(fptr);
		exit(1);
		}

	/* parse mask len */
	for (begptr = endptr + 1; xiswhite(*begptr); begptr++) ;
	endptr = sfindnotin(begptr, "0123456789");
	if (*endptr == NUL) {
		fprintf(stderr, "File %s line %d block %d: no data after network count.\n",
			alttag, line, blockcount);
		fclose(fptr);
		exit(1);
		}
	*endptr = NUL;
	if (!SToN(begptr, &i, 10) || i < 1 || i > 32) {
		fprintf(stderr, "File %s line %d block %d: '%s' is not valid integer between 1 and 32.\n",
			alttag, line, blockcount, begptr);
		fclose(fptr);
		exit(1);
		}
	a.masklen = i;

	/* generate mask */
	a.mask = ~((1 << (32 - a.masklen)) - 1);

	/* parse sval */
	for (begptr = endptr + 1; xiswhite(*begptr); begptr++) ;
	endptr = sfindnotin(begptr, "0123456789abcdefABCDEF");
	if (*endptr == NUL) {
		fprintf(stderr, "File %s line %d block %d: no data after sval.\n",
			alttag, line, blockcount);
		fclose(fptr);
		exit(1);
		}
	*endptr = NUL;
	if (!SToN(begptr, &i, 16)) {
		fprintf(stderr, "File %s line %d block %d: '%s' is not a valid hexadecimal value.\n",
			alttag, line, blockcount, begptr);
		fclose(fptr);
		exit(1);
		}
	a.sval = i;

	/* parse dval */
	for (begptr = endptr + 1; xiswhite(*begptr); begptr++) ;
	endptr = sfindnotin(begptr, "0123456789abcdefABCDEF");
	*endptr = NUL;
	if (!SToN(begptr, &i, 16)) {
		fprintf(stderr, "File %s line %d block %d: '%s' is not a valid hexadecimal value.\n",
			alttag, line, blockcount, begptr);
		fclose(fptr);
		exit(1);
		}
	a.dval = i;
	(aptr[blockcount - 1])[which] = a;
	return(line);
	}

/* ------------------------------------------------------------ */

/* Convert the Internet address INET to a string. */

void InetToS(char *str, INET_T inet) {
	sprintf(str, "%ld.%ld.%ld.%ld",
		(inet >> 24) & 0xFF,
		(inet >> 16) & 0xFF,
		(inet >>  8) & 0xFF,
		 inet        & 0xFF);
	}

/* ------------------------------------------------------------ */
/* Return True if the inner ip is within the outer IP network. */

FLAG is_inside(INET_T innerip, INET_T outerip, INET_T outermask) {
	return((innerip & outermask) == outerip);
	}

/* ------------------------------------------------------------ */

/* Return a pointer to the first occurrance in STR of any of the
characters NOT in ANY. */

char *sfindnotin(char *str, char *any) {
	while (*str != NUL && *sindex(any, *str)) ++str;
	return(str);
	}

/* ------------------------------------------------------------ */

/* Return a pointer to the first occurrance of C in STR. */

char *sindex(char *str, char chr) {
	while (*str != NUL && *str != chr) str++;
	return(str);
	}

/* ------------------------------------------------------------ */

/* Converts the value in STR to an Internet address and returns it in
INETPTR.  STR must contain a value in Internet dot notation (e.g.,
a.b.c.d).  All four components must be present.  Returns TRUE if the
conversion was sucessful, FALSE if the string was not a valid Internet
address. */

FLAG SToInet(char *str, INET_T *inetptr) {
	char buf[INPMAX];
	char *cptr;
	char *begptr;
	char *endptr;
	INET_T inet;
	int cnt;
	int num;

	if (strlen(str) >= INPMAX) return(FALSE);	/* too long */
	xstrncpy(buf, str);

	inet = 0;
	begptr = buf;
	endptr = buf + strlen(buf);
	for (cnt = 0; cnt < 4 && begptr < endptr && *begptr != NUL;
		 cnt++, begptr = cptr) {
		cptr = sindex(begptr, '.');
		*cptr++ = NUL;
		if (!SToN(begptr, &num, 10)) return(FALSE);
		if (num < 0 || num > 255) return(FALSE);
		inet <<= 8;
		inet |= (num & 0xFF);
		}
	if (cnt != 4) return(FALSE);
	*inetptr = inet;
	return(TRUE);
	}

/* ------------------------------------------------------------ */

/* Convert the value in STR to a decimal number and return it in N. 
The number is in base BASE.  Return TRUE if the conversion was
successful, FALSE if the string was not a valid number.

This routine allows for leading whitespace and can handle leading + or
- signs. */

FLAG
SToN(char *str, int *n, int base) {
	unsigned val;
	int minus;
	char chr;

	while (*str == SP || *str == TAB) str++;
	if (*str == '-') {
		minus = -1;
		str++;
		}
	else	{
		minus = 1;
		if (*str == '+') ++str;
		}
	for (val = 0; *str; ++str) {
		chr = xtoupper(*str);
		if (xisalpha(chr)) chr -= 'A' - 10;
		else if (xisdigit(chr)) chr -= '0';
		else return(FALSE);
		if (chr >= base) return(FALSE);
		val = val * base + chr;
		}
	*n = val * minus;
	return(TRUE);
	}

/* ------------------------------------------------------------ */