home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / netds / winsock / nwlink / testlib / cmdline.c next >
C/C++ Source or Header  |  1997-10-05  |  19KB  |  711 lines
  1. /****************************************************************************\
  2. *  cmdline.c -- sample program library demonstrating NWLink.
  3. *
  4. *       Microsoft Developer Support
  5. *       Copyright (c) 1992-1997 Microsoft Corporation
  6. *
  7. *  Demonstrates basic sockets programming with the Windows Sockets API
  8. *  using the NWLink transport.
  9. * 
  10. ****************************************************************************/
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <windows.h>
  14. #include <string.h>
  15. #include <stdlib.h>
  16. #include <ctype.h>
  17. #include "externs.h"
  18. #include <wsipx.h>
  19. #include "testlib.h"
  20.  
  21. /*
  22. *   Global variables that can be set on the command line 
  23. */
  24.  
  25. int     verbose = 0;
  26. int     Socket_Type = SOCK_DGRAM;
  27. int     Protocol = NSPROTO_IPX;
  28. int     Backlog = 1;
  29. int     No_Broadcast = 0;
  30. int     No_Loop = 0;
  31. int     Sleep_Time = 250;
  32. int     Send_Length = 1024;
  33. int     Receive_Length = 1024;
  34. int     Local_Packet_Type = 0;
  35. int     Send_Packet_Type = 9;
  36. int     Filter_Packet_Type = 0;
  37. int     Local_Address_Family = AF_NS;
  38. int     Remote_Address_Family = AF_NS;
  39. char    Local_Network_Number[4]  = {0x00, 0x00, 0x00, 0x00};
  40. char    Local_Node_Number[6]     = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  41. char    Local_Socket_Number[2]   = {0x00, 0x00};
  42. char    Remote_Network_Number[4] = {0x00, 0x00, 0x00, 0x00};
  43. char    Remote_Node_Number[6]    = "\xFF\xFF\xFF\xFF\xFF\xFF";
  44. char    Remote_Socket_Number[2]  = {0x12, 0x34};
  45.  
  46. /*
  47. *   Function prototypes for this file 
  48. */
  49.  
  50. void  usage(LPSTR);
  51. void  dump_defaults(LPSTR);
  52. void  get_hex_string(LPSTR, LPSTR, int);
  53. UCHAR get_hex_byte(char);
  54.  
  55. /****************************************************************************
  56. *
  57. *    FUNCTION:  parse_cmd_line( int argc, char **argv )
  58. *
  59. *    DESCRIPTION:  Routine used by all of the WinSock test programs for NWLink.
  60. *            Parses the command line and sets the respective global variables. 
  61. *
  62. *    ARGUMENTS:     char **     => array of command line arguments
  63. *                int         number of command line arguments
  64. *
  65. *     RETURNS:  nothing
  66. *
  67. *\***************************************************************************/
  68. void parse_cmd_line(int argc, char **argv)
  69. {
  70.     LPSTR p;
  71.     int num = 1;
  72.  
  73.     argc--;
  74.  
  75.     /*
  76.     *   Parse each command line parameter 
  77.     */
  78.  
  79.     while (num <= argc) {
  80.         /*
  81.         *   If option starts with '-' or '/', skip it 
  82.         */
  83.  
  84.         p = strupr(argv[num++]);
  85.         if (*p == '-' || *p == '/')
  86.             p++;
  87.  
  88.         /*
  89.         *   Help ? 
  90.         */
  91.  
  92.         printf("***> command: %s\n:",p);
  93.         if (*p == 'h' || *p == 'H' || *p == '?' || !stricmp(p, "help"))
  94.         usage(argv[0]);
  95.  
  96.         /*
  97.         *   Verbose option? 
  98.         */
  99.  
  100.         if (!stricmp(p, "v") || !stricmp(p, "verbose")) {
  101.             verbose++;
  102.  
  103.             printf("verbose is ON\n");
  104.             continue;
  105.         }
  106.  
  107.         /*
  108.         *   Display default values ? 
  109.         */
  110.  
  111.         if (!strnicmp(p, "default", 7)) {
  112.             p+= 7;
  113.  
  114.             dump_defaults(argv[0]);
  115.         }
  116.  
  117.         /*
  118.         *   Local address family ? 
  119.         */
  120.  
  121.         if (!strnicmp(p, "laf:", 4)) {
  122.             p+= 4;
  123.  
  124.             /*
  125.             *   Get the address family from the option 
  126.             */
  127.  
  128.             Local_Address_Family = atoi(p);
  129.  
  130.             if (verbose)
  131.                 printf("Local_Address_Family = %d\n", Local_Address_Family);
  132.             continue;
  133.         }
  134.  
  135.         /*
  136.         *   Remote address family ? 
  137.         */
  138.  
  139.         if (!strnicmp(p, "raf:", 4)) {
  140.             p+= 4;
  141.  
  142.             /*
  143.             *   Get the address family from the option 
  144.             */
  145.  
  146.             Remote_Address_Family = atoi(p);
  147.  
  148.             if (verbose)
  149.                 printf("Remote_Address_Family = %d\n", Remote_Address_Family);
  150.             continue;
  151.         }
  152.  
  153.         /*
  154.         *   Socket type ? 
  155.         */
  156.  
  157.         if (!strnicmp(p, "st:", 3)) {
  158.             p+= 3;
  159.  
  160.             /*
  161.             *   Get the socket type from the option 
  162.             */
  163.  
  164.             Socket_Type = atoi(p);
  165.             if (verbose)
  166.         printf("Socket_Type = %d\n", Socket_Type);
  167.             continue;
  168.         }
  169. #if(0)
  170.         /*
  171.         *   Socket family ? 
  172.         */
  173.  
  174.         if (!strnicmp(p, "sf:", 3)) {
  175.             p+= 3;
  176.  
  177.             /*
  178.             *   Get the socket family from the option 
  179.             */
  180.  
  181.             Socket_Family = get_socket_family(p);
  182.             continue;
  183.         }
  184. #endif
  185.         /*
  186.         *   Protocol ? 
  187.         */
  188.  
  189.         if (!strnicmp(p, "proto:", 6)) {
  190.             p+= 6;
  191.  
  192.             /*
  193.             *   Get the protocol from the option 
  194.             */
  195.  
  196.             Protocol = atoi(p);
  197.  
  198.             if (verbose)
  199.             printf("Protocol = %d\n", Protocol);
  200.             continue;
  201.         }
  202.  
  203.         /*
  204.         *   Local network number ? 
  205.         */
  206.  
  207.         if (!strnicmp(p, "lnet:", 5)) {
  208.             p+= 5;
  209.  
  210.             /*
  211.             *   Get the local network number from the option 
  212.             */
  213.  
  214.             memcpy(Local_Network_Number, get_network_number(p), 4);
  215.             if (verbose) {
  216.                 printf("Local_Network_Number = ");
  217.                 print_network_num(Local_Network_Number);
  218.                 printf("\n");
  219.             }
  220.             continue;
  221.         }
  222.  
  223.  
  224.         /*
  225.         *   Local node number ? 
  226.         */
  227.  
  228.         if (!strnicmp(p, "lnode:", 6)) {
  229.             p+= 6;
  230.  
  231.             /*
  232.             *   Get the local network number from the option 
  233.             */
  234.  
  235.             memcpy(Local_Node_Number, get_node_number(p), 6);
  236.             if (verbose) {
  237.                 printf("Local_Node_Number = ");
  238.          print_node_num(Local_Node_Number);
  239.                 printf("\n");
  240.             }
  241.             continue;
  242.         }
  243.  
  244.         /*
  245.         *   Remote network number ? 
  246.         */
  247.  
  248.         if (!strnicmp(p, "rnet:", 5)) {
  249.             p+= 5;
  250.  
  251.             /*
  252.             *   Get the remote network number from the option 
  253.             */
  254.  
  255.             memcpy(Remote_Network_Number, get_network_number(p), 4);
  256.             if (verbose) {
  257.                 printf("Remote_Network_Number = ");
  258.                 print_network_num(Remote_Network_Number);
  259.                 printf("\n");
  260.             }
  261.             continue;
  262.         }
  263.  
  264.         /*
  265.         *   Remote node number ? 
  266.         */
  267.  
  268.         if (!strnicmp(p, "rnode:", 6)) {
  269.             p+= 6;
  270.  
  271.             /*
  272.             *   Get the remote network number from the option 
  273.             */
  274.  
  275.             memcpy(Remote_Node_Number, get_node_number(p), 6);
  276.             if (verbose) {
  277.                 printf("Remote_Node_Number = ");
  278.          print_node_num(Remote_Node_Number);
  279.                 printf("\n");
  280.             }
  281.             continue;
  282.         }
  283.  
  284.         /*
  285.         *   Local socket number ? 
  286.         */
  287.  
  288.         if (!strnicmp(p, "lsock:", 6)) {
  289.             p+= 6;
  290.  
  291.             /*
  292.             *   Get the local socket number from the command line 
  293.             */
  294.  
  295.             memcpy(Local_Socket_Number, get_socket_number(p), 2);
  296.  
  297.         if (verbose) {
  298.                 printf("Local_Socket_Number = ");
  299.                 print_socket_num(Local_Socket_Number);
  300.                 printf("\n");
  301.             }
  302.             continue;
  303.         }
  304.  
  305.         /*
  306.         *   Remote socket number ? 
  307.         */
  308.  
  309.         if (!strnicmp(p, "rsock:", 6)) {
  310.             p+= 6;
  311.  
  312.             /*
  313.             *   Get the remote socket number from the command line 
  314.             */
  315.  
  316.             memcpy(Remote_Socket_Number, get_socket_number(p), 2);
  317.  
  318.         if (verbose) {
  319.                 printf("Remote_Socket_Number = ");
  320.                 print_socket_num(Remote_Socket_Number);
  321.                 printf("\n");
  322.             }
  323.             continue;
  324.         }
  325.  
  326.  
  327.         /*
  328.         *   Send length ? 
  329.         */
  330.  
  331.         if (!strnicmp(p, "sendlen:", 8)) {
  332.             p+= 8;
  333.  
  334.             /*
  335.             *   Get the amount of data to send from the command line 
  336.             */
  337.  
  338.             Send_Length = atoi(p);
  339.             if (verbose)
  340.                 printf("Send length = %d\n", Send_Length);
  341.  
  342.             continue;
  343.         }
  344.  
  345.         /*
  346.         *   Receive length ? 
  347.         */
  348.  
  349.         if (!strnicmp(p, "recvlen:", 8)) {
  350.             p+= 8;
  351.  
  352.             /*
  353.             *   Get the amount of data to send from the command line 
  354.             */
  355.  
  356.             Receive_Length = atoi(p);
  357.             if (verbose)
  358.                 printf("Receive length = %d\n", Receive_Length);
  359.  
  360.             continue;
  361.         }
  362.  
  363.         /*
  364.         *   Send packet type ? 
  365.         */
  366.  
  367.         if (!strnicmp(p, "sptype:", 7)) {
  368.         p+= 7;
  369.  
  370.             /*
  371.             *   Get the packet type from the command line 
  372.             */
  373.  
  374.             Send_Packet_Type = atoi(p);
  375.  
  376.           if (verbose)
  377.         printf("Send_Packet_Type = %d\n", Send_Packet_Type);
  378.             continue;
  379.         }
  380.  
  381.         /*
  382.         *   Local packet type ? 
  383.         */
  384.  
  385.         if (!strnicmp(p, "lptype:", 7)) {
  386.         p+= 7;
  387.  
  388.             /*
  389.             *   Get the packet type from the command line 
  390.             */
  391.  
  392.             Local_Packet_Type = atoi(p);
  393.  
  394.           if (verbose)
  395.         printf("Send_Packet_Type = %d\n", Send_Packet_Type);
  396.             continue;
  397.         }
  398.  
  399.         /*
  400.         *   Filter packet type ? 
  401.         */
  402.  
  403.         if (!strnicmp(p, "fptype:", 7)) {
  404.         p+= 7;
  405.  
  406.             /*
  407.             *   Get the packet type from the command line 
  408.             */
  409.  
  410.             Filter_Packet_Type = atoi(p);
  411.  
  412.           if (verbose)
  413.         printf("Filter_Packet_Type = %d\n", Send_Packet_Type);
  414.             continue;
  415.         }
  416.  
  417.         /*
  418.         *   Backlog size ? 
  419.         */
  420.  
  421.         if (!strnicmp(p, "backlog:", 8)) {
  422.          p+= 8;
  423.  
  424.             Backlog = atoi(p);
  425.  
  426.             if (verbose)
  427.                 printf("Backlog = %d\n", Backlog);
  428.             continue;
  429.         }
  430.  
  431.         /*
  432.         *   No broadcast flag ? 
  433.         */
  434.  
  435.         if (!strnicmp(p, "nobcast", 7)) {
  436.             p+= 7;
  437.  
  438.             No_Broadcast++;
  439.  
  440.             if (verbose)
  441.                 printf("No broadcast flag is set\n");
  442.  
  443.             continue;
  444.         }
  445.  
  446.         /*
  447.         *   No loop flag ? 
  448.         */
  449.  
  450.         if (!strnicmp(p, "noloop", 6)) {
  451.             p+= 6;
  452.  
  453.             No_Loop++;
  454.  
  455.             if (verbose)
  456.                 printf("No loop flag is set\n");
  457.  
  458.             continue;
  459.         }
  460.  
  461.         /*
  462.         *   Sleep time ? 
  463.         */
  464.  
  465.         if (!strnicmp(p, "sleep:", 6)) {
  466.             p+= 6;
  467.  
  468.             Sleep_Time = atoi(p);
  469.  
  470.             if (verbose)
  471.                 printf("Sleep time = %d\n", Sleep_Time);
  472.  
  473.             continue;
  474.         }
  475.  
  476.  
  477.         if (*p)
  478.             printf("Unknown command line parameter: %s\n", p);
  479.  
  480.     } /* while */
  481.  
  482.     if (verbose)
  483.         printf("\n\n");
  484. }
  485.  
  486. /****************************************************************************
  487. *
  488. *    FUNCTION:  usage( LPSTR progname )
  489. *
  490. *    PURPOSE:   Displays all allowable command line parameters.  (All may not be used
  491. *               by the program linking to this library, however).
  492. *
  493. *    ARGUMENTS:    LPSTR    => program name
  494. *
  495. *     RETURNS:   exits with errorlevel 0
  496. *
  497. *\***************************************************************************/
  498. void usage(LPSTR progname)
  499. {
  500.     printf("\n\nUsage: %s [options]\n", progname);
  501.     printf("\n");
  502.     printf("Valid options are:\n");
  503.     printf("-v               Toggles verbose mode ON\n");
  504.     printf("-laf:x           Sets local address family to x\n");
  505.     printf("-raf:x           Sets remote address family to x\n");
  506.     printf("-st:x            Sets socket type to x\n");
  507.     printf("-proto:x         Sets protocol to x\n");
  508.     printf("-sleep:x         Sets sleep time between sends to x milliseconds\n");
  509.     printf("-backlog:x       Sets listen backlog size to x indications\n");
  510.     printf("-nobcast         Sets flag so program won't set sockopt to broadcast\n");
  511.     printf("-noloop          Sets flag so program won't loop\n");
  512.     printf("-sptype:x        Sets send packet type to x\n");
  513.     printf("-lptype:x        Sets local packet type to x\n");
  514.     printf("-fptype:x        Sets filter for incoming packet type x\n");
  515.     printf("-sendlen:x       Sets amount of data to send to x bytes\n");
  516.     printf("-recvlen:x       Sets amount of data to receive to x bytes\n");
  517.     printf("-lnet:xxxx       Sets local network number to xxxx (1)\n");
  518.     printf("-lnode:xxxxxx    Sets local node number to xxxxxx (1)\n");
  519.     printf("-rnet:xxxx       Sets remote network number to xxxx (1)\n");
  520.     printf("-rnode:xxxxxx    Sets remote node number to xxxxxx (1)\n");
  521.     printf("-rsock:xx        Sets remote socket number to xx (1)\n");
  522.     printf("-default         Displays programs default values\n");
  523.     printf("-?, -help, or -h Displays this screen\n");
  524.     printf("\n");
  525.     printf("Notes:  (1) Network numbers (network, node, and socket) must\n");
  526.     printf("            be specified as a series of hexadecimal numbers,\n");
  527.     printf("            for example: -lnet:04003BFF. \n");
  528.     printf("\n");
  529.     printf("        All values must come immediately after the ':'\n");
  530.     printf("        -default and/or -v should be first\n");
  531.     printf("        Not all programs make use of all the above parameters\n");
  532.  
  533.     exit(0);
  534. }
  535.  
  536. /****************************************************************************
  537. *
  538. *    FUNCTION:  dump_defaults( LPSTR progname )
  539. *
  540. *    PURPOSE:   Prints out the current values of the command line options
  541. *               
  542. *
  543. *    ARGUMENTS:    LPSTR    => program name
  544. *
  545. *     RETURNS:   nothing
  546. *
  547. *\***************************************************************************/
  548. void dump_defaults(LPSTR progname)
  549. {
  550.     printf("Default option values for %s:\n\n", progname);
  551.  
  552.     printf("verbose =                %d\n", verbose);
  553.     printf("socket type =            %d\n", Socket_Type);
  554.     printf("protocol =               %d\n", Protocol);
  555.     printf("sleep time =             %d\n", Sleep_Time);
  556.     printf("backlog =                %d\n", Backlog);
  557.     printf("nobcast =                %d\n", No_Broadcast);
  558.     printf("noloop =                 %d\n", No_Loop);
  559.     printf("send length =            %d\n", Send_Length);
  560.     printf("receive length =         %d\n", Receive_Length);
  561.     printf("send packet type =       %d\n", Send_Packet_Type);
  562.     printf("local packet type =      %d\n", Local_Packet_Type);
  563.     printf("filter packet type =     %d\n", Filter_Packet_Type);
  564.     printf("local address family =   %d\n", Local_Address_Family);
  565.     printf("remote address family =  %d\n", Remote_Address_Family);
  566.     printf("local network number =   ");
  567.     print_network_num(Local_Network_Number);
  568.     printf("\nlocal node number =      ");
  569.     print_node_num(Local_Node_Number);
  570.     printf("\nlocal socket number =    ");
  571.     print_socket_num(Local_Socket_Number);
  572.     printf("\nremote network number =  ");
  573.     print_network_num(Remote_Network_Number);
  574.     printf("\nremote node number =     ");
  575.     print_node_num(Remote_Node_Number);
  576.     printf("\nremote socket number =   ");
  577.     print_socket_num(Remote_Socket_Number);
  578.     printf("\n\n");
  579. }
  580.  
  581.  
  582. /****************************************************************************
  583. *
  584. *    FUNCTION:  get_network_number( LPSTR cmd )
  585. *
  586. *    PURPOSE:   Reads a network number from the given string
  587. *
  588. *
  589. *    ARGUMENTS:    LPSTR  => string to read from
  590. *
  591. *     RETURNS:   LPSTR  => hex network number
  592. *
  593. *\***************************************************************************/
  594. LPSTR get_network_number(LPSTR cmd)
  595. {
  596.     static char hex_num[4];
  597.  
  598.     memset(hex_num, 0, 4);
  599.  
  600.     if (strlen(cmd) != 8) {
  601.         printf("Incorrect format for network number.\n");
  602.         exit(1);
  603.     }
  604.  
  605.     get_hex_string(cmd, hex_num, 4);
  606.  
  607.     return hex_num;
  608. }
  609.  
  610. /****************************************************************************
  611. *
  612. *    FUNCTION:  get_node_number( LPSTR cmd )
  613. *
  614. *    PURPOSE:   Reads a node number from the given string
  615. *
  616. *
  617. *    ARGUMENTS:    LPSTR  => string to read from
  618. *
  619. *     RETURNS:   LPSTR  => hex network number
  620. *
  621. *\***************************************************************************/
  622. LPSTR get_node_number(LPSTR cmd)
  623. {
  624.     static char hex_num[6];
  625.  
  626.     memset(hex_num, 0, 6);
  627.  
  628.     if (strlen(cmd) != 12) {
  629.         printf("Incorrect format for node number.\n");
  630.         exit(1);
  631.     }
  632.  
  633.     get_hex_string(cmd, hex_num, 6);
  634.  
  635.     return hex_num;
  636. }
  637.  
  638. /****************************************************************************
  639. *
  640. *    FUNCTION:  get_socket_number( LPSTR cmd )
  641. *
  642. *    PURPOSE:   Reads a socket number from the given string
  643. *
  644. *
  645. *    ARGUMENTS:    LPSTR  => string to read from
  646. *
  647. *     RETURNS:   LPSTR  => hex network number
  648. *
  649. *\***************************************************************************/
  650. LPSTR get_socket_number(LPSTR cmd)
  651. {
  652.     static char hex_num[2];
  653.  
  654.     memset(hex_num, 0, 2);
  655.  
  656.     if (strlen(cmd) != 4) {
  657.         printf("Incorrect format for socket number.\n");
  658.         exit(1);
  659.     }
  660.  
  661.     get_hex_string(cmd, hex_num, 2);
  662.  
  663.     return hex_num;
  664. }
  665.  
  666. /****************************************************************************
  667. *
  668. *    FUNCTION:  get_hex_string( LPSTR src, LPSTR dest, int num )
  669. *
  670. *    PURPOSE:   Reads in a character string containing hex digits and converts
  671. *                it to a hexadecimal number.
  672. *
  673. *    ARGUMENTS:    LPSTR  => source string
  674. *                LPSTR  => destination for hex number
  675. *                int    number of bytes to convert    
  676. *
  677. *     RETURNS:   nothing
  678. *
  679. *\***************************************************************************/
  680. void get_hex_string(LPSTR src, LPSTR dest, int num)
  681. {
  682.     LPSTR q = src;
  683.  
  684.     while (num--)
  685.         *dest++ = (get_hex_byte(*q++) << 4) + get_hex_byte(*q++);
  686.  
  687. }
  688.  
  689. /****************************************************************************
  690. *
  691. *    FUNCTION:  get_hex_byte( char ch )
  692. *
  693. *    PURPOSE:   Converts the character passed in to a hexadecimal nibble.
  694. *
  695. *    ARGUMENTS:    char    character to convert
  696. *
  697. *     RETURNS:   UCHAR   hex nibble
  698. *
  699. *\***************************************************************************/
  700. UCHAR get_hex_byte(char ch)
  701. {
  702.     if (ch >= '0' && ch <= '9')
  703.         return (ch - '0');
  704.  
  705.     if (ch >= 'A' && ch <= 'F')
  706.         return ((ch - 'A') + 0x0A);
  707.  
  708.     printf("Illegal character %c in hex string\n", ch);
  709.     exit(1);
  710. }
  711.