pcmd.c

一个通讯程序源码

	{
		strcpy(shm->Lrname,rname->pb);
		if(proctrace)
			pprintf("rname set to '%s'\n",rname->pb);
	}
	esdfree(rname);
	return(erc);

}	/* end of pcmd_rname */

/*+-------------------------------------------------------------------------
	pcmd_send(param)
send [-n] <str>
-n do not send trailing CR
-v turn on proctrace for just this statement
-p## pace characters ## msec apart
--------------------------------------------------------------------------*/
int
pcmd_send(param)
ESD *param;
{
int erc;
char *cptr;
ESD *buf;
char switches[32];
int send_cr;
int tell_it;
long pace_msec = 0L;

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

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

	get_switches(param,switches,sizeof(switches));
	send_cr = !strchr(switches,'n');
	tell_it = !!strchr(switches,'v');
	if(cptr = strchr(switches,'p'))
		sscanf(cptr + 1,"%ld",&pace_msec);

	if(erc = gstr(param,buf,1))
	{
		esdfree(buf);
		return(erc);
	}

	if(proctrace || tell_it)
	{
		hex_dump(buf->pb,buf->cb,
			(send_cr) ? "send with CR" : "send w/o CR",1);
	}

	if(pace_msec)
		lputs_paced(pace_msec,buf->pb);
	else
		lputs(buf->pb);

	if(send_cr)
		lputc(CRET);
	if(pace_msec)
		Nap(pace_msec);

	esdfree(buf);
	return(erc);
}	/* end of pcmd_send */

/*+-------------------------------------------------------------------------
	pcmd_set(param)
--------------------------------------------------------------------------*/
int
pcmd_set(param)
ESD *param;
{
int erc;
int itmp;
ulong varnum;
uint varmax;
char vartype;
char varstr[16];
int show_status;
long *ivptr;
ESD *svptr;
char *cptr;
char *make_char_graphic();

	if(erc = skip_cmd_break(param))
		return(erc);

	do {

		/* $ is optional */
		if((erc = skip_cmd_char(param,'$')) && (erc != eSyntaxError))
			return(erc);

		/* get variable type */
		if(get_cmd_char(param,&vartype))
			return(eSyntaxError);

		/* validate variable type */
		vartype = to_lower(vartype);
		switch(vartype)
		{
			case 'i':
				varmax = IVQUAN;
				break;
			case 's':
				varmax = SVQUAN;
				break;
			default:
				return(eIllegalVarType);
		}

		if(!get_numeric_value(param,&varnum))
			goto TEST_VARNUM;
		else if(*(param->pb + param->index) == '[')
		{
			if(erc = get_subscript(param,&varnum))
				return(erc);
TEST_VARNUM:
			if((int)varnum >= varmax)
				return(eIllegalVarNumber);
			switch(vartype)
			{
				case 'i':
					ivptr = &iv[(int)varnum];
					break;
				default:
					svptr = sv[(int)varnum];
			}
		}
		else if(get_alphanum_zstr(param,varstr,sizeof(varstr)))
			return(eInvalidVarName);
		else
		{
			varnum = NAMED_VARIABLE_FLAG;
			switch(vartype)
			{
				case 'i':
					erc = find_mkvi(varstr,&ivptr,1);
					break;
				default:
					erc = find_mkvs(varstr,&svptr,1);
			}
			if(erc)
				return(erc);
		}
			
		show_status = 1;
		if(!skip_cmd_char(param,'='))	/* assignment */
		{
			switch(vartype)
			{
				case 'i':
					if(erc = gint(param,ivptr))
						return(erc);
					break;
				default:
					if(erc = gstr(param,svptr,1))
						return(erc);
					break;
			}
			if(!proctrace)
				show_status = 0;
		}
		if(show_status)
		{
			switch(vartype)
			{
				case 'i':
					if(varnum != NAMED_VARIABLE_FLAG)
						pprintf("$i%02ld = %7ld (0x%08lx,0%03lo",varnum,
							*ivptr,*ivptr,*ivptr);
					else
						pprintf("$i%s = %ld (0x%08lx,0%03lo",varstr,
							*ivptr,*ivptr,*ivptr);
					if((*ivptr >= 0) && (*ivptr <= 255))
						pprintf(",'%s'",make_char_graphic((char)*ivptr,1));
					pputs(")\n");
					break;
				default:
					if(varnum != NAMED_VARIABLE_FLAG)
						pprintf("$s%02ld = '",varnum);
					else
						pprintf("$s%s = '",varstr);
					itmp = svptr->cb;
					cptr = svptr->pb;
					while(itmp--)
						pputs(make_char_graphic(*cptr++,0));
					pputs("'\n");
					break;
			}
		}
	} while(!skip_comma(param));

	if(!end_of_cmd(param))
		return(eSyntaxError);

	return(0);
}	/* end of pcmd_set */

