home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Crawly Crypt Collection 2
/
crawlyvol2.bin
/
program
/
c
/
berm122s
/
utextra.c
< prev
next >
Wrap
C/C++ Source or Header
|
1993-08-16
|
15KB
|
692 lines
/*******************************************************************
* UTEXTRA.C *
* *
* This file contains misc. functions needed for the BERMUDA *
* software. See LICENSE for information about distribution. *
* *
* Written by Jac Kersing *
*******************************************************************/
/*
#pragma warn -par
#pragma warn -sus
*/
#define MAILER /* VP */
#include "pandora.h"
#if TC
#include <dir.h>
#include <dos.h>
#include <sys\stat.h>
#endif
#if UNIX
#include <sys/dir.h>
#include <time.h>
#endif
#if STTC
#include <ext.h>
#include <tos.h>
#endif
#if BWIN32
#include <process.h>
#include <time.h>
#include <io.h>
#endif
#define __PROTO__ 1
#include "utextra.pro"
extern int loglevel;
extern FILE *log; /* used for logging */
#define LP *(unsigned long *)
#define IP (unsigned long)*(unsigned int *)
void setstamp(name,buf) char *name,*buf;
{
#if MEGAMAX
int f;
if((f=Fopen(name,2))<0) return;
Fdatime(f,buf,1);
Fclose(f);
#endif
}
#ifdef LINN
static void conv(getal,p,base,unsign,low) /* Local function of doprint */
int low;
#else
static void conv(getal,p,base,unsign) /* Local function of doprint */
#endif
unsigned long getal; /* convert number to ascii */
char *p;
int base;
int unsign;
{
char buf[10], *t = &buf[9], sign=getal&0x80000000L && !unsign;
char ch;
*t = 0;
if (sign) getal = -((long)getal);
do {
ch=(char)(getal % base);
#ifdef LINN
*--t = (ch < 10) ? ch+'0' : ch-10+(low?'a':'A');
#else
*--t = (ch < 10) ? ch+'0' : ch-10+'A';
#endif
getal /= base;
}
while (getal);
if (sign) *--t='-';
strcpy(p,t);
}
char *mon[12] =
{
"Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec"
};
static void cdecl iprint(outp,fmt,arg) /* needed for internal print */
#if __PROTO__
void (*outp)(char);
#else
void (*outp)();
#endif
char *fmt, *arg;
{
doprint(outp, fmt, &arg);
}
void cdecl doprint(outp,fmt,arg) /* Print internal format */
#if __PROTO__
void (*outp)(char);
#else
void (*outp)();
#endif
char *fmt, *arg;
{
register int width, precision, uselong;
register char *p,*pos,left,dot,pad;
char buf[128];
struct date d;
struct time t;
getdate(&d);
gettime(&t);
p = fmt-1;
while (*++p) {
if (*p=='%') {
p++;
uselong=width=precision=0;
pad = ' ';
if (*p=='%') { (*outp)('%'); continue; }
left = *p=='-';
if ( left ) p++;
if ( *p=='0' ) pad='0';
while ( isdigit(*p) ) width = width * 10 + *p++ - '0';
dot = *p=='.';
if ( dot ) {
p++;
while ( isdigit(*p) ) precision = precision * 10 + *p++ - '0';
}
uselong= *p=='l';
if ( uselong ) p++;
switch (*p) {
case 'D' : uselong++;
case 'd' : conv( uselong ? *(long *)arg : (long)*(int *)arg, buf, 10, 0, 0);
arg += uselong ? sizeof(long) : sizeof(int);
break;
case 'U' : uselong++;
case 'u' : conv( uselong ? LP arg : IP arg, buf, 10, 1, 0);
arg += uselong ? sizeof(long) : sizeof(int);
break;
case 'X' : uselong++;
case 'x' : conv( uselong ? LP arg : IP arg, buf, 0x10, 1, 0);
arg += uselong ? sizeof(long) : sizeof(int);
break;
#ifdef LINN
/* Y is lowercase hexadecimal, for use while numbering outbound directory a la Binkley */
case 'Y' : uselong++;
case 'y' : conv( uselong ? LP arg : IP arg, buf, 0x10, 1, 1);
arg += uselong ? sizeof(long) : sizeof(int);
break;
#endif
case 'O' : uselong++;
case 'o' : conv( uselong ? LP arg : IP arg, buf, 8, 1, 0);
arg += uselong ? sizeof(long) : sizeof(int);
break;
case 'Z' : uselong++;
case 'z' : conv( uselong ? LP arg : IP arg, buf, 36, 1, 0);
arg += uselong ? sizeof(long) : sizeof(int);
break;
case 'c' : buf[0] = *(int *)arg;
buf[1] = 0;
arg += sizeof(int); /* Char on stack == int */
break;
case 's' : strncpy(buf,*(char **)arg,127);
buf[127]=0;
arg += sizeof(char *);
if (dot) buf[precision] = 0;
break;
}
width -= (int)strlen(buf);
if (!left) while (width-->0) (*outp)(pad); /* left padding */
pos=buf;
while (*pos) (*outp)( *pos++ ); /* buffer */
if (left) while (width-->0) (*outp)(pad); /* right padding */
continue;
}
if (*p=='$')
switch (*++p) {
case '$' : (*outp)('$'); break;
case 't' : iprint(outp, "%02d:%02d:%02d", t.ti_hour, t.ti_min, t.ti_sec); break;
case 'd' : iprint(outp, "%02d-%02d-%02d", d.da_day, d.da_mon, d.da_year-1900); break;
case 'D' : iprint(outp, "%02d", d.da_day); break;
case 'm' : iprint(outp, "%03s", mon[d.da_mon-1]); break;
#ifdef LINN /* some more options used in pack.c */
case 'T' : iprint(outp, "%02d:%02d", t.ti_hour, t.ti_min); break;
case 'y' : iprint(outp, "%02d", d.da_year); break;
#endif
}
else (*outp)(*p);
}
}
static char *prtstr[2]; /* Must be array: Time/Date! */
static int prtcnt = -1; /* points to current buffer */
static void putSTR(c) /* Append char to string */
char c;
{
*prtstr[prtcnt]++ = c;
}
void cdecl fmprint(buf,fmt,args) /* print format to string */
char *buf, *fmt, *args;
{
prtstr[++prtcnt] = buf;
doprint(putSTR, fmt, args);
*prtstr[prtcnt--] = 0; /* add string terminator */
}
void cdecl sprint(buf,fmt,args) /* print format to string */
char *buf, *fmt, *args;
{
prtstr[++prtcnt] = buf;
doprint(putSTR, fmt, &args);
*prtstr[prtcnt--] = 0; /* add string terminator */
}
extern char progname[];
void cdecl message(level,fmt,arg) /* display a message to screen */
int level; /* and to logfile */
char *fmt, *arg;
{
char buf[255];
sprint(buf,"%c $D $m $t %3.3s ", *fmt,progname);
fmprint(&buf[strlen(buf)], &fmt[1], &arg);
if (level>=loglevel && log)
{
fprintf(log, "%s\n", buf);
fflush(log);
}
print("%s\n",buf);
}
void cdecl clprint(fmt,arg)
char *fmt, *arg;
{
char buf[255];
fmprint(buf, fmt, &arg);
if (loglevel<1 && log)
{
fprintf(log, "%s", buf);
fflush(log);
}
print("%s",buf);
}
void cdecl print(fmt, args)
char *fmt, *args;
{
#if MEGAMAX | MWC
char buffer[255];
fmprint(buffer, fmt, &args);
fprintf(stdout,"%s", buffer);
fflush(stdout);
#endif
#if TC | STTC | UNIX | BWIN32
vprintf(fmt, &args);
#endif
}
static char fname[20]; /* name of the file found by ffirst, fnext */
#if MEGAMAX | MWC
static char tdta[80];
#endif
#if TC | STTC
static struct ffblk FF;
#endif
#if BWIN32
static struct _finddata_t FF;
static long win32fh;
#endif
#if UNIX
/* from Ben Stuyts's port of Binkley */
char curr_filename[256],
curr_pathname[256];
DIR *dirp = NULL;
#define FILENAMELEN 13
void unixize(char *dos, char *un)
{
char *s, *d, ch;
s = dos; /* source */
d = un; /* dest */
while(*s) {
ch = *s++;
switch(ch) {
case '\\':
*d++ = '/'; /* first change all \ into / */
break;
case '?':
*d++ = '.'; /* any char as ? */
break;
case '.':
*d++ = '\\'; /* dot as \. */
*d++ = '.';
break;
case '*':
*d++ = '.'; /* any seq of char as .* */
*d++ = '*';
break;
default:
if (isalpha(ch)) {
/* we do pattern matching case insensitive */
*d++ = '[';
*d++ = toupper (ch);
*d++ = tolower (ch);
*d++ = ']';
} else
*d++ = ch;
break;
}
}
*d++ = '$'; /* end of line marker */
*d = '\0';
}
void splitpath(char *path, char *file, char *dir)
{
char *pos;
file[0] = '\0';
dir[0] = '\0';
pos = rindex(path, '/');
if (pos == 0)
strcpy(file, path);
else {
*pos = '\0';
strcpy(dir, path);
pos++;
strcpy(file, pos);
}
}
/* checkfile returns TRUE when filename is correct */
int checkfile(struct direct *dp)
{
char name[20];
int res;
#ifdef RE_BSD
re_comp(curr_filename);
#endif
if(dp->d_namlen > FILENAMELEN)
res = 0;
else {
strncpy(name, dp->d_name, dp->d_namlen);
name[dp->d_namlen] = '\0';
#ifdef RE_BSD
res = re_exec(name);
#else
res = !recmp(curr_filename, name);
#endif
}
return res;
}
#endif /* unix */
char *ffirst(name)
char *name;
{
#if MEGAMAX | MWC
char *hisdta= (char *)Fgetdta(); /* file info stored here */
char *q,*p; /* used for copying */
char *temp;
Fsetdta(tdta);
if (Fsfirst(name,7)!=-33l)
{
p=fname;
for (q=(tdta+30);*q;) *p++=*q++;
*p='\0';
temp= fname;
}
else
temp= NULL;
Fsetdta(hisdta);
return temp;
#endif
#if TC | STTC
if (findfirst(name, &FF, 0x27)==0)
{
strcpy(fname, FF.ff_name);
return fname;
}
return NULL;
#endif
#if UNIX
char un[256];
struct direct *dp;
unixize(name, un);
splitpath(name, un, curr_pathname);
unixize (un, curr_filename);
if(dirp)
closedir(dirp); /* cleanup for previous usage */
dirp = opendir(curr_pathname);
if (!dirp)
return NULL;
for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
if (checkfile(dp))
return dp->d_name;
closedir(dirp);
dirp = NULL;
return NULL;
#endif
#if BWIN32
if ((win32fh=_findfirst(name, &FF))>=0)
{
strcpy(fname, FF.name);
return fname;
}
return NULL;
#endif
}
char *fnext()
{
#if MEGAMAX | MWC
char *hisdta= (char *)Fgetdta(); /* file info stored here */
char *q,*p; /* used for copying */
char *temp;
Fsetdta(tdta);
if (Fsnext()==0l)
{
p=fname;
for (q=(tdta+30);*q;) *p++=*q++;
*p='\0';
temp= fname;
}
else
temp= NULL;
Fsetdta(hisdta);
return temp;
#endif
#if TC | STTC
if (findnext(&FF)==0)
{
strcpy(fname, FF.ff_name);
return fname;
}
return NULL;
#endif
#if UNIX
struct direct *dp;
if(!dirp)
return NULL;
for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
if (checkfile(dp))
return dp->d_name;
closedir(dirp);
dirp = NULL;
return NULL;
#endif
#if BWIN32
if(win32fh<0)
return NULL;
if (_findnext(win32fh,&FF)==0)
{
strcpy(fname, FF.name);
return fname;
}
_findclose(win32fh);
return NULL;
#endif
}
static char *suffixes[8] = {
"SU", "MO", "TU", "WE", "TH", "FR", "SA", NULL
};
#if MEGAMAX || MSTRUPR
char *strupr(str)
char *str;
{
char *p=str;
while (*p)
{
if (isalpha(*p)) *p=toupper(*p);
++p;
}
return str;
}
#endif
#if MSTRDUP
char *strdup (char *s)
{
char *t;
t=malloc (strlen(s)+1);
if (t != NULL)
strcpy (t, s);
return t;
}
#endif
#if UNIX | BWIN32
void getdate (struct date *date)
{
struct tm *tim;
time_t ze_time;
time (&ze_time);
tim = localtime (&ze_time);
date->da_year = tim->tm_year;
date->da_day = tim->tm_mday;
date->da_mon = tim->tm_mon+1;
}
void gettime (struct time *timee)
{
struct tm *tim;
time_t ze_time;
time (&ze_time);
tim = localtime (&ze_time);
timee->ti_min = tim->tm_min;
timee->ti_hour = tim->tm_hour;
timee->ti_hund = 0;
timee->ti_sec = tim->tm_sec;
}
#endif
int is_arcmail (p, n)
char *p;
int n;
{
int i;
char c[128];
if (!isdigit (p[n]))
{
return (0);
}
strcpy (c, p);
strupr (c);
for (i = n - 11; i < n - 3; i++)
{
if ((!isdigit(c[i])) && ((c[i] > 'F') || (c[i] < 'A')))
return(0);
}
for (i = 0; i < 7; i++)
{
if (strnicmp (&c[n-2], suffixes[i], 2) == 0)
break;
}
if (i >= 7)
{
return(0);
}
return (1);
}
int execute(prg,cmd)
char *prg, *cmd;
{
#if TC | BWIN32
char *arg[20], *p;
int i;
#endif
long result;
#if MEGAMAX
extern char *xenvistr;
result= Pexec(0,prg,cmd,xenvistr);
if (result < -30L)
#endif
#if MWC | STTC
extern char *environ;
result= Pexec(0,prg,cmd,environ);
if (result < -30L)
#endif
#if TC | BWIN32
i=2;
arg[0]=prg;
arg[1]=&cmd[1];
for (p=&cmd[1]; *p; p++)
if (isspace(*p))
{
*p='\0';
arg[i++]=p+1;
while (isspace( *(p+1) )) p++;
}
arg[i]=NULL;
result = spawnv(0, prg, arg);
if (result)
#endif
#if UNIX
char tot[200];
sprintf (tot, "%s %s", prg, cmd+1); /* skip length of command */
result = system(tot);
if (result)
#endif
{
message(6,"!Program %s not found!", prg);
}
return (int)result;
}
int weekday(d) struct date *d;
{
unsigned long df1;
unsigned long day, month, year;
day=d->da_day;
month=d->da_mon;
year=d->da_year;
df1= 365l*year + 31L * (month-1) + day + 1;
if (month>2)
{
df1 -= (4 * month + 23 ) / 10;
++year;
}
df1 += (year-1)/4;
df1 -= ( 3 * ((year-1) / 100) + 1 ) / 4; /* friday == 1 */
df1 += 4;
return (int) (df1%7);
}
unsigned int ztoi(str,len)
char *str;
int len;
{
unsigned int temp;
temp=0;
while (*str && len-- && isalnum(*str))
{
temp *= 36;
temp += isdigit(*str) ? *str-'0' : toupper(*str)-'A'+10;
++str;
}
return temp;
}
int getadress(str, zone, net, node)
char *str;
int *net, *node, *zone;
{
*zone= ztoi(str,2);
*net = ztoi(str+2,3);
*node= ztoi(str+5,3);
return 0;
}
#if MC68000==1 /* changed from STTC vp */
unsigned inteli(x)
int x;
{
return ( ((x << 8) & 0xFF00) | ((x >> 8) & 0x00FF) );
}
#endif