sktdbg.c

项目描述: slsnif is a serial port logging utility. It listens to the specified serial port and logs all

/* sktdbg.c: this program supports testing the Sockets library
 *   sktdbg {s|c} sktname
 */
#include <stdio.h>
#include "xtdio.h"
#include "sockets.h"

/* -------------------------------------------------------------------------
 * Local Definitions:
 */
/* #define ansi_escapes  -- experimental, doesn't work yet */

#define BIGBUFSIZE		8192
#define BUFSIZE			128
#define PLAINPROMPT		0
#define BYTESPROMPT		1
#define DYNAMICPROMPT	2

#define TIMEOUT			30L

/* -------------------------------------------------------------------------
 * Prototypes:
 */
#ifdef __PROTOTYPE__
void Taccept(char *buf);
void Tclose(char *buf);
void Tmenu(char *buf);
void Tdebug(char *buf);
void Tpeek(char *buf);
void Ttest(char *buf);
void Tfwinit(char *buf);
void Tfput(char *buf);
void Tgets(char *buf);
void Tprintf(char *buf);
void Tputs(char *buf);
void Tshut(char *buf);
void Tquit(char *buf);
void Tread(char *buf);
void Trmsrvr(char *buf);
void Tscanf(char *buf);
void Ttable(char *buf);
void Twait(char *buf);
void Twrite(char *buf);
void Tisset(char *buf);

#else

extern main();                                    /* sktdbg.c             */
extern void Taccept();                            /* sktdbg.c             */
extern void Tclose();                             /* sktdbg.c             */
extern void Tmenu();                              /* sktdbg.c             */
extern void Tdebug();                             /* sktdbg.c             */
extern void Tpeek();                              /* sktdbg.c             */
extern void Ttest();                              /* sktdbg.c             */
extern void Tfwinit();                            /* sktdbg.c             */
extern void Tfput();                              /* sktdbg.c             */
extern void Tgets();                              /* sktdbg.c             */
extern void Tputs();                              /* sktdbg.c             */
extern void Tshut();                              /* sktdbg.c             */
extern void Tquit();                              /* sktdbg.c             */
extern void Tread();                              /* sktdbg.c             */
extern void Twrite();                             /* sktdbg.c             */
extern void Twait();                              /* sktdbg.c             */
extern void Tscanf();                             /* sktdbg.c             */
extern void Tprintf();                            /* sktdbg.c             */
extern void Ttable();                             /* sktdbg.c             */
extern void Trmsrvr();                            /* sktdbg.c             */
extern void Tisset();                             /* sktdbg.c             */

#endif

/* -------------------------------------------------------------------------
 * Global Data
 */
#ifdef __PROTOTYPE__
struct menu_str{
	char *cmd;
	void (*test)(char *);
	} menu[]=
#else
struct menu_str{
	char *cmd;
	void (*test)();
	} menu[]=
#endif
	{{"accept",Taccept},
	{"close",Tclose},
	{"fput",Tfput},
	{"fwinit",Tfwinit},
	{"get",Tgets},
	{"isset",Tisset},
	{"menu",Tmenu},
	{"peek",Tpeek},
	{"printf",Tprintf},
	{"put",Tputs},
	{"q",Tquit},
	{"quit",Tquit},
	{"read",Tread},
	{"rmsrvr",Trmsrvr},
	{"scanf",Tscanf},
	{"shutdown",Tshut},
	{"table",Ttable},
	{"test",Ttest},
	{"wait",Twait},
	{"write",Twrite},
	{"?",Tmenu}
	};
int nmenu      = sizeof(menu)/sizeof(struct menu_str);
Socket *skt    = NULL;
Socket *server = NULL;

#ifdef ansi_escapes
int pflag= DYNAMICPROMPT;
#else
int pflag= BYTESPROMPT;
#endif

/* -------------------------------------------------------------------------
 * Source Code:
 */

/* main: */
#ifdef __PROTOTYPE__
int main(
  int    argc,
  char **argv)
