pcmd.c

一个通讯程序源码

int erc;
long int2;
long int3;
ESD *tesd1 = (ESD *)0;
ESD *svptr;
LRWT lr;
char switches[8];
ESD *esdalloc();
char ctmp;

	if(shm->Liofd < 0)
		return(eNoLineAttached);

	get_switches(param,switches,sizeof(switches));

	skip_cmd_char(param,'$');
	if(erc = get_cmd_char(param,&ctmp))
		return(erc);
	if(to_lower(ctmp) != 's')
		return(eIllegalVarType);
	if(erc = get_svptr(param,&svptr,1))
		return(erc);

	if(erc = gint(param,&int2))
		return(erc);

	if(erc = gint(param,&int3))
		return(erc);

	if((tesd1 = esdalloc(64)) == (ESD *)0)
		return(eNoMemory);
	if(gstr(param,tesd1,1))	/* optional delimiter */
	{
		esdfree(tesd1);
		tesd1 = (ESD *)0;
	}	

	esdzero(svptr);

	lr.to1 = int2 * 100L;
	lr.to2 = int3 * 100L;
	/* allow interrupts + raw read per -r */
	lr.raw_flag = (strchr(switches,'r')) ? 0x81 : 0x80;
	lr.buffer = svptr->pb;
	lr.bufsize = svptr->maxcb;
	lr.delim = (tesd1) ? tesd1->pb : (char *)0;
	lr.echo_flag = (strchr(switches,'e') != (char *)0);
	(void)lgets_timeout(&lr);
	if(tesd1)
		esdfree(tesd1);

	svptr->cb = lr.count;
	esd_null_terminate(svptr);
	iv[0] = (long)lr.count;
	if(zero_length_read_detected)
	{
		zero_length_read_detected = 0;
		erc = eProcAttn_DCDloss;
	}
	if(proctrace)
		pprintf("lgets read %d chars\n",lr.count);
	return(erc);

}	/* end of pcmd_lgets */

/*+-------------------------------------------------------------------------
	pcmd_flush(param)
--------------------------------------------------------------------------*/
/*ARGSUSED*/
int
pcmd_flush(param)
ESD *param;
{
	if(shm->Liofd < 0)
		return(eNoLineAttached);

	lflush(2);
	if(proctrace)
		pputs("line flushed\n");
	return(0);
}	/* end of pcmd_flush */

/*+-------------------------------------------------------------------------
	pcmd_hangup(param)
--------------------------------------------------------------------------*/
/*ARGSUSED*/
int
pcmd_hangup(param)
ESD *param;
{
	if(shm->Liofd < 0)
	{
		if(proctrace)
			pputs("no line attached ... hangup ignored\n");
		DCE_now_on_hook();
		return(0);
	}

	if(proctrace)
		pputs("hanging up ... ");
	DCE_hangup();
	if(proctrace)
		pputs("line on hook\n");
	return(0);
}	/* end of pcmd_hangup */

/*+-------------------------------------------------------------------------
	pcmd_hexdump(param)

hexdump [-s] <str>
hexdump -t[s] <str1> <str>
<str> buf to dump
<str1> title (if -t)
-s short (terse) dump
--------------------------------------------------------------------------*/
int
pcmd_hexdump(param)
ESD *param;
{
int erc;
ESD *title = (ESD *)0;
ESD *buf;
char switches[8];
extern FILE *plog_fp;

	if((buf = esdalloc(256)) == (ESD *)0)
		return(eNoMemory);

	get_switches(param,switches,sizeof(switches));

	if(strchr(switches,'t'))	/* if -t */
	{
		if((title = esdalloc(256)) == (ESD *)0)
		{
			erc = eNoMemory;
			goto RETURN;
		}
		if(erc = gstr(param,title,0))
			goto RETURN;
	}

	if(erc = gstr(param,buf,1))
		goto RETURN;

	hex_dump(buf->pb,buf->cb,(title) ? title->pb : "",
		(strchr(switches,'s')) ? 1 : 0);

	if(plog_fp)
		hex_dump_fp(plog_fp,buf->pb,buf->cb,(title) ? title->pb : "",
			(strchr(switches,'s')) ? 1 : 0);

RETURN:
	esdfree(buf);
	if(title)
		esdfree(title);
	return(erc);

}	/* end of pcmd_hexdump */

