DOSPING.C

/*===================================================================== 
P I N G . C 
 
This is the DOS side ping program.  It uses Novell's IPX/SPX APIs, 
requiring their SDK. It will send/receive 1-n IPX packets. 
======================================================================*/ 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <conio.h> 
#include <nxtdos.h> 
 
#define TIMER (unsigned long far *) 0x0000046cL 
 
char *progname; 
IPXHeader *ipx; 
int send_socket=0; 
int recv_socket; 
int datasize = 1; 
ECB send_ecb;  
ECB recv_ecb[10]; 
char mynodeaddr[6]; 
char sendb[2048]; 
char recvb[2048]; 
 
int ptype = 4; 
int niters = 1; 
 
/** 
    This is the address we try to send to.  When 
    we find a server, this address is replaced by the address 
    of the exact server.  The address is made up of: 
    bytes 1-4    = network number 
    bytes 5-10   = node number 
    bytes 11-12  = socket address 
 
**/ 
 
char destaddr[12] = { 
    0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x30, 0x00 
}; 
 
/** Function Prototypes **/ 
 
void   hang_recvs(void); 
void   cancel_recvs(void); 
void   do_recv(int); 
int    get_recv(void); 
void   find_a_server(void); 
void   print_address(char *); 
void   print_network(char *); 
void   print_nodeaddr(char *); 
void   parse_cmd_line(int, char **); 
void   swap_dwf(char *); 
char * get_node_number(char * cmd); 
char * get_network_number(char * cmd); 
/******************************************************************** 
m a i n 
*********************************************************************/ 
int main(int argc, char **argv) 
{ 
    char *p; 
    unsigned long start = *TIMER; 
    unsigned long end; 
    int cnt = 0; 
    long sendpkt = 0L; 
    long recvpkt = 0L; 
    int ttime; 
    float total = 0; 
 
    progname = *argv; 
    for (p = progname; *p; p++) { 
    if (*p == '\\') 
progname = p + 1; 
    } 
 
    /** Make sure IPX is loaded **/ 
 
    if (IPXInitialize()) { 
printf("%s: IPX IS NOT LOADED\n", progname); 
    exit(1); 
    } 
    recv_socket = *(short *)(destaddr + 10); 
    parse_cmd_line(argc, argv); 
    print_network(destaddr); 
    print_nodeaddr(destaddr + 4); 
    printf("packet type:    %d\n",ptype); 
    printf("datasize:       %d\n", datasize); 
    printf("n iterations:   %d\n", niters);     
     
 
 
    if (IPXOpenSocket(&send_socket, 0)) { 
printf("%s: ERROR: unable to open socket\n", progname); 
exit(1); 
    } 
    recv_socket = send_socket; 
    if (IPXGetLocalTarget(destaddr, send_ecb.immediateAddress, &ttime)) { 
printf("%s: ERROR: unable to get local target\n", progname); 
exit(1); 
    } 
 
    memcpy(mynodeaddr, send_ecb.immediateAddress, 6); 
 
    /** Go find a server **/ 
 
    find_a_server();  
hang_recvs(); 
 
 
    /** Do # iterations (default = 1) **/ 
while (cnt < niters) { 
    int rcv; 
/** send a packet **/ 
*(sendb + 5) = ptype; 
    memcpy(sendb + 6, destaddr, 12); 
    memcpy(send_ecb.immediateAddress, mynodeaddr, 6); 
    send_ecb.socketNumber = send_socket; 
    send_ecb.fragmentCount = 1; 
    send_ecb.fragmentDescriptor[0].address = sendb; 
    send_ecb.fragmentDescriptor[0].size = 30 + datasize; 
 
IPXSendPacket(&send_ecb); 
 
while (send_ecb.inUseFlag) /* wait for it to finish */ 
; 
 
if (send_ecb.completionCode) { 
cancel_recvs(); 
IPXCloseSocket(send_socket); 
printf("%s: Error sending packet: %d\n", progname, send_ecb.completionCode); 
exit(1); 
} 
 
    sendpkt++; 
    total += 30 + datasize;     /* Count the bytes */ 
    printf("\rSend packet Number %d ", sendpkt); 
 
    if ((rcv = get_recv()) == -1) 
goto EXIT; 
 
    do_recv(rcv); 
    total += 30 + datasize;     /* Count the bytes */ 
 
    cnt++; 
    recvpkt++; 
    printf(": Recv packet Number %d ", recvpkt); 
} 
 
/** We did 1000 packets - print KB per second **/ 
EXIT: 
end = *TIMER; 
end = (end - start) / 18.2; /* Num seconds it took */ 
 
total = (float)((total / 1024.0) / end); 
 
    /** All done - cancel recvs and exit **/ 
    cancel_recvs(); 
    IPXCloseSocket(send_socket); 
    printf("\n%ld packets \n", recvpkt); 
    if (recvpkt) 
printf("Average time per iteration: %5.3f\n",total/recvpkt); 
    exit(0); 
} 
 
