sunlink.c

操作系统SunOS 4.1.3版本的源码

                readmask = 1 << rec_device->fid;
        }
        readmask = 1 << rec_device->fid;
        if (select(32, &readmask, 0, 0, &long_time) == 1) 
        {
                send_message(-ACTIVITY_ON_LINE, ERROR,"Packet received but none sent!  \
                   Activity on-line.  Quiesce other end before starting.");
        }
	TRACE_OUT
}


/* **********
 * xmit_buf 
 * **********/

/* Transmit buffer */

xmit_buf(sbufptr, transmit_length, buf_cnt)
u_char  *sbufptr;
u_long  transmit_length;
int	buf_cnt;
{
    int             nbytes;

    func_name = "xmit_buf"; 
    TRACE_IN 
    send_message(0, DEBUG, "Starting transmit '%s'", xmit_device->device);

    if (simulate_error != RECEIVE_TIMEOUT) 
    {
	if ((nbytes = write(xmit_device->fid, sbufptr, transmit_length)) == -1) 
	{
	    perror(perror_msg);
	    errors++;
	    send_message(-WRITE_FAILED, ERROR, "transmit failed on '%s'.", 
				xmit_device->device);
	}
    }
    send_message(0, DEBUG, "Transmit complete '%s', buffer %d length %d",
               xmit_device->device, buf_cnt + 1, transmit_length);
    if (debug)
	sleep(1);

    if (check_point) 
    {
	printf("Data transmitted on device '%s', data = %x %x %x.\n", xmit_device->device, sbarray[0], sbarray[1], sbarray[2]);
    }
    TRACE_OUT
}

/* *************
 * receive_buf
 * *************/

receive_buf(rbufptr, transmit_length)
u_char  *rbufptr;
u_long  transmit_length;
{
    int             nbytes;

    func_name = "receive_buf"; 
    TRACE_IN 
    send_message(0, DEBUG, "Starting receive '%s'", rec_device->device);
    
    if (either_quick_test)
	alarm(4);
    else
	alarm(RECEIVE_WAIT_TIME);
    if (!ttyb_test || simulate_error == READ_FAILED || simulate_error == RECEIVE_TIMEOUT)
	if ((nbytes = read(rec_device->fid, rbufptr, transmit_length)) == -1) 
	{
	    alarm(0);
	    perror(perror_msg);
	    errors++;
	    send_message(-READ_FAILED, ERROR, "receive failed on '%s'.", 
		rec_device->device);
	}
    alarm(0);

    send_message(0, DEBUG, "Receive complete '%s', length %d.",
                rec_device->device, nbytes);

    if (check_point) 
    {
	printf("Data received on device '%s', data = %x %x %x.\n", rec_device->device, rbarray[0], rbarray[1], rbarray[2]);
    }
    TRACE_OUT
}

/* *************
 * compare_buf
 * *************/

/* Compare transmitted and received buffers */

compare_buf(sbufptr, rbufptr, transmit_length)
u_char  *sbufptr;
u_char  *rbufptr;
u_long  transmit_length;
{
    register	    j;

    func_name = "compare_buf"; 
    TRACE_IN 
    if (simulate_error == COMPARE_ERROR)
        sbarray[transmit_length - 1]--;  /* manipulate data for compare error */
   
    if (!ttyb_test || simulate_error == COMPARE_ERROR)
	if (bcmp(sbufptr, rbufptr, transmit_length)) 
	{
	    errors++;
	    for (j = 0; j <= transmit_length; j++) 
	    {
		if (rbarray[j] != sbarray[j]) 
		    break;
	    }
	    sprintf(msg, "data compare error on '%s', exp = 0x%x, actual = 0x%x, offset = %d.", rec_device->device, sbarray[j], rbarray[j], j);
	    if (!run_on_error || errors >= ERROR_THRESHOLD) 
		send_message(-COMPARE_ERROR, ERROR, msg);
	    else
		send_message(0, WARNING, msg); 

	    return_code = COMPARE_ERROR;
	}
    TRACE_OUT
}

no_receive_response()
{
    func_name = "no_receive_response"; 
    TRACE_IN 
    send_message(-RECEIVE_TIMEOUT, ERROR, 
	"'%s' does not respond, check loopback connector.", rec_device->device);
    TRACE_OUT
}

/*
 * -------------------------------------------------------------------
 * prepare sending buffer
 * -------------------------------------------------------------------
 */

prepare_buffer()
{
    register int    k, j;
    register u_char *mptr;

    func_name = "prepare_buffer"; 
    TRACE_IN 
    mptr = sbarray;
    switch (pattn_type) {

    case 'c':
	for (j = 0; j < MAX_LENGTH; j++)      /* filling */
	    *mptr++ = pattern;
	break;
    case 'i':
	k = pattern;
	for (j = 0; j < MAX_LENGTH; j++)      /* filling */
	    *mptr++ = (u_char) k++;
	break;
    case 'd':
	k = pattern;
	for (j = 0; j < MAX_LENGTH; j++)      /* filling */
	    *mptr++ = (u_char) k--;
	break;
    case 'r':
	for (j = 0; j < MAX_LENGTH; j++)      /* filling */
	    *mptr++ = (u_char) random();
	break;
    }
    TRACE_OUT
}

