ecuutil.c

一个通讯程序源码

#if defined(S_INSHD)
			if(mode & S_INSHD)				/* shared memory */
			{
				*rtn = 'm';
				break;
			}
			break;
#endif
#endif

		default:		*rtn = '?'; break;	/* ??? */
	}

	if(mode & 000400) *(rtn + 1) = 'r';
	if(mode & 000200) *(rtn + 2) = 'w';
	if(mode & 000100) *(rtn + 3) = 'x';
	if(mode & 004000) *(rtn + 3) = 's';
	if(mode & 000040) *(rtn + 4) = 'r';
	if(mode & 000020) *(rtn + 5) = 'w';
	if(mode & 000010) *(rtn + 6) = 'x';
	if(mode & 002000) *(rtn + 6) = 's';
	if(mode & 000004) *(rtn + 7) = 'r';
	if(mode & 000002) *(rtn + 8) = 'w';
	if(mode & 000001) *(rtn + 9) = 'x';
	if(mode & 001000) *(rtn + 9) = 't';

	return(rtn);

}	/* end of mode_map */

/*+-----------------------------------------------------------------------
	disp_termio(ttt)
  display termio 'ttt' on stderr
------------------------------------------------------------------------*/
void disp_termio(ttt,text)
struct termio *ttt;
char *text;
{
	register flag;
	register i_cc;
	register char *cptr;
	int dbits;
	char parity;

	pprintf("---------> %s\n",text);

	flag = ttt->c_iflag;
	pprintf(
"iflag: %07o IGNBRK:%d  BRKINT:%d  IGNPAR:%d  PARMRK:%d  INPCK:%d  ISTRIP:%d\n",
				flag,
				(flag & IGNBRK) ? 1 : 0,
				(flag & BRKINT) ? 1 : 0,
				(flag & IGNPAR) ? 1 : 0,
				(flag & PARMRK) ? 1 : 0,
				(flag & INPCK ) ? 1 : 0,
				(flag & ISTRIP) ? 1 : 0);
	pprintf("               INLCR:%d  IGNCR:%d  ICRNL:%d  IUCLC:%d  ",
				(flag & INLCR ) ? 1 : 0,
				(flag & IGNCR ) ? 1 : 0,
				(flag & ICRNL ) ? 1 : 0,
				(flag & IUCLC ) ? 1 : 0);
	pprintf("IXON:%d  IXANY:%d  IXOFF:%d\n",
				(flag & IXON  ) ? 1 : 0,
				(flag & IXANY ) ? 1 : 0,
				(flag & IXOFF ) ? 1 : 0);

	flag = ttt->c_oflag;
	pprintf("oflag: %07o OPOST:%d  OLCUC:%d  ONLCR:%d  OCRNL:%d  ",
				flag,
				(flag & OPOST ) ? 1 : 0,
				(flag & OLCUC ) ? 1 : 0,
				(flag & ONLCR ) ? 1 : 0,
				(flag & OCRNL ) ? 1 : 0);
	pprintf("ONOCR:%d  ONLRET:%d  OFDEL:%d\n",
				(flag & ONOCR ) ? 1 : 0,
				(flag & ONLRET) ? 1 : 0,
				(flag & OFDEL ) ? 1 : 0);

	flag = ttt->c_cflag;
	pprintf("cflag: %07o ",ttt->c_cflag);
	switch(flag & CBAUD)
	{
		case B0:	cptr = "HUP"; break;
		case B50:	cptr = "50"; break;
		case B75:	cptr = "75"; break;
		case B110:	cptr = "110"; break;
		case B134:	cptr = "134.5"; break;
		case B150:	cptr = "150"; break;
		case B200:	cptr = "200"; break;
		case B300:	cptr = "300"; break;
		case B600:	cptr = "600"; break;
		case B1200:	cptr = "1200"; break;
		case B1800:	cptr = "1800"; break;
		case B2400:	cptr = "2400"; break;
		case B4800:	cptr = "4800"; break;
		case B9600:	cptr = "9600"; break;
#if defined(B19200)
		case B19200:cptr = "19200"; break;
#endif
#if defined(B38400)
		case B38400:cptr = "38400"; break;
#endif
		default:	
			switch(flag & CBAUD)
			{
				case EXTA:	cptr = "EXTA"; break;
				case EXTB:	cptr = "EXTB"; break;
				default:	cptr = "????"; break;
			}
	}
	dbits = 5 + ((flag & CSIZE) >> 4);
	parity = (flag & PARENB) ? ((flag & PARODD) ? 'O' : 'E') : 'N';
	pprintf("%s-%d-%c-%d ",cptr,dbits,parity,(flag & CSTOPB) ? 2 : 1);
	switch(flag & CS8)
	{
		case CS8: pputs("CS8 "); break;
		case CS7: pputs("CS7 "); break;
		case CS6: pputs("CS6 "); break;
		case CS5: pputs("CS5 "); break;
	}
	pprintf("CREAD:%d  HUPCL:%d  CLOCAL:%d",
				(flag & CREAD ) ? 1 : 0,
				(flag & HUPCL ) ? 1 : 0,
				(flag & CLOCAL) ? 1 : 0);
#if defined(RTSFLOW) /* SCO */
	pprintf(" RTSFLOW:%d  CTSFLOW:%d",
				(flag & RTSFLOW ) ? 1 : 0,
				(flag & CTSFLOW ) ? 1 : 0);
#endif
#if defined(CRTSFL) /* SCO 3.2v4 */
	pprintf("\n               CRTSFL:%d",
				(flag & CRTSFL ) ? 1 : 0);
#endif
#if defined(RTSXOFF) /* SVR4 */
	pprintf(" RTSXOFF:%d  CTSXON:%d",
				(hx_flag & RTSXOFF ) ? 1 : 0,
				(hx_flag & CTSXON ) ? 1 : 0);
#endif
#ifdef CRTSCTS /* sun */
	pprintf(" CRTSCTS:%d",(flag & CRTSCTS) ? 1 : 0);
#endif
	pprintf("\n");

	flag = ttt->c_lflag;
	pprintf("lflag: %07o ISIG:%d  ICANON:%d  XCASE:%d  ECHO:%d  ECHOE:%d\n",
				flag,
				(flag & ISIG  ) ? 1 : 0,
				(flag & ICANON) ? 1 : 0,
				(flag & XCASE ) ? 1 : 0,
				(flag & ECHO  ) ? 1 : 0,
				(flag & ECHOE ) ? 1 : 0);
	pprintf("               ECHOK:%d  ECHONL:%d  NOFLSH:%d",
				(flag & ECHOK ) ? 1 : 0,
				(flag & ECHONL) ? 1 : 0,
				(flag & NOFLSH) ? 1 : 0);

#if defined(XCLUDE)
	pprintf("  XCLUDE:%d",(flag & XCLUDE) ? 1 : 0);
#endif
	pputs("\n");

	pprintf("ctl chars: ");
	for(i_cc = 0; i_cc < NCC; i_cc++)
		pprintf("%02x   ",ttt->c_cc[i_cc]);
	pputs("  (hex)\n");
	pputs("           INTR QUIT ERAS KILL EOF  EOL  ");
	pputs("EOL2 SWTCH  VMIN-EOF VTIME-EOL\n");

}	/* end of disp_termio */