/*+-------------------------------------------------------------------------
	pcmd_lbreak(param)
--------------------------------------------------------------------------*/
/*ARGSUSED*/
int
pcmd_lbreak(param)
ESD *param;
{
	if(shm->Liofd < 0)
		return(eNoLineAttached);

	lbreak();
	return(0);
}	/* end of pcmd_lbreak */

/*+-------------------------------------------------------------------------
	pcmd_logevent(param)

logevent 'cmd'
--------------------------------------------------------------------------*/
int
pcmd_logevent(param)
ESD *param;
{
int erc;
ESD *eventstr;
char switches[8];

	if((eventstr = esdalloc(256)) == (ESD *)0)
		return(eNoMemory);

	get_switches(param,switches,sizeof(switches));

/* a hack */
	strcpy(eventstr->pb,"PROC ");
	eventstr->pb += 5;
	eventstr->maxcb -= 5;

	if(erc = gstr(param,eventstr,0))
	{
		eventstr->pb -= 5;		/* be nice */
		eventstr->maxcb += 5;	/* or surely this will haunt us one day */
		esdfree(eventstr);
		return(erc);
	}

/* rehack */
	eventstr->pb -= 5;
	eventstr->maxcb += 5;
	eventstr->cb += 5;

	ecu_log_event(getpid(),eventstr->pb);
	esdfree(eventstr);
	return(0);

}	/* end of eventstr_logevent */

/*+-------------------------------------------------------------------------
	pcmd_lookfor(param)

lookfor [-e] [quiet | <str>] [<int>]

-e echo to screen while looking
quiet means look for quiet
<str> means look for string
<int> number 1/10ths secs (default 5.0 second) for timeout

in case of lookfor <str>, $i0 plugged 1 if found, else 0
--------------------------------------------------------------------------*/
int
pcmd_lookfor(param)
ESD *param;
{
int erc;
char switches[8];
char *cptr = (char *)0;
ESD *tesd = (ESD *)0;
ulong decisecs = 50; /* default wait is 5 seconds */
int echo_flag;
char s8[8];
long start_secs;


	if(shm->Liofd < 0)
		return(eNoLineAttached);

	get_switches(param,switches,sizeof(switches));
	echo_flag = (strchr(switches,'e') != (char *)0);

	if(!get_alpha_zstr(param,s8,sizeof(s8)))
	{
		if(strcmp(s8,"quiet"))
			return(eSyntaxError);
	} 
	else
	{
		if((tesd = esdalloc(64)) == (ESD *)0)
			return(eNoMemory);
		if(erc = gstr(param,tesd,0))
			goto RETURN;
		if(!tesd->cb)
		{
			pputs("lookfor null string\n");
			erc = eFATAL_ALREADY;
			goto RETURN;
		}
		cptr = tesd->pb;
	}

	if(erc = gint(param,&decisecs))
	{
		/* if something there non-integer */
		if(!end_of_cmd(param))
		{
			erc = eSyntaxError;
			goto RETURN;
		}
	}
	erc = 0;

	if(proctrace)
		time(&start_secs);

	if(cptr)
	{
		iv[0] = (long)llookfor(cptr,decisecs * 100L,echo_flag);
		if(proctrace)
			pprintf("lookfor set $i00 = %ld\n",iv[0]);
	}
	else
		lquiet(decisecs * 100L,echo_flag);

	if(proctrace)
		pprintf("waited %ld secs\n",time((long *)0) - start_secs);

RETURN:
	if(tesd)
		esdfree(tesd);
	if(zero_length_read_detected)
	{
		zero_length_read_detected = 0;
		erc = eProcAttn_DCDloss;
	}
	return(erc);

}	/* end of pcmd_lookfor */