/*
 * -----------------------------------------------------------------------
 * this subroutine displays the statistic
 * -----------------------------------------------------------------------
 */

statistics()
{
    int             io_op;
    int             ss;

    func_name = "statistics"; 
    TRACE_IN 	
    if (simulate_error == NO_STAT_SOCKET)
	sock_type = 7;
    else
	sock_type = SOCK_DGRAM;
    if ((ss = socket(AF_INET, sock_type, 0)) < 0) 
    {
	perror("sunlink: socket, perror says");
	send_message(0, INFO, "Couldn't open a socket for statistics, '%s'.",
            using_device->device);
	if (simulate_error != NO_STAT_SOCKET)
	{
	    TRACE_OUT
	    return;
	}
    }
    strcpy(ifr.ifr_name, using_device->device);
    if (ioctl(using_device->s, SIOCGETSYNC, &ifr)) 
    {
	perror("sunlink: SIOCGETSYNC, perror says");
	fprintf(stderr,
		"sunlink: Couldn't get sync mode statistics for '%s'.\n", using_device->device);
    }
    sm = *(struct syncmode *) ifr.ifr_data;
    strcpy(ifr.ifr_name, using_device->device);
    if (ioctl(using_device->s, SIOCSSDSTATS, &ifr)) 
    {
	perror("sunlink: SIOCSSDSTATS, perror says");
	fprintf(stderr,
		"sunlink: Couldn't get data statistics for '%s'.\n", using_device->device);
    }
    sd = *(struct ss_dstats *) ifr.ifr_data;
    strcpy(ifr.ifr_name, using_device->device);
    if (ioctl(using_device->s, SIOCSSESTATS, &ifr)) 
    {
	perror("sunlink: SIOCSSESTATS, perror says");
	fprintf(stderr,
		"sunlink: Couldn't get error statistics for '%s'.\n", using_device->device);
    }
    if (ss)
	close(ss);
    se = *(struct ss_estats *) ifr.ifr_data;

    printf("\n%s: ", using_device->device);
    printf("baud %d", sm.sm_baudrate);
    printf("  pkts: i %d", sd.ssd_ipack);
    printf("  o %d", sd.ssd_opack);
    printf("  chars: i %d", sd.ssd_ichar);
    printf("  o %d\n", sd.ssd_ochar);
    printf("       underruns %d", se.sse_underrun);
    printf("  overruns %d", se.sse_overrun);
    printf("  aborts %d", se.sse_abort);
    printf("  crcs %d", se.sse_crc);
    printf("  error frames %d\n\n", err_frame_no);
    
    TRACE_OUT
}

layer(dir, name, oname)
int	dir;
char	*name, *oname;
{
    struct ifreq    ifr_tmp;

    func_name = "layer"; 
    TRACE_IN 
    strncpy(ifr_tmp.ifr_name, name, sizeof(ifr_tmp.ifr_name));
    strncpy(ifr_tmp.ifr_oname, oname, sizeof(ifr_tmp.ifr_oname));
    TRACE_OUT
    return ioctl(using_device->s, dir, (caddr_t) & ifr_tmp);
}

/*
 * ------------------------------------------------------------- set default
 * parameters for the sunlink
 * -------------------------------------------------------------
 */
init_parm()
{
    int             i, disp;

    func_name = "init_parm"; 
    TRACE_IN 
    protocol = SDLC_PROTOCOL;
    if (simulate_error != 0) 
    {
        if (simulate_error == NO_LAYER_LOOPBACK)
            protocol = LOOPBACK;
        if (simulate_error == NO_BSC)
            protocol = BSC_PROTOCOL;
        if (simulate_error == NO_ASYNC)
            protocol = ASYNC_PROTOCOL;
        if (simulate_error == ILLEGAL_PROTOCOL)
            protocol = ILLEGAL_PROTOCOL;
    }

    baudrate = 9600;
    if (internal_loopback)
	clock_type = '0';
    else
	clock_type = '1';
    loop_count = 1;
    if (debug || ttyb_test || simulate_error) 
    {
	min_frame_len = 10;
	max_frame_len = 13;
    } 
    else 
    {
	if (internal_loopback) 
        {
	/*  min_frame_len = 1; */
	    min_frame_len = 2;
	    max_frame_len = 255;
	} 
        else 
	{
	    min_frame_len = MAX_LENGTH;
	    max_frame_len = MAX_LENGTH;
	    if (!either_quick_test)
		loop_count = 100;
	}
    }
    disp = FALSE;
    if (load_dcp_kernal) 
    {
	load_dcp_a = TRUE;
	load_dcp_b = TRUE;
	load_dcp_c = TRUE;
	load_dcp_d = TRUE;
	disp = TRUE;
    }
    for (i = 0; i < 4; i++) 
    {
	attach_a[i] = disp;
	attach_b[i] = disp;
	attach_c[i] = disp;
	attach_d[i] = disp;
    }
    lb_mptr = "yes";
    nrzi_mptr = "no";
    txc_mptr = "baud";
    rxc_mptr = "baud";
    ssm->sm_txclock = TXC_IS_BAUD;
    ssm->sm_rxclock = TXC_IS_BAUD;
    ssm->sm_loopback = 1;
    ssm->sm_nrzi = 0;

    TRACE_OUT
}