/*page************************************************************** 
h a n g _ r e c v s 
 
Arguments - None 
 
Returns - nothing 
*******************************************************************/ 
void hang_recvs(void) 
{ 
    int i; 
 
    for (i = 0; i < 10; i++) { 
 
/** Don't hang recv on one that is already hung **/ 
 
if (recv_ecb[i].inUseFlag) 
    continue; 
 
/** Hang a recv **/ 
 
memset(&recv_ecb[i], 0, sizeof(ECB)); 
recv_ecb[i].socketNumber = recv_socket; 
recv_ecb[i].fragmentCount = 1; 
recv_ecb[i].fragmentDescriptor[0].address = recvb; 
recv_ecb[i].fragmentDescriptor[0].size = 2048; 
IPXListenForPacket(&recv_ecb[i]); 
    } 
 
    /** All done **/ 
 
    return; 
} 
 
/*page************************************************************** 
c a n c e l _ r e c v s 
 
Arguments - None 
 
Returns - nothing 
*******************************************************************/ 
void cancel_recvs(void) 
{ 
    int i; 
 
    for (i = 0; i < 10; i++) { 
 
/** If recv not in use - skip it **/ 
 
if (!recv_ecb[i].inUseFlag) 
    continue; 
 
/** Cancel the recv **/ 
 
IPXCancelEvent(&recv_ecb[i]); 
    } 
 
    /** All done **/ 
 
    return; 
} 
 
/*page************************************************************** 
d o _ r e c v 
 
Arguments - i = recv index to hang 
 
Returns - nothing 
*******************************************************************/ 
void do_recv(int i) 
{ 
    memset(&recv_ecb[i], 0, sizeof(ECB)); 
    recv_ecb[i].socketNumber = recv_socket; 
    recv_ecb[i].fragmentCount = 1; 
    recv_ecb[i].fragmentDescriptor[0].address = recvb; 
    recv_ecb[i].fragmentDescriptor[0].size = 2048; 
    IPXListenForPacket(&recv_ecb[i]); 
    return; 
} 
 
/*page************************************************************** 
g e t _ r e c v 
 
Arguments - none 
 
Returns - -1 = User hit a key 
  else = recv index that was hit 
*******************************************************************/ 
int get_recv(void) 
{ 
    int i; 
 
    /** **/ 
 
    while (!kbhit()) { 
for (i = 0; i < 10; i++) { 
if (!recv_ecb[i].inUseFlag) 
return i; 
}                         
//      try resending the bugger...maybe we be out of synch?..bug,bug,bug???     
    IPXSendPacket(&send_ecb);            
    } 
 
    /** Return that user hit a key **/ 
 
    return -1; 
} 
 