/*+-------------------------------------------------------------------------
	pcmd_nap(param)
nap [-m] <int>
<int> number 1/10ths secs, except if -m, nap <int> milliseconds
--------------------------------------------------------------------------*/
int
pcmd_nap(param)
ESD *param;
{
int erc;
char switches[8];
ulong interval;

	get_switches(param,switches,sizeof(switches));

	if(erc = gint(param,&interval))
		return(erc);
	if(interval)
	{
		if(!strchr(switches,'m'))
			interval *= 100L;
		if(interval < hzmsec)		/* SCO nap bug */
			interval = hzmsec;		/* SCO nap bug */
		if(proctrace && (interval > 100))	/* short naps hurt by pprintf */
			pprintf("nap %ld msec\n",interval);
		if(Nap(interval) == -1)		/* EINTR is the only error returned ... */
		{							/* but check anyway */
			if(errno == EINTR)
				erc = eCONINT;
		}
	}
	return(erc);
}	/* end of pcmd_nap */

/*+-------------------------------------------------------------------------
	pcmd_nice(param)
--------------------------------------------------------------------------*/
int
pcmd_nice(param)
ESD *param;
{
long new_nice;
int erc;
int old_nice;
int nice();

	if(shm->Liofd < 0)
		return(eNoLineAttached);

	if(erc = gint(param,&new_nice))
		return(erc);
	if((new_nice < 0) || (new_nice > 39))
	{
		pprintf("warning: invalid nice %ld ignored (valid range 0-39)\n",
			new_nice);
		return(0);
	}

	old_nice = nice(0) + 20;
	nice(-old_nice + (int)new_nice);

	if(proctrace)
		pprintf("nice desired %u, set to %u\n",(uint)new_nice,nice(0) + 20);
	return(0);

}	/* end of pcmd_nice */

/*+-------------------------------------------------------------------------
	pcmd_parity(param)
parity [e | o | n]
parity ['e' | 'o' | 'n']
--------------------------------------------------------------------------*/
int
pcmd_parity(param)
ESD *param;
{
int erc;
int new_parity = 0;
ESD *tesd;
char s64[64];

	if(erc = skip_cmd_break(param))
		return(erc);
	if(!(tesd = esdalloc(64)))
		return(eNoMemory);
	if(!gstr(param,tesd,0))
		new_parity = to_lower(*tesd->pb);
	else if(!get_alpha_zstr(param,s64,sizeof(s64)))
		new_parity = to_lower(s64[0]);
	else
	{
		erc = eSyntaxError;
		goto RETURN;
	}
	esdfree(tesd);

	switch(new_parity)
	{
		case 'n':
			new_parity = 0;
		case 'e':
		case 'o':
			shm->Lparity = new_parity;
			if(shm->Liofd < 0)
				lset_parity(1);
			break;
		default:
			erc = eBadParameter;
	}
	if(proctrace && !erc)
	{
		pprintf("parity set to %s\n",
			(shm->Lparity) ? ((shm->Lparity == 'e') ? "even" : "odd")
			               : "none");
	}

RETURN:
	esdfree(tesd);
	return(erc);

}	/* end of pcmd_parity */

/*+-------------------------------------------------------------------------
	pcmd_prompt(param)
--------------------------------------------------------------------------*/
int
pcmd_prompt(param)
ESD *param;
{
extern ESD *icmd_prompt;

	return(gstr(param,icmd_prompt,0));
}	/* end of pcmd_prompt */

/*+-------------------------------------------------------------------------
	pcmd_ptrace(param)
--------------------------------------------------------------------------*/
int
pcmd_ptrace(param)
ESD *param;
{
char s8[8];

	if(get_alpha_zstr(param,s8,sizeof(s8)))
		return(eSyntaxError);
	if(isdigit(s8[0]))
		proctrace = atoi(s8);
	if(!strcmp(s8,"on"))
		proctrace = 1;
	else if(!strcmp(s8,"off"))
		proctrace = 0;
	else
		return(eSyntaxError);
	return(0);
}	/* end of pcmd_ptrace */

/*+-------------------------------------------------------------------------
	pcmd_rname(param) - set remote name
--------------------------------------------------------------------------*/
int
pcmd_rname(param)
ESD *param;
{
int erc;
ESD *rname;

	if(shm->Liofd < 0)
		return(eNoLineAttached);
	if(!shm->Lconnected)
	{
		pputs("Not connected\n");
		return(eFATAL_ALREADY);
	}

	if((rname = esdalloc(sizeof(shm->Lrname) - 1)) == (ESD *)0)
		return(eNoMemory);

	if(!(erc = gstr(param,rname,0)))