sunlink.c

操作系统SunOS 4.1.3版本的源码

static char     sccsid[] = "@(#)sunlink.c 1.1 7/30/92 3.24 90/04/03 Sun Micro";

#include <stdio.h>
#include <sys/types.h>
#include <ctype.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <sys/file.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <rpc/rpc.h>


/*
 * #include <sundev/syncmode.h> #include <sundev/syncstat.h>
 */

#define NO_PORTS_SELECTED       3
#define NO_SD_PORTS_SELECTED	4
#define NO_LOAD			5
#define NO_ATTACH		6
#define NO_LAYER		7
#define NO_LAYER_LOOPBACK	8
#define NO_SOCKET		9
#define NO_GETSYNC		10
#define NO_SETSYNC		11
#define NO_CHECK_SETSYNC	12
#define NO_BSC			13
#define NO_ASYNC		14
#define ILLEGAL_PROTOCOL	15
#define DEV_NOT_OPEN		16
#define WRITE_FAILED		17
#define READ_FAILED		18
#define RECEIVE_TIMEOUT		19
#define COMPARE_ERROR		20
#define NO_STAT_SOCKET		21
#define SIGBUS_ERROR            22
#define SIGSEGV_ERROR           23
#define BAD_SD_PORTS_SPEC	24
#define END_ERROR               25
#define DEV_NOT_AVAIL		26
#define PORT_NUM_OUT_OF_RANGE	27
#define ACTIVITY_ON_LINE	28

#define TTYB			0
#define DCP			1
#define MCP			2
#define HSS			3

#define NORMAL			0		/* HSI loopback modes */
#define NONE			3	
#define SIMPLE			4	
#define CLOCKLESS		5
#define SILENT			6
#define SILENT_CLOCKLESS	7

#define NO			0		/* hs_param loopbck flag vals */
#define YES			1
#define SLNT			2

#include "sdrtns.h"			       	/* sundiag include file */
#include "../../../lib/include/libonline.h"	/* online library include */
#include <net/if.h>
#include "syncmode.h"
#include "syncstat.h"
#include "hsparam.h"          /* additional syncmode fields for HSI board */

#define SDLC_PROTOCOL		0
#define BSC_PROTOCOL		1
#define ASYNC_PROTOCOL		2
#define LOOPBACK		3
#define MAX_LENGTH		1024
#define RECEIVE_WAIT_TIME	900
#define ERROR_THRESHOLD		4
#define MAX_IFD			20		/* max no. of /dev/ifd files */

char		device_sunlinkname[30];
char		*device = device_sunlinkname;
char		msg_buffer[MESSAGE_SIZE];
char		*msg = msg_buffer;
char            perror_msg_buffer[30];
char            *perror_msg = perror_msg_buffer;

int		sd_quick_test = FALSE;
int		either_quick_test = FALSE;
int		quick_check_flag = FALSE;
int             check_point = FALSE;
int		errors = 0;
int		match = 0;
int		return_code = 0;
int		simulate_error = 0;

u_char          pattern = 0x55, protocol;
u_char          load_dcp_kernal = FALSE;
int             port_ptr = 1;
int             internal_loopback = FALSE;
int             ttyb_test = FALSE, status_dcp = FALSE;
int             sock_type;
int             loop_count, max_frame_len, min_frame_len;
int             err_frame_no;
int             no_receive_response();
u_char          sbarray[1024], rbarray[1024];
char            tmpbuf[128], pattn_type = 'r', clock_type;
char           *lb_mptr, *nrzi_mptr, *txc_mptr, *rxc_mptr;
long            baudrate;
int             frame_count;
int             load_dcp_a = FALSE;
int             load_dcp_b = FALSE;
int             load_dcp_c = FALSE;
int             load_dcp_d = FALSE;
int             attach_a[4];
int             attach_b[4];
int             attach_c[4];
int             attach_d[4];
int             first_dev = TRUE;
int             second_dev = FALSE;
int             port_to_port = FALSE;
char            sl_port_names[10];
char           *sl_ports = sl_port_names;

int		its_hih = FALSE;       /* device is hih (HDLC) not hss */
int		its_his = FALSE;       /* device is his (SDLC) not hss */
int		cur_test;              /* current selected test */
int		loopback_type;         /* loopback type for hss */
char	       *from_ports;	       /* list of source ports */
char	       *to_ports;	       /* list of destination ports */