/******************************************************************* 
function name:      f i n d _ a _ s e r v e r 
    Description:    make sure can find the machine we want to send to 
    Arguments:      none 
    Returns:        none 
*********************************************************************/ 
void find_a_server(void) 
{ 
    long start; 
    long end; 
    ECB send_ecb; 
    ECB recv_ecb; 
 
    /** Setup the recv ecb and listen for a packet **/ 
 
    memset(&recv_ecb, 0, sizeof(ECB)); 
    recv_ecb.socketNumber = recv_socket; 
    recv_ecb.fragmentCount = 1; 
    recv_ecb.fragmentDescriptor[0].address = recvb; 
    recv_ecb.fragmentDescriptor[0].size = 31; 
    IPXListenForPacket(&recv_ecb); 
 
    memset(&send_ecb, 0, sizeof(ECB)); 
    memcpy(sendb + 6, destaddr, 12); 
    send_ecb.socketNumber = send_socket; 
    memcpy(send_ecb.immediateAddress, mynodeaddr, 6); 
    send_ecb.fragmentCount = 1; 
    send_ecb.fragmentDescriptor[0].address = sendb; 
    send_ecb.fragmentDescriptor[0].size = 31; 
 
    IPXSendPacket(&send_ecb); 
 
    while (send_ecb.inUseFlag && !kbhit()) 
; 
 
    if (send_ecb.completionCode) { 
printf("%s: ERROR: send completion code 0x%02x\n", progname, send_ecb.completionCode); 
exit(1); 
    } 
 
    /** Wait awhile for the recv to pay off **/ 
 
    start = *TIMER; 
 
    while (recv_ecb.inUseFlag && !kbhit() && (*TIMER - start) < 180L) 
; 
    end = *TIMER; 
 
    /** If we timed out - then we couldn't find a server **/ 
 
    if (end - start >= 180L) { 
IPXCancelEvent(&recv_ecb); 
IPXCloseSocket(send_socket); 
printf("%s: Unable to find a server\n", progname); 
exit(1); 
    } 
 
    /** If recv still in use - error **/ 
 
    if (recv_ecb.inUseFlag) { 
IPXCancelEvent(&recv_ecb); 
IPXCloseSocket(send_socket); 
printf("%s: Program terminated by a keystroke\n", progname); 
exit(1); 
    } 
 
    /** If recv error - clean up and exit **/ 
 
    if (recv_ecb.completionCode) { 
IPXCancelEvent(&recv_ecb); 
IPXCloseSocket(send_socket); 
printf("%s: Error receiving packet: %d\n", progname, recv_ecb.completionCode); 
exit(1); 
    } 
 
    /** Get the server address and print it out **/ 
 
    memcpy(destaddr, recvb + 18, 12);   /* Set the address to send to */ 
    memcpy(mynodeaddr, recv_ecb.immediateAddress, 6); 
    printf("Found server: "); 
    print_address(destaddr); 
 
    /** All done **/ 
 
    return; 
} 
 
/******************************************************************** 
p r i n t _ a d d r e s s 
 
Arguments - netaddr = ptr to 14 bytes address to print 
 
Returns - nothing 
*********************************************************************/ 
void print_address(char *netaddr) 
{ 
    int i; 
 
    for (i = 0; i < 12; i++) { 
if ((i == 4) || (i == 10)) 
    printf(" "); 
printf("%02X", (unsigned char) *(netaddr + i)); 
} 
    printf("\n"); 
    return; 
} 
 
void print_network(char *p) 
{ 
    int i; 
    printf("Network Number: "); 
    for (i = 0; i < 4; i++) 
printf("%02X", (unsigned char) *p++); 
    printf("\n"); 
    return; 
} 
 
void print_nodeaddr(char *p) 
{ 
    int i; 
 
    printf("Node Address:   "); 
    for (i = 0; i < 6; i++) 
printf("%02X", (unsigned char) *p++); 
    printf("\n"); 
    return; 
} 
 
