![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wshsmple.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / ddk / wshsmple|
Return to wshsmple.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / ddk / wshsmple |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: WshTcpip.c
8:
9: Abstract:
10:
11: This module contains necessary routines for the TCP/IP Windows Sockets
12: Helper DLL. This DLL provides the transport-specific support necessary
13: for the Windows Sockets DLL to use TCP/IP as a transport.
14:
15: Author:
16:
17: David Treadwell 19-Jul-1992
18:
19: Revision History:
20:
21: Converted to use Win32 APIs.
22:
23: --*/
24:
25: #include <windows.h>
26: #include <winerror.h>
27: #include <winioctl.h>
28:
29: #include <assert.h>
30: #include <wchar.h>
31:
32: typedef LONG NTSTATUS;
33: /*lint -e624 */ // Don't complain about different typedefs. // winnt
34: typedef NTSTATUS *PNTSTATUS;
35: /*lint +e624 */ // Resume checking for different typedefs. // winnt
36:
37: #include <tdi.h>
38:
39: #include <winsock.h>
40:
41: typedef struct _UNICODE_STRING {
42: USHORT Length;
43: USHORT MaximumLength;
44: #ifdef MIDL_PASS
45: [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT * Buffer;
46: #else // MIDL_PASS
47: PWSTR Buffer;
48: #endif // MIDL_PASS
49: } UNICODE_STRING;
50: typedef UNICODE_STRING *PUNICODE_STRING;
51: #define UNICODE_NULL ((WCHAR)0) // winnt
52:
53: #define RtlInitUnicodeString(s, b) \
54: do \
55: { \
56: PUNICODE_STRING string = (s); \
57: PWSTR buffer = (b); \
58: int length = 2 * wcslen(buffer); \
59: \
60: string->Length = length; \
61: string->MaximumLength = length; \
62: string->Buffer = buffer; \
63: } \
64: while ( 0 );
65:
66: #include <wsahelp.h>
67:
68: #include <sys\snet\stcp_opt.h>
69:
70: //
71: // Structure and variables to define the triples supported by TCP/IP. The
72: // first entry of each array is considered the canonical triple for
73: // that socket type; the other entries are synonyms for the first.
74: //
75:
76: typedef struct _MAPPING_TRIPLE {
77: INT AddressFamily;
78: INT SocketType;
79: INT Protocol;
80: } MAPPING_TRIPLE, *PMAPPING_TRIPLE;
81:
82: MAPPING_TRIPLE TcpMappingTriples[] = { AF_INET, SOCK_STREAM, IPPROTO_TCP,
83: AF_INET, SOCK_STREAM, 0,
84: AF_INET, 0, IPPROTO_TCP,
85: AF_UNSPEC, 0, IPPROTO_TCP,
86: AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP };
87:
88: MAPPING_TRIPLE UdpMappingTriples[] = { AF_INET, SOCK_DGRAM, IPPROTO_UDP,
89: AF_INET, SOCK_DGRAM, 0,
90: AF_INET, 0, IPPROTO_UDP,
91: AF_UNSPEC, 0, IPPROTO_UDP,
92: AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP };
93:
94: //
95: // Forward declarations of internal routines.
96: //
97:
98: VOID
99: WINAPI
100: CompleteTdiActionApc (
101: DWORD dwErrorCode,
102: DWORD dwNumberOfBytesTransfered,
103: LPOVERLAPPED lpOverlapped
104: );
105:
106: INT
107: DoTdiAction (
108: IN HANDLE TdiConnectionObjectHandle,
109: IN INT OptionLevel,
110: IN INT OptionName,
111: IN INT OptionalData
112: );
113:
114: BOOLEAN
115: IsTripleInList (
116: IN PMAPPING_TRIPLE List,
117: IN ULONG ListLength,
118: IN INT AddressFamily,
119: IN INT SocketType,
120: IN INT Protocol
121: );
122:
123: //
124: // The socket context structure for this DLL. Each open TCP/IP socket
125: // will have one of these context structures, which is used to maintain
126: // information about the socket.
127: //
128:
129: typedef struct _WSHTCPIP_SOCKET_CONTEXT {
130: INT AddressFamily;
131: INT SocketType;
132: INT Protocol;
133: INT ReceiveBufferSize;
134: BOOLEAN KeepAlive;
135: BOOLEAN DontRoute;
136: BOOLEAN NoDelay;
137: } WSHTCPIP_SOCKET_CONTEXT, *PWSHTCPIP_SOCKET_CONTEXT;
138:
139: #define DEFAULT_RECEIVE_BUFFER_SIZE 8192
140:
141:
142: INT
143: WINAPI
144: WSHGetSockaddrType (
145: IN PSOCKADDR Sockaddr,
146: IN DWORD SockaddrLength,
147: OUT PSOCKADDR_INFO SockaddrInfo
148: )
149:
150: /*++
151:
152: Routine Description:
153:
154: This routine parses a sockaddr to determine the type of the
155: machine address and endpoint address portions of the sockaddr.
156: This is called by the winsock DLL whenever it needs to interpret
157: a sockaddr.
158:
159: Arguments:
160:
161: Sockaddr - a pointer to the sockaddr structure to evaluate.
162:
163: SockaddrLength - the number of bytes in the sockaddr structure.
164:
165: SockaddrInfo - a pointer to a structure that will receive information
166: about the specified sockaddr.
167:
168:
169: Return Value:
170:
171: INT - a winsock error code indicating the status of the operation, or
172: NO_ERROR if the operation succeeded.
173:
174: --*/
175:
176: {
177: UNALIGNED SOCKADDR_IN *sockaddr = (PSOCKADDR_IN)Sockaddr;
178: ULONG i;
179:
180: //
181: // Make sure that the address family is correct.
182: //
183:
184: if ( sockaddr->sin_family != AF_INET ) {
185: return WSAEAFNOSUPPORT;
186: }
187:
188: //
189: // Make sure that the length is correct.
190: //
191:
192: if ( SockaddrLength < sizeof(SOCKADDR_IN) ) {
193: return WSAEFAULT;
194: }
195:
196: //
197: // The address passed the tests, looks like a good address.
198: // Determine the type of the address portion of the sockaddr.
199: //
200:
201: if ( sockaddr->sin_addr.s_addr == INADDR_ANY ) {
202: SockaddrInfo->AddressInfo = SockaddrAddressInfoWildcard;
203: } else if ( sockaddr->sin_addr.s_addr == INADDR_BROADCAST ) {
204: SockaddrInfo->AddressInfo = SockaddrAddressInfoBroadcast;
205: } else if ( sockaddr->sin_addr.s_addr == INADDR_LOOPBACK ) {
206: SockaddrInfo->AddressInfo = SockaddrAddressInfoLoopback;
207: } else {
208: SockaddrInfo->AddressInfo = SockaddrAddressInfoNormal;
209: }
210:
211: //
212: // Determine the type of the port (endpoint) in the sockaddr.
213: //
214:
215: if ( sockaddr->sin_port == 0 ) {
216: SockaddrInfo->EndpointInfo = SockaddrEndpointInfoWildcard;
217: } else if ( ntohs( sockaddr->sin_port ) < 2000 ) {
218: SockaddrInfo->EndpointInfo = SockaddrEndpointInfoReserved;
219: } else {
220: SockaddrInfo->EndpointInfo = SockaddrEndpointInfoNormal;
221: }
222:
223: //
224: // Zero out the sin_zero part of the address. We silently allow
225: // nonzero values in this field.
226: //
227:
228: for ( i = 0; i < sizeof(sockaddr->sin_zero); i++ ) {
229: sockaddr->sin_zero[i] = 0;
230: }
231:
232: return NO_ERROR;
233:
234: } // WSHGetSockaddrType
235:
236:
237: INT
238: WINAPI
239: WSHGetSocketInformation (
240: IN PVOID HelperDllSocketContext,
241: IN SOCKET SocketHandle,
242: IN HANDLE TdiAddressObjectHandle,
243: IN HANDLE TdiConnectionObjectHandle,
244: IN INT Level,
245: IN INT OptionName,
246: OUT PCHAR OptionValue,
247: OUT PINT OptionLength
248: )
249:
250: /*++
251:
252: Routine Description:
253:
254: This routine retrieves information about a socket for those socket
255: options supported in this helper DLL. The options supported here
256: are SO_KEEPALIVE and SO_DONTROUTE. This routine is called by
257: the winsock DLL when a level/option name combination is passed
258: to getsockopt() that the winsock DLL does not understand.
259:
260: Arguments:
261:
262: HelperDllSocketContext - the context pointer returned from
263: WSHOpenSocket().
264:
265: SocketHandle - the handle of the socket for which we're getting
266: information.
267:
268: TdiAddressObjectHandle - the TDI address object of the socket, if
269: any. If the socket is not yet bound to an address, then
270: it does not have a TDI address object and this parameter
271: will be NULL.
272:
273: TdiConnectionObjectHandle - the TDI connection object of the socket,
274: if any. If the socket is not yet connected, then it does not
275: have a TDI connection object and this parameter will be NULL.
276:
277: Level - the level parameter passed to getsockopt().
278:
279: OptionName - the optname parameter passed to getsockopt().
280:
281: OptionValue - the optval parameter passed to getsockopt().
282:
283: OptionLength - the optlen parameter passed to getsockopt().
284:
285: Return Value:
286:
287: INT - a winsock error code indicating the status of the operation, or
288: NO_ERROR if the operation succeeded.
289:
290: --*/
291:
292: {
293: PWSHTCPIP_SOCKET_CONTEXT context = HelperDllSocketContext;
294:
295: UNREFERENCED_PARAMETER( SocketHandle );
296: UNREFERENCED_PARAMETER( TdiAddressObjectHandle );
297: UNREFERENCED_PARAMETER( TdiConnectionObjectHandle );
298:
299: //
300: // Check if this is an internal request for context information.
301: //
302:
303: if ( Level == SOL_INTERNAL && OptionName == SO_CONTEXT ) {
304:
305: //
306: // The Windows Sockets DLL is requesting context information
307: // from us. If an output buffer was not supplied, the Windows
308: // Sockets DLL is just requesting the size of our context
309: // information.
310: //
311:
312: if ( OptionValue != NULL ) {
313:
314: //
315: // Make sure that the buffer is sufficient to hold all the
316: // context information.
317: //
318:
319: if ( *OptionLength < sizeof(*context) ) {
320: return WSAEFAULT;
321: }
322:
323: //
324: // Copy in the context information.
325: //
326:
327: CopyMemory( OptionValue, context, sizeof(*context) );
328: }
329:
330: *OptionLength = sizeof(*context);
331:
332: return NO_ERROR;
333: }
334:
335: //
336: // The only other levels we support here are SOL_SOCKET and
337: // IPPROTO_TCP.
338: //
339:
340: if ( Level != SOL_SOCKET && Level != IPPROTO_TCP ) {
341: return WSAEINVAL;
342: }
343:
344: //
345: // Make sure that the output buffer is sufficiently large.
346: //
347:
348: if ( *OptionLength < sizeof(int) ) {
349: return WSAEFAULT;
350: }
351:
352: //
353: // Handle TCP-level options.
354: //
355:
356: if ( Level == IPPROTO_TCP ) {
357:
358: if ( OptionName != TCP_NODELAY ) {
359: return WSAEINVAL;
360: }
361:
362: if ( context->SocketType == SOCK_DGRAM ) {
363: return WSAENOPROTOOPT;
364: }
365:
366: ZeroMemory( OptionValue, *OptionLength );
367:
368: *OptionValue = context->NoDelay;
369: *OptionLength = sizeof(int);
370:
371: return NO_ERROR;
372: }
373:
374: //
375: // Handle socket-level options.
376: //
377:
378: switch ( OptionName ) {
379:
380: case SO_KEEPALIVE:
381:
382: if ( context->SocketType == SOCK_DGRAM ) {
383: return WSAENOPROTOOPT;
384: }
385:
386: ZeroMemory( OptionValue, *OptionLength );
387:
388: *OptionValue = context->KeepAlive;
389: *OptionLength = sizeof(int);
390:
391: break;
392:
393: case SO_DONTROUTE:
394:
395: ZeroMemory( OptionValue, *OptionLength );
396:
397: *OptionValue = context->DontRoute;
398: *OptionLength = sizeof(int);
399:
400: break;
401:
402: default:
403:
404: return WSAENOPROTOOPT;
405: }
406:
407: return NO_ERROR;
408:
409: } // WSHGetSocketInformation
410:
411:
412: INT
413: WINAPI
414: WSHGetWildcardSockaddr (
415: IN PVOID HelperDllSocketContext,
416: OUT PSOCKADDR Sockaddr,
417: OUT PINT SockaddrLength
418: )
419:
420: /*++
421:
422: Routine Description:
423:
424: This routine returns a wildcard socket address. A wildcard address
425: is one which will bind the socket to an endpoint of the transport's
426: choosing. For TCP/IP, a wildcard address has IP address ==
427: 0.0.0.0 and port = 0.
428:
429: Arguments:
430:
431: HelperDllSocketContext - the context pointer returned from
432: WSHOpenSocket() for the socket for which we need a wildcard
433: address.
434:
435: Sockaddr - points to a buffer which will receive the wildcard socket
436: address.
437:
438: SockaddrLength - receives the length of the wioldcard sockaddr.
439:
440: Return Value:
441:
442: INT - a winsock error code indicating the status of the operation, or
443: NO_ERROR if the operation succeeded.
444:
445: --*/
446:
447: {
448: if ( *SockaddrLength < sizeof(SOCKADDR_IN) ) {
449: return WSAEFAULT;
450: }
451:
452: *SockaddrLength = sizeof(SOCKADDR_IN);
453:
454: //
455: // Just zero out the address and set the family to AF_INET--this is
456: // a wildcard address for TCP/IP.
457: //
458:
459: ZeroMemory( Sockaddr, sizeof(SOCKADDR_IN) );
460:
461: Sockaddr->sa_family = AF_INET;
462:
463: return NO_ERROR;
464:
465: } // WSAGetWildcardSockaddr
466:
467:
468: DWORD
469: WINAPI
470: WSHGetWinsockMapping (
471: OUT PWINSOCK_MAPPING Mapping,
472: IN DWORD MappingLength
473: )
474:
475: /*++
476:
477: Routine Description:
478:
479: Returns the list of address family/socket type/protocol triples
480: supported by this helper DLL.
481:
482: Arguments:
483:
484: Mapping - receives a pointer to a WINSOCK_MAPPING structure that
485: describes the triples supported here.
486:
487: MappingLength - the length, in bytes, of the passed-in Mapping buffer.
488:
489: Return Value:
490:
491: DWORD - the length, in bytes, of a WINSOCK_MAPPING structure for this
492: helper DLL. If the passed-in buffer is too small, the return
493: value will indicate the size of a buffer needed to contain
494: the WINSOCK_MAPPING structure.
495:
496: --*/
497:
498: {
499: DWORD mappingLength;
500:
501: mappingLength = sizeof(WINSOCK_MAPPING) - sizeof(MAPPING_TRIPLE) +
502: sizeof(TcpMappingTriples) + sizeof(UdpMappingTriples);
503:
504: //
505: // If the passed-in buffer is too small, return the length needed
506: // now without writing to the buffer. The caller should allocate
507: // enough memory and call this routine again.
508: //
509:
510: if ( mappingLength > MappingLength ) {
511: return mappingLength;
512: }
513:
514: //
515: // Fill in the output mapping buffer with the list of triples
516: // supported in this helper DLL.
517: //
518:
519: Mapping->Rows = sizeof(TcpMappingTriples) / sizeof(TcpMappingTriples[0])
520: + sizeof(UdpMappingTriples) / sizeof(UdpMappingTriples[0]);
521: Mapping->Columns = sizeof(MAPPING_TRIPLE) / sizeof(DWORD);
522: MoveMemory(
523: Mapping->Mapping,
524: TcpMappingTriples,
525: sizeof(TcpMappingTriples)
526: );
527: MoveMemory(
528: (PCHAR)Mapping->Mapping + sizeof(TcpMappingTriples),
529: UdpMappingTriples,
530: sizeof(UdpMappingTriples)
531: );
532:
533: //
534: // Return the number of bytes we wrote.
535: //
536:
537: return mappingLength;
538:
539: } // WSHGetWinsockMapping
540:
541:
542: INT
543: WINAPI
544: WSHOpenSocket (
545: IN OUT PINT AddressFamily,
546: IN OUT PINT SocketType,
547: IN OUT PINT Protocol,
548: OUT PUNICODE_STRING TransportDeviceName,
549: OUT PVOID *HelperDllSocketContext,
550: OUT PDWORD NotificationEvents
551: )
552:
553: /*++
554:
555: Routine Description:
556:
557: Does the necessary work for this helper DLL to open a socket and is
558: called by the winsock DLL in the socket() routine. This routine
559: verifies that the specified triple is valid, determines the NT
560: device name of the TDI provider that will support that triple,
561: allocates space to hold the socket's context block, and
562: canonicalizes the triple.
563:
564: Arguments:
565:
566: AddressFamily - on input, the address family specified in the
567: socket() call. On output, the canonicalized value for the
568: address family.
569:
570: SocketType - on input, the socket type specified in the socket()
571: call. On output, the canonicalized value for the socket type.
572:
573: Protocol - on input, the protocol specified in the socket() call.
574: On output, the canonicalized value for the protocol.
575:
576: TransportDeviceName - receives the name of the TDI provider that
577: will support the specified triple.
578:
579: HelperDllSocketContext - receives a context pointer that the winsock
580: DLL will return to this helper DLL on future calls involving
581: this socket.
582:
583: NotificationEvents - receives a bitmask of those state transitions
584: this helper DLL should be notified on.
585:
586: Return Value:
587:
588: INT - a winsock error code indicating the status of the operation, or
589: NO_ERROR if the operation succeeded.
590:
591: --*/
592:
593: {
594: PWSHTCPIP_SOCKET_CONTEXT context;
595:
596: //
597: // Determine whether this is to be a TCP or UDP socket.
598: //
599:
600: if ( IsTripleInList(
601: TcpMappingTriples,
602: sizeof(TcpMappingTriples) / sizeof(TcpMappingTriples[0]),
603: *AddressFamily,
604: *SocketType,
605: *Protocol ) ) {
606:
607: //
608: // Return the canonical form of a TCP socket triple.
609: //
610:
611: *AddressFamily = TcpMappingTriples[0].AddressFamily;
612: *SocketType = TcpMappingTriples[0].SocketType;
613: *Protocol = TcpMappingTriples[0].Protocol;
614:
615: //
616: // Indicate the name of the TDI device that will service
617: // SOCK_STREAM sockets in the internet address family.
618: //
619:
620: RtlInitUnicodeString( TransportDeviceName, L"\\Device\\Streams\\Tcp" );
621:
622: } else if ( IsTripleInList(
623: UdpMappingTriples,
624: sizeof(UdpMappingTriples) / sizeof(UdpMappingTriples[0]),
625: *AddressFamily,
626: *SocketType,
627: *Protocol ) ) {
628:
629: //
630: // Return the canonical form of a UDP socket triple.
631: //
632:
633: *AddressFamily = UdpMappingTriples[0].AddressFamily;
634: *SocketType = UdpMappingTriples[0].SocketType;
635: *Protocol = UdpMappingTriples[0].Protocol;
636:
637: //
638: // Indicate the name of the TDI device that will service
639: // SOCK_DGRAM sockets in the internet address family.
640: //
641:
642: RtlInitUnicodeString( TransportDeviceName, L"\\Device\\Streams\\Udp" );
643:
644: } else {
645:
646: //
647: // This should never happen if the registry information about this
648: // helper DLL is correct. If somehow this did happen, just return
649: // an error.
650: //
651:
652: return WSAEINVAL;
653: }
654:
655: //
656: // Allocate context for this socket. The Windows Sockets DLL will
657: // return this value to us when it asks us to get/set socket options.
658: //
659:
660: context = (PWSHTCPIP_SOCKET_CONTEXT) HeapAlloc(
661: GetProcessHeap(),
662: 0,
663: sizeof(*context)
664: );
665: if ( context == NULL ) {
666: return WSAENOBUFS;
667: }
668:
669: //
670: // Initialize the context for the socket.
671: //
672:
673: context->AddressFamily = *AddressFamily;
674: context->SocketType = *SocketType;
675: context->Protocol = *Protocol;
676: context->ReceiveBufferSize = DEFAULT_RECEIVE_BUFFER_SIZE;
677: context->KeepAlive = FALSE;
678: context->DontRoute = FALSE;
679: context->NoDelay = FALSE;
680:
681: //
682: // Tell the Windows Sockets DLL which state transitions we're
683: // interested in being notified of. The only time we need to be
684: // called is after a connect has completed so that we can turn on
685: // the sending of keepalives if SO_KEEPALIVE was set before the
686: // socket was connected.
687: //
688:
689: *NotificationEvents = WSH_NOTIFY_CONNECT | WSH_NOTIFY_CLOSE;
690:
691: //
692: // Everything worked, return success.
693: //
694:
695: *HelperDllSocketContext = context;
696: return NO_ERROR;
697:
698: } // WSHOpenSocket
699:
700:
701: INT
702: WINAPI
703: WSHNotify (
704: IN PVOID HelperDllSocketContext,
705: IN SOCKET SocketHandle,
706: IN HANDLE TdiAddressObjectHandle,
707: IN HANDLE TdiConnectionObjectHandle,
708: IN DWORD NotifyEvent
709: )
710:
711: /*++
712:
713: Routine Description:
714:
715: This routine is called by the winsock DLL after a state transition
716: of the socket. Only state transitions returned in the
717: NotificationEvents parameter of WSHOpenSocket() are notified here.
718: This routine allows a winsock helper DLL to track the state of
719: socket and perform necessary actions corresponding to state
720: transitions.
721:
722: Arguments:
723:
724: HelperDllSocketContext - the context pointer given to the winsock
725: DLL by WSHOpenSocket().
726:
727: SocketHandle - the handle for the socket.
728:
729: TdiAddressObjectHandle - the TDI address object of the socket, if
730: any. If the socket is not yet bound to an address, then
731: it does not have a TDI address object and this parameter
732: will be NULL.
733:
734: TdiConnectionObjectHandle - the TDI connection object of the socket,
735: if any. If the socket is not yet connected, then it does not
736: have a TDI connection object and this parameter will be NULL.
737:
738: NotifyEvent - indicates the state transition for which we're being
739: called.
740:
741: Return Value:
742:
743: INT - a winsock error code indicating the status of the operation, or
744: NO_ERROR if the operation succeeded.
745:
746: --*/
747:
748: {
749: PWSHTCPIP_SOCKET_CONTEXT context = HelperDllSocketContext;
750: INT err;
751:
752: //
753: // We should only be called after a connect() completes or when the
754: // socket is being closed.
755: //
756:
757: if ( NotifyEvent == WSH_NOTIFY_CONNECT ) {
758:
759: //
760: // SO_KEEPALIVE or TCP_NODELAY was set before the socket was
761: // connected. Set it now.
762: //
763:
764: if ( context->KeepAlive ) {
765: err = DoTdiAction(
766: TdiConnectionObjectHandle,
767: TOL_TLI,
768: TO_KEEPALIVE,
769: TRUE
770: );
771: if ( err != NO_ERROR ) {
772: return err;
773: }
774: }
775:
776: if ( context->NoDelay ) {
777: err = DoTdiAction(
778: TdiConnectionObjectHandle,
779: TOL_TLI,
780: TO_NODELAY,
781: TRUE
782: );
783: if ( err != NO_ERROR ) {
784: return err;
785: }
786: }
787:
788: if ( context->ReceiveBufferSize != DEFAULT_RECEIVE_BUFFER_SIZE ) {
789: err = DoTdiAction(
790: TdiConnectionObjectHandle,
791: TOL_RCVBUF,
792: 0,
793: context->ReceiveBufferSize
794: );
795: if ( err != NO_ERROR ) {
796: return err;
797: }
798: }
799:
800: } else if ( NotifyEvent == WSH_NOTIFY_CLOSE ) {
801:
802: //
803: // Just free the socket context.
804: //
805:
806: HeapFree( GetProcessHeap( ), 0, (LPSTR)HelperDllSocketContext );
807:
808: } else {
809:
810: return WSAEINVAL;
811: }
812:
813:
814: return NO_ERROR;
815:
816: } // WSHNotify
817:
818:
819: INT
820: WINAPI
821: WSHSetSocketInformation (
822: IN PVOID HelperDllSocketContext,
823: IN SOCKET SocketHandle,
824: IN HANDLE TdiAddressObjectHandle,
825: IN HANDLE TdiConnectionObjectHandle,
826: IN INT Level,
827: IN INT OptionName,
828: IN PCHAR OptionValue,
829: IN INT OptionLength
830: )
831:
832: /*++
833:
834: Routine Description:
835:
836: This routine sets information about a socket for those socket
837: options supported in this helper DLL. The options supported here
838: are SO_KEEPALIVE and SO_DONTROUTE. This routine is called by the
839: winsock DLL when a level/option name combination is passed to
840: setsockopt() that the winsock DLL does not understand.
841:
842: Arguments:
843:
844: HelperDllSocketContext - the context pointer returned from
845: WSHOpenSocket().
846:
847: SocketHandle - the handle of the socket for which we're getting
848: information.
849:
850: TdiAddressObjectHandle - the TDI address object of the socket, if
851: any. If the socket is not yet bound to an address, then
852: it does not have a TDI address object and this parameter
853: will be NULL.
854:
855: TdiConnectionObjectHandle - the TDI connection object of the socket,
856: if any. If the socket is not yet connected, then it does not
857: have a TDI connection object and this parameter will be NULL.
858:
859: Level - the level parameter passed to setsockopt().
860:
861: OptionName - the optname parameter passed to setsockopt().
862:
863: OptionValue - the optval parameter passed to setsockopt().
864:
865: OptionLength - the optlen parameter passed to setsockopt().
866:
867: Return Value:
868:
869: INT - a winsock error code indicating the status of the operation, or
870: NO_ERROR if the operation succeeded.
871:
872: --*/
873:
874: {
875: PWSHTCPIP_SOCKET_CONTEXT context = HelperDllSocketContext;
876: INT error;
877: INT optionValue;
878:
879: UNREFERENCED_PARAMETER( SocketHandle );
880: UNREFERENCED_PARAMETER( TdiAddressObjectHandle );
881: UNREFERENCED_PARAMETER( TdiConnectionObjectHandle );
882:
883: //
884: // Check if this is an internal request for context information.
885: //
886:
887: if ( Level == SOL_INTERNAL && OptionName == SO_CONTEXT ) {
888:
889: //
890: // The Windows Sockets DLL is requesting that we set context
891: // information for a new socket. If the new socket was
892: // accept()'ed, then we have already been notified of the socket
893: // and HelperDllSocketContext will be valid. If the new socket
894: // was inherited or duped into this process, then this is our
895: // first notification of the socket and HelperDllSocketContext
896: // will be equal to NULL.
897: //
898: // Insure that the context information being passed to us is
899: // sufficiently large.
900: //
901:
902: if ( OptionLength < sizeof(*context) ) {
903: return WSAEINVAL;
904: }
905:
906: if ( HelperDllSocketContext == NULL ) {
907:
908: //
909: // This is our notification that a socket handle was
910: // inherited or duped into this process. Allocate a context
911: // structure for the new socket.
912: //
913:
914: context = (PWSHTCPIP_SOCKET_CONTEXT) HeapAlloc(
915: GetProcessHeap(),
916: 0,
917: sizeof(*context)
918: );
919: if ( context == NULL ) {
920: return WSAENOBUFS;
921: }
922:
923: //
924: // Copy over information into the context block.
925: //
926:
927: CopyMemory( context, OptionValue, sizeof(*context) );
928:
929: //
930: // Tell the Windows Sockets DLL where our context information is
931: // stored so that it can return the context pointer in future
932: // calls.
933: //
934:
935: *(PWSHTCPIP_SOCKET_CONTEXT *)OptionValue = context;
936:
937: return NO_ERROR;
938:
939: } else {
940:
941: PWSHTCPIP_SOCKET_CONTEXT parentContext;
942: INT one = 1;
943:
944: //
945: // The socket was accept()'ed and it needs to have the same
946: // properties as it'sw parent. The OptionValue buffer
947: // contains the context information of this socket's parent.
948: //
949:
950: parentContext = (PWSHTCPIP_SOCKET_CONTEXT)OptionValue;
951:
952: assert( context->AddressFamily == parentContext->AddressFamily );
953: assert( context->SocketType == parentContext->SocketType );
954: assert( context->Protocol == parentContext->Protocol );
955:
956: //
957: // Turn on in the child any options that have been set in
958: // the parent.
959: //
960:
961: if ( parentContext->KeepAlive ) {
962:
963: error = WSHSetSocketInformation(
964: HelperDllSocketContext,
965: SocketHandle,
966: TdiAddressObjectHandle,
967: TdiConnectionObjectHandle,
968: SOL_SOCKET,
969: SO_KEEPALIVE,
970: (PCHAR)&one,
971: sizeof(one)
972: );
973: if ( error != NO_ERROR ) {
974: return error;
975: }
976: }
977:
978: if ( parentContext->DontRoute ) {
979:
980: error = WSHSetSocketInformation(
981: HelperDllSocketContext,
982: SocketHandle,
983: TdiAddressObjectHandle,
984: TdiConnectionObjectHandle,
985: SOL_SOCKET,
986: SO_DONTROUTE,
987: (PCHAR)&one,
988: sizeof(one)
989: );
990: if ( error != NO_ERROR ) {
991: return error;
992: }
993: }
994:
995: if ( parentContext->NoDelay ) {
996:
997: error = WSHSetSocketInformation(
998: HelperDllSocketContext,
999: SocketHandle,
1000: TdiAddressObjectHandle,
1001: TdiConnectionObjectHandle,
1002: IPPROTO_TCP,
1003: TCP_NODELAY,
1004: (PCHAR)&one,
1005: sizeof(one)
1006: );
1007: if ( error != NO_ERROR ) {
1008: return error;
1009: }
1010: }
1011:
1012: if ( parentContext->ReceiveBufferSize != DEFAULT_RECEIVE_BUFFER_SIZE ) {
1013:
1014: error = WSHSetSocketInformation(
1015: HelperDllSocketContext,
1016: SocketHandle,
1017: TdiAddressObjectHandle,
1018: TdiConnectionObjectHandle,
1019: SOL_SOCKET,
1020: SO_RCVBUF,
1021: (PCHAR)&parentContext->ReceiveBufferSize,
1022: sizeof(parentContext->ReceiveBufferSize)
1023: );
1024: if ( error != NO_ERROR ) {
1025: return error;
1026: }
1027: }
1028:
1029: return NO_ERROR;
1030: }
1031: }
1032:
1033: //
1034: // The only other levels we support here are SOL_SOCKET and
1035: // IPPROTO_TCP.
1036: //
1037:
1038: if ( Level != SOL_SOCKET && Level != IPPROTO_TCP ) {
1039: return WSAEINVAL;
1040: }
1041:
1042: //
1043: // Make sure that the option length is sufficient.
1044: //
1045:
1046: if ( OptionLength < sizeof(int) ) {
1047: return WSAEFAULT;
1048: }
1049:
1050: optionValue = *(PINT)OptionValue;
1051:
1052: //
1053: // Handle TCP-level options.
1054: //
1055:
1056: if ( Level == IPPROTO_TCP ) {
1057:
1058: if ( OptionName != TCP_NODELAY ) {
1059: return WSAEINVAL;
1060: }
1061:
1062: if ( context->SocketType == SOCK_DGRAM ) {
1063: return WSAENOPROTOOPT;
1064: }
1065:
1066: //
1067: // Atempt to turn on or off Nagle's algorithm, as necessary.
1068: //
1069:
1070: if ( !context->NoDelay && optionValue != 0 ) {
1071:
1072: //
1073: // NoDelay is currently off and the application wants to
1074: // turn it on. If the TDI connection object handle is NULL,
1075: // then the socket is not yet connected. In this case we'll
1076: // just remember that the no delay option was set and
1077: // actually turn them on in WSHNotify() after a connect()
1078: // has completed on the socket.
1079: //
1080:
1081: if ( TdiConnectionObjectHandle != NULL ) {
1082: error = DoTdiAction(
1083: TdiConnectionObjectHandle,
1084: TOL_TLI,
1085: TO_NODELAY,
1086: TRUE
1087: );
1088: if ( error != NO_ERROR ) {
1089: return error;
1090: }
1091: }
1092:
1093: //
1094: // Remember that no delay is enabled for this socket.
1095: //
1096:
1097: context->NoDelay = TRUE;
1098:
1099: } else if ( context->NoDelay && optionValue == 0 ) {
1100:
1101: //
1102: // No delay is currently enabled and the application wants
1103: // to turn it off. If the TDI connection object is NULL,
1104: // the socket is not yet connected. In this case we'll just
1105: // remember that nodelay is disabled.
1106: //
1107:
1108: if ( TdiConnectionObjectHandle != NULL ) {
1109: error = DoTdiAction(
1110: TdiConnectionObjectHandle,
1111: TOL_TLI,
1112: TO_NODELAY,
1113: FALSE
1114: );
1115: if ( error != NO_ERROR ) {
1116: return error;
1117: }
1118: }
1119:
1120: //
1121: // Remember that no delay is disabled for this socket.
1122: //
1123:
1124: context->NoDelay = FALSE;
1125: }
1126:
1127: return NO_ERROR;
1128: }
1129:
1130: //
1131: // Handle socket-level options.
1132: //
1133:
1134: switch ( OptionName ) {
1135:
1136: case SO_KEEPALIVE:
1137:
1138: //
1139: // Atempt to turn on or off keepalive sending, as necessary.
1140: //
1141:
1142: if ( context->SocketType == SOCK_DGRAM ) {
1143: return WSAENOPROTOOPT;
1144: }
1145:
1146: if ( !context->KeepAlive && optionValue != 0 ) {
1147:
1148: //
1149: // Keepalives are currently off and the application wants to
1150: // turn them on. If the TDI connection object handle is
1151: // NULL, then the socket is not yet connected. In this case
1152: // we'll just remember that the keepalive option was set and
1153: // actually turn them on in WSHNotify() after a connect()
1154: // has completed on the socket.
1155: //
1156:
1157: if ( TdiConnectionObjectHandle != NULL ) {
1158: error = DoTdiAction(
1159: TdiConnectionObjectHandle,
1160: TOL_TLI,
1161: TO_KEEPALIVE,
1162: TRUE
1163: );
1164: if ( error != NO_ERROR ) {
1165: return error;
1166: }
1167: }
1168:
1169: //
1170: // Remember that keepalives are enabled for this socket.
1171: //
1172:
1173: context->KeepAlive = TRUE;
1174:
1175: } else if ( context->KeepAlive && optionValue == 0 ) {
1176:
1177: //
1178: // Keepalives are currently enabled and the application
1179: // wants to turn them off. If the TDI connection object is
1180: // NULL, the socket is not yet connected. In this case
1181: // we'll just remember that keepalives are disabled.
1182: //
1183:
1184: if ( TdiConnectionObjectHandle != NULL ) {
1185: error = DoTdiAction(
1186: TdiConnectionObjectHandle,
1187: TOL_TLI,
1188: TO_KEEPALIVE,
1189: FALSE
1190: );
1191: if ( error != NO_ERROR ) {
1192: return error;
1193: }
1194: }
1195:
1196: //
1197: // Remember that keepalives are disabled for this socket.
1198: //
1199:
1200: context->KeepAlive = FALSE;
1201: }
1202:
1203: break;
1204:
1205: case SO_DONTROUTE:
1206:
1207: //
1208: // We don't really support SO_DONTROUTE. Just remember that the
1209: // option was set or unset.
1210: //
1211:
1212: if ( optionValue != 0 ) {
1213: context->DontRoute = TRUE;
1214: } else if ( optionValue == 0 ) {
1215: context->DontRoute = FALSE;
1216: }
1217:
1218: break;
1219:
1220: case SO_RCVBUF:
1221:
1222: //
1223: // If the receive buffer size is being changed, tell TCP about
1224: // it. Do nothing if this is a datagram.
1225: //
1226:
1227: if ( context->ReceiveBufferSize == optionValue ||
1228: context->SocketType == SOCK_DGRAM ) {
1229: break;
1230: }
1231:
1232: //
1233: // We need to pass the new receive buffer size to the TCP
1234: // transport. If the TDI connection object is NULL, the socket
1235: // is not yet connected. In this case we'll just remember the
1236: // new buffer size and set it after the socket is connected.
1237: //
1238:
1239: if ( TdiConnectionObjectHandle != NULL ) {
1240: error = DoTdiAction(
1241: TdiConnectionObjectHandle,
1242: TOL_RCVBUF,
1243: 0,
1244: optionValue
1245: );
1246: if ( error != NO_ERROR ) {
1247: return error;
1248: }
1249: }
1250:
1251: context->ReceiveBufferSize = optionValue;
1252:
1253: break;
1254:
1255: default:
1256:
1257: return WSAENOPROTOOPT;
1258: }
1259:
1260: return NO_ERROR;
1261:
1262: } // WSHSetSocketInformation
1263:
1264:
1265: BOOLEAN
1266: IsTripleInList (
1267: IN PMAPPING_TRIPLE List,
1268: IN ULONG ListLength,
1269: IN INT AddressFamily,
1270: IN INT SocketType,
1271: IN INT Protocol
1272: )
1273:
1274: /*++
1275:
1276: Routine Description:
1277:
1278: Determines whether the specified triple has an exact match in the
1279: list of triples.
1280:
1281: Arguments:
1282:
1283: List - a list of triples (address family/socket type/protocol) to
1284: search.
1285:
1286: ListLength - the number of triples in the list.
1287:
1288: AddressFamily - the address family to look for in the list.
1289:
1290: SocketType - the socket type to look for in the list.
1291:
1292: Protocol - the protocol to look for in the list.
1293:
1294: Return Value:
1295:
1296: BOOLEAN - TRUE if the triple was found in the list, false if not.
1297:
1298: --*/
1299:
1300: {
1301: ULONG i;
1302:
1303: //
1304: // Walk through the list searching for an exact match.
1305: //
1306:
1307: for ( i = 0; i < ListLength; i++ ) {
1308:
1309: //
1310: // If all three elements of the triple match, return indicating
1311: // that the triple did exist in the list.
1312: //
1313:
1314: if ( AddressFamily == List[i].AddressFamily &&
1315: SocketType == List[i].SocketType &&
1316: Protocol == List[i].Protocol ) {
1317: return TRUE;
1318: }
1319: }
1320:
1321: //
1322: // The triple was not found in the list.
1323: //
1324:
1325: return FALSE;
1326:
1327: } // IsTripleInList
1328:
1329:
1330: INT
1331: DoTdiAction (
1332: IN HANDLE TdiConnectionObjectHandle,
1333: IN INT OptionLevel,
1334: IN INT OptionName,
1335: IN INT OptionalData
1336: )
1337:
1338: /*++
1339:
1340: Routine Description:
1341:
1342: Performs a TDI action to the TCP/IP driver. A TDI action translates
1343: into a streams T_OPTMGMT_REQ.
1344:
1345: Arguments:
1346:
1347: TdiConnectionObjectHandle - a TDI connection object on which to perform
1348: the TDI action.
1349:
1350: OptionLevel - the opt_level to pass in the TOPT structure.
1351:
1352: OptionName - The TPI option to set.
1353:
1354: OptionalData - data to put in the opt_data field of the TOPT
1355: structure.
1356:
1357: Return Value:
1358:
1359: INT - NO_ERROR, or a Windows Sockets error code.
1360:
1361: --*/
1362:
1363: {
1364: BOOLEAN deviceIoResult;
1365: PSTREAMS_TDI_ACTION tdiAction;
1366: ULONG tdiActionLength;
1367: TOPT *tpiOptions;
1368: ULONG outputLength;
1369:
1370: //
1371: // Allocate space to hold the TDI action buffer and the IO status
1372: // block. These cannot be stack variables in case we must return
1373: // before the operation is complete.
1374: //
1375:
1376: tdiActionLength = sizeof(*tdiAction) + sizeof(*tpiOptions) -
1377: sizeof(tdiAction->Buffer[0]);
1378:
1379: tdiAction = (PSTREAMS_TDI_ACTION) HeapAlloc(
1380: GetProcessHeap( ),
1381: 0,
1382: tdiActionLength
1383: );
1384: if ( tdiAction == NULL ) {
1385: return WSAENOBUFS;
1386: }
1387:
1388: //
1389: // Initialize the TDI action buffer.
1390: //
1391:
1392: tdiAction->BufferLength = sizeof(*tpiOptions);
1393:
1394: tpiOptions = (TOPT *)tdiAction->Buffer;
1395: tpiOptions->opt_level = OptionLevel;
1396: tpiOptions->opt_name = OptionName;
1397: tpiOptions->opt_data[0] = OptionalData;
1398:
1399: //
1400: // Make the actual TDI action call. The Streams TDI mapper will
1401: // translate this into a TPI option management request for us and
1402: // give it to TCP/IP.
1403: //
1404:
1405: deviceIoResult = DeviceIoControl(
1406: TdiConnectionObjectHandle,
1407: IOCTL_TDI_ACTION,
1408: tdiAction,
1409: tdiActionLength,
1410: tdiAction,
1411: tdiActionLength,
1412: &outputLength,
1413: NULL
1414: );
1415:
1416: HeapFree( GetProcessHeap( ), 0, (LPSTR)tdiAction );
1417:
1418: return deviceIoResult ? NO_ERROR : WSAENOBUFS;
1419:
1420: } // DoTdiAction
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.