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 / dt_dll / handlers.cpp < prev    next >
C/C++ Source or Header  |  1997-09-21  |  120KB  |  3,870 lines

  1. /*++
  2.  
  3.   Copyright (c) 1995 Intel Corp
  4.  
  5.   Module Name:
  6.  
  7.     handlers.cpp
  8.  
  9.   Abstract:
  10.  
  11.     Contains handler functions for each possible API or SPI hook.
  12.  
  13. --*/
  14.  
  15. #include "nowarn.h"  /* turn off benign warnings */
  16. #ifndef _WINSOCKAPI_
  17. #define _WINSOCKAPI_   /* Prevent inclusion of winsock.h in windows.h */
  18. #endif
  19.  
  20. #include "nowarn.h"  /* some warnings may have been turned back on */
  21. #include <winsock2.h>
  22. #include <ws2spi.h>
  23.  
  24. #include "handlers.h"
  25. #include "dt_dll.h"
  26. #include "dt.h"
  27.  
  28. // turn off unreferenced local variable warning
  29. #pragma warning(disable: 4100)
  30.  
  31.  
  32.  
  33. //
  34. // Function Definitions
  35. //
  36.  
  37.  
  38. BOOL
  39. DTHandlerInit(
  40.     OUT LPLPFNDTHANDLER HandlerFuncTable,
  41.     int                    NumEntries)
  42. /*++
  43.  
  44.   Function Description:
  45.  
  46.       Fills in the given HandlerFuncTable with pointers to all the
  47.       appropriate handler functions, based on notification code.
  48.  
  49.   Arguments:
  50.  
  51.       HandlerFuncTable -- an uninitialized array of pointers of type
  52.       LPFNDTHANDLER, which point to handler functions (see handlers.h)
  53.  
  54.       NumEntries -- the number of entries in the array.  Currently
  55.       only used to zero out the array.
  56.  
  57.   Return Value:
  58.  
  59.       Always returns TRUE.
  60.  
  61. --*/
  62. {
  63.     memset((char *)HandlerFuncTable, 0, NumEntries * sizeof(LPFNDTHANDLER));
  64.  
  65.     HandlerFuncTable[DTCODE_accept] = DTHandler_accept;
  66.     HandlerFuncTable[DTCODE_bind] = DTHandler_bind;
  67.     HandlerFuncTable[DTCODE_closesocket] = DTHandler_closesocket;
  68.     HandlerFuncTable[DTCODE_connect] = DTHandler_connect;
  69.     HandlerFuncTable[DTCODE_getpeername] = DTHandler_getpeername;
  70.     HandlerFuncTable[DTCODE_getsockname] = DTHandler_getsockname;
  71.     HandlerFuncTable[DTCODE_getsockopt] = DTHandler_getsockopt;
  72.     HandlerFuncTable[DTCODE_htonl] = DTHandler_htonl;
  73.     HandlerFuncTable[DTCODE_htons] = DTHandler_htons;
  74.     HandlerFuncTable[DTCODE_ioctlsocket] = DTHandler_ioctlsocket;
  75.     HandlerFuncTable[DTCODE_listen] = DTHandler_listen;
  76.     HandlerFuncTable[DTCODE_ntohl] = DTHandler_ntohl;
  77.     HandlerFuncTable[DTCODE_ntohs] = DTHandler_ntohs;
  78.     HandlerFuncTable[DTCODE_recv] = DTHandler_recv;
  79.     HandlerFuncTable[DTCODE_recvfrom] = DTHandler_recvfrom;
  80.     HandlerFuncTable[DTCODE_select] = DTHandler_select;
  81.     HandlerFuncTable[DTCODE_send] = DTHandler_send;
  82.     HandlerFuncTable[DTCODE_sendto] = DTHandler_sendto;
  83.     HandlerFuncTable[DTCODE_setsockopt] = DTHandler_setsockopt;
  84.     HandlerFuncTable[DTCODE_shutdown] = DTHandler_shutdown;
  85.     HandlerFuncTable[DTCODE_socket] = DTHandler_socket;
  86.     HandlerFuncTable[DTCODE_WSAAccept] = DTHandler_WSAAccept;
  87.     HandlerFuncTable[DTCODE_WSAAsyncSelect] = DTHandler_WSAAsyncSelect;
  88.     HandlerFuncTable[DTCODE_WSACancelBlockingCall] =
  89.       DTHandler_WSACancelBlockingCall;
  90.     HandlerFuncTable[DTCODE_WSACleanup] = DTHandler_WSACleanup;
  91.     HandlerFuncTable[DTCODE_WSACloseEvent] = DTHandler_WSACloseEvent;
  92.     HandlerFuncTable[DTCODE_WSAConnect] = DTHandler_WSAConnect;
  93.     HandlerFuncTable[DTCODE_WSACreateEvent] = DTHandler_WSACreateEvent;
  94.     HandlerFuncTable[DTCODE_WSADuplicateSocketA] =
  95.       DTHandler_WSADuplicateSocketA;
  96.     HandlerFuncTable[DTCODE_WSADuplicateSocketW] =
  97.       DTHandler_WSADuplicateSocketW;
  98.     HandlerFuncTable[DTCODE_WSAEnumNetworkEvents] =
  99.       DTHandler_WSAEnumNetworkEvents;
  100.     HandlerFuncTable[DTCODE_WSAEnumProtocolsA] = DTHandler_WSAEnumProtocolsA;
  101.     HandlerFuncTable[DTCODE_WSAEnumProtocolsW] = DTHandler_WSAEnumProtocolsW;
  102.     HandlerFuncTable[DTCODE_WSAEventSelect] = DTHandler_WSAEventSelect;
  103.     HandlerFuncTable[DTCODE_WSAGetLastError] = DTHandler_WSAGetLastError;
  104.     HandlerFuncTable[DTCODE_WSAGetOverlappedResult] =
  105.       DTHandler_WSAGetOverlappedResult;
  106.     HandlerFuncTable[DTCODE_WSAGetQOSByName] = DTHandler_WSAGetQOSByName;
  107.     HandlerFuncTable[DTCODE_WSAHtonl] = DTHandler_WSAHtonl;
  108.     HandlerFuncTable[DTCODE_WSAHtons] = DTHandler_WSAHtons;
  109.     HandlerFuncTable[DTCODE_WSAIoctl] = DTHandler_WSAIoctl;
  110.     HandlerFuncTable[DTCODE_WSAIsBlocking] = DTHandler_WSAIsBlocking;
  111.     HandlerFuncTable[DTCODE_WSAJoinLeaf] = DTHandler_WSAJoinLeaf;
  112.     HandlerFuncTable[DTCODE_WSANtohl] = DTHandler_WSANtohl;
  113.     HandlerFuncTable[DTCODE_WSANtohs] = DTHandler_WSANtohs;
  114.     HandlerFuncTable[DTCODE_WSARecv] = DTHandler_WSARecv;
  115.     HandlerFuncTable[DTCODE_WSARecvDisconnect] =
  116.       DTHandler_WSARecvDisconnect;
  117.     HandlerFuncTable[DTCODE_WSARecvFrom] = DTHandler_WSARecvFrom;
  118.     HandlerFuncTable[DTCODE_WSAResetEvent] = DTHandler_WSAResetEvent;
  119.     HandlerFuncTable[DTCODE_WSASend] = DTHandler_WSASend;
  120.     HandlerFuncTable[DTCODE_WSASendDisconnect] =
  121.       DTHandler_WSASendDisconnect;
  122.     HandlerFuncTable[DTCODE_WSASendTo] = DTHandler_WSASendTo;
  123.     HandlerFuncTable[DTCODE_WSASetBlockingHook] =
  124.       DTHandler_WSASetBlockingHook;
  125.     HandlerFuncTable[DTCODE_WSASetEvent] = DTHandler_WSASetEvent;
  126.     HandlerFuncTable[DTCODE_WSASetLastError] = DTHandler_WSASetLastError;
  127.     HandlerFuncTable[DTCODE_WSASocketA] = DTHandler_WSASocketA;
  128.     HandlerFuncTable[DTCODE_WSASocketW] = DTHandler_WSASocketW;
  129.     HandlerFuncTable[DTCODE_WSAStartup] = DTHandler_WSAStartup;
  130.     HandlerFuncTable[DTCODE_WSAUnhookBlockingHook] =
  131.       DTHandler_WSAUnhookBlockingHook;
  132.     HandlerFuncTable[DTCODE_WSAWaitForMultipleEvents] =
  133.       DTHandler_WSAWaitForMultipleEvents;
  134.     HandlerFuncTable[DTCODE_gethostbyaddr] = DTHandler_gethostbyaddr;
  135.     HandlerFuncTable[DTCODE_gethostbyname] = DTHandler_gethostbyname;
  136.     HandlerFuncTable[DTCODE_gethostname] = DTHandler_gethostname;
  137.     HandlerFuncTable[DTCODE_getprotobyname] = DTHandler_getprotobyname;
  138.     HandlerFuncTable[DTCODE_getprotobynumber] = DTHandler_getprotobynumber;
  139.     HandlerFuncTable[DTCODE_getservbyname] = DTHandler_getservbyname;
  140.     HandlerFuncTable[DTCODE_getservbyport] = DTHandler_getservbyport;
  141.     HandlerFuncTable[DTCODE_inet_addr] = DTHandler_inet_addr;
  142.     HandlerFuncTable[DTCODE_inet_ntoa] = DTHandler_inet_ntoa;
  143.     HandlerFuncTable[DTCODE_WSAAsyncGetHostByAddr] =
  144.       DTHandler_WSAAsyncGetHostByAddr;
  145.     HandlerFuncTable[DTCODE_WSAAsyncGetHostByName] =
  146.       DTHandler_WSAAsyncGetHostByName;
  147.     HandlerFuncTable[DTCODE_WSAAsyncGetProtoByName] =
  148.       DTHandler_WSAAsyncGetProtoByName;
  149.     HandlerFuncTable[DTCODE_WSAAsyncGetProtoByNumber] =
  150.       DTHandler_WSAAsyncGetProtoByNumber;
  151.     HandlerFuncTable[DTCODE_WSAAsyncGetServByName] =
  152.       DTHandler_WSAAsyncGetServByName;
  153.     HandlerFuncTable[DTCODE_WSAAsyncGetServByPort] =
  154.       DTHandler_WSAAsyncGetServByPort;
  155.     HandlerFuncTable[DTCODE_WSACancelAsyncRequest] =
  156.       DTHandler_WSACancelAsyncRequest;
  157.     HandlerFuncTable[DTCODE_WSPAccept] = DTHandler_WSPAccept;
  158.     HandlerFuncTable[DTCODE_WSPAsyncSelect] = DTHandler_WSPAsyncSelect;
  159.     HandlerFuncTable[DTCODE_WSPBind] = DTHandler_WSPBind;
  160.     HandlerFuncTable[DTCODE_WSPCancelBlockingCall] =
  161.       DTHandler_WSPCancelBlockingCall;
  162.     HandlerFuncTable[DTCODE_WSPCleanup] = DTHandler_WSPCleanup;
  163.     HandlerFuncTable[DTCODE_WSPCloseSocket] = DTHandler_WSPCloseSocket;
  164.     HandlerFuncTable[DTCODE_WSPConnect] = DTHandler_WSPConnect;
  165.     HandlerFuncTable[DTCODE_WSPDuplicateSocket] =
  166.       DTHandler_WSPDuplicateSocket;
  167.     HandlerFuncTable[DTCODE_WSPEnumNetworkEvents] =
  168.       DTHandler_WSPEnumNetworkEvents;
  169.     HandlerFuncTable[DTCODE_WSPEventSelect] = DTHandler_WSPEventSelect;
  170.     HandlerFuncTable[DTCODE_WSPGetOverlappedResult] =
  171.       DTHandler_WSPGetOverlappedResult;
  172.     HandlerFuncTable[DTCODE_WSPGetPeerName] = DTHandler_WSPGetPeerName;
  173.     HandlerFuncTable[DTCODE_WSPGetSockName] = DTHandler_WSPGetSockName;
  174.     HandlerFuncTable[DTCODE_WSPGetSockOpt] = DTHandler_WSPGetSockOpt;
  175.     HandlerFuncTable[DTCODE_WSPGetQOSByName] = DTHandler_WSPGetQOSByName;
  176.     HandlerFuncTable[DTCODE_WSPIoctl] = DTHandler_WSPIoctl;
  177.     HandlerFuncTable[DTCODE_WSPJoinLeaf] = DTHandler_WSPJoinLeaf;
  178.     HandlerFuncTable[DTCODE_WSPListen] = DTHandler_WSPListen;
  179.     HandlerFuncTable[DTCODE_WSPRecv] = DTHandler_WSPRecv;
  180.     HandlerFuncTable[DTCODE_WSPRecvDisconnect] =
  181.       DTHandler_WSPRecvDisconnect;
  182.     HandlerFuncTable[DTCODE_WSPRecvFrom] = DTHandler_WSPRecvFrom;
  183.     HandlerFuncTable[DTCODE_WSPSelect] = DTHandler_WSPSelect;
  184.     HandlerFuncTable[DTCODE_WSPSend] = DTHandler_WSPSend;
  185.     HandlerFuncTable[DTCODE_WSPSendDisconnect] =
  186.       DTHandler_WSPSendDisconnect;
  187.     HandlerFuncTable[DTCODE_WSPSendTo] = DTHandler_WSPSendTo;
  188.     HandlerFuncTable[DTCODE_WSPSetSockOpt] = DTHandler_WSPSetSockOpt;
  189.     HandlerFuncTable[DTCODE_WSPShutdown] = DTHandler_WSPShutdown;
  190.     HandlerFuncTable[DTCODE_WSPSocket] = DTHandler_WSPSocket;
  191.     HandlerFuncTable[DTCODE_WSPStartup] = DTHandler_WSPStartup;
  192.     HandlerFuncTable[DTCODE_WPUCloseEvent] = DTHandler_WPUCloseEvent;
  193.     HandlerFuncTable[DTCODE_WPUCloseSocketHandle] =
  194.       DTHandler_WPUCloseSocketHandle;
  195.     HandlerFuncTable[DTCODE_WPUCreateEvent] = DTHandler_WPUCreateEvent;
  196.     HandlerFuncTable[DTCODE_WPUCreateSocketHandle] =
  197.       DTHandler_WPUCreateSocketHandle;
  198.     HandlerFuncTable[DTCODE_WSCDeinstallProvider] =
  199.       DTHandler_WSCDeinstallProvider;
  200.     HandlerFuncTable[DTCODE_WSCInstallProvider] =
  201.       DTHandler_WSCInstallProvider;
  202.     HandlerFuncTable[DTCODE_WPUModifyIFSHandle] =
  203.       DTHandler_WPUModifyIFSHandle;
  204.     HandlerFuncTable[DTCODE_WPUQueryBlockingCallback] =
  205.       DTHandler_WPUQueryBlockingCallback;
  206.     HandlerFuncTable[DTCODE_WPUQuerySocketHandleContext] =
  207.       DTHandler_WPUQuerySocketHandleContext;
  208.     HandlerFuncTable[DTCODE_WPUQueueApc] = DTHandler_WPUQueueApc;
  209.     HandlerFuncTable[DTCODE_WPUResetEvent] = DTHandler_WPUResetEvent;
  210.     HandlerFuncTable[DTCODE_WPUSetEvent] = DTHandler_WPUSetEvent;
  211.     HandlerFuncTable[DTCODE_WSCEnumProtocols] = DTHandler_WSCEnumProtocols;
  212.     HandlerFuncTable[DTCODE_WPUGetProviderPath] = DTHandler_WPUGetProviderPath;
  213.     HandlerFuncTable[DTCODE_WPUPostMessage] = DTHandler_WPUPostMessage;
  214.     HandlerFuncTable[DTCODE_WPUFDIsSet] = DTHandler_WPUFDIsSet;
  215.     HandlerFuncTable[DTCODE___WSAFDIsSet] = DTHandler___WSAFDIsSet;
  216.     HandlerFuncTable[DTCODE_WSAAddressToStringA] =
  217.         DTHandler_WSAAddressToStringA;
  218.     HandlerFuncTable[DTCODE_WSAAddressToStringW] =
  219.         DTHandler_WSAAddressToStringW;
  220.     HandlerFuncTable[DTCODE_WSAStringToAddressA] =
  221.         DTHandler_WSAStringToAddressA;
  222.     HandlerFuncTable[DTCODE_WSAStringToAddressW] =
  223.         DTHandler_WSAStringToAddressW;
  224.     HandlerFuncTable[DTCODE_WSALookupServiceBeginA] =
  225.         DTHandler_WSALookupServiceBeginA;
  226.     HandlerFuncTable[DTCODE_WSALookupServiceBeginW] =
  227.         DTHandler_WSALookupServiceBeginW;
  228.     HandlerFuncTable[DTCODE_WSALookupServiceNextA] =
  229.         DTHandler_WSALookupServiceNextA;
  230.     HandlerFuncTable[DTCODE_WSALookupServiceNextW] =
  231.         DTHandler_WSALookupServiceNextW;
  232.     HandlerFuncTable[DTCODE_WSALookupServiceEnd] =
  233.         DTHandler_WSALookupServiceEnd;
  234.     HandlerFuncTable[DTCODE_WSAInstallServiceClassA] =
  235.         DTHandler_WSAInstallServiceClassA;
  236.     HandlerFuncTable[DTCODE_WSAInstallServiceClassW] =
  237.         DTHandler_WSAInstallServiceClassW;
  238.     HandlerFuncTable[DTCODE_WSASetServiceA] =
  239.         DTHandler_WSASetServiceA;
  240.     HandlerFuncTable[DTCODE_WSASetServiceW] =
  241.         DTHandler_WSASetServiceW;
  242.     HandlerFuncTable[DTCODE_WSARemoveServiceClass] =
  243.         DTHandler_WSARemoveServiceClass;
  244.     HandlerFuncTable[DTCODE_WSAGetServiceClassInfoA] =
  245.         DTHandler_WSAGetServiceClassInfoA;
  246.     HandlerFuncTable[DTCODE_WSAGetServiceClassInfoW] =
  247.         DTHandler_WSAGetServiceClassInfoW;
  248.     HandlerFuncTable[DTCODE_WSAEnumNameSpaceProvidersA] =
  249.         DTHandler_WSAEnumNameSpaceProvidersA;
  250.     HandlerFuncTable[DTCODE_WSAEnumNameSpaceProvidersW] =
  251.         DTHandler_WSAEnumNameSpaceProvidersW;
  252.     HandlerFuncTable[DTCODE_WSAGetServiceClassNameByClassIdA] =
  253.         DTHandler_WSAGetServiceClassNameByClassIdA;
  254.     HandlerFuncTable[DTCODE_WSAGetServiceClassNameByClassIdW] =
  255.         DTHandler_WSAGetServiceClassNameByClassIdW;
  256.     HandlerFuncTable[DTCODE_NSPLookupServiceBegin] =
  257.         DTHandler_NSPLookupServiceBegin;
  258.     HandlerFuncTable[DTCODE_NSPLookupServiceNext] =
  259.         DTHandler_NSPLookupServiceNext;
  260.     HandlerFuncTable[DTCODE_NSPLookupServiceEnd] =
  261.         DTHandler_NSPLookupServiceEnd;
  262.     HandlerFuncTable[DTCODE_NSPInstallServiceClass] =
  263.         DTHandler_NSPInstallServiceClass;
  264.     HandlerFuncTable[DTCODE_NSPSetService] =
  265.         DTHandler_NSPSetService;
  266.     HandlerFuncTable[DTCODE_NSPRemoveServiceClass] =
  267.         DTHandler_NSPRemoveServiceClass;
  268.     HandlerFuncTable[DTCODE_NSPGetServiceClassInfo] =
  269.         DTHandler_NSPGetServiceClassInfo;
  270.  
  271.     return(TRUE);
  272. }
  273.  
  274. /*++
  275.  
  276.   Note:
  277.  
  278.       This comment applies to all DTHandler_xxxx functions.
  279.  
  280.   Function Description:
  281.  
  282.       For the present, each handler function simply adds "xxxx
  283.       called." to the end of the string passed in, and calls
  284.       DTTextOut to output the whole string to the Debug Window.  This
  285.       allows handler functions to be disabled easily, or to output
  286.       more information (like the arguments) via multiple calls to
  287.       DTTextOut, etc.  See the Debug/Trace documentation for more
  288.       information.
  289.  
  290.   Arguments:
  291.  
  292.       vl -- Variable used to strip arguments off the stack of
  293.       WSA[Pre|Post]ApiNotify, the calling function.
  294.  
  295.       ReturnValue -- A void pointer to the return value for the
  296.       original API/SPI function.  Use a local variable to cast it to
  297.       the appropriate type.
  298.  
  299.       LibraryName -- For API functions, this should just be
  300.       "WinSock2", but for SPI functions it is the name of the service
  301.       provider.  This is to distinguish among the multiple service
  302.       providers that WinSock2 may be calling.
  303.  
  304.       Buffer -- A string containg some info about the thread and
  305.       function call # of this call.
  306.  
  307.       Index -- How many characters are in the above.
  308.  
  309.       BufLen -- How big is the buffer.
  310.  
  311.       PreOrPost -- TRUE if called by a WSAPreApiNotify, FALSE if
  312.       called by WSAPostApiNotify.
  313.  
  314.   Return Value:
  315.  
  316.       If the PreOrPost argument is FALSE, then the return value is
  317.       ignored.  If it's TRUE, then the return value indicates to
  318.       WSAPreApiNotify whether or not we want to short-circuit the API
  319.       or SPI function.  TRUE means short-circuit it, FALSE mean don't.
  320.  
  321. --*/
  322.  
  323.  
  324. BOOL CALLBACK
  325. DTHandler_accept(
  326.     IN     va_list vl,
  327.     IN OUT LPVOID  ReturnValue,
  328.     IN     LPSTR   LibraryName,
  329.     OUT    char    *Buffer,
  330.     IN     int     Index,
  331.     IN     int     BufLen,
  332.     IN     BOOL    PreOrPost)
  333. {
  334.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  335.     SOCKET *s = va_arg(vl, SOCKET *);
  336.     struct sockaddr FAR **addr = va_arg(vl, struct sockaddr FAR **);
  337.     int FAR **addrlen = va_arg(vl, int FAR **);
  338.  
  339.     wsprintf(Buffer + Index, "accept() %s.\r\n",
  340.              PreOrPost ? "called" : "returned");
  341.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  342.     return(FALSE);
  343. }
  344.  
  345.  
  346. BOOL CALLBACK
  347. DTHandler_bind(
  348.     IN     va_list vl,
  349.     IN OUT LPVOID  ReturnValue,
  350.     IN     LPSTR   LibraryName,
  351.     OUT    char    *Buffer,
  352.     IN     int     Index,
  353.     IN     int     BufLen,
  354.     IN     BOOL    PreOrPost)
  355. {
  356.     int *RetVal = (int *)ReturnValue;
  357.     SOCKET *s = va_arg(vl, SOCKET *);
  358.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  359.     int *namelen = va_arg(vl, int *);
  360.  
  361.     wsprintf(Buffer + Index, "bind() %s.\r\n",
  362.              PreOrPost ? "called" : "returned");
  363.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  364.     return(FALSE);
  365. }
  366.  
  367.  
  368. BOOL CALLBACK
  369. DTHandler_closesocket(
  370.     IN     va_list vl,
  371.     IN OUT LPVOID  ReturnValue,
  372.     IN     LPSTR   LibraryName,
  373.     OUT    char    *Buffer,
  374.     IN     int     Index,
  375.     IN     int     BufLen,
  376.     IN     BOOL    PreOrPost)
  377. {
  378.     int *RetVal = (int *)ReturnValue;
  379.     SOCKET *s = va_arg(vl, SOCKET *);
  380.  
  381.     wsprintf(Buffer + Index, "closesocket() %s.\r\n",
  382.              PreOrPost ? "called" : "returned");
  383.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  384.     return(FALSE);
  385. }
  386.  
  387.  
  388. BOOL CALLBACK
  389. DTHandler_connect(
  390.     IN     va_list vl,
  391.     IN OUT LPVOID  ReturnValue,
  392.     IN     LPSTR   LibraryName,
  393.     OUT    char    *Buffer,
  394.     IN     int     Index,
  395.     IN     int     BufLen,
  396.     IN     BOOL    PreOrPost)
  397. {
  398.     int *RetVal = (int *)ReturnValue;
  399.     SOCKET *s = va_arg(vl, SOCKET *);
  400.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  401.     int *namelen = va_arg(vl, int *);
  402.  
  403.     wsprintf(Buffer + Index, "connect() %s.\r\n",
  404.              PreOrPost ? "called" : "returned");
  405.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  406.     return(FALSE);
  407. }
  408.  
  409.  
  410. BOOL CALLBACK
  411. DTHandler_getpeername(
  412.     IN     va_list vl,
  413.     IN OUT LPVOID  ReturnValue,
  414.     IN     LPSTR   LibraryName,
  415.     OUT    char    *Buffer,
  416.     IN     int     Index,
  417.     IN     int     BufLen,
  418.     IN     BOOL    PreOrPost)
  419. {
  420.     int *RetVal = (int *)ReturnValue;
  421.     SOCKET *s = va_arg(vl, SOCKET *);
  422.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  423.     int FAR **namelen = va_arg(vl, int FAR **);
  424.  
  425.     wsprintf(Buffer + Index, "getpeername() %s.\r\n",
  426.              PreOrPost ? "called" : "returned");
  427.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  428.     return(FALSE);
  429. }
  430.  
  431.  
  432. BOOL CALLBACK
  433. DTHandler_getsockname(
  434.     IN     va_list vl,
  435.     IN OUT LPVOID  ReturnValue,
  436.     IN     LPSTR   LibraryName,
  437.     OUT    char    *Buffer,
  438.     IN     int     Index,
  439.     IN     int     BufLen,
  440.     IN     BOOL    PreOrPost)
  441. {
  442.     int *RetVal = (int *)ReturnValue;
  443.     SOCKET *s = va_arg(vl, SOCKET *);
  444.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  445.     int FAR **namelen = va_arg(vl, int FAR **);
  446.  
  447.     wsprintf(Buffer + Index, "getsockname() %s.\r\n",
  448.              PreOrPost ? "called" : "returned");
  449.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  450.     return(FALSE);
  451. }
  452.  
  453.  
  454. BOOL CALLBACK
  455. DTHandler_getsockopt(
  456.     IN     va_list vl,
  457.     IN OUT LPVOID  ReturnValue,
  458.     IN     LPSTR   LibraryName,
  459.     OUT    char    *Buffer,
  460.     IN     int     Index,
  461.     IN     int     BufLen,
  462.     IN     BOOL    PreOrPost)
  463. {
  464.     int *RetVal = (int *)ReturnValue;
  465.     SOCKET *s = va_arg(vl, SOCKET *);
  466.     int *level = va_arg(vl, int *);
  467.     int *optname = va_arg(vl, int *);
  468.     char FAR **optval = va_arg(vl, char FAR **);
  469.     int FAR **optlen = va_arg(vl, int FAR **);
  470.  
  471.     wsprintf(Buffer + Index, "getsockopt() %s.\r\n",
  472.              PreOrPost ? "called" : "returned");
  473.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  474.     return(FALSE);
  475. }
  476.  
  477.  
  478. BOOL CALLBACK
  479. DTHandler_htonl(
  480.     IN     va_list vl,
  481.     IN OUT LPVOID  ReturnValue,
  482.     IN     LPSTR   LibraryName,
  483.     OUT    char    *Buffer,
  484.     IN     int     Index,
  485.     IN     int     BufLen,
  486.     IN     BOOL    PreOrPost)
  487. {
  488.     u_long *RetVal = (u_long *)ReturnValue;
  489.     u_long *hostlong = va_arg(vl, u_long *);
  490.  
  491.     wsprintf(Buffer + Index, "htonl() %s.\r\n",
  492.              PreOrPost ? "called" : "returned");
  493.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  494.     return(FALSE);
  495. }
  496.  
  497.  
  498. BOOL CALLBACK
  499. DTHandler_htons(
  500.     IN     va_list vl,
  501.     IN OUT LPVOID  ReturnValue,
  502.     IN     LPSTR   LibraryName,
  503.     OUT    char    *Buffer,
  504.     IN     int     Index,
  505.     IN     int     BufLen,
  506.     IN     BOOL    PreOrPost)
  507. {
  508.     u_short *RetVal = (u_short *)ReturnValue;
  509.     u_short *hostshort = va_arg(vl, u_short *);
  510.  
  511.     wsprintf(Buffer + Index, "htons() %s.\r\n",
  512.              PreOrPost ? "called" : "returned");
  513.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  514.     return(FALSE);
  515. }
  516.  
  517.  
  518. BOOL CALLBACK
  519. DTHandler_ioctlsocket(
  520.     IN     va_list vl,
  521.     IN OUT LPVOID  ReturnValue,
  522.     IN     LPSTR   LibraryName,
  523.     OUT    char    *Buffer,
  524.     IN     int     Index,
  525.     IN     int     BufLen,
  526.     IN     BOOL    PreOrPost)
  527. {
  528.     int *RetVal = (int *)ReturnValue;
  529.     SOCKET *s = va_arg(vl, SOCKET *);
  530.     long *cmd = va_arg(vl, long *);
  531.     u_long FAR **argp = va_arg(vl, u_long FAR **);
  532.  
  533.     wsprintf(Buffer + Index, "ioctlsocket() %s.\r\n",
  534.              PreOrPost ? "called" : "returned");
  535.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  536.     return(FALSE);
  537. }
  538.  
  539.  
  540. BOOL CALLBACK
  541. DTHandler_listen(
  542.     IN     va_list vl,
  543.     IN OUT LPVOID  ReturnValue,
  544.     IN     LPSTR   LibraryName,
  545.     OUT    char    *Buffer,
  546.     IN     int     Index,
  547.     IN     int     BufLen,
  548.     IN     BOOL    PreOrPost)
  549. {
  550.     int *RetVal = (int *)ReturnValue;
  551.     SOCKET *s = va_arg(vl, SOCKET *);
  552.     int *backlog = va_arg(vl, int *);
  553.  
  554.     wsprintf(Buffer + Index, "listen() %s.\r\n",
  555.              PreOrPost ? "called" : "returned");
  556.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  557.     return(FALSE);
  558. }
  559.  
  560.  
  561. BOOL CALLBACK
  562. DTHandler_ntohl(
  563.     IN     va_list vl,
  564.     IN OUT LPVOID  ReturnValue,
  565.     IN     LPSTR   LibraryName,
  566.     OUT    char    *Buffer,
  567.     IN     int     Index,
  568.     IN     int     BufLen,
  569.     IN     BOOL    PreOrPost)
  570. {
  571.     u_long *RetVal = (u_long *)ReturnValue;
  572.     u_long *netlong = va_arg(vl, u_long *);
  573.  
  574.     wsprintf(Buffer + Index, "ntohl() %s.\r\n",
  575.              PreOrPost ? "called" : "returned");
  576.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  577.     return(FALSE);
  578. }
  579.  
  580.  
  581. BOOL CALLBACK
  582. DTHandler_ntohs(
  583.     IN     va_list vl,
  584.     IN OUT LPVOID  ReturnValue,
  585.     IN     LPSTR   LibraryName,
  586.     OUT    char    *Buffer,
  587.     IN     int     Index,
  588.     IN     int     BufLen,
  589.     IN     BOOL    PreOrPost)
  590. {
  591.     u_short *RetVal = (u_short *)ReturnValue;
  592.     u_short *netshort = va_arg(vl, u_short *);
  593.  
  594.     wsprintf(Buffer + Index, "ntohs() %s.\r\n",
  595.              PreOrPost ? "called" : "returned");
  596.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  597.     return(FALSE);
  598. }
  599.  
  600.  
  601. BOOL CALLBACK
  602. DTHandler_recv(
  603.     IN     va_list vl,
  604.     IN OUT LPVOID  ReturnValue,
  605.     IN     LPSTR   LibraryName,
  606.     OUT    char    *Buffer,
  607.     IN     int     Index,
  608.     IN     int     BufLen,
  609.     IN     BOOL    PreOrPost)
  610. {
  611.     int *RetVal = (int *)ReturnValue;
  612.     SOCKET *s = va_arg(vl, SOCKET *);
  613.     char FAR **buf = va_arg(vl, char FAR **);
  614.     int *len = va_arg(vl, int *);
  615.     int *flags = va_arg(vl, int *);
  616.  
  617.     wsprintf(Buffer + Index, "recv() %s.\r\n",
  618.              PreOrPost ? "called" : "returned");
  619.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  620.     return(FALSE);
  621. }
  622.  
  623.  
  624. BOOL CALLBACK
  625. DTHandler_recvfrom(
  626.     IN     va_list vl,
  627.     IN OUT LPVOID  ReturnValue,
  628.     IN     LPSTR   LibraryName,
  629.     OUT    char    *Buffer,
  630.     IN     int     Index,
  631.     IN     int     BufLen,
  632.     IN     BOOL    PreOrPost)
  633. {
  634.     int *RetVal = (int *)ReturnValue;
  635.     SOCKET *s = va_arg(vl, SOCKET *);
  636.     char FAR **buf = va_arg(vl, char FAR **);
  637.     int *len = va_arg(vl, int *);
  638.     int *flags = va_arg(vl, int *);
  639.     struct sockaddr FAR **from = va_arg(vl, struct sockaddr FAR **);
  640.     int FAR **fromlen = va_arg(vl, int FAR **);
  641.  
  642.     wsprintf(Buffer + Index, "recvfrom() %s.\r\n",
  643.              PreOrPost ? "called" : "returned");
  644.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  645.     return(FALSE);
  646. }
  647.  
  648.  
  649. BOOL CALLBACK
  650. DTHandler_select(
  651.     IN     va_list vl,
  652.     IN OUT LPVOID  ReturnValue,
  653.     IN     LPSTR   LibraryName,
  654.     OUT    char    *Buffer,
  655.     IN     int     Index,
  656.     IN     int     BufLen,
  657.     IN     BOOL    PreOrPost)
  658. {
  659.     int *RetVal = (int *)ReturnValue;
  660.     int *nfds = va_arg(vl, int *);
  661.     fd_set FAR **readfds = va_arg(vl, fd_set FAR **);
  662.     fd_set FAR **writefds = va_arg(vl, fd_set FAR **);
  663.     fd_set FAR **exceptfds = va_arg(vl, fd_set FAR **);
  664.     struct timeval FAR **timeout = va_arg(vl, struct timeval FAR **);
  665.  
  666.     wsprintf(Buffer + Index, "select() %s.\r\n",
  667.              PreOrPost ? "called" : "returned");
  668.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  669.     return(FALSE);
  670. }
  671.  
  672.  
  673. BOOL CALLBACK
  674. DTHandler_send(
  675.     IN     va_list vl,
  676.     IN OUT LPVOID  ReturnValue,
  677.     IN     LPSTR   LibraryName,
  678.     OUT    char    *Buffer,
  679.     IN     int     Index,
  680.     IN     int     BufLen,
  681.     IN     BOOL    PreOrPost)
  682. {
  683.     int *RetVal = (int *)ReturnValue;
  684.     SOCKET *s = va_arg(vl, SOCKET *);
  685.     char FAR **buf = va_arg(vl, char FAR **);
  686.     int *len = va_arg(vl, int *);
  687.     int *flags = va_arg(vl, int *);
  688.  
  689.     wsprintf(Buffer + Index, "send() %s.\r\n",
  690.              PreOrPost ? "called" : "returned");
  691.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  692.     return(FALSE);
  693. }
  694.  
  695.  
  696. BOOL CALLBACK
  697. DTHandler_sendto(
  698.     IN     va_list vl,
  699.     IN OUT LPVOID  ReturnValue,
  700.     IN     LPSTR   LibraryName,
  701.     OUT    char    *Buffer,
  702.     IN     int     Index,
  703.     IN     int     BufLen,
  704.     IN     BOOL    PreOrPost)
  705. {
  706.     int *RetVal = (int *)ReturnValue;
  707.     SOCKET *s = va_arg(vl, SOCKET *);
  708.     char FAR **buf = va_arg(vl, char FAR **);
  709.     int *len = va_arg(vl, int *);
  710.     int *flags = va_arg(vl, int *);
  711.     struct sockaddr FAR **to = va_arg(vl, struct sockaddr FAR **);
  712.     int *tolen = va_arg(vl, int *);
  713.  
  714.     wsprintf(Buffer + Index, "sendto() %s.\r\n",
  715.              PreOrPost ? "called" : "returned");
  716.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  717.     return(FALSE);
  718. }
  719.  
  720.  
  721. BOOL CALLBACK
  722. DTHandler_setsockopt(
  723.     IN     va_list vl,
  724.     IN OUT LPVOID  ReturnValue,
  725.     IN     LPSTR   LibraryName,
  726.     OUT    char    *Buffer,
  727.     IN     int     Index,
  728.     IN     int     BufLen,
  729.     IN     BOOL    PreOrPost)
  730. {
  731.     int *RetVal = (int *)ReturnValue;
  732.     SOCKET *s = va_arg(vl, SOCKET *);
  733.     int *level = va_arg(vl, int *);
  734.     int *optname = va_arg(vl, int *);
  735.     char FAR **optval = va_arg(vl, char FAR **);
  736.     int *optlen = va_arg(vl, int *);
  737.  
  738.     wsprintf(Buffer + Index, "setsockopt() %s.\r\n",
  739.              PreOrPost ? "called" : "returned");
  740.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  741.     return(FALSE);
  742. }
  743.  
  744.  
  745. BOOL CALLBACK
  746. DTHandler_shutdown(
  747.     IN     va_list vl,
  748.     IN OUT LPVOID  ReturnValue,
  749.     IN     LPSTR   LibraryName,
  750.     OUT    char    *Buffer,
  751.     IN     int     Index,
  752.     IN     int     BufLen,
  753.     IN     BOOL    PreOrPost)
  754. {
  755.     int *RetVal = (int *)ReturnValue;
  756.     SOCKET *s = va_arg(vl, SOCKET *);
  757.     int *how = va_arg(vl, int *);
  758.  
  759.     wsprintf(Buffer + Index, "shutdown() %s.\r\n",
  760.              PreOrPost ? "called" : "returned");
  761.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  762.     return(FALSE);
  763. }
  764.  
  765.  
  766. BOOL CALLBACK
  767. DTHandler_socket(
  768.     IN     va_list vl,
  769.     IN OUT LPVOID  ReturnValue,
  770.     IN     LPSTR   LibraryName,
  771.     OUT    char    *Buffer,
  772.     IN     int     Index,
  773.     IN     int     BufLen,
  774.     IN     BOOL    PreOrPost)
  775. {
  776.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  777.     int *af = va_arg(vl, int *);
  778.     int *type = va_arg(vl, int *);
  779.     int *protocol = va_arg(vl, int *);
  780.  
  781.     wsprintf(Buffer + Index, "socket() %s.\r\n",
  782.              PreOrPost ? "called" : "returned");
  783.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  784.     return(FALSE);
  785. }
  786.  
  787.  
  788. BOOL CALLBACK
  789. DTHandler_WSAAccept(
  790.     IN     va_list vl,
  791.     IN OUT LPVOID  ReturnValue,
  792.     IN     LPSTR   LibraryName,
  793.     OUT    char    *Buffer,
  794.     IN     int     Index,
  795.     IN     int     BufLen,
  796.     IN     BOOL    PreOrPost)
  797. {
  798.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  799.     SOCKET *s = va_arg(vl, SOCKET *);
  800.     struct sockaddr FAR **addr = va_arg(vl, struct sockaddr FAR **);
  801.     LPINT *addrlen = va_arg(vl, LPINT *);
  802.     LPCONDITIONPROC *lpfnCondition = va_arg(vl, LPCONDITIONPROC *);
  803.     DWORD *dwCallbackData = va_arg(vl, DWORD *);
  804.  
  805.     wsprintf(Buffer + Index, "WSAAccept() %s.\r\n",
  806.              PreOrPost ? "called" : "returned");
  807.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  808.     return(FALSE);
  809. }
  810.  
  811.  
  812. BOOL CALLBACK
  813. DTHandler_WSAAsyncSelect(
  814.     IN     va_list vl,
  815.     IN OUT LPVOID  ReturnValue,
  816.     IN     LPSTR   LibraryName,
  817.     OUT    char    *Buffer,
  818.     IN     int     Index,
  819.     IN     int     BufLen,
  820.     IN     BOOL    PreOrPost)
  821. {
  822.     int *RetVal = (int *)ReturnValue;
  823.     SOCKET *s = va_arg(vl, SOCKET *);
  824.     HWND *hWnd = va_arg(vl, HWND *);
  825.     u_int *wMsg = va_arg(vl, u_int *);
  826.     long *lEvent = va_arg(vl, long *);
  827.  
  828.     wsprintf(Buffer + Index, "WSAAsyncSelect() %s.\r\n",
  829.              PreOrPost ? "called" : "returned");
  830.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  831.     return(FALSE);
  832. }
  833.  
  834.  
  835. BOOL CALLBACK
  836. DTHandler_WSACancelBlockingCall(
  837.     IN     va_list vl,
  838.     IN OUT LPVOID  ReturnValue,
  839.     IN     LPSTR   LibraryName,
  840.     OUT    char    *Buffer,
  841.     IN     int     Index,
  842.     IN     int     BufLen,
  843.     IN     BOOL    PreOrPost)
  844. {
  845.     int *RetVal = (int *)ReturnValue;
  846.  
  847.     wsprintf(Buffer + Index, "WSACancelBlockingCall() %s.\r\n",
  848.              PreOrPost ? "called" : "returned");
  849.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  850.     return(FALSE);
  851. }
  852.  
  853.  
  854. BOOL CALLBACK
  855. DTHandler_WSACleanup(
  856.     IN     va_list vl,
  857.     IN OUT LPVOID  ReturnValue,
  858.     IN     LPSTR   LibraryName,
  859.     OUT    char    *Buffer,
  860.     IN     int     Index,
  861.     IN     int     BufLen,
  862.     IN     BOOL    PreOrPost)
  863. {
  864.     int *RetVal = (int *)ReturnValue;
  865.  
  866.     wsprintf(Buffer + Index, "WSACleanup() %s.\r\n",
  867.              PreOrPost ? "called" : "returned");
  868.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  869.     return(FALSE);
  870. }
  871.  
  872.  
  873. BOOL CALLBACK
  874. DTHandler_WSACloseEvent(
  875.     IN     va_list vl,
  876.     IN OUT LPVOID  ReturnValue,
  877.     IN     LPSTR   LibraryName,
  878.     OUT    char    *Buffer,
  879.     IN     int     Index,
  880.     IN     int     BufLen,
  881.     IN     BOOL    PreOrPost)
  882. {
  883.     BOOL *RetVal = (BOOL *)ReturnValue;
  884.     WSAEVENT *hEvent = va_arg(vl, WSAEVENT *);
  885.  
  886.     wsprintf(Buffer + Index, "WSACloseEvent() %s.\r\n",
  887.              PreOrPost ? "called" : "returned");
  888.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  889.     return(FALSE);
  890. }
  891.  
  892.  
  893. BOOL CALLBACK
  894. DTHandler_WSAConnect(
  895.     IN     va_list vl,
  896.     IN OUT LPVOID  ReturnValue,
  897.     IN     LPSTR   LibraryName,
  898.     OUT    char    *Buffer,
  899.     IN     int     Index,
  900.     IN     int     BufLen,
  901.     IN     BOOL    PreOrPost)
  902. {
  903.     int *RetVal = (int *)ReturnValue;
  904.     SOCKET *s = va_arg(vl, SOCKET *);
  905.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  906.     int *namelen = va_arg(vl, int *);
  907.     LPWSABUF *lpCallerData = va_arg(vl, LPWSABUF *);
  908.     LPWSABUF *lpCalleeData = va_arg(vl, LPWSABUF *);
  909.     LPQOS *lpSQOS = va_arg(vl, LPQOS *);
  910.     LPQOS *lpGQOS = va_arg(vl, LPQOS *);
  911.  
  912.     wsprintf(Buffer + Index, "WSAConnect() %s.\r\n",
  913.              PreOrPost ? "called" : "returned");
  914.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  915.     return(FALSE);
  916. }
  917.  
  918.  
  919. BOOL CALLBACK
  920. DTHandler_WSACreateEvent(
  921.     IN     va_list vl,
  922.     IN OUT LPVOID  ReturnValue,
  923.     IN     LPSTR   LibraryName,
  924.     OUT    char    *Buffer,
  925.     IN     int     Index,
  926.     IN     int     BufLen,
  927.     IN     BOOL    PreOrPost)
  928. {
  929.     WSAEVENT *RetVal = (WSAEVENT *)ReturnValue;
  930.  
  931.     wsprintf(Buffer + Index, "WSACreateEvent() %s.\r\n",
  932.              PreOrPost ? "called" : "returned");
  933.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  934.     return(FALSE);
  935. }
  936.  
  937.  
  938. BOOL CALLBACK
  939. DTHandler_WSADuplicateSocketA(
  940.     IN     va_list vl,
  941.     IN OUT LPVOID  ReturnValue,
  942.     IN     LPSTR   LibraryName,
  943.     OUT    char    *Buffer,
  944.     IN     int     Index,
  945.     IN     int     BufLen,
  946.     IN     BOOL    PreOrPost)
  947. {
  948.     int *RetVal = (int *)ReturnValue;
  949.     SOCKET *s = va_arg(vl, SOCKET *);
  950.     DWORD *dwProcessId = va_arg(vl, DWORD *);
  951.     LPWSAPROTOCOL_INFOA *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFOA *);
  952.  
  953.     wsprintf(Buffer + Index, "WSADuplicateSocketA() %s.\r\n",
  954.              PreOrPost ? "called" : "returned");
  955.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  956.     return(FALSE);
  957. }
  958.  
  959.  
  960. BOOL CALLBACK
  961. DTHandler_WSADuplicateSocketW(
  962.     IN     va_list vl,
  963.     IN OUT LPVOID  ReturnValue,
  964.     IN     LPSTR   LibraryName,
  965.     OUT    char    *Buffer,
  966.     IN     int     Index,
  967.     IN     int     BufLen,
  968.     IN     BOOL    PreOrPost)
  969. {
  970.     int *RetVal = (int *)ReturnValue;
  971.     SOCKET *s = va_arg(vl, SOCKET *);
  972.     DWORD *dwProcessId = va_arg(vl, DWORD *);
  973.     LPWSAPROTOCOL_INFOW *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFOW *);
  974.  
  975.     wsprintf(Buffer + Index, "WSADuplicateSocketW() %s.\r\n",
  976.              PreOrPost ? "called" : "returned");
  977.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  978.     return(FALSE);
  979. }
  980.  
  981.  
  982. BOOL CALLBACK
  983. DTHandler_WSAEnumNetworkEvents(
  984.     IN     va_list vl,
  985.     IN OUT LPVOID  ReturnValue,
  986.     IN     LPSTR   LibraryName,
  987.     OUT    char    *Buffer,
  988.     IN     int     Index,
  989.     IN     int     BufLen,
  990.     IN     BOOL    PreOrPost)
  991. {
  992.     int *RetVal = (int *)ReturnValue;
  993.     SOCKET *s = va_arg(vl, SOCKET *);
  994.     WSAEVENT *hEventObject = va_arg(vl, WSAEVENT *);
  995.     LPWSANETWORKEVENTS *lpNetworkEvents = va_arg(vl, LPWSANETWORKEVENTS *);
  996.  
  997.     wsprintf(Buffer + Index, "WSAEnumNetworkEvents() %s.\r\n",
  998.              PreOrPost ? "called" : "returned");
  999.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1000.     return(FALSE);
  1001. }
  1002.  
  1003.  
  1004. BOOL CALLBACK
  1005. DTHandler_WSAEnumProtocolsA(
  1006.     IN     va_list vl,
  1007.     IN OUT LPVOID  ReturnValue,
  1008.     IN     LPSTR   LibraryName,
  1009.     OUT    char    *Buffer,
  1010.     IN     int     Index,
  1011.     IN     int     BufLen,
  1012.     IN     BOOL    PreOrPost)
  1013. {
  1014.     int *RetVal = (int *)ReturnValue;
  1015.     LPINT *lpiProtocols = va_arg(vl, LPINT *);
  1016.     LPWSAPROTOCOL_INFOA *lpProtocolBuffer = va_arg(vl, LPWSAPROTOCOL_INFOA *);
  1017.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD *);
  1018.  
  1019.     wsprintf(Buffer + Index, "WSAEnumProtocolsA() %s.\r\n",
  1020.              PreOrPost ? "called" : "returned");
  1021.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1022.     return(FALSE);
  1023. }
  1024.  
  1025.  
  1026. BOOL CALLBACK
  1027. DTHandler_WSAEnumProtocolsW(
  1028.     IN     va_list vl,
  1029.     IN OUT LPVOID  ReturnValue,
  1030.     IN     LPSTR   LibraryName,
  1031.     OUT    char    *Buffer,
  1032.     IN     int     Index,
  1033.     IN     int     BufLen,
  1034.     IN     BOOL    PreOrPost)
  1035. {
  1036.     int *RetVal = (int *)ReturnValue;
  1037.     LPINT *lpiProtocols = va_arg(vl, LPINT *);
  1038.     LPWSAPROTOCOL_INFOW *lpProtocolBuffer = va_arg(vl, LPWSAPROTOCOL_INFOW *);
  1039.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD *);
  1040.  
  1041.     wsprintf(Buffer + Index, "WSAEnumProtocolsW() %s.\r\n",
  1042.              PreOrPost ? "called" : "returned");
  1043.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1044.     return(FALSE);
  1045. }
  1046.  
  1047.  
  1048. BOOL CALLBACK
  1049. DTHandler_WSAEventSelect(
  1050.     IN     va_list vl,
  1051.     IN OUT LPVOID  ReturnValue,
  1052.     IN     LPSTR   LibraryName,
  1053.     OUT    char    *Buffer,
  1054.     IN     int     Index,
  1055.     IN     int     BufLen,
  1056.     IN     BOOL    PreOrPost)
  1057. {
  1058.     int *RetVal = (int *)ReturnValue;
  1059.     SOCKET *s = va_arg(vl, SOCKET *);
  1060.     WSAEVENT *hEventObject = va_arg(vl, WSAEVENT *);
  1061.     long *lNetworkEvents = va_arg(vl, long *);
  1062.  
  1063.     wsprintf(Buffer + Index, "WSAEventSelect() %s.\r\n",
  1064.          PreOrPost ? "called" : "returned");
  1065.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1066.     return(FALSE);
  1067. }
  1068.  
  1069.  
  1070. BOOL CALLBACK
  1071. DTHandler_WSAGetLastError(
  1072.     IN     va_list vl,
  1073.     IN OUT LPVOID  ReturnValue,
  1074.     IN     LPSTR   LibraryName,
  1075.     OUT    char    *Buffer,
  1076.     IN     int     Index,
  1077.     IN     int     BufLen,
  1078.     IN     BOOL    PreOrPost)
  1079. {
  1080.     int *RetVal = (int *)ReturnValue;
  1081.  
  1082.     wsprintf(Buffer + Index, "WSAGetLastError() %s.\r\n",
  1083.          PreOrPost ? "called" : "returned");
  1084.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1085.     return(FALSE);
  1086. }
  1087.  
  1088.  
  1089. BOOL CALLBACK
  1090. DTHandler_WSAGetOverlappedResult(
  1091.     IN     va_list vl,
  1092.     IN OUT LPVOID  ReturnValue,
  1093.     IN     LPSTR   LibraryName,
  1094.     OUT    char    *Buffer,
  1095.     IN     int     Index,
  1096.     IN     int     BufLen,
  1097.     IN     BOOL    PreOrPost)
  1098. {
  1099.     BOOL *RetVal = (BOOL *)ReturnValue;
  1100.     SOCKET *s = va_arg(vl, SOCKET *);
  1101.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  1102.     LPDWORD *lpcbTransfer = va_arg(vl, LPDWORD *);
  1103.     BOOL *fWait = va_arg(vl, BOOL *);
  1104.     LPDWORD *lpdwFlags = va_arg(vl, LPDWORD *);
  1105.  
  1106.     wsprintf(Buffer + Index, "WSAGetOverlappedResult() %s.\r\n",
  1107.              PreOrPost ? "called" : "returned");
  1108.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1109.     return(FALSE);
  1110. }
  1111.  
  1112.  
  1113. BOOL CALLBACK
  1114. DTHandler_WSAGetQOSByName(
  1115.     IN     va_list vl,
  1116.     IN OUT LPVOID  ReturnValue,
  1117.     IN     LPSTR   LibraryName,
  1118.     OUT    char    *Buffer,
  1119.     IN     int     Index,
  1120.     IN     int     BufLen,
  1121.     IN     BOOL    PreOrPost)
  1122. {
  1123.     BOOL *RetVal = (BOOL *)ReturnValue;
  1124.     SOCKET *s = va_arg(vl, SOCKET *);
  1125.     LPWSABUF *lpQOSName = va_arg(vl, LPWSABUF *);
  1126.     LPQOS *lpQOS = va_arg(vl, LPQOS *);
  1127.  
  1128.     wsprintf(Buffer + Index, "WSAGetQOSByName() %s.\r\n",
  1129.              PreOrPost ? "called" : "returned");
  1130.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1131.     return(FALSE);
  1132. }
  1133.  
  1134.  
  1135. BOOL CALLBACK
  1136. DTHandler_WSAHtonl(
  1137.     IN     va_list vl,
  1138.     IN OUT LPVOID  ReturnValue,
  1139.     IN     LPSTR   LibraryName,
  1140.     OUT    char    *Buffer,
  1141.     IN     int     Index,
  1142.     IN     int     BufLen,
  1143.     IN     BOOL    PreOrPost)
  1144. {
  1145.     int *RetVal = (int *)ReturnValue;
  1146.     SOCKET *s = va_arg(vl, SOCKET *);
  1147.     u_long *hostlong = va_arg(vl, u_long *);
  1148.     u_long FAR **lpnetlong = va_arg(vl, u_long FAR **);
  1149.  
  1150.     wsprintf(Buffer + Index, "WSAHtonl() %s.\r\n",
  1151.              PreOrPost ? "called" : "returned");
  1152.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1153.     return(FALSE);
  1154. }
  1155.  
  1156.  
  1157. BOOL CALLBACK
  1158. DTHandler_WSAHtons(
  1159.     IN     va_list vl,
  1160.     IN OUT LPVOID  ReturnValue,
  1161.     IN     LPSTR   LibraryName,
  1162.     OUT    char    *Buffer,
  1163.     IN     int     Index,
  1164.     IN     int     BufLen,
  1165.     IN     BOOL    PreOrPost)
  1166. {
  1167.     int *RetVal = (int *)ReturnValue;
  1168.     SOCKET *s = va_arg(vl, SOCKET *);
  1169.     u_short *hostshort = va_arg(vl, u_short *);
  1170.     u_short FAR **lpnetshort = va_arg(vl, u_short FAR **);
  1171.  
  1172.     wsprintf(Buffer + Index, "WSAHtons() %s.\r\n",
  1173.              PreOrPost ? "called" : "returned");
  1174.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1175.     return(FALSE);
  1176. }
  1177.  
  1178.  
  1179. BOOL CALLBACK
  1180. DTHandler_WSAIoctl(
  1181.     IN     va_list vl,
  1182.     IN OUT LPVOID  ReturnValue,
  1183.     IN     LPSTR   LibraryName,
  1184.     OUT    char    *Buffer,
  1185.     IN     int     Index,
  1186.     IN     int     BufLen,
  1187.     IN     BOOL    PreOrPost)
  1188. {
  1189.     int *RetVal = (int *)ReturnValue;
  1190.     SOCKET *s = va_arg(vl, SOCKET *);
  1191.     DWORD *dwIoControlCode = va_arg(vl, DWORD *);
  1192.     LPVOID *lpvInBuffer = va_arg(vl, LPVOID *);
  1193.     DWORD *cbInBuffer = va_arg(vl, DWORD *);
  1194.     LPVOID *lpvOutBuffer = va_arg(vl, LPVOID *);
  1195.     DWORD *cbOutBuffer = va_arg(vl, DWORD *);
  1196.     LPDWORD *lpcbBytesReturned = va_arg(vl, LPDWORD *);
  1197.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  1198.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  1199.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  1200.  
  1201.     wsprintf(Buffer + Index, "WSAIoctl() %s.\r\n",
  1202.              PreOrPost ? "called" : "returned");
  1203.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1204.     return(FALSE);
  1205. }
  1206.  
  1207.  
  1208. BOOL CALLBACK
  1209. DTHandler_WSAIsBlocking(
  1210.     IN     va_list vl,
  1211.     IN OUT LPVOID  ReturnValue,
  1212.     IN     LPSTR   LibraryName,
  1213.     OUT    char    *Buffer,
  1214.     IN     int     Index,
  1215.     IN     int     BufLen,
  1216.     IN     BOOL    PreOrPost)
  1217. {
  1218.     BOOL *RetVal = (BOOL *)ReturnValue;
  1219.  
  1220.     wsprintf(Buffer + Index, "WSAIsBlocking() %s.\r\n",
  1221.              PreOrPost ? "called" : "returned");
  1222.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1223.     return(FALSE);
  1224. }
  1225.  
  1226.  
  1227. BOOL CALLBACK
  1228. DTHandler_WSAJoinLeaf(
  1229.     IN     va_list vl,
  1230.     IN OUT LPVOID  ReturnValue,
  1231.     IN     LPSTR   LibraryName,
  1232.     OUT    char    *Buffer,
  1233.     IN     int     Index,
  1234.     IN     int     BufLen,
  1235.     IN     BOOL    PreOrPost)
  1236. {
  1237.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  1238.     SOCKET *s = va_arg(vl, SOCKET *);
  1239.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  1240.     int *namelen = va_arg(vl, int *);
  1241.     LPWSABUF *lpCallerData = va_arg(vl, LPWSABUF *);
  1242.     LPWSABUF *lpCalleeData = va_arg(vl, LPWSABUF *);
  1243.     LPQOS *lpSQOS = va_arg(vl, LPQOS *);
  1244.     LPQOS *lpGQOS = va_arg(vl, LPQOS *);
  1245.     DWORD *dwFlags = va_arg(vl, DWORD *);
  1246.  
  1247.     wsprintf(Buffer + Index, "WSAJoinLeaf() %s.\r\n",
  1248.              PreOrPost ? "called" : "returned");
  1249.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1250.     return(FALSE);
  1251. }
  1252.  
  1253.  
  1254. BOOL CALLBACK
  1255. DTHandler_WSANtohl(
  1256.     IN     va_list vl,
  1257.     IN OUT LPVOID  ReturnValue,
  1258.     IN     LPSTR   LibraryName,
  1259.     OUT    char    *Buffer,
  1260.     IN     int     Index,
  1261.     IN     int     BufLen,
  1262.     IN     BOOL    PreOrPost)
  1263. {
  1264.     int *RetVal = (int *)ReturnValue;
  1265.     SOCKET *s = va_arg(vl, SOCKET *);
  1266.     u_long *netlong = va_arg(vl, u_long *);
  1267.     u_long FAR **lphostlong = va_arg(vl, u_long FAR **);
  1268.  
  1269.     wsprintf(Buffer + Index, "WSANtohl() %s.\r\n",
  1270.              PreOrPost ? "called" : "returned");
  1271.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1272.     return(FALSE);
  1273. }
  1274.  
  1275.  
  1276. BOOL CALLBACK
  1277. DTHandler_WSANtohs(
  1278.     IN     va_list vl,
  1279.     IN OUT LPVOID  ReturnValue,
  1280.     IN     LPSTR   LibraryName,
  1281.     OUT    char    *Buffer,
  1282.     IN     int     Index,
  1283.     IN     int     BufLen,
  1284.     IN     BOOL    PreOrPost)
  1285. {
  1286.     int *RetVal = (int *)ReturnValue;
  1287.     SOCKET *s = va_arg(vl, SOCKET *);
  1288.     u_short *netshort = va_arg(vl, u_short *);
  1289.     u_short FAR **lphostshort = va_arg(vl, u_short FAR **);
  1290.  
  1291.     wsprintf(Buffer + Index, "WSANtohs() %s.\r\n",
  1292.              PreOrPost ? "called" : "returned");
  1293.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1294.     return(FALSE);
  1295. }
  1296.  
  1297.  
  1298. BOOL CALLBACK
  1299. DTHandler_WSARecv(
  1300.     IN     va_list vl,
  1301.     IN OUT LPVOID  ReturnValue,
  1302.     IN     LPSTR   LibraryName,
  1303.     OUT    char    *Buffer,
  1304.     IN     int     Index,
  1305.     IN     int     BufLen,
  1306.     IN     BOOL    PreOrPost)
  1307. {
  1308.     int *RetVal = (int *)ReturnValue;
  1309.     SOCKET *s = va_arg(vl, SOCKET *);
  1310.     LPWSABUF *lpBuffers = va_arg(vl, LPWSABUF *);
  1311.     DWORD *dwBufferCount = va_arg(vl, DWORD *);
  1312.     LPDWORD *lpNumberOfBytesRecvd = va_arg(vl, LPDWORD *);
  1313.     LPDWORD *lpFlags = va_arg(vl, LPDWORD *);
  1314.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  1315.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  1316.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  1317.  
  1318.     wsprintf(Buffer + Index, "WSARecv() %s.\r\n",
  1319.              PreOrPost ? "called" : "returned");
  1320.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1321.     return(FALSE);
  1322. }
  1323.  
  1324.  
  1325. BOOL CALLBACK
  1326. DTHandler_WSARecvDisconnect(
  1327.     IN     va_list vl,
  1328.     IN OUT LPVOID  ReturnValue,
  1329.     IN     LPSTR   LibraryName,
  1330.     OUT    char    *Buffer,
  1331.     IN     int     Index,
  1332.     IN     int     BufLen,
  1333.     IN     BOOL    PreOrPost)
  1334. {
  1335.     int *RetVal = (int *)ReturnValue;
  1336.     SOCKET *s = va_arg(vl, SOCKET *);
  1337.     LPWSABUF *lpInboundDisconnectData = va_arg(vl, LPWSABUF *);
  1338.  
  1339.     wsprintf(Buffer + Index, "WSARecvDisconnect() %s.\r\n",
  1340.              PreOrPost ? "called" : "returned");
  1341.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1342.     return(FALSE);
  1343. }
  1344.  
  1345.  
  1346. BOOL CALLBACK
  1347. DTHandler_WSARecvFrom(
  1348.     IN     va_list vl,
  1349.     IN OUT LPVOID  ReturnValue,
  1350.     IN     LPSTR   LibraryName,
  1351.     OUT    char    *Buffer,
  1352.     IN     int     Index,
  1353.     IN     int     BufLen,
  1354.     IN     BOOL    PreOrPost)
  1355. {
  1356.     int *RetVal = (int *)ReturnValue;
  1357.     SOCKET *s = va_arg(vl, SOCKET *);
  1358.     LPWSABUF *lpBuffers = va_arg(vl, LPWSABUF *);
  1359.     DWORD *dwBufferCount = va_arg(vl, DWORD *);
  1360.     LPDWORD *lpNumberOfBytesRecvd = va_arg(vl, LPDWORD *);
  1361.     LPDWORD *lpFlags = va_arg(vl, LPDWORD *);
  1362.     struct sockaddr FAR **lpFrom = va_arg(vl, struct sockaddr FAR **);
  1363.     LPINT *lpFromlen = va_arg(vl, LPINT *);
  1364.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  1365.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  1366.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  1367.  
  1368.     wsprintf(Buffer + Index, "WSARecvFrom() %s.\r\n",
  1369.              PreOrPost ? "called" : "returned");
  1370.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1371.     return(FALSE);
  1372. }
  1373.  
  1374.  
  1375. BOOL CALLBACK
  1376. DTHandler_WSAResetEvent(
  1377.     IN     va_list vl,
  1378.     IN OUT LPVOID  ReturnValue,
  1379.     IN     LPSTR   LibraryName,
  1380.     OUT    char    *Buffer,
  1381.     IN     int     Index,
  1382.     IN     int     BufLen,
  1383.     IN     BOOL    PreOrPost)
  1384. {
  1385.     BOOL *RetVal = (BOOL *)ReturnValue;
  1386.     WSAEVENT *hEvent = va_arg(vl, WSAEVENT *);
  1387.  
  1388.     wsprintf(Buffer + Index, "WSAResetEvent() %s.\r\n",
  1389.              PreOrPost ? "called" : "returned");
  1390.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1391.     return(FALSE);
  1392. }
  1393.  
  1394.  
  1395. BOOL CALLBACK
  1396. DTHandler_WSASend(
  1397.     IN     va_list vl,
  1398.     IN OUT LPVOID  ReturnValue,
  1399.     IN     LPSTR   LibraryName,
  1400.     OUT    char    *Buffer,
  1401.     IN     int     Index,
  1402.     IN     int     BufLen,
  1403.     IN     BOOL    PreOrPost)
  1404. {
  1405.     int *RetVal = (int *)ReturnValue;
  1406.     SOCKET *s = va_arg(vl, SOCKET *);
  1407.     LPWSABUF *lpBuffers = va_arg(vl, LPWSABUF *);
  1408.     DWORD *dwBufferCount = va_arg(vl, DWORD *);
  1409.     LPDWORD *lpNumberOfBytesSent = va_arg(vl, LPDWORD *);
  1410.     DWORD *dwFlags = va_arg(vl, DWORD *);
  1411.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  1412.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  1413.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  1414.  
  1415.     wsprintf(Buffer + Index, "WSASend() %s.\r\n",
  1416.              PreOrPost ? "called" : "returned");
  1417.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1418.     return(FALSE);
  1419. }
  1420.  
  1421.  
  1422. BOOL CALLBACK
  1423. DTHandler_WSASendDisconnect(
  1424.     IN     va_list vl,
  1425.     IN OUT LPVOID  ReturnValue,
  1426.     IN     LPSTR   LibraryName,
  1427.     OUT    char    *Buffer,
  1428.     IN     int     Index,
  1429.     IN     int     BufLen,
  1430.     IN     BOOL    PreOrPost)
  1431. {
  1432.     int *RetVal = (int *)ReturnValue;
  1433.     SOCKET *s = va_arg(vl, SOCKET *);
  1434.     LPWSABUF *lpOutboundDisconnectData = va_arg(vl, LPWSABUF *);
  1435.  
  1436.     wsprintf(Buffer + Index, "WSASendDisconnect() %s.\r\n",
  1437.              PreOrPost ? "called" : "returned");
  1438.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1439.     return(FALSE);
  1440. }
  1441.  
  1442.  
  1443. BOOL CALLBACK
  1444. DTHandler_WSASendTo(
  1445.     IN     va_list vl,
  1446.     IN OUT LPVOID  ReturnValue,
  1447.     IN     LPSTR   LibraryName,
  1448.     OUT    char    *Buffer,
  1449.     IN     int     Index,
  1450.     IN     int     BufLen,
  1451.     IN     BOOL    PreOrPost)
  1452. {
  1453.     int *RetVal = (int *)ReturnValue;
  1454.     SOCKET *s = va_arg(vl, SOCKET *);
  1455.     LPWSABUF *lpBuffers = va_arg(vl, LPWSABUF *);
  1456.     DWORD *dwBufferCount = va_arg(vl, DWORD *);
  1457.     LPDWORD *lpNumberOfBytesSent = va_arg(vl, LPDWORD *);
  1458.     DWORD *dwFlags = va_arg(vl, DWORD *);
  1459.     struct sockaddr FAR **lpTo = va_arg(vl, struct sockaddr FAR **);
  1460.     int *iTolen = va_arg(vl, int *);
  1461.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  1462.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  1463.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  1464.  
  1465.     wsprintf(Buffer + Index, "WSASendTo() %s.\r\n",
  1466.              PreOrPost ? "called" : "returned");
  1467.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1468.     return(FALSE);
  1469. }
  1470.  
  1471.  
  1472. BOOL CALLBACK
  1473. DTHandler_WSASetBlockingHook(
  1474.     IN     va_list vl,
  1475.     IN OUT LPVOID  ReturnValue,
  1476.     IN     LPSTR   LibraryName,
  1477.     OUT    char    *Buffer,
  1478.     IN     int     Index,
  1479.     IN     int     BufLen,
  1480.     IN     BOOL    PreOrPost)
  1481. {
  1482.     FARPROC *RetVal = (FARPROC *)ReturnValue;
  1483.     FARPROC *lpBlockFunc = va_arg(vl, FARPROC *);
  1484.  
  1485.     wsprintf(Buffer + Index, "WSASetBlockingHook() %s.\r\n",
  1486.              PreOrPost ? "called" : "returned");
  1487.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1488.     return(FALSE);
  1489. }
  1490.  
  1491.  
  1492. BOOL CALLBACK
  1493. DTHandler_WSASetEvent(
  1494.     IN     va_list vl,
  1495.     IN OUT LPVOID  ReturnValue,
  1496.     IN     LPSTR   LibraryName,
  1497.     OUT    char    *Buffer,
  1498.     IN     int     Index,
  1499.     IN     int     BufLen,
  1500.     IN     BOOL    PreOrPost)
  1501. {
  1502.     BOOL *RetVal = (BOOL *)ReturnValue;
  1503.     WSAEVENT *hEvent = va_arg(vl, WSAEVENT *);
  1504.  
  1505.     wsprintf(Buffer + Index, "WSASetEvent() %s.\r\n",
  1506.              PreOrPost ? "called" : "returned");
  1507.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1508.     return(FALSE);
  1509. }
  1510.  
  1511.  
  1512. BOOL CALLBACK
  1513. DTHandler_WSASetLastError(
  1514.     IN     va_list vl,
  1515.     IN OUT LPVOID  ReturnValue,
  1516.     IN     LPSTR   LibraryName,
  1517.     OUT    char    *Buffer,
  1518.     IN     int     Index,
  1519.     IN     int     BufLen,
  1520.     IN     BOOL    PreOrPost)
  1521. {
  1522.     // WSASetLastError returns void, so ReturnValue should be NULL
  1523.     int *iError = va_arg(vl, int *);
  1524.  
  1525.     wsprintf(Buffer + Index, "WSASetLastError() %s.\r\n",
  1526.              PreOrPost ? "called" : "returned");
  1527.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1528.     return(FALSE);
  1529. }
  1530.  
  1531.  
  1532. BOOL CALLBACK
  1533. DTHandler_WSASocketA(
  1534.     IN     va_list vl,
  1535.     IN OUT LPVOID  ReturnValue,
  1536.     IN     LPSTR   LibraryName,
  1537.     OUT    char    *Buffer,
  1538.     IN     int     Index,
  1539.     IN     int     BufLen,
  1540.     IN     BOOL    PreOrPost)
  1541. {
  1542.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  1543.     int *af = va_arg(vl, int *);
  1544.     int *type = va_arg(vl, int *);
  1545.     int *protocol = va_arg(vl, int *);
  1546.     LPWSAPROTOCOL_INFOA *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFOA *);
  1547.     GROUP *g = va_arg(vl, GROUP *);
  1548.     DWORD *dwFlags = va_arg(vl, DWORD *);
  1549.  
  1550.     wsprintf(Buffer + Index, "WSASocketA() %s.\r\n",
  1551.              PreOrPost ? "called" : "returned");
  1552.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1553.     return(FALSE);
  1554. }
  1555.  
  1556.  
  1557. BOOL CALLBACK
  1558. DTHandler_WSASocketW(
  1559.     IN     va_list vl,
  1560.     IN OUT LPVOID  ReturnValue,
  1561.     IN     LPSTR   LibraryName,
  1562.     OUT    char    *Buffer,
  1563.     IN     int     Index,
  1564.     IN     int     BufLen,
  1565.     IN     BOOL    PreOrPost)
  1566. {
  1567.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  1568.     int *af = va_arg(vl, int *);
  1569.     int *type = va_arg(vl, int *);
  1570.     int *protocol = va_arg(vl, int *);
  1571.     LPWSAPROTOCOL_INFOW *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFOW *);
  1572.     GROUP *g = va_arg(vl, GROUP *);
  1573.     DWORD *dwFlags = va_arg(vl, DWORD *);
  1574.  
  1575.     wsprintf(Buffer + Index, "WSASocketW() %s.\r\n",
  1576.              PreOrPost ? "called" : "returned");
  1577.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1578.     return(FALSE);
  1579. }
  1580.  
  1581.  
  1582. BOOL CALLBACK
  1583. DTHandler_WSAStartup(
  1584.     IN     va_list vl,
  1585.     IN OUT LPVOID  ReturnValue,
  1586.     IN     LPSTR   LibraryName,
  1587.     OUT    char    *Buffer,
  1588.     IN     int     Index,
  1589.     IN     int     BufLen,
  1590.     IN     BOOL    PreOrPost)
  1591. {
  1592.     int *RetVal = (int *)ReturnValue;
  1593.     WORD *wVersionRequested = va_arg(vl, WORD *);
  1594.     LPWSADATA *lpWSAData = va_arg(vl, LPWSADATA *);
  1595.  
  1596.     wsprintf(Buffer + Index, "WSAStartup() %s.\r\n",
  1597.              PreOrPost ? "called" : "returned");
  1598.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1599.     return(FALSE);
  1600. }
  1601.  
  1602.  
  1603. BOOL CALLBACK
  1604. DTHandler_WSAUnhookBlockingHook(
  1605.     IN     va_list vl,
  1606.     IN OUT LPVOID  ReturnValue,
  1607.     IN     LPSTR   LibraryName,
  1608.     OUT    char    *Buffer,
  1609.     IN     int     Index,
  1610.     IN     int     BufLen,
  1611.     IN     BOOL    PreOrPost)
  1612. {
  1613.     int *RetVal = (int *)ReturnValue;
  1614.  
  1615.     wsprintf(Buffer + Index, "WSAUnhookBlockingHook() %s.\r\n",
  1616.              PreOrPost ? "called" : "returned");
  1617.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1618.     return(FALSE);
  1619. }
  1620.  
  1621.  
  1622. BOOL CALLBACK
  1623. DTHandler_WSAWaitForMultipleEvents(
  1624.     IN     va_list vl,
  1625.     IN OUT LPVOID  ReturnValue,
  1626.     IN     LPSTR   LibraryName,
  1627.     OUT    char    *Buffer,
  1628.     IN     int     Index,
  1629.     IN     int     BufLen,
  1630.     IN     BOOL    PreOrPost)
  1631. {
  1632.     DWORD *RetVal = (DWORD *)ReturnValue;
  1633.     DWORD *cEvents = va_arg(vl, DWORD *);
  1634.     WSAEVENT FAR **lphEvents = va_arg(vl, WSAEVENT FAR **);
  1635.     BOOL *fWaitAll = va_arg(vl, BOOL *);
  1636.     DWORD *dwTimeout = va_arg(vl, DWORD *);
  1637.     BOOL *fAlertable = va_arg(vl, BOOL *);
  1638.  
  1639.     wsprintf(Buffer + Index, "WSAWaitForMultipleEvents() %s.\r\n",
  1640.              PreOrPost ? "called" : "returned");
  1641.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1642.     return(FALSE);
  1643. }
  1644.  
  1645.  
  1646. BOOL CALLBACK
  1647. DTHandler_gethostbyaddr(
  1648.     IN     va_list vl,
  1649.     IN OUT LPVOID  ReturnValue,
  1650.     IN     LPSTR   LibraryName,
  1651.     OUT    char    *Buffer,
  1652.     IN     int     Index,
  1653.     IN     int     BufLen,
  1654.     IN     BOOL    PreOrPost)
  1655. {
  1656.     struct hostent FAR **RetVal = (struct hostent FAR **)ReturnValue;
  1657.     char FAR **addr = va_arg(vl, char FAR **);
  1658.     int *len = va_arg(vl, int *);
  1659.     int *type = va_arg(vl, int *);
  1660.  
  1661.     wsprintf(Buffer + Index, "gethostbyaddr() %s.\r\n",
  1662.              PreOrPost ? "called" : "returned");
  1663.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1664.     return(FALSE);
  1665. }
  1666.  
  1667.  
  1668. BOOL CALLBACK
  1669. DTHandler_gethostbyname(
  1670.     IN     va_list vl,
  1671.     IN OUT LPVOID  ReturnValue,
  1672.     IN     LPSTR   LibraryName,
  1673.     OUT    char    *Buffer,
  1674.     IN     int     Index,
  1675.     IN     int     BufLen,
  1676.     IN     BOOL    PreOrPost)
  1677. {
  1678.     struct hostent FAR **RetVal = (struct hostent FAR **)ReturnValue;
  1679.     char FAR **name = va_arg(vl, char FAR **);
  1680.  
  1681.     wsprintf(Buffer + Index, "gethostbyname() %s.\r\n",
  1682.              PreOrPost ? "called" : "returned");
  1683.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1684.     return(FALSE);
  1685. }
  1686.  
  1687.  
  1688. BOOL CALLBACK
  1689. DTHandler_gethostname(
  1690.     IN     va_list vl,
  1691.     IN OUT LPVOID  ReturnValue,
  1692.     IN     LPSTR   LibraryName,
  1693.     OUT    char    *Buffer,
  1694.     IN     int     Index,
  1695.     IN     int     BufLen,
  1696.     IN     BOOL    PreOrPost)
  1697. {
  1698.     int *RetVal = (int *)ReturnValue;
  1699.     char FAR **name = va_arg(vl, char FAR **);
  1700.     int *namelen = va_arg(vl, int *);
  1701.  
  1702.     wsprintf(Buffer + Index, "gethostname() %s.\r\n",
  1703.              PreOrPost ? "called" : "returned");
  1704.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1705.     return(FALSE);
  1706. }
  1707.  
  1708.  
  1709. BOOL CALLBACK
  1710. DTHandler_getprotobyname(
  1711.     IN     va_list vl,
  1712.     IN OUT LPVOID  ReturnValue,
  1713.     IN     LPSTR   LibraryName,
  1714.     OUT    char    *Buffer,
  1715.     IN     int     Index,
  1716.     IN     int     BufLen,
  1717.     IN     BOOL    PreOrPost)
  1718. {
  1719.     struct protoent FAR **RetVal = (struct protoent FAR **)ReturnValue;
  1720.     char FAR **name = va_arg(vl, char FAR **);
  1721.  
  1722.     wsprintf(Buffer + Index, "getprotobyname() %s.\r\n",
  1723.              PreOrPost ? "called" : "returned");
  1724.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1725.     return(FALSE);
  1726. }
  1727.  
  1728.  
  1729. BOOL CALLBACK
  1730. DTHandler_getprotobynumber(
  1731.     IN     va_list vl,
  1732.     IN OUT LPVOID  ReturnValue,
  1733.     IN     LPSTR   LibraryName,
  1734.     OUT    char    *Buffer,
  1735.     IN     int     Index,
  1736.     IN     int     BufLen,
  1737.     IN     BOOL    PreOrPost)
  1738. {
  1739.     struct protoent FAR **RetVal = (struct protoent FAR **)ReturnValue;
  1740.     int *number = va_arg(vl, int *);
  1741.  
  1742.     wsprintf(Buffer + Index, "getprotobynumber() %s.\r\n",
  1743.              PreOrPost ? "called" : "returned");
  1744.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1745.     return(FALSE);
  1746. }
  1747.  
  1748.  
  1749. BOOL CALLBACK
  1750. DTHandler_getservbyname(
  1751.     IN     va_list vl,
  1752.     IN OUT LPVOID  ReturnValue,
  1753.     IN     LPSTR   LibraryName,
  1754.     OUT    char    *Buffer,
  1755.     IN     int     Index,
  1756.     IN     int     BufLen,
  1757.     IN     BOOL    PreOrPost)
  1758. {
  1759.     struct servent FAR **RetVal = (struct servent FAR **)ReturnValue;
  1760.     char FAR **name = va_arg(vl, char FAR **);
  1761.     char FAR **proto = va_arg(vl, char FAR **);
  1762.  
  1763.     wsprintf(Buffer + Index, "getservbyname() %s.\r\n",
  1764.              PreOrPost ? "called" : "returned");
  1765.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1766.     return(FALSE);
  1767. }
  1768.  
  1769.  
  1770. BOOL CALLBACK
  1771. DTHandler_getservbyport(
  1772.     IN     va_list vl,
  1773.     IN OUT LPVOID  ReturnValue,
  1774.     IN     LPSTR   LibraryName,
  1775.     OUT    char    *Buffer,
  1776.     IN     int     Index,
  1777.     IN     int     BufLen,
  1778.     IN     BOOL    PreOrPost)
  1779. {
  1780.     struct servent FAR **RetVal = (struct servent FAR **)ReturnValue;
  1781.     int *port = va_arg(vl, int *);
  1782.     char FAR **proto = va_arg(vl, char FAR **);
  1783.  
  1784.     wsprintf(Buffer + Index, "getservbyport() %s.\r\n",
  1785.              PreOrPost ? "called" : "returned");
  1786.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1787.     return(FALSE);
  1788. }
  1789.  
  1790.  
  1791. BOOL CALLBACK
  1792. DTHandler_inet_addr(
  1793.     IN     va_list vl,
  1794.     IN OUT LPVOID  ReturnValue,
  1795.     IN     LPSTR   LibraryName,
  1796.     OUT    char    *Buffer,
  1797.     IN     int     Index,
  1798.     IN     int     BufLen,
  1799.     IN     BOOL    PreOrPost)
  1800. {
  1801.     unsigned long *RetVal = (unsigned long *)ReturnValue;
  1802.     char FAR **cp = va_arg(vl, char FAR **);
  1803.  
  1804.     wsprintf(Buffer + Index, "inet_addr() %s.\r\n",
  1805.              PreOrPost ? "called" : "returned");
  1806.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1807.     return(FALSE);
  1808. }
  1809.  
  1810.  
  1811. BOOL CALLBACK
  1812. DTHandler_inet_ntoa(
  1813.     IN     va_list vl,
  1814.     IN OUT LPVOID  ReturnValue,
  1815.     IN     LPSTR   LibraryName,
  1816.     OUT    char    *Buffer,
  1817.     IN     int     Index,
  1818.     IN     int     BufLen,
  1819.     IN     BOOL    PreOrPost)
  1820. {
  1821.     char FAR **RetVal = (char FAR **)ReturnValue;
  1822.     struct in_addr *in = va_arg(vl, struct in_addr *);
  1823.  
  1824.     wsprintf(Buffer + Index, "inet_ntoa() %s.\r\n",
  1825.              PreOrPost ? "called" : "returned");
  1826.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1827.     return(FALSE);
  1828. }
  1829.  
  1830.  
  1831. BOOL CALLBACK
  1832. DTHandler_WSAAsyncGetHostByAddr(
  1833.     IN     va_list vl,
  1834.     IN OUT LPVOID  ReturnValue,
  1835.     IN     LPSTR   LibraryName,
  1836.     OUT    char    *Buffer,
  1837.     IN     int     Index,
  1838.     IN     int     BufLen,
  1839.     IN     BOOL    PreOrPost)
  1840. {
  1841.     HANDLE *RetVal = (HANDLE *)ReturnValue;
  1842.     HWND *hWnd = va_arg(vl, HWND *);
  1843.     u_int *wMsg = va_arg(vl, u_int *);
  1844.     char FAR **addr = va_arg(vl, char FAR **);
  1845.     int *len = va_arg(vl, int *);
  1846.     int *type = va_arg(vl, int *);
  1847.     char FAR **buf = va_arg(vl, char FAR **);
  1848.     int *buflen = va_arg(vl, int *);
  1849.  
  1850.     wsprintf(Buffer + Index, "WSAAsyncGetHostByAddr() %s.\r\n",
  1851.              PreOrPost ? "called" : "returned");
  1852.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1853.     return(FALSE);
  1854. }
  1855.  
  1856.  
  1857. BOOL CALLBACK
  1858. DTHandler_WSAAsyncGetHostByName(
  1859.     IN     va_list vl,
  1860.     IN OUT LPVOID  ReturnValue,
  1861.     IN     LPSTR   LibraryName,
  1862.     OUT    char    *Buffer,
  1863.     IN     int     Index,
  1864.     IN     int     BufLen,
  1865.     IN     BOOL    PreOrPost)
  1866. {
  1867.     HANDLE *RetVal = (HANDLE *)ReturnValue;
  1868.     HWND *hWnd = va_arg(vl, HWND *);
  1869.     u_int *wMsg = va_arg(vl, u_int *);
  1870.     char FAR **name = va_arg(vl, char FAR **);
  1871.     char FAR **buf = va_arg(vl, char FAR **);
  1872.     int *buflen = va_arg(vl, int *);
  1873.  
  1874.     wsprintf(Buffer + Index, "WSAAsyncGetHostByName() %s.\r\n",
  1875.              PreOrPost ? "called" : "returned");
  1876.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1877.     return(FALSE);
  1878. }
  1879.  
  1880.  
  1881. BOOL CALLBACK
  1882. DTHandler_WSAAsyncGetProtoByName(
  1883.     IN     va_list vl,
  1884.     IN OUT LPVOID  ReturnValue,
  1885.     IN     LPSTR   LibraryName,
  1886.     OUT    char    *Buffer,
  1887.     IN     int     Index,
  1888.     IN     int     BufLen,
  1889.     IN     BOOL    PreOrPost)
  1890. {
  1891.     HANDLE *RetVal = (HANDLE *)ReturnValue;
  1892.     HWND *hWnd = va_arg(vl, HWND *);
  1893.     u_int *wMsg = va_arg(vl, u_int *);
  1894.     char FAR **name = va_arg(vl, char FAR **);
  1895.     char FAR **buf = va_arg(vl, char FAR **);
  1896.     int *buflen = va_arg(vl, int *);
  1897.  
  1898.     wsprintf(Buffer + Index, "WSAAsyncGetProtoByName() %s.\r\n",
  1899.              PreOrPost ? "called" : "returned");
  1900.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1901.     return(FALSE);
  1902. }
  1903.  
  1904.  
  1905. BOOL CALLBACK
  1906. DTHandler_WSAAsyncGetProtoByNumber(
  1907.     IN     va_list vl,
  1908.     IN OUT LPVOID  ReturnValue,
  1909.     IN     LPSTR   LibraryName,
  1910.     OUT    char    *Buffer,
  1911.     IN     int     Index,
  1912.     IN     int     BufLen,
  1913.     IN     BOOL    PreOrPost)
  1914. {
  1915.     HANDLE *RetVal = (HANDLE *)ReturnValue;
  1916.     HWND *hWnd = va_arg(vl, HWND *);
  1917.     u_int *wMsg = va_arg(vl, u_int *);
  1918.     int *number = va_arg(vl, int *);
  1919.     char FAR **buf = va_arg(vl, char FAR **);
  1920.     int *buflen = va_arg(vl, int *);
  1921.  
  1922.     wsprintf(Buffer + Index, "WSAAsyncGetProtoByNumber() %s.\r\n",
  1923.              PreOrPost ? "called" : "returned");
  1924.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1925.     return(FALSE);
  1926. }
  1927.  
  1928.  
  1929. BOOL CALLBACK
  1930. DTHandler_WSAAsyncGetServByName(
  1931.     IN     va_list vl,
  1932.     IN OUT LPVOID  ReturnValue,
  1933.     IN     LPSTR   LibraryName,
  1934.     OUT    char    *Buffer,
  1935.     IN     int     Index,
  1936.     IN     int     BufLen,
  1937.     IN     BOOL    PreOrPost)
  1938. {
  1939.     HANDLE *RetVal = (HANDLE *)ReturnValue;
  1940.     HWND *hWnd = va_arg(vl, HWND *);
  1941.     u_int *wMsg = va_arg(vl, u_int *);
  1942.     char FAR **name = va_arg(vl, char FAR **);
  1943.     char FAR **proto = va_arg(vl, char FAR **);
  1944.     char FAR **buf = va_arg(vl, char FAR **);
  1945.     int *buflen = va_arg(vl, int *);
  1946.  
  1947.     wsprintf(Buffer + Index, "WSAAsyncGetServByName() %s.\r\n",
  1948.              PreOrPost ? "called" : "returned");
  1949.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1950.     return(FALSE);
  1951. }
  1952.  
  1953.  
  1954. BOOL CALLBACK
  1955. DTHandler_WSAAsyncGetServByPort(
  1956.     IN     va_list vl,
  1957.     IN OUT LPVOID  ReturnValue,
  1958.     IN     LPSTR   LibraryName,
  1959.     OUT    char    *Buffer,
  1960.     IN     int     Index,
  1961.     IN     int     BufLen,
  1962.     IN     BOOL    PreOrPost)
  1963. {
  1964.     HANDLE *RetVal = (HANDLE *)ReturnValue;
  1965.     HWND *hWnd = va_arg(vl, HWND *);
  1966.     u_int *wMsg = va_arg(vl, u_int *);
  1967.     int *port = va_arg(vl, int *);
  1968.     char FAR **proto = va_arg(vl, char FAR **);
  1969.     char FAR **buf = va_arg(vl, char FAR **);
  1970.     int *buflen = va_arg(vl, int *);
  1971.  
  1972.     wsprintf(Buffer + Index, "WSAAsyncGetServByPort() %s.\r\n",
  1973.              PreOrPost ? "called" : "returned");
  1974.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1975.     return(FALSE);
  1976. }
  1977.  
  1978.  
  1979. BOOL CALLBACK
  1980. DTHandler_WSACancelAsyncRequest(
  1981.     IN     va_list vl,
  1982.     IN OUT LPVOID  ReturnValue,
  1983.     IN     LPSTR   LibraryName,
  1984.     OUT    char    *Buffer,
  1985.     IN     int     Index,
  1986.     IN     int     BufLen,
  1987.     IN     BOOL    PreOrPost)
  1988. {
  1989.     int *RetVal = (int *)ReturnValue;
  1990.     HANDLE *hAsyncTaskHandle = va_arg(vl, HANDLE *);
  1991.  
  1992.     wsprintf(Buffer + Index, "WSACancelAsyncRequest() %s.\r\n",
  1993.              PreOrPost ? "called" : "returned");
  1994.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  1995.     return(FALSE);
  1996. }
  1997.  
  1998.  
  1999. BOOL CALLBACK
  2000. DTHandler_WSPAccept(
  2001.     IN     va_list vl,
  2002.     IN OUT LPVOID  ReturnValue,
  2003.     IN     LPSTR   LibraryName,
  2004.     OUT    char    *Buffer,
  2005.     IN     int     Index,
  2006.     IN     int     BufLen,
  2007.     IN     BOOL    PreOrPost)
  2008. {
  2009.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  2010.     SOCKET *s = va_arg(vl, SOCKET *);
  2011.     struct sockaddr FAR **addr = va_arg(vl, struct sockaddr FAR **);
  2012.     INT FAR **addrlen = va_arg(vl, INT FAR **);
  2013.     LPCONDITIONPROC *lpfnCondition = va_arg(vl, LPCONDITIONPROC *);
  2014.     DWORD *dwCallbackData = va_arg(vl, DWORD *);
  2015.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2016.  
  2017.     wsprintf(Buffer + Index, "WSPAccept() %s.\r\n",
  2018.              PreOrPost ? "called" : "returned");
  2019.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2020.     return(FALSE);
  2021. }
  2022.  
  2023.  
  2024. BOOL CALLBACK
  2025. DTHandler_WSPAsyncSelect(
  2026.     IN     va_list vl,
  2027.     IN OUT LPVOID  ReturnValue,
  2028.     IN     LPSTR   LibraryName,
  2029.     OUT    char    *Buffer,
  2030.     IN     int     Index,
  2031.     IN     int     BufLen,
  2032.     IN     BOOL    PreOrPost)
  2033. {
  2034.     INT *RetVal = (INT *)ReturnValue;
  2035.     SOCKET *s = va_arg(vl, SOCKET *);
  2036.     HWND *hWnd = va_arg(vl, HWND *);
  2037.     unsigned int *wMsg = va_arg(vl, unsigned int *);
  2038.     long *lEvent = va_arg(vl, long *);
  2039.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2040.  
  2041.     wsprintf(Buffer + Index, "WSPAsyncSelect() %s.\r\n",
  2042.              PreOrPost ? "called" : "returned");
  2043.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2044.     return(FALSE);
  2045. }
  2046.  
  2047.  
  2048. BOOL CALLBACK
  2049. DTHandler_WSPBind(
  2050.     IN     va_list vl,
  2051.     IN OUT LPVOID  ReturnValue,
  2052.     IN     LPSTR   LibraryName,
  2053.     OUT    char    *Buffer,
  2054.     IN     int     Index,
  2055.     IN     int     BufLen,
  2056.     IN     BOOL    PreOrPost)
  2057. {
  2058.     INT *RetVal = (INT *)ReturnValue;
  2059.     SOCKET *s = va_arg(vl, SOCKET *);
  2060.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  2061.     INT *namelen = va_arg(vl, INT *);
  2062.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2063.  
  2064.     wsprintf(Buffer + Index, "WSPBind() %s.\r\n",
  2065.              PreOrPost ? "called" : "returned");
  2066.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2067.     return(FALSE);
  2068. }
  2069.  
  2070.  
  2071. BOOL CALLBACK
  2072. DTHandler_WSPCancelBlockingCall(
  2073.     IN     va_list vl,
  2074.     IN OUT LPVOID  ReturnValue,
  2075.     IN     LPSTR   LibraryName,
  2076.     OUT    char    *Buffer,
  2077.     IN     int     Index,
  2078.     IN     int     BufLen,
  2079.     IN     BOOL    PreOrPost)
  2080. {
  2081.     INT *RetVal = (INT *)ReturnValue;
  2082.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2083.  
  2084.     wsprintf(Buffer + Index, "WSPCancelBlockingCall() %s.\r\n",
  2085.              PreOrPost ? "called" : "returned");
  2086.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2087.     return(FALSE);
  2088. }
  2089.  
  2090.  
  2091. BOOL CALLBACK
  2092. DTHandler_WSPCleanup(
  2093.     IN     va_list vl,
  2094.     IN OUT LPVOID  ReturnValue,
  2095.     IN     LPSTR   LibraryName,
  2096.     OUT    char    *Buffer,
  2097.     IN     int     Index,
  2098.     IN     int     BufLen,
  2099.     IN     BOOL    PreOrPost)
  2100. {
  2101.     INT *RetVal = (INT *)ReturnValue;
  2102.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2103.  
  2104.     wsprintf(Buffer + Index, "WSPCleanup() %s.\r\n",
  2105.              PreOrPost ? "called" : "returned");
  2106.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2107.     return(FALSE);
  2108. }
  2109.  
  2110.  
  2111. BOOL CALLBACK
  2112. DTHandler_WSPCloseSocket(
  2113.     IN     va_list vl,
  2114.     IN OUT LPVOID  ReturnValue,
  2115.     IN     LPSTR   LibraryName,
  2116.     OUT    char    *Buffer,
  2117.     IN     int     Index,
  2118.     IN     int     BufLen,
  2119.     IN     BOOL    PreOrPost)
  2120. {
  2121.     INT *RetVal = (INT *)ReturnValue;
  2122.     SOCKET *s = va_arg(vl, SOCKET *);
  2123.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2124.  
  2125.     wsprintf(Buffer + Index, "WSPCloseSocket() %s.\r\n",
  2126.              PreOrPost ? "called" : "returned");
  2127.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2128.     return(FALSE);
  2129. }
  2130.  
  2131.  
  2132. BOOL CALLBACK
  2133. DTHandler_WSPConnect(
  2134.     IN     va_list vl,
  2135.     IN OUT LPVOID  ReturnValue,
  2136.     IN     LPSTR   LibraryName,
  2137.     OUT    char    *Buffer,
  2138.     IN     int     Index,
  2139.     IN     int     BufLen,
  2140.     IN     BOOL    PreOrPost)
  2141. {
  2142.     INT *RetVal = (INT *)ReturnValue;
  2143.     SOCKET *s = va_arg(vl, SOCKET *);
  2144.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  2145.     INT *namelen = va_arg(vl, INT *);
  2146.     LPWSABUF *lpCallerData = va_arg(vl, LPWSABUF *);
  2147.     LPWSABUF *lpCalleeData = va_arg(vl, LPWSABUF *);
  2148.     LPQOS *lpSQOS = va_arg(vl, LPQOS *);
  2149.     LPQOS *lpGQOS = va_arg(vl, LPQOS *);
  2150.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2151.  
  2152.     wsprintf(Buffer + Index, "WSPConnect() %s.\r\n",
  2153.              PreOrPost ? "called" : "returned");
  2154.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2155.     return(FALSE);
  2156. }
  2157.  
  2158.  
  2159. BOOL CALLBACK
  2160. DTHandler_WSPDuplicateSocket(
  2161.     IN     va_list vl,
  2162.     IN OUT LPVOID  ReturnValue,
  2163.     IN     LPSTR   LibraryName,
  2164.     OUT    char    *Buffer,
  2165.     IN     int     Index,
  2166.     IN     int     BufLen,
  2167.     IN     BOOL    PreOrPost)
  2168. {
  2169.     INT *RetVal = (INT *)ReturnValue;
  2170.     SOCKET *s = va_arg(vl, SOCKET *);
  2171.     DWORD *dwProcessID = va_arg(vl, DWORD *);
  2172.     LPWSAPROTOCOL_INFO *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFO *);
  2173.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2174.  
  2175.     wsprintf(Buffer + Index, "WSPDuplicateSocket() %s.\r\n",
  2176.              PreOrPost ? "called" : "returned");
  2177.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2178.     return(FALSE);
  2179. }
  2180.  
  2181.  
  2182. BOOL CALLBACK
  2183. DTHandler_WSPEnumNetworkEvents(
  2184.     IN     va_list vl,
  2185.     IN OUT LPVOID  ReturnValue,
  2186.     IN     LPSTR   LibraryName,
  2187.     OUT    char    *Buffer,
  2188.     IN     int     Index,
  2189.     IN     int     BufLen,
  2190.     IN     BOOL    PreOrPost)
  2191. {
  2192.     INT *RetVal = (INT *)ReturnValue;
  2193.     SOCKET *s = va_arg(vl, SOCKET *);
  2194.     WSAEVENT *hEventObject = va_arg(vl, WSAEVENT *);
  2195.     LPWSANETWORKEVENTS *lpNetworkEvents = va_arg(vl, LPWSANETWORKEVENTS *);
  2196.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2197.  
  2198.     wsprintf(Buffer + Index, "WSPEnumNetworkEvents() %s.\r\n",
  2199.              PreOrPost ? "called" : "returned");
  2200.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2201.     return(FALSE);
  2202. }
  2203.  
  2204.  
  2205. BOOL CALLBACK
  2206. DTHandler_WSPEventSelect(
  2207.     IN     va_list vl,
  2208.     IN OUT LPVOID  ReturnValue,
  2209.     IN     LPSTR   LibraryName,
  2210.     OUT    char    *Buffer,
  2211.     IN     int     Index,
  2212.     IN     int     BufLen,
  2213.     IN     BOOL    PreOrPost)
  2214. {
  2215.     INT *RetVal = (INT *)ReturnValue;
  2216.     SOCKET *s = va_arg(vl, SOCKET *);
  2217.     WSAEVENT *hEventObject = va_arg(vl, WSAEVENT *);
  2218.     long *lNetworkEvents = va_arg(vl, long *);
  2219.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2220.  
  2221.     wsprintf(Buffer + Index, "WSPEventSelect() %s.\r\n",
  2222.              PreOrPost ? "called" : "returned");
  2223.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2224.     return(FALSE);
  2225. }
  2226.  
  2227.  
  2228. BOOL CALLBACK
  2229. DTHandler_WSPGetOverlappedResult(
  2230.     IN     va_list vl,
  2231.     IN OUT LPVOID  ReturnValue,
  2232.     IN     LPSTR   LibraryName,
  2233.     OUT    char    *Buffer,
  2234.     IN     int     Index,
  2235.     IN     int     BufLen,
  2236.     IN     BOOL    PreOrPost)
  2237. {
  2238.     INT *RetVal = (INT *)ReturnValue;
  2239.     SOCKET *s = va_arg(vl, SOCKET *);
  2240.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  2241.     LPDWORD *lpcbTransfer = va_arg(vl, LPDWORD *);
  2242.     BOOL *fWait = va_arg(vl, BOOL *);
  2243.     LPDWORD *lpdwFlags = va_arg(vl, LPDWORD *);
  2244.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2245.  
  2246.     wsprintf(Buffer + Index, "WSPGetOverlappedResult() %s.\r\n",
  2247.              PreOrPost ? "called" : "returned");
  2248.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2249.     return(FALSE);
  2250. }
  2251.  
  2252.  
  2253. BOOL CALLBACK
  2254. DTHandler_WSPGetPeerName(
  2255.     IN     va_list vl,
  2256.     IN OUT LPVOID  ReturnValue,
  2257.     IN     LPSTR   LibraryName,
  2258.     OUT    char    *Buffer,
  2259.     IN     int     Index,
  2260.     IN     int     BufLen,
  2261.     IN     BOOL    PreOrPost)
  2262. {
  2263.     INT *RetVal = (INT *)ReturnValue;
  2264.     SOCKET *s = va_arg(vl, SOCKET *);
  2265.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  2266.     INT FAR **namelen = va_arg(vl, INT FAR **);
  2267.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2268.  
  2269.     wsprintf(Buffer + Index, "WSPGetPeerName() %s.\r\n",
  2270.              PreOrPost ? "called" : "returned");
  2271.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2272.     return(FALSE);
  2273. }
  2274.  
  2275.  
  2276.  
  2277. BOOL CALLBACK
  2278. DTHandler_WSPGetSockName(
  2279.     IN     va_list vl,
  2280.     IN OUT LPVOID  ReturnValue,
  2281.     IN     LPSTR   LibraryName,
  2282.     OUT    char    *Buffer,
  2283.     IN     int     Index,
  2284.     IN     int     BufLen,
  2285.     IN     BOOL    PreOrPost)
  2286. {
  2287.     INT *RetVal = (INT *)ReturnValue;
  2288.     SOCKET *s = va_arg(vl, SOCKET *);
  2289.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  2290.     INT FAR **namelen = va_arg(vl, INT FAR **);
  2291.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2292.  
  2293.     wsprintf(Buffer + Index, "WSPGetSockName() %s.\r\n",
  2294.              PreOrPost ? "called" : "returned");
  2295.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2296.     return(FALSE);
  2297. }
  2298.  
  2299.  
  2300. BOOL CALLBACK
  2301. DTHandler_WSPGetSockOpt(
  2302.     IN     va_list vl,
  2303.     IN OUT LPVOID  ReturnValue,
  2304.     IN     LPSTR   LibraryName,
  2305.     OUT    char    *Buffer,
  2306.     IN     int     Index,
  2307.     IN     int     BufLen,
  2308.     IN     BOOL    PreOrPost)
  2309. {
  2310.     INT *RetVal = (INT *)ReturnValue;
  2311.     SOCKET *s = va_arg(vl, SOCKET *);
  2312.     INT *level = va_arg(vl, INT *);
  2313.     INT *optname = va_arg(vl, INT *);
  2314.     char FAR **optval = va_arg(vl, char FAR **);
  2315.     INT FAR **optlen = va_arg(vl, INT FAR **);
  2316.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2317.  
  2318.     wsprintf(Buffer + Index, "WSPGetSockOpt() %s.\r\n",
  2319.              PreOrPost ? "called" : "returned");
  2320.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2321.     return(FALSE);
  2322. }
  2323.  
  2324.  
  2325. BOOL CALLBACK
  2326. DTHandler_WSPGetQOSByName(
  2327.     IN     va_list vl,
  2328.     IN OUT LPVOID  ReturnValue,
  2329.     IN     LPSTR   LibraryName,
  2330.     OUT    char    *Buffer,
  2331.     IN     int     Index,
  2332.     IN     int     BufLen,
  2333.     IN     BOOL    PreOrPost)
  2334. {
  2335.     INT *RetVal = (INT *)ReturnValue;
  2336.     SOCKET *s = va_arg(vl, SOCKET *);
  2337.     LPWSABUF *lpQOSName = va_arg(vl, LPWSABUF *);
  2338.     LPQOS *lpQOS = va_arg(vl, LPQOS *);
  2339.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2340.  
  2341.     wsprintf(Buffer + Index, "WSPGetQOSByName() %s.\r\n",
  2342.              PreOrPost ? "called" : "returned");
  2343.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2344.     return(FALSE);
  2345. }
  2346.  
  2347.  
  2348. BOOL CALLBACK
  2349. DTHandler_WSPIoctl(
  2350.     IN     va_list vl,
  2351.     IN OUT LPVOID  ReturnValue,
  2352.     IN     LPSTR   LibraryName,
  2353.     OUT    char    *Buffer,
  2354.     IN     int     Index,
  2355.     IN     int     BufLen,
  2356.     IN     BOOL    PreOrPost)
  2357. {
  2358.     INT *RetVal = (INT *)ReturnValue;
  2359.     SOCKET *s = va_arg(vl, SOCKET *);
  2360.     DWORD *dwIoControlCode = va_arg(vl, DWORD *);
  2361.     LPVOID *lpvInBuffer = va_arg(vl, LPVOID *);
  2362.     DWORD *cbInBuffer = va_arg(vl, DWORD *);
  2363.     LPVOID *lpvOutBuffer = va_arg(vl, LPVOID *);
  2364.     DWORD *cbOutBuffer = va_arg(vl, DWORD *);
  2365.     LPDWORD *lpcbBytesReturned = va_arg(vl, LPDWORD *);
  2366.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  2367.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  2368.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  2369.     LPWSATHREADID *lpThreadId = va_arg(vl, LPWSATHREADID *);
  2370.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2371.  
  2372.     wsprintf(Buffer + Index, "WSPIoctl() %s.\r\n",
  2373.              PreOrPost ? "called" : "returned");
  2374.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2375.     return(FALSE);
  2376. }
  2377.  
  2378.  
  2379. BOOL CALLBACK
  2380. DTHandler_WSPJoinLeaf(
  2381.     IN     va_list vl,
  2382.     IN OUT LPVOID  ReturnValue,
  2383.     IN     LPSTR   LibraryName,
  2384.     OUT    char    *Buffer,
  2385.     IN     int     Index,
  2386.     IN     int     BufLen,
  2387.     IN     BOOL    PreOrPost)
  2388. {
  2389.     INT *RetVal = (INT *)ReturnValue;
  2390.     SOCKET *s = va_arg(vl, SOCKET *);
  2391.     struct sockaddr FAR **name = va_arg(vl, struct sockaddr FAR **);
  2392.     INT *namelen = va_arg(vl, INT *);
  2393.     LPWSABUF *lpCallerData = va_arg(vl, LPWSABUF *);
  2394.     LPWSABUF *lpCalleeData = va_arg(vl, LPWSABUF *);
  2395.     LPQOS *lpSQOS = va_arg(vl, LPQOS *);
  2396.     LPQOS *lpGQOS = va_arg(vl, LPQOS *);
  2397.     DWORD *dwFlags = va_arg(vl, DWORD *);
  2398.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2399.  
  2400.     wsprintf(Buffer + Index, "WSPJoinLeaf() %s.\r\n",
  2401.              PreOrPost ? "called" : "returned");
  2402.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2403.     return(FALSE);
  2404. }
  2405.  
  2406.  
  2407. BOOL CALLBACK
  2408. DTHandler_WSPListen(
  2409.     IN     va_list vl,
  2410.     IN OUT LPVOID  ReturnValue,
  2411.     IN     LPSTR   LibraryName,
  2412.     OUT    char    *Buffer,
  2413.     IN     int     Index,
  2414.     IN     int     BufLen,
  2415.     IN     BOOL    PreOrPost)
  2416. {
  2417.     INT *RetVal = (INT *)ReturnValue;
  2418.     SOCKET *s = va_arg(vl, SOCKET *);
  2419.     INT *backlog = va_arg(vl, INT *);
  2420.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2421.  
  2422.     wsprintf(Buffer + Index, "WSPListen() %s.\r\n",
  2423.              PreOrPost ? "called" : "returned");
  2424.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2425.     return(FALSE);
  2426. }
  2427.  
  2428.  
  2429. BOOL CALLBACK
  2430. DTHandler_WSPRecv(
  2431.     IN     va_list vl,
  2432.     IN OUT LPVOID  ReturnValue,
  2433.     IN     LPSTR   LibraryName,
  2434.     OUT    char    *Buffer,
  2435.     IN     int     Index,
  2436.     IN     int     BufLen,
  2437.     IN     BOOL    PreOrPost)
  2438. {
  2439.     INT *RetVal = (INT *)ReturnValue;
  2440.     SOCKET *s = va_arg(vl, SOCKET *);
  2441.     LPWSABUF *lpBuffers = va_arg(vl, LPWSABUF *);
  2442.     DWORD *dwBufferCount = va_arg(vl, DWORD *);
  2443.     LPDWORD *lpNumberOfBytesRecvd = va_arg(vl, LPDWORD *);
  2444.     LPDWORD *lpFlags = va_arg(vl, LPDWORD *);
  2445.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  2446.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  2447.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  2448.     LPWSATHREADID *lpThreadId = va_arg(vl, LPWSATHREADID *);
  2449.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2450.  
  2451.     wsprintf(Buffer + Index, "WSPRecv() %s.\r\n",
  2452.              PreOrPost ? "called" : "returned");
  2453.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2454.     return(FALSE);
  2455. }
  2456.  
  2457.  
  2458. BOOL CALLBACK
  2459. DTHandler_WSPRecvDisconnect(
  2460.     IN     va_list vl,
  2461.     IN OUT LPVOID  ReturnValue,
  2462.     IN     LPSTR   LibraryName,
  2463.     OUT    char    *Buffer,
  2464.     IN     int     Index,
  2465.     IN     int     BufLen,
  2466.     IN     BOOL    PreOrPost)
  2467. {
  2468.     INT *RetVal = (INT *)ReturnValue;
  2469.     SOCKET *s = va_arg(vl, SOCKET *);
  2470.     LPWSABUF *lpInboundDisconnectData = va_arg(vl, LPWSABUF *);
  2471.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2472.  
  2473.     wsprintf(Buffer + Index, "WSPRecvDisconnect() %s.\r\n",
  2474.              PreOrPost ? "called" : "returned");
  2475.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2476.     return(FALSE);
  2477. }
  2478.  
  2479.  
  2480. BOOL CALLBACK
  2481. DTHandler_WSPRecvFrom(
  2482.     IN     va_list vl,
  2483.     IN OUT LPVOID  ReturnValue,
  2484.     IN     LPSTR   LibraryName,
  2485.     OUT    char    *Buffer,
  2486.     IN     int     Index,
  2487.     IN     int     BufLen,
  2488.     IN     BOOL    PreOrPost)
  2489. {
  2490.     INT *RetVal = (INT *)ReturnValue;
  2491.     SOCKET *s = va_arg(vl, SOCKET *);
  2492.     LPWSABUF *lpBuffers = va_arg(vl, LPWSABUF *);
  2493.     DWORD *dwBufferCount = va_arg(vl, DWORD *);
  2494.     LPDWORD *lpNumberOfBytesRecvd = va_arg(vl, LPDWORD *);
  2495.     LPDWORD *lpFlags = va_arg(vl, LPDWORD *);
  2496.     struct sockaddr FAR **lpFrom = va_arg(vl, struct sockaddr FAR **);
  2497.     LPINT *lpFromlen = va_arg(vl, LPINT *);
  2498.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  2499.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  2500.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  2501.     LPWSATHREADID *lpThreadId = va_arg(vl, LPWSATHREADID *);
  2502.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2503.  
  2504.     wsprintf(Buffer + Index, "WSPRecvFrom() %s.\r\n",
  2505.              PreOrPost ? "called" : "returned");
  2506.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2507.     return(FALSE);
  2508. }
  2509.  
  2510.  
  2511. BOOL CALLBACK
  2512. DTHandler_WSPSelect(
  2513.     IN     va_list vl,
  2514.     IN OUT LPVOID  ReturnValue,
  2515.     IN     LPSTR   LibraryName,
  2516.     OUT    char    *Buffer,
  2517.     IN     int     Index,
  2518.     IN     int     BufLen,
  2519.     IN     BOOL    PreOrPost)
  2520. {
  2521.     INT *RetVal = (INT *)ReturnValue;
  2522.     INT *nfds = va_arg(vl, INT *);
  2523.     fd_set FAR **readfds = va_arg(vl, fd_set FAR **);
  2524.     fd_set FAR **writefds = va_arg(vl, fd_set FAR **);
  2525.     fd_set FAR **exceptfds = va_arg(vl, fd_set FAR **);
  2526.     struct timeval FAR **timeout = va_arg(vl, struct timeval FAR **);
  2527.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2528.  
  2529.     wsprintf(Buffer + Index, "WSPSelect() %s.\r\n",
  2530.              PreOrPost ? "called" : "returned");
  2531.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2532.     return(FALSE);
  2533. }
  2534.  
  2535.  
  2536. BOOL CALLBACK
  2537. DTHandler_WSPSend(
  2538.     IN     va_list vl,
  2539.     IN OUT LPVOID  ReturnValue,
  2540.     IN     LPSTR   LibraryName,
  2541.     OUT    char    *Buffer,
  2542.     IN     int     Index,
  2543.     IN     int     BufLen,
  2544.     IN     BOOL    PreOrPost)
  2545. {
  2546.     INT *RetVal = (INT *)ReturnValue;
  2547.     SOCKET *s = va_arg(vl, SOCKET *);
  2548.     LPWSABUF *lpBuffers = va_arg(vl, LPWSABUF *);
  2549.     DWORD *dwBufferCount = va_arg(vl, DWORD *);
  2550.     LPDWORD *lpNumberOfBytesSent = va_arg(vl, LPDWORD *);
  2551.     DWORD *dwFlags = va_arg(vl, DWORD *);
  2552.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  2553.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  2554.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  2555.     LPWSATHREADID *lpThreadId = va_arg(vl, LPWSATHREADID *);
  2556.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2557.  
  2558.     wsprintf(Buffer + Index, "WSPSend() %s.\r\n",
  2559.              PreOrPost ? "called" : "returned");
  2560.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2561.     return(FALSE);
  2562. }
  2563.  
  2564.  
  2565. BOOL CALLBACK
  2566. DTHandler_WSPSendDisconnect(
  2567.     IN     va_list vl,
  2568.     IN OUT LPVOID  ReturnValue,
  2569.     IN     LPSTR   LibraryName,
  2570.     OUT    char    *Buffer,
  2571.     IN     int     Index,
  2572.     IN     int     BufLen,
  2573.     IN     BOOL    PreOrPost)
  2574. {
  2575.     INT *RetVal = (INT *)ReturnValue;
  2576.     SOCKET *s = va_arg(vl, SOCKET *);
  2577.     LPWSABUF *lpOutboundDisconnectData = va_arg(vl, LPWSABUF *);
  2578.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2579.  
  2580.     wsprintf(Buffer + Index, "WSPSendDisconnect() %s.\r\n",
  2581.              PreOrPost ? "called" : "returned");
  2582.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2583.     return(FALSE);
  2584. }
  2585.  
  2586.  
  2587. BOOL CALLBACK
  2588. DTHandler_WSPSendTo(
  2589.     IN     va_list vl,
  2590.     IN OUT LPVOID  ReturnValue,
  2591.     IN     LPSTR   LibraryName,
  2592.     OUT    char    *Buffer,
  2593.     IN     int     Index,
  2594.     IN     int     BufLen,
  2595.     IN     BOOL    PreOrPost)
  2596. {
  2597.     INT *RetVal = (INT *)ReturnValue;
  2598.     SOCKET *s = va_arg(vl, SOCKET *);
  2599.     LPWSABUF *lpBuffers = va_arg(vl, LPWSABUF *);
  2600.     DWORD *dbBufferCount = va_arg(vl, DWORD *);
  2601.     LPDWORD *lpNumberOfBytesSent = va_arg(vl, LPDWORD *);
  2602.     DWORD *dwFlags = va_arg(vl, DWORD *);
  2603.     struct sockaddr FAR **lpTo = va_arg(vl, struct sockaddr FAR **);
  2604.     INT *iTolen = va_arg(vl, INT *);
  2605.     LPWSAOVERLAPPED *lpOverlapped = va_arg(vl, LPWSAOVERLAPPED *);
  2606.     LPWSAOVERLAPPED_COMPLETION_ROUTINE *lpCompletionRoutine =
  2607.       va_arg(vl, LPWSAOVERLAPPED_COMPLETION_ROUTINE *);
  2608.     LPWSATHREADID *lpThreadId = va_arg(vl, LPWSATHREADID *);
  2609.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2610.  
  2611.     wsprintf(Buffer + Index, "WSPSendTo() %s.\r\n",
  2612.              PreOrPost ? "called" : "returned");
  2613.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2614.     return(FALSE);
  2615. }
  2616.  
  2617.  
  2618. BOOL CALLBACK
  2619. DTHandler_WSPSetSockOpt(
  2620.     IN     va_list vl,
  2621.     IN OUT LPVOID  ReturnValue,
  2622.     IN     LPSTR   LibraryName,
  2623.     OUT    char    *Buffer,
  2624.     IN     int     Index,
  2625.     IN     int     BufLen,
  2626.     IN     BOOL    PreOrPost)
  2627. {
  2628.     INT *RetVal = (INT *)ReturnValue;
  2629.     SOCKET *s = va_arg(vl, SOCKET *);
  2630.     INT *level = va_arg(vl, INT *);
  2631.     INT *optname = va_arg(vl, INT *);
  2632.     char FAR **optval = va_arg(vl, char FAR **);
  2633.     INT *optlen = va_arg(vl, INT *);
  2634.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2635.  
  2636.     wsprintf(Buffer + Index, "WSPSetSockOpt() %s.\r\n",
  2637.              PreOrPost ? "called" : "returned");
  2638.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2639.     return(FALSE);
  2640. }
  2641.  
  2642.  
  2643. BOOL CALLBACK
  2644. DTHandler_WSPShutdown(
  2645.     IN     va_list vl,
  2646.     IN OUT LPVOID  ReturnValue,
  2647.     IN     LPSTR   LibraryName,
  2648.     OUT    char    *Buffer,
  2649.     IN     int     Index,
  2650.     IN     int     BufLen,
  2651.     IN     BOOL    PreOrPost)
  2652. {
  2653.     INT *RetVal = (INT *)ReturnValue;
  2654.     SOCKET *s = va_arg(vl, SOCKET *);
  2655.     INT *how = va_arg(vl, INT *);
  2656.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2657.  
  2658.     wsprintf(Buffer + Index, "WSPShutdown() %s.\r\n",
  2659.              PreOrPost ? "called" : "returned");
  2660.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2661.     return(FALSE);
  2662. }
  2663.  
  2664.  
  2665. BOOL CALLBACK
  2666. DTHandler_WSPSocket(
  2667.     IN     va_list vl,
  2668.     IN OUT LPVOID  ReturnValue,
  2669.     IN     LPSTR   LibraryName,
  2670.     OUT    char    *Buffer,
  2671.     IN     int     Index,
  2672.     IN     int     BufLen,
  2673.     IN     BOOL    PreOrPost)
  2674. {
  2675.     INT *RetVal = (INT *)ReturnValue;
  2676.     int *af = va_arg(vl, int *);
  2677.     int *type = va_arg(vl, int *);
  2678.     int *protocol = va_arg(vl, int *);
  2679.     LPWSAPROTOCOL_INFO *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFO *);
  2680.     GROUP *g = va_arg(vl, GROUP *);
  2681.     DWORD *dwFlags = va_arg(vl, DWORD *);
  2682.     INT FAR **lpErrno = va_arg(vl, INT FAR **);
  2683.  
  2684.     wsprintf(Buffer + Index, "WSPSocket() %s.\r\n",
  2685.              PreOrPost ? "called" : "returned");
  2686.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2687.     return(FALSE);
  2688. }
  2689.  
  2690.  
  2691. BOOL CALLBACK
  2692. DTHandler_WSPStartup(
  2693.     IN     va_list vl,
  2694.     IN OUT LPVOID  ReturnValue,
  2695.     IN     LPSTR   LibraryName,
  2696.     OUT    char    *Buffer,
  2697.     IN     int     Index,
  2698.     IN     int     BufLen,
  2699.     IN     BOOL    PreOrPost)
  2700. {
  2701.     int *RetVal = (int *)ReturnValue;
  2702.     WORD *wVersionRequested = va_arg(vl, WORD *);
  2703.     LPWSPDATA *lpWSPData = va_arg(vl, LPWSPDATA *);
  2704.     LPWSAPROTOCOL_INFOA *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFOA *);
  2705.     WSPUPCALLTABLE *UpcallTable = va_arg(vl, WSPUPCALLTABLE *);
  2706.     LPWSPPROC_TABLE *lpProcTable = va_arg(vl, LPWSPPROC_TABLE *);
  2707.  
  2708.     wsprintf(Buffer + Index, "WSPStartup() %s.\r\n",
  2709.              PreOrPost ? "called" : "returned");
  2710.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2711.     return(FALSE);
  2712. }
  2713.  
  2714.  
  2715. BOOL CALLBACK
  2716. DTHandler_WPUCloseEvent(
  2717.     IN     va_list vl,
  2718.     IN OUT LPVOID  ReturnValue,
  2719.     IN     LPSTR   LibraryName,
  2720.     OUT    char    *Buffer,
  2721.     IN     int     Index,
  2722.     IN     int     BufLen,
  2723.     IN     BOOL    PreOrPost)
  2724. {
  2725.     BOOL *RetVal = (BOOL *)ReturnValue;
  2726.     WSAEVENT *hEvent = va_arg(vl, WSAEVENT *);
  2727.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2728.  
  2729.     wsprintf(Buffer + Index, "WPUCloseEvent() %s.\r\n",
  2730.              PreOrPost ? "called" : "returned");
  2731.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2732.     return(FALSE);
  2733. }
  2734.  
  2735.  
  2736. BOOL CALLBACK
  2737. DTHandler_WPUCloseSocketHandle(
  2738.     IN     va_list vl,
  2739.     IN OUT LPVOID  ReturnValue,
  2740.     IN     LPSTR   LibraryName,
  2741.     OUT    char    *Buffer,
  2742.     IN     int     Index,
  2743.     IN     int     BufLen,
  2744.     IN     BOOL    PreOrPost)
  2745. {
  2746.     int *RetVal = (int *)ReturnValue;
  2747.     SOCKET *s = va_arg(vl, SOCKET *);
  2748.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2749.  
  2750.     wsprintf(Buffer + Index, "WPUCloseSocketHandle() %s.\r\n",
  2751.              PreOrPost ? "called" : "returned");
  2752.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2753.     return(FALSE);
  2754. }
  2755.  
  2756.  
  2757. BOOL CALLBACK
  2758. DTHandler_WPUCreateEvent(
  2759.     IN     va_list vl,
  2760.     IN OUT LPVOID  ReturnValue,
  2761.     IN     LPSTR   LibraryName,
  2762.     OUT    char    *Buffer,
  2763.     IN     int     Index,
  2764.     IN     int     BufLen,
  2765.     IN     BOOL    PreOrPost)
  2766. {
  2767.     WSAEVENT *RetVal = (WSAEVENT *)ReturnValue;
  2768.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2769.  
  2770.     wsprintf(Buffer + Index, "WPUCreateEvent() %s.\r\n",
  2771.              PreOrPost ? "called" : "returned");
  2772.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2773.     return(FALSE);
  2774. }
  2775.  
  2776.  
  2777. BOOL CALLBACK
  2778. DTHandler_WPUCreateSocketHandle(
  2779.     IN     va_list vl,
  2780.     IN OUT LPVOID  ReturnValue,
  2781.     IN     LPSTR   LibraryName,
  2782.     OUT    char    *Buffer,
  2783.     IN     int     Index,
  2784.     IN     int     BufLen,
  2785.     IN     BOOL    PreOrPost)
  2786. {
  2787.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  2788.     DWORD *dwCatalogEntryId = va_arg(vl, DWORD *);
  2789.     DWORD *dwContext = va_arg(vl, DWORD *);
  2790.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2791.  
  2792.     wsprintf(Buffer + Index, "WPUCreateSocketHandle() %s.\r\n",
  2793.              PreOrPost ? "called" : "returned");
  2794.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2795.     return(FALSE);
  2796. }
  2797.  
  2798.  
  2799. BOOL CALLBACK
  2800. DTHandler_WSCDeinstallProvider(
  2801.     IN     va_list vl,
  2802.     IN OUT LPVOID  ReturnValue,
  2803.     IN     LPSTR   LibraryName,
  2804.     OUT    char    *Buffer,
  2805.     IN     int     Index,
  2806.     IN     int     BufLen,
  2807.     IN     BOOL    PreOrPost)
  2808. {
  2809.     int *RetVal = (int *)ReturnValue;
  2810.     DWORD *dwProviderId = va_arg(vl, DWORD *);
  2811.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2812.  
  2813.     wsprintf(Buffer + Index, "WSCDeinstallProvider() %s.\r\n",
  2814.              PreOrPost ? "called" : "returned");
  2815.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2816.     return(FALSE);
  2817. }
  2818.  
  2819.  
  2820. BOOL CALLBACK
  2821. DTHandler_WSCInstallProvider(
  2822.     IN     va_list vl,
  2823.     IN OUT LPVOID  ReturnValue,
  2824.     IN     LPSTR   LibraryName,
  2825.     OUT    char    *Buffer,
  2826.     IN     int     Index,
  2827.     IN     int     BufLen,
  2828.     IN     BOOL    PreOrPost)
  2829. {
  2830.     int *RetVal = (int *)ReturnValue;
  2831.     char FAR **lpszProviderName = va_arg(vl, char FAR **);
  2832.     char FAR **lpszProviderDllPath = va_arg(vl, char FAR **);
  2833.     LPWSAPROTOCOL_INFO *lpProtocolInfoList = va_arg(vl, LPWSAPROTOCOL_INFO *);
  2834.     DWORD *dwNumberOfEntries = va_arg(vl, DWORD *);
  2835.     LPDWORD *lpdwProviderId = va_arg(vl, LPDWORD *);
  2836.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2837.  
  2838.     wsprintf(Buffer + Index, "WSCInstallProvider() %s.\r\n",
  2839.          PreOrPost ? "called" : "returned");
  2840.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2841.     return(FALSE);
  2842. }
  2843.  
  2844.  
  2845. BOOL CALLBACK
  2846. DTHandler_WPUModifyIFSHandle(
  2847.     IN     va_list vl,
  2848.     IN OUT LPVOID  ReturnValue,
  2849.     IN     LPSTR   LibraryName,
  2850.     OUT    char    *Buffer,
  2851.     IN     int     Index,
  2852.     IN     int     BufLen,
  2853.     IN     BOOL    PreOrPost)
  2854. {
  2855.     SOCKET *RetVal = (SOCKET *)ReturnValue;
  2856.     DWORD *dwCatalogEntryId = va_arg(vl, DWORD *);
  2857.     SOCKET *ProposedHandle = va_arg(vl, SOCKET *);
  2858.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2859.  
  2860.     wsprintf(Buffer + Index, "WPUModifyIFSHandle() %s.\r\n",
  2861.              PreOrPost ? "called" : "returned");
  2862.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2863.     return(FALSE);
  2864. }
  2865.  
  2866.  
  2867. BOOL CALLBACK
  2868. DTHandler_WPUQueryBlockingCallback(
  2869.     IN     va_list vl,
  2870.     IN OUT LPVOID  ReturnValue,
  2871.     IN     LPSTR   LibraryName,
  2872.     OUT    char    *Buffer,
  2873.     IN     int     Index,
  2874.     IN     int     BufLen,
  2875.     IN     BOOL    PreOrPost)
  2876. {
  2877.     int *RetVal = (int *)ReturnValue;
  2878.     DWORD *dwCatalogEntryId = va_arg(vl, DWORD *);
  2879.     LPBLOCKINGCALLBACK FAR **lplpfnCallback =
  2880.       va_arg(vl, LPBLOCKINGCALLBACK FAR **);
  2881.     LPDWORD *lpdwContext = va_arg(vl, LPDWORD *);
  2882.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2883.  
  2884.     wsprintf(Buffer + Index, "WPUQueryBlockingCallback() %s.\r\n",
  2885.              PreOrPost ? "called" : "returned");
  2886.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2887.     return(FALSE);
  2888. }
  2889.  
  2890.  
  2891. BOOL CALLBACK
  2892. DTHandler_WPUQuerySocketHandleContext(
  2893.     IN     va_list vl,
  2894.     IN OUT LPVOID  ReturnValue,
  2895.     IN     LPSTR   LibraryName,
  2896.     OUT    char    *Buffer,
  2897.     IN     int     Index,
  2898.     IN     int     BufLen,
  2899.     IN     BOOL    PreOrPost)
  2900. {
  2901.     int *RetVal = (int *)ReturnValue;
  2902.     SOCKET *s = va_arg(vl, SOCKET *);
  2903.     LPDWORD *lpContext = va_arg(vl, LPDWORD *);
  2904.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2905.  
  2906.     wsprintf(Buffer + Index, "WPUQuerySocketHandleContext() %s.\r\n",
  2907.              PreOrPost ? "called" : "returned");
  2908.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2909.     return(FALSE);
  2910. }
  2911.  
  2912.  
  2913. BOOL CALLBACK
  2914. DTHandler_WPUQueueApc(
  2915.     IN     va_list vl,
  2916.     IN OUT LPVOID  ReturnValue,
  2917.     IN     LPSTR   LibraryName,
  2918.     OUT    char    *Buffer,
  2919.     IN     int     Index,
  2920.     IN     int     BufLen,
  2921.     IN     BOOL    PreOrPost)
  2922. {
  2923.     int *RetVal = (int *)ReturnValue;
  2924.     LPWSATHREADID *lpThreadId = va_arg(vl, LPWSATHREADID *);
  2925.     LPWSAUSERAPC *lpfnUserApc = va_arg(vl, LPWSAUSERAPC *);
  2926.     DWORD *dwContext = va_arg(vl, DWORD *);
  2927.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2928.  
  2929.     wsprintf(Buffer + Index, "WPUQueueApc() %s.\r\n",
  2930.              PreOrPost ? "called" : "returned");
  2931.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2932.     return(FALSE);
  2933. }
  2934.  
  2935.  
  2936. BOOL CALLBACK
  2937. DTHandler_WPUResetEvent(
  2938.     IN     va_list vl,
  2939.     IN OUT LPVOID  ReturnValue,
  2940.     IN     LPSTR   LibraryName,
  2941.     OUT    char    *Buffer,
  2942.     IN     int     Index,
  2943.     IN     int     BufLen,
  2944.     IN     BOOL    PreOrPost)
  2945. {
  2946.     BOOL *RetVal = (BOOL *)ReturnValue;
  2947.     WSAEVENT *hEvent = va_arg(vl, WSAEVENT *);
  2948.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2949.  
  2950.     wsprintf(Buffer + Index, "WPUResetEvent() %s.\r\n",
  2951.              PreOrPost ? "called" : "returned");
  2952.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2953.     return(FALSE);
  2954. }
  2955.  
  2956.  
  2957. BOOL CALLBACK
  2958. DTHandler_WPUSetEvent(
  2959.     IN     va_list vl,
  2960.     IN OUT LPVOID  ReturnValue,
  2961.     IN     LPSTR   LibraryName,
  2962.     OUT    char    *Buffer,
  2963.     IN     int     Index,
  2964.     IN     int     BufLen,
  2965.     IN     BOOL    PreOrPost)
  2966. {
  2967.     BOOL *RetVal = (BOOL *)ReturnValue;
  2968.     WSAEVENT *hEvent = va_arg(vl, WSAEVENT *);
  2969.     LPINT *lpErrno = va_arg(vl, LPINT *);
  2970.  
  2971.     wsprintf(Buffer + Index, "WPUSetEvent() %s.\r\n",
  2972.              PreOrPost ? "called" : "returned");
  2973.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2974.     return(FALSE);
  2975. }
  2976.  
  2977.  
  2978.  
  2979. BOOL CALLBACK
  2980. DTHandler_WPUFDIsSet(
  2981.     IN     va_list vl,
  2982.     IN OUT LPVOID  ReturnValue,
  2983.     IN     LPSTR   LibraryName,
  2984.     OUT    char    *Buffer,
  2985.     IN     int     Index,
  2986.     IN     int     BufLen,
  2987.     IN     BOOL    PreOrPost)
  2988. {
  2989.     int *RetVal = (int *)ReturnValue;
  2990.     SOCKET *s = va_arg(vl, SOCKET *);
  2991.     fd_set FAR **set = va_arg(vl, fd_set FAR **);
  2992.  
  2993.     wsprintf(Buffer + Index, "WPUFDIsSet() %s.\r\n",
  2994.              PreOrPost ? "called" : "returned");
  2995.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  2996.     return(FALSE);
  2997. }
  2998.  
  2999.  
  3000. BOOL CALLBACK
  3001. DTHandler_WPUGetProviderPath(
  3002.     IN     va_list vl,
  3003.     IN OUT LPVOID  ReturnValue,
  3004.     IN     LPSTR   LibraryName,
  3005.     OUT    char    *Buffer,
  3006.     IN     int     Index,
  3007.     IN     int     BufLen,
  3008.     IN     BOOL    PreOrPost)
  3009. {
  3010.     int *RetVal = (int *)ReturnValue;
  3011.     DWORD *dwProviderId = va_arg(vl, DWORD *);
  3012.     char FAR **lpszProviderDllPath = va_arg(vl, char FAR **);
  3013.     LPINT *lpProviderDllPathLen = va_arg(vl, LPINT *);
  3014.     LPINT *lpErrno = va_arg(vl, LPINT *);
  3015.  
  3016.     wsprintf(Buffer + Index, "WPUGetProviderPath() %s.\r\n",
  3017.              PreOrPost ? "called" : "returned");
  3018.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3019.     return(FALSE);
  3020. }
  3021.  
  3022.  
  3023. BOOL CALLBACK
  3024. DTHandler_WPUPostMessage(
  3025.     IN     va_list vl,
  3026.     IN OUT LPVOID  ReturnValue,
  3027.     IN     LPSTR   LibraryName,
  3028.     OUT    char    *Buffer,
  3029.     IN     int     Index,
  3030.     IN     int     BufLen,
  3031.     IN     BOOL    PreOrPost)
  3032. {
  3033.     BOOL *RetVal = (BOOL *)ReturnValue;
  3034.     HWND *hWnd = va_arg(vl, HWND *);
  3035.     UINT *Msg = va_arg(vl, UINT *);
  3036.     WPARAM *wParam = va_arg(vl, WPARAM *);
  3037.     LPARAM *lParam = va_arg(vl, LPARAM *);
  3038.  
  3039.     wsprintf(Buffer + Index, "WPUPostMessage() %s.\r\n",
  3040.              PreOrPost ? "called" : "returned");
  3041.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3042.     return(FALSE);
  3043. }
  3044.  
  3045.  
  3046. BOOL CALLBACK
  3047. DTHandler_WSCEnumProtocols(
  3048.     IN     va_list vl,
  3049.     IN OUT LPVOID  ReturnValue,
  3050.     IN     LPSTR   LibraryName,
  3051.     OUT    char    *Buffer,
  3052.     IN     int     Index,
  3053.     IN     int     BufLen,
  3054.     IN     BOOL    PreOrPost)
  3055. {
  3056.     int *RetVal = (int *)ReturnValue;
  3057.     LPINT *lpiProtocols = va_arg(vl, LPINT *);
  3058.     LPWSAPROTOCOL_INFO *lpProtocolBuffer = va_arg(vl, LPWSAPROTOCOL_INFO *);
  3059.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD *);
  3060.     LPINT *lpErrno = va_arg(vl, LPINT *);
  3061.  
  3062.     wsprintf(Buffer + Index, "WSCEnumProtocols() %s.\r\n",
  3063.              PreOrPost ? "called" : "returned");
  3064.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3065.     return(FALSE);
  3066. }
  3067.  
  3068.  
  3069. BOOL CALLBACK
  3070. DTHandler___WSAFDIsSet(
  3071.     IN     va_list vl,
  3072.     IN OUT LPVOID  ReturnValue,
  3073.     IN     LPSTR   LibraryName,
  3074.     OUT    char    *Buffer,
  3075.     IN     int     Index,
  3076.     IN     int     BufLen,
  3077.     IN     BOOL    PreOrPost)
  3078. {
  3079.     int *RetVal = (int *)ReturnValue;
  3080.     SOCKET *s = va_arg(vl, SOCKET *);
  3081.     fd_set FAR **set = va_arg(vl, fd_set FAR **);
  3082.  
  3083.     wsprintf(Buffer + Index, "__WSAFDIsSet() %s.\r\n",
  3084.              PreOrPost ? "called" : "returned");
  3085.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3086.     return(FALSE);
  3087. }
  3088.  
  3089.  
  3090. BOOL CALLBACK
  3091. DTHandler_WSAAddressToStringA(
  3092.     IN     va_list vl,
  3093.     IN OUT LPVOID  ReturnValue,
  3094.     IN     LPSTR   LibraryName,
  3095.     OUT    char    *Buffer,
  3096.     IN     int     Index,
  3097.     IN     int     BufLen,
  3098.     IN     BOOL    PreOrPost)
  3099. {
  3100.     int *RetVal = (int *)ReturnValue;
  3101.     LPSOCKADDR *lpsaAddress = va_arg(vl, LPSOCKADDR *);
  3102.     DWORD *dwAddressLength= va_arg(vl, DWORD *);
  3103.     LPWSAPROTOCOL_INFOA *lpProtocolInfo= va_arg(vl, LPWSAPROTOCOL_INFOA *);
  3104.     LPSTR *lpszAddressString= va_arg(vl, LPSTR *);
  3105.     LPDWORD *lpdwAddressStringLength= va_arg(vl, LPDWORD *);
  3106.  
  3107.     wsprintf(Buffer + Index, "WSAAddressToStringA() %s.\r\n",
  3108.              PreOrPost ? "called" : "returned");
  3109.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3110.     return(FALSE);
  3111. }
  3112.  
  3113.  
  3114.  
  3115. BOOL CALLBACK
  3116. DTHandler_WSAAddressToStringW(
  3117.     IN     va_list vl,
  3118.     IN OUT LPVOID  ReturnValue,
  3119.     IN     LPSTR   LibraryName,
  3120.     OUT    char    *Buffer,
  3121.     IN     int     Index,
  3122.     IN     int     BufLen,
  3123.     IN     BOOL    PreOrPost)
  3124. {
  3125.     int *RetVal = (int *)ReturnValue;
  3126.     LPSOCKADDR *lpsaAddress = va_arg(vl, LPSOCKADDR *);
  3127.     DWORD *dwAddressLength= va_arg(vl, DWORD *);
  3128.     LPWSAPROTOCOL_INFOW *lpProtocolInfo= va_arg(vl, LPWSAPROTOCOL_INFOW *);
  3129.     LPWSTR *lpszAddressString= va_arg(vl, LPWSTR *);
  3130.     LPDWORD *lpdwAddressStringLength= va_arg(vl, LPDWORD *);
  3131.  
  3132.     wsprintf(Buffer + Index, "WSAAddressToStringW() %s.\r\n",
  3133.              PreOrPost ? "called" : "returned");
  3134.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3135.     return(FALSE);
  3136. }
  3137.  
  3138.  
  3139.  
  3140. BOOL CALLBACK
  3141. DTHandler_WSAStringToAddressA(
  3142.     IN     va_list vl,
  3143.     IN OUT LPVOID  ReturnValue,
  3144.     IN     LPSTR   LibraryName,
  3145.     OUT    char    *Buffer,
  3146.     IN     int     Index,
  3147.     IN     int     BufLen,
  3148.     IN     BOOL    PreOrPost)
  3149. {
  3150.     int *RetVal = (int *)ReturnValue;
  3151.     LPSTR *AddressString = va_arg(vl, LPSTR*);
  3152.     INT *AddressFamily = va_arg(vl, INT *);
  3153.     LPWSAPROTOCOL_INFOA *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFOA*);
  3154.     LPSOCKADDR *lpAddress = va_arg(vl, LPSOCKADDR*);
  3155.     LPINT *lpAddressLength = va_arg(vl, LPINT*);
  3156.  
  3157.     wsprintf(Buffer + Index, "WSAStringToAddressA() %s.\r\n",
  3158.              PreOrPost ? "called" : "returned");
  3159.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3160.     return(FALSE);
  3161. }
  3162.  
  3163.  
  3164. BOOL CALLBACK
  3165. DTHandler_WSAStringToAddressW(
  3166.     IN     va_list vl,
  3167.     IN OUT LPVOID  ReturnValue,
  3168.     IN     LPSTR   LibraryName,
  3169.     OUT    char    *Buffer,
  3170.     IN     int     Index,
  3171.     IN     int     BufLen,
  3172.     IN     BOOL    PreOrPost)
  3173. {
  3174.     int *RetVal = (int *)ReturnValue;
  3175.     LPWSTR *AddressString = va_arg(vl, LPWSTR*);
  3176.     INT *AddressFamily = va_arg(vl, INT *);
  3177.     LPWSAPROTOCOL_INFOW *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFOW*);
  3178.     LPSOCKADDR *lpAddress = va_arg(vl, LPSOCKADDR*);
  3179.     LPINT *lpAddressLength = va_arg(vl, LPINT*);
  3180.  
  3181.     wsprintf(Buffer + Index, "WSAStringToAddressW() %s.\r\n",
  3182.              PreOrPost ? "called" : "returned");
  3183.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3184.     return(FALSE);
  3185. }
  3186.  
  3187.  
  3188.  
  3189. BOOL CALLBACK
  3190. DTHandler_WSALookupServiceBeginA(
  3191.     IN     va_list vl,
  3192.     IN OUT LPVOID  ReturnValue,
  3193.     IN     LPSTR   LibraryName,
  3194.     OUT    char    *Buffer,
  3195.     IN     int     Index,
  3196.     IN     int     BufLen,
  3197.     IN     BOOL    PreOrPost)
  3198. {
  3199.     int *RetVal = (int *)ReturnValue;
  3200.     LPWSAQUERYSETA *lpqsRestrictions = va_arg(vl, LPWSAQUERYSETA*);
  3201.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3202.     LPHANDLE *lphLookup  = va_arg(vl, LPHANDLE*);
  3203.  
  3204.     wsprintf(Buffer + Index, "WSALookupServiceBeginA() %s.\r\n",
  3205.              PreOrPost ? "called" : "returned");
  3206.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3207.     return(FALSE);
  3208. }
  3209.  
  3210.  
  3211. BOOL CALLBACK
  3212. DTHandler_WSALookupServiceBeginW(
  3213.     IN     va_list vl,
  3214.     IN OUT LPVOID  ReturnValue,
  3215.     IN     LPSTR   LibraryName,
  3216.     OUT    char    *Buffer,
  3217.     IN     int     Index,
  3218.     IN     int     BufLen,
  3219.     IN     BOOL    PreOrPost)
  3220. {
  3221.     int *RetVal = (int *)ReturnValue;
  3222.     LPWSAQUERYSETW *lpqsRestrictions = va_arg(vl, LPWSAQUERYSETW*);
  3223.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3224.     LPHANDLE *lphLookup  = va_arg(vl, LPHANDLE*);
  3225.  
  3226.     wsprintf(Buffer + Index, "WSALookupServiceBeginW() %s.\r\n",
  3227.              PreOrPost ? "called" : "returned");
  3228.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3229.     return(FALSE);
  3230. }
  3231.  
  3232.  
  3233.  
  3234. BOOL CALLBACK
  3235. DTHandler_WSALookupServiceNextA(
  3236.     IN     va_list vl,
  3237.     IN OUT LPVOID  ReturnValue,
  3238.     IN     LPSTR   LibraryName,
  3239.     OUT    char    *Buffer,
  3240.     IN     int     Index,
  3241.     IN     int     BufLen,
  3242.     IN     BOOL    PreOrPost)
  3243. {
  3244.     int *RetVal = (int *)ReturnValue;
  3245.     HANDLE *hLookup = va_arg(vl, HANDLE*);
  3246.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3247.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3248.     LPWSAQUERYSETA *lpqsResults = va_arg(vl, LPWSAQUERYSETA*);
  3249.  
  3250.     wsprintf(Buffer + Index, "WSALookupServiceNextA() %s.\r\n",
  3251.              PreOrPost ? "called" : "returned");
  3252.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3253.     return(FALSE);
  3254. }
  3255.  
  3256.  
  3257. BOOL CALLBACK
  3258. DTHandler_WSALookupServiceNextW(
  3259.     IN     va_list vl,
  3260.     IN OUT LPVOID  ReturnValue,
  3261.     IN     LPSTR   LibraryName,
  3262.     OUT    char    *Buffer,
  3263.     IN     int     Index,
  3264.     IN     int     BufLen,
  3265.     IN     BOOL    PreOrPost)
  3266. {
  3267.     int *RetVal = (int *)ReturnValue;
  3268.     HANDLE *hLookup = va_arg(vl, HANDLE*);
  3269.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3270.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3271.     LPWSAQUERYSETW *lpqsResults = va_arg(vl, LPWSAQUERYSETW*);
  3272.  
  3273.     wsprintf(Buffer + Index, "WSALookupServiceNextW() %s.\r\n",
  3274.              PreOrPost ? "called" : "returned");
  3275.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3276.     return(FALSE);
  3277. }
  3278.  
  3279.  
  3280.  
  3281.  
  3282. BOOL CALLBACK
  3283. DTHandler_WSALookupServiceEnd(
  3284.     IN     va_list vl,
  3285.     IN OUT LPVOID  ReturnValue,
  3286.     IN     LPSTR   LibraryName,
  3287.     OUT    char    *Buffer,
  3288.     IN     int     Index,
  3289.     IN     int     BufLen,
  3290.     IN     BOOL    PreOrPost)
  3291. {
  3292.     int *RetVal = (int *)ReturnValue;
  3293.     HANDLE *hLookup = va_arg(vl, HANDLE*);
  3294.  
  3295.     wsprintf(Buffer + Index, "WSALookupServiceEnd() %s.\r\n",
  3296.              PreOrPost ? "called" : "returned");
  3297.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3298.     return(FALSE);
  3299. }
  3300.  
  3301.  
  3302.  
  3303.  
  3304. BOOL CALLBACK
  3305. DTHandler_WSAGetAddressByNameA(
  3306.     IN     va_list vl,
  3307.     IN OUT LPVOID  ReturnValue,
  3308.     IN     LPSTR   LibraryName,
  3309.     OUT    char    *Buffer,
  3310.     IN     int     Index,
  3311.     IN     int     BufLen,
  3312.     IN     BOOL    PreOrPost)
  3313. {
  3314.     int *RetVal = (int *)ReturnValue;
  3315.     LPSTR *lpszServiceInstanceName = va_arg(vl, LPSTR*);
  3316.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3317.     DWORD *dwNameSpace = va_arg(vl, DWORD*);
  3318.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3319.     LPWSAQUERYSETA *lpqsResults = va_arg(vl, LPWSAQUERYSETA*);
  3320.     DWORD *dwResolution = va_arg(vl, DWORD*);
  3321.     LPSTR *lpszAliasBuffer = va_arg(vl, LPSTR*);
  3322.     LPDWORD *lpdwAliasBufferLength  = va_arg(vl, LPDWORD*);
  3323.  
  3324.     wsprintf(Buffer + Index, "WSAGetAddressByNameA() %s.\r\n",
  3325.              PreOrPost ? "called" : "returned");
  3326.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3327.     return(FALSE);
  3328. }
  3329.  
  3330.  
  3331. BOOL CALLBACK
  3332. DTHandler_WSAGetAddressByNameW(
  3333.     IN     va_list vl,
  3334.     IN OUT LPVOID  ReturnValue,
  3335.     IN     LPSTR   LibraryName,
  3336.     OUT    char    *Buffer,
  3337.     IN     int     Index,
  3338.     IN     int     BufLen,
  3339.     IN     BOOL    PreOrPost)
  3340. {
  3341.     int *RetVal = (int *)ReturnValue;
  3342.     LPWSTR *lpszServiceInstanceName = va_arg(vl, LPWSTR*);
  3343.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3344.     DWORD *dwNameSpace = va_arg(vl, DWORD*);
  3345.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3346.     LPWSAQUERYSETW *lpqsResults = va_arg(vl, LPWSAQUERYSETW*);
  3347.     DWORD *dwResolution = va_arg(vl, DWORD*);
  3348.     LPWSTR *lpszAliasBuffer = va_arg(vl, LPWSTR*);
  3349.     LPDWORD *lpdwAliasBufferLength  = va_arg(vl, LPDWORD*);
  3350.  
  3351.     wsprintf(Buffer + Index, "WSAGetAddressByNameW() %s.\r\n",
  3352.              PreOrPost ? "called" : "returned");
  3353.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3354.     return(FALSE);
  3355. }
  3356.  
  3357.  
  3358.  
  3359.  
  3360. BOOL CALLBACK
  3361. DTHandler_WSAInstallServiceClassA(
  3362.     IN     va_list vl,
  3363.     IN OUT LPVOID  ReturnValue,
  3364.     IN     LPSTR   LibraryName,
  3365.     OUT    char    *Buffer,
  3366.     IN     int     Index,
  3367.     IN     int     BufLen,
  3368.     IN     BOOL    PreOrPost)
  3369. {
  3370.     int *RetVal = (int *)ReturnValue;
  3371.     LPWSASERVICECLASSINFOA *lpServiceClassInfo =
  3372.         va_arg(vl, LPWSASERVICECLASSINFOA*);
  3373.  
  3374.     wsprintf(Buffer + Index, "WSAInstallServiceClassA() %s.\r\n",
  3375.              PreOrPost ? "called" : "returned");
  3376.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3377.     return(FALSE);
  3378. }
  3379.  
  3380.  
  3381. BOOL CALLBACK
  3382. DTHandler_WSAInstallServiceClassW(
  3383.     IN     va_list vl,
  3384.     IN OUT LPVOID  ReturnValue,
  3385.     IN     LPSTR   LibraryName,
  3386.     OUT    char    *Buffer,
  3387.     IN     int     Index,
  3388.     IN     int     BufLen,
  3389.     IN     BOOL    PreOrPost)
  3390. {
  3391.     int *RetVal = (int *)ReturnValue;
  3392.     LPWSASERVICECLASSINFOW *lpServiceClassInfo =
  3393.         va_arg(vl, LPWSASERVICECLASSINFOW*);
  3394.  
  3395.     wsprintf(Buffer + Index, "WSAInstallServiceClassW() %s.\r\n",
  3396.              PreOrPost ? "called" : "returned");
  3397.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3398.     return(FALSE);
  3399. }
  3400.  
  3401.  
  3402.  
  3403. BOOL CALLBACK
  3404. DTHandler_WSASetServiceA(
  3405.     IN     va_list vl,
  3406.     IN OUT LPVOID  ReturnValue,
  3407.     IN     LPSTR   LibraryName,
  3408.     OUT    char    *Buffer,
  3409.     IN     int     Index,
  3410.     IN     int     BufLen,
  3411.     IN     BOOL    PreOrPost)
  3412. {
  3413.     int *RetVal = (int *)ReturnValue;
  3414.     LPWSAQUERYSETA *lpqsRegInfo = va_arg(vl, LPWSAQUERYSETA*);
  3415.     WSAESETSERVICEOP *essOperation = va_arg(vl, WSAESETSERVICEOP*);
  3416.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3417.  
  3418.     wsprintf(Buffer + Index, "WSASetServiceA() %s.\r\n",
  3419.              PreOrPost ? "called" : "returned");
  3420.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3421.     return(FALSE);
  3422. }
  3423.  
  3424.  
  3425.  
  3426. BOOL CALLBACK
  3427. DTHandler_WSASetServiceW(
  3428.     IN     va_list vl,
  3429.     IN OUT LPVOID  ReturnValue,
  3430.     IN     LPSTR   LibraryName,
  3431.     OUT    char    *Buffer,
  3432.     IN     int     Index,
  3433.     IN     int     BufLen,
  3434.     IN     BOOL    PreOrPost)
  3435. {
  3436.     int *RetVal = (int *)ReturnValue;
  3437.     LPWSAQUERYSETW *lpqsRegInfo = va_arg(vl, LPWSAQUERYSETW*);
  3438.     WSAESETSERVICEOP *essOperation = va_arg(vl, WSAESETSERVICEOP*);
  3439.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3440.  
  3441.     wsprintf(Buffer + Index, "WSASetServiceW() %s.\r\n",
  3442.              PreOrPost ? "called" : "returned");
  3443.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3444.     return(FALSE);
  3445. }
  3446.  
  3447.  
  3448.  
  3449. BOOL CALLBACK
  3450. DTHandler_WSARemoveServiceClass(
  3451.     IN     va_list vl,
  3452.     IN OUT LPVOID  ReturnValue,
  3453.     IN     LPSTR   LibraryName,
  3454.     OUT    char    *Buffer,
  3455.     IN     int     Index,
  3456.     IN     int     BufLen,
  3457.     IN     BOOL    PreOrPost)
  3458. {
  3459.     int *RetVal = (int *)ReturnValue;
  3460.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3461.  
  3462.     wsprintf(Buffer + Index, "WSARemoveServiceClass() %s.\r\n",
  3463.              PreOrPost ? "called" : "returned");
  3464.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3465.     return(FALSE);
  3466. }
  3467.  
  3468.  
  3469.  
  3470.  
  3471. BOOL CALLBACK
  3472. DTHandler_WSAGetServiceClassInfoA(
  3473.     IN     va_list vl,
  3474.     IN OUT LPVOID  ReturnValue,
  3475.     IN     LPSTR   LibraryName,
  3476.     OUT    char    *Buffer,
  3477.     IN     int     Index,
  3478.     IN     int     BufLen,
  3479.     IN     BOOL    PreOrPost)
  3480. {
  3481.     int *RetVal = (int *)ReturnValue;
  3482.     LPGUID *lpProviderId = va_arg(vl, LPGUID*);
  3483.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3484.     LPDWORD *lpdwBufSize = va_arg(vl, LPDWORD*);
  3485.     LPWSASERVICECLASSINFOA *lpServiceClassInfo =
  3486.         va_arg(vl, LPWSASERVICECLASSINFOA*);
  3487.  
  3488.     wsprintf(Buffer + Index, "WSAGetServiceClassInfoA() %s.\r\n",
  3489.              PreOrPost ? "called" : "returned");
  3490.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3491.     return(FALSE);
  3492. }
  3493.  
  3494.  
  3495.  
  3496. BOOL CALLBACK
  3497. DTHandler_WSAGetServiceClassInfoW(
  3498.     IN     va_list vl,
  3499.     IN OUT LPVOID  ReturnValue,
  3500.     IN     LPSTR   LibraryName,
  3501.     OUT    char    *Buffer,
  3502.     IN     int     Index,
  3503.     IN     int     BufLen,
  3504.     IN     BOOL    PreOrPost)
  3505. {
  3506.     int *RetVal = (int *)ReturnValue;
  3507.     LPGUID *lpProviderId = va_arg(vl, LPGUID*);
  3508.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3509.     LPDWORD *lpdwBufSize = va_arg(vl, LPDWORD*);
  3510.     LPWSASERVICECLASSINFOW *lpServiceClassInfo =
  3511.         va_arg(vl, LPWSASERVICECLASSINFOW*);
  3512.  
  3513.     wsprintf(Buffer + Index, "WSAGetServiceClassInfoW() %s.\r\n",
  3514.              PreOrPost ? "called" : "returned");
  3515.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3516.     return(FALSE);
  3517. }
  3518.  
  3519.  
  3520.  
  3521.  
  3522. BOOL CALLBACK
  3523. DTHandler_WSAEnumNameSpaceProvidersA(
  3524.     IN     va_list vl,
  3525.     IN OUT LPVOID  ReturnValue,
  3526.     IN     LPSTR   LibraryName,
  3527.     OUT    char    *Buffer,
  3528.     IN     int     Index,
  3529.     IN     int     BufLen,
  3530.     IN     BOOL    PreOrPost)
  3531. {
  3532.     int *RetVal = (int *)ReturnValue;
  3533.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3534.     LPWSANAMESPACE_INFOA *Lpnspbuffer = va_arg(vl,  LPWSANAMESPACE_INFOA*);
  3535.  
  3536.     wsprintf(Buffer + Index, "WSAEnumNameSpaceProvidersA() %s.\r\n",
  3537.              PreOrPost ? "called" : "returned");
  3538.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3539.     return(FALSE);
  3540. }
  3541.  
  3542.  
  3543. BOOL CALLBACK
  3544. DTHandler_WSAEnumNameSpaceProvidersW(
  3545.     IN     va_list vl,
  3546.     IN OUT LPVOID  ReturnValue,
  3547.     IN     LPSTR   LibraryName,
  3548.     OUT    char    *Buffer,
  3549.     IN     int     Index,
  3550.     IN     int     BufLen,
  3551.     IN     BOOL    PreOrPost)
  3552. {
  3553.     int *RetVal = (int *)ReturnValue;
  3554.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3555.     LPWSANAMESPACE_INFOW *Lpnspbuffer = va_arg(vl,  LPWSANAMESPACE_INFOW*);
  3556.  
  3557.     wsprintf(Buffer + Index, "WSAEnumNameSpaceProvidersW() %s.\r\n",
  3558.              PreOrPost ? "called" : "returned");
  3559.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3560.     return(FALSE);
  3561. }
  3562.  
  3563.  
  3564.  
  3565.  
  3566. BOOL CALLBACK
  3567. DTHandler_WSAGetServiceClassNameByClassIdA(
  3568.     IN     va_list vl,
  3569.     IN OUT LPVOID  ReturnValue,
  3570.     IN     LPSTR   LibraryName,
  3571.     OUT    char    *Buffer,
  3572.     IN     int     Index,
  3573.     IN     int     BufLen,
  3574.     IN     BOOL    PreOrPost)
  3575. {
  3576.     int *RetVal = (int *)ReturnValue;
  3577.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3578.     LPSTR *lpszServiceClassName = va_arg(vl, LPSTR*);
  3579.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3580.  
  3581.     wsprintf(Buffer + Index, "WSAGetServiceClassNameByClassIdA() %s.\r\n",
  3582.              PreOrPost ? "called" : "returned");
  3583.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3584.     return(FALSE);
  3585. }
  3586.  
  3587.  
  3588. BOOL CALLBACK
  3589. DTHandler_WSAGetServiceClassNameByClassIdW(
  3590.     IN     va_list vl,
  3591.     IN OUT LPVOID  ReturnValue,
  3592.     IN     LPSTR   LibraryName,
  3593.     OUT    char    *Buffer,
  3594.     IN     int     Index,
  3595.     IN     int     BufLen,
  3596.     IN     BOOL    PreOrPost)
  3597. {
  3598.     int *RetVal = (int *)ReturnValue;
  3599.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3600.     LPWSTR *lpszServiceClassName = va_arg(vl, LPWSTR*);
  3601.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3602.  
  3603.     wsprintf(Buffer + Index, "WSAGetServiceClassNameByClassIdW() %s.\r\n",
  3604.              PreOrPost ? "called" : "returned");
  3605.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3606.     return(FALSE);
  3607. }
  3608.  
  3609. BOOL CALLBACK
  3610. DTHandler_NSPAddressToString(
  3611.     IN     va_list vl,
  3612.     IN OUT LPVOID  ReturnValue,
  3613.     IN     LPSTR   LibraryName,
  3614.     OUT    char    *Buffer,
  3615.     IN     int     Index,
  3616.     IN     int     BufLen,
  3617.     IN     BOOL    PreOrPost)
  3618. {
  3619.     int *RetVal = (int *)ReturnValue;
  3620.     LPSOCKADDR *lpsaAddress = va_arg(vl, LPSOCKADDR *);
  3621.     DWORD *dwAddressLength= va_arg(vl, DWORD *);
  3622.     LPWSAPROTOCOL_INFOW *lpProtocolInfo= va_arg(vl, LPWSAPROTOCOL_INFOW *);
  3623.     LPWSTR *lpszAddressString= va_arg(vl, LPWSTR *);
  3624.     LPDWORD *lpdwAddressStringLength= va_arg(vl, LPDWORD *);
  3625.  
  3626.     wsprintf(Buffer + Index, "NSPAddressToString() %s.\r\n",
  3627.              PreOrPost ? "called" : "returned");
  3628.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3629.     return(FALSE);
  3630. }
  3631.  
  3632.  
  3633.  
  3634. BOOL CALLBACK
  3635. DTHandler_NSPStringToAddress(
  3636.     IN     va_list vl,
  3637.     IN OUT LPVOID  ReturnValue,
  3638.     IN     LPSTR   LibraryName,
  3639.     OUT    char    *Buffer,
  3640.     IN     int     Index,
  3641.     IN     int     BufLen,
  3642.     IN     BOOL    PreOrPost)
  3643. {
  3644.     int *RetVal = (int *)ReturnValue;
  3645.     LPWSTR *AddressString = va_arg(vl, LPWSTR*);
  3646.     INT *AddressFamily = va_arg(vl, INT *);
  3647.     LPWSAPROTOCOL_INFOW *lpProtocolInfo = va_arg(vl, LPWSAPROTOCOL_INFOW*);
  3648.     LPSOCKADDR *lpAddress = va_arg(vl, LPSOCKADDR*);
  3649.     LPINT *lpAddressLength = va_arg(vl, LPINT*);
  3650.  
  3651.     wsprintf(Buffer + Index, "NSPStringToAddress() %s.\r\n",
  3652.              PreOrPost ? "called" : "returned");
  3653.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3654.     return(FALSE);
  3655. }
  3656.  
  3657.  
  3658.  
  3659. BOOL CALLBACK
  3660. DTHandler_NSPLookupServiceBegin(
  3661.     IN     va_list vl,
  3662.     IN OUT LPVOID  ReturnValue,
  3663.     IN     LPSTR   LibraryName,
  3664.     OUT    char    *Buffer,
  3665.     IN     int     Index,
  3666.     IN     int     BufLen,
  3667.     IN     BOOL    PreOrPost)
  3668. {
  3669.     int *RetVal = (int *)ReturnValue;
  3670.     LPWSAQUERYSETW *lpqsRestrictions = va_arg(vl, LPWSAQUERYSETW*);
  3671.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3672.     LPHANDLE *lphLookup  = va_arg(vl, LPHANDLE*);
  3673.  
  3674.     wsprintf(Buffer + Index, "NSPLookupServiceBegin() %s.\r\n",
  3675.              PreOrPost ? "called" : "returned");
  3676.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3677.     return(FALSE);
  3678. }
  3679.  
  3680.  
  3681.  
  3682. BOOL CALLBACK
  3683. DTHandler_NSPLookupServiceNext(
  3684.     IN     va_list vl,
  3685.     IN OUT LPVOID  ReturnValue,
  3686.     IN     LPSTR   LibraryName,
  3687.     OUT    char    *Buffer,
  3688.     IN     int     Index,
  3689.     IN     int     BufLen,
  3690.     IN     BOOL    PreOrPost)
  3691. {
  3692.     int *RetVal = (int *)ReturnValue;
  3693.     HANDLE *hLookup = va_arg(vl, HANDLE*);
  3694.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3695.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3696.     LPWSAQUERYSETW *lpqsResults = va_arg(vl, LPWSAQUERYSETW*);
  3697.  
  3698.     wsprintf(Buffer + Index, "NSPLookupServiceNext() %s.\r\n",
  3699.              PreOrPost ? "called" : "returned");
  3700.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3701.     return(FALSE);
  3702. }
  3703.  
  3704.  
  3705.  
  3706.  
  3707. BOOL CALLBACK
  3708. DTHandler_NSPLookupServiceEnd(
  3709.     IN     va_list vl,
  3710.     IN OUT LPVOID  ReturnValue,
  3711.     IN     LPSTR   LibraryName,
  3712.     OUT    char    *Buffer,
  3713.     IN     int     Index,
  3714.     IN     int     BufLen,
  3715.     IN     BOOL    PreOrPost)
  3716. {
  3717.     int *RetVal = (int *)ReturnValue;
  3718.     HANDLE *hLookup = va_arg(vl, HANDLE*);
  3719.  
  3720.     wsprintf(Buffer + Index, "NSPLookupServiceEnd() %s.\r\n",
  3721.              PreOrPost ? "called" : "returned");
  3722.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3723.     return(FALSE);
  3724. }
  3725.  
  3726.  
  3727.  
  3728. BOOL CALLBACK
  3729. DTHandler_NSPGetAddressByName(
  3730.     IN     va_list vl,
  3731.     IN OUT LPVOID  ReturnValue,
  3732.     IN     LPSTR   LibraryName,
  3733.     OUT    char    *Buffer,
  3734.     IN     int     Index,
  3735.     IN     int     BufLen,
  3736.     IN     BOOL    PreOrPost)
  3737. {
  3738.     int *RetVal = (int *)ReturnValue;
  3739.     LPWSTR *lpszServiceInstanceName = va_arg(vl, LPWSTR*);
  3740.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3741.     DWORD *dwNameSpace = va_arg(vl, DWORD*);
  3742.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3743.     LPWSAQUERYSETW *lpqsResults = va_arg(vl, LPWSAQUERYSETW*);
  3744.     DWORD *dwResolution = va_arg(vl, DWORD*);
  3745.     LPWSTR *lpszAliasBuffer = va_arg(vl, LPWSTR*);
  3746.     LPDWORD *lpdwAliasBufferLength  = va_arg(vl, LPDWORD*);
  3747.  
  3748.     wsprintf(Buffer + Index, "NSPGetAddressByName() %s.\r\n",
  3749.              PreOrPost ? "called" : "returned");
  3750.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3751.     return(FALSE);
  3752. }
  3753.  
  3754.  
  3755.  
  3756. BOOL CALLBACK
  3757. DTHandler_NSPInstallServiceClass(
  3758.     IN     va_list vl,
  3759.     IN OUT LPVOID  ReturnValue,
  3760.     IN     LPSTR   LibraryName,
  3761.     OUT    char    *Buffer,
  3762.     IN     int     Index,
  3763.     IN     int     BufLen,
  3764.     IN     BOOL    PreOrPost)
  3765. {
  3766.     int *RetVal = (int *)ReturnValue;
  3767.     LPWSASERVICECLASSINFOW *lpServiceClassInfo =
  3768.         va_arg(vl, LPWSASERVICECLASSINFOW*);
  3769.  
  3770.     wsprintf(Buffer + Index, "NSPInstallServiceClass() %s.\r\n",
  3771.              PreOrPost ? "called" : "returned");
  3772.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3773.     return(FALSE);
  3774. }
  3775.  
  3776.  
  3777.  
  3778. BOOL CALLBACK
  3779. DTHandler_NSPSetService(
  3780.     IN     va_list vl,
  3781.     IN OUT LPVOID  ReturnValue,
  3782.     IN     LPSTR   LibraryName,
  3783.     OUT    char    *Buffer,
  3784.     IN     int     Index,
  3785.     IN     int     BufLen,
  3786.     IN     BOOL    PreOrPost)
  3787. {
  3788.     int *RetVal = (int *)ReturnValue;
  3789.     LPWSAQUERYSETW *lpqsRegInfo = va_arg(vl, LPWSAQUERYSETW*);
  3790.     WSAESETSERVICEOP *essOperation = va_arg(vl, WSAESETSERVICEOP*);
  3791.     DWORD *dwControlFlags = va_arg(vl, DWORD*);
  3792.  
  3793.     wsprintf(Buffer + Index, "NSPSetService() %s.\r\n",
  3794.              PreOrPost ? "called" : "returned");
  3795.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3796.     return(FALSE);
  3797. }
  3798.  
  3799.  
  3800.  
  3801. BOOL CALLBACK
  3802. DTHandler_NSPRemoveServiceClass(
  3803.     IN     va_list vl,
  3804.     IN OUT LPVOID  ReturnValue,
  3805.     IN     LPSTR   LibraryName,
  3806.     OUT    char    *Buffer,
  3807.     IN     int     Index,
  3808.     IN     int     BufLen,
  3809.     IN     BOOL    PreOrPost)
  3810. {
  3811.     int *RetVal = (int *)ReturnValue;
  3812.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3813.  
  3814.     wsprintf(Buffer + Index, "NSPRemoveServiceClass() %s.\r\n",
  3815.              PreOrPost ? "called" : "returned");
  3816.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3817.     return(FALSE);
  3818. }
  3819.  
  3820.  
  3821.  
  3822. BOOL CALLBACK
  3823. DTHandler_NSPGetServiceClassInfo(
  3824.     IN     va_list vl,
  3825.     IN OUT LPVOID  ReturnValue,
  3826.     IN     LPSTR   LibraryName,
  3827.     OUT    char    *Buffer,
  3828.     IN     int     Index,
  3829.     IN     int     BufLen,
  3830.     IN     BOOL    PreOrPost)
  3831. {
  3832.     int *RetVal = (int *)ReturnValue;
  3833.     LPGUID *lpProviderId = va_arg(vl, LPGUID*);
  3834.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3835.     LPDWORD *lpdwBufSize = va_arg(vl, LPDWORD*);
  3836.     LPWSASERVICECLASSINFOW *lpServiceClassInfo =
  3837.         va_arg(vl, LPWSASERVICECLASSINFOW*);
  3838.  
  3839.     wsprintf(Buffer + Index, "NSPGetServiceClassInfo() %s.\r\n",
  3840.              PreOrPost ? "called" : "returned");
  3841.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3842.     return(FALSE);
  3843. }
  3844.  
  3845.  
  3846. BOOL CALLBACK
  3847. DTHandler_NSPGetServiceClassNameByClassId(
  3848.     IN     va_list vl,
  3849.     IN OUT LPVOID  ReturnValue,
  3850.     IN     LPSTR   LibraryName,
  3851.     OUT    char    *Buffer,
  3852.     IN     int     Index,
  3853.     IN     int     BufLen,
  3854.     IN     BOOL    PreOrPost)
  3855. {
  3856.     int *RetVal = (int *)ReturnValue;
  3857.     LPGUID *lpServiceClassId = va_arg(vl, LPGUID*);
  3858.     LPWSTR *lpszServiceClassName = va_arg(vl, LPWSTR*);
  3859.     LPDWORD *lpdwBufferLength = va_arg(vl, LPDWORD*);
  3860.  
  3861.     wsprintf(Buffer + Index, "NSPGetServiceClassNameByClassId() %s.\r\n",
  3862.              PreOrPost ? "called" : "returned");
  3863.     DTTextOut(DebugWindow, LogFileHandle, Buffer, OutputStyle);
  3864.     return(FALSE);
  3865. }
  3866.  
  3867.  
  3868.  
  3869.  
  3870.