test_ports(ports_open)
int ports_open;			/* indicates if ports already open */
				/* port to port only */
{

    func_name = "test_ports"; 
    TRACE_IN 
    if (!ports_open) 
    {
    	using_device = xmit_device;
    	open_ports();
    	if (port_to_port) 
        {
	    using_device = rec_device;
	    open_ports();
       	}
    }

    strcpy(device, rec_device->device);	/* set name for error report */
    device_name = device;

    if (!status_dcp)
        exercise_dcp();

    if (status_dcp || (debug && !ttyb_test)) 
    {
	using_device = xmit_device;
	statistics();
	if (port_to_port) 
        {
	    using_device = rec_device;
	    statistics();
	}
    }

    if ((port_to_port && ports_open) || !port_to_port) 
    {
    	if (xmit_device->s)
	    close(xmit_device->s);
	send_message(0, DEBUG, "Close transmit port '%s'.\n", 
		xmit_device->device);

    	if (xmit_device->fid) 
        {
	    flock(xmit_device->fid, LOCK_UN);	/* unlock file */
	    close(xmit_device->fid);
        }

    	if (rec_device->s)
            close(rec_device->s);
	send_message(0, DEBUG,"Close receive port '%s'.\n", rec_device->device);
 
    	if (rec_device->fid) 
   	{
	    flock(rec_device->fid, LOCK_UN);	/* unlock file */
            close(rec_device->fid);
    	}
    }
    TRACE_OUT
}

open_ports()
{
    int i;
    int open_ret;

    func_name = "open_ports"; 
    TRACE_IN 
    if (using_device->dcp || simulate_error == DEV_NOT_OPEN) 
    {
	sprintf(tmpbuf, "/dev/%s", 
                using_device->dcp ? using_device->device : "dev.invalid");

	if ((using_device->fid = open(tmpbuf, O_RDWR, 0)) == -1) 
	{
	    perror(perror_msg);
	    sprintf(msg, "Couldn't open file '%s'.", tmpbuf);
            if (run_on_error && (verbose || single_pass))		
		send_message(0, WARNING, msg);
	    else
		send_message(-DEV_NOT_OPEN, ERROR, msg);
	    return_code = DEV_NOT_OPEN;
	    TRACE_OUT
	    return(FALSE);
	} 
    } 
    else 
    {
	for (i=0; i < MAX_IFD; i++) 
 	{
            sprintf(tmpbuf, "/dev/ifd%d", i);   /* ifd name for MCP or HSI */
 
	    send_message(0, DEBUG, "opening %s\n", tmpbuf);
            if ((using_device->fid = open(tmpbuf, O_RDWR|O_EXCL, 0)) != -1) 
	    {
     						/* locked? */
                if (flock(using_device->fid, LOCK_EX|LOCK_NB) != -1)
                    break;
		else
		    close(using_device->fid);
	    }
        }
	if (i >= MAX_IFD)                       /* no available ifd file */
 	{
            strcpy(msg, "No /dev/ifd files available.");
		
            if (run_on_error && (verbose || single_pass))
                send_message(0, WARNING, msg);
            else
                send_message(-DEV_NOT_AVAIL, ERROR, msg);

	    return_code = DEV_NOT_AVAIL;
	    TRACE_OUT
	    return FALSE;
	}
	sprintf(using_device->ifdname, "ifd%d", i);
        layer(SIOCUPPER, using_device->device, using_device->ifdname);
	layer(SIOCLOWER, using_device->ifdname, using_device->device);
    }
    TRACE_OUT
}

routine_usage()
{
    func_name = "proc_sund_ports"; 
    TRACE_IN 
    printf("Routine specific arguments [defaults]:\n");
    printf("device : SunLink port(s) to test [none]\n");
    printf("   Supported devices:\n");
    printf("         mcp0 -  mcp15\n");
    printf("         dcpa0 - dcpd3\n");
    printf("p= Data pattern [r]\n");
    printf("    c : character 0x55\n");
    printf("    i : incrementing\n");
    printf("    d : decrementing\n");
    printf("    d : random\n");
    printf("i : internal loopback [external]\n");
    printf("k : load dcp kernal [no load]\n");
    printf("st : display sunlink status only\n\n");
}

/**** dummy code to satisfy libtest.a *******/
clean_up()
{
}