![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wsock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / wsock|
Return to wsock.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / wsock |
1.1 root 1:
2: //-----------------------------------------------------------------------------
3: // This is a part of the Microsoft Source Code Samples.
4: // Copyright (C) 1993 Microsoft Corporation.
5: // All rights reserved.
6: //
7: // This source code is only intended as a supplement to
8: // Microsoft Development Tools and/or WinHelp documentation.
9: // See these sources for detailed information regarding the
10: // Microsoft samples programs.
11: //-----------------------------------------------------------------------------
12:
13: /****************************************************************************\
14: * wsock.c -- sample program demonstrating Windows Sockets APIs.
15: *
16: * Demonstrates basic sockets programming with the Windows Sockets API.
17: * Allows two occurances of the application to connect. Also, displays
18: * information about a host computer.
19: *
20: ****************************************************************************/
21:
22: #include <windows.h> /* required for all Windows applications */
23: #include <winsock.h>
24: #include <stdio.h> /* for sprintf */
25: #include <string.h> /* for strlen */
26: #include <memory.h>
27: #include <process.h> /* for _beginthread */
28: #include "wsock.h" /* specific to this program */
29:
30: HANDLE hInst; /* current instance */
31:
32: SOCKET sock;
33: u_short portno; /* Which tcp port are we going to use? */
34:
35: char szBuff[ 80 ]; /* Temp buffer - used to pass strings */
36: /* to and from dialog boxes, etc */
37:
38: #define MAX_PENDING_CONNECTS 4 /* The backlog allowed for listen() */
39: #define NO_FLAGS_SET 0 /* Used with recv()/send() */
40: #define MY_MSG_LENGTH 80 /* msg buffer sent back and forth */
41:
42: /****************************************************************************
43: *
44: * FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
45: *
46: * PURPOSE: calls initialization function, processes message loop
47: *
48: *\***************************************************************************/
49:
50: WINAPI WinMain(
51: HANDLE hInstance,
52: HANDLE hPrevInstance,
53: LPSTR lpCmdLine,
54: int nCmdShow
55: )
56: {
57:
58: MSG msg;
59:
60: UNREFERENCED_PARAMETER( lpCmdLine );
61:
62: if (!hPrevInstance) /* Other instances of app running? */
63: if (!InitApplication(hInstance)) /* Initialize shared things */
64: return (FALSE); /* Exits if unable to initialize */
65:
66: /*
67: * Perform initializations that apply to a specific instance
68: */
69: if (!InitInstance(hInstance, nCmdShow))
70: return (FALSE);
71:
72: /*
73: * Acquire and dispatch messages until a WM_QUIT message is received.
74: */
75: while (GetMessage(&msg, /* message structure */
76: NULL, /* handle of window receiving the message */
77: 0, /* lowest message to examine */
78: 0)) /* highest message to examine */
79: {
80: TranslateMessage(&msg); /* Translates virtual key codes */
81: DispatchMessage(&msg); /* Dispatches message to window */
82: }
83: return (msg.wParam); /* Returns the value from PostQuitMessage */
84: }
85:
86:
87: /****************************************************************************
88: *
89: * FUNCTION: InitApplication(HANDLE)
90: *
91: * PURPOSE: Initializes window data and registers window class
92: *
93: *\***************************************************************************/
94:
95: BOOL InitApplication(HANDLE hInstance) /* current instance */
96: {
97: WNDCLASS wc;
98:
99: /* Fill in window class structure with parameters that describe the */
100: /* main window. */
101:
102: wc.style = 0; /* Class style(s). */
103: wc.lpfnWndProc = (WNDPROC)MainWndProc; /* Function to retrieve messages for */
104: /* windows of this class. */
105: wc.cbClsExtra = 0; /* No per-class extra data. */
106: wc.cbWndExtra = 0; /* No per-window extra data. */
107: wc.hIcon = LoadIcon (hInstance, "wsockicon"); /* Icon name from .RC */
108: wc.hInstance = hInstance; /* Application that owns the class. */
109: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
110: wc.hbrBackground = GetStockObject(WHITE_BRUSH);
111: wc.lpszMenuName = "WSockMenu"; /* Name of menu resource in .RC file. */
112: wc.lpszClassName = "WSockWClass"; /* Name used in call to CreateWindow. */
113:
114: /* Register the window class and return success/failure code. */
115:
116: return (RegisterClass(&wc));
117:
118: }
119:
120:
121: /****************************************************************************\
122: *
123: * FUNCTION: InitInstance(HANDLE, int)
124: *
125: * PURPOSE: Saves instance handle and creates main window
126: *
127: *\***************************************************************************/
128:
129: BOOL InitInstance(
130: HANDLE hInstance, /* Current instance identifier. */
131: int nCmdShow) /* Param for first ShowWindow() call. */
132: {
133: HWND hWnd; /* Main window handle. */
134:
135: /* Save the instance handle in static variable, which will be used in */
136: /* many subsequence calls from this application to Windows. */
137:
138: hInst = hInstance;
139:
140: /* Create a main window for this application instance. */
141:
142: hWnd = CreateWindow(
143: "WSockWClass", /* See RegisterClass() call. */
144: "Windows Sockets Sample Application", /* Text for window title bar. */
145: WS_OVERLAPPEDWINDOW, /* Window style. */
146: CW_USEDEFAULT, /* Default horizontal position. */
147: CW_USEDEFAULT, /* Default vertical position. */
148: CW_USEDEFAULT, /* Default width. */
149: CW_USEDEFAULT, /* Default height. */
150: NULL, /* Overlapped windows have no parent. */
151: NULL, /* Use the window class menu. */
152: hInstance, /* This instance owns this window. */
153: NULL /* Pointer not needed. */
154: );
155:
156: /* If window could not be created, return "failure" */
157:
158: if (!hWnd)
159: return (FALSE);
160:
161: /* Make the window visible; update its client area; and return "success" */
162:
163: ShowWindow(hWnd, nCmdShow); /* Show the window */
164: UpdateWindow(hWnd); /* Sends WM_PAINT message */
165: return (TRUE); /* Returns the value from PostQuitMessage */
166:
167: }
168:
169: /****************************************************************************\
170: *
171: * FUNCTION: AcceptThreadProc(PTHREADPACK tp)
172: *
173: * PURPOSE: Use blocking accept() calls and display a message box when
174: * a connection is made.
175: *
176: *\***************************************************************************/
177:
178: void AcceptThreadProc( PTHREADPACK ptp )
179: {
180: SOCKADDR_IN acc_sin; /* Accept socket address - internet style */
181: int acc_sin_len; /* Accept socket address length */
182: int status;
183: char szMsg[ MY_MSG_LENGTH ];
184:
185:
186: acc_sin_len = sizeof(acc_sin);
187:
188: wsprintf( szBuff, "thread #%d created.", ptp->nThread);
189: MessageBox(ptp->hWnd, szBuff, "FYI", MB_OK);
190:
191: sock = accept( sock,(struct sockaddr FAR *) &acc_sin,
192: (int FAR *) &acc_sin_len );
193:
194: if (sock < 0) {
195: sprintf(szBuff, "%d is the error", WSAGetLastError());
196:
197: MessageBox(ptp->hWnd, szBuff, "accept(sock) failed", MB_OK);
198:
199: }
200:
201: wsprintf( szBuff, "Thread #%d accepted something\n\nCheck for incoming messages?", ptp->nThread);
202:
203: /*
204: * Now have a connection --
205: * SetConnectMenus() grays/enables proper menu items
206: */
207: SetConnectMenus( ptp->hWnd );
208:
209:
210: while (1) {
211:
212: /*
213: * By default sockets are created in blocking mode.
214: * Just keep reading until process destroyed.
215: */
216: status = recv( sock, szMsg, MY_MSG_LENGTH, NO_FLAGS_SET );
217:
218: if (status == SOCKET_ERROR) {
219: wsprintf( szMsg, "Error %d", WSAGetLastError() );
220: MessageBox( ptp->hWnd, szMsg, "Error with recv()", MB_OK);
221: _endthread();
222: }
223: szMsg[status] = '\0'; /* NULL-terminate the string */
224:
225: if (status)
226: MessageBox( ptp->hWnd, szMsg, "From thread", MB_OK);
227: else {
228: MessageBox( ptp->hWnd, "Connection broken", "Error", MB_OK);
229: _endthread();
230: }
231:
232: } /* while (forever) */
233: }
234:
235: /****************************************************************************\
236: *
237: * FUNCTION: FillAddr(HWND, PSOCKADDR_IN, BOOL)
238: *
239: * PURPOSE: Retrieves the IP address and port number.
240: *
241: * COMMENTS:
242: * This function is called in two conditions.
243: * 1.) When a client is preparing to call connect(), or
244: * 2.) When a server host is going to call bind(), listen() and
245: * accept().
246: * In both situations, a SOCKADDR_IN structure is filled.
247: * However, different fields are filled depending on the condition.
248: *
249: * ASSUMPTION:
250: * szBuff is a global variable that contains the remote host name or NULL
251: * if local.
252: * bConnect determines if the socket address is being set up for a listen()
253: * (bConnect == TRUE) or a connect() (bConnect == FALSE)
254: *
255: *
256: *\***************************************************************************/
257:
258: BOOL FillAddr(
259: HWND hWnd,
260: PSOCKADDR_IN psin,
261: BOOL bConnect)
262: {
263: DWORD dwSize;
264: PHOSTENT phe;
265: PSERVENT pse;
266: char szTemp[200];
267: int status;
268:
269:
270: psin->sin_family = AF_INET;
271:
272:
273: /*
274: * If we are setting up for a listen() call (bConnect = FALSE),
275: * fill servent with our address.
276: */
277: if (!bConnect) {
278:
279: /*
280: * Retrieve my ip address. Assuming the hosts file in
281: * in %systemroot%/system/drivers/etc/hosts contains my computer name.
282: */
283:
284: dwSize = sizeof(szBuff);
285: gethostname(szBuff, dwSize);
286: }
287:
288:
289: phe = gethostbyname(szBuff);
290: if (phe == NULL) {
291: sprintf(szTemp, "%d is the error. Make sure '%s' is listed in the hosts file.", WSAGetLastError(), szBuff);
292:
293: MessageBox(hWnd, szTemp, "gethostbyname() failed.", MB_OK);
294: return FALSE;
295: }
296: memcpy((char FAR *)&(psin->sin_addr), phe->h_addr,
297: phe->h_length);
298:
299:
300: /*
301: * Retrieve the Port number
302: */
303: status = DialogBox(hInst, /* current instance */
304: "TCPPORTNUM", /* resource to use */
305: hWnd, /* parent handle */
306: GetTcpPort); /* instance address */
307:
308: switch(status) {
309: case 0: /* User cancelled request from prev. dialog box */
310: return FALSE;
311:
312: case 1: /* actual port number entered */
313: psin->sin_port = htons(portno); /* Convert to network ordering */
314: break;
315:
316: case 2: /* service name entereted */
317: /*
318: * Find the service name, szBuff, which is a type tcp protocol in
319: * the "services" file.
320: */
321: pse = getservbyname(szBuff, "tcp");
322: if (pse == NULL) {
323: sprintf(szBuff, "%d is the error. Make sure this is a valid TCP service.", WSAGetLastError());
324: MessageBox(hWnd, szBuff, "getservbyname(sock) failed", MB_OK);
325: return FALSE;
326: }
327: psin->sin_port = pse->s_port;
328: break;
329:
330: default:
331: return FALSE;
332: }
333: return TRUE;
334: }
335:
336: /****************************************************************************
337: *
338: * FUNCTION: SetConnectMenus( HWND )
339: *
340: * PURPOSE: Gray/Enable the proper menu items after a connection has been
341: * established.
342: *
343: *\***************************************************************************/
344:
345: void SetConnectMenus( HWND hWnd )
346: {
347: /*
348: * Disable/enable proper menu items.
349: */
350: EnableMenuItem(GetMenu( hWnd ), IDM_HOSTNAME, MF_ENABLED );
351: EnableMenuItem(GetMenu( hWnd ), IDM_LISTEN, MF_GRAYED );
352: EnableMenuItem(GetMenu( hWnd ), IDM_CONNECT, MF_GRAYED );
353: EnableMenuItem(GetMenu( hWnd ), IDM_ALISTEN, MF_GRAYED );
354: EnableMenuItem(GetMenu( hWnd ), IDM_TLISTEN, MF_GRAYED );
355: EnableMenuItem(GetMenu( hWnd ), IDM_CANCEL, MF_GRAYED );
356: EnableMenuItem(GetMenu( hWnd ), IDM_SENDTCP, MF_ENABLED );
357:
358: /*
359: * Reflect socket connection in title bar.
360: */
361: SetWindowText( hWnd, "Connected");
362: }
363:
364: /****************************************************************************\
365: *
366: * FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
367: *
368: * PURPOSE: Processes main window messages
369: *
370: * MESSAGES:
371: * WM_CREATE - call WSAStartUp() and display description message
372: * WSA_ACCEPT - User-defined message used with WSAAsyncSelect(). Sent
373: * by the Windows Sockets DLL when a socket connection is
374: * pending.
375: *
376: * WM_COMMAND
377: * IDM_CONNECT - Connect to a remote host.
378: * IDM_LISTEN - Use the BSD-Style accept().
379: * IDM_ALISTEN - Use the Windows Sockets Asynchronous APIs to detect when
380: * a connection is made.
381: * IDM_CANCEL - Cancel the Asynchronous call above.
382: * IDM_TLISTEN - Uses two threads to accept network connections (using the
383: * BSD-Style accept().
384: * IDM_HOSTNAME- Display information about a host.
385: * IDM_ABOUT - About box.
386: *
387: * WM_DESTROY - destroy window and call the WSACleanUp()
388: *
389: *\***************************************************************************/
390:
391: LONG APIENTRY MainWndProc(
392: HWND hWnd, /* window handle */
393: UINT message, /* type of message */
394: UINT wParam, /* additional information */
395: LONG lParam) /* additional information */
396: {
397: int status; /* Status Code */
398: SOCKADDR_IN local_sin; /* Local socket - internet style */
399: SOCKADDR_IN acc_sin; /* Accept socket address - internet style */
400: int acc_sin_len; /* Accept socket address length */
401:
402:
403: switch (message) {
404: case WM_CREATE:
405: {
406: WSADATA WSAData;
407: char szTemp[80];
408:
409: if ((status = WSAStartup(MAKEWORD(1,1), &WSAData)) == 0) {
410: MessageBox( hWnd, WSAData.szDescription, WSAData.szSystemStatus, MB_OK);
411: }
412: else {
413: sprintf(szTemp, "%d is the err", status);
414: MessageBox( hWnd, szTemp, "Error", MB_OK);
415: }
416: }
417: break; /* WM_CREATE */
418:
419: /*
420: * Notification if data is waiting on a socket. This comes
421: * from Windows Sockets (via WSAAsyncSelect()).
422: */
423: case WSA_READ:
424: {
425: char szTemp[ MY_MSG_LENGTH ];
426:
427: if (WSAGETSELECTEVENT(lParam) == FD_READ) {
428: status = recv((SOCKET)wParam, szTemp, MY_MSG_LENGTH, NO_FLAGS_SET );
429:
430: if (status) {
431: szTemp[ status ] = '\0';
432: MessageBox( hWnd, szTemp, "WSA_READ", MB_OK);
433: }
434: else
435: MessageBox( hWnd, "Connection broken", "Error", MB_OK);
436: }
437: else { /* FD_CLOSE -- connection dropped */
438: MessageBox( hWnd, "Connection lost", "WSA_READ", MB_OK);
439: EnableMenuItem(GetMenu( hWnd ), IDM_HOSTNAME, MF_ENABLED);
440: EnableMenuItem(GetMenu( hWnd ), IDM_LISTEN, MF_ENABLED);
441: EnableMenuItem(GetMenu( hWnd ), IDM_CONNECT, MF_ENABLED);
442: EnableMenuItem(GetMenu( hWnd ), IDM_ALISTEN, MF_ENABLED);
443: EnableMenuItem(GetMenu( hWnd ), IDM_TLISTEN, MF_ENABLED);
444: EnableMenuItem(GetMenu( hWnd ), IDM_CANCEL, MF_GRAYED);
445: EnableMenuItem(GetMenu( hWnd ), IDM_SENDTCP, MF_GRAYED);
446: }
447:
448:
449: }
450: break; /* WSA_READ*/
451:
452: case WSA_ACCEPT: /* Notification if a socket connection is pending. */
453: /*
454: * Disable/enable proper menu items.
455: */
456: EnableMenuItem(GetMenu( hWnd ), IDM_HOSTNAME, MF_ENABLED);
457: EnableMenuItem(GetMenu( hWnd ), IDM_LISTEN, MF_ENABLED);
458: EnableMenuItem(GetMenu( hWnd ), IDM_CONNECT, MF_ENABLED);
459: EnableMenuItem(GetMenu( hWnd ), IDM_ALISTEN, MF_ENABLED);
460: EnableMenuItem(GetMenu( hWnd ), IDM_TLISTEN, MF_ENABLED);
461: EnableMenuItem(GetMenu( hWnd ), IDM_CANCEL, MF_GRAYED);
462:
463: if (WSAGETSELECTERROR( lParam ) == 0) { /* Success */
464:
465: /*
466: * Accept the incoming connection.
467: */
468: acc_sin_len = sizeof( acc_sin );
469: sock = accept( sock,(struct sockaddr FAR *) &acc_sin,
470: (int FAR *) &acc_sin_len );
471:
472: if (sock < 0) {
473: sprintf(szBuff, "%d is the error", WSAGetLastError());
474:
475: MessageBox(hWnd, szBuff, "accept(sock) failed", MB_OK);
476: break;
477: }
478:
479: MessageBox(hWnd, "accept()", "Accepted a connection!", MB_OK);
480:
481: /*
482: * Now have a connection --
483: * SetConnectMenus() grays/enables proper menu items
484: */
485: SetConnectMenus( hWnd );
486:
487: /*
488: * Send main window a WSA_READ when either data is pending on
489: * the socket (FD_READ) or the connection is closed (FD_CLOSE)
490: */
491: if ((status = WSAAsyncSelect( sock, hWnd, WSA_READ, FD_READ | FD_CLOSE )) > 0) {
492: wsprintf(szBuff, "%d (0x%x)", status, status);
493: MessageBox( hWnd, "Error on WSAAsyncSelect()", szBuff, MB_OK);
494: closesocket( sock );
495: }
496: }
497: else {
498: MessageBox(hWnd, "accept()", "Error occured!", MB_OK);
499:
500: /*
501: * Cancel any further notifications.
502: */
503: WSAAsyncSelect( sock, hWnd, 0, 0);
504: SetWindowText( hWnd, "Async Listen call canceled");
505: }
506: break; /* WSA_ACCEPT */
507:
508:
509:
510: case WM_COMMAND: /* message: command from application menu */
511: switch(LOWORD(wParam)) {
512: case IDM_CONNECT: /* Client - connect to remote host */
513: {
514: /*
515:
516: When a network client wants to connect to a server,
517: it must have:
518: 1.) a TCP port number (gotten via getservbyname())
519: and
520: 2.) an IP address of the remote host (gotten via gethostbyname()).
521:
522: The following summarizes the steps used to connect.
523: Make a dialog box (HostName)
524: Get the name of the remote host computer in which
525: to connect from the user (store string in "szBuff" global var)
526: * Check to see if the hosts file knows the computer (gethostbyname)
527: * Get the host information (hostent structure filled)
528: * Fill in the address of the remote host into the servent structure (memcpy)
529: * Make a dialog box (TCPPORTNUM)
530: * Get the NAME of the port to connect to on the remote host from the
531: user.
532: * Get the port number (getservbyname)
533: * Fill in the port number of the servent structure
534: Establish a connection (connect)
535:
536: The * prefixed steps are done in the FillAddr() procedure.
537:
538:
539: */
540: SOCKADDR_IN dest_sin; /* DESTination Socket INternet */
541:
542:
543:
544: /* Get the name of the remote host. Store the string in szBuff. */
545:
546: status = DialogBox(hInst,
547: "HOSTNAME",
548: hWnd,
549: GetHostName);
550:
551: if (!status) /* User cancelled request from prev. dialog box */
552: break;
553:
554: sock = socket( AF_INET, SOCK_STREAM, 0);
555: if (sock == INVALID_SOCKET) {
556: MessageBox(hWnd, "socket() failed", "Error", MB_OK);
557: break;
558: }
559:
560: /*
561: * Retrieve the IP address and TCP Port number
562: * Global variable szBuff contains the remote host name.
563: */
564: if (!FillAddr( hWnd, &dest_sin, TRUE)) {
565: closesocket( sock );
566: break;
567: }
568:
569:
570: if (connect( sock, (PSOCKADDR) &dest_sin, sizeof( dest_sin)) < 0) {
571: closesocket( sock );
572: MessageBox(hWnd, "connect() failed", "Error", MB_OK);
573: break;
574: }
575: MessageBox(hWnd, "connect() worked!", "Success!", MB_OK);
576:
577: /*
578: * Now have a connection --
579: * SetConnectMenus() grays/enables proper menu items
580: */
581: SetConnectMenus( hWnd );
582:
583: /*
584: * Send main window a WSA_READ when either data is pending on
585: * the socket (FD_READ) or the connection is closed (FD_CLOSE)
586: */
587: if ((status = WSAAsyncSelect( sock, hWnd, WSA_READ, FD_READ | FD_CLOSE )) > 0) {
588: wsprintf(szBuff, "%d (0x%x)");
589: MessageBox( hWnd, "Error on WSAAsyncSelect()", szBuff, MB_OK);
590: closesocket( sock );
591: }
592:
593: }
594: break; /* IDM_CONNECT */
595:
596: case IDM_LISTEN:
597: {
598: sock = socket( AF_INET, SOCK_STREAM, 0);
599: if (sock == INVALID_SOCKET) {
600: MessageBox(hWnd, "socket() failed", "Error", MB_OK);
601: closesocket(sock);
602: break;
603: }
604:
605: /*
606: * Retrieve the IP address and TCP Port number
607: */
608:
609: if (!FillAddr(hWnd, &local_sin, FALSE ))
610: break;
611:
612: /*
613: * Disable/enable proper menu items.
614: */
615: EnableMenuItem(GetMenu( hWnd ), IDM_HOSTNAME, MF_GRAYED);
616: EnableMenuItem(GetMenu( hWnd ), IDM_LISTEN, MF_GRAYED);
617: EnableMenuItem(GetMenu( hWnd ), IDM_ALISTEN, MF_GRAYED);
618: EnableMenuItem(GetMenu( hWnd ), IDM_TLISTEN, MF_GRAYED);
619: EnableMenuItem(GetMenu( hWnd ), IDM_CONNECT, MF_GRAYED);
620:
621: SetWindowText( hWnd, "Waiting for connection..");
622:
623:
624: /*
625: * Associate an address with a socket. (bind)
626: */
627: if (bind( sock, (struct sockaddr FAR *) &local_sin, sizeof(local_sin)) == SOCKET_ERROR) {
628: sprintf(szBuff, "%d is the error", WSAGetLastError());
629:
630: MessageBox(hWnd, szBuff, "bind(sock) failed", MB_OK);
631: break;
632: }
633:
634: if (listen( sock, MAX_PENDING_CONNECTS ) < 0) {
635: sprintf(szBuff, "%d is the error", WSAGetLastError());
636:
637: MessageBox(hWnd, szBuff, "listen(sock) failed", MB_OK);
638: break;
639: }
640:
641: acc_sin_len = sizeof(acc_sin);
642:
643:
644: sock = accept( sock,(struct sockaddr FAR *) &acc_sin,
645: (int FAR *) &acc_sin_len );
646: if (sock < 0) {
647: sprintf(szBuff, "%d is the error", WSAGetLastError());
648:
649: MessageBox(hWnd, szBuff, "accept(sock) failed", MB_OK);
650: break;
651: }
652:
653: MessageBox(hWnd, "accept()", "Accepted a connection!", MB_OK);
654:
655: /*
656: * Now have a connection --
657: * SetConnectMenus() grays/enables proper menu items
658: */
659: SetConnectMenus( hWnd );
660:
661: /*
662: * Send main window a WSA_READ when either data is pending on
663: * the socket (FD_READ) or the connection is closed (FD_CLOSE)
664: */
665: if ((status = WSAAsyncSelect( sock, hWnd, WSA_READ, FD_READ | FD_CLOSE )) > 0) {
666: wsprintf(szBuff, "%d (0x%x)");
667: MessageBox( hWnd, "Error on WSAAsyncSelect()", szBuff, MB_OK);
668: closesocket( sock );
669: }
670:
671: }
672: break; /* IDM_LISTEN */
673:
674: /*
675: * Asynchronous Listen - Using WSA extensions.
676: */
677: case IDM_ALISTEN:
678: {
679:
680: sock = socket( AF_INET, SOCK_STREAM, 0);
681: if (sock == INVALID_SOCKET) {
682: MessageBox(hWnd, "socket() failed", "Error", MB_OK);
683: break;
684: }
685: /*
686: * Retrieve the IP address and TCP Port number
687: */
688:
689: if (!FillAddr( hWnd, &local_sin, FALSE)) {
690: closesocket( sock );
691: break;
692: }
693:
694: /*
695: * Disable/enable proper menu items.
696: */
697: EnableMenuItem(GetMenu( hWnd ), IDM_HOSTNAME, MF_GRAYED);
698: EnableMenuItem(GetMenu( hWnd ), IDM_LISTEN, MF_GRAYED);
699: EnableMenuItem(GetMenu( hWnd ), IDM_CONNECT, MF_GRAYED);
700: EnableMenuItem(GetMenu( hWnd ), IDM_ALISTEN, MF_GRAYED);
701: EnableMenuItem(GetMenu( hWnd ), IDM_TLISTEN, MF_GRAYED);
702: EnableMenuItem(GetMenu( hWnd ), IDM_CANCEL, MF_ENABLED);
703:
704: SetWindowText( hWnd, "Waiting for connection.. (Async)");
705:
706:
707: /*
708: * Associate an address with a socket. (bind)
709: */
710: if (bind( sock, (struct sockaddr FAR *) &local_sin, sizeof(local_sin)) == SOCKET_ERROR) {
711: sprintf(szBuff, "%d is the error", WSAGetLastError());
712:
713: MessageBox(hWnd, szBuff, "bind(sock) failed", MB_OK);
714: closesocket( sock );
715: break;
716: }
717:
718: if (listen( sock, MAX_PENDING_CONNECTS ) < 0) {
719: sprintf(szBuff, "%d is the error", WSAGetLastError());
720:
721: MessageBox(hWnd, szBuff, "listen(sock) failed", MB_OK);
722: break;
723: }
724:
725: /*
726: * Send window a WSA_ACCEPT when something is trying to connect.
727: */
728: if ((status = WSAAsyncSelect( sock, hWnd, WSA_ACCEPT, FD_ACCEPT)) > 0) {
729: wsprintf( szBuff, "%d (0x%x)");
730: MessageBox( hWnd, "Error on WSAAsyncSelect()", szBuff, MB_OK);
731: SetWindowText( hWnd, "Async listen cancelled");
732: closesocket( sock );
733: }
734:
735: }
736: break; /* IDM_ALISTEN */
737:
738:
739: /*
740: * Cancel an asynchronous call.
741: */
742: case IDM_CANCEL:
743: WSAAsyncSelect( sock, hWnd, 0, 0);
744: SetWindowText( hWnd, "Async Listen cancelled..");
745:
746: /*
747: * Disable/enable proper menu items.
748: */
749: EnableMenuItem(GetMenu( hWnd ), IDM_HOSTNAME, MF_ENABLED);
750: EnableMenuItem(GetMenu( hWnd ), IDM_LISTEN, MF_ENABLED);
751: EnableMenuItem(GetMenu( hWnd ), IDM_CONNECT, MF_ENABLED);
752: EnableMenuItem(GetMenu( hWnd ), IDM_ALISTEN, MF_ENABLED);
753: EnableMenuItem(GetMenu( hWnd ), IDM_TLISTEN, MF_ENABLED);
754: EnableMenuItem(GetMenu( hWnd ), IDM_CANCEL, MF_GRAYED);
755: EnableMenuItem(GetMenu( hWnd ), IDM_SENDTCP, MF_GRAYED);
756:
757: break; /* IDM_CANCEL */
758:
759: /*
760: * Listen in the main thread -- spawn and accept two network
761: * connections inside two threads.
762: */
763: case IDM_TLISTEN:
764: {
765: static THREADPACK tp;
766:
767: sock = socket( AF_INET, SOCK_STREAM, 0);
768: if (sock == INVALID_SOCKET) {
769: MessageBox(hWnd, "socket() failed", "Error", MB_OK);
770: closesocket(sock);
771: break;
772: }
773:
774: /*
775: * Retrieve the IP address and TCP Port number
776: */
777:
778: if (!FillAddr(hWnd, &local_sin, FALSE ))
779: break;
780:
781: /*
782: * Disable/enable proper menu items.
783: */
784: EnableMenuItem(GetMenu( hWnd ), IDM_HOSTNAME, MF_GRAYED);
785: EnableMenuItem(GetMenu( hWnd ), IDM_LISTEN, MF_GRAYED);
786: EnableMenuItem(GetMenu( hWnd ), IDM_ALISTEN, MF_GRAYED);
787: EnableMenuItem(GetMenu( hWnd ), IDM_TLISTEN, MF_GRAYED);
788: EnableMenuItem(GetMenu( hWnd ), IDM_CONNECT, MF_GRAYED);
789: EnableMenuItem(GetMenu( hWnd ), IDM_SENDTCP, MF_GRAYED);
790:
791: SetWindowText( hWnd, "Waiting for connection..");
792:
793:
794: /*
795: * Associate an address with a socket. (bind)
796: */
797: if (bind( sock, (struct sockaddr FAR *) &local_sin, sizeof(local_sin)) == SOCKET_ERROR) {
798: sprintf(szBuff, "%d is the error", WSAGetLastError());
799:
800: MessageBox(hWnd, szBuff, "bind(sock) failed", MB_OK);
801: break;
802: }
803:
804: if (listen( sock, MAX_PENDING_CONNECTS ) < 0) {
805: sprintf(szBuff, "%d is the error", WSAGetLastError());
806:
807: MessageBox(hWnd, szBuff, "listen(sock) failed", MB_OK);
808: break;
809: }
810:
811: tp.nThread = 0;
812: tp.hWnd = hWnd;
813:
814: _beginthread(AcceptThreadProc, 0, &tp);
815:
816: }
817: break; /* IDM_TLISTEN */
818:
819:
820: /*
821: * Display host information.
822: */
823: case IDM_HOSTNAME:
824:
825: /*
826: * Prompt the user and retrieve the text name of the host.
827: */
828: status = DialogBox(hInst,
829: "HOSTNAME",
830: hWnd,
831: GetHostName);
832:
833:
834: if (status == TRUE) { /* If user hit "OK" .. */
835:
836: /*
837: * Get the host information
838: */
839:
840: if ((phe = gethostbyname( szBuff )) == NULL) {
841: MessageBox(hWnd, "gethostbyname() failed", "Error", MB_OK);
842: break;
843: }
844: else {
845:
846: /*
847: * Display the host information ..
848: */
849: DialogBox(hInst,
850: "DISPLAYHOST",
851: hWnd,
852: DisplayHostEnt);
853: }
854: }
855: break; /* IDM_HOSTNAME */
856: /*
857: * Send a message to (via TCP connection) to remote host.
858: */
859: case IDM_SENDTCP:
860: DialogBox(hInst, /* current instance */
861: "GetString", /* resource to use */
862: hWnd, /* parent handle */
863: GetSendString); /* instance address */
864:
865: /*
866: * Assumption -- The GetString dialog box proc fills the global
867: * string buffer, szBuff, with the desired string to send.
868: */
869: send(sock, szBuff, strlen(szBuff), NO_FLAGS_SET );
870:
871: break; /* IDM_SENDTCP */
872:
873:
874:
875: case IDM_ABOUT:
876: DialogBox(hInst, /* current instance */
877: "AboutBox", /* resource to use */
878: hWnd, /* parent handle */
879: About); /* About() instance address */
880:
881: break; /* IDM_ABOUT */
882:
883: default:
884: /* Lets Windows process it */
885: return (DefWindowProc(hWnd, message, wParam, lParam));
886: break;
887: }
888: break;
889:
890:
891: /*
892: * Clean up. Takes care of any open socket descriptors.
893: */
894: case WM_DESTROY:
895: WSACleanup();
896: PostQuitMessage(0);
897: break;
898:
899: default: /* Passes it on if unproccessed */
900: return (DefWindowProc(hWnd, message, wParam, lParam));
901:
902: }
903: return (0);
904:
905: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.