/*+-------------------------------------------------------------------------
	disp_stat(st)
--------------------------------------------------------------------------*/
void
disp_stat(st)
struct stat *st;
{
	char mdmap[32];
	mode_map(st->st_mode,mdmap);
	pprintf("mode: %s ",mdmap);
	pprintf("inode: %5u  dev: %3u rdev: %u,%u (0x%04x)\n",
	    (uint)st->st_ino,(uint)st->st_dev,
	    (ushort)st->st_rdev >> 8,(ushort)st->st_rdev & 0xFF,
	    (ushort)st->st_rdev);

}	/* end of disp_stat */

/*+-----------------------------------------------------------------------
	disp_line_termio(fd)

Get current termio structure for file descriptor fd
and display on stderr
------------------------------------------------------------------------*/
void
disp_line_termio(fd,text)
int fd;		/* file descriptor */
char *text;
{
	struct termio fd_termio;
	struct stat fd_stat;
	char text2[128];

	ioctl(fd,TCGETA,&fd_termio);
	sprintf(text2,"fd: %d  %s",fd,text);
	disp_termio(&fd_termio,text2);
	fstat(fd,&fd_stat);
	disp_stat(&fd_stat);

}	/* end of disp_line_termio */

/*+-----------------------------------------------------------------------
	ascii_name_to_hex(str3char)

  return value of ascii ctl char name (e.g., "NUL") 0 - 0x1F
  support CSI "ascii" 0x9B (for ESC + '[' ANSI)
  returns -1 if input not valid
------------------------------------------------------------------------*/
ascii_name_to_hex(str3char)
char *str3char;
{
	register char *cptr = ascii_ctlstr;
	register intval;

	if((strlen(str3char) == 3) && (ulcmpb(str3char,"del") < 0))
		return(0x7F);
	if((strlen(str3char) == 3) && (ulcmpb(str3char,"csi") < 0))
		return(0x9B);

	for(intval = 0; intval <= SPACE; intval++)
	{
		if(	(to_lower(*str3char) == to_lower(*cptr))				&&
			(to_lower(*(str3char + 1)) == to_lower(*(cptr + 1)))	&&
			((to_lower(*(str3char + 2)) == to_lower(*(cptr + 2)))	||
			(*(cptr + 2) == ' ')))
		{
			return(intval);
		}
		cptr += 3;
	}

	return(-1);

}	/* end of ascii_name_to_hex */