#else	/* __PROTOTYPE__ */
int main(argc,argv)
int    argc;
char **argv;
#endif	/* __PROTOTYPE__ */
{
char *b;
char  buf[BUFSIZE];
char  cmdbuf[BUFSIZE];
int   icmd;
int   fd;
int   newcnt = 0;
int   oldcnt = 0;
Smask fdmask;
Smask sktmask;

rdcolor(); /* initialize ANSI escape sequences */

if(argc < 3) { /* give usage */
	static char *usage[]={
	 XYELLOW,"sktdbg ",
	 XCYAN,"sktname ",XGREEN,
	 "{",XCYAN,"s",XGREEN,"|",XCYAN,"c",XGREEN,"}\n\n",

	 XUWHITE,"Author:\n",XGREEN,"Dr. Charles E. Campbell\n\n",

	 XUWHITE,"Explanation:\n",XGREEN,
	 "This program is designed to test out the Sockets Library.\n",
	 "The ",XCYAN,"sktname",XGREEN," is the name of the socket.\n",
	 "It can be sktname@hostname or just sktname (current host is then used)\n",
	 "The ",XCYAN,"s",XGREEN," yields a server/accept socket.\n",
	 "The ",XCYAN,"c",XGREEN," yields a client socket.\n\n",

	 "The Sockets Library was written by Dr. Charles E. Campbell, Jr. and\n",
	 "Terry McRoberts of Goddard Space Flight Center, NASA\n",
	 "",""};
	char **u;

	/* print out explanation */
	for(u= usage; **u || **(u+1); ++u) rdcputs(*u,stdout);
#ifdef vms
	exit(1);
#else
	exit(0);
#endif
	}

Sinit();	/* initialize sockets */

/* open a socket of the appropriate type */
skt= Sopenv(argv[1],argv[2],"SKTDBG");
if(!skt) {
	if(!strcmp(argv[2],"s")) {
		error(XTDIO_WARNING,"unable to Sopen(%s,%s), removing <%s>\n", argv[1],argv[2],argv[1]);
		Srmsrvr(argv[1]);
		skt= Sopenv(argv[1],argv[2],"SKTDBG");
		if(!skt) error(XTDIO_ERROR,"2nd try: unable to Sopen(%s,%s)\n",argv[1],argv[2]);
		else     error(XTDIO_NOTE,"second try to Sopen(%s,%s) succeeded\n",argv[1],argv[2]);
		}
	else error(XTDIO_ERROR,"unable to Sopen(%s,%s)\n",argv[1],argv[2]);
	}

/* print out menu */
fputc('\n',stdout);
Tmenu("");

/* command loop */
while(1) {

	/* get command from user */
	switch(pflag) {

	case PLAINPROMPT:
		printf("%sEnter: %s",CYAN,GREEN);
		break;

	case BYTESPROMPT:
		printf("%s(%s%4d%s bytes) Enter: %s",
		  CYAN,GREEN,Stest(skt),
		  CYAN,GREEN);
		break;

#ifdef ansi_escapes
	case DYNAMICPROMPT:
		/* set up Smaskwait */
		Smaskset((Socket *) NULL);
		fd= fileno(stdin);
		Smaskfdset(fd);
		fdmask= Smaskget();
		Smaskset(skt);
		sktmask= Smaskget();
		printf("%s(%s%4d%s bytes) Enter: %s",
		  CYAN,GREEN,Stest(skt),
		  CYAN,GREEN);
		fflush(stdout);

		while(1) {
			/* block until skt or keyboard sends something */
			Smaskwait();
			Smaskuse(fdmask);
			if(Smasktest()) break;
			Smaskuse(sktmask);

			/* update screen */
			newcnt= Stest(skt);
			if(newcnt == oldcnt) continue;
			oldcnt= newcnt;
			printf("\033[20D%s(%s%4d%s bytes) Enter: %s",
			  CYAN,GREEN,newcnt,
			  CYAN,GREEN);
			fflush(stdout);
			sleep(1);
			}
		break;
#endif	/* ansi_escapes */
		}

	/* get prompt from user */
	fgets(buf,BUFSIZE,stdin);
	srmtrblk(buf);
	b= stpblk(buf);
	if(!*b) continue;

	/* get command from b */
	sscanf(buf,"%s",cmdbuf);
	b= stpnxt(buf,"%s%b");	/* point past command string */

	/* handle option */
	if(*b == '-') {
		switch(b[1]) {

		case 'p':	/* prompt mode control */
#ifdef ansi_escapes
			if(++pflag > DYNAMICPROMPT) pflag= PLAINPROMPT;
#else
			if(++pflag > BYTESPROMPT)   pflag= PLAINPROMPT;
#endif
			break;

		default:
			error(XTDIO_WARNING,"I don't know the <%s%s%s> command\n",
			  MAGENTA,cmdbuf,GREEN);
			break;
			}
		continue;
		}

	/* identify command */
	for(icmd= 0; icmd < nmenu; ++icmd)
	  if(!strcmp(menu[icmd].cmd,cmdbuf)) break;
	if(icmd >= nmenu) {
		error(XTDIO_WARNING,"I don't know the <%s%s%s> command\n",
		  MAGENTA,cmdbuf,GREEN);
		continue;
		}

	/* pass control to command */
	(*menu[icmd].test)(b);
	}
}

