diff --git a/CMakeLists.txt b/CMakeLists.txt index e74f755..25fa420 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -62,6 +62,7 @@ pluginloader_add_impl(dinput8 "src/proxy/dinput8.cpp") pluginloader_add_impl(dsound "src/proxy/dsound.cpp" "src/proxy/dsound.def") pluginloader_add_impl(winmm "src/proxy/winmm.cpp") pluginloader_add_impl(xinput1_3 "src/proxy/xinput1_3.cpp" "src/proxy/xinput1_3.def") +pluginloader_add_impl(wsock32 "src/proxy/wsock32.cpp" "src/proxy/wsock32.def") install( TARGETS @@ -71,5 +72,6 @@ install( pluginloader_dsound pluginloader_winmm pluginloader_xinput1_3 + pluginloader_wsock32 RUNTIME DESTINATION . ) diff --git a/src/proxy/wsock32.cpp b/src/proxy/wsock32.cpp new file mode 100644 index 0000000..8871db8 --- /dev/null +++ b/src/proxy/wsock32.cpp @@ -0,0 +1,578 @@ +#include "pch.h" + +#include "proxy.h" +#include "util.h" + +namespace pluginloader::proxy { + +namespace { + +HMODULE wsock32_dll_handle = nullptr; + +FARPROC accept_ptr = nullptr; +FARPROC bind_ptr = nullptr; +FARPROC close_socket_ptr = nullptr; +FARPROC connect_ptr = nullptr; +FARPROC get_peer_name_ptr = nullptr; +FARPROC get_sock_name_ptr = nullptr; +FARPROC get_sock_opt_ptr = nullptr; +FARPROC htonl_ptr = nullptr; +FARPROC htons_ptr = nullptr; +FARPROC inet_addr_ptr = nullptr; +FARPROC inet_ntoa_ptr = nullptr; +FARPROC ioctl_socket_ptr = nullptr; +FARPROC listen_ptr = nullptr; +FARPROC ntohl_ptr = nullptr; +FARPROC ntohs_ptr = nullptr; +FARPROC recv_ptr = nullptr; +FARPROC recv_from_ptr = nullptr; +FARPROC select_ptr = nullptr; +FARPROC send_ptr = nullptr; +FARPROC send_to_ptr = nullptr; +FARPROC set_sock_opt_ptr = nullptr; +FARPROC shutdown_ptr = nullptr; +FARPROC socket_ptr = nullptr; +FARPROC migrate_winsock_configuration_ptr = nullptr; +FARPROC get_host_by_addr_ptr = nullptr; +FARPROC get_host_by_name_ptr = nullptr; +FARPROC get_proto_by_name_ptr = nullptr; +FARPROC get_proto_by_number_ptr = nullptr; +FARPROC get_serv_by_name_ptr = nullptr; +FARPROC get_serv_by_port_ptr = nullptr; +FARPROC get_host_name_ptr = nullptr; +FARPROC wsa_async_select_ptr = nullptr; +FARPROC wsa_async_get_host_by_addr_ptr = nullptr; +FARPROC wsa_async_get_host_by_name_ptr = nullptr; +FARPROC wsa_async_get_proto_by_number_ptr = nullptr; +FARPROC wsa_async_get_proto_by_name_ptr = nullptr; +FARPROC wsa_async_get_serv_by_port_ptr = nullptr; +FARPROC wsa_async_get_serv_by_name_ptr = nullptr; +FARPROC wsa_cancel_async_request_ptr = nullptr; +FARPROC wsa_set_blocking_hook_ptr = nullptr; +FARPROC wsa_unhook_blocking_hook_ptr = nullptr; +FARPROC wsa_get_last_error_ptr = nullptr; +FARPROC wsa_set_last_error_ptr = nullptr; +FARPROC wsa_cancel_blocking_call_ptr = nullptr; +FARPROC wsa_is_blocking_ptr = nullptr; +FARPROC wsa_startup_ptr = nullptr; +FARPROC wsa_cleanup_ptr = nullptr; +FARPROC wsa_fd_is_set_ptr = nullptr; +FARPROC wep_ptr = nullptr; +FARPROC wsa_p_set_post_routine_ptr = nullptr; +FARPROC inet_network_ptr = nullptr; +FARPROC get_net_by_name_ptr = nullptr; +FARPROC rcmd_ptr = nullptr; +FARPROC rexec_ptr = nullptr; +FARPROC rresvport_ptr = nullptr; +FARPROC set_host_name_ptr = nullptr; +FARPROC dn_expand_ptr = nullptr; +FARPROC wsa_recv_ex_ptr = nullptr; +FARPROC s_perror_ptr = nullptr; +FARPROC get_address_by_name_a_ptr = nullptr; +FARPROC get_address_by_name_w_ptr = nullptr; +FARPROC enum_protocols_a_ptr = nullptr; +FARPROC enum_protocols_w_ptr = nullptr; +FARPROC get_type_by_name_a_ptr = nullptr; +FARPROC get_type_by_name_w_ptr = nullptr; +FARPROC get_name_by_type_a_ptr = nullptr; +FARPROC get_name_by_type_w_ptr = nullptr; +FARPROC set_service_a_ptr = nullptr; +FARPROC set_service_w_ptr = nullptr; +FARPROC get_service_a_ptr = nullptr; +FARPROC get_service_w_ptr = nullptr; +FARPROC np_load_name_spaces_ptr = nullptr; +FARPROC transmit_file_ptr = nullptr; +FARPROC accept_ex_ptr = nullptr; +FARPROC get_accept_ex_sockaddrs_ptr = nullptr; + +} // namespace + +// NOLINTBEGIN(readability-identifier-naming) + +#ifdef __MINGW32__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wcast-function-type" +#endif +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wcast-function-type-mismatch" +#endif + +typedef UINT_PTR SOCKET; +struct in_addr { + unsigned long s_addr; +}; + +DLL_EXPORT SOCKET WINAPI accept(SOCKET s, void* addr, int* addrlen) { + return reinterpret_cast(accept_ptr)(s, addr, addrlen); +} +DLL_EXPORT int WINAPI bind(SOCKET s, const void* name, int namelen) { + return reinterpret_cast(bind_ptr)(s, name, namelen); +} +DLL_EXPORT int WINAPI closesocket(SOCKET s) { + return reinterpret_cast(close_socket_ptr)(s); +} +DLL_EXPORT int WINAPI connect(SOCKET s, const void* name, int namelen) { + return reinterpret_cast(connect_ptr)(s, name, namelen); +} +DLL_EXPORT int WINAPI getpeername(SOCKET s, void* name, int* namelen) { + return reinterpret_cast(get_peer_name_ptr)(s, name, namelen); +} +DLL_EXPORT int WINAPI getsockname(SOCKET s, void* name, int* namelen) { + return reinterpret_cast(get_sock_name_ptr)(s, name, namelen); +} +DLL_EXPORT int WINAPI getsockopt(SOCKET s, int level, int optname, char* optval, int* optlen) { + return reinterpret_cast(get_sock_opt_ptr)(s, level, optname, optval, + optlen); +} +DLL_EXPORT unsigned long WINAPI htonl(unsigned long hostlong) { + return reinterpret_cast(htonl_ptr)(hostlong); +} +DLL_EXPORT unsigned short WINAPI htons(unsigned short hostshort) { + return reinterpret_cast(htons_ptr)(hostshort); +} +DLL_EXPORT unsigned long WINAPI inet_addr(const char* cp) { + return reinterpret_cast(inet_addr_ptr)(cp); +} +DLL_EXPORT char* WINAPI inet_ntoa(in_addr in) { + return reinterpret_cast(inet_ntoa_ptr)(in); +} +DLL_EXPORT int WINAPI ioctlsocket(SOCKET s, long cmd, unsigned long* argp) { + return reinterpret_cast(ioctl_socket_ptr)(s, cmd, argp); +} +DLL_EXPORT int WINAPI listen(SOCKET s, int backlog) { + return reinterpret_cast(listen_ptr)(s, backlog); +} +DLL_EXPORT unsigned long WINAPI ntohl(unsigned long netlong) { + return reinterpret_cast(ntohl_ptr)(netlong); +} +DLL_EXPORT unsigned short WINAPI ntohs(unsigned short netshort) { + return reinterpret_cast(ntohs_ptr)(netshort); +} +DLL_EXPORT int WINAPI recv(SOCKET s, char* buf, int len, int flags) { + return reinterpret_cast(recv_ptr)(s, buf, len, flags); +} +DLL_EXPORT int WINAPI recvfrom(SOCKET s, char* buf, int len, int flags, void* from, int* fromlen) { + return reinterpret_cast(recv_from_ptr)(s, buf, len, flags, from, fromlen); +} +DLL_EXPORT int WINAPI +select(int nfds, void* readfds, void* writefds, void* exceptfds, const void* timeout) { + return reinterpret_cast(select_ptr)(nfds, readfds, writefds, exceptfds, + timeout); +} +DLL_EXPORT int WINAPI send(SOCKET s, const char* buf, int len, int flags) { + return reinterpret_cast(send_ptr)(s, buf, len, flags); +} +DLL_EXPORT int WINAPI +sendto(SOCKET s, const char* buf, int len, int flags, const void* to, int tolen) { + return reinterpret_cast(send_to_ptr)(s, buf, len, flags, to, tolen); +} +DLL_EXPORT int WINAPI setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen) { + return reinterpret_cast(set_sock_opt_ptr)(s, level, optname, optval, + optlen); +} +DLL_EXPORT int WINAPI shutdown(SOCKET s, int how) { + return reinterpret_cast(shutdown_ptr)(s, how); +} +DLL_EXPORT SOCKET WINAPI socket(int af, int type, int protocol) { + return reinterpret_cast(socket_ptr)(af, type, protocol); +} +DLL_EXPORT unsigned long WINAPI MigrateWinsockConfiguration(unsigned long unknown1, + unsigned long unknown2, + unsigned long unknown3) { + return reinterpret_cast( + migrate_winsock_configuration_ptr)(unknown1, unknown2, unknown3); +} +DLL_EXPORT void* WINAPI gethostbyaddr(const char* addr, int len, int type) { + return reinterpret_cast(get_host_by_addr_ptr)(addr, len, type); +} +DLL_EXPORT void* WINAPI gethostbyname(const char* name) { + return reinterpret_cast(get_host_by_name_ptr)(name); +} +DLL_EXPORT void* WINAPI getprotobyname(const char* name) { + return reinterpret_cast(get_proto_by_name_ptr)(name); +} +DLL_EXPORT void* WINAPI getprotobynumber(int number) { + return reinterpret_cast(get_proto_by_number_ptr)(number); +} +DLL_EXPORT void* WINAPI getservbyname(const char* name, const char* proto) { + return reinterpret_cast(get_serv_by_name_ptr)(name, proto); +} +DLL_EXPORT void* WINAPI getservbyport(int port, const char* proto) { + return reinterpret_cast(get_serv_by_port_ptr)(port, proto); +} +DLL_EXPORT int WINAPI gethostname(char* name, int namelen) { + return reinterpret_cast(get_host_name_ptr)(name, namelen); +} +DLL_EXPORT int WINAPI WSAAsyncSelect(SOCKET s, void* hWnd, unsigned int wMsg, long lEvent) { + return reinterpret_cast(wsa_async_select_ptr)(s, hWnd, wMsg, lEvent); +} +DLL_EXPORT void* WINAPI WSAAsyncGetHostByAddr(void* hWnd, + unsigned int wMsg, + const char* addr, + int len, + int type, + char* buf, + int buflen) { + return reinterpret_cast(wsa_async_get_host_by_addr_ptr)( + hWnd, wMsg, addr, len, type, buf, buflen); +} +DLL_EXPORT void* WINAPI +WSAAsyncGetHostByName(void* hWnd, unsigned int wMsg, const char* name, char* buf, int buflen) { + return reinterpret_cast(wsa_async_get_host_by_name_ptr)( + hWnd, wMsg, name, buf, buflen); +} +DLL_EXPORT void* WINAPI +WSAAsyncGetProtoByNumber(void* hWnd, unsigned int wMsg, int number, char* buf, int buflen) { + return reinterpret_cast(wsa_async_get_proto_by_number_ptr)( + hWnd, wMsg, number, buf, buflen); +} +DLL_EXPORT void* WINAPI +WSAAsyncGetProtoByName(void* hWnd, unsigned int wMsg, const char* name, char* buf, int buflen) { + return reinterpret_cast(wsa_async_get_proto_by_name_ptr)( + hWnd, wMsg, name, buf, buflen); +} +DLL_EXPORT void* WINAPI WSAAsyncGetServByPort(void* hWnd, + unsigned int wMsg, + int port, + const char* proto, + char* buf, + int buflen) { + return reinterpret_cast(wsa_async_get_serv_by_port_ptr)( + hWnd, wMsg, port, proto, buf, buflen); +} +DLL_EXPORT void* WINAPI WSAAsyncGetServByName(void* hWnd, + unsigned int wMsg, + const char* name, + const char* proto, + char* buf, + int buflen) { + return reinterpret_cast(wsa_async_get_serv_by_name_ptr)( + hWnd, wMsg, name, proto, buf, buflen); +} +DLL_EXPORT int WINAPI WSACancelAsyncRequest(void* hAsyncTaskHandle) { + return reinterpret_cast(wsa_cancel_async_request_ptr)( + hAsyncTaskHandle); +} +DLL_EXPORT void* WINAPI WSASetBlockingHook(void* lpBlockFunc) { + return reinterpret_cast(wsa_set_blocking_hook_ptr)(lpBlockFunc); +} +DLL_EXPORT int WINAPI WSAUnhookBlockingHook(void) { + return reinterpret_cast(wsa_unhook_blocking_hook_ptr)(); +} +DLL_EXPORT int WINAPI WSAGetLastError(void) { + return reinterpret_cast(wsa_get_last_error_ptr)(); +} +DLL_EXPORT void WINAPI WSASetLastError(int iError) { + reinterpret_cast(wsa_set_last_error_ptr)(iError); +} +DLL_EXPORT int WINAPI WSACancelBlockingCall(void) { + return reinterpret_cast(wsa_cancel_blocking_call_ptr)(); +} +DLL_EXPORT int WINAPI WSAIsBlocking(void) { + return reinterpret_cast(wsa_is_blocking_ptr)(); +} +DLL_EXPORT int WINAPI WSAStartup(unsigned short wVersionRequested, void* lpWSAData) { + return reinterpret_cast(wsa_startup_ptr)(wVersionRequested, lpWSAData); +} +DLL_EXPORT int WINAPI WSACleanup(void) { + return reinterpret_cast(wsa_cleanup_ptr)(); +} +DLL_EXPORT int WINAPI __WSAFDIsSet(SOCKET fd, void* set) { + return reinterpret_cast(wsa_fd_is_set_ptr)(fd, set); +} +DLL_EXPORT int WINAPI WEP(void) { + return reinterpret_cast(wep_ptr)(); +} +DLL_EXPORT int WINAPI WSApSetPostRoutine(void* lpPostRoutine) { + return reinterpret_cast(wsa_p_set_post_routine_ptr)( + lpPostRoutine); +} +DLL_EXPORT unsigned long WINAPI inet_network(const char* cp) { + return reinterpret_cast(inet_network_ptr)(cp); +} +DLL_EXPORT void* WINAPI getnetbyname(const char* name) { + return reinterpret_cast(get_net_by_name_ptr)(name); +} +DLL_EXPORT int WINAPI +rcmd(char** ahost, unsigned short inport, char* locuser, char* remuser, char* cmd, int* fd2p) { + return reinterpret_cast(rcmd_ptr)(ahost, inport, locuser, remuser, cmd, fd2p); +} +DLL_EXPORT int WINAPI +rexec(char** ahost, int inport, char* user, char* passwd, char* cmd, int* fd2p) { + return reinterpret_cast(rexec_ptr)(ahost, inport, user, passwd, cmd, fd2p); +} +DLL_EXPORT int WINAPI rresvport(int* port) { + return reinterpret_cast(rresvport_ptr)(port); +} +DLL_EXPORT int WINAPI sethostname(char* name, int namelen) { + return reinterpret_cast(set_host_name_ptr)(name, namelen); +} +DLL_EXPORT int WINAPI dn_expand(unsigned char* msg, + unsigned char* eomorig, + unsigned char* comp_dn, + unsigned char* exp_dn, + int length) { + return reinterpret_cast(dn_expand_ptr)(msg, eomorig, comp_dn, exp_dn, + length); +} +DLL_EXPORT int WINAPI WSARecvEx(SOCKET s, char* buf, int len, int* flags) { + return reinterpret_cast(wsa_recv_ex_ptr)(s, buf, len, flags); +} +DLL_EXPORT int WINAPI s_perror(char* yourmsg, int lerror) { + return reinterpret_cast(s_perror_ptr)(yourmsg, lerror); +} +DLL_EXPORT int WINAPI GetAddressByNameA(unsigned long dwNameSpace, + void* lpServiceType, + char* lpServiceName, + int* lpiProtocols, + unsigned long dwResolution, + void* lpServiceAsyncInfo, + void* lpCsaddrBuffer, + unsigned long* lpdwBufferLength, + char* lpAliasBuffer, + unsigned long* lpdwAliasBufferLength) { + return reinterpret_cast(get_address_by_name_a_ptr)( + dwNameSpace, lpServiceType, lpServiceName, lpiProtocols, dwResolution, lpServiceAsyncInfo, + lpCsaddrBuffer, lpdwBufferLength, lpAliasBuffer, lpdwAliasBufferLength); +} +DLL_EXPORT int WINAPI GetAddressByNameW(unsigned long dwNameSpace, + void* lpServiceType, + wchar_t* lpServiceName, + int* lpiProtocols, + unsigned long dwResolution, + void* lpServiceAsyncInfo, + void* lpCsaddrBuffer, + unsigned long* lpdwBufferLength, + wchar_t* lpAliasBuffer, + unsigned long* lpdwAliasBufferLength) { + return reinterpret_cast(get_address_by_name_w_ptr)( + dwNameSpace, lpServiceType, lpServiceName, lpiProtocols, dwResolution, lpServiceAsyncInfo, + lpCsaddrBuffer, lpdwBufferLength, lpAliasBuffer, lpdwAliasBufferLength); +} +DLL_EXPORT int WINAPI EnumProtocolsA(int* lpiProtocols, + void* lpProtocolBuffer, + unsigned long* lpdwBufferLength) { + return reinterpret_cast(enum_protocols_a_ptr)( + lpiProtocols, lpProtocolBuffer, lpdwBufferLength); +} +DLL_EXPORT int WINAPI EnumProtocolsW(int* lpiProtocols, + void* lpProtocolBuffer, + unsigned long* lpdwBufferLength) { + return reinterpret_cast(enum_protocols_w_ptr)( + lpiProtocols, lpProtocolBuffer, lpdwBufferLength); +} +DLL_EXPORT int WINAPI GetTypeByNameA(char* lpServiceName, void* lpServiceType) { + return reinterpret_cast(get_type_by_name_a_ptr)(lpServiceName, + lpServiceType); +} +DLL_EXPORT int WINAPI GetTypeByNameW(wchar_t* lpServiceName, void* lpServiceType) { + return reinterpret_cast(get_type_by_name_w_ptr)(lpServiceName, + lpServiceType); +} +DLL_EXPORT int WINAPI GetNameByTypeA(void* lpServiceType, + char* lpServiceName, + unsigned long dwNameLength) { + return reinterpret_cast(get_name_by_type_a_ptr)( + lpServiceType, lpServiceName, dwNameLength); +} +DLL_EXPORT int WINAPI GetNameByTypeW(void* lpServiceType, + wchar_t* lpServiceName, + unsigned long dwNameLength) { + return reinterpret_cast(get_name_by_type_w_ptr)( + lpServiceType, lpServiceName, dwNameLength); +} +DLL_EXPORT int WINAPI SetServiceA(unsigned long dwNameSpace, + unsigned long dwOperation, + unsigned long dwFlags, + void* lpServiceInfo, + void* lpServiceAsyncInfo, + unsigned long* lpdwStatusFlags) { + return reinterpret_cast(set_service_a_ptr)( + dwNameSpace, dwOperation, dwFlags, lpServiceInfo, lpServiceAsyncInfo, lpdwStatusFlags); +} +DLL_EXPORT int WINAPI SetServiceW(unsigned long dwNameSpace, + unsigned long dwOperation, + unsigned long dwFlags, + void* lpServiceInfo, + void* lpServiceAsyncInfo, + unsigned long* lpdwStatusFlags) { + return reinterpret_cast(set_service_w_ptr)( + dwNameSpace, dwOperation, dwFlags, lpServiceInfo, lpServiceAsyncInfo, lpdwStatusFlags); +} +DLL_EXPORT int WINAPI GetServiceA(unsigned long dwNameSpace, + void* lpGuid, + char* lpServiceName, + unsigned long dwProperties, + void* lpBuffer, + unsigned long* lpdwBufferSize, + void* lpServiceAsyncInfo) { + return reinterpret_cast(get_service_a_ptr)( + dwNameSpace, lpGuid, lpServiceName, dwProperties, lpBuffer, lpdwBufferSize, + lpServiceAsyncInfo); +} +DLL_EXPORT int WINAPI GetServiceW(unsigned long dwNameSpace, + void* lpGuid, + wchar_t* lpServiceName, + unsigned long dwProperties, + void* lpBuffer, + unsigned long* lpdwBufferSize, + void* lpServiceAsyncInfo) { + return reinterpret_cast(get_service_w_ptr)( + dwNameSpace, lpGuid, lpServiceName, dwProperties, lpBuffer, lpdwBufferSize, + lpServiceAsyncInfo); +} +DLL_EXPORT int WINAPI NPLoadNameSpaces(unsigned long dwVersion, + void* lpdwNumberOfNameSpaces, + void* lpNameSpaceBuffer) { + return reinterpret_cast(np_load_name_spaces_ptr)( + dwVersion, lpdwNumberOfNameSpaces, lpNameSpaceBuffer); +} +DLL_EXPORT int WINAPI TransmitFile(SOCKET hSocket, + void* hFile, + unsigned long nBytes, + unsigned long nBytesPerSend, + void* lpOverlapped, + void* lpTransmitBuffers, + unsigned long dwFlags) { + return reinterpret_cast(transmit_file_ptr)( + hSocket, hFile, nBytes, nBytesPerSend, lpOverlapped, lpTransmitBuffers, dwFlags); +} +DLL_EXPORT int WINAPI AcceptEx(SOCKET sListen, + SOCKET sAccept, + void* lpOutputBuffer, + unsigned long dwRecvLen, + unsigned long dwLocalLen, + unsigned long dwRemoteLen, + unsigned long* lpdwBytesReceived, + void* lpOverlapped) { + return reinterpret_cast(accept_ex_ptr)(sListen, sAccept, lpOutputBuffer, + dwRecvLen, dwLocalLen, dwRemoteLen, + lpdwBytesReceived, lpOverlapped); +} +DLL_EXPORT void WINAPI GetAcceptExSockaddrs(void* lpOutputBuffer, + unsigned long dwRecvLen, + unsigned long dwLocalLen, + unsigned long dwRemoteLen, + void** LocalSockaddr, + int* LocalLen, + void** RemoteSockaddr, + int* RemoteLen) { + reinterpret_cast(get_accept_ex_sockaddrs_ptr)( + lpOutputBuffer, dwRecvLen, dwLocalLen, dwRemoteLen, LocalSockaddr, LocalLen, RemoteSockaddr, + RemoteLen); +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif +#ifdef __MINGW32__ +#pragma GCC diagnostic pop +#endif + +// NOLINTEND(readability-identifier-naming) + +void init(HMODULE /*this_dll*/) { + // Suspend all other threads to prevent a giant race condition + const util::ThreadSuspender suspender{}; + + wchar_t buf[MAX_PATH]; + if (GetSystemDirectoryW(&buf[0], ARRAYSIZE(buf)) == 0) { + std::cerr << "Unable to find system dll directory! We're probably about to crash.\n"; + return; + } + + auto system_wsock32 = std::filesystem::path{static_cast(buf)} / "wsock32.dll"; + wsock32_dll_handle = LoadLibraryA(system_wsock32.generic_string().c_str()); + if (wsock32_dll_handle == nullptr) { + std::cerr << "Unable to find system wsock32.dll! We're probably about to crash.\n"; + return; + } + + accept_ptr = GetProcAddress(wsock32_dll_handle, "accept"); + bind_ptr = GetProcAddress(wsock32_dll_handle, "bind"); + close_socket_ptr = GetProcAddress(wsock32_dll_handle, "closesocket"); + connect_ptr = GetProcAddress(wsock32_dll_handle, "connect"); + get_peer_name_ptr = GetProcAddress(wsock32_dll_handle, "getpeername"); + get_sock_name_ptr = GetProcAddress(wsock32_dll_handle, "getsockname"); + get_sock_opt_ptr = GetProcAddress(wsock32_dll_handle, "getsockopt"); + htonl_ptr = GetProcAddress(wsock32_dll_handle, "htonl"); + htons_ptr = GetProcAddress(wsock32_dll_handle, "htons"); + inet_addr_ptr = GetProcAddress(wsock32_dll_handle, "inet_addr"); + inet_ntoa_ptr = GetProcAddress(wsock32_dll_handle, "inet_ntoa"); + ioctl_socket_ptr = GetProcAddress(wsock32_dll_handle, "ioctlsocket"); + listen_ptr = GetProcAddress(wsock32_dll_handle, "listen"); + ntohl_ptr = GetProcAddress(wsock32_dll_handle, "ntohl"); + ntohs_ptr = GetProcAddress(wsock32_dll_handle, "ntohs"); + recv_ptr = GetProcAddress(wsock32_dll_handle, "recv"); + recv_from_ptr = GetProcAddress(wsock32_dll_handle, "recvfrom"); + select_ptr = GetProcAddress(wsock32_dll_handle, "select"); + send_ptr = GetProcAddress(wsock32_dll_handle, "send"); + send_to_ptr = GetProcAddress(wsock32_dll_handle, "sendto"); + set_sock_opt_ptr = GetProcAddress(wsock32_dll_handle, "setsockopt"); + shutdown_ptr = GetProcAddress(wsock32_dll_handle, "shutdown"); + socket_ptr = GetProcAddress(wsock32_dll_handle, "socket"); + migrate_winsock_configuration_ptr = + GetProcAddress(wsock32_dll_handle, "MigrateWinsockConfiguration"); + get_host_by_addr_ptr = GetProcAddress(wsock32_dll_handle, "gethostbyaddr"); + get_host_by_name_ptr = GetProcAddress(wsock32_dll_handle, "gethostbyname"); + get_proto_by_name_ptr = GetProcAddress(wsock32_dll_handle, "getprotobyname"); + get_proto_by_number_ptr = GetProcAddress(wsock32_dll_handle, "getprotobynumber"); + get_serv_by_name_ptr = GetProcAddress(wsock32_dll_handle, "getservbyname"); + get_serv_by_port_ptr = GetProcAddress(wsock32_dll_handle, "getservbyport"); + get_host_name_ptr = GetProcAddress(wsock32_dll_handle, "gethostname"); + wsa_async_select_ptr = GetProcAddress(wsock32_dll_handle, "WSAAsyncSelect"); + wsa_async_get_host_by_addr_ptr = GetProcAddress(wsock32_dll_handle, "WSAAsyncGetHostByAddr"); + wsa_async_get_host_by_name_ptr = GetProcAddress(wsock32_dll_handle, "WSAAsyncGetHostByName"); + wsa_async_get_proto_by_number_ptr = + GetProcAddress(wsock32_dll_handle, "WSAAsyncGetProtoByNumber"); + wsa_async_get_proto_by_name_ptr = GetProcAddress(wsock32_dll_handle, "WSAAsyncGetProtoByName"); + wsa_async_get_serv_by_port_ptr = GetProcAddress(wsock32_dll_handle, "WSAAsyncGetServByPort"); + wsa_async_get_serv_by_name_ptr = GetProcAddress(wsock32_dll_handle, "WSAAsyncGetServByName"); + wsa_cancel_async_request_ptr = GetProcAddress(wsock32_dll_handle, "WSACancelAsyncRequest"); + wsa_set_blocking_hook_ptr = GetProcAddress(wsock32_dll_handle, "WSASetBlockingHook"); + wsa_unhook_blocking_hook_ptr = GetProcAddress(wsock32_dll_handle, "WSAUnhookBlockingHook"); + wsa_get_last_error_ptr = GetProcAddress(wsock32_dll_handle, "WSAGetLastError"); + wsa_set_last_error_ptr = GetProcAddress(wsock32_dll_handle, "WSASetLastError"); + wsa_cancel_blocking_call_ptr = GetProcAddress(wsock32_dll_handle, "WSACancelBlockingCall"); + wsa_is_blocking_ptr = GetProcAddress(wsock32_dll_handle, "WSAIsBlocking"); + wsa_startup_ptr = GetProcAddress(wsock32_dll_handle, "WSAStartup"); + wsa_cleanup_ptr = GetProcAddress(wsock32_dll_handle, "WSACleanup"); + wsa_fd_is_set_ptr = GetProcAddress(wsock32_dll_handle, "__WSAFDIsSet"); + wep_ptr = GetProcAddress(wsock32_dll_handle, "WEP"); + wsa_p_set_post_routine_ptr = GetProcAddress(wsock32_dll_handle, "WSApSetPostRoutine"); + inet_network_ptr = GetProcAddress(wsock32_dll_handle, "inet_network"); + get_net_by_name_ptr = GetProcAddress(wsock32_dll_handle, "getnetbyname"); + rcmd_ptr = GetProcAddress(wsock32_dll_handle, "rcmd"); + rexec_ptr = GetProcAddress(wsock32_dll_handle, "rexec"); + rresvport_ptr = GetProcAddress(wsock32_dll_handle, "rresvport"); + set_host_name_ptr = GetProcAddress(wsock32_dll_handle, "sethostname"); + dn_expand_ptr = GetProcAddress(wsock32_dll_handle, "dn_expand"); + wsa_recv_ex_ptr = GetProcAddress(wsock32_dll_handle, "WSARecvEx"); + s_perror_ptr = GetProcAddress(wsock32_dll_handle, "s_perror"); + get_address_by_name_a_ptr = GetProcAddress(wsock32_dll_handle, "GetAddressByNameA"); + get_address_by_name_w_ptr = GetProcAddress(wsock32_dll_handle, "GetAddressByNameW"); + enum_protocols_a_ptr = GetProcAddress(wsock32_dll_handle, "EnumProtocolsA"); + enum_protocols_w_ptr = GetProcAddress(wsock32_dll_handle, "EnumProtocolsW"); + get_type_by_name_a_ptr = GetProcAddress(wsock32_dll_handle, "GetTypeByNameA"); + get_type_by_name_w_ptr = GetProcAddress(wsock32_dll_handle, "GetTypeByNameW"); + get_name_by_type_a_ptr = GetProcAddress(wsock32_dll_handle, "GetNameByTypeA"); + get_name_by_type_w_ptr = GetProcAddress(wsock32_dll_handle, "GetNameByTypeW"); + set_service_a_ptr = GetProcAddress(wsock32_dll_handle, "SetServiceA"); + set_service_w_ptr = GetProcAddress(wsock32_dll_handle, "SetServiceW"); + get_service_a_ptr = GetProcAddress(wsock32_dll_handle, "GetServiceA"); + get_service_w_ptr = GetProcAddress(wsock32_dll_handle, "GetServiceW"); + np_load_name_spaces_ptr = GetProcAddress(wsock32_dll_handle, "NPLoadNameSpaces"); + transmit_file_ptr = GetProcAddress(wsock32_dll_handle, "TransmitFile"); + accept_ex_ptr = GetProcAddress(wsock32_dll_handle, "AcceptEx"); + get_accept_ex_sockaddrs_ptr = GetProcAddress(wsock32_dll_handle, "GetAcceptExSockaddrs"); +} + +void free(void) { + if (wsock32_dll_handle != nullptr) { + FreeLibrary(wsock32_dll_handle); + wsock32_dll_handle = nullptr; + } +} + +} // namespace pluginloader::proxy diff --git a/src/proxy/wsock32.def b/src/proxy/wsock32.def new file mode 100644 index 0000000..908b9e3 --- /dev/null +++ b/src/proxy/wsock32.def @@ -0,0 +1,77 @@ +LIBRARY wsock32 +EXPORTS + accept @1 + bind @2 + closesocket @3 + connect @4 + getpeername @5 + getsockname @6 + getsockopt @7 + htonl @8 + htons @9 + inet_addr @10 + inet_ntoa @11 + ioctlsocket @12 + listen @13 + ntohl @14 + ntohs @15 + recv @16 + recvfrom @17 + select @18 + send @19 + sendto @20 + setsockopt @21 + shutdown @22 + socket @23 + MigrateWinsockConfiguration @24 + gethostbyaddr @51 + gethostbyname @52 + getprotobyname @53 + getprotobynumber @54 + getservbyname @55 + getservbyport @56 + gethostname @57 + WSAAsyncSelect @101 + WSAAsyncGetHostByAddr @102 + WSAAsyncGetHostByName @103 + WSAAsyncGetProtoByNumber @104 + WSAAsyncGetProtoByName @105 + WSAAsyncGetServByPort @106 + WSAAsyncGetServByName @107 + WSACancelAsyncRequest @108 + WSASetBlockingHook @109 + WSAUnhookBlockingHook @110 + WSAGetLastError @111 + WSASetLastError @112 + WSACancelBlockingCall @113 + WSAIsBlocking @114 + WSAStartup @115 + WSACleanup @116 + __WSAFDIsSet @151 + WEP @500 + WSApSetPostRoutine @1000 + inet_network @1100 + getnetbyname @1101 + rcmd @1102 + rexec @1103 + rresvport @1104 + sethostname @1105 + dn_expand @1106 + WSARecvEx @1107 + s_perror @1108 + GetAddressByNameA @1109 + GetAddressByNameW @1110 + EnumProtocolsA @1111 + EnumProtocolsW @1112 + GetTypeByNameA @1113 + GetTypeByNameW @1114 + GetNameByTypeA @1115 + GetNameByTypeW @1116 + SetServiceA @1117 + SetServiceW @1118 + GetServiceA @1119 + GetServiceW @1120 + NPLoadNameSpaces @1130 + TransmitFile @1140 + AcceptEx @1141 + GetAcceptExSockaddrs @1142 \ No newline at end of file