/*+-------------------------------------------------------------------------
	pcmd_system(param)

system [-l] 'cmd'
-l makes comm line stdin/stdout
-s keeps all fds the same

returns $i0 set to exit status of program or 0x100 if interrupted
--------------------------------------------------------------------------*/
int
pcmd_system(param)
ESD *param;
{
int erc;
ESD *cmd;
extern int last_child_wait_status;
char switches[8];

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

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

/* a hack */
	*cmd->pb++ = (strchr(switches,'s')) ? '>' : 
		((strchr(switches,'l')) ? '$' : '!');

	cmd->maxcb--;

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

/* rehack */
	cmd->pb--;
	cmd->cb++;
	cmd->maxcb++;

	if(proctrace)
	{
		pputs(cmd->pb + 1);
		pputs("\n");
	}

	last_child_wait_status = 0xFF00;
	shell(cmd->pb);
	iv[0] = (last_child_wait_status & 0xFF)
			? 0x100L : (long)last_child_wait_status >> 8;
	if(proctrace)
		pprintf("$i0 = %ld, (%s)\n",iv[0],
			(iv[0] == 0x100L) ? "interrupted" : "program exit status");

	esdfree(cmd);
	return(0);
}	/* end of pcmd_system */

/*+-------------------------------------------------------------------------
	get_big_endian_16(ptr)
--------------------------------------------------------------------------*/
ushort
get_big_endian_16(ptr)
register uchar *ptr;
{
register ushort uint16 = ((ushort)ptr[0] << 8) | ptr[1];
 
	return(uint16);
 
}	/* end of get_big_endian_16 */
 
/*+-------------------------------------------------------------------------
	get_big_endian_32(ptr)
--------------------------------------------------------------------------*/
ulong
get_big_endian_32(ptr)
register uchar *ptr;
{
register ulong uint32 = ((ulong)*ptr++) << 24;
	uint32 |= ((ulong)*ptr++) << 16;
	uint32 |= ((ulong)*ptr++) <<  8;
	uint32 |=  (ulong)*ptr++;
	return(uint32);
 
}	/* end of get_big_endian_32 */

