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 / dgsend / dgsend.c next >
C/C++ Source or Header  |  1997-10-05  |  10KB  |  424 lines
  1. /****************************************************************************\
  2. *  dgsend.c -- sample program demonstrating NWLink.
  3. *
  4. *       Microsoft Developer Support
  5. *       Copyright (c) 1992-1997 Microsoft Corporation
  6. *
  7. *      This program is a simple example of opening a socket,
  8. *      binding to the socket, and sending a packet repeatedly.
  9. * 
  10. ****************************************************************************/
  11. #include <windows.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <malloc.h>
  16. #include <wsipx.h>
  17. #include <wsnwlink.h>
  18. #include "..\testlib\testlib.h"
  19.  
  20. /*
  21. *   Sockaddr structures 
  22. */
  23.  
  24. SOCKADDR_IPX addr;
  25. SOCKADDR_IPX baddr;
  26. SOCKADDR_IPX saddr;
  27.  
  28. /*
  29. *   Data for sending 
  30. */
  31.  
  32. char send_data[] = "This is an IPX packet from NT";
  33.  
  34. /*
  35. *   Function Prototypes 
  36. */
  37. extern int main(int, char **);
  38. extern int net_init(SOCKET *);
  39. extern int enable_broadcasts(SOCKET);
  40. extern void build_dest_addr(SOCKET, PSOCKADDR_IPX);
  41. extern int dg_send(SOCKET);
  42.  
  43. /****************************************************************************
  44. *
  45. *    FUNCTION:  main( int argc, char **argv )
  46. *
  47. *    PURPOSE:   This is the main entry for the program
  48. *               
  49. *
  50. *    ARGUMENTS:    argc = Number of arguments
  51. *               argv = Array of ptrs to cmd line args
  52. *                
  53. *
  54. *     RETURNS:   Exit code for the program
  55. *                
  56. *\***************************************************************************/
  57. int main(int argc, char **argv)
  58. {
  59.     SOCKET s;
  60.  
  61.     /*
  62.     *   Fill in any default values before checking the command line 
  63.     */
  64.  
  65.     *Remote_Socket_Number = 0x06;
  66.     *(Remote_Socket_Number+1) = 0x00;
  67.     Sleep_Time = 500;
  68.  
  69.     /*
  70.     *   Parse the command line to set up any command line options 
  71.     */
  72.  
  73.     parse_cmd_line(argc, argv);
  74.  
  75.     if (net_init(&s))
  76.         return 1;
  77.  
  78.     if (!No_Broadcast) {
  79.         if (enable_broadcasts(s))
  80.             return 1;
  81.     }
  82.  
  83.     build_dest_addr(s, &saddr);
  84.  
  85.     /*
  86.     *   Send some datagrams 
  87.     */
  88.  
  89.     dg_send(s);
  90.  
  91.     /*
  92.     *   All Done - Close up the socket and exit 
  93.     */
  94.  
  95.     if (verbose)
  96.     printf("Calling closesocket()\n");
  97.  
  98.     closesocket(s);
  99.     return 0;
  100. }
  101.  
  102. /****************************************************************************
  103. *
  104. *    FUNCTION:  net_init( SOCKET *skt )
  105. *
  106. *    PURPOSE:   Initializes the WinSock stuff and sets up our socket.
  107. *               
  108. *
  109. *    ARGUMENTS:    SOCKET * => struct to receive our socket info    
  110. *
  111. *     RETURNS:   0 if ok
  112. *                1 if error
  113. *
  114. *\***************************************************************************/
  115. int net_init(SOCKET *skt)
  116. {
  117.     SOCKET s;
  118.     WSADATA wsdata;
  119.     WORD    wVersionRequested;
  120.  
  121.  
  122.     int rc, addrlen = 16;
  123.  
  124.     if (verbose)
  125.         printf("Calling WSAStartup(), ");
  126.  
  127.     /*
  128.     *   Initialize with the WINSOCK library 
  129.     */
  130.  
  131.     wVersionRequested = MAKEWORD(1,1);
  132.     rc = WSAStartup(wVersionRequested, &wsdata);
  133.  
  134.     if (verbose)
  135.         printf("return = 0x%X (%d)\n", rc, rc);
  136.  
  137.     if (rc) {
  138.         printf("WSAStartup failed: error code = %d\n", rc);
  139.         return 1;
  140.     }
  141.  
  142.     if (verbose) {
  143.         printf("Contents of wsadata struct:\n");
  144.         print_wsa(&wsdata);
  145.     }
  146.  
  147.     /*
  148.     *   Open a DATAGRAM socket with IPX 
  149.     */
  150.  
  151.     if (verbose)
  152.         printf("Calling socket(address family = %d, socket type = %d, protocol = %d)\n", Local_Address_Family, Socket_Type, Protocol);
  153.  
  154.     s = socket(Local_Address_Family, Socket_Type, Protocol);
  155.  
  156.     if (verbose)
  157.     printf("socket() returned 0x%X (%d)\n", s, s);
  158.  
  159.     if (s == INVALID_SOCKET) {
  160.         dos_net_perror("Socket call failed");
  161.         exit(1);
  162.     }
  163.  
  164.     /*
  165.     *   Bind to a socket.  We dont care what socket we bind to,
  166.     *   so we will send down all 0's
  167.     */
  168.  
  169.     addr.sa_family = Local_Address_Family;
  170.  
  171.     memcpy(&addr.sa_netnum, Local_Network_Number, 4);
  172.     memcpy(&addr.sa_nodenum, Local_Node_Number, 6);
  173.     memcpy(&addr.sa_socket, Local_Socket_Number, 2);
  174.  
  175.     if (verbose) {
  176.         printf("calling bind(), local address =\n  ");
  177.         print_saddr(&addr);
  178.     }
  179.  
  180.     rc = bind(s, (const struct sockaddr *) &addr, 16);
  181.  
  182.     if (verbose)
  183.         printf("\nbind() returned 0x%X (%d)\n", rc, rc);
  184.  
  185.     if (rc == SOCKET_ERROR) {
  186.         dos_net_perror("Error binding to socket");
  187.         printf("Socket = 0x%lx\n", s);
  188.         closesocket(s);
  189.         return 1;
  190.     }
  191.  
  192.     /*
  193.     *   Get the address we bound to and print it out 
  194.     */
  195.  
  196.     if (verbose)
  197.         printf("calling getsockname(socket = %d), ", s);
  198.  
  199.     rc = getsockname(s, (struct sockaddr *) &baddr, &addrlen);
  200.  
  201.     if (verbose)
  202.         printf("return = 0x%lX (%d)\n", rc, rc);
  203.  
  204.     if (rc == SOCKET_ERROR) {
  205.         dos_net_perror("Error getting socket name");
  206.         closesocket(s);
  207.         return 1;
  208.     }
  209.  
  210.     /*
  211.     *   Set the packet type for this socket 
  212.     */
  213.  
  214.     if (verbose)
  215.         printf("Calling setsockopt for packet type %d\n", Local_Packet_Type);
  216.  
  217.     rc = setsockopt(s, NSPROTO_IPX, IPX_PTYPE, (const char *) &Local_Packet_Type, 4);
  218.  
  219.     if (rc == SOCKET_ERROR)
  220.         dos_net_perror("setsockopt() call failed");
  221.  
  222.     /*
  223.     *   Print out the network address 
  224.     */
  225.  
  226.     if (verbose) {
  227.         printf("addrlen = %d\n", addrlen);
  228.         print_netaddr(baddr.sa_netnum, "  Bound to address ", "\n");
  229.     }
  230.  
  231.     *skt = s;
  232.  
  233.     return 0;
  234. }
  235.  
  236. /****************************************************************************
  237. *
  238. *    FUNCTION:  enable_broadcasts( SOCKET s )
  239. *
  240. *    PURPOSE:   Sets the socket option to enable broadcast sends on it.
  241. *               
  242. *
  243. *    ARGUMENTS:    SOCKET   socket to enable    
  244. *
  245. *     RETURNS:   0 if ok
  246. *                1 if error
  247. *
  248. *\***************************************************************************/
  249. int enable_broadcasts(SOCKET s)
  250. {
  251.     int rc;
  252.     BOOL optval = TRUE;
  253.  
  254.     /*
  255.     *   Enable sending of broadcasts 
  256.     */
  257.  
  258.     /*
  259.     *    NOTE:  This only needs to be done if you want to SEND
  260.     *           broadcast packets.  Reception of broadcast
  261.     *           packets will happen automatically.
  262.     */
  263.  
  264.     if (verbose)
  265.         printf("Setting socket option to broadcast, ");
  266.     rc = setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(int));
  267.     if (verbose)
  268.         printf("return = 0x%X (%d)\n", rc, rc);
  269.  
  270.     if (rc == SOCKET_ERROR) {
  271.         dos_net_perror("Error enabling broadcast address");
  272.         closesocket(s);
  273.         return 1;
  274.     }
  275.  
  276.     return 0;
  277. }
  278.  
  279. /****************************************************************************
  280. *
  281. *    FUNCTION:  build_dest_addr( SOCKET s )
  282. *
  283. *    PURPOSE:   Fills in the destination address fields and sets the packet type.
  284. *               
  285. *
  286. *    ARGUMENTS:    SOCKET       socket to set packet type for
  287. *                PSOCKADDR_NS => address struct to fill in    
  288. *
  289. *     RETURNS:   0 if ok
  290. *                1 if error
  291. *
  292. *\***************************************************************************/
  293. void build_dest_addr(SOCKET s, PSOCKADDR_IPX psaddr)
  294. {
  295.     int rc;
  296.  
  297.     /*
  298.     *   Build the dest. address 
  299.     */
  300.  
  301.     psaddr->sa_family = Remote_Address_Family;
  302.  
  303.     /*
  304.     *   Set dest. network number 
  305.     */
  306.  
  307.     memcpy(&psaddr->sa_netnum, Remote_Network_Number, 4);
  308.  
  309.     /*
  310.     *   Set dest. node address 
  311.     */
  312.  
  313.     memcpy(&psaddr->sa_nodenum, Remote_Node_Number, 6);
  314.  
  315.     /*
  316.     *   Set the dest. socket number 
  317.     */
  318.  
  319.     memcpy(&psaddr->sa_socket, Remote_Socket_Number, 2);
  320.  
  321.  
  322.     /*
  323.     *   Set the packet type for this socket 
  324.     */
  325.  
  326.     if (verbose)
  327.         printf("Calling setsockopt for packet type %d\n", Send_Packet_Type);
  328.  
  329.     rc = setsockopt(s, NSPROTO_IPX, IPX_PTYPE, (const char *) &Send_Packet_Type, sizeof(int));
  330.  
  331.     if (rc == SOCKET_ERROR)
  332.         dos_net_perror("setsockopt() call failed");
  333.  
  334.     return;
  335. }
  336.  
  337. /****************************************************************************
  338. *
  339. *    FUNCTION:  dg_send( SOCKET s )
  340. *
  341. *    PURPOSE:   Receives datagrams.
  342. *
  343. *    ARGUMENTS:    SOCKET socket to transmit on
  344. *
  345. *     RETURNS:   0 if ok
  346. *               1 if error
  347. *
  348. *\***************************************************************************/
  349. int dg_send(SOCKET s)
  350. {
  351.     LPSTR sendbuf;
  352.     int rc, errflag = 0;
  353.     UINT dgrms = 0;
  354.  
  355.     if (verbose)
  356.         printf("allocating %d bytes for send buffer\n", Send_Length);
  357.  
  358.     /*
  359.     *   Set up the data buffer to send 
  360.     */
  361.  
  362.     sendbuf = (LPSTR)malloc(Send_Length);
  363.  
  364.     if (!sendbuf) {
  365.         printf("Error allocating %d bytes for send buffer\n", Send_Length);
  366.         return 1;
  367.     }
  368.  
  369.     /*
  370.     *   Zero the buffer and copy as much of our data to it as possible 
  371.     */
  372.  
  373.     memset(sendbuf, 0, Send_Length);
  374.     strncpy(sendbuf, send_data, Send_Length);
  375.  
  376.     while (1) {
  377.         if (verbose) {
  378.             printf("calling sendto(socket = %d, length = %d),\n", s, Send_Length);
  379.             printf("destination address:\n  ");
  380.             print_saddr(&saddr);
  381.         }
  382.  
  383.         /*
  384.         *   Send a packet to everybody 
  385.         */
  386.  
  387.         rc = sendto(s, sendbuf, Send_Length, 0, (const struct sockaddr *) &saddr, 16);
  388.  
  389.         if (verbose)
  390.         printf("\nsendto() returned %d\n", rc);
  391.  
  392.         if (rc == SOCKET_ERROR) {
  393.             dos_net_perror("Sendto() failed");
  394.             errflag++;
  395.             break;
  396.         }
  397.         else {
  398.             printf("\rSent datagram %d, length = %d bytes", ++dgrms, rc);
  399.             if (verbose)
  400.                 printf("\n");
  401.         }
  402.  
  403.         /*
  404.         *   If we are to send only one, break out 
  405.         */
  406.  
  407.         if (No_Loop)
  408.             break;
  409.  
  410.         /*
  411.         *   Sleep for a little while so we don't bombard the network 
  412.         */
  413.  
  414.         Sleep(Sleep_Time);
  415.     }
  416.  
  417.     if (verbose)
  418.         printf("Freeing send buffer\n");
  419.  
  420.     free(sendbuf);
  421.  
  422.     return errflag;
  423. }
  424.