ecugrabbag.c

一个通讯程序源码

	return(0);
}	/* end of morse_bell */
#endif

/*+-------------------------------------------------------------------------
	xbell(type,count)
--------------------------------------------------------------------------*/
void
xbell(type,count)
int type;
int count;
{
#if defined(WHT) && defined(MORSE)
	if(morse_bell(type,count))
		ring_bell();
#else
#if defined(WHT) && defined(AUDIO)
	void audio_notify();
	audio_notify(type);
#else
	if(!tty_is_multiscreen)
	{
		ring_bell();
		return;
	}

#if defined(MORSE)
	if(morse_bell(type,count))
#endif
		xbell_fd(1,type,count);
#endif /* WHT && AUDIO */
#endif /* WHT && MORSE */

}	/* end of xbell */

/*+-------------------------------------------------------------------------
	bell_alarm(xbell_type)
  ring bell on multiscreens; if morse driver included, use it instead
--------------------------------------------------------------------------*/
int
bell_alarm(xbell_type)
int xbell_type;
{
#if defined(M_SYSV)
	register notify_fd;
	register fork_pid;
	static long notify_time = 0L;
	char *get_ttyname();
	char devname[64];
	int devnum;
	int ttnum;

#if !(defined(WHT) && defined(MORSE))
	if(!tty_is_multiscreen)
	{
		ring_bell();
		return(1);
	}
#endif

	ttnum = atoi(get_ttyname() + 8);

/* if happened less than 15 secs ago, forget it */
	if((time((long *)0) - notify_time) < 15L)
		return(0);

	notify_time = time((long *)0);

#if defined(MORSE)
	if(morse_bell(xbell_type,1))
	{
#endif
		if((fork_pid = smart_fork()) != 0)
		{
#if defined(FORK_DEBUG)
			sprintf(devname,"DEBUG bell notify pid %d",fork_pid);
			ecu_log_event(getpid(),devname);	/* bell notify */
#endif
			return(fork_pid > 0);
		}

		for(devnum = 1; devnum < 13; devnum++)
		{
			if(devnum == ttnum)		/* don't bell notify ecu's tty */
				continue;
			sprintf(devname,"/dev/tty%02d",devnum);
			if((notify_fd = open(devname,O_WRONLY,0)) >= 0)
			{
				xbell_fd(notify_fd,xbell_type,1);
				close(notify_fd);
			}
		}

		_exit(0);		/* end of child tine (of the fork, naturally) */
#if defined(MORSE)
	}
	/*NOTREACHED*/
#endif
#else /* not SCO (M_SYSV) */
	ring_bell();
#endif
	return(1);
}	/* end of bell_alarm */

/*+-------------------------------------------------------------------------
	bell_notify(xbell_type)
--------------------------------------------------------------------------*/
void
bell_notify(xbell_type)
int xbell_type;
{
#if defined(M_SYSV)
	if(
#if !defined(WHT) && !defined(PTY_BELL_NOTIFY)
		tty_is_multiscreen &&
#endif
			 shm->bell_notify_state)
	{
		bell_alarm(xbell_type);
	}
#endif
}	/* end of bell_notify */

/*+-------------------------------------------------------------------------
	parse_bell_notify_argument(strarg) - parse "bell notify" argument

  Returns 0,1,2 according to parsing rules
          -1 on error
--------------------------------------------------------------------------*/
int
parse_bell_notify_argument(strarg)
char *strarg;
{
	static STR_CLASSIFY sc[] = {
		{ "off",	3,0 },
		{ "on",		2,1 },
		{ "alert",  1,2 },
		{ (char *)0,0,-1 },
	};
	int itmp;

	if(isdigit(*strarg))
	{
		if( ( (itmp = atoi(strarg)) >= 0) && (itmp < 3) )
			return(itmp);
		return(-1);
	}

	return(str_classify(sc,strarg));

}	/* end of parse_bell_notify_argument */

/*+-------------------------------------------------------------------------
	bell_notify_text(bn) - text for bell notify status
--------------------------------------------------------------------------*/
char *
bell_notify_text(bn)
int bn;
{
	char *cptr = "?";

	switch(bn)
	{
		case 0: cptr = "OFF"; break;
		case 1: cptr = "ON"; break;
		case 2: cptr = "ON+ALERT"; break;
		default: cptr = "???"; break;
	}
	return(cptr);
}	/* end of bell_notify_text */

