开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
netredirect.cpp
资源名称：openkore-2.0.7.zip　[点击查看]
上传用户：market2
上传日期：2018-11-18
资源大小：18786k
文件大小：18k
源码类别：

外挂编程

开发平台：

Windows_Unix

netredirect.cpp：源码内容
  1. /*
  2.  * This DLL is "injected" into the RO client's address space.
  3.  * Once injected, we intercept all network traffic and redirect
  4.  * some of it to Kore.
  5.  */
  7. #include <stdio.h>
  8. #include "common.h"
  9. #include <string>
  10. #include <string.h>
  12. using namespace std;
  14. MyRecvProc OriginalRecvProc = (MyRecvProc) recv;
  15. MySendProc OriginalSendProc = (MySendProc) send;
  16. MyRecvFromProc OriginalRecvFromProc = (MyRecvFromProc) recvfrom;
  17. MySendToProc OriginalSendToProc = (MySendToProc) sendto;
  18. MyConnectProc OriginalConnectProc = (MyConnectProc) connect;
  19. MySelectProc OriginalSelectProc = (MySelectProc) select;
  20. MyWSARecvProc OriginalWSARecvProc = (MyWSARecvProc) WSARecv;
  21. MyWSARecvFromProc OriginalWSARecvFromProc = (MyWSARecvFromProc) WSARecvFrom;
  22. MyWSASendProc OriginalWSASendProc = (MyWSASendProc) WSASend;
  23. MyWSASendToProc OriginalWSASendToProc = (MyWSASendToProc) WSASendTo;
  24. MyWSAAsyncSelectProc OriginalWSAAsyncSelectProc = (MyWSAAsyncSelectProc) WSAAsyncSelect;
  25. MyGetProcAddressProc OriginalGetProcAddressProc = (MyGetProcAddressProc) GetProcAddress;
  27. bool enableDebug = false;
  30. // Connection to the X-Kore server that Kore created
  31. static SOCKET koreClient = INVALID_SOCKET;
  32. static bool koreClientIsAlive = false;
  33. static CRITICAL_SECTION CS_koreClientIsAlive;
  35. static bool dataAvailableFromKore = false;
  36. static bool dataAvailableFromKore2 = false;
  37. static CRITICAL_SECTION CS_dataAvailableFromKore;
  39. static SOCKET roServer = INVALID_SOCKET;
  40. static CRITICAL_SECTION CS_ro;
  42. static CRITICAL_SECTION CS_rosend;
  43. static CRITICAL_SECTION CS_send;
  44. static string roSendBuf(""); // Data to send to the RO client
  45. static string xkoreSendBuf(""); // Data to send to the X-Kore server
  47. #define SLEEP_TIME 10
  50. // Process a packet that the X-Kore server sent us
  51. static void
  52. processPacket (Packet *packet)
  53. {
  54. switch (packet->ID) {
  55. case 'S': // Send a packet to the RO server
  56. EnterCriticalSection (&CS_ro);
  57. if (roServer != INVALID_SOCKET && isConnected (roServer))
  58. OriginalSendProc (roServer, packet->data, packet->len, 0);
  59. LeaveCriticalSection (&CS_ro);
  60. break;
  62. case 'R': // Fool the RO client into thinking that we got a packet from the RO server
  63. // We copy the data in this packet into a string
  64. // Next time the RO client calls recv(), this packet will be returned, along with
  65. // whatever data the RO server sent
  66. EnterCriticalSection (&CS_rosend);
  67. roSendBuf.append (packet->data, packet->len);
  68. LeaveCriticalSection (&CS_rosend);
  69. dataAvailableFromKore2 = true;
  70. break;
  72. case 'K': default: // Keep-alive
  73. break;
  74. }
  75. }
  77. // Handles the connection between the RO client (this process) and the X-Kore server
  78. // Note that this function is run in a thread and never exits
  79. static void
  80. koreConnectionMain ()
  81. {
  82. #define BUF_SIZE 1024 * 32
  83. //#define TIMEOUT 10000
  84. #define TIMEOUT 600000
  85. #define PING_INTERVAL 5000
  86. #define RECONNECT_INTERVAL 3000
  88. char buf[BUF_SIZE + 1];
  89. char pingPacket[3];
  90. unsigned short pingPacketLength = 0;
  91. DWORD koreClientTimeout, koreClientPingTimeout, reconnectTimeout;
  92. string koreClientRecvBuf;
  94. debug ("Thread startedn");
  95. koreClientTimeout = GetTickCount ();
  96. koreClientPingTimeout = GetTickCount ();
  97. reconnectTimeout = 0;
  99. memcpy (pingPacket, "K", 1);
  100. memcpy (pingPacket + 1, &pingPacketLength, 2);
  102. while (1) {
  103. bool isAlive;
  104. bool isAliveChanged = false;
  106. // Attempt to connect to the X-Kore server if necessary
  107. EnterCriticalSection (&CS_koreClientIsAlive);
  108. koreClientIsAlive = koreClient != INVALID_SOCKET;
  109. isAlive = koreClientIsAlive; // keep a local copy of that variable so we don't have to enter critical sections over and over
  110. LeaveCriticalSection (&CS_koreClientIsAlive);
  112. if ((!isAlive || !isConnected (koreClient) || GetTickCount () - koreClientTimeout > TIMEOUT)
  113.   && GetTickCount () - reconnectTimeout > RECONNECT_INTERVAL) {
  114. debug ("Connecting to X-Kore server...n");
  116. if (koreClient != INVALID_SOCKET)
  117. closesocket (koreClient);
  118. koreClient = createSocket (XKORE_SERVER_PORT);
  120. isAlive = koreClient != INVALID_SOCKET;
  121. isAliveChanged = true;
  122. if (!isAlive)
  123. debug ("Failedn");
  124. else
  125. koreClientTimeout = GetTickCount ();
  126. reconnectTimeout = GetTickCount ();
  127. }
  130. // Receive data from the X-Kore server
  131. if (isAlive) {
  132. int ret;
  134. ret = readSocket (koreClient, buf, BUF_SIZE);
  135. if (ret == SF_CLOSED) {
  136. // Connection closed
  137. debug ("X-Kore server exitedn");
  138. closesocket (koreClient);
  139. koreClient = INVALID_SOCKET;
  140. isAlive = false;
  141. isAliveChanged = true;
  143. } else if (ret > 0) {
  144. // Data available
  145. Packet *packet;
  146. int next = 0;
  148. koreClientRecvBuf.append (buf, ret);
  149. while ((packet = unpackPacket (koreClientRecvBuf.c_str (), koreClientRecvBuf.size (), next))) {
  150. // Packet is complete
  151. processPacket (packet);
  152. free (packet);
  153. koreClientRecvBuf.erase (0, next);
  154. }
  156. if (dataAvailableFromKore2) {
  157. EnterCriticalSection (&CS_dataAvailableFromKore);
  158. dataAvailableFromKore = true;
  159. LeaveCriticalSection (&CS_dataAvailableFromKore);
  160. }
  162. // Update timeout
  163. koreClientTimeout = GetTickCount ();
  164. }
  165. }
  168. // Check whether we have data to send to the X-Kore server
  169. // This data originates from the RO client and is supposed to go to the real RO server
  170. EnterCriticalSection (&CS_send);
  171. if (xkoreSendBuf.size ()) {
  172. if (isAlive) {
  173. OriginalSendProc (koreClient, (char *) xkoreSendBuf.c_str (), xkoreSendBuf.size (), 0);
  175. } else {
  176. Packet *packet;
  177. int next;
  179. // Kore is not running; send it to the RO server instead,
  180. // if this packet is supposed to go to the RO server ('S')
  181. // Ignore packets that are meant for Kore ('R')
  182. EnterCriticalSection (&CS_ro);
  183. while ((packet = unpackPacket (xkoreSendBuf.c_str (), xkoreSendBuf.size (), next))) {
  184. if (packet->ID == 'S')
  185. OriginalSendProc (roServer, (char *) packet->data, packet->len, 0);
  186. free (packet);
  187. xkoreSendBuf.erase (0, next);
  188. }
  189. LeaveCriticalSection (&CS_ro);
  190. }
  191. xkoreSendBuf.erase ();
  192. }
  193. LeaveCriticalSection (&CS_send);
  196. // Ping the X-Kore server to keep the connection alive
  197. if (koreClientIsAlive && GetTickCount () - koreClientPingTimeout > PING_INTERVAL) {
  198. OriginalSendProc (koreClient, pingPacket, 3, 0);
  199. koreClientPingTimeout = GetTickCount ();
  200. }
  202. if (isAliveChanged) {
  203. EnterCriticalSection (&CS_koreClientIsAlive);
  204. koreClientIsAlive = isAlive;
  205. LeaveCriticalSection (&CS_koreClientIsAlive);
  206. }
  207. Sleep (SLEEP_TIME);
  208. }
  209. }
  212. /*********** Faked functions ************/
  214. int WINAPI
  215. MyWSASend (SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
  216. {
  217. return OriginalWSASendProc(s,lpBuffers,dwBufferCount,lpNumberOfBytesSent,dwFlags,lpOverlapped,lpCompletionRoutine);
  218. }
  220. int WINAPI
  221. MyWSASendTo (SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, struct sockaddr* lpTo, int iToLen, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine) {
  222. return OriginalWSASendToProc(s,lpBuffers,dwBufferCount,lpNumberOfBytesSent,dwFlags,lpTo,iToLen,lpOverlapped,lpCompletionRoutine);
  223. }
  225. int WINAPI
  226. MyWSARecv (SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
  227. {
  228. return OriginalWSARecvProc(s,lpBuffers,dwBufferCount,lpNumberOfBytesRecvd,lpFlags,lpOverlapped,lpCompletionRoutine);
  229. }
  231. int WINAPI
  232. MyWSARecvFrom (SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, struct sockaddr* lpFrom, LPINT lpFromlen, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
  233. {
  234. return OriginalWSARecvFromProc(s,lpBuffers,dwBufferCount,lpNumberOfBytesRecvd,lpFlags,lpFrom,lpFromlen,lpOverlapped,lpCompletionRoutine);
  235. }
  237. int WINAPI
  238. MySelect (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout)
  239. {
  240. EnterCriticalSection (&CS_dataAvailableFromKore);
  241. if (dataAvailableFromKore) {
  242. dataAvailableFromKore = false;
  243. LeaveCriticalSection (&CS_dataAvailableFromKore);
  244. return 1;
  245. }
  246. LeaveCriticalSection (&CS_dataAvailableFromKore);
  247. return OriginalSelectProc(nfds, readfds, writefds, exceptfds, timeout);
  248. }
  250. int WINAPI
  251. MySend (SOCKET s, char* buf, int len, int flags)
  252. {
  253. int ret;
  255. // See if the socket to the RO server is still alive, and make
  256. // sure WSAGetLastError() returns the right error if something's wrong
  257. EnterCriticalSection (&CS_ro);
  258. roServer = s;
  259. LeaveCriticalSection (&CS_ro);
  260. ret = OriginalSendProc (s, buf, 0, flags);
  262. if (ret != SOCKET_ERROR & len > 0) {
  263. bool isAlive;
  265. // Is Kore running?
  266. EnterCriticalSection (&CS_koreClientIsAlive);
  267. isAlive = koreClientIsAlive;
  268. LeaveCriticalSection (&CS_koreClientIsAlive);
  270. if (isAlive) {
  271. // Don't send this packet to the RO server; send it to the X-Kore server instead
  272. char *newbuf = (char *) malloc (len + 3);
  274. unsigned short sLen = (unsigned short) len;
  275. memcpy (newbuf, "S", 1);
  276. memcpy (newbuf + 1, &sLen, 2);
  277. memcpy (newbuf + 3, buf, len);
  279. // We put this packet in a string, and let the X-Kore client thread send it
  280. EnterCriticalSection (&CS_send);
  281. xkoreSendBuf.append (newbuf, len + 3);
  282. LeaveCriticalSection (&CS_send);
  283. free (newbuf);
  284. return len;
  286. } else {
  287. // Send packet directly to the RO server
  288. ret = OriginalSendProc (s, buf, len, flags);
  289. return ret;
  290. }
  291. } else
  292. return ret;
  293. }
  295. int WINAPI
  296. MySendTo (SOCKET s, char* buf, int len, int flags, struct sockaddr* to, int tolen)
  297. {
  298. return OriginalSendToProc(s,buf,len,flags, to, tolen);
  299. }
  301. int WINAPI
  302. MyRecv (SOCKET s, char* buf, int len, int flags)
  303. {
  304. int ret = 0;
  305. int ret2 = 0;
  307. EnterCriticalSection (&CS_ro);
  308. roServer = s;
  309. LeaveCriticalSection (&CS_ro);
  311. // Is Kore running?
  312. EnterCriticalSection (&CS_koreClientIsAlive);
  313. bool isAlive = koreClientIsAlive;
  314. LeaveCriticalSection (&CS_koreClientIsAlive);
  316. if (isAlive) {
  317. // Data that the RO server sent
  318. if (dataWaiting(s)) {
  319. // Grab data
  320. ret2 = OriginalRecvProc(s, buf, len, flags);
  321. if (ret2 != SOCKET_ERROR && ret2 > 0) {
  322. // Redirect it to Kore
  323. char *newbuf = (char *) malloc (ret2 + 3);
  324. unsigned short sLen = (unsigned short) ret2;
  325. memcpy (newbuf, "R", 1);
  326. memcpy (newbuf + 1, &sLen, 2);
  327. memcpy (newbuf + 3, buf, ret2);
  329. EnterCriticalSection(&CS_send);
  330. xkoreSendBuf.append (newbuf, ret2 + 3);
  331. LeaveCriticalSection(&CS_send);
  333. free (newbuf);
  335. } else if (ret2 == 0 || (ret2 == SOCKET_ERROR && WSAGetLastError () != WSAEWOULDBLOCK)) {
  336. // Connection with RO server closed
  337. EnterCriticalSection(&CS_ro);
  338. roServer = INVALID_SOCKET;
  339. LeaveCriticalSection(&CS_ro);
  340. }
  341. }
  343. // Pass data from Kore to RO Client
  344. EnterCriticalSection (&CS_rosend);
  345. int roSendBufsize = roSendBuf.size();
  346. if (roSendBufsize) {
  347. ret = roSendBufsize < len? roSendBufsize : len;
  348. memcpy (buf, (char *) roSendBuf.c_str (), ret);
  349. roSendBuf.erase (0, ret);
  350. } else {
  351. WSASetLastError (WSAEWOULDBLOCK);
  352. ret = SOCKET_ERROR;
  353. }
  354. LeaveCriticalSection (&CS_rosend);
  355. } else {
  356. EnterCriticalSection (&CS_rosend);
  357. int roSendBufsize = roSendBuf.size();
  358. LeaveCriticalSection (&CS_rosend);
  359. if (roSendBufsize) {
  360. // Flush out anything left thats kore->ROclient
  361. ret = roSendBufsize < len? roSendBufsize : len;
  362. EnterCriticalSection (&CS_rosend);
  363. memcpy (buf, (char *) roSendBuf.c_str(), ret);
  364. roSendBuf.erase(0, ret);
  365. LeaveCriticalSection (&CS_rosend);
  366. } else {
  367. ret2 = OriginalRecvProc(s, buf, len, flags);
  368. if (ret2 == 0 || (ret2 == SOCKET_ERROR && WSAGetLastError () != WSAEWOULDBLOCK)) {
  369. EnterCriticalSection(&CS_ro);
  370. roServer = INVALID_SOCKET;
  371. LeaveCriticalSection(&CS_ro);
  372. }
  373. ret = ret2;
  374. }
  375. }
  377. return ret;
  378. }
  380. int WINAPI
  381. MyRecvFrom (SOCKET s, char* buf, int len, int flags, struct sockaddr* from, int *fromlen)
  382. {
  383. return OriginalRecvFromProc(s,buf,len,flags,from,fromlen);
  384. }
  386. int WINAPI
  387. MyConnect (SOCKET s, struct sockaddr* name, int namelen)
  388. {
  389. EnterCriticalSection (&CS_ro);
  390. roServer = s;
  391. LeaveCriticalSection (&CS_ro);
  392. return OriginalConnectProc(s, name, namelen);
  393. }
  395. int WINAPI
  396. MyWSAAsyncSelect (SOCKET s, HWND hWnd, unsigned int wMsg, long lEvent)
  397. {
  398. EnterCriticalSection (&CS_ro);
  399. roServer = s;
  400. LeaveCriticalSection (&CS_ro);
  401. OriginalWSAAsyncSelectProc(s,hWnd,wMsg,lEvent);
  402. return 0;
  403. }
  405. FARPROC WINAPI
  406. MyGetProcAddress (HMODULE hModule, LPCSTR lpProcName)
  407. {
  408. FARPROC ret = OriginalGetProcAddressProc (hModule, lpProcName);
  409. HMODULE WS2_32 = LoadLibrary ("WS2_32.DLL");
  410. if (hModule == WS2_32) {
  411. if (stricmp (lpProcName, "WSASend") == 0) {
  412. OriginalWSASendProc = (MyWSASendProc) ret;
  413. ret = (FARPROC) MyWSASend;
  415. } else if (stricmp (lpProcName, "WSASendTo") == 0) {
  416. OriginalWSASendToProc = (MyWSASendToProc) ret;
  417. ret = (FARPROC) MyWSASendTo;
  419. } else if (stricmp (lpProcName, "WSARecv") == 0) {
  420. OriginalWSARecvProc = (MyWSARecvProc) ret;
  421. ret = (FARPROC) MyWSARecv;
  423. } else if (stricmp (lpProcName, "WSARecvFrom") == 0) {
  424. OriginalWSARecvFromProc = (MyWSARecvFromProc) ret;
  425. ret = (FARPROC) MyWSARecvFrom;
  427. } else if (stricmp (lpProcName, "send") == 0) {
  428. OriginalSendProc = (MySendProc) ret;
  429. ret = (FARPROC) MySend;
  431. } else if (stricmp (lpProcName, "sendto") == 0) {
  432. OriginalSendToProc = (MySendToProc) ret;
  433. ret = (FARPROC) MySendTo;
  435. } else if (stricmp (lpProcName, "recv") == 0) {
  436. OriginalRecvProc = (MyRecvProc) ret;
  437. ret = (FARPROC) MyRecv;
  439. } else if (stricmp (lpProcName, "recvfrom") == 0) {
  440. OriginalRecvFromProc = (MyRecvFromProc) ret;
  441. ret = (FARPROC) MyRecvFrom;
  443. } else if (stricmp (lpProcName, "connect") == 0) {
  444. OriginalConnectProc = (MyConnectProc) ret;
  445. ret = (FARPROC) MyConnect;
  447. } else if (stricmp (lpProcName, "WSAAsyncSelect") == 0) {
  448. OriginalWSAAsyncSelectProc = (MyWSAAsyncSelectProc) ret;
  449. ret = (FARPROC) MyWSAAsyncSelect;
  450. }
  451. }
  452.   return ret;
  453. }
  455. /************************************************/
  458. static void
  459. DoHookProcs ()
  460. {
  461. // Read the comment for HookImportedFunction() in utils-netredirect.cpp
  462. // about what's going on here
  464. OriginalWSASendProc = (MyWSASendProc)
  465. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "WSASend", (PROC)MyWSASend);
  467. OriginalWSASendToProc = (MyWSASendToProc)
  468. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "WSASendTo", (PROC)MyWSASendTo);
  470. OriginalWSARecvProc = (MyWSARecvProc)
  471. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "WSARecv", (PROC)MyWSARecv);
  473. OriginalWSARecvFromProc = (MyWSARecvFromProc)
  474. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "WSARecvFrom", (PROC)MyWSARecvFrom);
  476. OriginalSendProc = (MySendProc)
  477. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "send", (PROC)MySend);
  479. OriginalSendToProc = (MySendToProc)
  480. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "sendto", (PROC)MySendTo);
  482. OriginalRecvProc = (MyRecvProc)
  483. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "recv", (PROC)MyRecv);
  485. OriginalRecvFromProc = (MyRecvFromProc)
  486. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "recvfrom", (PROC)MyRecvFrom);
  488. OriginalConnectProc = (MyConnectProc)
  489. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "connect", (PROC)MyConnect);
  491. OriginalSelectProc = (MySelectProc)
  492. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "select", (PROC)MySelect);
  494. OriginalWSAAsyncSelectProc = (MyWSAAsyncSelectProc)
  495. HookImportedFunction( GetModuleHandle(0), "WS2_32.DLL", "WSAAsyncSelect", (PROC)MyWSAAsyncSelect);
  497. OriginalGetProcAddressProc = (MyGetProcAddressProc)
  498. HookImportedFunction( GetModuleHandle(0), "KERNEL32.DLL", "GetProcAddress", (PROC)MyGetProcAddress);
  499. }
  501. static void
  502. init ()
  503. {
  504. WSAData WSAData;
  505. ULONG threadID;
  507. WSAStartup (MAKEWORD (2,2),&WSAData);
  508. InitializeCriticalSection (&CS_koreClientIsAlive);
  509. InitializeCriticalSection (&CS_dataAvailableFromKore);
  510. InitializeCriticalSection (&CS_ro);
  511. InitializeCriticalSection (&CS_send);
  512. InitializeCriticalSection (&CS_rosend);
  513. debugInit ();
  515. debug ("Hooking functions...n");
  516. DoHookProcs ();
  517. debug ("Creating thread...n");
  518. CreateThread (0, 0, (LPTHREAD_START_ROUTINE) koreConnectionMain, 0, 0, &threadID);
  519. debug ("Thread createdn");
  520. }
  523. /********* DLL injection support for Win9x *********/
  525. //#define TESTING_INJECT9x
  527. static int isNT = 0;
  528. static int started = 0;
  529. static HINSTANCE hDll = 0;
  530. static HHOOK hookID = 0;
  532. static int
  533. start ()
  534. {
  535. init ();
  536. return 0;
  537. }
  539. // This function is called when we're injected into another process
  540. static LRESULT WINAPI
  541. hookProc (int code, WPARAM wParam, LPARAM lParam)
  542. {
  543. if (!started) {
  544. char lib[MAX_PATH];
  545. ULONG threadID;
  547. started = 1;
  548. GetModuleFileName (hDll, lib, MAX_PATH);
  549. if (LoadLibrary (lib))
  550. UnhookWindowsHookEx (hookID);
  552. // For some reason RO crashes if I call init() here.
  553. // Calling it in a thread seems to fix the problem.
  554. // (but won't we get race conditions??)
  555. CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) start, NULL, 0, &threadID);
  556. }
  557. return CallNextHookEx (hookID, code, wParam, lParam);
  558. }
  560. // Inject this DLL into the process that owns window hwnd
  561. extern "C" int WINAPI __declspec(dllexport)
  562. injectSelf (HWND hwnd)
  563. {
  564. int idHook;
  566. if (isNT)
  567. idHook = WH_CALLWNDPROC;
  568. else
  569. idHook = WH_GETMESSAGE;
  571. hookID = SetWindowsHookEx (idHook, (HOOKPROC) hookProc, hDll,
  572. GetWindowThreadProcessId (hwnd, NULL));
  573. if (hookID == NULL)
  574. return 0;
  576. SendMessage (hwnd, WM_USER + 10, 0, 1);
  577. return 1;
  578. }
  580. /***************************************************/
  583. extern "C" BOOL APIENTRY
  584. DllMain (HINSTANCE hInstance, DWORD dwReason, LPVOID _Reserved)
  585. {
  586. switch (dwReason) {
  587. case DLL_PROCESS_ATTACH:
  588. hDll = hInstance;
  590. // Check whether debugging should be enabled
  591. HKEY key;
  592. DWORD type, size;
  593. BYTE val[1024];
  595. size = sizeof (val) - 1;
  596. val[0] = '';
  597. RegOpenKey (HKEY_CURRENT_USER,
  598. "Software\Kore",
  599. &key);
  600. RegQueryValueEx (key,
  601. "DebugNetRedirect",
  602. NULL,
  603. &type,
  604. val,
  605. &size);
  606. RegCloseKey (key);
  607. enableDebug = val[0] == '1';
  610. #ifndef TESTING_INJECT9x
  611. OSVERSIONINFO version;
  613. version.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
  614. GetVersionEx (&version);
  615. isNT = version.dwPlatformId == VER_PLATFORM_WIN32_NT;
  617. // If we're injected on Win9x, then init() must
  618. // be called from a different function (see above).
  619. // This is because Kore LoadLibrary() this dll when on Win9x.
  620. if (isNT)
  621. init ();
  622. #endif
  623. break;
  625. default:
  626. break;
  627. }
  629. return true;
  630. }