/*+-------------------------------------------------------------------------
	pcmd_getf(param) - get friend memory

getf -x <int-var-spec> <offset>
where: -x ==
   -b byte
   -w word (little-endian)
   -W word (big-endian)
   -l 32-bits (little-endian)
   -L 32-bits (big-endian)
--------------------------------------------------------------------------*/
int
pcmd_getf(param)
ESD *param;
{
int erc;
char switches[8];
long *piv;
long offset;
int size;
int big_endian;

	if(erc = get_switches(param,switches,sizeof(switches)))
		return(erc);
	if((strlen(switches) != 2) || !strchr("bwWlL",switches[1]))
	{
		pputs("invalid switch\n");
		return(eFATAL_ALREADY);
	}
	size = to_lower(switches[1]);
	big_endian = isupper(switches[1]);

/*
	if(!get_svptr(param,&psv))
		return(eNotImplemented);
	else
*/
	if(!strncmp(param->pb + param->index,"$i",2))
		param->index += 2;
	if(erc = get_ivptr(param,&piv,1))
		return(erc);

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

	if(proctrace)
		pprintf("getf %s offset=0x%lx",switches,offset);

	switch(size)
	{
		case 'b':
			if(offset > ((long)sizeof(shm->friend_space) - 1))
				goto OFFSET_TOO_LARGE;
			*piv = *(((uchar *)shm->friend_space) + (int)offset) & 0xFF;
			break;
		case 'w':
			if(offset > ((long)sizeof(shm->friend_space) - 2))
				goto OFFSET_TOO_LARGE;
			if(big_endian)
				*piv = get_big_endian_16((uchar *)shm->friend_space +
						(int)offset);
			else
				*piv = *(((ushort *)shm->friend_space) + (int)offset) & 0xFFFF;
			break;
		case 'l':
			if(offset > ((long)sizeof(shm->friend_space) - 4))
				goto OFFSET_TOO_LARGE;
			if(big_endian)
			{
				*piv = get_big_endian_32((uchar *)shm->friend_space +
						(int)offset);
			}
			else
				*piv = *((long *)((char *)shm->friend_space + (int)offset));
			break;
	}

	if(proctrace)
		pprintf(" value=%ld (%08lx)\n",*piv,*piv);
	return(0);

OFFSET_TOO_LARGE:
	if(proctrace)
		pputs("\n");
	pprintf("offset 0x%02lx too large for -%c (0x%02x bytes available)\n",
		offset,switches[1],sizeof(shm->friend_space));
	return(eFATAL_ALREADY);

}	/* end of pcmd_getf */

/*+-------------------------------------------------------------------------
	pcmd_putf(param)
--------------------------------------------------------------------------*/
/*ARGSUSED*/
int
pcmd_putf(param)
ESD *param;
{
	return(eNotImplemented);
}	/* end of pcmd_putf */

/*+-------------------------------------------------------------------------
	pcmd_xon(param)
--------------------------------------------------------------------------*/
int
pcmd_xon(param)
ESD *param;
{
int erc;
char new_xonxoff[8];
char *xon_status();

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

	if(erc = get_alpha_zstr(param,new_xonxoff,sizeof(new_xonxoff)))
		return(erc);

	if(set_xon_xoff_by_arg(new_xonxoff))
		return(eBadParameter);

	if(proctrace)
		pprintf("xon/xoff flow control set to %s\n",xon_status());

	return(erc);

}	/* end of pcmd_xon */

/*+-------------------------------------------------------------------------
	pcmd_rtscts(param)
--------------------------------------------------------------------------*/
int
pcmd_rtscts(param)
ESD *param;
{
int erc;
char new_rtscts[8];

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

	if(erc = get_alphanum_zstr(param,new_rtscts,sizeof(new_rtscts)))
		return(erc);

#if defined(HW_FLOW_CONTROL) /* see ecu.h */
	lRTSCTS_control(yes_or_no(new_rtscts));

	if(proctrace)
		display_hw_flow_config();
#else
	if(proctrace)
		pprintf("hardware flow control not available .... rtscts ignored\n");
#endif /* RTSFLOW */

	return(erc);
}	/* end of pcmd_rtscts */

/*+-------------------------------------------------------------------------
	pcmd_setline(param) - _rc.ep setline command

This command can be used to set the initial line in _rc.ep
--------------------------------------------------------------------------*/
int
pcmd_setline(param)
ESD *param;
{
int erc;
ESD *tesd;

	if(rc_ep_has_run)
	{
		pprintf("command legal only in _rc.ep\n");
		return(eFATAL_ALREADY);
	}

	if(!(tesd = esdalloc(sizeof(shm->Lline))))
		return(eNoMemory);
	if(erc = gstr(param,tesd,0))
		goto RETURN;
	shm->Lline[0] = 0;
	if(strncmp(tesd->pb,"/dev/",5))
		strcat(shm->Lline,"/dev/");
	strncat(shm->Lline,tesd->pb,sizeof(shm->Lline) - strlen(shm->Lline));
	shm->Lline[sizeof(shm->Lline) - 1] = 0;
	if(proctrace)
		pprintf("line set to %s\n",shm->Lline);

RETURN:
	esdfree(tesd);
	return(erc);
}	/* end of pcmd_setline */

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