/*+-------------------------------------------------------------------------
	ascii_to_hex(ascii)
--------------------------------------------------------------------------*/
int
ascii_to_hex(ascii)
char *ascii;
{
	int hexval;
	if(strlen(ascii) == 1)
		return(*ascii);
	else if(!strncmp(ascii,"0x",2))
	{
		sscanf(ascii + 2,"%x",&hexval);
		return(hexval & 0xFF);
	}
	else if(*ascii == '^')
		return(*(ascii + 1) & 0x1F);
	else
		return(ascii_name_to_hex(ascii));
}	/* end of ascii_to_hex */

/*+-------------------------------------------------------------------------
	hex_to_ascii_name(char_val)

  Returns pointer to static string containing three character ASCII
  name for control character followed by a null.
--------------------------------------------------------------------------*/
char *
hex_to_ascii_name(char_val)
char char_val;
{
	static char ascii_name[4];

	char_val &= 0x7F;

	if(char_val == 0x7F)
		strcpy(ascii_name,"DEL");
	else if(char_val > SPACE)
	{
		ascii_name[0] = char_val;
		ascii_name[1] = 0;
	}
	else
	{
		strncpy(ascii_name,ascii_ctlstr + (char_val * 3),3);
		ascii_name[3] = 0;
	}

	return(ascii_name);

}	/* end of hex_to_ascii_name */

/*+-------------------------------------------------------------------------
	get_curr_dir(cdir,cdir_max) - get current directory into 'cdir'
--------------------------------------------------------------------------*/
int
get_curr_dir(cdir,cdir_max)
char *cdir;
int cdir_max;
{
	FILE *popen();
	FILE *pipefp = popen("/bin/pwd","r");
	int itmp;

	strcpy(cdir,".");
	if(!pipefp)
		return(-1);
	fgets(cdir,cdir_max,pipefp);
	if((itmp = strlen(cdir)) && (*(cdir + itmp - 1) == 0x0A))
		*(cdir + itmp - 1) = 0;
	fclose(pipefp);
	return(0);
}	/* end of get_curr_dir */

/*+-----------------------------------------------------------------------
	get_home_dir(home_dir) - get user home directory
------------------------------------------------------------------------*/
get_home_dir(home_dir)
char *home_dir;
{
	static char home_directory[256] = "";
	struct passwd *pwent;
	char *cptr;

	if(home_directory[0])
	{
		strcpy(home_dir,home_directory);
		return(0);
	}

	if(cptr = getenv("HOME"))			/* x286 seems to blow up ... */
	{									/* ... in pwent code ... hmmm */
		strcpy(home_directory,cptr);
		strcpy(home_dir,cptr);
		return(0);
	}

	if(!(pwent = getpwuid(getuid())))
	{
		pperror("cannot get pwent for you!!");
		termecu(TERMECU_PWENT_ERROR);
	}
	strcpy(home_directory,pwent->pw_dir);
	strcpy(home_dir,pwent->pw_dir);
	endpwent();
	return(0);

}	/* end of get_home_dir */

/*+-------------------------------------------------------------------------
	make_ecu_subdir()
must be called early in execution before wierd tty states set, etc.
--------------------------------------------------------------------------*/
void
make_ecu_subdir()
{
	int itmp;
	struct stat fst;
	char s256[256];
	char s258[258];

	get_home_dir(s256);
	strcat(s256,"/.ecu");
	if((!(itmp = stat(s256,&fst))) && ((fst.st_mode & S_IFMT) != S_IFDIR))
	{
		ff(se,"~/.ecu is not a directory. Rename the file and try again.\n\n");
		exit(1);
	}
	if(itmp)		/* if stat failed, try to make the directory */
	{
		strcpy(s258,s256);
		strcat(s258,"/x");
		errno = ENOENT;
		if(make_dirs(s258))
		{
			if(stat(s256,&fst))
			{
				ff(se,"cannot make ~/.ecu subdirectory.\n");
				perror(s256);
				exit(1);
			}
		}
	}
	chmod(s256,0700);
}	/* end of make_ecu_subdir */