/* ------------------------------------------------------------------------- */

/* Taccept: this function allows a server to accept a connection */
#ifdef __PROTOTYPE__
void Taccept(char *buf)
#else	/* __PROTOTYPE__ */
void Taccept(buf)
char *buf;
#endif	/* __PROTOTYPE__ */
{

/* If server is null, then the skt *is* a server.  Copy it over.
 * Otherwise, if there's a skt, close it before accepting
 */
if(!server)  {
	if(skt->type == PM_SERVER) {
		server= skt;
		skt   = NULL;
		}
	else {
		error(XTDIO_WARNING,"cannot Saccept with a skt<%s>\n",Sprtskt(skt));
		return;
		}
	}
else if(skt) {
	Sclose(skt);
	skt= NULL;
	}

/* only wait up to TIMEOUT seconds */
if(Stimeoutwait(server,TIMEOUT,0L) <= 0) {
	error(XTDIO_WARNING,"accept timed out (waited %ld seconds)\n",TIMEOUT);
	return;
	}
skt   = Saccept(server);

printf("  %sSaccept%s => <%s%s%s>\n",
  YELLOW,GREEN,MAGENTA,skt? Sprtskt(skt) : "null",GREEN);

}

/* ------------------------------------------------------------------------- */

/* Tclose: this function closes the socket and,
 * for non-accept sockets, exits the program
 */
#ifdef __PROTOTYPE__
void Tclose(char *buf)
#else	/* __PROTOTYPE__ */
void Tclose(buf)
char *buf;
#endif	/* __PROTOTYPE__ */
{

switch(skt->type) {

case PM_ACCEPT:
	Sclose(skt);
	skt   = server;
	server= NULL;
	printf("  %sSclose%s: closed accept Socket\n",YELLOW,GREEN);
	printf("              server socket still available\n");
	break;

case PM_CLIENT:
	Sclose(skt);
	printf("  %sSclose%s: closed client Socket\n",YELLOW,GREEN);
#ifdef vms
	exit(1);
#else
	exit(0);
#endif

case PM_SERVER:
	Sclose(skt);
	skt= server= NULL;
	printf("  %sSclose%s: closed server Socket\n",YELLOW,GREEN);
#ifdef vms
	exit(1);
#else
	exit(0);
#endif
	}

}

/* ------------------------------------------------------------------------- */

/* Tmenu: this function print out the commands */
#ifdef __PROTOTYPE__
void Tmenu(char *buf)
#else	/* __PROTOTYPE__ */
void Tmenu(buf)
char *buf;
#endif	/* __PROTOTYPE__ */
{
int i;


printf("%sSocket Test Commands%s\n",UWHITE,GREEN);
for(i= 0; i < nmenu; ++i) printf("  %s\n",menu[i].cmd);

}

/* ------------------------------------------------------------------------- */


/* ------------------------------------------------------------------------- */

/* Tpeek: this function does a Speek */
#ifdef __PROTOTYPE__
void Tpeek(char *buf)
#else	/* __PROTOTYPE__ */
void Tpeek(buf)
char *buf;
#endif	/* __PROTOTYPE__ */
{
static char locbuf[BIGBUFSIZE];
int         buflen;


buflen= Speek(skt,locbuf,BIGBUFSIZE);
printf("  %sSpeek%s=> skt<%s> locbuf<%s> buflen=%d\n",
  YELLOW,GREEN,Sprtskt(skt),sprt(locbuf),buflen);

}

/* ------------------------------------------------------------------------- */

/* Ttest: this function does a STell */
#ifdef __PROTOTYPE__
void Ttest(char *buf)
#else	/* __PROTOTYPE__ */
void Ttest(buf)
char *buf;
#endif	/* __PROTOTYPE__ */
{
int  buflen;


buflen= Stest(skt);
buf[0]= '\0';
printf("  %sStest%s => skt<%s> %d\n",YELLOW,GREEN,Sprtskt(skt),buflen);

}

/* ------------------------------------------------------------------------- */

/* Tfwinit: sends a PM_FW to the PortMaster */
#ifdef __PROTOTYPE__
void Tfwinit(char *buf)
#else	/* __PROTOTYPE__ */
void Tfwinit(buf)
char *buf;
#endif	/* __PROTOTYPE__ */
{
int      trycnt;
Socket  *pmskt;
SKTEVENT mesg;