ecuutil.c

一个通讯程序源码

/*+-----------------------------------------------------------------------
	ecuutil.c -- utility routines for extended calling unit
	[e-mail]


  Defined functions:
	arg_token(parsestr,termchars)
	ascii_name_to_hex(str3char)
	ascii_to_hex(ascii)
	build_arg_array(cmd,arg,arg_max_quan,narg_rtn)
	build_str_array(str,arg,str_max_quan,nstr_rtn)
	cfree(p,num,size)
	defeat_optimize_to_work_around_bug(would_be_optimized)
	disp_line_termio(fd,text)
	disp_stat(st)
	disp_termio(ttt,text)
	errno_text(err)
	find_shell_chars(command)
	get_curr_dir(cdir,cdir_max)
	get_home_dir(home_dir)
	hex_to_ascii_name(char_val)
	make_char_graphic(ch,incl_3char)
	make_ecu_subdir()
	mem_cpy(dest,src,len)
	mode_map(mode,mode_str)
	pad_zstr_to_len(zstr,len)
	perror_errmsg(str)
	rdchk(fd)
	skip_ld_break(zstr)
	str_classify(sc,str)
	str_token(parsestr,termchars)
	strip_trail_break(zstr)
	yes_or_no(strarg)

This module assumes the neo-standard 'mode_t' type is an unsigned
short and 'dev_t' is a short in accordance with tradition.  This
is, in fact, true with all the supported systems which have it as
of this writing.  This is just a test of the Brown Shirt Warning
System.  If this had been an actual Brown Shirt Alert, you would
have heard the noise of sickening thuds and breaking things nearby.

------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:09-10-1992-13:59-wht@n4hgf-ECU release 3.20 */
/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
/*:05-11-1992-16:42-wht@gyro-fix WORKING_SELECT nap once and for all */
/*:05-08-1992-02:42-wht@n4hgf-select-based Nap was buggy on EINTR */
/*:04-05-1992-15:31-wht@n4hgf-no more use of memmove in any environment */
/*:02-22-1992-16:19-wht@n4hgf-build arg/str array now handles zero tokens */
/*:11-26-1991-19:36-wht@n4hgf-add str_classify and yes_or_no uses it */
/*:09-01-1991-12:46-wht@n4hgf2-show sun flow control bit */
/*:08-30-1991-20:09-wht@n4hgf2-sun Nap was not returning a value */
/*:08-25-1991-14:39-wht@n4hgf-SVR4 port thanks to aega84!lh */
/*:08-17-1991-14:11-root@n4hgf-ascii_to_hex supports "csi" */
/*:08-13-1991-13:53-wht@n4hgf-UNIX and ISC nap() broken; XENIX still wins */
/*:07-25-1991-12:57-wht@n4hgf-ECU release 3.10 */
/*:04-16-1991-15:45-wht@n4hgf-gcc cannot use memmove */
/*:03-18-1991-22:31-wht@n4hgf-ISC 2.2 has mkdir() */
/*:02-03-1991-14:23-wht@n4hgf-hack workaround for get_home_dir under x286 */
/*:01-25-1991-16:23-wht@n4hgf-source name wrong in headers */
/*:12-26-1990-14:32-wht@n4hgf-use memmove or Duff's Device in mem_cpy() */
/*:12-04-1990-00:58-wht@n4hgf-allow alternating between str/arg_token */
/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */

#include "ecu.h"
#include "termecu.h"
#include "ecufork.h"
#include "ecukey.h"
#include "ecu_pwd.h"

#if defined(sun)
#undef ECHO
#undef NL0
#undef NL1
#undef TAB0
#undef TAB1
#undef TAB2
#undef XTABS
#undef CR0
#undef CR1
#undef CR2
#undef CR3
#undef FF0
#undef FF1
#undef BS0
#undef BS1
#undef TOSTOP
#undef FLUSHO
#undef PENDIN
#undef NOFLSH
#include <sys/ioctl.h>
#endif

#if defined(SVR4)
# include <sys/termiox.h>
extern int hx_flag;
#endif

char *getenv();

extern int errno;
extern char curr_dir[CURR_DIRSIZ];

char *str_token_static = (char *)0;

char *ascii_ctlstr =
"NULSOHSTXETXEOTENQACKBELBS HT NL VT FF CR SO SI DLEDC1DC2DC3DC4NAKSYNETBCANEM SUBESCFS GS RS US SP ";