/*----------------------------------------------------------------- 
function name: parse_cmd_line 
Description: 
    Parse the command line for the parameters and host name. 
Arguments:      
       -i <number of iterations> 
       -p <packet type> 
       -d <data size> 
  NOTE: must be < frame size - 14 (MAC length) - 30 (IPX header) 
       -n <network number> 
  NOTE: you can ignore this if on the same subnet.  Must be 4 hex 
bytes 
       -a <destination address> 
  NOTE: must be 6 hex bytes representing the physical NIC address of 
the remote machine. 
       -s <socket> 
  Two byte socket number 
Returns:        Nothing 
----------------------------------------------------------------------*/ 
void parse_cmd_line(int argc, char **argv) 
{ 
    short socket; 
 
    argv++;                      /* skip to first arg */ 
    while (--argc) {             /* do all args */ 
if (**argv == '-') { 
    ++(*argv); 
    switch(tolower(**argv)) { 
case 'i': 
    niters = atoi(++(*argv)); 
    if (niters < 0)  
       niters = 1; 
    break;    
case 'p': 
    ptype = atoi(++(*argv)); 
    if (ptype < 0 || ptype > 255) { 
ptype = 4; 
printf("%s: Invalid packet type.  Setting to default = %d\n", 
progname,ptype); 
    } 
    break; 
case 'd':  /*amount of data to send in a frame */ 
    datasize = atoi(++(*argv)); 
    if (!datasize) { 
datasize = 1; 
printf("%s: Datasize cannot be zero. Setting to default = 1\n", progname); 
    } 
    break; 
case 's':  /* socket number, default = 0x3000 */ 
    socket = (short)strtol(++(*argv), NULL, 16); 
    printf("New socket = 0x%x\n", socket); 
    *(short *)(destaddr + 10) = socket; 
    swap_dwf(destaddr + 10); 
    break; 
case 'n':  /* network number, default = local net (= 0) */ 
    ++(*argv); 
    memcpy(destaddr, get_network_number(*argv),4); 
    if (destaddr[0] == 'X') { 
printf("\n****!\n%s is an incorrect net number.\n****!\n", *argv); 
printf("%s E.G.: -nAABBCCDD (I.E.: 8 hex digits)\n"); 
exit(1); 
    } 
    break; 
case 'a': /* remote address, have to know this */ 
    ++(*argv); 
    memcpy(destaddr+4, get_node_number(*argv), 6); 
    if (*(destaddr+4) == 'X') { 
       printf("\n****!\n%s is an incorrect Node address.\n****!\n", *argv); 
       printf("\n E.G.: -a 023C8DAADDCC (12 hex digits)\n"); 
       exit(1); 
    } 
    break; 
default: 
    printf("%s [-p] [-d] [-nxxxxxxxx] [-axxxxxxxxxxxx] [-sx]\n", progname); 
    printf("     -p - packet type\n"); 
    printf("     -d - data size\n"); 
    printf("     -n - network number (in hex)\n"); 
    printf("     -a - address (in hex)\n"); 
    printf("     -s - socket number (in hex)\n"); 
    exit(0); 
    } 
    argv++; 
} 
    } 
    return; 
} 
/********************************************************************** 
    g e t _ h e x _ b y t e 
 
    Converts the character passed in to a hexadecimal nibble. 
 
    Arguments:    char    character to convert 
 
    Returns:      UCHAR   hex nibble 
**************************************************************************/ 
char get_hex_byte(char ch) 
{ 
    if (ch >= '0' && ch <= '9') 
    return (ch - '0'); 
 
    if (ch >= 'A' && ch <= 'F') 
    return ((ch - 'A') + 0x0A); 
 
    return -1; 
} 
/********************************************************************** 
    g e t _ h e x _ s t r i n g 
 
    Reads in a character string containing hex digits and converts 
    it to a hexadecimal number. 
 
    Arguments:    src   => source string to convert 
  dest  => destination for hex number 
  num   => number of chars to convert 
 
    Returns:      nothing 
**************************************************************************/ 
char get_hex_string(char * src, char * dest, int num) 
{ 
    char *   q = src; 
    char     hexbyte1,hexbyte2; 
 
    strupr(q); 
    while (num--) 
      {hexbyte1 = get_hex_byte(*q++); 
       hexbyte2 = get_hex_byte(*q++); 
       if ( (hexbyte1 < 0) || (hexbyte2 < 0) ) 
      return -1; 
       *dest++ = (hexbyte1 << 4) + hexbyte2; 
      } 
 
    return(0); 
} 
/************************************************************************* 
    g e t _ n o d e _ n u m b e r 
 
    Reads a node number from the given string. 
 
    Arguments:    cmd  => string to read from 
 
    Returns:      hex node number 
**************************************************************************/ 
char * get_node_number(char * cmd) 
{ 
    static char hex_num[6]; 
 
    memset(hex_num, 0, 6); 
 
    if (strlen(cmd) != 12){ 
    hex_num[0] = 'X'; 
    return hex_num; 
       } 
 
    if (get_hex_string(cmd, hex_num, 6) < 0) 
    hex_num[0] = 'X'; 
    return hex_num; 
} 
/************************************************************************** 
    g e t _ n e t w o k _ n u m b e r 
 
    Reads a network number from the given string. 
 
    Arguments:    cmd   string to read from 
 
    Returns:      hex network number 
**************************************************************************/ 
char * get_network_number(char * cmd) 
{ 
    static char hex_num[4]; 
 
    memset(hex_num, 0, 4); 
 
    if (strlen(cmd) != 8) { 
    hex_num[0] = 'X'; 
    return(hex_num); 
    } 
 
    if (get_hex_string(cmd, hex_num, 4) < 0) 
    hex_num[0] = 'X'; 
 
    return hex_num; 
} 
/******************************************************************* 
s w a p _ d w f 
 
Swap the bytes pointed to by p. 
 
Arguments - p = ptr to word to swap 
 
Returns - nothing 
********************************************************************/ 
void swap_dwf(char *p) 
{ 
    char tmp; 
 
    tmp = *p; 
    *p = *(p + 1); 
    *(p + 1) = tmp; 
    return; 
}