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 / connect / connect.c next >
C/C++ Source or Header  |  1997-10-05  |  9KB  |  396 lines
  1. /****************************************************************************\
  2. *  dgrecv.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 using SPX connect.
  8. * 
  9. ****************************************************************************/
  10. #include <windows.h>
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include <malloc.h>
  15. #include <wsipx.h>
  16. #include "../testlib/testlib.h"
  17.  
  18. SOCKADDR_IPX addr;
  19. SOCKADDR_IPX baddr;
  20. SOCKADDR_IPX caddr;
  21.  
  22. UCHAR ch = 0;
  23.  
  24. /*
  25. *   Function Prototypes 
  26. */
  27.  
  28. extern int main(int, char **);
  29. extern int net_init(SOCKET *);
  30. extern int make_connection(SOCKET);
  31. extern int do_send_receive(SOCKET);
  32.  
  33. /****************************************************************************
  34. *
  35. *    FUNCTION:  main( int argc, char **argv )
  36. *
  37. *    PURPOSE:   This is the main entry for the program
  38. *               
  39. *
  40. *    ARGUMENTS:    argc = Number of arguments
  41. *               argv = Array of ptrs to cmd line args
  42. *                
  43. *
  44. *     RETURNS:   Exit code for the program
  45. *                
  46. *\***************************************************************************/
  47. int main(int argc, char **argv)
  48. {
  49.     SOCKET s;
  50.  
  51.     /*
  52.     *   Set up our default values before checking command line 
  53.     */
  54.  
  55.     memcpy(Remote_Node_Number, "\x08\x00\x2B\x2E\x98\xA8", 6);
  56.     memcpy(Remote_Socket_Number, "\x05\x00", 2);
  57.     Socket_Type = SOCK_STREAM;
  58.     Protocol = NSPROTO_SPX;
  59.     Remote_Address_Family = AF_NS;
  60.     Sleep_Time = 250;
  61.  
  62.     /*
  63.     *   Get any command line options 
  64.     */
  65.  
  66.     parse_cmd_line(argc, argv);
  67.  
  68.     /*
  69.     *   Initialize the network and set up the socket 
  70.     */
  71.  
  72.     if (net_init(&s))
  73.         return 1;
  74.  
  75.     /*
  76.     *   Try to connect to our server 
  77.     */
  78.  
  79.     if (make_connection(s))
  80.         return 1;
  81.  
  82.     /*
  83.     *   Send/receive data to/from server 
  84.     */
  85.  
  86.     do_send_receive(s);
  87.  
  88.     /*
  89.     *   All done - close up 
  90.     */
  91.  
  92.     if (verbose)
  93.         printf("calling closesocket(socket = %d)\n", s);
  94.  
  95.     closesocket(s);
  96.     return 0;
  97. }
  98.  
  99. /****************************************************************************
  100. *
  101. *    FUNCTION:  net_init( SOCKET *skt )
  102. *
  103. *    PURPOSE:   Initializes the WinSock stuff and sets up our socket.
  104. *               
  105. *
  106. *    ARGUMENTS:    SOCKET * => struct to fill in with opened socket.
  107. *
  108. *     RETURNS:   0 if ok
  109. *                1 if error
  110. *
  111. *\***************************************************************************/
  112. int net_init(SOCKET *skt)
  113. {
  114.     SOCKET s;
  115.     int rc, addrlen;
  116.     WSADATA wsdata;
  117.     WORD    wVersionRequested;
  118.  
  119.     wVersionRequested = MAKEWORD(1,1);
  120.  
  121.  
  122.     /*
  123.     *   Register with the socket library 
  124.     */
  125.  
  126.     rc = WSAStartup(wVersionRequested, &wsdata);
  127.  
  128.     if (verbose)
  129.         printf("WSAStartup returned 0x%X\n", rc);
  130.  
  131.     if (rc) {
  132.         printf("WSAStartup failed: error = %d\n", rc);
  133.         return 1;
  134.     }
  135.  
  136.     if (verbose) {
  137.         printf("contents of wsdata structure: \n");
  138.         print_wsa(&wsdata);
  139.         printf("calling socket(address family = %d, socket type = %d, protocol = %d)\n", Local_Address_Family, Socket_Type, Protocol);
  140.     }
  141.  
  142.     /*
  143.     *   Open a STREAMING socket 
  144.     */
  145.  
  146.     s = socket(Local_Address_Family, Socket_Type, Protocol);
  147.  
  148.     if (verbose)
  149.         printf("socket() returned 0x%X (%d)\n", s, s);
  150.  
  151.     if (s == INVALID_SOCKET) {
  152.         dos_net_perror("socket call failed");
  153.         return 1;
  154.     }
  155.  
  156.     /*
  157.     *   Bind to any address 
  158.     */
  159.  
  160.     addr.sa_family = Local_Address_Family;
  161.     memcpy(&addr.sa_netnum, Local_Network_Number, 4);
  162.     memcpy(&addr.sa_nodenum, Local_Node_Number, 6);
  163.     memcpy(&addr.sa_socket, Local_Socket_Number, 2);
  164.  
  165.     rc = bind(s, (const struct sockaddr FAR *)&addr, 16);
  166.  
  167.     if (verbose)
  168.         printf("bind() returned 0x%X\n", rc);
  169.  
  170.     if (rc == SOCKET_ERROR) {
  171.         dos_net_perror("bind call failed");
  172.         return 1;
  173.     }
  174.  
  175.     if (verbose)
  176.         printf("calling getsockname(socket = %d)\n", s);
  177.  
  178.     addrlen = 16;
  179.     rc = getsockname(s, (struct sockaddr *) &addr, &addrlen);
  180.  
  181.     if (verbose)
  182.         printf("getsockname() returned 0x%X\n", rc);
  183.  
  184.     if (rc == SOCKET_ERROR) {
  185.         dos_net_perror("Error binding to socket");
  186.         closesocket(s);
  187.         return 1;
  188.     }
  189.  
  190.     if (verbose) {
  191.         printf("addrlen = %d\n", addrlen);
  192.         print_netaddr(addr.sa_netnum, "Bound address = ", "\n");
  193.     }
  194.  
  195.  
  196.     /*
  197.     *   Build the address of the node to connect to 
  198.     */
  199.  
  200.     memcpy(&caddr.sa_netnum, Remote_Network_Number, 4);
  201.     memcpy(&caddr.sa_nodenum, Remote_Node_Number, 6);
  202.     memcpy(&caddr.sa_socket, Remote_Socket_Number, 2);
  203.     caddr.sa_family = AF_NS;
  204.  
  205.     /*
  206.     *   Set up socket for return 
  207.     */
  208.  
  209.     *skt = s;
  210.  
  211.     return 0;
  212. }
  213.  
  214. /****************************************************************************
  215. *
  216. *    FUNCTION:  make_connection( SOCKET s )
  217. *
  218. *    PURPOSE:   Establishes a connection with our server.
  219. *
  220. *    ARGUMENTS:    SOCKET socket to use for connection
  221. *
  222. *     RETURNS:   0 if ok
  223. *                1 if error
  224. *
  225. *\***************************************************************************/
  226. int make_connection(SOCKET s)
  227. {
  228.     int rc, addrlen;
  229.  
  230.     /*
  231.     *   Connect 
  232.     */
  233.  
  234.     if (verbose)
  235.         printf("calling connect(socket = %d)\n", s);
  236.  
  237.     rc = connect(s, (const struct sockaddr FAR *)&caddr, 16);
  238.  
  239.     if (verbose)
  240.         printf("connect() returned 0x%X\n", rc);
  241.  
  242.     if (rc == SOCKET_ERROR) {
  243.         dos_net_perror("connect call failed");
  244.         return 1;
  245.     }
  246.  
  247.     printf("Connect OK\n");
  248.  
  249.     /*
  250.     *   Print out address we connected to 
  251.     */
  252.  
  253.     if (verbose)
  254.         printf("calling getpeername(socket = %d)\n", s);
  255.  
  256.     addrlen = 16;
  257.     rc = getpeername(s, (struct sockaddr *) &caddr, &addrlen);
  258.  
  259.     if (verbose)
  260.         printf("getpeername() returned 0x%X\n", rc);
  261.  
  262.     if (verbose) {
  263.         printf("addrlen = %d\n", addrlen);
  264.         print_netaddr(caddr.sa_netnum, "Remote Address = ", "\n");
  265.     }
  266.  
  267.     return 0;
  268. }
  269. /****************************************************************************
  270. *
  271. *    FUNCTION:  do_send_receive( SOCKET *s )
  272. *
  273. *    PURPOSE:   Alternately sends/receives data to/from the server.
  274. *
  275. *    ARGUMENTS:    SOCKET socket to transmit on
  276. *
  277. *     RETURNS:   0 if ok
  278. *                1 if error
  279. *
  280. *\***************************************************************************/
  281. int do_send_receive(SOCKET s)
  282. {
  283.     int rc, errflag = 0;
  284.     int sndpkts = 0, rcvpkts = 0;
  285.     LPSTR sendbuf;
  286.  
  287.     /*
  288.     *   Allocate a send buffer 
  289.     */
  290.  
  291.     if (verbose)
  292.         printf("Allocating %d bytes for send buffer \n");
  293.  
  294.     sendbuf = malloc(Send_Length);
  295.  
  296.     if (!sendbuf) {
  297.         printf("Error allocating %d bytes for send buffer\n");
  298.         return 1;
  299.     }
  300.  
  301.     /*
  302.     *   Send data and recv it back 
  303.     */
  304.  
  305.     while (1) {
  306.  
  307.         /*
  308.         *   Fill the buffer with our current character 
  309.         */
  310.  
  311.         memset(sendbuf, ch, Send_Length);
  312.  
  313.         /*
  314.         *   Send data 
  315.         */
  316.  
  317.         if (verbose)
  318.         printf("calling send(socket = %d, length = %d)\n", s, Send_Length);
  319.  
  320.         rc = send(s, sendbuf, Send_Length, 0);
  321.  
  322.         if (verbose)
  323.             printf("send() returned 0x%X\n", rc);
  324.  
  325.         if (rc == SOCKET_ERROR) {
  326.             dos_net_perror("\nsend() call failed");
  327.             errflag++;
  328.             break;
  329.         }
  330.  
  331.         if (verbose)
  332.             printf("Sent packet %d: sent %d bytes\n", sndpkts++, rc);
  333.         else
  334.             printf("\rSent packet %d: sent %d bytes... ", sndpkts++, rc);
  335.  
  336.         /*
  337.         *   Receive the data back 
  338.         */
  339.  
  340.         if (verbose)
  341.             printf("calling recv(socket = %d, length = %d)\n", s, Send_Length);
  342.  
  343.         rc = recv(s, sendbuf, Send_Length, 0);
  344.  
  345.         if (verbose)
  346.             printf("recv() returned %d\n", rc);
  347.  
  348.         if (rc == SOCKET_ERROR) {
  349.             dos_net_perror("\nrecv() call failed");
  350.             errflag++;
  351.             break;
  352.         }
  353.  
  354.         if (!rc) {
  355.             printf("connection has been lost\n");
  356.             break;
  357.         }
  358.  
  359.         printf("Received %d bytes", rc);
  360.  
  361.         if (verbose)
  362.             printf("\n");
  363.  
  364.         /*
  365.         *   See if our buffer has the same data in it 
  366.         */
  367.  
  368.         rc = mem_check(sendbuf, ch++, Send_Length);
  369.  
  370.         if (rc)
  371.             printf("Data compare error: packet = %d, offset = %d\n", (sndpkts-1), rc);
  372.         else if (verbose)
  373.             printf("Data compares okay\n");
  374.  
  375.         /*
  376.         *   If we are to send just 1, break out 
  377.         */
  378.  
  379.         if (No_Loop)
  380.             break;
  381.  
  382.         /*
  383.         *   Pause a little while (don't trash the network) 
  384.         */
  385.  
  386.         Sleep(Sleep_Time);
  387.     }
  388.  
  389.     if (verbose)
  390.         printf("\nFreeing send buffer\n");
  391.  
  392.     free(sendbuf);
  393.  
  394.     return errflag;
  395. }
  396.