/*+-------------------------------------------------------------------------
	mem_cpy(dest,src,len) - memcpy() with non-destructive overlapping copy

  use Duff's device for speed if memmove not available
--------------------------------------------------------------------------*/
void
mem_cpy(dest,src,len)
register char *dest;
register char *src;
register len;
{
#if 0 /* defined(M_UNIX) && !defined(DUFF)*/ /*  && !defined(__GNUC__) */
	/*
	 * memmove() clobbers regs that GCC wants to keep
	 * unless you use -fcall-save-bx
	 */
	memmove(dest,src,len);
#else
	/*
	 * for systems without memmove or with compiler that cannot use it
	 */

	register itmp = (len + 7) / 8;
	if(dest > src)
	{
		dest += len;
		src += len;
		switch(len % 8)
		{
		case 0:	do{	*--dest = *--src;
		case 7:		*--dest = *--src;
		case 6:		*--dest = *--src;
		case 5:		*--dest = *--src;
		case 4:		*--dest = *--src;
		case 3:		*--dest = *--src;
		case 2:		*--dest = *--src;
		case 1:		*--dest = *--src;
			 	}while(--itmp > 0);
		}
	}
	else
	{
		switch(len % 8)
		{
		case 0:	do{	*dest++ = *src++;
		case 7:		*dest++ = *src++;
		case 6:		*dest++ = *src++;
		case 5:		*dest++ = *src++;
		case 4:		*dest++ = *src++;
		case 3:		*dest++ = *src++;
		case 2:		*dest++ = *src++;
		case 1:		*dest++ = *src++;
			 	}while(--itmp > 0);
		}
	}
#endif
}	/* end of mem_cpy */

/*+-------------------------------------------------------------------------
	skip_ld_break(zstr) - skip leading spaces and tabs
--------------------------------------------------------------------------*/
char *
skip_ld_break(zstr)
register char *zstr;
{
	while(isspace(*zstr))
		zstr++;
	return(zstr);
}	/* end of skip_ld_break */

/*+-------------------------------------------------------------------------
	strip_trail_break(zstr) - strip leading spaces and tabs
--------------------------------------------------------------------------*/
void
strip_trail_break(zstr)
char *zstr;
{
	register int itmp = strlen(zstr);
	register char *zptr = zstr + itmp - 1;

	while(itmp && isspace(*zptr))
	{
		*zptr-- = 0;
		itmp--;
	}
}	/* end of strip_trail_break */

/*+-----------------------------------------------------------------------
	pad_zstr_to_len(zstr,len)

  pads with spaces to specified length, unless already longer than
  len in which case the string is truncated to 'len' characters.
------------------------------------------------------------------------*/
void
pad_zstr_to_len(zstr,len)
char *zstr;
int len;
{
	register izstr;

	izstr = strlen(zstr);
	if(izstr >= len)
		zstr[len] = 0;
	else
	{
		while(izstr < len)
			zstr[izstr++] = 0x20;
		zstr[izstr] = 0;
	}
}	/* end of pad_zstr_to_len */

/*+-----------------------------------------------------------------------
	arg_token(parsestr,termchars)

Get next token from string parsestr ((char *)0 on 2nd, 3rd, etc.
calls), where tokens are nonempty strings separated by runs of chars
from termchars.  Writes nulls into parsestr to end tokens.
termchars need not remain constant from call to call.

Treats multiple occurrences of a termchar as one delimiter (does not
allow null fields).
------------------------------------------------------------------------*/
char *
arg_token(parsestr,termchars)
char *parsestr;
char *termchars;
{
	register char *parseptr;
	char *token;

	if(!parsestr && !str_token_static)
		return((char *)0);

	if(parsestr)
	{
		str_token_static = (char *)0;
		parseptr = parsestr;
	}
	else
       parseptr = str_token_static;

	while(*parseptr)
	{
		if(!strchr(termchars,*parseptr))
			break;
		parseptr++;
	}

	if(!*parseptr)
	{
		str_token_static = (char *)0;
		return((char *)0);
	}

	token = parseptr;

	/*
	 * tokens beginning with apostrophe or quotes kept together
	 */
	if(*token == '\'')
	{
		token++;
		parseptr++;
		while(*parseptr)
		{
			if(*parseptr == '\'')
			{
				str_token_static = parseptr + 1;
				*parseptr = 0;
				return(token);
			}
			parseptr++;
		}
		str_token_static = (char *)0;
		return(token);
	}
	else if(*token == '"')
	{
		token++;
		parseptr++;
		while(*parseptr)
		{
			if(*parseptr == '"')
			{
				str_token_static = parseptr + 1;
				*parseptr = 0;
				return(token);
			}
			parseptr++;
		}
		str_token_static = (char *)0;
		return(token);
	}

	while(*parseptr)
	{
		if(strchr(termchars,*parseptr))
		{
			*parseptr = 0;
			str_token_static = parseptr + 1;
			while(*str_token_static)
			{
				if(!strchr(termchars,*str_token_static))
					break;
				str_token_static++;
			}
			return(token);
		}
		parseptr++;
	}
	str_token_static = (char *)0;
	return(token);
}	/* end of arg_token */

/*+-------------------------------------------------------------------------
	build_arg_array(cmd,arg,arg_max_quan,&narg)
--------------------------------------------------------------------------*/
void
build_arg_array(cmd,arg,arg_max_quan,narg_rtn)
char *cmd;
char **arg;
int arg_max_quan;
int *narg_rtn;
{
	register narg;

	str_token_static = (char *)0;
	memset((char *)arg,0,sizeof(char *) * arg_max_quan);
	if(!(arg[0] = arg_token(cmd," \t\r\n")))
	{
		*narg_rtn = 0;
		return;
	}

	for(narg = 1; narg < arg_max_quan; ++narg)
	{
		if(!(arg[narg] = arg_token((char *)0," \t\r\n"))) 
			break;
	}

	*narg_rtn = narg;

}	/* end of build_arg_array */