/*+-------------------------------------------------------------------------
	str_classify(sc,str) - classify a string and return value

Use the STR_CLASSIFY structure to classify a string (convert str to
lexical token or error code) and return the value;  use last token
in table if no string matches
--------------------------------------------------------------------------*/
str_classify(sc,str)
STR_CLASSIFY *sc;
char *str;
{
	while(sc->str)
	{
		if(minunique(sc->str,str,sc->min_ch))
			return(sc->token);
		sc++;
	}
	return(sc->token);
}	/* end of str_classify */

/*+-------------------------------------------------------------------------
	yes_or_no(strarg) - lenient yes/no, on/off

  Returns 1 if first char is 'Y' or 'y'
	or if strarg is numeric returns the numeric value
	or if strarg is alpha == "on" returns 1
  Returns 0 otherwise
--------------------------------------------------------------------------*/
int
yes_or_no(strarg)
char *strarg;
{
	static STR_CLASSIFY sc[] = {
		{ "yes",	1,1 },
		{ "on",		2,1 },
		{ "no",		1,0 },
		{ "off",	3,0 },
		{ (char *)0,0,0 },
	};

	if(isdigit(*strarg))
		return(atoi(strarg));
	else
		return(str_classify(sc,strarg));

}	/* end of yes_or_no */

/*+-------------------------------------------------------------------------
	find_shell_chars(command) - search for shell metacharacters

returns 1 if found
--------------------------------------------------------------------------*/
int
find_shell_chars(command)
char *command;
{
	register schar;
	register cchar;
	register char *scptr;
	static char shell_chars[] = "\\\"~;*?'`{}[]$";

	while(cchar = *command++)
	{
		scptr = shell_chars;
		while(schar = *scptr++)
			if(schar == cchar)
				return(1);
	}
	return(0);
}	/* end of find_shell_chars */

/*+-------------------------------------------------------------------------
	errno_text(err) - safe sys_errlist lookup
--------------------------------------------------------------------------*/
char *
errno_text(err)
int err;
{
	static char errant[32];

	if((unsigned)err <= (unsigned)sys_nerr)
		return(sys_errlist[errno]);
	sprintf(errant,"errno %d",errno);
	return(errant);

}	/* end of errno_text */

/*+-------------------------------------------------------------------------
	perror_errmsg(str)
--------------------------------------------------------------------------*/
void
perror_errmsg(str)
char *str;
{
	extern char errmsg[];

	sprintf(errmsg,"%s: %s",str,errno_text(errno));
}	/* end of perror_errmsg */

/*+-------------------------------------------------------------------------
	cfree(p,num,size) - fix bug in XENIX -lmalloc
--------------------------------------------------------------------------*/
#if defined(M_XENIX) && defined(XENIX_MALLOC_LIB_BUG)
cfree(p,num,size)
char *p;
int num;
int size;
{
	free(p);
}	/* end of cfree */
#endif

/*+-------------------------------------------------------------------------
	defeat_optimize_to_work_around_bug(would_be_optimized)

work around for GCC 1.39 optimization bug (see ecufkey.c)
This bug was fixed in gcc 1.40
--------------------------------------------------------------------------*/
#if defined(__GNUC__) && !defined(GCC140)
void
defeat_optimize_to_work_around_bug(would_be_optimized)
int *would_be_optimized;
{
	;	/* do absolutely nothing */
}	/* end of defeat_optimize_to_work_around_bug */

#endif /* __GNUC__ */

/*+-------------------------------------------------------------------------
	rdchk(fd) - for systems without it but with FIONREAD
--------------------------------------------------------------------------*/
#if defined(sun) || defined(NO_RDCHK)
int
rdchk(fd)
int fd;
{
	int chars_waiting;

	if(ioctl(fd,FIONREAD,&chars_waiting))
		return(0);
	else
		return(!!chars_waiting);
}	/* end of rdchk */
#endif

/* end of ecuutil.c */
/* vi: set tabstop=4 shiftwidth=4: */