struct dev {
    char            device[10];
    int             fid;
    int             s;
    int             dcp;
    char            board;
    u_char          port;
    int             int_port;
    char            ifdname[8];
    u_char	    hp_v35;
    u_char	    hp_obclk;
}               testing[2] = {
    {
	"mcph0",
	0,
	0,
	FALSE,
	'h',
	'0',
	0,
	"ifd0"
    },
    {
	"mcph0",
	0,
	0,
	FALSE,
	'h',
	'0',
	0,
	"ifd0",
    }
};
struct dev     *xmit_device, *rec_device, *using_device;

struct timeval short_time = { 1, 0 };
struct timeval long_time = { 4, 0 };
struct ifreq    ifr;
struct syncmode sm;
struct syncmode *ssm = (struct syncmode *) ifr.ifr_data; 
struct hs_param *hsm = (struct hs_param *) ifr.ifr_data; /* hss param ptr */ 
struct ss_dstats sd;
struct ss_estats se;

int             s;
char           *yesno[] = {
    "no",
    "yes",
    0,
};
char           *txnames[] = {
    "txc",
    "rxc",
    "baud",
    "pll",
    0,
};

char           *rxnames[] = {
    "rxc",
    "txc",
    "baud",
    "pll",
    0,
};

static char  *test_usage_msg = 
		"[device {device}] [p={c/i/d/r}] [i{4-7}] [k] [st]";
/*
 * ------------------------------------------------------------------------
 * The main program to handle the command line The format of the command
 * line:
 * ------------------------------------------------------------------------
 */
main(argc, argv)
    int             argc;		       /* # of argument(s) */
    char           *argv[];		       /* pointer array to the
					        * arguments */
{
    extern int  process_sunlink_args();
    extern int  routine_usage();
    int error_in_first_check = 0, exit_code;

    versionid = "3.24";		/* sccs version id */
    from_ports = 0;             /* init source ports list */
    to_ports   = 0;             /* init dest ports list */

				/* begin Sundiag test */
    test_init(argc, argv, process_sunlink_args, routine_usage, test_usage_msg);

    signal(SIGALRM, no_receive_response);
			        /* assign trap handlers for SIGALRM signal */

    if (quick_test || sd_quick_test)
        either_quick_test = TRUE;
 
    if (!either_quick_test) /* no need for quick check if running quick test */
    {
	quick_check_flag = TRUE;
    	error_in_first_check = quick_check();
    }
    if (error_in_first_check)
    {
	exit(exit_code);
    }
    else
    {
	quick_check_flag = FALSE;
    	exit_code = exec_test();    /* execute test of ports */ 
    	if (exit_code) exit(exit_code);  
    }
    test_end();			/* Sundiag normal exit */
}

/*****************************************************************
 Process Sunlink specific arguments.
******************************************************************/
process_sunlink_args(argv, argindex)
char  *argv[];
int    argindex;
{
    func_name = "process_sunlink_args";
    TRACE_IN
    if (!det_ttyb(argv[argindex])) 		   /* ttyb option? */	
       if (!det_dcp(argv[argindex])) 	 	   /* dcp option? */
          if (!det_mcp(argv[argindex]))    	   /* mcp option? */
             if (!det_hss(argv[argindex]))         /* hss option? */
                if (!det_options(argv[argindex]))  /* other sunlink options? */
	        {
    		    TRACE_OUT
		    return FALSE;
		}
    TRACE_OUT
    return TRUE;
}

/* **********
 * det_ttyb
 * **********/

/* Determine if TTYB option selected */

det_ttyb(arg)
char *arg;
{
/* Make sure ttyb was not previously selected. */

    func_name = "det_ttyb";
    TRACE_IN
    if (strcmp(arg, "ttyb") == 0 && cur_test != TTYB) 
    {
	using_device = &testing[0];
	using_device->dcp = TRUE;
	exec_by_sundiag = FALSE;
	strcpy(using_device->device, "ttyb");
	ttyb_test = TRUE;
        cur_test = TTYB;
	testing[1] = testing[0];
	device_name = "ttyb";
        TRACE_OUT
	return TRUE;
    } 

    TRACE_OUT
    return FALSE;
}

/* *********
 * det_dcp
 * *********/

/* Determine if DCP option selected */

det_dcp(arg)
char *arg;  
{

/* Make sure 2 DCP ports had not been previously selected */
/* DCP argument should be of the form 'dcpxn' where 'x'=a-d and 'n'=0-3 */
/* Save source and destination ports lists for later processing */

    func_name = "det_dcp";
    TRACE_IN
    if (strncmp(arg, "dcp", 3) == 0 && (first_dev || second_dev))
	if (!(second_dev && cur_test != DCP)) {  /* previous device = DCP? */
	    cur_test = DCP;
	    set_dev_args(arg);			/* save source & dest lists */
	    device_name = "dcp";
	    TRACE_OUT
	    return TRUE;
	}

    TRACE_OUT
    return FALSE;
}