/*+-----------------------------------------------------------------------
	str_token(parsestr,termchars)

Get next token from string parsestr ((char *)0 on 2nd, 3rd, etc.
calls), where tokens are nonempty strings separated by runs of chars
from termchars.  Writes nulls into parsestr to end tokens.
termchars need not remain constant from call to call.

Treats each occurrence of a termchar as delimiter (allows null
fields).
------------------------------------------------------------------------*/
char *
str_token(parsestr,termchars)
char *parsestr;
char *termchars;
{
	register char *termptr;
	register char *parseptr;
	char *token;

	if(!parsestr && !str_token_static)
		return((char *)0);

	if(parsestr)
	{
		str_token_static = (char *)0;
		parseptr = parsestr;
	}
	else
       parseptr = str_token_static;

	while(*parseptr)
	{
		for(termptr = termchars; *termptr != 0; termptr++)
		{
			if(*parseptr == *termptr)
				goto FOUND_TERM;
		}
		if(!*termptr)
			break;
		parseptr++;
	}

	if(!*parseptr)
	{
		str_token_static = (char *)0;
		return((char *)0);
	}

FOUND_TERM:
	token = parseptr;
	while(*parseptr)
	{
		for(termptr = termchars; *termptr;)
		{
			if(*parseptr == *termptr++)
			{
				str_token_static = parseptr + 1;
				*parseptr = 0;
				return(token);
			}
		}
		parseptr++;
	}
	str_token_static = (char *)0;
	return(token);
}	/* end of str_token */

/*+-------------------------------------------------------------------------
	build_str_array(str,arg,arg_max_quan,&narg)
--------------------------------------------------------------------------*/
void
build_str_array(str,arg,arg_max_quan,narg_rtn)
char *str;
char **arg;
int arg_max_quan;
int *narg_rtn;
{
	register narg;

	str_token_static = (char *)0;
	memset((char *)arg,0,sizeof(char *) * arg_max_quan);
	if(!(arg[0] = str_token(str," \t\r\n")))
	{
		*narg_rtn = 0;
		return;
	}

	for(narg = 1; narg < arg_max_quan; ++narg)
	{
		if(!(arg[narg] = str_token((char *)0," \t\r\n"))) 
			break;
	}

	*narg_rtn = narg;

}	/* end of build_str_array */

/*+-----------------------------------------------------------------------
	make_char_graphic(character,incl_3char) - Make all chars "printable"

  returns pointer to a static string containing printable version
  of a character.  If control char, printed as "^A", etc.
  if incl_3char set true, then space + ASCII assignment (e.g. "NUL") is
  appended to the string for non-printable graphics
------------------------------------------------------------------------*/
char *
make_char_graphic(ch,incl_3char)
register char ch;
int incl_3char;
{
	static char gg[16];

	ch &= 0x7F;
	if((ch >= 0x20) && (ch < 0x7F))
	{
		gg[0] = ch; gg[1] = 0;
	}
	else
	{
		gg[0] = '^'; 
		if(ch == 0x7F)
		{
			gg[1] = '?';
			if(incl_3char)
				strcpy(&gg[2]," DEL");
			else
				gg[2] = 0;
		}
		else
		{
			gg[1] = ch + 0x40;
			if(incl_3char)
			{
				gg[2] = 0x20;
				strncpy(&gg[3],ascii_ctlstr + (ch * 3),3);
				gg[7] = 0;
			}
			else
				gg[2] = 0;
		}
	}
	return(gg);
}	/* end of make_char_graphic */

/*+-----------------------------------------------------------------------
	mode_map(mode,mode_str)	build drwxrwxrwx string
------------------------------------------------------------------------*/
char *
mode_map(mode,mode_str)
unsigned short mode;
char *mode_str;
{
	register unsigned ftype = mode & S_IFMT;
	register char *rtn;
	static char result[12];

	rtn = (mode_str == (char *)0) ? result : mode_str;

	/*               drwxrwxrwx */
	/*               0123456789 */
	strcpy(rtn,"----------");

	switch(ftype)
	{
		case S_IFIFO:	*rtn = 'p'; break; /* FIFO (named pipe) */
		case S_IFDIR:	*rtn = 'd'; break; /* directory */
		case S_IFCHR:	*rtn = 'c'; break; /* character special */
		case S_IFBLK:	*rtn = 'b'; break; /* block special */
		case S_IFREG:	*rtn = '-'; break; /* regular */

#if defined(S_IFLNK)
		case S_IFLNK:	*rtn = 'l'; break; /* symbolic link */
#endif
#if defined(S_IFSOCK)
		case S_IFSOCK:	*rtn = 's'; break; /* socket */
#endif

#if defined(S_IFNAM)
		case S_IFNAM:						/* name space entry */
#if defined(S_IFNAM)
			if(mode & S_INSEM)				/* semaphore */
			{
				*rtn = 's';
				break;
			}
#endif