/xliveless.cpp

https://bitbucket.org/zabb65/xliveless-dirt3 · C++ · 1303 lines · 932 code · 190 blank · 181 comment · 104 complexity · 0939c8ba7bb9df41c9cec7e4db0e86fb MD5 · raw file 

    

  1. // -No Copyright- 2010 Stanislav "listener" Golovin

    2. 

  2. // This file donated to the public domain

    3. 

  3. #include "stdafx.h"

    4. 

  4. 

    5. 

  5. typedef ULONGLONG XUID;

    6. 

  6. typedef XUID *PXUID;

    7. 

  7. 

    8. 

  8. typedef struct {

    9. 

  9. 	WORD wActionId;

    10. 

  10. 	WCHAR wszActionText[23];

    11. 

  11. 	DWORD dwFlags;

    12. 

  12. }XCUSTOMACTION;

    13. 

  13. 

    14. 

  14. typedef

    15. 

  15. VOID

    16. 

  16. (WINAPI *PXOVERLAPPED_COMPLETION_ROUTINE)(

    17. 

  17. 	__in    DWORD                       dwErrorCode,

    18. 

  18. 	__in    DWORD                       dwNumberOfBytesTransfered,

    19. 

  19. 	__inout struct _XOVERLAPPED*        pOverlapped);

    20. 

  20. 

    21. 

  21. 

    22. 

  22. typedef struct _XOVERLAPPED {

    23. 

  23. 	ULONG_PTR                           InternalLow;

    24. 

  24. 	ULONG_PTR                           InternalHigh;

    25. 

  25. 	ULONG_PTR                           InternalContext;

    26. 

  26. 	HANDLE                              hEvent;

    27. 

  27. 	PXOVERLAPPED_COMPLETION_ROUTINE     pCompletionRoutine;

    28. 

  28. 	DWORD_PTR                           dwCompletionContext;

    29. 

  29. 	DWORD                               dwExtendedError;

    30. 

  30. }XOVERLAPPED, *PXOVERLAPPED;

    31. 

  31. 

    32. 

  32. #ifndef NO_TRACE

    33. 

  33. CRITICAL_SECTION d_lock;

    34. 

  34. static FILE * logfile;

    35. 

  35. XLIVELESS_API void trace (char * message, ...) {

    36. 

  36. 	if (!logfile)

    37. 

  37. 		return;

    38. 

  38. 	EnterCriticalSection (&d_lock);

    39. 

  39. 	if (!logfile)

    40. 

  40. 		return;

    41. 

  41. 	SYSTEMTIME	t;

    42. 

  42. 	GetLocalTime (&t);	

    43. 

  43. 	fprintf (logfile, "%02d/%02d/%04d %02d:%02d:%02d.%03d ", t.wDay, t.wMonth, t.wYear, t.wHour, t.wMinute, t.wSecond, t.wMilliseconds);

    44. 

  44. 	va_list	arg;	

    45. 

  45. 	va_start (arg, message);

    46. 

  46. 	vfprintf (logfile, message, arg);

    47. 

  47.  fflush (logfile);

    48. 

  48. 	va_end (arg); 

    49. 

  49. 	LeaveCriticalSection (&d_lock);

    50. 

  50. }

    51. 

  51. #else

    52. 

  52. #undef trace

    53. 

  53. #define trace(message, ...)

    54. 

  54. #endif

    55. 

  55. 

    56. 

  56. XLIVELESS_API GameVersion dwGameVersion = GvUnknown;	

    57. 

  57. XLIVELESS_API DWORD	dwLoadOffset = 0x400000;	

    58. 

  58. 

    59. 

  59. // Delphi don't support importing variables from DLL

    60. 

  60. XLIVELESS_API GameVersion getGameVersion () { return dwGameVersion; }

    61. 

  61. XLIVELESS_API DWORD getLoadOffset () { return dwLoadOffset; }

    62. 

  62. 

    63. 

  63. XLIVELESS_API void injectFunction (DWORD dwAddress, DWORD pfnReplacement) {

    64. 

  64. 	dwAddress += dwLoadOffset;

    65. 

  65. 	BYTE * patch = (BYTE *)dwAddress;

    66. 

  66. 	*patch = 0xE9;	// JMP

    67. 

  67. 	*(DWORD *)(patch+1) = (pfnReplacement-(dwAddress+5));	

    68. 

  68. }

    69. 

  69. 

    70. 

  70. 

    71. 

  71. // === Start of xlive functions ===

    72. 

  72. // TODO: move all GfWL functions to the separate file

    73. 

  73. // #1: XWSAStartup

    74. 

  74. extern "C"  int __stdcall XWSAStartup (WORD wVersionRequested, LPWSADATA lpWsaData) { 

    75. 

  75. 	lpWsaData->wVersion = 2;

    76. 

  76. 	trace ("XWSAStartup \n");

    77. 

  77. 	return 0;

    78. 

  78. }

    79. 

  79. 

    80. 

  80. // #2: XWSACleanup

    81. 

  81. extern "C"  void __stdcall XWSACleanup () {	// XWSACleanup

    82. 

  82. 	trace ("XWSACleanup\n");

    83. 

  83. }

    84. 

  84. 

    85. 

  85. // #3: XCreateSocket

    86. 

  86. extern "C"  SOCKET __stdcall XCreateSocket (int af, int type, int protocol) { 

    87. 

  87. 	trace ("XCreateSocket (%d, %d, %d)\n", af, type, protocol);

    88. 

  88. 	return INVALID_SOCKET;

    89. 

  89. }

    90. 

  90. 

    91. 

  91. // #4: XSockeClose

    92. 

  92. extern "C"  int __stdcall XSockeClose (SOCKET s) {	

    93. 

  93. 	trace ("XSockeClose)\n");

    94. 

  94. 	return 0;

    95. 

  95. }

    96. 

  96. 

    97. 

  97. // #5: XSocketShutdown

    98. 

  98. extern "C"  int __stdcall XSocketShutdown (SOCKET s, int how) {	

    99. 

  99. 	trace ("XSocketShutdown\n");

    100. 

  100. 	return 0;

    101. 

  101. }

    102. 

  102. 

    103. 

  103. // #6: XSocketIOCTLSocket

    104. 

  104. extern "C"  int __stdcall XSocketIOCTLSocket (SOCKET s, long cmd, long * argp) {

    105. 

  105. 	trace ("XSocketIOCTLSocket\n");

    106. 

  106. 	return 0;

    107. 

  107. }

    108. 

  108. 

    109. 

  109. // #7: XSocketSetSockOpt

    110. 

  110. extern "C"  int __stdcall XSocketSetSockOpt (SOCKET s, DWORD, DWORD, DWORD, DWORD) {

    111. 

  111. 	trace ("XSocketSetSockOpt\n");

    112. 

  112. 	return 0;

    113. 

  113. }

    114. 

  114. 

    115. 

  115. // #9: XSocketGetSockName

    116. 

  116. extern "C"  int __stdcall XSocketGetSockName (SOCKET s, sockaddr_in * name, int * namelen) {

    117. 

  117. 	trace ("XSocketGetSockName\n");

    118. 

  118. 	if (namelen && name && *namelen == sizeof (sockaddr_in)) 

    119. 

  119. 		memset (name, 0, sizeof (sockaddr_in));

    120. 

  120. 	return 0;

    121. 

  121. }

    122. 

  122. 

    123. 

  123. // #11: XSocketBind

    124. 

  124. extern "C"  SOCKET __stdcall XSocketBind (SOCKET s, sockaddr_in * addr, int * addrlen) {

    125. 

  125. 	trace ("XSocketBind\n");

    126. 

  126. 	return INVALID_SOCKET;

    127. 

  127. }

    128. 

  128. 

    129. 

  129. // #12: XSocketConnect

    130. 

  130. extern "C"  int __stdcall XSocketConnect (SOCKET s, sockaddr_in * addr, int * addrlen) {

    131. 

  131. 	trace ("XSocketConnect\n");

    132. 

  132. 	return 0;

    133. 

  133. }

    134. 

  134. 

    135. 

  135. // #13: XSocketListen

    136. 

  136. extern "C"  int __stdcall XSocketListen (SOCKET s, int backlog) { 

    137. 

  137. 	trace ("XSocketListen\n");

    138. 

  138. 	return 0;

    139. 

  139. }

    140. 

  140. 

    141. 

  141. // #14: XSocketAccept

    142. 

  142. extern "C"  SOCKET __stdcall XSocketAccept (SOCKET s, sockaddr_in * addr, int * addrlen) { 

    143. 

  143. 	trace ("XSocketAccept\n");

    144. 

  144. 	return INVALID_SOCKET;

    145. 

  145. }

    146. 

  146. 

    147. 

  147. // #15: XSocketSelect

    148. 

  148. extern "C"  int __stdcall XSocketSelect (int n, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, const struct timeval * timeout) { 

    149. 

  149. 	trace ("XSocketSelect\n");

    150. 

  150. 	return 0;

    151. 

  151. }

    152. 

  152. 

    153. 

  153. // #18: XSocketRecv

    154. 

  154. extern "C"  int __stdcall XSocketRecv (SOCKET s, char * buf, int len, int flags) { 

    155. 

  155. 	return 0;

    156. 

  156. }

    157. 

  157. 

    158. 

  158. // #20: XSocketRecvFrom

    159. 

  159. extern "C"  int __stdcall XSocketRecvFrom (SOCKET s, char * buf, int len, int flags, sockaddr_in * from, int fromlen) { 

    160. 

  160. 	return 0;

    161. 

  161. }

    162. 

  162. 

    163. 

  163. // #22: XSocketSend

    164. 

  164. extern "C"  int __stdcall XSocketSend (SOCKET s, char * buf, int len, int flags) {

    165. 

  165. 	return 0;

    166. 

  166. }

    167. 

  167. 

    168. 

  168. // #24: XSocketSendTo

    169. 

  169. extern "C"  int __stdcall XSocketSendTo (SOCKET s, char * buf, int len, int flags, sockaddr_in * to, int tolen) { 

    170. 

  170. 	return 0;

    171. 

  171. }

    172. 

  172. 

    173. 

  173. // #26: XSocketInet_Addr

    174. 

  174. extern "C"  int __stdcall XSocketInet_Addr (char *) { 

    175. 

  175. 	trace ("XSocketInet_Addr\n");

    176. 

  176. 	return 0;

    177. 

  177. }

    178. 

  178. 

    179. 

  179. // #27: XWSAGetLastError

    180. 

  180. extern "C"  int __stdcall XWSAGetLastError () {

    181. 

  181. 	return WSAENETDOWN; // 0 ?

    182. 

  182. }

    183. 

  183. 

    184. 

  184. // #37 XSocketHTONL

    185. 

  185. extern "C" DWORD __stdcall XSocketHTONL (DWORD n) {

    186. 

  186. 	return ((n&0xFF000000) >> 24)|((n & 0x00FF0000) >> 8)|((n&0x0000FF00) << 8)|((n & 0x000000FF) << 24);

    187. 

  187. 	//return htonl(n);

    188. 

  188. }

    189. 

  189. 

    190. 

  190. // #38: XSocketNTOHS

    191. 

  191. extern "C"  WORD __stdcall XSocketNTOHS (WORD n) {	

    192. 

  192. 	//return ntohs(n);

    193. 

  193. 	return ((n&0xFF00) >> 8)|((n&0xFF) << 8);

    194. 

  194. }

    195. 

  195. 

    196. 

  196. // #39: XSocketNTOHL

    197. 

  197. extern "C"  DWORD __stdcall XSocketNTOHL (DWORD n) {

    198. 

  198. 	//return ntohl(n);

    199. 

  199. 	return ((n&0xFF000000) >> 24)|((n & 0x00FF0000) >> 8)|((n&0x0000FF00) << 8)|((n & 0x000000FF) << 24);

    200. 

  200. }

    201. 

  201. 

    202. 

  202. // #40 XSocketHTONS

    203. 

  203. extern "C" WORD __stdcall XSocketHTONS (WORD n) {

    204. 

  204. 	return ((n&0xFF00) >> 8)|((n&0xFF) << 8);

    205. 

  205. 	//return htons(n);

    206. 

  206. }

    207. 

  207. 

    208. 

  208. // #51: XNetStartup

    209. 

  209. extern "C"  int __stdcall XNetStartup (void *) { // XNetStartup(XNetStartupParams *)

    210. 

  210. 	trace ("XNetStartup\n");

    211. 

  211. 	return 0;

    212. 

  212. }

    213. 

  213. 

    214. 

  214. // #52: XNetCleanup

    215. 

  215. extern "C"  int __stdcall XNetCleanup () { 

    216. 

  216. 	trace ("xlive_52: XNetCleanup\n");

    217. 

  217. 	return 0;

    218. 

  218. }

    219. 

  219. 

    220. 

  220. // #54: XNetCreateKey

    221. 

  221. extern "C" int __stdcall XNetCreateKey (void * pxnkid, void * pxnkey) { 

    222. 

  222. 	trace ("XNetCreateKey\n");

    223. 

  223. 	return 0;

    224. 

  224. }

    225. 

  225. 

    226. 

  226. // #55: XNetRegisterKey

    227. 

  227. extern "C" int __stdcall XNetRegisterKey (DWORD, DWORD) { 

    228. 

  228. 	return 0;

    229. 

  229. }

    230. 

  230. 

    231. 

  231. // #56: XNetUnregisterKey

    232. 

  232. extern "C" int __stdcall XNetUnregisterKey (DWORD) { 

    233. 

  233. 	return 0;

    234. 

  234. }

    235. 

  235. 

    236. 

  236. // #57: XNetXnAddrToInAddr

    237. 

  237. extern "C"  int __stdcall XNetXnAddrToInAddr (DWORD, DWORD, DWORD * p) { 

    238. 

  238. 	*p = 0;

    239. 

  239. 	return 0;

    240. 

  240. }

    241. 

  241. 

    242. 

  242. // #58: XNetServerToInAddr

    243. 

  243. extern "C"  DWORD __stdcall XNetServerToInAddr (DWORD, DWORD, DWORD) { 

    244. 

  244. 	return 0;

    245. 

  245. }

    246. 

  246. 

    247. 

  247. // #60: XNetInAddrToXnAddr

    248. 

  248. extern "C" DWORD __stdcall XNetInAddrToXnAddr (DWORD, DWORD, DWORD) { 

    249. 

  249. 	return 0;

    250. 

  250. } 

    251. 

  251. 

    252. 

  252. // #63: XNetUnregisterInAddr

    253. 

  253. extern "C"  int __stdcall XNetUnregisterInAddr (DWORD) {

    254. 

  254. 	return 0;

    255. 

  255. }

    256. 

  256. 

    257. 

  257. // #64: XNetXnAddrToMachineId

    258. 

  258. extern "C" DWORD __stdcall XNetXnAddrToMachineId (DWORD, ULONGLONG* out) {

    259. 

  259. 	*out = 0ULL;

    260. 

  260. 	return 0;

    261. 

  261. }

    262. 

  262. 

    263. 

  263. // #65: XNetConnect

    264. 

  264. extern "C" int __stdcall XNetConnect (DWORD) { 

    265. 

  265. 	return 0;

    266. 

  266. }

    267. 

  267. 

    268. 

  268. // #66: XNetGetConnectStatus

    269. 

  269. extern "C"  int __stdcall XNetGetConnectStatus (DWORD) { 

    270. 

  270. 	trace ("XNetGetConnectStatus\n");

    271. 

  271. 	return 0;	

    272. 

  272. }

    273. 

  273. 

    274. 

  274. // #69: XNetQosListen

    275. 

  275. extern "C"  DWORD __stdcall XNetQosListen (DWORD, DWORD, DWORD, DWORD, DWORD) { 

    276. 

  276. 	return 0; 

    277. 

  277. }

    278. 

  278. 

    279. 

  279. // #70: XNetQosLookup

    280. 

  280. extern "C"  DWORD __stdcall XNetQosLookup (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) { 

    281. 

  281. 	return 0; 

    282. 

  282. }

    283. 

  283. 

    284. 

  284. // #71: XNetQosServiceLookup

    285. 

  285. extern "C" DWORD __stdcall XNetQosServiceLookup (DWORD, DWORD, DWORD) { 

    286. 

  286. 	return 0;

    287. 

  287. }

    288. 

  288. 

    289. 

  289. // #72: XNetQosRelease

    290. 

  290. extern "C"  DWORD __stdcall XNetQosRelease (DWORD) {	

    291. 

  291. 	return 0; 

    292. 

  292. }

    293. 

  293. 

    294. 

  294. // #73: XNetGetTitleXnAddr

    295. 

  295. extern "C"  DWORD __stdcall XNetGetTitleXnAddr (DWORD * pAddr) {

    296. 

  296. 	*pAddr = 0x0100007F;	// 127.0.0.1

    297. 

  297. 	return 4; 

    298. 

  298. }

    299. 

  299. 

    300. 

  300. // #75: XNetGetEthernetLinkStatus

    301. 

  301. extern "C"  DWORD __stdcall XNetGetEthernetLinkStatus () { 

    302. 

  302. 	return 1; 

    303. 

  303. }

    304. 

  304. 

    305. 

  305. // #84: XNetSetSystemLinkPort

    306. 

  306. extern "C"  DWORD __stdcall XNetSetSystemLinkPort (DWORD) { 

    307. 

  307. 	return 0; 

    308. 

  308. }

    309. 

  309. 

    310. 

  310. // #473: XCustomGetLastActionPress

    311. 

  311. extern "C" int __stdcall XCustomGetLastActionPress (DWORD, DWORD, DWORD) { 

    312. 

  312. 	trace ("XCustomGetLastActionPress\n");

    313. 

  313. 	return 0;

    314. 

  314. }

    315. 

  315. extern "C" DWORD __stdcall XCustomGetLastActionPressEx (DWORD*, DWORD*, XUID*, WORD*) {

    316. 

  316. 	trace ("XCustomGetLastActionPressEx\n");

    317. 

  317. 	return ERROR_NO_DATA;

    318. 

  318. }

    319. 

  319. 

    320. 

  320. // #651: XNotifyGetNext

    321. 

  321. extern "C"  int __stdcall XNotifyGetNext (HANDLE hNotification, DWORD dwMsgFilter, DWORD * pdwId, void * pParam) {

    322. 

  322. 	return 0;   // no notifications

    323. 

  323. }

    324. 

  324. 

    325. 

  325. // #652: XNotifyPositionUI

    326. 

  326. extern "C" DWORD __stdcall XNotifyPositionUI (DWORD dwPosition) {

    327. 

  327.     trace ("XNotifyPositionUI (%d)\n", dwPosition);

    328. 

  328. 	return 0;

    329. 

  329. }

    330. 

  330. 

    331. 

  331. // #1082: XGetOverlappedExtendedError

    332. 

  332. extern "C"  DWORD __stdcall XGetOverlappedExtendedError (void *) { 

    333. 

  333. 	trace ("XGetOverlappedExtendedError\n");

    334. 

  334. 	return 0;

    335. 

  335. }

    336. 

  336. 

    337. 

  337. // #1083: XGetOverlappedResult

    338. 

  338. extern "C"  DWORD __stdcall XGetOverlappedResult (PXOVERLAPPED buffer, DWORD* pResult, DWORD bWait) { 

    339. 

  339. 	trace ("XGetOverlappedResult(%p, %p, %x)\n", buffer, pResult, bWait);

    340. 

  340. 	if(!buffer)

    341. 

  341. 		return ERROR_INVALID_PARAMETER;

    342. 

  342. 	

    343. 

  343. 	trace ("XGetOverlappedResult(): InternalLow: %x InternalHigh: %x InternalContext: %x, hEvent: %x CompletionRoutine: %p CompletionContext: %p ExtendedError: %x\n",

    344. 

  344. 			buffer->InternalLow, buffer->InternalHigh, buffer->InternalContext, buffer->hEvent, buffer->pCompletionRoutine, buffer->dwCompletionContext, buffer->dwExtendedError);

    345. 

  345. 	if(buffer->InternalLow == 0xC0DEBEEF)

    346. 

  346. 		*pResult = buffer->InternalHigh;

    347. 

  347. 	return 0;

    348. 

  348. }

    349. 

  349. 

    350. 

  350. // #5000: XLiveInitialize

    351. 

  351. extern "C"  int __stdcall XLiveInitialize (DWORD) {	// XLiveInitialize(struct _XLIVE_INITIALIZE_INFO *)

    352. 

  352. 	trace ("XLiveInitialize\n");

    353. 

  353. 	return 0;

    354. 

  354. }

    355. 

  355. 

    356. 

  356. // #5001: XLiveInput

    357. 

  357. extern "C"  int __stdcall XLiveInput (DWORD * p) {

    358. 

  358. 	// trace ("XLiveInput\n");

    359. 

  359. 	p[5] = 0;

    360. 

  360. 	return 1;	// -1 ?

    361. 

  361. }

    362. 

  362. 

    363. 

  363. 

    364. 

  364. // #5002: XLiveRender

    365. 

  365. extern "C"  int __stdcall XLiveRender () {

    366. 

  366. //	trace ("XLiveRender\n");

    367. 

  367. 	return 0;

    368. 

  368. }

    369. 

  369. 

    370. 

  370. // #5003: XLiveUninitialize

    371. 

  371. extern "C"  int __stdcall XLiveUninitialize () { 

    372. 

  372. 	trace ("XLiveUninitialize\n");

    373. 

  373. 	return 0;

    374. 

  374. }

    375. 

  375. 

    376. 

  376. // #5005: XLiveOnCreateDevice

    377. 

  377. extern "C"  int __stdcall XLiveOnCreateDevice (DWORD, DWORD) {

    378. 

  378. 	trace ("XLiveOnCreateDevice\n");

    379. 

  379. 	return 0;

    380. 

  380. }

    381. 

  381. 

    382. 

  382. extern "C" DWORD __stdcall xlive_5006 () {

    383. 

  383. 	trace ("xlive_5006\n");

    384. 

  384. 	return 0;

    385. 

  385. }

    386. 

  386. 

    387. 

  387. // #5007: XLiveOnResetDevice

    388. 

  388. extern "C"  int __stdcall XLiveOnResetDevice (DWORD) {

    389. 

  389. 	trace ("XLiveOnResetDevice\n");

    390. 

  390. 	return 0;

    391. 

  391. }

    392. 

  392. 

    393. 

  393. // #5008: XHVCreateEngine

    394. 

  394. extern "C"  int __stdcall XHVCreateEngine (DWORD, DWORD, void ** ppEngine) { 

    395. 

  395. 	trace ("XHVCreateEngine\n");

    396. 

  396.     if (ppEngine)

    397. 

  397.         *ppEngine = NULL;

    398. 

  398. 	return -1;	// disable live voice   

    399. 

  399. }

    400. 

  400. 

    401. 

  401. // #5022: XLiveGetUpdateInformation

    402. 

  402. extern "C"  int __stdcall XLiveGetUpdateInformation (DWORD) {

    403. 

  403. 	trace ("XLiveGetUpdateInformation\n");

    404. 

  404. 	return -1; // no update

    405. 

  405. }

    406. 

  406. 

    407. 

  407. // #5024: XLiveUpdateSystem

    408. 

  408. extern "C"  int __stdcall XLiveUpdateSystem (DWORD) {

    409. 

  409. 	trace ("XLiveUpdateSystem\n");

    410. 

  410. 	return -1; // no update

    411. 

  411. }

    412. 

  412. 

    413. 

  413. // #5028

    414. 

  414. extern "C" DWORD __stdcall XLiveSecureLoadLibraryW (LPCWSTR path, HMODULE* handle, DWORD flags) {

    415. 

  415. 	trace ("XLiveSecureLoadLibraryW\n");

    416. 

  416. 	HMODULE module = LoadLibraryExW(path, NULL, flags);

    417. 

  417. 	if(module)

    418. 

  418. 		*handle = module;

    419. 

  419. 	return GetLastError() | REASON_LEGACY_API;

    420. 

  420. }

    421. 

  421. 

    422. 

  422. // #5029

    423. 

  423. extern "C" DWORD __stdcall XLiveSecureFreeLibrary(HMODULE module) {

    424. 

  424. 	trace ("XLiveSecureFreeLibrary\n");

    425. 

  425. 	FreeLibrary(module);

    426. 

  426. 	return GetLastError() | REASON_LEGACY_API;

    427. 

  427. }

    428. 

  428. 

    429. 

  429. // #5030: XLivePreTranslateMessage

    430. 

  430. extern "C"  int __stdcall XLivePreTranslateMessage (DWORD) {

    431. 

  431. 	return 0;

    432. 

  432. }

    433. 

  433. 

    434. 

  434. // #5031 XLiveSetDebugLevel

    435. 

  435. extern "C" int __stdcall XLiveSetDebugLevel (DWORD xdlLevel, DWORD * pxdlOldLevel) { 

    436. 

  436. 	trace ("XLiveSetDebugLevel (%d)\n", xdlLevel);

    437. 

  437. 	return 0;

    438. 

  438. }

    439. 

  439. 

    440. 

  440. // #5214: XShowPlayerReviewUI

    441. 

  441. extern "C"  int __stdcall XShowPlayerReviewUI (DWORD, DWORD, DWORD) {

    442. 

  442. 	trace ("XShowPlayerReviewUI\n");

    443. 

  443. 	return 0;

    444. 

  444. }

    445. 

  445. 

    446. 

  446. // #5215: XShowGuideUI

    447. 

  447. extern "C"  int __stdcall XShowGuideUI (DWORD) {

    448. 

  448. 	trace ("XShowGuideUI\n");

    449. 

  449. 	return 1;

    450. 

  450. }

    451. 

  451. 

    452. 

  452. // #5216: XShowKeyboardUI

    453. 

  453. extern "C" int __stdcall XShowKeyboardUI (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) { 

    454. 

  454. 	trace ("XShowKeyboardUI\n");

    455. 

  455. 	return 0;

    456. 

  456. }

    457. 

  457. 

    458. 

  458. // #5250

    459. 

  459. extern "C" DWORD __stdcall xlive_5250 (DWORD) {

    460. 

  460. 	trace ("xlive_5250\n");

    461. 

  461. 	return 0;

    462. 

  462. }

    463. 

  463. 

    464. 

  464. // #5251: XCloseHandle

    465. 

  465. extern "C"  int __stdcall XCloseHandle (HANDLE handle) {

    466. 

  466. 	trace ("XCloseHandle\n");

    467. 

  467. 	if(!handle || handle == (HANDLE)-1)

    468. 

  468. 	{

    469. 

  469. 		SetLastError(ERROR_INVALID_PARAMETER);

    470. 

  470. 		return ERROR_INVALID_PARAMETER;

    471. 

  471. 	}

    472. 

  472. 	CloseHandle(handle);

    473. 

  473. 	return 0;

    474. 

  474. }

    475. 

  475. 

    476. 

  476. // #5252: XShowGamerCardUI

    477. 

  477. extern "C"  int __stdcall XShowGamerCardUI (DWORD, DWORD, DWORD) {

    478. 

  478. 	trace ("XShowGamerCardUI\n");

    479. 

  479. 	return 0;

    480. 

  480. }

    481. 

  481. 

    482. 

  482. // #5254: XCancelOverlapped

    483. 

  483. extern "C"  int __stdcall XCancelOverlapped (DWORD* buffer) {

    484. 

  484. 	trace ("XCancelOverlapped\n");

    485. 

  485. 	if(buffer[0] == 0xDEADC0DE)

    486. 

  486. 	{

    487. 

  487. 		buffer[0] = 0;

    488. 

  488. 	}

    489. 

  489. 	return 0;

    490. 

  490. }

    491. 

  491. 

    492. 

  492. // #5256: XEnumerate

    493. 

  493. extern "C"  int __stdcall XEnumerate (HANDLE hEnum, void * pvBuffer, DWORD cbBuffer, DWORD * pcItemsReturned, void * pOverlapped) { // XEnumerate

    494. 

  494. 	trace ("XEnumerate (buffer=> %p[%d])\n", pvBuffer, cbBuffer);

    495. 

  495. //    if (pvBuffer && cbBuffer) 

    496. 

  496. //        memset (pvBuffer, 0, cbBuffer);

    497. 

  497. 	if (pcItemsReturned)

    498. 

  498. 		*pcItemsReturned = 0;

    499. 

  499. 	return 0;	// some error ? 

    500. 

  500. }

    501. 

  501. 

    502. 

  502. // #5260: XShowSigninUI

    503. 

  503. extern "C"  int __stdcall XShowSigninUI (DWORD, DWORD) { 

    504. 

  504. 	trace ("XShowSigninUI\n");

    505. 

  505. 	return 0;

    506. 

  506. }

    507. 

  507. 

    508. 

  508. // #5261: XUserGetXUID

    509. 

  509. extern "C"  int __stdcall XUserGetXUID (DWORD, DWORD * pXuid) {

    510. 

  510. 	trace ("XUserGetXUID\n");

    511. 

  511. 	pXuid[0] = 0xC0DEBEEF;

    512. 

  512. 	pXuid[1] = 0x10001010;

    513. 

  513. 	return 0; // ???

    514. 

  514. }

    515. 

  515. 

    516. 

  516. 

    517. 

  517. // #5262: XUserGetSigninState

    518. 

  518. extern "C"  int __stdcall XUserGetSigninState (DWORD dwUserIndex) {

    519. 

  519. 	trace ("xlive_5262: XUserGetSigninState (%d)\n", dwUserIndex);

    520. 

  520. 	if(dwUserIndex)

    521. 

  521. 		return 0;

    522. 

  522. 	return 2; // eXUserSigninState_SignedInLocally

    523. 

  523. }

    524. 

  524. 

    525. 

  525. // #5263: XUserGetName

    526. 

  526. extern "C"  int __stdcall XUserGetName (DWORD dwUserId, char * pBuffer, DWORD dwBufLen) {

    527. 

  527. 	trace ("xlive_5263: XUserGetName (%d, .. , %d)\n", dwUserId, dwBufLen);

    528. 

  528. 	if (dwBufLen < 8)

    529. 

  529. 		return 1;

    530. 

  530. 	memcpy (pBuffer, "Profile1", 8);

    531. 

  531. 	return 0;

    532. 

  532. }

    533. 

  533. 

    534. 

  534. // #5264: XUserAreUsersFriends

    535. 

  535. extern "C"  int __stdcall XUserAreUsersFriends(DWORD dwUserIndex, DWORD * pXuids, DWORD dwXuidCount, DWORD * pResult, void * pOverlapped) {

    536. 

  536. 	trace ("XUserAreUsersFriends\n");

    537. 

  537.     return ERROR_NOT_LOGGED_ON;

    538. 

  538. }

    539. 

  539. 

    540. 

  540. // #5265: XUserCheckPrivilege

    541. 

  541. extern "C"  int __stdcall XUserCheckPrivilege (DWORD user, DWORD priv, PBOOL b) {

    542. 

  542. 	trace ("XUserCheckPrivilege (%d, %d, ..)\n", user, priv);

    543. 

  543. 	*b = false;

    544. 

  544. 	return ERROR_NOT_LOGGED_ON;

    545. 

  545. }

    546. 

  546. 

    547. 

  547. // #5266

    548. 

  548. extern "C" DWORD __stdcall xlive_5266(DWORD p1, DWORD* p2, DWORD* p3, DWORD p4, DWORD p5, DWORD p6, DWORD p7, DWORD* p8, PXOVERLAPPED p9) {

    549. 

  549. 	trace ("xlive_5266(%x, %p, %p, %x, %p, %x, %x, %p, %p)\n", p1, p2, p3, p4, p5, p6, p7, p8, p9);

    550. 

  550. 	*p8 = 0;

    551. 

  551. 	p9->InternalLow = 0xC0DEBEEF;

    552. 

  552. 	p9->InternalHigh = 0;

    553. 

  553. 	return 0;

    554. 

  554. }

    555. 

  555. 

    556. 

  556. struct XUSER_SIGNIN_INFO {

    557. 

  557.    DWORD	xuidL; // 0

    558. 

  558.    DWORD	xuidH; // 4

    559. 

  559.    DWORD    dwInfoFlags; // 8

    560. 

  560.    DWORD	UserSigninState; // 12

    561. 

  561.    DWORD    dwGuestNumber; // 16

    562. 

  562.    DWORD    dwSponsorUserIndex; // 20

    563. 

  563.    CHAR     szUserName[16]; // 24

    564. 

  564. };

    565. 

  565. 

    566. 

  566. // #5267: XUserGetSigninInfo

    567. 

  567. extern "C"  int __stdcall XUserGetSigninInfo (DWORD dwUser, DWORD dwFlags, XUSER_SIGNIN_INFO * pInfo) {  

    568. 

  568. 	//trace ("XUserGetSigninInfo (%d, %d, ...)\n", dwUser, dwFlags);

    569. 

  569. 	memset(pInfo, 0, sizeof(XUSER_SIGNIN_INFO));

    570. 

  570. 	if(dwFlags & 2)

    571. 

  571. 	{

    572. 

  572. 		pInfo->UserSigninState = 2;

    573. 

  573. 	}

    574. 

  574. 	else

    575. 

  575. 	{

    576. 

  576. 		pInfo->UserSigninState = 1;

    577. 

  577. 	}

    578. 

  578. 	pInfo->xuidL = 0x10001010;

    579. 

  579. 	pInfo->xuidH = 0xC0DEBEEF;

    580. 

  580. 	pInfo->dwInfoFlags = 1;

    581. 

  581. 	pInfo->dwGuestNumber = 0;

    582. 

  582. 	pInfo->dwSponsorUserIndex = 254;

    583. 

  583. 	strcpy(pInfo->szUserName, "Profile1");

    584. 

  584. 	return 0;

    585. 

  585. }

    586. 

  586. 

    587. 

  587. // #5270: XNotifyCreateListener

    588. 

  588. extern "C"  HANDLE __stdcall XNotifyCreateListener (DWORD l, DWORD h) {

    589. 

  589. 	trace ("xlive_5270: XNotifyCreateListener (0x%08x%08x)\n", h, l);

    590. 

  590. 	return (HANDLE)1; // any non-zero value. (zero treated as fatal error)

    591. 

  591. }

    592. 

  592. 

    593. 

  593. // #5273: XUserReadGamerpictureByKey

    594. 

  594. extern "C" int __stdcall XUserReadGamerpictureByKey (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) { 

    595. 

  595. 	trace ("XUserReadGamerpictureByKey\n");

    596. 

  596. 	return 0;

    597. 

  597. }

    598. 

  598. 

    599. 

  599. // #5274: unknown friend api

    600. 

  600. extern "C" DWORD __stdcall xlive_5274(DWORD, DWORD, DWORD, DWORD) {

    601. 

  601. 	trace ("xlive_5274\n");

    602. 

  602. 	return 0;

    603. 

  603. }

    604. 

  604. 

    605. 

  605. // #5275: XShowFriendsUI

    606. 

  606. extern "C" int __stdcall XShowFriendsUI (DWORD) {

    607. 

  607. 	trace ("XShowFriendsUI\n");

    608. 

  608. 	return 0;

    609. 

  609. }

    610. 

  610. 

    611. 

  611. // #5276: XUserSetProperty

    612. 

  612. extern "C"  int __stdcall XUserSetProperty (DWORD, DWORD, DWORD, DWORD) {

    613. 

  613. 	trace ("XUserSetProperty\n");

    614. 

  614. 	return 0;

    615. 

  615. }

    616. 

  616. 

    617. 

  617. // #5277: XUserSetContext

    618. 

  618. extern "C"  int __stdcall XUserSetContext (DWORD, DWORD, DWORD) {

    619. 

  619. 	trace ("XUserSetContext\n");

    620. 

  620. 	return 0;

    621. 

  621. }

    622. 

  622. 

    623. 

  623. // #5278: XUserWriteAchievements

    624. 

  624. extern "C"  DWORD __stdcall XUserWriteAchievements (DWORD, DWORD, DWORD) {

    625. 

  625. 	trace ("XUserWriteAchievements\n");

    626. 

  626. 	return 0;

    627. 

  627. }

    628. 

  628. 

    629. 

  629. // #5280: XUserCreateAchievementEnumerator

    630. 

  630. extern "C"  DWORD __stdcall XUserCreateAchievementEnumerator (DWORD dwTitleId, DWORD dwUserIndex, DWORD xuidL, DWORD xuidHi, DWORD dwDetailFlags, DWORD dwStartingIndex, DWORD cItem, DWORD * pcbBuffer, HANDLE * phEnum) {

    631. 

  631. 	trace ("XUserCreateAchievementEnumerator (dwStartingIndex=>%d, cItem=>%d \n", dwStartingIndex, cItem);

    632. 

  632.     if (pcbBuffer)

    633. 

  633.         *pcbBuffer = 0;

    634. 

  634.     if (phEnum)

    635. 

  635. 	    *phEnum = INVALID_HANDLE_VALUE;

    636. 

  636. 	return 1;   // return error (otherwise, 0-size buffer will be allocated)

    637. 

  637. }

    638. 

  638. 

    639. 

  639. // #5281: XUserReadStats

    640. 

  640. extern "C"  DWORD __stdcall XUserReadStats (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD * pcbResults, DWORD * pResults, void *) { 

    641. 

  641. 	trace ("XUserReadStats\n");

    642. 

  642. 	if (pcbResults)	

    643. 

  643. 		*pcbResults = 4;

    644. 

  644. 	if (pResults)

    645. 

  645. 		*pResults = 0;

    646. 

  646. 	return 0;

    647. 

  647. }

    648. 

  648. 

    649. 

  649. // #5284: XUserCreateStatsEnumeratorByRank

    650. 

  650. extern "C"  DWORD __stdcall XUserCreateStatsEnumeratorByRank (DWORD dwTitleId, DWORD dwRankStart, DWORD dwNumRows, DWORD dwNuStatSpec, void * pSpecs, DWORD * pcbBuffer, PHANDLE phEnum) { 

    651. 

  651. 	trace ("XUserCreateStatsEnumeratorByRank\n");

    652. 

  652.     if (pcbBuffer)

    653. 

  653.         *pcbBuffer = 0;

    654. 

  654. 	*phEnum = INVALID_HANDLE_VALUE;

    655. 

  655. 	return 1;

    656. 

  656. }

    657. 

  657. 

    658. 

  658. // #5286: XUserCreateStatsEnumeratorByXuid

    659. 

  659. extern "C"  DWORD __stdcall XUserCreateStatsEnumeratorByXuid (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD * pcbBuffer, PHANDLE phEnum) { 

    660. 

  660. 	trace ("XUserCreateStatsEnumeratorByXuid\n");

    661. 

  661.     if (pcbBuffer)

    662. 

  662.         pcbBuffer = 0;

    663. 

  663. 	*phEnum = INVALID_HANDLE_VALUE;

    664. 

  664. 	return 1;

    665. 

  665. }

    666. 

  666. 

    667. 

  667. // #5292: XUserSetContextEx

    668. 

  668. extern "C"  int __stdcall XUserSetContextEx (DWORD dwUserIndex, DWORD dwContextId, DWORD dwContextValue, void * pOverlapped) {

    669. 

  669. 	trace ("XUserSetContextEx\n");

    670. 

  670. 	return 0;

    671. 

  671. }

    672. 

  672. 

    673. 

  673. // #5293: XUserSetPropertyEx

    674. 

  674. extern "C" int __stdcall XUserSetPropertyEx (DWORD dwUserIndex, DWORD dwPropertyId, DWORD cbValue, void * pvValue, void * pOverlapped) { 

    675. 

  675. 	trace ("XUserSetPropertyEx (%d, 0x%x, ...)\n", dwUserIndex, dwPropertyId);

    676. 

  676. 	return 0;

    677. 

  677. }

    678. 

  678. 

    679. 

  679. // #5297: XLiveInitializeEx

    680. 

  680. extern "C" int __stdcall XLiveInitializeEx (void * pXii, DWORD dwVersion) {

    681. 

  681. 	trace ("XLiveInitializeEx\n");

    682. 

  682. 	return 0;

    683. 

  683. }

    684. 

  684. 	

    685. 

  685. // #5300: XSessionCreate

    686. 

  686. extern "C"  DWORD __stdcall XSessionCreate (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) { 

    687. 

  687. 	trace ("XSessionCreate\n");

    688. 

  688. 	return -1;

    689. 

  689. }

    690. 

  690. 

    691. 

  691. // #5303: XStringVerify

    692. 

  692. extern "C"  DWORD __stdcall XStringVerify (DWORD, DWORD, DWORD, DWORD, DWORD, WORD * pResult, DWORD) { // XStringVerify

    693. 

  693. 	trace ("XStringVerify\n");

    694. 

  694. 	*pResult = 0;

    695. 

  695. 	return 0;

    696. 

  696. }

    697. 

  697. 

    698. 

  698. // #5305: XStorageUploadFromMemory

    699. 

  699. extern "C"  DWORD __stdcall XStorageUploadFromMemory (DWORD, DWORD, DWORD, DWORD, DWORD) { 

    700. 

  700. 	trace ("XStorageUploadFromMemory\n");

    701. 

  701. 	return 0;

    702. 

  702. }

    703. 

  703. 

    704. 

  704. // #5306: XStorageEnumerate

    705. 

  705. extern "C" int __stdcall XStorageEnumerate (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) { // XStorageEnumerate

    706. 

  706. 	trace ("XStorageEnumerate\n");

    707. 

  707. 	return 0;

    708. 

  708. }

    709. 

  709. 

    710. 

  710. extern "C" DWORD __stdcall xlive_5309(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) {

    711. 

  711. 	trace ("xlive_5309\n");

    712. 

  712. 	return 0;

    713. 

  713. }

    714. 

  714. 

    715. 

  715. // #5310: XOnlineStartup

    716. 

  716. extern "C"  int __stdcall XOnlineStartup () { 

    717. 

  717. 	trace ("XOnlineStartup\n");

    718. 

  718. 	return 0; 

    719. 

  719. }

    720. 

  720. 

    721. 

  721. // #5311: XOnlineCleanup

    722. 

  722. extern "C"  int __stdcall XOnlineCleanup () {

    723. 

  723. 	trace ("XOnlineCleanup\n");

    724. 

  724. 	return 0;

    725. 

  725. }

    726. 

  726. 

    727. 

  727. // #5312: XFriendsCreateEnumerator

    728. 

  728. extern "C"  DWORD __stdcall XFriendsCreateEnumerator (DWORD, DWORD, DWORD, DWORD, HANDLE * phEnum) { 

    729. 

  729. 	trace ("XFriendsCreateEnumerator\n");

    730. 

  730. 	*phEnum = INVALID_HANDLE_VALUE;

    731. 

  731. 	return 0; 

    732. 

  732. }

    733. 

  733. 

    734. 

  734. // #5314: XUserMuteListQuery

    735. 

  735. extern "C"  int __stdcall XUserMuteListQuery (DWORD, DWORD, DWORD, DWORD) { 

    736. 

  736. 	trace ("XUserMuteListQuery\n");

    737. 

  737. 	return 0; 

    738. 

  738. }

    739. 

  739. 

    740. 

  740. // #5315: XInviteGetAcceptedInfo

    741. 

  741. extern "C"  int __stdcall XInviteGetAcceptedInfo (DWORD, DWORD) { 

    742. 

  742. 	trace ("XInviteGetAcceptedInfo\n");

    743. 

  743. 	return 1; 

    744. 

  744. }

    745. 

  745. 

    746. 

  746. // #5316: XInviteSend

    747. 

  747. extern "C"  int __stdcall XInviteSend (DWORD, DWORD, DWORD, DWORD, DWORD) { 

    748. 

  748. 	trace ("XInviteSend\n");

    749. 

  749. 	return 0; 

    750. 

  750. }

    751. 

  751. 

    752. 

  752. // #5317: XSessionWriteStats

    753. 

  753. extern "C"  DWORD __stdcall XSessionWriteStats (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) { 

    754. 

  754. 	trace ("XSessionWriteStats\n");

    755. 

  755. 	return 0; 

    756. 

  756. }

    757. 

  757. 

    758. 

  758. // #5318

    759. 

  759. extern "C"  int __stdcall XSessionStart (DWORD, DWORD, DWORD) {

    760. 

  760. 	trace ("XSessionStart\n");

    761. 

  761. 	return 0;

    762. 

  762. }

    763. 

  763. 

    764. 

  764. // #5319: XSessionSearchEx

    765. 

  765. extern "C"  DWORD __stdcall XSessionSearchEx (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) { 

    766. 

  766. 	trace ("XSessionSearchEx\n");

    767. 

  767. 	return 0; 

    768. 

  768. }

    769. 

  769. 

    770. 

  770. // #5320

    771. 

  771. extern "C" DWORD __stdcall xlive_5320 (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) {

    772. 

  772. 	trace ("xlive_5320\n");

    773. 

  773. 	return 0;

    774. 

  774. }

    775. 

  775. 

    776. 

  776. // #5321

    777. 

  777. extern "C" DWORD __stdcall xlive_5321 (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD* p9, DWORD) {

    778. 

  778. 	trace ("xlive_5321\n");

    779. 

  779. 	if(p9)

    780. 

  780. 		*p9 = 0;

    781. 

  781. 	return 0;

    782. 

  782. }

    783. 

  783. 

    784. 

  784. // #5322: XSessionModify

    785. 

  785. extern "C"  DWORD __stdcall XSessionModify (DWORD, DWORD, DWORD, DWORD, DWORD) { 

    786. 

  786. 	trace ("XSessionModify\n");

    787. 

  787. 	return 0; 

    788. 

  788. }

    789. 

  789. 

    790. 

  790. // #5323: XSessionMigrateHost

    791. 

  791. extern "C"  DWORD __stdcall XSessionMigrateHost (DWORD, DWORD, DWORD, DWORD) {  

    792. 

  792. 	trace ("XSessionMigrateHost\n");

    793. 

  793. 	return 0; 

    794. 

  794. }

    795. 

  795. 

    796. 

  796. // #5324: XOnlineGetNatType

    797. 

  797. extern "C"  int __stdcall XOnlineGetNatType () { 

    798. 

  798. 	trace ("XOnlineGetNatType\n");

    799. 

  799. 	return 0; 

    800. 

  800. }

    801. 

  801. 

    802. 

  802. // #5325: XSessionLeaveLocal

    803. 

  803. extern "C"  DWORD __stdcall XSessionLeaveLocal (DWORD, DWORD, DWORD, DWORD) { 

    804. 

  804. 	trace ("XSessionLeaveLocal\n");

    805. 

  805. 	return 0; 

    806. 

  806. }

    807. 

  807. 

    808. 

  808. // #5326: XSessionJoinRemote

    809. 

  809. extern "C"  DWORD __stdcall XSessionJoinRemote (DWORD, DWORD, DWORD, DWORD, DWORD) { 

    810. 

  810. 	trace ("XSessionJoinRemote\n");

    811. 

  811. 	return 0; 

    812. 

  812. }

    813. 

  813. 

    814. 

  814. // #5327: XSessionJoinLocal

    815. 

  815. extern "C"  DWORD __stdcall XSessionJoinLocal (DWORD, DWORD, DWORD, DWORD, DWORD) { 

    816. 

  816. 	trace ("XSessionJoinLocal\n");

    817. 

  817. 	return 0; 

    818. 

  818. }

    819. 

  819. 

    820. 

  820. // #5328: XSessionGetDetails

    821. 

  821. extern "C"  DWORD __stdcall XSessionGetDetails (DWORD, DWORD, DWORD, DWORD) { 

    822. 

  822. 	trace ("XSessionGetDetails\n");

    823. 

  823. 	return 0; 

    824. 

  824. }

    825. 

  825. 

    826. 

  826. // #5329: XSessionFlushStats

    827. 

  827. extern "C"  int __stdcall XSessionFlushStats (DWORD, DWORD) { 

    828. 

  828. 	trace ("XSessionFlushStats\n");

    829. 

  829. 	return 0; 

    830. 

  830. }

    831. 

  831. 

    832. 

  832. // #5330: XSessionDelete

    833. 

  833. extern "C"  DWORD __stdcall XSessionDelete (DWORD, DWORD) { 

    834. 

  834. 	trace ("XSessionDelete\n");

    835. 

  835. 	return 0; 

    836. 

  836. }

    837. 

  837. 

    838. 

  838. struct XUSER_READ_PROFILE_SETTINGS {

    839. 

  839. 	DWORD	dwLength;

    840. 

  840. 	BYTE *	pSettings;

    841. 

  841. };

    842. 

  842. 

    843. 

  843. // #5331: XUserReadProfileSettings

    844. 

  844. extern "C"  DWORD __stdcall XUserReadProfileSettings (DWORD dwTitleId, DWORD dwUserIndex, DWORD dwNumSettingIds, 

    845. 

  845. 					DWORD * pdwSettingIds, DWORD * pcbResults, XUSER_READ_PROFILE_SETTINGS * pResults, DWORD pOverlapped) {

    846. 

  846. 	trace ("XUserReadProfileSettings (%d, %d, %d, ..., %d, ...)\n", dwTitleId, dwUserIndex, dwNumSettingIds, *pcbResults);

    847. 

  847. 	if (*pcbResults < 1036) {

    848. 

  848. 		*pcbResults = 1036;	// TODO: make correct calculation by IDs.

    849. 

  849. 		return ERROR_INSUFFICIENT_BUFFER;

    850. 

  850. 	}

    851. 

  851. 	memset (pResults, 0, *pcbResults);

    852. 

  852. 	pResults->dwLength = *pcbResults-sizeof (XUSER_READ_PROFILE_SETTINGS);

    853. 

  853. 	pResults->pSettings = (BYTE *)pResults+sizeof (XUSER_READ_PROFILE_SETTINGS);

    854. 

  854. 	return 0;

    855. 

  855. }

    856. 

  856. 

    857. 

  857. // #5332: XSessionEnd

    858. 

  858. extern "C"  int __stdcall XSessionEnd (DWORD, DWORD) {	

    859. 

  859. 	trace ("XSessionEnd\n");

    860. 

  860. 	return 0;

    861. 

  861. }

    862. 

  862. 

    863. 

  863. // #5333: XSessionArbitrationRegister

    864. 

  864. extern "C"  DWORD __stdcall XSessionArbitrationRegister (DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD) { 

    865. 

  865. 	trace ("XSessionArbitrationRegister\n");

    866. 

  866. 	return 0; 

    867. 

  867. }

    868. 

  868. 

    869. 

  869. // #5335: XTitleServerCreateEnumerator

    870. 

  870. extern "C"  DWORD __stdcall XTitleServerCreateEnumerator (LPCSTR pszServerInfo, DWORD cItem, DWORD * pcbBuffer, PHANDLE phEnum) {

    871. 

  871. 	trace ("XTitleServerCreateEnumerator (cItem=> %d)\n", cItem);

    872. 

  872. 	if(pcbBuffer)

    873. 

  873. 		*pcbBuffer = 0;

    874. 

  874. 	*phEnum = INVALID_HANDLE_VALUE;

    875. 

  875. 	return 1;

    876. 

  876. }

    877. 

  877. 

    878. 

  878. // #5336: XSessionLeaveRemote

    879. 

  879. extern "C"  DWORD __stdcall XSessionLeaveRemote (DWORD, DWORD, DWORD, DWORD) { 

    880. 

  880. 	trace ("XSessionLeaveRemote\n");

    881. 

  881. 	return 0; 

    882. 

  882. }

    883. 

  883. 

    884. 

  884. // #5337: XUserWriteProfileSettings

    885. 

  885. extern "C"  DWORD __stdcall XUserWriteProfileSettings (DWORD, DWORD, DWORD, DWORD) {

    886. 

  886. 	trace ("XUserWriteProfileSettings\n");

    887. 

  887. 	return 0;

    888. 

  888. }

    889. 

  889. 

    890. 

  890. // #5339: XUserReadProfileSettingsByXuid

    891. 

  891. extern "C" DWORD __stdcall XUserReadProfileSettingsByXuid (DWORD, DWORD, DWORD, DWORD,DWORD, DWORD,DWORD, DWORD,DWORD) {

    892. 

  892. 	trace ("XUserReadProfileSettingsByXuid\n");

    893. 

  893. 	return 0;

    894. 

  894. }

    895. 

  895. 

    896. 

  896. // #5342

    897. 

  897. extern "C" DWORD __stdcall xlive_5342(DWORD, DWORD, DWORD, DWORD) {

    898. 

  898. 	trace ("xlive_5342\n");

    899. 

  899. 	return 0;

    900. 

  900. }

    901. 

  901. 

    902. 

  902. // #5343: XLiveCalculateSkill

    903. 

  903. extern "C" DWORD __stdcall XLiveCalculateSkill (DWORD, DWORD, DWORD, DWORD, DWORD) { 

    904. 

  904. 	trace ("XLiveCalculateSkill\n");

    905. 

  905. 	return 0;

    906. 

  906. }

    907. 

  907. 

    908. 

  908. // #5344: XStorageBuildServerPath

    909. 

  909. extern "C"  DWORD __stdcall XStorageBuildServerPath (DWORD dwUserIndex, DWORD StorageFacility, 

    910. 

  910. 		void * pvStorageFacilityInfo, DWORD dwStorageFacilityInfoSize, 

    911. 

  911. 		void * pwszItemName, void * pwszServerPath, DWORD * pdwServerPathLength) { 

    912. 

  912. 	trace ("XStorageBuildServerPath\n");

    913. 

  913. 	return 0; 

    914. 

  914. }

    915. 

  915. 

    916. 

  916. // #5345: XStorageDownloadToMemory

    917. 

  917. extern "C"  DWORD __stdcall XStorageDownloadToMemory (DWORD dwUserIndex, DWORD, DWORD, DWORD, DWORD, DWORD, void * ) { 

    918. 

  918. 	trace ("XStorageDownloadToMemory\n");

    919. 

  919. 	return 0; 

    920. 

  920. }

    921. 

  921. 

    922. 

  922. // #5347 XLiveSecureLoadLibraryExW

    923. 

  923. 

    924. 

  924. extern "C" DWORD __stdcall XLiveSecureLoadLibraryExW(DWORD a, DWORD, LPCWSTR lpModuleName, DWORD flags, HMODULE* handle) {

    925. 

  925. 	trace ("XLiveSecureLoadLibraryExW\n");

    926. 

  926. 	if(a)

    927. 

  927. 		return E_INVALIDARG;

    928. 

  928. 	return XLiveSecureLoadLibraryW(lpModuleName, handle, flags);

    929. 

  929. }

    930. 

  930. 

    931. 

  931. // #5348 XLiveSecureCreateFileW

    932. 

  932. extern "C" DWORD __stdcall XLiveSecureCreateFileW (DWORD something, DWORD, LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,

    933. 

  933. 													DWORD, DWORD dwFlagsAndAttributes, HANDLE* fileHandle)

    934. 

  934. {

    935. 

  935. 	trace ("XLiveSecureCreateFileW %S\n", lpFileName);

    936. 

  936. 	if ( something )

    937. 

  937. 		return E_INVALIDARG;

    938. 

  938. 

    939. 

  939. 	*fileHandle = CreateFileW(

    940. 

  940. 					  lpFileName,

    941. 

  941. 					  dwDesiredAccess,

    942. 

  942. 					  dwShareMode,

    943. 

  943. 					  lpSecurityAttributes,

    944. 

  944. 					  3u,

    945. 

  945. 					  dwFlagsAndAttributes,

    946. 

  946. 					  0);

    947. 

  947.   return 0;

    948. 

  948. }

    949. 

  949. 

    950. 

  950. // #5349: XLiveProtectedVerifyFile

    951. 

  951. extern "C" DWORD __stdcall XLiveProtectedVerifyFile (HANDLE hContentAccess, VOID * pvReserved, PCWSTR pszFilePath) {

    952. 

  952. 	trace ("XLiveProtectedVerifyFile\n");

    953. 

  953. 	return 0;

    954. 

  954. }

    955. 

  955. 

    956. 

  956. // #5350: XLiveContentCreateAccessHandle

    957. 

  957. extern "C" DWORD __stdcall XLiveContentCreateAccessHandle (DWORD dwTitleId, void * pContentInfo, 

    958. 

  958. 	DWORD dwLicenseInfoVersion, void * xebBuffer, DWORD dwOffset, HANDLE * phAccess, void * pOverlapped) {

    959. 

  959. 	trace ("XLiveContentCreateAccessHandle\n");

    960. 

  960. 	if (phAccess)

    961. 

  961. 		*phAccess = INVALID_HANDLE_VALUE;

    962. 

  962. 	return E_OUTOFMEMORY;	// TODO: fix it

    963. 

  963. }

    964. 

  964. 

    965. 

  965. // #5352: XLiveContentUninstall

    966. 

  966. extern "C" DWORD __stdcall XLiveContentUninstall (void * pContentInfo, void * pxuidFor, void * pInstallCallbackParams) {

    967. 

  967. 	trace ("XLiveContentUninstall\n");

    968. 

  968. 	return 0;

    969. 

  969. }

    970. 

  970. 

    971. 

  971. // #5354

    972. 

  972. extern "C" DWORD __stdcall xlive_5354(DWORD, DWORD) {

    973. 

  973. 	trace ("xlive_5354\n");

    974. 

  974. 	return 0;

    975. 

  975. }

    976. 

  976. 

    977. 

  977. // #5355: XLiveContentGetPath

    978. 

  978. extern "C" DWORD __stdcall XLiveContentGetPath (DWORD dwUserIndex, void * pContentInfo, wchar_t * pszPath, DWORD * pcchPath) {

    979. 

  979.     trace ("XLiveContentGetPath\n");

    980. 

  980. 	if (pcchPath)

    981. 

  981. 		*pcchPath = 0;

    982. 

  982. 	if (pszPath)

    983. 

  983. 		*pszPath = 0;

    984. 

  984. 	return 0;

    985. 

  985. }

    986. 

  986. 

    987. 

  987. // #5356

    988. 

  988. extern "C" DWORD __stdcall xlive_5356 (DWORD, DWORD, DWORD, DWORD) {

    989. 

  989. 	trace ("xlive_5356\n");

    990. 

  990. 	return 0;

    991. 

  991. }

    992. 

  992. 

    993. 

  993. // #5360: XLiveContentCreateEnumerator

    994. 

  994. extern "C" DWORD __stdcall XLiveContentCreateEnumerator (DWORD, void *, DWORD *pchBuffer, HANDLE * phContent) {

    995. 

  995. 	trace ("XLiveContentCreateEnumerator\n");

    996. 

  996. 	if (phContent)

    997. 

  997. 		*phContent = 0;

    998. 

  998. 		//*phContent = INVALID_HANDLE_VALUE;

    999. 

  999. 	if (pchBuffer)

    1000. 

  1000. 		*pchBuffer = 0;

    1001. 

  1001. 	return 1;

    1002. 

  1002. }

    1003. 

  1003. 

    1004. 

  1004. // #5361: XLiveContentRetrieveOffersByDate

    1005. 

  1005. extern "C" DWORD __stdcall XLiveContentRetrieveOffersByDate (DWORD dwUserIndex, DWORD dwOffserInfoVersion, 

    1006. 

  1006. 	SYSTEMTIME * pstStartDate, void * pOffserInfoArray, DWORD * pcOfferInfo, void * pOverlapped) {

    1007. 

  1007.         trace ("XLiveContentRetrieveOffersByDate\n");

    1008. 

  1008. 	if (pcOfferInfo)

    1009. 

  1009. 		*pcOfferInfo = 0;

    1010. 

  1010. 	return 0;

    1011. 

  1011. } 

    1012. 

  1012. 

    1013. 

  1013. // #5365: XShowMarketplaceUI

    1014. 

  1014. extern "C" DWORD __stdcall XShowMarketplaceUI (DWORD dwUserIndex, DWORD dwEntryPoint, ULONGLONG dwOfferId, DWORD dwContentCategories) {

    1015. 

  1015. 	return 1;

    1016. 

  1016. }

    1017. 

  1017. 

    1018. 

  1018. // === replacements ===

    1019. 

  1019. struct FakeProtectedBuffer {

    1020. 

  1020. 	DWORD	dwMagick;	

    1021. 

  1021. 	DWORD	dwSize;

    1022. 

  1022. 	DWORD	__fill[2]; // To match buffer size in Rick's wrapper

    1023. 

  1023. 	BYTE	bData[4];

    1024. 

  1024. };

    1025. 

  1025. 

    1026. 

  1026. // #5016: XLivePBufferAllocate

    1027. 

  1027. extern "C"  DWORD __stdcall XLivePBufferAllocate (int size, FakeProtectedBuffer ** pBuffer) {

    1028. 

  1028. //	trace ("xlive_5016: XLivePBufferAllocate (%d)\n", size);

    1029. 

  1029. 	*pBuffer = (FakeProtectedBuffer *)malloc (size+16);

    1030. 

  1030. 	if (!*pBuffer) {

    1031. 

  1031. 		trace ("ERROR: XLivePBufferAllocate unable to allocate %d bytes\n", size);

    1032. 

  1032. 		return E_OUTOFMEMORY;

    1033. 

  1033. 	}

    1034. 

  1034. 

    1035. 

  1035. 	(*pBuffer)->dwMagick = 0xDEADDEAD;	// some arbitrary number

    1036. 

  1036. 	(*pBuffer)->dwSize = size;

    1037. 

  1037. 	return 0;

    1038. 

  1038. }

    1039. 

  1039. 

    1040. 

  1040. // #5017: XLivePBufferFree

    1041. 

  1041. extern "C"  DWORD __stdcall XLivePBufferFree (FakeProtectedBuffer * pBuffer) {

    1042. 

  1042. 	// trace ("xlive_5017: XLivePBufferFree\n");

    1043. 

  1043. 	if (pBuffer && pBuffer->dwMagick == 0xDEADDEAD)

    1044. 

  1044. 		free (pBuffer);

    1045. 

  1045. 	return 0;

    1046. 

  1046. }

    1047. 

  1047. 

    1048. 

  1048. // #5295: XLivePBufferSetByteArray

    1049. 

  1049. extern "C"  DWORD __stdcall XLivePBufferSetByteArray (FakeProtectedBuffer * pBuffer, DWORD offset, BYTE * source, DWORD size) {

    1050. 

  1050. 	if (!pBuffer || pBuffer->dwMagick != 0xDEADDEAD || !source || offset < 0 || offset+size > pBuffer->dwSize)

    1051. 

  1051. 		return 0;

    1052. 

  1052. 	memcpy (pBuffer->bData+offset, source, size);

    1053. 

  1053. 	return 0;

    1054. 

  1054. }

    1055. 

  1055. 

    1056. 

  1056. // #5294: XLivePBufferGetByteArray

    1057. 

  1057. extern "C"  DWORD __stdcall XLivePBufferGetByteArray (FakeProtectedBuffer * pBuffer, DWORD offset, BYTE * destination, DWORD size) {

    1058. 

  1058. 	if (!pBuffer || pBuffer->dwMagick != 0xDEADDEAD || !destination || offset < 0 || offset+size > pBuffer->dwSize)

    1059. 

  1059. 		return 0;

    1060. 

  1060. 	memcpy (destination, pBuffer->bData+offset, size);

    1061. 

  1061. 	return 0;

    1062. 

  1062. }

    1063. 

  1063. 

    1064. 

  1064. // #5019: XLivePBufferSetByte

    1065. 

  1065. extern "C"  DWORD __stdcall XLivePBufferSetByte (FakeProtectedBuffer * pBuffer, DWORD offset, BYTE value) {

    1066. 

  1066. 	if (!pBuffer || pBuffer->dwMagick != 0xDEADDEAD || offset < 0 || offset > pBuffer->dwSize)

    1067. 

  1067. 		return 0;

    1068. 

  1068. 	pBuffer->bData[offset] = value;

    1069. 

  1069. 	return 0;

    1070. 

  1070. }

    1071. 

  1071. 

    1072. 

  1072. // #5018: XLivePBufferGetByte

    1073. 

  1073. extern "C"  DWORD __stdcall XLivePBufferGetByte (FakeProtectedBuffer * pBuffer, DWORD offset, BYTE * value) {

    1074. 

  1074. 	if (!pBuffer || pBuffer->dwMagick != 0xDEADDEAD || !value || offset < 0 || offset > pBuffer->dwSize)

    1075. 

  1075. 		return 0;

    1076. 

  1076. 	*value = pBuffer->bData[offset];

    1077. 

  1077. 	return 0;

    1078. 

  1078. }

    1079. 

  1079. 

    1080. 

  1080. // #5020: XLivePBufferGetDWORD

    1081. 

  1081. extern "C" DWORD __stdcall XLivePBufferGetDWORD (FakeProtectedBuffer * pBuffer, DWORD dwOffset, DWORD * pdwValue) {

    1082. 

  1082. 	if (!pBuffer || pBuffer->dwMagick != 0xDEADDEAD || dwOffset < 0 || dwOffset > pBuffer->dwSize-4 || !pdwValue)

    1083. 

  1083. 		return 0;

    1084. 

  1084. 	*pdwValue = *(DWORD *)(pBuffer->bData+dwOffset);

    1085. 

  1085. 	return 0;

    1086. 

  1086. }

    1087. 

  1087. 

    1088. 

  1088. // #5021: XLivePBufferSetDWORD

    1089. 

  1089. extern "C" DWORD __stdcall XLivePBufferSetDWORD (FakeProtectedBuffer * pBuffer, DWORD dwOffset, DWORD dwValue ) {

    1090. 

  1090. 	if (!pBuffer || pBuffer->dwMagick != 0xDEADDEAD || dwOffset < 0 || dwOffset > pBuffer->dwSize-4)

    1091. 

  1091. 		return 0;

    1092. 

  1092. 	*(DWORD *)(pBuffer->bData+dwOffset) = dwValue;

    1093. 

  1093. 	return 0;

    1094. 

  1094. }

    1095. 

  1095. 

    1096. 

  1096. // #5026: XLiveSetSponsorToken

    1097. 

  1097. extern "C" DWORD __stdcall XLiveSetSponsorToken (LPCWSTR pwszToken, DWORD dwTitleId) {

    1098. 

  1098.     trace ("XLiveSetSponsorToken (, 0x%08x)\n", dwTitleId);

    1099. 

  1099.     return S_OK;

    1100. 

  1100. }

    1101. 

  1101. 

    1102. 

  1102. // #5036: XLiveCreateProtectedDataContext

    1103. 

  1103. extern "C"  DWORD __stdcall XLiveCreateProtectedDataContext (DWORD * dwType, PHANDLE pHandle) {

    1104. 

  1104. 	trace ("XLiveCreateProtectedDataContext\n");

    1105. 

  1105. 	if (pHandle)

    1106. 

  1106. 		*pHandle = (HANDLE)1;

    1107. 

  1107. 	return 0;

    1108. 

  1108. }

    1109. 

  1109. 

    1110. 

  1110. // #5037: XLiveQueryProtectedDataInformation

    1111. 

  1111. extern "C"  DWORD __stdcall XLiveQueryProtectedDataInformation (HANDLE h, DWORD * p) {

    1112. 

  1112. 	trace ("XLiveQueryProtectedDataInformation\n");

    1113. 

  1113. 	return 0;

    1114. 

  1114. }

    1115. 

  1115. 

    1116. 

  1116. // #5038: XLiveCloseProtectedDataContext

    1117. 

  1117. extern "C"  DWORD __stdcall XLiveCloseProtectedDataContext (HANDLE h) {

    1118. 

  1118. 	trace ("XLiveCloseProtectedDataContext\n");

    1119. 

  1119. 	return 0;

    1120. 

  1120. }

    1121. 

  1121. 

    1122. 

  1122. // #5035: XLiveUnprotectData

    1123. 

  1123. extern "C"  DWORD __stdcall XLiveUnprotectData (BYTE * pInBuffer, DWORD dwInDataSize, BYTE * pOutBuffer, DWORD * pDataSize, HANDLE * ph) {

    1124. 

  1124. 	trace ("XLiveUnprotectData (..., %d, ..., %d, %d)\n", dwInDataSize, *pDataSize, *(DWORD*)ph);

    1125. 

  1125. 	if (!pDataSize || !ph)	// invalid parameter

    1126. 

  1126. 		return E_FAIL;

    1127. 

  1127. 	*ph = (HANDLE)1;

    1128. 

  1128. 	if (!pOutBuffer || *pDataSize < dwInDataSize) {

    1129. 

  1129. 		*pDataSize = dwInDataSize;

    1130. 

  1130. 		return ERROR_INSUFFICIENT_BUFFER;

    1131. 

  1131. 	}

    1132. 

  1132. 	*pDataSize = dwInDataSize;

    1133. 

  1133. 	memcpy (pOutBuffer, pInBuffer, dwInDataSize);

    1134. 

  1134. 	return 0;

    1135. 

  1135. }

    1136. 

  1136. 

    1137. 

  1137. // #5034: XLiveProtectData

    1138. 

  1138. extern "C"  DWORD __stdcall XLiveProtectData (BYTE * pInBuffer, DWORD dwInDataSize, BYTE * pOutBuffer, DWORD * pDataSize, HANDLE h) {

    1139. 

  1139. 	trace ("XLiveProtectData (..., %d, ..., %d, %d)\n", dwInDataSize, *pDataSize, (DWORD)h);

    1140. 

  1140. 	*pDataSize = dwInDataSize;

    1141. 

  1141. 	if (pOutBuffer)

    1142. 

  1142. 	{

    1143. 

  1143. 		memcpy (pOutBuffer, pInBuffer, dwInDataSize);

    1144. 

  1144. 	}

    1145. 

  1145. 	else

    1146. 

  1146. 	{

    1147. 

  1147. 		return 0x8007007A;

    1148. 

  1148. 	}

    1149. 

  1149. 	return 0;

    1150. 

  1150. }

    1151. 

  1151. 

    1152. 

  1152. // #5367

    1153. 

  1153. extern "C" DWORD __stdcall xlive_5367 (HANDLE, DWORD, DWORD, BYTE *, DWORD) {

    1154. 

  1154.     trace  ("xlive_5367\n");

    1155. 

  1155.     return 1;

    1156. 

  1156. }

    1157. 

  1157. 

    1158. 

  1158. // #5372

    1159. 

  1159. extern "C" DWORD __stdcall xlive_5372 (HANDLE, DWORD, DWORD, DWORD, BYTE *, HANDLE) {

    1160. 

  1160.     trace ("xlive_5372\n");

    1161. 

  1161.     return 1;

    1162. 

  1162. }

    1163. 

  1163. 

    1164. 

  1164. // === end of xlive functions ===

    1165. 

  1165. 

    1166. 

  1166. static char * pszPath = "";

    1167. 

  1167. 

    1168. 

  1168. // change savefile path to "%USERPROFILE%\Documents\Rockstar Games\GTA IV\savegames\"

    1169. 

  1169. void getSavefilePath (int __unused, char * pBuffer, char * pszSaveName) {

    1170. 

  1170. 	strcpy_s (pBuffer, 256, pszPath);

    1171. 

  1171. 	strcat_s (pBuffer, 256, "savegames");

    1172. 

  1172. 

    1173. 

  1173. 	// check path and create directory if necessary

    1174. 

  1174. 	DWORD attrs = GetFileAttributes (pBuffer);

    1175. 

  1175. 	if (attrs == INVALID_FILE_ATTRIBUTES) 

    1176. 

  1176. 		CreateDirectory (pBuffer, NULL);

    1177. 

  1177. 	else if (!(attrs & FILE_ATTRIBUTE_DIRECTORY)) {

    1178. 

  1178. 		trace ("ERROR: unable to create directory '%s', file '%s' already exists\n", pBuffer);

    1179. 

  1179. 		strcpy_s (pBuffer, 256, pszSaveName);

    1180. 

  1180. 		return;

    1181. 

  1181. 	}

    1182. 

  1182. 

    1183. 

  1183. 	if (pszSaveName) {

    1184. 

  1184. 		strcat_s (pBuffer, 256, "\\");

    1185. 

  1185. 		strcat_s (pBuffer, 256, pszSaveName);

    1186. 

  1186. 	}

    1187. 

  1187.     trace ("[getSavefilePath]: '%s'\n", pBuffer);

    1188. 

  1188. }

    1189. 

  1189. 

    1190. 

  1190. void patchCode () {

    1191. 

  1191. 	// get load address of the exe

    1192. 

  1192. 	dwLoadOffset = (DWORD)GetModuleHandle (NULL);

    1193. 

  1193.     trace ("GetModuleHandle returns %08x\n", dwLoadOffset);

    1194. 

  1194. 	

    1195. 

  1195.     // Unprotect image - make .text and .rdata section writeable

    1196. 

  1196.     BYTE * pImageBase = reinterpret_cast<BYTE *>(dwLoadOffset); 

    1197. 

  1197.     PIMAGE_DOS_HEADER   pDosHeader = reinterpret_cast<PIMAGE_DOS_HEADER> (dwLoadOffset);

    1198. 

  1198.     PIMAGE_NT_HEADERS   pNtHeader  = reinterpret_cast<PIMAGE_NT_HEADERS> (pImageBase+pDosHeader->e_lfanew);

    1199. 

  1199.     PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pNtHeader);

    1200. 

  1200.     // trace ("[EXE] NtHeader contains %d sections\n", pNtHeaders->FileHeader.NumberOfSections);

    1201. 

  1201. 

    1202. 

  1202.     for (int iSection = 0; iSection < pNtHeader->FileHeader.NumberOfSections; ++iSection, ++pSection) {

    1203. 

  1203.         char * pszSectionName = reinterpret_cast<char *>(pSection->Name);

    1204. 

  1204.         if (!strcmp (pszSectionName, ".text") || !strcmp (pszSectionName, ".rdata")) {

    1205. 

  1205.             DWORD dwPhysSize = (pSection->Misc.VirtualSize + 4095) & ~4095;    

    1206. 

  1206.             trace ("[EXE] unprotecting section '%s': addr = 0x%08x, size = 0x%08x\n", pSection->Name, pSection->VirtualAddress, dwPhysSize);

    1207. 

  1207. 

    1208. 

  1208.             DWORD	oldProtect;

    1209. 

  1209.             DWORD   newProtect = (pSection->Characteristics & IMAGE_SCN_MEM_EXECUTE) ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;

    1210. 

  1210.             if (!VirtualProtect (reinterpret_cast <VOID *>(dwLoadOffset+pSection->VirtualAddress), dwPhysSize, newProtect, &oldProtect)) {

    1211. 

  1211.                 trace ("[EXE] Virtual protect error\n");

    1212. 

  1212.                 ExitProcess (0);

    1213. 

  1213.             }

    1214. 

  1214.         }

    1215. 

  1215.     }

    1216. 

  1216. 

    1217. 

  1217.     dwLoadOffset -= 0x400000;	 

    1218. 

  1218.     // ExitProcess (0);

    1219. 

  1219. 

    1220. 

  1220. 	// version check

    1221. 

  1221. 	DWORD signature = *(DWORD *)(0x608C34+dwLoadOffset);

    1222. 

  1222. 	switch (signature)

    1223. 

  1223. 	{

    1224. 

  1224. 		default:

    1225. 

  1225. 			trace ("Unknown game version, skipping patches (signature = 0x%08x)\n", signature);

    1226. 

  1226. 			break;

    1227. 

  1227. 	}

    1228. 

  1228. }

    1229. 

  1229. 

    1230. 

  1230. // Plugin Loader

    1231. 

  1231. void loadPlugins (char * pszMask) {	

    1232. 

  1232. 	if (!pszMask)

    1233. 

  1233. 		return;

    1234. 

  1234. 	char * pszType = strrchr (pszMask, '.');

    1235. 

  1235. 	DWORD typeMask = pszType ? *(DWORD *)pszType : 0x6c6c642e; // '.dll'

    1236. 

  1236. 

    1237. 

  1237. 	WIN32_FIND_DATA fd;

    1238. 

  1238. 	char pathName[MAX_PATH];	// module name buffer

    1239. 

  1239. 	char * p = strrchr (pszMask, '\\');

    1240. 

  1240. 	char * namePtr = pathName;

    1241. 

  1241. 	if (p) {

    1242. 

  1242. 		strcpy_s (pathName, MAX_PATH, pszMask);

    1243. 

  1243. 		pathName[p-pszMask+1] = '\0';

    1244. 

  1244. 		namePtr = pathName + (p-pszMask+1);

    1245. 

  1245. 	}

    1246. 

  1246. 

    1247. 

  1247. 

    1248. 

  1248. 	HANDLE asiFile = FindFirstFile (pszMask, &fd);

    1249. 

  1249. 	if (asiFile == INVALID_HANDLE_VALUE)

    1250. 

  1250. 		return;

    1251. 

  1251. 	do {

    1252. 

  1252. 		if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {

    1253. 

  1253. 			int pos = 0;

    1254. 

  1254. 			while (fd.cFileName[pos])

    1255. 

  1255. 				pos++;

    1256. 

  1256. 			DWORD type = *(DWORD *)(fd.cFileName+pos-4);

    1257. 

  1257. 			type |= 0x20202020; // convert to lowercase

    1258. 

  1258. 			if (type == typeMask) {

    1259. 

  1259. 				strcpy (namePtr, fd.cFileName);

    1260. 

  1260. 				if (!LoadLibrary (pathName)) 

    1261. 

  1261. 					trace ("Error loading library %d\n", GetLastError ());

    1262. 

  1262. 				trace ("plugin loader: loaded '%s'\n", pathName);

    1263. 

  1263. 			}

    1264. 

  1264. 

    1265. 

  1265. 		}

    1266. 

  1266. 	} while (FindNextFile (asiFile, &fd));

    1267. 

  1267. 	FindClose (asiFile);

    1268. 

  1268. }

    1269. 

  1269. //=============================================================================

    1270. 

  1270. // Entry Point 

    1271. 

  1271. BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) {

    1272. 

  1272. 	switch (ul_reason_for_call) {

    1273. 

  1273. 	case DLL_PROCESS_ATTACH:

    1274. 

  1274. #ifndef NO_TRACE

    1275. 

  1275. 		logfile = fopen ("xlive_trace.log", "at");  // TODO: move log to the User\Documents or something

    1276. 

  1276. 		if (logfile)

    1277. 

  1277. 			InitializeCriticalSection (&d_lock);

    1278. 

  1278. 		trace ("Log started (xliveless 1.0b1)\n");

    1279. 

  1279. #endif

    1280. 

  1280. 		patchCode ();

    1281. 

  1281. 		loadPlugins ("*.asi");

    1282. 

  1282. 		loadPlugins ("plugins\\*.asi");

    1283. 

  1283. 		loadPlugins ("plugins\\*.dll");

    1284. 

  1284. 		break;

    1285. 

  1285. 	case DLL_THREAD_ATTACH:

    1286. 

  1286. 	case DLL_THREAD_DETACH:

    1287. 

  1287. 		break;

    1288. 

  1288. 	case DLL_PROCESS_DETACH:

    1289. 

  1289. #ifndef NO_TRACE

    1290. 

  1290. 		if (logfile) {

    1291. 

  1291. 			EnterCriticalSection (&d_lock);

    1292. 

  1292. 			fflush (logfile);

    1293. 

  1293. 			fclose (logfile);       

    1294. 

  1294. 			logfile = NULL;

    1295. 

  1295. 			LeaveCriticalSection (&d_lock);

    1296. 

  1296. 			DeleteCriticalSection (&d_lock);

    1297. 

  1297. 		}

    1298. 

  1298. #endif

    1299. 

  1299. 		break;

    1300. 

  1300. 	}

    1301. 

  1301.     return TRUE;

    1302. 

  1302. }
    1303.