/*+-------------------------------------------------------------------------
	signal_name_text(sig)
--------------------------------------------------------------------------*/
char *
signal_name_text(sig)
int sig;
{
	register char *cptr;
	static char sigunknown[20];

	sig &= 0x7F;
	switch(sig)
	{
		case SIGHUP:	cptr = "SIGHUP"; break;
		case SIGINT:	cptr = "SIGINT"; break;
		case SIGQUIT:	cptr = "SIGQUIT"; break;
		case SIGILL:	cptr = "SIGILL"; break;
		case SIGTRAP:	cptr = "SIGTRAP"; break;
#ifdef SIGIOT
		case SIGIOT:	cptr = "SIGIOT"; break;
#endif
#ifdef SIGEMT
		case SIGEMT:	cptr = "SIGEMT"; break;
#endif
		case SIGFPE:	cptr = "SIGFPE"; break;
		case SIGKILL:	cptr = "SIGKILL"; break;
#ifdef SIGBUS		
		case SIGBUS:	cptr = "SIGBUS"; break;
#endif
		case SIGSEGV:	cptr = "SIGSEGV"; break;
#ifdef SIGSYS
		case SIGSYS:	cptr = "SIGSYS"; break;
#endif
		case SIGPIPE:	cptr = "SIGPIPE"; break;
		case SIGALRM:	cptr = "SIGALRM"; break;
		case SIGTERM:	cptr = "SIGTERM"; break;
		case SIGUSR1:	cptr = "SIGUSR1"; break;
		case SIGUSR2:	cptr = "SIGUSR2"; break;
		case SIGCLD:	cptr = "SIGCLD"; break;
#if	defined(SIGPWR)
		case SIGPWR:	cptr = "SIGPWR"; break;
#endif
#if	defined(SIGSTOP)
		case SIGSTOP:   cptr = "SIGSTOP"; break;
#endif
#if	defined(SIGTSOP)
		case SIGTSTP:   cptr = "SIGTSTP"; break;
#endif
#if	defined(SIGCONT)
		case SIGCONT:   cptr = "SIGCONT"; break;
#endif
#if	defined(SIGTTIN)
		case SIGTTIN:   cptr = "SIGTTIN"; break;
#endif
#if	defined(SIGTTOU)
		case SIGTTOU:   cptr = "SIGTTOU"; break;
#endif
		default:
			sprintf(sigunknown,"SIGNAL %u",sig);
			return(sigunknown);
	}
	return(cptr);

}	/* end of signal_name_text */

/*+-------------------------------------------------------------------------
	rename(from,to)
--------------------------------------------------------------------------*/
#if defined(M_XENIX) && !defined(BUILDING_LINT_ARGS)
int
rename(from,to)
char *from;
char *to;
{
	struct stat ss;
	int save_errno;
	extern int errno;

	if(!stat(to,&ss))	/* if to exists, flunk */
	{
		errno = EEXIST;	/* fake "file exists" error */
		return(-1);
	}

	if(link(from,to))	/* if cannot link, flunk */
		return(-1);

	if(unlink(from))	/* if cannot unlink, flunk */
	{
		save_errno = errno;
		unlink(to);
		errno = save_errno;
		return(-1);
	}

	return(0);

}	/* end of rename */
#endif

/*+-------------------------------------------------------------------------
	send_get_response(narg,arg) - send a string, get and log response
--------------------------------------------------------------------------*/
/*ARGSUSED*/
void
send_get_response(narg,arg)
int narg;
char **arg;
{
	int itmp;
	int mode;
	LRWT lr;
	char buf[1024];
	FILE *fplog;
	char *fname = "ecu.sgr.log";
	int restart_rcvr = need_rcvr_restart();

	if(narg < 3)
	{
		fputs("   usage: sgr <mode> <cmd>\r\n",se);
		fputs("mode = 0 for sanitized response, 1 == raw\r\n",se);
		fputs("cmd = 'Send' string (see 'expresp' proc cmd in manual)\r\n",se);
		return;
	}

	/*
	 * don't want receiver stealing our response
	 */
	kill_rcvr_process(SIGUSR1);

	/*
	 * set up for capturing response
	 */
	mode = atoi(arg[1]) & 0x0F;;
	lr.to1 = 10 * 1000L;
	lr.to2 =  5 * 1000L;
	lr.raw_flag = 0x80 + mode; /* allow interrupts */
	lr.buffer = buf;
	lr.bufsize = sizeof(buf);
	lr.delim = (char *)0;
	lr.echo_flag = 0;

	/*
	 * stimulus/response
	 */
	ff(se,"  ... wait ... ");
	respond(arg[2]);
	if(!sigint)
	{
		lgets_timeout(&lr);
		if(sigint)
			goto INTERRUPTED;
		ff(se,"done\r\n");

		/*
		 * log response if possible and display on screen
		 */
		if(fplog = fopen(fname,"a"))
		{
			itmp = strlen(arg[2]);
			hex_dump_fp(fplog,arg[2],itmp,"Stimulus",(itmp <= 16));
			hex_dump_fp(fplog,buf,lr.count,"Response",(lr.count <= 16));
			fputs("\n",fplog);
			fclose(fplog);
		}
		hex_dump(buf,lr.count,"Response",(lr.count <= 16));
	}
	else
	{
INTERRUPTED:
		sigint = 0;
		ff(se,"interrupted\r\n");
	}

	if(restart_rcvr)
		start_rcvr_process(0);
}	/* end of send_get_response */

/*+-------------------------------------------------------------------------
	xterm_title(text,code) - experimental - watch this space
--------------------------------------------------------------------------*/
#if defined(WHT2) || defined(XTERM_FRIEND)
void
xterm_title(text,code)
char *text;
int code;
{
	static char *term = (char *)0;
	static char usrname[L_cuserid] = "";
	char *getenv();
	char *cuserid();
	static char xtstr1[82] = "";

	if(!term)
		term = getenv("TERM");
	if(!term)
	{
		term = "";
		return;
	}
	if(ulcmpb(term,"xterm") >= 0)
		return;

	if(!usrname[0])
		(void)cuserid(usrname);

	switch(code)
	{
		case 0:
		case 1:
			xtstr1[0] = 0;
			if(code == 1)
				strcpy(xtstr1,"ECU: ");
			strcat(xtstr1,text);
			if(usrname[0])
				sprintf(xtstr1 + strlen(xtstr1)," (%s)",usrname);
		case 2:
			fputs("\033]0;",se);
			fputs(xtstr1,se);
			fputc(7,se);
			break;
	}
}	/* end of xterm_title */
#endif

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