mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-22 11:17:19 +00:00
746 lines
17 KiB
C
746 lines
17 KiB
C
/*
|
|
* Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
*---------------------------------------------------------------------------
|
|
*
|
|
* main.c - i4b selftest utility
|
|
* -----------------------------
|
|
*
|
|
* $Id: main.c,v 1.16 2000/03/13 16:18:38 hm Exp $
|
|
*
|
|
* $FreeBSD$
|
|
*
|
|
* last edit-date: [Mon Mar 13 17:19:26 2000]
|
|
*
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
#include <stdio.h>
|
|
#include <signal.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <ctype.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
|
|
#include <machine/i4b_ioctl.h>
|
|
#include <machine/i4b_cause.h>
|
|
|
|
static void kbdrdhdl ( void );
|
|
static void isdnrdhdl (int isdnfd );
|
|
|
|
void handle_connect_ind(unsigned char *ptr);
|
|
void handle_disconnect(unsigned char *ptr);
|
|
void handle_connect_active_ind(unsigned char *ptr);
|
|
|
|
int connect_response(int isdnfd, unsigned int cdid, int response);
|
|
int disconnect_request(int isdnfd, unsigned int cdid);
|
|
unsigned int get_cdid(int isdnfd);
|
|
int connect_request(int isdnfd, unsigned int cdid);
|
|
int do_test(void);
|
|
static void cleanup(void);
|
|
static void usage(void);
|
|
void setup_wrfix(int len, unsigned char *buf);
|
|
int check_rd(int len, unsigned char *wbuf, unsigned char *rdbuf);
|
|
|
|
static int isdnfd;
|
|
char outgoingnumber[32];
|
|
char incomingnumber[32];
|
|
int debug_level = 0;
|
|
|
|
#define I4BDEVICE "/dev/i4b"
|
|
#define DATADEV0 "/dev/i4brbch0"
|
|
#define DATAUNIT0 0
|
|
#define DATADEV1 "/dev/i4brbch1"
|
|
#define DATAUNIT1 1
|
|
|
|
unsigned int out_cdid = CDID_UNUSED;
|
|
unsigned int in_cdid = CDID_UNUSED;
|
|
|
|
int waitchar = 0;
|
|
int usehdlc = 0;
|
|
int controller = 0;
|
|
int dotest = 0;
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* usage display and exit
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
usage(void)
|
|
{
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "isdntest - i4b selftest, version %d.%d.%d, compiled %s %s\n",VERSION, REL, STEP, __DATE__, __TIME__);
|
|
fprintf(stderr, "usage: isdntest [-c ctrl] [-d level] [-h] [-i telno] [-o telno] [-t num] [-w]\n");
|
|
fprintf(stderr, " -c <ctrl> specify controller to use\n");
|
|
fprintf(stderr, " -d <level> set debug level\n");
|
|
fprintf(stderr, " -h use HDLC as Bchannel protocol\n");
|
|
fprintf(stderr, " -i <telno> incoming telephone number\n");
|
|
fprintf(stderr, " -o <telno> outgoing telephone number\n");
|
|
fprintf(stderr, " -t <num> send test pattern num times\n");
|
|
fprintf(stderr, " -w wait for keyboard entry to disconnect\n");
|
|
fprintf(stderr, "\n");
|
|
exit(1);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* program entry
|
|
*---------------------------------------------------------------------------*/
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
int i;
|
|
int c;
|
|
fd_set set;
|
|
int ret;
|
|
char *ptr;
|
|
|
|
incomingnumber[0] = '\0';
|
|
outgoingnumber[0] = '\0';
|
|
|
|
while ((c = getopt(argc, argv, "c:d:hi:o:t:w")) != -1)
|
|
{
|
|
switch(c)
|
|
{
|
|
case 'c':
|
|
if(isdigit(*optarg))
|
|
{
|
|
controller = strtoul(optarg, NULL, 10);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Error: option -c requires a numeric argument!\n");
|
|
usage();
|
|
}
|
|
break;
|
|
|
|
case 'd':
|
|
if(isdigit(*optarg))
|
|
{
|
|
debug_level = strtoul(optarg, NULL, 10);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Error: option -d requires a numeric argument!\n");
|
|
usage();
|
|
}
|
|
break;
|
|
|
|
case 'o':
|
|
i = 0;
|
|
ptr = optarg;
|
|
|
|
while(*ptr)
|
|
{
|
|
if(isdigit(*ptr))
|
|
{
|
|
outgoingnumber[i++] = *ptr++;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Error: option -o requires a numeric argument!\n");
|
|
usage();
|
|
}
|
|
}
|
|
outgoingnumber[i] = '\0';
|
|
break;
|
|
|
|
case 'i':
|
|
i = 0;
|
|
ptr = optarg;
|
|
|
|
while(*ptr)
|
|
{
|
|
if(isdigit(*ptr))
|
|
{
|
|
incomingnumber[i++] = *ptr++;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Error: option -i requires a numeric argument!\n");
|
|
usage();
|
|
}
|
|
}
|
|
incomingnumber[i] = '\0';
|
|
break;
|
|
|
|
case 'w':
|
|
waitchar = 1;
|
|
break;
|
|
|
|
case 'h':
|
|
usehdlc = 1;
|
|
break;
|
|
|
|
case 't':
|
|
if(isdigit(*optarg))
|
|
{
|
|
dotest = strtoul(optarg, NULL, 10);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Error: option -t requires a numeric argument!\n");
|
|
usage();
|
|
}
|
|
break;
|
|
|
|
case '?':
|
|
default:
|
|
usage();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if((strlen(incomingnumber) == 0) || (strlen(outgoingnumber) == 0))
|
|
usage();
|
|
|
|
fprintf(stderr, "isdntest: accepting calls from telephone number [%s] \n", incomingnumber);
|
|
fprintf(stderr, "isdntest: calling out telephone number [%s] \n", outgoingnumber);
|
|
|
|
if((atexit(cleanup)) != 0)
|
|
{
|
|
fprintf(stderr, "isdntest: atexit error: %s\n", strerror(errno));
|
|
exit(1);
|
|
}
|
|
|
|
/* open isdn device */
|
|
|
|
if((isdnfd = open(I4BDEVICE, O_RDWR)) < 0)
|
|
{
|
|
fprintf(stderr, "\nisdntest: cannot open %s: %s\n", I4BDEVICE, strerror(errno));
|
|
fprintf(stderr, " isdnd is probably running, to use isdntest,\n");
|
|
fprintf(stderr, " terminate isdnd and then run isdntest again!\n");
|
|
exit(1);
|
|
}
|
|
|
|
if((out_cdid = get_cdid(isdnfd)) == 0)
|
|
{
|
|
fprintf(stderr, "isdntest: error getting cdid: %s\n", strerror(errno));
|
|
exit(1);
|
|
}
|
|
|
|
if((connect_request(isdnfd, out_cdid)) == -1)
|
|
{
|
|
fprintf(stderr, "isdntest: error, outgoing call failed!\n");
|
|
exit(1);
|
|
}
|
|
|
|
for(;;)
|
|
{
|
|
FD_ZERO(&set);
|
|
|
|
FD_SET(0, &set);
|
|
|
|
FD_SET(isdnfd, &set);
|
|
|
|
ret = select(isdnfd + 1, &set, NULL, NULL, NULL);
|
|
|
|
if(ret > 0)
|
|
{
|
|
if(FD_ISSET(isdnfd, &set))
|
|
isdnrdhdl(isdnfd);
|
|
|
|
if(FD_ISSET(0, &set))
|
|
kbdrdhdl();
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "isdntest: select error: %s\n", strerror(errno));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* data from keyboard available
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
kbdrdhdl(void)
|
|
{
|
|
cleanup();
|
|
exit(2);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* data from /dev/isdn available, read and process them
|
|
*---------------------------------------------------------------------------*/
|
|
static void
|
|
isdnrdhdl(int isdnfd)
|
|
{
|
|
static unsigned char buf[1024];
|
|
int len;
|
|
|
|
if((len = read(isdnfd, buf, 1024 - 1)) > 0)
|
|
{
|
|
switch (buf[0])
|
|
{
|
|
case MSG_CONNECT_IND:
|
|
handle_connect_ind(&buf[0]);
|
|
break;
|
|
|
|
case MSG_CONNECT_ACTIVE_IND:
|
|
handle_connect_active_ind(&buf[0]);
|
|
break;
|
|
|
|
case MSG_DISCONNECT_IND:
|
|
handle_disconnect(&buf[0]);
|
|
break;
|
|
|
|
default:
|
|
if(debug_level)
|
|
fprintf(stderr, "isdntest: unknown message 0x%x = %c\n", buf[0], buf[0]);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "isdntest: read error, errno = %d, length = %d", errno, len);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* initiate an outgoing connection
|
|
*---------------------------------------------------------------------------*/
|
|
int
|
|
connect_request(int isdnfd, unsigned int cdid)
|
|
{
|
|
msg_connect_req_t mcr;
|
|
int ret;
|
|
|
|
bzero(&mcr, sizeof(msg_connect_req_t));
|
|
|
|
mcr.controller = controller;
|
|
mcr.channel = CHAN_ANY; /* any channel */
|
|
mcr.cdid = cdid; /* cdid from get_cdid() */
|
|
|
|
if(usehdlc)
|
|
mcr.bprot = BPROT_RHDLC;/* b channel protocol */
|
|
else
|
|
mcr.bprot = BPROT_NONE; /* b channel protocol */
|
|
|
|
mcr.driver = BDRV_RBCH; /* raw b channel driver */
|
|
mcr.driver_unit = DATAUNIT0; /* raw b channel driver unit */
|
|
|
|
strcpy(mcr.dst_telno, outgoingnumber);
|
|
strcpy(mcr.src_telno, incomingnumber);
|
|
|
|
if((ret = ioctl(isdnfd, I4B_CONNECT_REQ, &mcr)) < 0)
|
|
{
|
|
fprintf(stderr, "ioctl I4B_CONNECT_REQ failed: %s", strerror(errno));
|
|
return(-1);
|
|
}
|
|
fprintf(stderr, "isdntest: calling out to telephone number [%s] \n", outgoingnumber);
|
|
return(0);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* handle setup indicator
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
handle_connect_ind(unsigned char *ptr)
|
|
{
|
|
msg_connect_ind_t *msi = (msg_connect_ind_t *)ptr;
|
|
|
|
fprintf(stderr, "isdntest: incoming SETUP: from %s to %s\n",
|
|
msi->src_telno,
|
|
msi->dst_telno);
|
|
|
|
fprintf(stderr, " channel %d, controller %d, bprot %d, cdid %d\n",
|
|
msi->channel,
|
|
msi->controller,
|
|
msi->bprot,
|
|
msi->header.cdid);
|
|
|
|
in_cdid = msi->header.cdid;
|
|
|
|
if(strcmp(msi->dst_telno, outgoingnumber))
|
|
{
|
|
msg_connect_resp_t msr;
|
|
int ret;
|
|
|
|
fprintf(stderr, "isdntest: ignoring incoming SETUP: my number [%s] != outgoing [%s]\n",
|
|
msi->dst_telno, outgoingnumber);
|
|
|
|
msr.cdid = in_cdid;
|
|
msr.response = SETUP_RESP_DNTCRE;
|
|
|
|
if((ret = ioctl(isdnfd, I4B_CONNECT_RESP, &msr)) < 0)
|
|
{
|
|
fprintf(stderr, "ioctl I4B_CONNECT_RESP ignore failed: %s", strerror(errno));
|
|
exit(1);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
msg_connect_resp_t msr;
|
|
int ret;
|
|
|
|
fprintf(stderr, "isdntest: accepting call, sending CONNECT_RESPONSE .....\n");
|
|
|
|
msr.cdid = in_cdid;
|
|
msr.response = SETUP_RESP_ACCEPT;
|
|
|
|
if(usehdlc)
|
|
msr.bprot = BPROT_RHDLC;
|
|
else
|
|
msr.bprot = BPROT_NONE;
|
|
|
|
msr.driver = BDRV_RBCH;
|
|
msr.driver_unit = DATAUNIT1;
|
|
|
|
if((ret = ioctl(isdnfd, I4B_CONNECT_RESP, &msr)) < 0)
|
|
{
|
|
fprintf(stderr, "ioctl I4B_CONNECT_RESP accept failed: %s", strerror(errno));
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
#define SLEEPTIME 5
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* handle connection active
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
handle_connect_active_ind(unsigned char *ptr)
|
|
{
|
|
msg_connect_active_ind_t *msi = (msg_connect_active_ind_t *)ptr;
|
|
int i;
|
|
|
|
fprintf(stderr, "isdntest: connection active, cdid %d\n", msi->header.cdid);
|
|
|
|
if(out_cdid == msi->header.cdid)
|
|
{
|
|
if(waitchar)
|
|
{
|
|
fprintf(stderr, "isdntest: press any key to disconnect ...%c%c%c\n", 0x07, 0x07, 0x07);
|
|
getchar();
|
|
}
|
|
else
|
|
{
|
|
if(dotest)
|
|
{
|
|
do_test();
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "isdntest: %d secs delay until disconnect:", SLEEPTIME);
|
|
|
|
for(i=0; i < SLEEPTIME;i++)
|
|
{
|
|
fprintf(stderr, " .");
|
|
sleep(1);
|
|
}
|
|
fprintf(stderr, "\n");
|
|
}
|
|
cleanup();
|
|
exit(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* handle disconnect indication
|
|
*---------------------------------------------------------------------------*/
|
|
void
|
|
handle_disconnect(unsigned char *ptr)
|
|
{
|
|
msg_disconnect_ind_t *mdi = (msg_disconnect_ind_t *)ptr;
|
|
|
|
if(mdi->header.cdid == out_cdid)
|
|
{
|
|
fprintf(stderr, "isdntest: incoming disconnect indication, cdid %d (out_cdid), cause %d\n",
|
|
mdi->header.cdid, mdi->cause);
|
|
|
|
out_cdid = CDID_UNUSED;
|
|
}
|
|
else if(mdi->header.cdid == in_cdid)
|
|
{
|
|
fprintf(stderr, "isdntest: incoming disconnect indication, cdid %d (in_cdid), cause %d\n",
|
|
mdi->header.cdid, mdi->cause);
|
|
in_cdid = CDID_UNUSED;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "isdntest: incoming disconnect indication, cdid %d (???), cause %d\n",
|
|
mdi->header.cdid, mdi->cause);
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* hang up
|
|
*---------------------------------------------------------------------------*/
|
|
int
|
|
disconnect_request(int isdnfd, unsigned int cdid)
|
|
{
|
|
msg_discon_req_t mdr;
|
|
int ret;
|
|
|
|
mdr.cdid = cdid;
|
|
mdr.cause = (CAUSET_I4B << 8) | CAUSE_I4B_NORMAL;
|
|
|
|
if((ret = ioctl(isdnfd, I4B_DISCONNECT_REQ, &mdr)) < 0)
|
|
{
|
|
fprintf(stderr, "ioctl I4B_DISCONNECT_REQ failed: %s", strerror(errno));
|
|
return(-1);
|
|
}
|
|
fprintf(stderr, "isdntest: sending disconnect request\n");
|
|
return(0);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* get cdid from kernel
|
|
*---------------------------------------------------------------------------*/
|
|
unsigned int
|
|
get_cdid(int isdnfd)
|
|
{
|
|
msg_cdid_req_t mcr;
|
|
int ret;
|
|
|
|
mcr.cdid = 0;
|
|
|
|
if((ret = ioctl(isdnfd, I4B_CDID_REQ, &mcr)) < 0)
|
|
{
|
|
fprintf(stderr, "ioctl I4B_CDID_REQ failed: %s", strerror(errno));
|
|
return(0);
|
|
}
|
|
fprintf(stderr, "isdntest: got cdid %d from kernel\n", mcr.cdid);
|
|
return(mcr.cdid);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* make shure all cdid's are inactive before leaving
|
|
*---------------------------------------------------------------------------*/
|
|
void cleanup(void)
|
|
{
|
|
int len;
|
|
char buf[1024];
|
|
|
|
if(out_cdid != CDID_UNUSED)
|
|
{
|
|
fprintf(stderr, "isdntest: cleanup, send disconnect req for out_cdid %d, in_cdid %d\n", out_cdid, in_cdid);
|
|
disconnect_request(isdnfd, out_cdid);
|
|
}
|
|
|
|
while((out_cdid != CDID_UNUSED) || (in_cdid != CDID_UNUSED))
|
|
{
|
|
if(debug_level)
|
|
fprintf(stderr, "isdntest: cleanup, out_cdid %d, in_cdid %d\n", out_cdid, in_cdid);
|
|
|
|
if((len = read(isdnfd, buf, 1024 - 1)) > 0)
|
|
{
|
|
switch (buf[0])
|
|
{
|
|
case MSG_CONNECT_IND:
|
|
handle_connect_ind(&buf[0]);
|
|
break;
|
|
|
|
case MSG_CONNECT_ACTIVE_IND:
|
|
handle_connect_active_ind(&buf[0]);
|
|
break;
|
|
|
|
case MSG_DISCONNECT_IND:
|
|
handle_disconnect(&buf[0]);
|
|
break;
|
|
|
|
default:
|
|
if(debug_level)
|
|
fprintf(stderr, "isdntest: unknown message 0x%x = %c\n", buf[0], buf[0]);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "isdntest: read error, errno = %d, length = %d", errno, len);
|
|
}
|
|
}
|
|
if(debug_level)
|
|
fprintf(stderr, "isdntest: exit cleanup, out_cdid %d, in_cdid %d\n", out_cdid, in_cdid);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* test the b-channels
|
|
*---------------------------------------------------------------------------*/
|
|
int do_test(void)
|
|
{
|
|
|
|
#define FPH 0x3c
|
|
#define FPL 0x66
|
|
|
|
int fd0, fd1;
|
|
unsigned char wrbuf[2048];
|
|
unsigned char rdbuf[2048];
|
|
int sz;
|
|
fd_set set;
|
|
struct timeval timeout;
|
|
int ret;
|
|
int frame;
|
|
int errcnt;
|
|
int frm_len;
|
|
int bytecnt = 0;
|
|
time_t start_time;
|
|
time_t cur_time;
|
|
time_t run_time;
|
|
|
|
if((fd0 = open(DATADEV0, O_RDWR)) == -1)
|
|
{
|
|
fprintf(stderr, "open of %s failed: %s", DATADEV0, strerror(errno));
|
|
return(-1);
|
|
}
|
|
|
|
if((fd1 = open(DATADEV1, O_RDWR)) == -1)
|
|
{
|
|
fprintf(stderr, "open of %s failed: %s", DATADEV1, strerror(errno));
|
|
return(-1);
|
|
}
|
|
|
|
printf("\n");
|
|
frame = 0;
|
|
errcnt = 0;
|
|
|
|
frm_len = 2;
|
|
|
|
start_time = time(NULL);
|
|
|
|
printf(" frame size errors totalbytes bps elapsedtime\n");
|
|
|
|
for(;dotest > 0; dotest--)
|
|
{
|
|
setup_wrfix(frm_len, &wrbuf[0]);
|
|
|
|
frame++;
|
|
|
|
bytecnt += frm_len;
|
|
|
|
printf("%6d %4d", frame, frm_len);
|
|
fflush(stdout);
|
|
|
|
if((sz = write(fd0, wrbuf, frm_len)) != frm_len)
|
|
{
|
|
fprintf(stderr, "write (%d of %d bytes) to %s failed: %s\n", sz, frm_len, DATADEV0, strerror(errno));
|
|
}
|
|
|
|
timeout.tv_sec = 2;
|
|
timeout.tv_usec = 0;
|
|
|
|
FD_ZERO(&set);
|
|
|
|
FD_SET(0, &set);
|
|
FD_SET(fd1, &set);
|
|
|
|
ret = select(fd1+1, &set, NULL, NULL, &timeout);
|
|
|
|
if(ret > 0)
|
|
{
|
|
if(FD_ISSET(fd1, &set))
|
|
{
|
|
if((sz = read(fd1, rdbuf, 2048)) != frm_len)
|
|
{
|
|
fprintf(stderr, "read (%d bytes) from %s failed: %s\n", sz, DATADEV1, strerror(errno));
|
|
}
|
|
|
|
cur_time = time(NULL);
|
|
run_time = difftime(cur_time, start_time);
|
|
|
|
if(run_time == 0)
|
|
run_time = 1;
|
|
|
|
printf(" %6d %10d %4d %2.2d:%2.2d:%2.2d \r",
|
|
errcnt, bytecnt,
|
|
(int)((int)bytecnt/(int)run_time),
|
|
(int)run_time/3600, (int)run_time/60, (int)run_time%60);
|
|
fflush(stdout);
|
|
|
|
errcnt += check_rd(frm_len, &wrbuf[0], &rdbuf[0]);
|
|
|
|
#ifdef NOTDEF
|
|
for(i=0; i<sz; i++)
|
|
{
|
|
printf("0x%02x ", (unsigned char)rdbuf[i]);
|
|
}
|
|
printf("\n");
|
|
#endif
|
|
}
|
|
|
|
if(FD_ISSET(0, &set))
|
|
{
|
|
return(0);
|
|
printf("\n\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "isdntest, do_test: select error: %s\n", strerror(errno));
|
|
}
|
|
|
|
frm_len = frm_len*2;
|
|
if(frm_len > 2048)
|
|
frm_len = 2;
|
|
|
|
}
|
|
printf("\n\n");
|
|
return(0);
|
|
}
|
|
|
|
void
|
|
setup_wrfix(int len, unsigned char *buf)
|
|
{
|
|
register int i;
|
|
|
|
for(i=0; i<len;)
|
|
{
|
|
*buf = FPH;
|
|
buf++;
|
|
*buf = FPL;
|
|
buf++;
|
|
i+=2;
|
|
}
|
|
}
|
|
|
|
int
|
|
check_rd(int len, unsigned char *wbuf, unsigned char *rbuf)
|
|
{
|
|
register int i;
|
|
int ret = 0;
|
|
|
|
for(i=0; i<len; i++)
|
|
{
|
|
if(*wbuf != *rbuf)
|
|
{
|
|
fprintf(stderr, "\nERROR, byte %d, written 0x%02x, read 0x%02x\n", i, *wbuf, *rbuf);
|
|
ret++;
|
|
}
|
|
wbuf++;
|
|
rbuf++;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* EOF */
|