/* *********
 * det_mcp
 * *********/

/* Determine if MCP option selected */

det_mcp(arg)
char *arg;
{

/* Make sure 2 MCP ports had not been previouly selected */
/* MCP argument should be of form 'mcpnn' where 'nn'=0-15 */
/* Save source and destination ports lists for later processing */

    func_name = "det_mcp";
    TRACE_IN
    if (strncmp(arg, "mcp", 3) == 0 && (first_dev || second_dev)) 
	if (!(second_dev && cur_test != MCP)) {   /* previous device = MCP? */
	    cur_test = MCP;
            set_dev_args(arg);                    /* save source & dest lists */
	    device_name = "mcp";
	    TRACE_OUT
	    return TRUE;
	}

    TRACE_OUT
    return FALSE;
}

/* *********
 * det_hss
 * *********/

/* Determine if HSS device selected */

det_hss(arg)
char *arg;
{

/* Make sure 2 HSS ports have not been previously selected */
/* HSS argument should be of the form 'hssxny' where 'x'=e/o,'n'=0-3,'y'=r/v */
/* Save source and destination ports lists for later processing */
  
    func_name = "det_hss";
    TRACE_IN
    if (strncmp(arg, "hss", 3) == 0 && (first_dev || second_dev)) 
    {
	if (!(second_dev && cur_test != HSS))   /* previous device = HSS? */
	{   
            cur_test = HSS; 
            set_dev_args(arg);                  /* save source & dest lists */
	    device_name = "hss";
	    TRACE_OUT
	    return TRUE;
	}
    }
    else if (strncmp(arg, "hih", 3) == 0 && (first_dev || second_dev)) 
    {
	if (!(second_dev && cur_test != HSS))  /* previous device = HSS? */
        {   
            cur_test = HSS; 
            set_dev_args(arg);                 /* save source & dest lists */
	    device_name = "hih";
	    its_hih = TRUE;
	    TRACE_OUT
	    return TRUE;
	}
     }
     else
     {
        if (strncmp(arg, "his", 3) == 0 && (first_dev || second_dev)) 
	if (!(second_dev && cur_test != HSS))   /* previous device = HSS? */
	{  
            cur_test = HSS; 
            set_dev_args(arg);                  /* save source & dest lists */
	    device_name = "his";
	    its_his = TRUE;
	    TRACE_OUT
	    return TRUE;
	}
     }
    TRACE_OUT
    return FALSE;
}

/* **************
 * set_dev_args
/* **************

/* Save lists of source and destination ports */

set_dev_args(arg)
char *arg;
{

    func_name = "set_dev_args";
    TRACE_IN
    if (first_dev)
	from_ports = &arg[3];		/* pt to list of source ports */
    else if (second_dev) 
	to_ports = &arg[3];		/* pt to list of dest ports */

    second_dev = FALSE;
    if (first_dev) {
        first_dev = FALSE;
        second_dev = TRUE;
    }
    TRACE_OUT
}

/* *************
 * det_options
 * *************/

/* Check for other sunlink options */

det_options(arg)
char *arg;
{
    func_name = "det_options";
    TRACE_IN
    if (strncmp(arg, "p=", 2) == 0) {
	if (arg[2] == 'c') {
	    pattn_type = 'c';
	} else if (arg[2] == 'i') {
	    pattn_type = 'i';
	} else if (arg[2] == 'd') {
	    pattn_type = 'd';
	} else if (arg[2] == 'r') {
	    pattn_type = 'r';
	}
	else
	{
	    TRACE_OUT
	    return FALSE;
	}
    }
    else if (arg[0] == 'i') {
	loopback_type = atoi(&arg[1]);		/* get loopback type value */
	if (loopback_type >= SIMPLE && loopback_type <= SILENT_CLOCKLESS) {
	    internal_loopback = TRUE;
	}
	else
	{
	    TRACE_OUT
	    return FALSE;
	}
    }
    else if (arg[0] == 'I') {
	internal_loopback = TRUE;
    }
    else if (strcmp(arg, "st") == 0) {
	status_dcp = TRUE;
    }
    else if (strcmp(arg, "k") == 0) {
	load_dcp_kernal = TRUE;
    }
    else
    {
	TRACE_OUT
	return FALSE;