www.pudn.com > tfs.rar > genlib.c
/* genlib.c:
* This file has some of the stuff that is typically pulled in by the c
* library. It is provided as local source so that the monitor can be
* built without the need for a library. Some of this code was taken from
* the Berkley source code (see notice below).
*
* General notice:
* This code is part of a boot-monitor package developed as a generic base
* platform for embedded system designs. As such, it is likely to be
* distributed to various projects beyond the control of the original
* author. Please notify the author of any enhancements made or bugs found
* so that all may benefit from the changes. In addition, notification back
* to the author will allow the new user to pick up changes that may have
* been made by other users after this version of the code was distributed.
*
* Note1: the majority of this code was edited with 4-space tabs.
* Note2: as more and more contributions are accepted, the term "author"
* is becoming a mis-representation of credit.
*
* Original author: Ed Sutter
* Email: esutter@lucent.com
* Phone: 908-582-2351
*/
/*
* Copyright (c) 1988, 1993
* The Regents of the University of California. 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*/
#include "ctype.h"
#include "genlib.h"
#include "stddefs.h"
#include "tfs.h"
char *BSDCRN = "Copyright (c) 1988, 1993 The Regents of the University of California. All rights reserved.";
static int UserLevel;
/* If an application is using this source code, then the printf() calls
* might want to be redirected to mon_printf...
*/
#ifdef MONPRINTF
extern int mon_printf();
#define printf mon_printf
#endif
int
abs(int arg)
{
return (arg >= 0 ? arg : -arg);
}
int
atoi(char *p)
{
int n, c, neg;
neg = 0;
if (!isdigit((c = *p))) {
while (isspace(c))
c = *++p;
switch (c) {
case '-':
neg++;
break;
case '+': /* fall-through */
c = *++p;
break;
}
if (!isdigit(c))
return (0);
}
for (n = '0' - c; isdigit((c = *++p)); ) {
n *= 10; /* two steps to avoid unnecessary overflow */
n += '0' - c; /* accum neg to avoid surprises at MAX */
}
return (neg ? n : -n);
}
unsigned char ctypetbl[] = {
0, _C, _C, _C, _C, _C, _C, _C,
_C, _S|_C, _S|_C, _S|_C, _S|_C, _S|_C, _C, _C,
_C, _C, _C, _C, _C, _C, _C, _C,
_C, _C, _C, _C, _C, _C, _C, _C,
_S|_B, _P, _P, _P, _P, _P, _P, _P,
_P, _P, _P, _P, _P, _P, _P, _P,
_N|_X, _N|_X, _N|_X, _N|_X, _N|_X, _N|_X, _N|_X, _N|_X,
_N|_X, _N|_X, _P, _P, _P, _P, _P, _P,
_P, _U|_X, _U|_X, _U|_X, _U|_X, _U|_X, _U|_X, _U,
_U, _U, _U, _U, _U, _U, _U, _U,
_U, _U, _U, _U, _U, _U, _U, _U,
_U, _U, _U, _P, _P, _P, _P, _P,
_P, _L|_X, _L|_X, _L|_X, _L|_X, _L|_X, _L|_X, _L,
_L, _L, _L, _L, _L, _L, _L, _L,
_L, _L, _L, _L, _L, _L, _L, _L,
_L, _L, _L, _P, _P, _P, _P, _C,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
/* memccpy():
* Copy s2 to s1, stopping if character c is copied. Copy no more than n bytes.
* Return a pointer to the byte after character c in the copy,
* or NULL if c is not found in the first n bytes.
*/
char *
memccpy(register char *s1,register char *s2,register int c,register int n)
{
while (--n >= 0)
if ((*s1++ = *s2++) == c)
return (s1);
return (0);
}
/* memchr():
* Return the ptr in sp at which the character c appears;
* NULL if not found in n chars; don't stop at \0.
*/
char *
memchr(register char *sp, register char c,register int n)
{
while (--n >= 0)
if (*sp++ == c)
return (--sp);
return (0);
}
/* memcmp():
* Compare n bytes: s1>s2: >0 s1==s2: 0 s1= 0)
if ((diff = (*s1++ - *s2++)))
return (diff);
return (0);
}
/* memcpy():
* Copy n bytes from 'from' to 'to'; return 'to'.
* This version of memcpy() tries to take advantage of address alignment.
* The goal is to do as many of the copies on 4-byte aligned addresses,
* falling back to 2-byte alignment, and finally, if there is no other
* way, simple byte-by-byte copy.
* Note that there is some point where the amount of overhead may exceed
* the byte count; hence, this will take longer for small byte counts.
* The assumption here is that small byte count memcpy() calls don't really
* care.
*/
char *
memcpy(char *to,char *from,int count)
{
char *to_copy, *end;
to_copy = to;
#if INCLUDE_QUICKMEMCPY
/* If count is greater than 8, get fancy, else just do byte-copy... */
if (count > 8) {
/* Attempt to optimize the transfer here... */
if (((int)to & 3) && ((int)from & 3)) {
/* If from and to pointers are both unaligned to the
* same degree then we can do a few char copies to get them
* 4-byte aligned and then do a lot of 4-byte aligned copies.
*/
if (((int)to & 3) == ((int)from & 3)) {
while((int)to & 3) {
*to++ = *from++;
count--;
}
}
/* If from and to pointers are both odd, but different, then
* we can increment them both by 1 and do a bunch of 2-byte
* aligned copies...
*/
else if (((int)to & 1) && ((int)from & 1)) {
*to++ = *from++;
count--;
}
}
/* If both pointers are now 4-byte aligned or 2-byte aligned,
* take advantage of that here...
*/
if (!((int)to & 3) && !((int)from & 3)) {
end = to + (count & ~3);
count = count & 3;
while(to < end) {
*(ulong *)to = *(ulong *)from;
from += 4;
to += 4;
}
}
else if (!((int)to & 1) && !((int)from & 1)) {
end = to + (count & ~1);
count = count & 1;
while(to < end) {
*(ushort *)to = *(ushort *)from;
from += 2;
to += 2;
}
}
}
#endif
if (count) {
end = to + count;
while(to < end)
*to++ = *from++;
}
return(to_copy);
}
void
bcopy(char *from, char *to, int size)
{
memcpy(to,from,size);
}
/* memset():
* Set an array of n chars starting at sp to the character c.
* Return sp.
*/
char *
memset(register char *sp, register char c, register int n)
{
register char *sp0 = sp;
while (--n >= 0)
*sp++ = c;
return (sp0);
}
/* strcat():
* Concatenate s2 on the end of s1. S1's space must be large enough.
* Return s1.
*/
/*
char *
strcat(register char *s1, register char *s2)
{
register char *os1;
os1 = s1;
while(*s1++)
;
--s1;
while((*s1++ = *s2++))
;
return(os1);
}
*/
/* strchr():
* Return the ptr in sp at which the character c appears;
* NULL if not found
*/
/*
char *
strchr(register char *sp, register char c)
{
do {
if(*sp == c)
return(sp);
} while(*sp++);
return((char *)0);
}
*/
/* strstr():
* Find the first occurrence of find in s.
*/
char *
strstr(register char *s, register char *find)
{
register char c, sc;
register int len;
if ((c = *find++) != 0) {
len = strlen(find);
do {
do {
if ((sc = *s++) == 0)
return ((char *)0);
} while (sc != c);
} while (strncmp(s, find, len) != 0);
s--;
}
return ((char *)s);
}
/* strcmp():
* Compare strings: s1>s2: >0 s1==s2: 0 s1s2; >0 s1==s2; 0 s1= 0 && *s1 == *s2++)
if(*s1++ == '\0')
return(0);
return((n < 0)? 0: (*s1 - *--s2));
}
/* strncpy():
* Copy s2 to s1, truncating or null-padding to always copy n bytes
* return s1
*/
char *
strncpy(register char *s1,register char *s2,register int n)
{
register char *os1 = s1;
while (--n >= 0)
if ((*s1++ = *s2++) == '\0')
while (--n >= 0)
*s1++ = '\0';
return (os1);
}
/* strpbrk():
* Return ptr to first occurance of any character from `brkset'
* in the character string `string'; NULL if none exists.
*/
char *
strpbrk(register char *string,register char *brkset)
{
register char *p;
do {
for(p=brkset; *p != '\0' && *p != *string; ++p)
;
if(*p != '\0')
return(string);
}
while(*string++);
return((char *)0);
}
/* strrchr():
* Return the ptr in sp at which the character c last
* appears; NULL if not found
*/
char *
strrchr(register char *sp, register char c)
{
register char *r;
r = (char *)0;
do {
if(*sp == c)
r = sp;
} while(*sp++);
return(r);
}
/* strspn():
* Return the number of characters in the maximum leading segment
* of string which consists solely of characters from charset.
*/
int
strspn(char *string,register char *charset)
{
register char *p, *q;
for(q=string; *q != '\0'; ++q) {
for(p=charset; *p != '\0' && *p != *q; ++p)
;
if(*p == '\0')
break;
}
return(q-string);
}
/* strtok():
* uses strpbrk and strspn to break string into tokens on
* sequentially subsequent calls. returns NULL when no
* non-separator characters remain.
* `subsequent' calls are calls with first argument NULL.
*/
char *
strtok(char *string,char *sepset)
{
register char *p, *q, *r;
static char *savept;
/*first or subsequent call*/
p = (string == (char *)0)? savept: string;
if(p == 0) /* return if no tokens remaining */
return((char *)0);
q = p + strspn(p, sepset); /* skip leading separators */
if(*q == '\0') /* return if no tokens remaining */
return((char *)0);
if((r = strpbrk(q, sepset)) == (char *)0) /* move past token */
savept = 0; /* indicate this is last token */
else {
*r = '\0';
savept = ++r;
}
return(q);
}
#define DIGIT(x) (isdigit(x) ? (x) - '0' : \
islower(x) ? (x) + 10 - 'a' : (x) + 10 - 'A')
#define MBASE ('z' - 'a' + 1 + 10)
long
strtol(register char *str,char **ptr,register int base)
{
register long val;
register int c;
int xx, neg = 0;
if (ptr != (char **)0)
*ptr = str; /* in case no number is formed */
if (base < 0 || base > MBASE)
return (0); /* base is invalid -- should be a fatal error */
if (!isalnum((c = *str))) {
while (isspace(c))
c = *++str;
switch (c) {
case '-':
neg++;
case '+': /* fall-through */
c = *++str;
}
}
if (base == 0) {
if (c != '0')
base = 10;
else if (str[1] == 'x' || str[1] == 'X')
base = 16;
else
base = 8;
}
/*
* for any base > 10, the digits incrementally following
* 9 are assumed to be "abc...z" or "ABC...Z"
*/
if (!isalnum(c) || (xx = DIGIT(c)) >= base)
return (0); /* no number formed */
if (base == 16 && c == '0' && isxdigit(str[2]) &&
(str[1] == 'x' || str[1] == 'X'))
c = *(str += 2); /* skip over leading "0x" or "0X" */
for (val = -DIGIT(c); isalnum((c = *++str)) && (xx = DIGIT(c)) < base; )
/* accumulate neg avoids surprises near MAXLONG */
val = base * val - xx;
if (ptr != (char **)0)
*ptr = str;
return (neg ? val : -val);
}
unsigned long
strtoul(char *str, char **ptr,int base)
{
long val;
val = strtol(str, ptr, base);
return((unsigned long)val);
}
#if 0
/* tolower():
* If arg is upper-case, return the lower-case, else return the arg.
*/
int
tolower(register int c)
{
if(c >= 'A' && c <= 'Z')
c -= 'A' - 'a';
return(c);
}
/* toupper():
* If arg is lower-case, return upper-case, otherwise return arg.
*/
int
toupper(register int c)
{
if(c >= 'a' && c <= 'z')
c += 'A' - 'a';
return(c);
}
#endif
/* strtolower():
* In-place modification of a string to be all lower case.
*/
char *
strtolower(char *string)
{
char *cp;
cp = string;
while(*cp) {
*cp = tolower(*cp);
cp++;
}
return(string);
}
/* strtoupper():
* In-place modification of a string to be all upper case.
*/
char *
strtoupper(char *string)
{
char *cp;
cp = string;
while(*cp) {
*cp = toupper(*cp);
cp++;
}
return(string);
}
ushort
swap2(ushort sval_in)
{
uchar *cp_in, *cp_out;
ushort sval_out;
cp_in = (uchar *)&sval_in;
cp_out = (uchar *)&sval_out;
cp_out[0] = cp_in[1];
cp_out[1] = cp_in[0];
return(sval_out);
}
ulong
swap4(ulong sval_in)
{
uchar *cp_in, *cp_out;
ulong sval_out;
cp_in = (uchar *)&sval_in;
cp_out = (uchar *)&sval_out;
cp_out[0] = cp_in[3];
cp_out[1] = cp_in[2];
cp_out[2] = cp_in[1];
cp_out[3] = cp_in[0];
return(sval_out);
}
/* Variables used by getopt: */
int optind; /* argv index to first cmd line arg that is not part
* of the option list.
*/
char *optarg; /* pointer to argument associated with an option */
int sp;
int
getopt(int argc,char *argv[],char *opts)
{
register int c;
register char *cp;
if(sp == 1) {
if (optind >= argc)
return(-1);
else if (argv[optind][0] != '-')
return(-1);
else if (argv[optind][1] == '\0')
return(-1);
else if(strcmp(argv[optind], "--") == 0) {
optind++;
return(-1);
}
}
c = argv[optind][sp];
if(c == ':' || (cp=strchr(opts, c)) == 0) {
printf("Illegal option: %c\n",c);
if(argv[optind][++sp] == '\0') {
optind++;
sp = 1;
}
return('?');
}
if(*++cp == ':') {
if(argv[optind][sp+1] != '\0')
optarg = &argv[optind++][sp+1];
else if(++optind >= argc) {
printf("Option requires argument: %c\n",c);
sp = 1;
return('?');
} else
optarg = argv[optind++];
sp = 1;
} else {
if(argv[optind][++sp] == '\0') {
sp = 1;
optind++;
}
optarg = 0;
}
return(c);
}
/* getoptinit():
* Since getopt() can be used by every command in the monitor
* it's variables must be reinitialized prior to each command
* executed through docommand()...
*/
void
getoptinit(void)
{
sp = 1;
optind = 1;
}
/* crc32tab[]:
* Used for calculating a 32-bit CRC.
*/
unsigned long crc32tab[] = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
ulong
crc32(uchar *buffer,ulong nbytes)
{
int temp;
unsigned long crc_rslt;
crc_rslt = 0xffffffff;
while(nbytes) {
temp = (crc_rslt ^ *buffer++) & 0x000000FFL;
crc_rslt = ((crc_rslt >> 8) & 0x00FFFFFFL) ^ crc32tab[temp];
nbytes--;
#ifdef WATCHDOG_MACRO
WATCHDOG_MACRO();
#endif
}
return(~crc_rslt);
}
/* CRC-CCITT crc16 used primarily by Xmodem...
*/
ushort xcrc16tab[] = {
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};
ushort
xcrc16(uchar *buffer,ulong nbytes)
{
ulong i;
ushort crc;
crc = 0;
for(i=0;i>8) ^ buffer[i]];
#ifdef WATCHDOG_MACRO
WATCHDOG_MACRO();
#endif
}
return(crc);
}
void
initUsrLvl(int lvl)
{
extgetUsrLvl = 0;
UserLevel = lvl;
}
/* getUsrLvl():
* This is the ONLY point of access for retrieval of the user level.
* This allows the application to redefine how the monitor retrieves
* what it thinks of as the user level.
*/
int
getUsrLvl(void)
{
if (extgetUsrLvl)
return(extgetUsrLvl());
return(UserLevel);
}
int
setUsrLvl(int level, char *password)
{
int olvl;
olvl = UserLevel;
/* If level is -1, then assume this is only a request for the current */
/* user level. If the incoming level is any other value outside the */
/* range of MINUSRLEVEL and MAXUSRLEVEL, return -1. */
if (level == -1)
return(UserLevel);
if ((level > MAXUSRLEVEL) || (level < MINUSRLEVEL))
return(olvl);
/* If password pointer is NULL, then don't check for password, just set */
/* the level and be done. */
if (!password) {
UserLevel = level;
}
else {
if (validPassword(password,level))
UserLevel = level;
}
return(olvl);
}
/* returnMaxUsrLvl(), setTmpMaxUsrLvl() & clrTmpMaxUsrLvl():
* These three functions are used to allow a few places in the monitor
* to temporarily force the user level to MAXUSRLEVEL. This is necessary
* for accessing the password file and the tfs log file.
* Call setTmpMaxUsrLvl() to enable MAX mode and then clrTmpMaxUsrLvl()
* with the value returned by setTmpMaxUsrLvl() when done.
*/
int
returnMaxUsrLvl(void)
{
return(MAXUSRLEVEL);
}
void *
setTmpMaxUsrLvl()
{
void *fptr;
fptr = (void *)extgetUsrLvl;
extgetUsrLvl = returnMaxUsrLvl;
return(fptr);
}
void
clrTmpMaxUsrLvl(int (*fptr)())
{
extgetUsrLvl = fptr;
}
char *VersionHelp[] = {
"Version information",
"[application_info]",
0,
};