├── .gitignore
├── LICENSE
├── README.md
├── cgame.cpp
├── cl_chat.cpp
├── cl_input.cpp
├── cl_main.cpp
├── client.h
├── cod.bmp
├── codextended.cpp
├── common.cpp
├── common.h
├── console.cpp
├── crypt.cpp
├── cvar.cpp
├── discord.cpp
├── dl_main.cpp
├── dl_public.h
├── dllmain.cpp
├── exmaster_client.cpp
├── exmaster_client.h
├── files.cpp
├── fixes.cpp
├── game.cpp
├── hdd_serial_number.h
├── hook.cpp
├── keycodes.h
├── keys.h
├── lib_export.def
├── librarymodule.cpp
├── libs
    ├── detours
    │   ├── detours.h
    │   └── detours.lib
    ├── discord
    │   ├── discord-rpc.lib
    │   ├── discord_register.h
    │   └── discord_rpc.h
    └── libcurl
    │   ├── curl.h
    │   ├── curlver.h
    │   ├── easy.h
    │   ├── header.h
    │   ├── libcurl.lib
    │   ├── libcurl_a.lib
    │   ├── mprintf.h
    │   ├── multi.h
    │   ├── options.h
    │   ├── stdcheaders.h
    │   ├── system.h
    │   ├── typecheck-gcc.h
    │   ├── urlapi.h
    │   └── websockets.h
├── mem_util.h
├── menudef.h
├── mss32.VC.db
├── mss32.cpp
├── mss32.filters
├── mss32.rc
├── mss32.sln
├── mss32.user
├── mss32.vcxproj
├── mss32.vcxproj.user
├── net.cpp
├── render.cpp
├── render.h
├── resource.h
├── shared.cpp
├── shared.h
├── stdafx.cpp
├── stdafx.h
├── stockmapinfo.h
├── targetver.h
├── ui.cpp
├── version.h
├── version_info.h
├── win_authority.cpp
├── win_main.cpp
├── xm_phandler.cpp
├── xuid.cpp
└── xuidtool.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | .vs/
2 | Debug/
3 | Release/
4 | Dev/
5 | EXE/


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Call of Duty Extended [Client]
 2 | 
 3 | CoDExtended Client (1.1x), is a client-side modification for Call of Duty 1 1.1.
 4 | 
 5 | ## Requirements
 6 | - At least PC with Windows XP SP3 Update, but recommended is Windows 10. (Supported OS'es: Win XP SP3,Win 7,Win 10, Win 11), non tested OS'es: Win Vista, Win 8
 7 | - Disabled VirtualStore
 8 | 
 9 | ## Changes/additions
10 | 
11 | - server list name cleanup (removed invalid characters which pushed servers to top)
12 | - fixed  "invalid CD-Key" when using fs_game / mods
13 | - cURL (HTTP/fast) download
14 | - new UI elements (cg_xui_scoreboard, cg_xui_connect, cg_xui_fps)
15 | - Discord Rich Presence
16 | - unlocked FOV
17 | - bugfixes
18 | 
19 | ## Building from source
20 | 
21 | Build with Visual Studio<br>
22 | Rename old mss32.dll to miles32.dll<br>
23 | Copy newly compiled DLL to game directory and rename it to mss32.dll<br>
24 | ???<br>
25 | PROFIT<br>
26 | 
27 | ## Notice
28 | 
29 | The official 1.1x source code is private. This build will not let you play on 1.1x-enforced servers.  
30 | If you wish to add your own features, add your features with a pull request so we can include them in the next official release.
31 | 
32 | Forum: http://xtnded.org  
33 | Discord: http://discord.cod1x.eu  
34 | 
35 | ## License
36 | 
37 | CoDExtended Client is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
38 | 


--------------------------------------------------------------------------------
/cgame.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #include "client.h"
  3 | #include "render.h"
  4 | #include <mmsystem.h>
  5 | #pragma comment(lib, "winmm.lib")
  6 | 
  7 | typedef enum {
  8 | 	CG_R_ADDREFENTITYTOSCREEN = 61,
  9 | 
 10 | 	CG_GETDOBJ = 162,
 11 | 
 12 | 
 13 | 
 14 | 
 15 | 
 16 | 
 17 | 
 18 | 
 19 | 
 20 | 	e_cgame_trap_end
 21 | } e_cgame_trap;
 22 | 
 23 | /* notepad ++ search for regex for e.g more parms with specific syscall num with
 24 | _30074898\([^,]*, 61
 25 | */
 26 | 
 27 | typedef void(*CG_ServerCommand_t)();
 28 | CG_ServerCommand_t CG_ServerCommand;
 29 | 
 30 | const char* disliked_vars[] = { 
 31 | "r_showimages",
 32 | "name",
 33 | "cl_allowdownload",
 34 | "version",
 35 | "cg_norender",
 36 | "cl_avidemo",
 37 | NULL };
 38 | 
 39 | #define M_DrawShadowString(x,y,font,fontscale,color,text,a,b,c) \
 40 | 	RE_SetColor(vColorBlack); \
 41 | 	SCR_DrawString(x + 1,y + 1,font,fontscale,vColorBlack,text,a,b,c); \
 42 | 	RE_SetColor(color); \
 43 | 	SCR_DrawString(x,y,font,fontscale,color,text,a,b,c); \
 44 | 	RE_SetColor(NULL);
 45 | 
 46 | DWORD cgame_mp;
 47 | 
 48 | class ChatMessage {
 49 | public:
 50 | 	std::string msg;
 51 | 	time_t addtime;
 52 | 
 53 | 	ChatMessage() {
 54 | 		addtime = time(NULL);
 55 | 	}
 56 | };
 57 | 
 58 | std::vector<ChatMessage> chatmessages;
 59 | 
 60 | 
 61 | void CG_RemoveChatEscapeChar(char *s) {
 62 | 	char *src, *dest;
 63 | 	for (src = s, dest = s; *src; src++) {
 64 | 		if( *src == '^' && isdigit(*(src + 1)) || isdigit(*src) && src != s && *(src - 1) == '^')
 65 | 			continue;
 66 | 		if (*src != 25 && *src >= 32 && *src <= 126)
 67 | 			*dest++ = *src;
 68 | 	}
 69 | 	*dest = 0;
 70 | }
 71 | 
 72 | char *(*CG_Argv)(int) = nullptr;
 73 | 
 74 | void myCG_ServerCommand(void) {
 75 | 	int argc = Cmd_Argc();
 76 | 	#if 0
 77 | 		Com_Printf("^2CG_ServerCommand: ");
 78 | 		for (int i = 0; i < argc; i++)
 79 | 			Com_Printf("%s ", Cmd_Argv(i));
 80 | 		Com_Printf("\n");
 81 | 	#endif
 82 | 
 83 | 	if (argc > 0) {
 84 | 		char* cmd = Cmd_Argv(0);
 85 | 		if (strlen(cmd) > 0) {
 86 | 			if ((*cmd == 'h' || *cmd == 'i')) {
 87 | 			} else if (*cmd == 'b') {
 88 | 				Com_DPrintf("[CG_ParseScores] b ");
 89 | 				for (size_t i = 0; i < argc; i++) {
 90 | 					Com_DPrintf("%s ", Cmd_Argv(i));
 91 | 				}
 92 | 				Com_DPrintf("\n");
 93 | 			} else if (*cmd == 'v') {
 94 | 				if (argc > 1) {
 95 | 					char* var = Cmd_Argv(1);
 96 | 
 97 | 					for (int i = 0; disliked_vars[i]; i++) {
 98 | 						if (!strcmp(disliked_vars[i], var))
 99 | 							return; // kindly fuck off please (c) php
100 | 					}
101 | 				}
102 | 
103 | 			}
104 | 		}
105 | 	}
106 | 	CG_ServerCommand();
107 | }
108 | 
109 | void pm_aimflag() {
110 | 	int *pm = (int*)(cgame_mp + 0x19D570);
111 | 	int *ps = (int*)*pm;
112 | 	int *gclient = (int*)*ps;
113 | 
114 | 	int *v4 = (int *)(ps + 12);
115 | 
116 | 	int val = *(int*)(gclient + 21); //336? 84*4=336 /84/4=21??
117 | 
118 | 	if (val == 1023) {
119 | 		*v4 |= 0x20;
120 | 		return;
121 | 	}
122 | 
123 | 	void(*call)();
124 | 	*(int*)&call = CGAME_OFF(0x3000FB80);
125 | 	call();
126 | }
127 | 
128 | #define cg_crosshairClientNum (*(int*)CGAME_OFF(0x3020C8C8))
129 | #define cg_renderingThirdPerson (*(int*)CGAME_OFF(0x30207158))
130 | 
131 | typedef enum {
132 | 	TEAM_FREE,
133 | 	TEAM_AXIS,
134 | 	TEAM_ALLIES,
135 | 	TEAM_SPECTATOR,
136 | 
137 | 	TEAM_NUM_TEAMS
138 | } team_t;
139 | 
140 | static const char *teamStrings[] = { "TEAM_FREE", "Axis", "Allies", "Spectator" };
141 | 
142 | typedef struct {
143 | 	int snapsFlags;
144 | 	int ping;
145 | 	int serverTime;
146 | 	//rest
147 | } snapshot_t;
148 | 
149 | typedef struct {
150 | 	int unk;
151 | 	int infoValid;
152 | 	int clientNum;
153 | 	char name[32];
154 | 	team_t team;
155 | 	//down here model names and attachments and rest of client info
156 | } clientInfo_t;
157 | 
158 | typedef struct {
159 | 	float alpha;
160 | 	int clientNum;
161 | 	time_t time;
162 | 	team_t team;
163 | } fadeStatus_t;
164 | 
165 | #define MAX_LAST_NUMS 5
166 | static fadeStatus_t lastNums[MAX_LAST_NUMS] = { 0 };
167 | static int lastNumsIndex = 0;
168 | 
169 | static clientInfo_t *other_info = NULL, *info = NULL;
170 | static int *cent;
171 | 
172 | #define CLIENTINFO_SIZE 0x448
173 | 
174 | void R_AddDebugString(float *origin, float *color, float fontScale, const char* str) {
175 | 	__asm {
176 | 		push str
177 | 			push fontScale
178 | 			mov ebx, origin
179 | 			mov edi, color
180 | 			mov eax, 0x4E0A40
181 | 			call eax
182 | 			add esp, 8
183 | 	}
184 | }
185 | 
186 | void CG_DrawCrosshairNames() {
187 | 	cg_crosshairClientNum = 65;
188 | 	float(*CG_ScanForCrosshairEntity)();
189 | 	*(int*)&CG_ScanForCrosshairEntity = CGAME_OFF(0x30016E50);
190 | 	CG_ScanForCrosshairEntity();
191 | 
192 | 	if (cg_crosshairClientNum > 64)
193 | 		return;
194 | 
195 | 	other_info = (clientInfo_t*)(0x448 * cg_crosshairClientNum + CGAME_OFF(0x3018BC0C));
196 | 	info = (clientInfo_t*)(0x448 * *(int*)(*(int*)CGAME_OFF(0x301E2160) + 184) + CGAME_OFF(0x3018BC0C));
197 | 
198 | 	if (other_info->team == TEAM_ALLIES || other_info->team == TEAM_AXIS) {
199 | 		if (!*(int*)CGAME_OFF(0x3020BA24) && !*(int*)CGAME_OFF(0x3020BA28)) {
200 | 			return;
201 | 		}
202 | 		else if (other_info->team == info->team || info->team == TEAM_SPECTATOR) {
203 | 			for (int i = 0; i < MAX_LAST_NUMS; i++) {
204 | 				if (lastNums[i].alpha > 0 && lastNums[i].clientNum == cg_crosshairClientNum) {
205 | 					lastNums[i].alpha = 1;
206 | 					return;
207 | 				}
208 | 			}
209 | 
210 | 			lastNumsIndex = (lastNumsIndex + 1) % MAX_LAST_NUMS;
211 | 			fadeStatus_t *st = &lastNums[lastNumsIndex];
212 | 			st->clientNum = cg_crosshairClientNum;
213 | 			st->time = *cls_realtime;
214 | 			st->alpha = 1;
215 | 			st->team = other_info->team;
216 | 
217 | 			//float *origin = (float*)FILE_OFF(0x301E2188); //my origin
218 | 			//R_AddDebugString(origin,color,2,other_info->name);
219 | 		}
220 | 	}
221 | }
222 | 
223 | void __cdecl cg_playersprites_sub() {
224 | 
225 | 	other_info = NULL;
226 | 
227 | 	for (int i = 0; i < MAX_LAST_NUMS; i++) {
228 | 		fadeStatus_t *st = &lastNums[i];
229 | 
230 | 		if (st->clientNum != *(int*)((int)cent + 144))
231 | 			continue;
232 | 
233 | 		if (st->alpha <= 0) {
234 | 			st->time = 0;
235 | 			st->alpha = 0;
236 | 			st->clientNum = 65;
237 | 			continue;
238 | 		}
239 | 
240 | 		if (*cls_realtime - st->time > 350) {
241 | 			st->alpha -= 0.1;
242 | 			st->time = *cls_realtime;
243 | 		}
244 | 
245 | 		other_info = (clientInfo_t*)(0x448 * st->clientNum + CGAME_OFF(0x3018BC0C));
246 | 
247 | #ifndef SMALLCHAR_WIDTH
248 | #define SMALLCHAR_WIDTH 48
249 | #endif
250 | 		vec4_t color = { 1, 1, 1, st->alpha };
251 | 		vec3_t org = { 0 };
252 | 		org[0] = *(float*)((int)cent + 504);
253 | 		org[1] = *(float*)((int)cent + 508);
254 | 		org[2] = *(float*)((int)cent + 512) + 80;
255 | 		char tmp_name[64] = { 0 };
256 | 		strcpy(tmp_name, other_info->name);
257 | 		R_AddDebugString(org, color, .5, Q_CleanStr(tmp_name));
258 | 	}
259 | }
260 | 
261 | void(*CG_PlayerSprites)();
262 | void _CG_PlayerSprites() {
263 | 	__asm mov cent, eax
264 | 	CG_PlayerSprites();
265 | 	cg_playersprites_sub();
266 | }
267 | 
268 | void CG_SetHeadNames(int flag) {
269 | 	if (!cgame_mp)
270 | 		return;
271 | 
272 | 	if (*cls_state != 6) // CA_ACTIVE
273 | 		return;
274 | 
275 | 	static char org_bytes[2][5] = {
276 | 		{ 0xA1, 0x2C, 0x90, 0x1D, 0x30 },
277 | 		{ 0xE8, 0xED, 0xF1, 0xFF, 0xFF }
278 | 	};
279 | 	if (!flag) {
280 | 		_memcpy((void*)CGAME_OFF(0x30016F70), &org_bytes[0], 5);
281 | 		_memcpy((void*)CGAME_OFF(0x300282DE), &org_bytes[1], 5);
282 | 		return;
283 | 	}
284 | 	__jmp(CGAME_OFF(0x30016F70), (int)CG_DrawCrosshairNames);
285 | 	__call(CGAME_OFF(0x300282DE), (int)_CG_PlayerSprites);
286 | }
287 | 
288 | void ParseVector(char *s, vec3_t out) {
289 | 	if (!s || !*s)
290 | 		return;
291 | 
292 | 	if (strlen(s) > 200)
293 | 		return;
294 | 	char b[128] = { 0 };
295 | 	int outN = 0, bi = 0;
296 | 	for (int i = 0; s[i] != '\0'; i++) {
297 | 		if ((i != 0 && s[i] == ' ') || s[i + 1] == '\0') {
298 | 			out[outN++] = atof(b);
299 | 			memset(b, 0, sizeof(b));
300 | 			bi = 0;
301 | 		}
302 | 		else {
303 | 			b[bi++] = s[i];
304 | 		}
305 | 
306 | 	}
307 | }
308 | 
309 | char *PrintVector(vec3_t v) {
310 | 	return va("x: %f, y: %f, z: %f", v[0], v[1], v[2]);
311 | }
312 | 
313 | #define M_DrawShadowedString(x, y, fontscale, fontcolor, text) \
314 | 	SCR_DrawString(x+2,y+2, 1, fontscale, vColorBlack, text, NULL, NULL, NULL); \
315 | 	SCR_DrawString(x,y,1,fontscale,fontcolor,text,NULL,NULL,NULL);
316 | 
317 | 
318 | #pragma pack(push, 1)
319 | typedef struct {
320 | 	int clientNum;
321 | 	int score;
322 | 	int ping;
323 | 	int deaths;
324 | 	char *clientName;
325 | 	int statusicon;
326 | } clientScoreInfo_t;
327 | #pragma pack(pop)
328 | 
329 | #include <algorithm>
330 | 
331 | void CG_KeyEvent(int key, int down, unsigned time) {
332 | 	if (keys[key].repeats > 1)
333 | 		return;
334 | 	if (!down)
335 | 		return;
336 | 
337 | 	if (!cgame_mp)
338 | 		return;
339 | }
340 | 
341 | extern cvar_t *cg_drawheadnames;
342 | 
343 | void CG_SCR_DrawScreenField(int stereoFrame) {
344 | 	if (cg_drawheadnames->modified) {
345 | 		void CG_SetHeadNames(int flag);
346 | 		CG_SetHeadNames(cg_drawheadnames->integer);
347 | 	}
348 | }
349 | 
350 | void CG_DrawDisconnect() {
351 | 	cvar_t* xui_interrupted = Cvar_Get("cg_xui_interrupted", "0", CVAR_ARCHIVE);
352 | 	if (xui_interrupted->integer) {
353 | 		void(*call)();
354 | 		*(int*)&call = CGAME_OFF(0x30015450);
355 | 		call();
356 | 	}
357 | }
358 | 
359 | void CG_DrawFPS(float y) {
360 | 	cvar_t* xui_fps = Cvar_Get("cg_xui_fps", "1", CVAR_ARCHIVE);
361 | 
362 | 	if (xui_fps->integer) {
363 | 		cvar_t* x = Cvar_Get("cg_xui_fps_x", "597", CVAR_ARCHIVE); // uh this x y values just look good with my hp bar
364 | 		cvar_t* y = Cvar_Get("cg_xui_fps_y", "8", CVAR_ARCHIVE);
365 | 
366 | 		#define	FPS_FRAMES 4
367 | 		static int previousTimes[FPS_FRAMES];
368 | 		static int index;
369 | 		int	i, total;
370 | 		int	fps;
371 | 		static int previous;
372 | 		int	t, frameTime;
373 | 
374 | 		t = timeGetTime();
375 | 		frameTime = t - previous;
376 | 		previous = t;
377 | 		previousTimes[index % FPS_FRAMES] = frameTime;
378 | 		index++;
379 | 
380 | 		if (index > FPS_FRAMES) {
381 | 			total = 0;
382 | 			for (i = 0; i < FPS_FRAMES; i++) {
383 | 				total += previousTimes[i];
384 | 			}
385 | 			if (!total) {
386 | 				total = 1;
387 | 			}
388 | 			fps = 1000 * FPS_FRAMES / total;
389 | 
390 | 			M_DrawShadowString(x->integer, y->integer, 1, .20, vColorWhite, va("FPS: %d", fps), NULL, NULL, NULL);
391 | 		}
392 | 	} else {
393 | 		void(*call)(float);
394 | 		*(int*)&call = CGAME_OFF(0x30014A00);
395 | 		call(y);
396 | 	}
397 | }
398 | 
399 | void CG_Obituary(int ent) {
400 | 	if (!Cvar_VariableIntegerValue("cg_x_obituary")) return;
401 | 
402 | 	void(*call)(int);
403 | 	*(int*)(&call) = CGAME_OFF(0x3001D6C0);
404 | 	call(ent);
405 | }
406 | 
407 | void PM_ClipVelocity(vec3_t in, vec3_t normal, vec3_t out) {
408 | 	float	backoff;
409 | 	float	change;
410 | 	int		i;
411 | 	float   overbounce = 1.001f;
412 | 
413 | 	backoff = DotProduct(in, normal);
414 | 
415 | 	if (backoff < 0) {
416 | 		backoff *= overbounce;
417 | 	}
418 | 	else {
419 | 		backoff /= overbounce;
420 | 	}
421 | 
422 | 	for (i = 0; i < 3; i++) {
423 | 		change = normal[i] * backoff;
424 | 		out[i] = in[i] - change;
425 | 	}
426 | }
427 | 
428 | // xoxor4d
429 | void PM_ProjectVelocity(vec3_t in, vec3_t normal, vec3_t out) {
430 | 	float speedXY, DotNormalXY, normalisedNormalXY, projectionZ, projectionXYZ;
431 | 
432 | 	speedXY = in[1] * in[1] + in[0] * in[0];
433 | 
434 | 	if ((normal[2]) < 0.001f || (speedXY == 0.0f)) {
435 | 		VectorCopy(in, out);
436 | 	}
437 | 	else {
438 | 		DotNormalXY = normal[1] * in[1] + in[0] * normal[0];
439 | 		normalisedNormalXY = -DotNormalXY / normal[2];
440 | 
441 | 		projectionZ = in[2] * in[2] + speedXY;
442 | 
443 | 		projectionXYZ = sqrtf((projectionZ / (speedXY + normalisedNormalXY * normalisedNormalXY)));
444 | 
445 | 		if (projectionXYZ < 1.0f || normalisedNormalXY < 0.0f || in[2] > 0.0f) {
446 | 			out[0] = projectionXYZ * in[0];
447 | 			out[1] = projectionXYZ * in[1];
448 | 			out[2] = projectionXYZ * normalisedNormalXY;
449 | 		}
450 | 	}
451 | }
452 | 
453 | uint32_t PM_Bounce(vec3_t in, vec3_t normal, vec3_t out) {
454 | 	int x_cl_bounce = atoi(Info_ValueForKey(cs1, "x_cl_bounce"));
455 | 
456 | 	if (x_cl_bounce) {
457 | 		PM_ProjectVelocity(in, normal, out);
458 | 	}
459 | 	else {
460 | 		PM_ClipVelocity(in, normal, out);
461 | 	}
462 | 
463 | 	return CGAME_OFF(0x3000D830);
464 | }
465 | 
466 | __declspec(naked) void PM_Bounce_Stub()
467 | {
468 | 	__asm
469 | 	{
470 | 		push    esi; // out
471 | 		push    ecx; // normal
472 | 		push    edx; // in
473 | 		call    PM_Bounce;
474 | 		add     esp, 12;
475 | 
476 | 		push eax
477 | 			retn;
478 | 	}
479 | }
480 | 
481 | static void (*PM_CheckForChangeWeapon)();
482 | static void (*PM_BeginWeaponChange)(int, int);
483 | static void (*PM_FinishWeaponChange)();
484 | void _PM_CheckForChangeWeapon()
485 | {
486 | 	int* pm = (int*)(cgame_mp + 0x19D570);
487 | 	pmove_t* xm = *(pmove_t**)(int)pm;
488 | 
489 | 	if ((xm->ps->pm_flags & 0x20000))
490 | 	{
491 | 		int* weapon = (int*)((int)xm->ps + 176);
492 | 		if (*weapon)
493 | 		{
494 | 			PM_BeginWeaponChange(*weapon, 0);
495 | 		}
496 | 		return;
497 | 	}
498 | 	PM_CheckForChangeWeapon();
499 | }
500 | 
501 | void _PM_FinishWeaponChange()
502 | {
503 | 	int* pm = (int*)(cgame_mp + 0x19D570);
504 | 	pmove_t* xm = *(pmove_t**)(int)pm;
505 | 
506 | 	if ((xm->ps->pm_flags & 0x20000))
507 | 	{
508 | 		int* weapon = (int*)((int)xm->ps + 176);
509 | 		if (*weapon)
510 | 		{
511 | 			*weapon = 0;
512 | 		}
513 | 		return;
514 | 	}
515 | 	PM_FinishWeaponChange();
516 | }
517 | 
518 | void CG_Init(DWORD base) {
519 | 	cgame_mp = base;
520 | 	CG_ServerCommand = (CG_ServerCommand_t)(cgame_mp + 0x2E0D0);
521 | 	CG_Argv = (char*(*)(int))CGAME_OFF(0x30020960);
522 | 
523 | 	XUNLOCK((void*)CGAME_OFF(0x3020C8C8), sizeof(int));
524 | 
525 | 	XUNLOCK((void*)CGAME_OFF(0x3020C8C8), sizeof(int)); //crosshairnumber
526 | 
527 | 	__call(CGAME_OFF(0x3002E5A6), (int)myCG_ServerCommand);
528 | 	__call(CGAME_OFF(0x3000C799), (int)pm_aimflag);
529 | 	__call(CGAME_OFF(0x3000C7B8), (int)pm_aimflag);
530 | 	__call(CGAME_OFF(0x3000C7D2), (int)pm_aimflag);
531 | 	__call(CGAME_OFF(0x3000C7FF), (int)pm_aimflag);
532 | 	__call(CGAME_OFF(0x3000C858), (int)pm_aimflag);
533 | 	__call(CGAME_OFF(0x3000C893), (int)pm_aimflag);
534 | 	CG_PlayerSprites = (void(*)())CGAME_OFF(0x300274D0);
535 | 
536 | 	__call(CGAME_OFF(0x300159CC), (int)CG_DrawDisconnect);
537 | 	__call(CGAME_OFF(0x300159D4), (int)CG_DrawDisconnect);
538 | 
539 | 	__call(CGAME_OFF(0x3001509E), (int)CG_DrawFPS);
540 | 
541 | 	__call(CGAME_OFF(0x3001E6A1), (int)CG_Obituary);
542 | 
543 | 	*(UINT32*)CGAME_OFF(0x300749EC) = CVAR_ARCHIVE; // Enable cg_fov
544 | 	*(UINT32*)CGAME_OFF(0x30074EBC) = CVAR_ARCHIVE; // Enable cg_thirdperson
545 | 
546 | 	void CG_SetHeadNames(int flag);
547 | 	CG_SetHeadNames(cg_drawheadnames->integer);
548 | 
549 | 	__jmp(CGAME_OFF(0x3000D82B), (int)PM_Bounce_Stub);
550 | 
551 | 	__nop(CGAME_OFF(0x30065550), 1); //weapon 32 fix
552 | 
553 | 	__call(CGAME_OFF(0x30011C25), (int)_PM_CheckForChangeWeapon);
554 | 	__call(CGAME_OFF(0x30011CB4), (int)_PM_FinishWeaponChange);
555 | 	PM_CheckForChangeWeapon = (void(*)())CGAME_OFF(0x300112E0);
556 | 	PM_BeginWeaponChange = (void(*)(int, int))CGAME_OFF(0x30010570);
557 | 	PM_FinishWeaponChange = (void(*)())CGAME_OFF(0x300107c0);
558 | }
559 | 


--------------------------------------------------------------------------------
/cl_chat.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #include "render.h"
  3 | #include "client.h"
  4 | 
  5 | #define GCHAT_BASE_X 50
  6 | #define GCHAT_BASE_Y 20
  7 | #define GCHAT_FONT_TYPE 2
  8 | 
  9 | static const vec4_t gChatColor = {1,1,1,1};
 10 | 
 11 | struct chatmsg {
 12 | 	std::string name;
 13 | 	std::string message;
 14 | 	time_t time;
 15 | 	float opacity;
 16 | 	int clearTimer;
 17 | };
 18 | 
 19 | #define MAX_DISPLAY_MSG 15
 20 | 
 21 | class UIGlobalChatMessageWindow : public UIObject {
 22 | public:
 23 | 
 24 | 	std::vector<chatmsg> messages;
 25 | 
 26 | 	UIGlobalChatMessageWindow(int a, int b, int c, int d) : UIObject(a, b, c, d) {
 27 | 		classType = UIOT_UIGlobalChatMessageWindow;
 28 | 		shader = whiteShader;
 29 | 	}
 30 | 
 31 | 	virtual void Render() {
 32 | 
 33 | 		vec4_t bg_color_lower = { 0, 0, 0, .5 };
 34 | 		vec4_t bg_color = { 0, 0, 0, .85 };
 35 | 		RE_SetColor(bg_color);
 36 | 		SCR_DrawPic(x, y, width, height, *whiteShader);
 37 | 		RE_SetColor(NULL);
 38 | 
 39 | 		const char *sMessage, *sName;
 40 | 		int name_len, msg_count = 0;
 41 | 
 42 | 		time_t curTime = time(NULL);
 43 | 		vec4_t per_color = { gChatColor[0], gChatColor[1], gChatColor[2], 1 };
 44 | 
 45 | 		static bool reset_other_faders = false;
 46 | 		int faders = 0;
 47 | 
 48 | 		for (std::vector<chatmsg>::iterator it = messages.begin(); it != messages.end();) {
 49 | 			name_len = 0;
 50 | 			sMessage = it->message.c_str();
 51 | 			per_color[3] = it->opacity;
 52 | 
 53 | 			if (it->name.size() > 0) {
 54 | 				//sName = va("(difftime = %f and %d) %s: ", difftime(curTime, it->time), *cls_realtime - it->clearTimer, it->name.c_str());
 55 | 				sName = va("%s: ", it->name.c_str());
 56 | 				name_len = SMALLCHAR_WIDTH * CG_DrawStrlen(sName);
 57 | 				SCR_DrawString(x, y + SMALLCHAR_HEIGHT * (msg_count+1), GCHAT_FONT_TYPE, .3, (float*)per_color, sName, NULL, NULL, NULL);
 58 | 			}
 59 | 			SCR_DrawString(x + name_len, y + SMALLCHAR_HEIGHT * (msg_count+1), GCHAT_FONT_TYPE, .3, (float*)per_color, sMessage, NULL, NULL, NULL);
 60 | 
 61 | 			msg_count++;
 62 | 
 63 | 			if (difftime(curTime, it->time) >= 1 && ((messages.size() > MAX_DISPLAY_MSG && !reset_other_faders) || messages.size() - faders > MAX_DISPLAY_MSG)) {
 64 | 				if (!it->clearTimer) {
 65 | 					it->clearTimer = *cls_realtime;
 66 | 					reset_other_faders = true;
 67 | 				}
 68 | 			}
 69 | 
 70 | 			if (it->clearTimer) {
 71 | 				if (*cls_realtime - it->clearTimer > 500)
 72 | 					it->opacity -= 0.007f;
 73 | 				faders++;
 74 | 			}
 75 | 
 76 | 			if (it->opacity <= 0) {
 77 | 				reset_other_faders = false;
 78 | 				it = messages.erase(it);
 79 | 				continue;
 80 | 			}
 81 | 
 82 | 			++it;
 83 | 		}
 84 | 	}
 85 | 
 86 | 	virtual ~UIGlobalChatMessageWindow() {}
 87 | };
 88 | 
 89 | UIGlobalChatMessageWindow *gwindow;
 90 | 
 91 | bool xui_txt_box_OnEnter(UITextbox *o) {
 92 | 	
 93 | 	void Enc_SendTalkMessage(const char *chatmsg);
 94 | 	Enc_SendTalkMessage(o->text.c_str());
 95 | 
 96 | 	return true;
 97 | }
 98 | 
 99 | void CM_CreateWindow(UIMenu *m) {
100 | 	int X_POS = 105;
101 | 	int X_WIDTH = 640;
102 | 	gwindow = xui->createMenuItem<UIGlobalChatMessageWindow>(m, X_POS, 0, X_WIDTH, 430);
103 | 	UITextbox *txt_box = xui->createMenuItem<UITextbox>(m, X_POS, 440, 200, 30);
104 | 	txt_box->SetBackgroundColor(.7, .7, .7, 1);
105 | 	txt_box->m_OnEnter = xui_txt_box_OnEnter;
106 | }
107 | 
108 | void CM_ReceiveHandler(const char *name, const char *message) {
109 | 	//if (gChatMessages.size() > 10)
110 | 		//gChatMessages.clear();
111 | 
112 | 	chatmsg msg;
113 | 	msg.message = message;
114 | 	if (name != NULL) //it's a global broadcast
115 | 		msg.name = name;
116 | 	msg.time = time(NULL);
117 | 	msg.opacity = 1;
118 | 	msg.clearTimer = 0;
119 | 	gwindow->messages.push_back(msg);
120 | }


--------------------------------------------------------------------------------
/cl_input.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | #include "render.h"
 3 | #include "client.h"
 4 | #include "exmaster_client.h"
 5 | 
 6 | qkey_t* keys = (qkey_t*)0x142F780;
 7 | 
 8 | static cvar_t* cl_bypassMouseInput = (cvar_t*)0x142F604;
 9 | 
10 | #define KEY_ENTER 13 //KEY_RETURN?
11 | #define KEY_BACKSPACE 8
12 | 
13 | void CL_CharEvent_(int key) {
14 | 	if (key == (unsigned char)'`' || key == (unsigned char)'~') {
15 | 		return;
16 | 	}
17 | 	if (*cls_keyCatchers & KEYCATCH_CONSOLE) // some day use the field_t types :D:D:DD but for now custom (c) php
18 | 		return;
19 | }
20 | 
21 | #define CALL_CL_KEYEVENT(key) \
22 | 	__asm{push ebx} \
23 | 	__asm{mov ebx, 40E200h} \
24 | 	__asm{mov eax, key} \
25 | 	__asm{call ebx} \
26 | 	__asm{pop ebx}
27 | 
28 | UINT_PTR pcl_charevent = (UINT_PTR)0x40E200;
29 | 
30 | void __declspec(naked) CL_CharEvent() {
31 | 	__asm
32 | 	{
33 | 		push eax
34 | 		call pcl_charevent
35 | 		call CL_CharEvent_
36 | 		add esp, 4
37 | 		retn
38 | 	}
39 | }
40 | 
41 | #define SHIFT_KEY 160
42 | #define SPACE_KEY 32
43 | #define KEY_ESCAPE 27
44 | 
45 | #define IS_TOGGLING_OVERLAY (keys[SHIFT_KEY].down && keys[SPACE_KEY].repeats <= 1 && keys[SPACE_KEY].down && key == SPACE_KEY)
46 | qkey_t qeys[MAX_KEYS] = { 0 };
47 | 
48 | void CL_KeyEvent(int key, int down, unsigned int time) {
49 | 	call<void*, int, int, unsigned>(0x40DC30, key, down, time);
50 | 
51 | 	if (!key)
52 | 		return;
53 | 
54 | 	if (ui_cursor == nullptr)
55 | 		return;
56 | 
57 | 	void CG_KeyEvent(int, int, unsigned);
58 | 	CG_KeyEvent(key, down, time);
59 | 
60 | 	if (*cls_keyCatchers & KEYCATCH_CONSOLE) {
61 | 
62 | 		if (key == 'a' && keys[K_LCTRL].down) {
63 | 			char* consoleBuffer = (char*)0x142F65C;
64 | 			if (CopyToClipboard(consoleBuffer));
65 | 		}
66 | 		return;
67 | 
68 | 	}
69 | 
70 | 	if (!down || !keys[key].down || keys[key].repeats > 1)
71 | 		return;
72 | }
73 | 
74 | UINT_PTR pfield_charevent_return = (UINT_PTR)0x40CB77;
75 | UINT_PTR pfield_charevent_continue = (UINT_PTR)0x40CB23;
76 | 
77 | __declspec(naked) void Field_CharEvent_IgnoreTilde()
78 | {
79 | 	__asm
80 | 	{
81 | 		cmp ebx, 20h
82 | 		jge check
83 | 		jmp pfield_charevent_return
84 | 
85 | 		check :
86 | 		cmp ebx, 126
87 | 			jl checked
88 | 			jmp pfield_charevent_return
89 | 
90 | 			checked :
91 | 		jmp pfield_charevent_continue
92 | 	}
93 | }
94 | 
95 | // cmp ebx, 20h is 3 bytes, we need 5 for a jmp...
96 | // jl ... is 2 bytes 7c54 (assuming when subtracing the addresses)
97 | // so it works out
98 | // - Richard


--------------------------------------------------------------------------------
/cl_main.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #include "client.h"
  3 | #include "render.h"
  4 | #include "version_info.h"
  5 | #include "dl_public.h"
  6 | 
  7 | #pragma comment(lib, "psapi.lib")
  8 | 
  9 | #include "Shlwapi.h"
 10 | 
 11 | cvar_t *cl_running;
 12 | cvar_t *clientname;
 13 | cvar_t *cl_wwwDownload;
 14 | cvar_t *cl_allowDownload;
 15 | cvar_t *cl_console_fraction;
 16 | cvar_t *cl_findshader;
 17 | 
 18 | cvar_t *cg_drawheadnames;
 19 | cvar_t *cg_fov;
 20 | cvar_t* cg_x_discord;
 21 | 
 22 | cvar_t* g_bounce;
 23 | 
 24 | cvar_t* com_hunkmegs;
 25 | cvar_t* x_master;
 26 | 
 27 | cvar_t* r_borderless;
 28 | 
 29 | DWORD __glob_wd_threadid;
 30 | HANDLE __glob_wd_threadhandle;
 31 | std::string res;
 32 | 
 33 | #include <sstream>
 34 | 
 35 | void CL_Connect_f() {
 36 | 	void(*o)() = (void(*)())0x40F6A0;
 37 | 
 38 | 	o();
 39 | 	
 40 |     if (*cls_state == CA_CONNECTING || *cls_state == CA_CHALLENGING) {
 41 |         Cvar_Set("cl_allowDownload", "0");
 42 |     }        
 43 | 
 44 |     char* info = clc_stringData + clc_stringOffsets[1];
 45 |     char *fs_game = Info_ValueForKey(info, "fs_game"); // Reset client fs_game if loaded & server doesn't use it.
 46 | 	if (fs_game == "") {
 47 | 		Cvar_Set("fs_game", ""); 
 48 | 	}
 49 | }
 50 | 
 51 | void(*CL_DownloadsComplete)(void) = (void(*)())0x40FFB0;
 52 | 
 53 | void DL_Name(const char *localName, char* remoteName) {
 54 | 	char *downloadName = Cvar_VariableString("cl_downloadName");
 55 | 	Cvar_Set("cl_downloadName", va("        %s", remoteName)); // Enough spaces to render name fully. :P
 56 | }
 57 | 
 58 | static int use_regular_dl = 0;
 59 | 
 60 | int dl_files_count = 0;
 61 | 
 62 | void WWW_BeginDownload(void) {
 63 | 	char localTempName[MAX_PATH];
 64 | 	char remoteTempName[MAX_PATH];
 65 | 
 66 | 	if (clc_bWWWDl)
 67 | 		return;
 68 | 
 69 | 	char *s;
 70 | 	char *remoteName, *localName;
 71 | 
 72 | 	char* info = clc_stringData + clc_stringOffsets[1];
 73 | 	char *url = Info_ValueForKey(info, "sv_wwwBaseURL");
 74 | 
 75 | 	if (*clc_downloadList) {
 76 | 		s = clc_downloadList;
 77 | 
 78 | 		dl_files_count = 0;
 79 | 		int i;
 80 | 		for (i = 0; i < strlen(clc_downloadList); i++)
 81 | 			if (clc_downloadList[i] == '@')
 82 | 				dl_files_count++;
 83 | 
 84 | 		// @remotename@localname@remotename@localname, etc.
 85 | 
 86 | 		if (*s == '@') {
 87 | 			s++;
 88 | 		}
 89 | 		remoteName = s;
 90 | 
 91 | 		if ((s = strchr(s, '@')) == NULL) {
 92 | 			CL_DownloadsComplete();
 93 | 			return;
 94 | 		}
 95 | 
 96 | 		*s++ = 0;
 97 | 		localName = s;
 98 | 		if ((s = strchr(s, '@')) != NULL) {
 99 | 			*s++ = 0;
100 | 		} else {
101 | 			s = localName + strlen(localName); // point at the nul byte
102 | 		}
103 | 
104 | 		int tmp = use_regular_dl;
105 | 		use_regular_dl = 0;
106 | 		if (cl_wwwDownload->integer && url && *url && !tmp) {
107 | 			Com_Printf("***** WWW_BeginDownload *****\n"
108 | 				"Localname: %s\n"
109 | 				"Remotename: %s\n"
110 | 				"****************************\n", localName, remoteName);
111 | 
112 | 			Cvar_Set("cl_downloadSize", "0");
113 | 			Cvar_Set("cl_downloadCount", "0");
114 | 			Cvar_Set("cl_downloadTime", va("%i", *cls_realtime));
115 | 
116 | 			Q_strncpyz(localTempName, FS_BuildOSPath(Cvar_VariableString("fs_homepath"), localName, ""), sizeof(localTempName));
117 | 			localTempName[strlen(localTempName) - 1] = '\0';
118 | 
119 | 			Q_strncpyz(remoteTempName, FS_BuildOSPath(url, remoteName, ""), sizeof(remoteTempName));
120 | 			remoteTempName[strlen(remoteTempName) - 1] = '\0';
121 | 
122 | 			if (!DL_BeginDownload(localTempName, remoteTempName, 1)) {
123 | 				clc_bWWWDl = false;
124 | 				char *error = va("Download failure while getting '%s'\n", remoteTempName); // get the msg before clearing structs
125 | 
126 | 				Com_Error(ERR_DROP, error);
127 | 				return;
128 | 			}
129 | 
130 | 			clc_bWWWDl = true;
131 | 		}
132 | 
133 | 		*cls_downloadRestart = qtrue;
134 | 
135 | 		memmove(clc_downloadList, s, strlen(s) + 1);
136 | 
137 | 		return;
138 | 	}
139 | 
140 | 	CL_DownloadsComplete();
141 | }
142 | 
143 | void X_CL_NextDownload(void) {
144 | 	char* info = clc_stringData + clc_stringOffsets[1];
145 | 	char* url = Info_ValueForKey(info, "sv_wwwBaseURL");
146 | 	int argc = Cmd_Argc();
147 | 
148 | 	if (argc > 1) {
149 | 		const char* arg1 = Info_ValueForKey(info, "sv_referencedPakNames");
150 | 
151 | 		if (strstr(arg1, ".pk3") != NULL) { //so if extension is not pk3 but is (exe,bat and any other) kick player (So you can't dl .exe,.bat,.cfg)
152 | 			Com_Error(ERR_DROP, "It's likely that this server will infect your computer with malware. \n We do not permit connections to such servers in order to protect your security.");
153 | 			return;
154 | 		}
155 | 	}
156 | 
157 | 	if (cl_wwwDownload->integer && *url)
158 | 		WWW_BeginDownload();
159 | 	else
160 | 		CL_NextDownload();
161 | }
162 | 
163 | void CL_WWWDownload() {
164 | 	dlStatus_t ret = DL_DownloadLoop();
165 | 
166 | 	if (ret == DL_CONTINUE)
167 | 		return;
168 | 
169 | 	if (ret == DL_DONE) {
170 | 		Cvar_Set("cl_downloadName", "");
171 | 		clc_bWWWDl = false;
172 | 		*cls_downloadRestart = 1;
173 | 		CL_DownloadsComplete();
174 | 	} else if (ret == DL_FAILED) {
175 | 		// Perhaps actually check the response? Invalid URL, forbidden, etc?
176 | 		const char* error = va("Download failure while getting %s.\nURL might be invalid.", Cvar_VariableString("dlname_error"));
177 | 		Com_Error(ERR_DROP, error);
178 | 		return;
179 | 	}
180 | }
181 | 
182 | void CL_InitDownloads() {
183 | 	if (clc_bWWWDl)
184 | 		return;
185 | 
186 | 	if (cl_allowDownload->integer && FS_ComparePaks(clc_downloadList, 1024, qtrue)) {
187 | 		Com_Printf("Need paks: %s\n", clc_downloadList);
188 | 		if (*clc_downloadList) { // if autodownloading is not enabled on the server
189 | 			*cls_state = 3;
190 | 			CL_NextDownload();
191 | 			return;
192 | 		}
193 | 	}
194 | 
195 | 	CL_DownloadsComplete();
196 | }
197 | 
198 | void CL_FOVLimit() {
199 | 	int fov = Cvar_VariableIntegerValue("cg_fov");
200 | 	int cheats = atoi(Info_ValueForKey(cs1, "sv_cheats"));
201 | 
202 | 	char* sv_fov_min = Info_ValueForKey(cs1, "sv_fov_min");
203 | 	char* sv_fov_max = Info_ValueForKey(cs1, "sv_fov_max");
204 | 	int fovMin = strlen(sv_fov_min) ? atoi(sv_fov_min) : 80;
205 | 	int fovMax = strlen(sv_fov_max) ? atoi(sv_fov_max) : 95;
206 | 
207 | 	if ((fov < fovMin || fov > fovMax) && cheats != 1) {
208 | 		Com_Printf("cg_fov \"%d\" is invalid. Allowed values: \"%d\" - \"%d\".\n", fov, fovMin, fovMax);
209 | 		Cvar_Set("cg_fov", "80");
210 | 	}
211 | }
212 | 
213 | void CL_FPSLimit() {
214 | 	int fps = Cvar_VariableIntegerValue("com_maxfps");
215 | 	int cheats = atoi(Info_ValueForKey(cs1, "sv_cheats"));
216 | 
217 | 	char* sv_fps_min = Info_ValueForKey(cs1, "sv_fps_min");
218 | 	char* sv_fps_max = Info_ValueForKey(cs1, "sv_fps_max");
219 | 	int fpsMin = strlen(sv_fps_min) ? atoi(sv_fps_min) : 30;
220 | 	int fpsMax = strlen(sv_fps_max) ? atoi(sv_fps_max) : 333;
221 | 
222 | 	if ((fps < fpsMin || fps > fpsMax) && cheats != 1) {
223 | 		Com_Printf("com_maxfps \"%d\" is invalid. Allowed values: \"%d\" - \"%d\".\n", fps, fpsMin, fpsMax);
224 | 		Cvar_Set("com_maxfps", "85");
225 | 	}
226 | }
227 | 
228 | void Disconnect_IfEsc() {
229 | 	if (*cls_state == CA_CONNECTING || *cls_state == CA_CHALLENGING || *cls_state == CA_CONNECTED) {
230 | 		if (GetFocus() && GetKeyState(VK_ESCAPE) & 0x8000)
231 | 		{
232 | 			((void(*)())0x40F5F0)(); //CL_Disconnnect 
233 | 		}
234 | 	}
235 | }
236 | 
237 | void CL_Frame(int msec) {
238 | 	void(*call)(int);
239 | 	*(DWORD*)&call = 0x411280;
240 | 
241 | 	if (!cl_running->integer)
242 | 		return;
243 | 	
244 | 	void Enc_SendHeartbeat();
245 | 	Enc_SendHeartbeat();
246 | 
247 | 	if (clc_bWWWDl)
248 | 		CL_WWWDownload();
249 | 
250 | 	void CL_DiscordFrame();
251 | 	if (cg_x_discord->integer)
252 | 		CL_DiscordFrame();
253 | 
254 | 	CL_FOVLimit();
255 | 	CL_FPSLimit();
256 | 	Disconnect_IfEsc();
257 | 
258 | 	call(msec);
259 | }
260 | 
261 | void Cmd_Borderless() {
262 | 	if (Cmd_Argc() > 1) {
263 | 		Cvar_Set("r_borderless", Cmd_Argv(1));
264 | 
265 | 		if (Cvar_VariableIntegerValue("r_borderless")) {
266 | 			Cvar_Set("r_fullscreen", "0");
267 | 			Cvar_Set("r_mode", "-1");
268 | 			Cvar_Set("com_introplayed", "1");
269 | 		}
270 | 
271 | 		void(*Cbuf_ExecuteText)(const char*);
272 | 		*(UINT32*)&Cbuf_ExecuteText = 0x428A80;
273 | 		char cmd[10];
274 | 		sprintf(cmd, "vid_restart", cmd);
275 | 		Cbuf_ExecuteText(cmd);
276 | 	}
277 | 	else {
278 | 		Com_Printf("\"r_borderless\" is:\"%d\" default: \"0\"\n", Cvar_VariableIntegerValue("r_borderless"));
279 | 	}
280 | }
281 | 
282 | void Cmd_Minimize() {
283 | 	ShowWindow(*gameWindow, SW_MINIMIZE);
284 | }
285 | 
286 | int *whiteShader = (int*)0x15CA630;
287 | 
288 | const char* CL_GetConfigString(int index) {
289 | 	// Check if the index is within bounds
290 | 	if (index < 0 || index >= 2048) {
291 | 		Com_Error(ERR_FATAL, "GetConfigString index out of bounds");
292 | 	}
293 | 
294 | 	// Calculate the offset based on the index
295 | 	int offset = clc_stringOffsets[index];
296 | 
297 | 	// Check if the offset is zero (empty string)
298 | 	if (!offset) {
299 | 		return "";
300 | 	}
301 | 
302 | 	// Return the actual config string
303 | 	return clc_stringData + offset;
304 | }
305 | 
306 | void CL_OpenScriptMenu(void)
307 | {
308 | 	char* parentMenuName;
309 | 	const char* scriptMenuResponse;
310 | 	int menuIndex;
311 | 	char* command;
312 | 	int* dword_163B3E0 = (int*)(0x163B3E0);
313 | 	int* dword_161747C = (int*)(0x161747C);
314 | 
315 | 	if (Cmd_Argc() == 3)
316 | 	{
317 | 		if (*(dword_163B3E0 + 32))
318 | 		{
319 | 			if (dword_161747C)
320 | 			{
321 | 				parentMenuName = Cmd_Argv(1);
322 | 				scriptMenuResponse = Cmd_Argv(2);
323 | 
324 | 				if (parentMenuName && scriptMenuResponse)
325 | 				{
326 | 					menuIndex = -1;
327 | 					for (int i = 0; i < 32; ++i) {
328 | 						const char* configString = CL_GetConfigString(i + 1180);
329 | 
330 | 						if (*configString && !I_stricmp(parentMenuName, configString)) {
331 | 							menuIndex = i;
332 | 							break;
333 | 						}
334 | 					}
335 | 
336 | 					if (menuIndex != -1) {
337 | 						int serverId = Cvar_VariableIntegerValue("sv_serverId");
338 | 						command = va("cmd mr %i %i %s\n", serverId, menuIndex, scriptMenuResponse);
339 | 						void(*Cbuf_ExecuteText)(const char*);
340 | 						*(UINT32*)&Cbuf_ExecuteText = 0x428A80;
341 | 						Cbuf_ExecuteText(command);
342 | 					}
343 | 					else {
344 | 						Com_Printf("Menu '%s' not found!\n", parentMenuName);
345 | 					}
346 | 				}
347 | 			}
348 | 		}
349 | 	}
350 | 	else
351 | 	{
352 | 		Com_Printf("USAGE: openScriptMenu <parent menu name> <script menu response>\n");
353 | 		Com_Printf("EXAMPLE: openScriptMenu quickcommands 1\n");
354 | 	}
355 | }
356 | 
357 | void CL_Init(void) {
358 | 	bool fix_bugs();
359 | 	if (!fix_bugs()) {
360 | 		MsgBox("failed to fix bugs in default cod1");
361 | 		Com_Quit_f();
362 | 	}
363 | 
364 | 	void(*oCL_Init)();
365 | 	*(int*)(&oCL_Init) = 0x411E60;
366 | 
367 | 	oCL_Init();
368 | 
369 | 	cl_running = Cvar_Get("cl_running", "0", 64);
370 | 	clientname = Cvar_Get("name", "Unknown Soldier", 3);
371 | 	cl_wwwDownload = Cvar_Get("cl_wwwDownload", "1", CVAR_ARCHIVE);
372 | 	cl_allowDownload = Cvar_Get("cl_allowDownload", "0", CVAR_ARCHIVE);
373 | 	cl_console_fraction = Cvar_Get("cl_console_fraction", "1.0", CVAR_ARCHIVE);
374 | 	cl_findshader = Cvar_Get("cl_findshader", "not-an-existing-shader", 0);
375 | 	cg_drawheadnames = Cvar_Get("cg_drawheadnames", "0", 0);
376 | 	cg_fov = Cvar_Get("cg_fov", "80", CVAR_ARCHIVE);
377 | 	cg_x_discord = Cvar_Get("cg_x_discord", "1", CVAR_LATCH | CVAR_ARCHIVE);
378 | 	com_hunkmegs = Cvar_Get("com_hunkmegs", "128", CVAR_LATCH | CVAR_ARCHIVE);
379 | 	x_master = Cvar_Get("x_master", "0", CVAR_ARCHIVE);
380 | 	g_bounce = Cvar_Get("g_bounce", "0", CVAR_ARCHIVE);
381 | 
382 | 	Cvar_Get("cg_thirdperson", "0", CVAR_ARCHIVE);
383 | 	Cvar_Set("version", va("COD MP 1.1x build %d %s %s win-x86", BUILDNUMBER, __DATE__, __TIME__));
384 | 	Cvar_Set("shortversion", va("1.1x (%d)", BUILDNUMBER));
385 | 
386 | 	Cvar_Get("cg_x_obituary", "1", 0);
387 | 	Cvar_Get("r_borderless", "0", CVAR_ARCHIVE);
388 | 
389 | 	Cmd_AddCommand("r_borderless", Cmd_Borderless);
390 | 	Cmd_AddCommand("minimize", Cmd_Minimize);
391 | 	Cmd_AddCommand("openScriptMenu", CL_OpenScriptMenu);
392 | 
393 | 	Cvar_Set("r_overbrightbits", "0");
394 | 	Cvar_Set("r_ignorehwgamma", "0");
395 | 	Cvar_Set("cl_languagewarnings", "0");
396 | 	Cvar_Set("cl_languagewarningsaserrors", "0");
397 | 
398 | 	void CL_DiscordInitialize();
399 | 	if (cg_x_discord->integer)
400 | 		CL_DiscordInitialize();
401 | }
402 | 
403 | void SCR_DrawScreenField(stereoFrame_t stereoFrame) { //TODO fix draw after console
404 | 	void(*oSCR_DrawScreenField)(stereoFrame_t);
405 | 	*(int*)(&oSCR_DrawScreenField) = 0x416DD0;
406 | 	oSCR_DrawScreenField(stereoFrame);
407 | 
408 | #if 0
409 | 	extern FILE* dl_file;
410 | 	if (dl_file != NULL) {
411 | 		float color[4] = { 1, 1, 1, 1 };
412 | 		SCR_DrawString(210, 90, 1, .5, color, va("^3%d ^7downloads left", dl_files_count / 2), NULL, NULL, NULL);
413 | 	}
414 | #endif
415 | 
416 | 	void CG_SCR_DrawScreenField(int);
417 | 	CG_SCR_DrawScreenField(stereoFrame);
418 | }
419 | 
420 | char* __cdecl CL_SetServerInfo_HostnameStrncpy(char* a1, char* a2, size_t a3) {
421 | 	return strncpy(a1, Com_CleanHostname(a2, true), a3);
422 | }
423 | 
424 | void CL_GlobalServers_f(void) {
425 | 	if (Cmd_Argc() < 3) {
426 | 		Com_Printf("usage: globalservers <master# 0-1> <protocol> [keywords]\n");
427 | 		return;
428 | 	}
429 | 
430 | 	/*
431 | 	if (x_master->integer) {
432 | 		void XMaster_GetServers();
433 | 		XMaster_GetServers();
434 | 	}
435 | 	*/
436 | 
437 | 	netadr_t to;
438 | 	int i;
439 | 	int count;
440 | 	char* buffptr;
441 | 	char command[1024];
442 | 
443 | 	*cls_numglobalservers = -1;
444 | 	*cls_pingUpdateSource = 1;
445 | 
446 | 	if (x_master->integer) {
447 | 		if (NET_StringToAdr("cod.pm", &to)) {
448 | 			Com_Printf("Requesting servers from CoD 1.1x master...\n");
449 | 		}
450 | 	}
451 | 	else {
452 | 		if (NET_StringToAdr("codmaster.activision.com", &to)) {
453 | 			Com_Printf("Requesting servers from codmaster.activision.com...\n");
454 | 		}
455 | 	}
456 | 
457 | 	short BigShort(short);
458 | 	to.type = NA_IP;
459 | 	to.port = BigShort(20510);
460 | 
461 | 	sprintf(command, "getservers %s", Cmd_Argv(2));
462 | 
463 | 	buffptr = command + strlen(command);
464 | 	count = Cmd_Argc();
465 | 	for (i = 3; i < count; i++)
466 | 		buffptr += sprintf(buffptr, " %s", Cmd_Argv(i));
467 | 
468 | 	NET_OutOfBandPrint(NS_SERVER, to, command);
469 | }


--------------------------------------------------------------------------------
/client.h:
--------------------------------------------------------------------------------
 1 | #define cls_realtime ((int*)0x155F3E0)
 2 | #define cls_state ((int*)0x155F2C0)
 3 | #define cls_downloadRestart ((PINT)0x15EEFBC)
 4 | #define clc_downloadList ((PCHAR)0x15EEBBC)
 5 | #define clc_stringData ((PCHAR)0x1436A7C)
 6 | #define clc_stringOffsets ((PINT)0x1434A7C)
 7 | #define cls_downloadBlock ((PINT)0x15EEBB0)
 8 | #define cls_downloadCount ((PINT)0x15EEBB4)
 9 | #define cls_downloadName ((PCHAR)0x15EEAAC)
10 | #define cls_downloadTempName ((PCHAR)0x15EE9AC)
11 | #define clc_serverAddress ((netadr_t*)0x15CE86C)
12 | #define clc_connectTime ((PINT)0x15CE880)
13 | #define clc_demoplaying ((PINT)0x15EF004)
14 | #define clc_connectPacketCount ((PINT)0x15CE884)
15 | #define cls_keyCatchers ((PINT)0x155F2C4)
16 | #define cls_servername ((char*)0x155F2CC)
17 | #define cls_numglobalservers ((int*)0x1565004)
18 | #define cls_numGlobalServerAddresses ((int*)0x15C1008)
19 | #define cls_pingUpdateSource ((int*)0x15C9C10)
20 | 
21 | static void(*CL_AddReliableCommand)(const char *cmd) = (void(*)(const char*))0x40E2F0;
22 | static const char* (*CL_TranslateStringBuf)(const char *string) = (const char*(*)(const char*))0x4A9E20;
23 | 
24 | #define cs0 (clc_stringData + clc_stringOffsets[0])
25 | #define cs1 (clc_stringData + clc_stringOffsets[1])
26 | 
27 | #define gameWindow ((HWND*)0x16C35E8)
28 | #define glc_vidWidth ((int*)0x16C3AE4)
29 | #define glc_vidHeight ((int*)0x16C3AE8)
30 | 
31 | static bool unlock_client_structure() {
32 | 	__try {
33 | 
34 | 		XUNLOCK((void*)cls_realtime, sizeof(int));
35 | 		XUNLOCK((void*)cls_state, sizeof(int));
36 | 		XUNLOCK((void*)cls_downloadRestart, 4);
37 | 		XUNLOCK((void*)0x155F2C0, 4);
38 | 		XUNLOCK((void*)clc_connectTime, 4);
39 | 		XUNLOCK((void*)clc_demoplaying, 4);
40 | 		XUNLOCK((void*)clc_downloadList, 4096);
41 | 		XUNLOCK((void*)cls_downloadBlock, 4);
42 | 		XUNLOCK((void*)cls_downloadCount, 4);
43 | 		XUNLOCK((void*)0x15EEAAC, 64);
44 | 		XUNLOCK((void*)cls_downloadTempName, 64);
45 | 	}
46 | 	__except (1) {
47 | 		return false;
48 | 	}
49 | 
50 | 	return true;
51 | }


--------------------------------------------------------------------------------
/cod.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xtnded/codextended-client/45af251518a390ab08b1c8713a6a1544b70114a1/cod.bmp


--------------------------------------------------------------------------------
/codextended.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | #include <WinSock2.h>
 3 | 
 4 | bool apply_hooks();
 5 | 
 6 | bool determine_cod_version();
 7 | bool find_cod_version();
 8 | 
 9 | /* any text with __dev__ must be fixed before release */
10 | 
11 | #define ENABLE_CODX
12 | 
13 | void codextended() {
14 | 	srand(time(NULL));
15 | 
16 | 	if (GetModuleHandleA("codextended.dll") != NULL) {
17 | 		return;
18 | 	}
19 | 
20 | 	if (!determine_cod_version()) {
21 | 		if (!find_cod_version()) {
22 | 			MsgBox("Failed to find Call of Duty version, please report this at www.cod1x.eu.");
23 | 			return;
24 | 		}
25 | 	}
26 | 
27 | #ifdef ENABLE_CODX
28 | 	if (!apply_hooks()) {
29 | 		MsgBox("Failed to initialize CoDExtended, please report this at www.cod1x.eu.\n");
30 | 		Com_Quit_f();
31 | 	}
32 | 
33 | #endif
34 | }
35 | 
36 | void codextended_unload() {}
37 | 


--------------------------------------------------------------------------------
/common.cpp:
--------------------------------------------------------------------------------
 1 | #include "common.h"
 2 | 
 3 | Com_DPrintf_t Com_DPrintf = (Com_DPrintf_t)0x435820;
 4 | Com_Printf_t Com_Printf = (Com_Printf_t)0x4357B0;
 5 | Com_Error_t Com_Error = (Com_Error_t)0x435AD0;
 6 | Cmd_RemoveCommand_t Cmd_RemoveCommand = (Cmd_RemoveCommand_t)0x428990;
 7 | Cmd_AddCommand_t Cmd_AddCommand = (Cmd_AddCommand_t)0x428840;
 8 | 
 9 | int Q_vsnprintf(char *dest, int size, const char *fmt, va_list argptr) {
10 | 	int ret;
11 | 
12 | #ifdef _WIN32
13 | #undef _vsnprintf
14 | 	ret = _vsnprintf(dest, size - 1, fmt, argptr);
15 | #define _vsnprintf  use_idStr_vsnPrintf
16 | #else
17 | #undef vsnprintf
18 | 	ret = vsnprintf(dest, size, fmt, argptr);
19 | #define vsnprintf   use_idStr_vsnPrintf
20 | #endif
21 | 	dest[size - 1] = '\0';
22 | 	if (ret < 0 || ret >= size) {
23 | 		return -1;
24 | 	}
25 | 	return ret;
26 | }
27 | 
28 | char *va(char *format, ...) {
29 | 	va_list argptr;
30 | #define MAX_VA_STRING   32000
31 | 	static char temp_buffer[MAX_VA_STRING];
32 | 	static char string[MAX_VA_STRING];      // in case va is called by nested functions
33 | 	static int index = 0;
34 | 	char    *buf;
35 | 	int len;
36 | 
37 | 
38 | 	va_start(argptr, format);
39 | 	vsprintf(temp_buffer, format, argptr);
40 | 	va_end(argptr);
41 | 
42 | 	if ((len = strlen(temp_buffer)) >= MAX_VA_STRING) {
43 | 		Com_Error( ERR_DROP, "Attempted to overrun string in call to va()\n" );
44 | 	}
45 | 
46 | 	if (len + index >= MAX_VA_STRING - 1) {
47 | 		index = 0;
48 | 	}
49 | 
50 | 	buf = &string[index];
51 | 	memcpy(buf, temp_buffer, len + 1);
52 | 
53 | 	index += len + 1;
54 | 
55 | 	return buf;
56 | }


--------------------------------------------------------------------------------
/common.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "stdafx.h"
  4 | #include <WinSock2.h>
  5 | 
  6 | #define MAX_MSGLEN              32768       // max length of a message, which may     
  7 | 
  8 | typedef enum {
  9 | 	NA_BOT,
 10 | 	NA_BAD,                 // an address lookup failed
 11 | 	NA_LOOPBACK,
 12 | 	NA_BROADCAST,
 13 | 	NA_IP,
 14 | 	NA_IPX,
 15 | 	NA_BROADCAST_IPX
 16 | } netadrtype_t;
 17 | 
 18 | typedef enum {
 19 | 	NS_CLIENT,
 20 | 	NS_SERVER
 21 | } netsrc_t;
 22 | 
 23 | typedef struct {
 24 | 	netadrtype_t type;
 25 | 	union {
 26 | 		int _ip;
 27 | 		unsigned char ip[4];
 28 | 	};
 29 | 	unsigned char ipx[10];
 30 | 
 31 | 	unsigned short port;
 32 | } netadr_t;
 33 | 
 34 | typedef enum {
 35 | 	ERR_FATAL,                  // exit the entire game with a popup window
 36 | 	//ERR_VID_FATAL,              // exit the entire game with a popup window and doesn't delete profile.pid
 37 | 	ERR_DROP,                   // print to console and disconnect from game
 38 | 	ERR_SERVERDISCONNECT,       // don't kill server
 39 | 	ERR_DISCONNECT,             // client disconnected from the server
 40 | 	ERR_NEED_CD,                // pop up the need-cd dialog
 41 | 	ERR_AUTOUPDATE
 42 | } errorParm_t;
 43 | 
 44 | typedef void(*Com_Printf_t)(const char*, ...);
 45 | extern Com_Printf_t Com_Printf;
 46 | 
 47 | typedef void(*Com_DPrintf_t)(const char *, ...);
 48 | extern Com_DPrintf_t Com_DPrintf;
 49 | 
 50 | typedef void(*Com_Error_t)(int, const char*, ...);
 51 | extern Com_Error_t Com_Error;
 52 | 
 53 | typedef void(*xfunc)(void);
 54 | 
 55 | typedef void(*Cmd_AddCommand_t)(const char*, xfunc);
 56 | typedef void(*Cmd_RemoveCommand_t)(const char*);
 57 | extern Cmd_AddCommand_t Cmd_AddCommand;
 58 | extern Cmd_RemoveCommand_t Cmd_RemoveCommand;
 59 | 
 60 | typedef int(*FS_CreatePath_t)(const char *OSPath);
 61 | extern FS_CreatePath_t FS_CreatePath;
 62 | 
 63 | typedef int (*FS_ComparePaks_t)(char *neededpaks, int len, int dlstring);
 64 | extern FS_ComparePaks_t FS_ComparePaks;
 65 | 
 66 | typedef int(*FS_ReadFile_t)(const char *qpath, void **buffer);
 67 | extern FS_ReadFile_t FS_ReadFile;
 68 | typedef void(*FS_FreeFile_t)(void *);
 69 | extern FS_FreeFile_t FS_FreeFile;
 70 | 
 71 | char *FS_BuildOSPath(const char *base, const char *game, const char *qpath);
 72 | 
 73 | char * va(char *format, ...);
 74 | 
 75 | int Q_vsnprintf(char *dest, int size, const char *fmt, va_list argptr);
 76 | void Sys_SendPacket(int packet_size, void *packet, netadr_t to);
 77 | class rMSG {
 78 | public:
 79 | 	bool oob;
 80 | 	char buffer[MAX_MSGLEN];
 81 | 	int bufsize;
 82 | 	int readsize;
 83 | 
 84 | 	rMSG(bool oob = false) : bufsize(0) {
 85 | 		memset(buffer, 0, sizeof(buffer));
 86 | 		this->oob = oob;
 87 | 		if (oob)
 88 | 			AddInt(-1);
 89 | 		readsize = 0;
 90 | 	}
 91 | 
 92 | 	rMSG(char *buf, int len) {
 93 | 		memset(buffer, 0, sizeof(buffer));
 94 | 		int l = len > sizeof(buffer) ? sizeof(buffer) : len;
 95 | 		memcpy(buffer, buf, l);
 96 | 		bufsize = l;
 97 | 		readsize = 0;
 98 | 	}
 99 | 
100 | 	unsigned char ReadByte() {
101 | 		if (readsize + 1 > bufsize)
102 | 			return 0;
103 | 		return *(unsigned char*)(buffer + readsize++);
104 | 	}
105 | 
106 | 	int ReadInt() {
107 | 		if (readsize + sizeof(int) > bufsize)
108 | 			return 0;
109 | 		readsize += sizeof(int);
110 | 		return ntohl(*(int*)(buffer + readsize - sizeof(int)));
111 | 	}
112 | 
113 | 	void* ReadData(char *to, int len) {
114 | 		if (readsize + len > bufsize)
115 | 			return NULL;
116 | 		memcpy(to, buffer + readsize, len);
117 | 		readsize += len;
118 | 		return to;
119 | 	}
120 | 
121 | 	short ReadShort() {
122 | 		if (readsize + sizeof(short) > bufsize)
123 | 			return 0;
124 | 		readsize += sizeof(short);
125 | 		return ntohs(*(short*)(buffer + readsize - sizeof(short)));
126 | 	}
127 | 
128 | 	unsigned short ReadUShort() {
129 | 		if (readsize + sizeof(unsigned short) > bufsize)
130 | 			return 0;
131 | 		readsize += sizeof(unsigned short);
132 | 		return ntohs(*(unsigned short*)(buffer + readsize - sizeof(unsigned short)));
133 | 	}
134 | 
135 | 	unsigned int ReadUInt() {
136 | 		if (readsize + sizeof(unsigned int) > bufsize)
137 | 			return 0;
138 | 		readsize += sizeof(unsigned int);
139 | 		return ntohl(*(unsigned int*)(buffer + readsize - sizeof(unsigned int)));
140 | 	}
141 | 
142 | 	template <typename T>
143 | 	T ReadPrimitive() {
144 | 		if (readsize + sizeof(T) > bufsize)
145 | 			return 0;
146 | 		readsize += sizeof(T);
147 | 		return *(T*)(buffer + readsize - sizeof(T));
148 | 	}
149 | 
150 | 	template <typename T>
151 | 	void AddPrimitive(T tee) {
152 | 		if (bufsize + sizeof(T) >= MAX_MSGLEN)
153 | 			return;
154 | 		*(T*)(buffer + bufsize) = tee;
155 | 		bufsize += sizeof(T);
156 | 	}
157 | 
158 | 	void AddByte(unsigned char b) {
159 | 		if (bufsize + 1 >= MAX_MSGLEN)
160 | 			return;
161 | 		buffer[bufsize++] = b;
162 | 	}
163 | 
164 | 	void AddString(const char *s) {
165 | 		int len = strlen(s) + 1;
166 | 		if (bufsize + len >= MAX_MSGLEN)
167 | 			return;
168 | 		memcpy(buffer + bufsize, s, len);
169 | 		bufsize += len;
170 | 	}
171 | 
172 | 	void AddVaString(const char *s, ...) {
173 | 		char string[MAX_MSGLEN];
174 | 		va_list argptr;
175 | 
176 | 		va_start(argptr, s);
177 | 		int count = Q_vsnprintf(this->buffer + this->bufsize, sizeof(this->buffer) - this->bufsize, s, argptr);
178 | 		va_end(argptr);
179 | 		if (!(count < 0)) {
180 | 			bufsize += count + 1;
181 | 		}
182 | 	}
183 | 
184 | 	void AddInt(int i) {
185 | 		if (bufsize + sizeof(int) >= MAX_MSGLEN)
186 | 			return;
187 | 		*(int*)(buffer + bufsize) = htonl(i);
188 | 		bufsize += sizeof(int);
189 | 	}
190 | 
191 | 	void AddUInt(unsigned int i) {
192 | 		if (bufsize + sizeof(unsigned int) >= MAX_MSGLEN)
193 | 			return;
194 | 		*(unsigned int*)(buffer + bufsize) = htonl(i);
195 | 		bufsize += sizeof(unsigned int);
196 | 	}
197 | 
198 | 	void AddShort(short s) {
199 | 		if (bufsize + sizeof(short) >= MAX_MSGLEN)
200 | 			return;
201 | 		*(short*)(buffer + bufsize) = htons(s);
202 | 		bufsize += sizeof(short);
203 | 	}
204 | 
205 | 	void AddUShort(unsigned short s) {
206 | 		if (bufsize + sizeof(unsigned short) >= MAX_MSGLEN)
207 | 			return;
208 | 		*(unsigned short*)(buffer + bufsize) = htons(s);
209 | 		bufsize += sizeof(unsigned short);
210 | 	}
211 | 
212 | 	void AddData(char *d, int len) {
213 | 		if (bufsize + len > MAX_MSGLEN)
214 | 			return;
215 | 		memcpy(buffer + bufsize, d, len);
216 | 		bufsize += len;
217 | 	}
218 | #ifdef _WIN32
219 | 	void Send(netadr_t &to) {
220 | 		Sys_SendPacket(this->bufsize, this->buffer, to);
221 | 	}
222 | 
223 | 	void SendEnc(netadr_t &to, char *key) {
224 | 		int key_len = strlen(key);
225 | 		for (int i = sizeof(int) + sizeof(char); i < this->bufsize; i++)
226 | 			this->buffer[i] = this->buffer[i] ^ key[i % key_len];
227 | 		Sys_SendPacket(this->bufsize, this->buffer, to);
228 | 	}
229 | #endif
230 | };


--------------------------------------------------------------------------------
/console.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | #include "resource.h"
 3 | 
 4 | static HBITMAP hBitmap = NULL;
 5 | extern HINSTANCE hInstance;
 6 | extern HMODULE hModule;
 7 | 
 8 | LRESULT CALLBACK ConsoleWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
 9 | 	int wmId, wmEvent;
10 | 
11 | 	switch (message) {
12 | 		case WM_CREATE:
13 | 			hBitmap = (HBITMAP)LoadImageA((HINSTANCE)hModule, MAKEINTRESOURCE(IDB_BITMAP1), IMAGE_BITMAP, 0, 0, LR_SHARED | LR_COPYFROMRESOURCE);
14 | 		break;
15 | 		case WM_PAINT:
16 | 			PAINTSTRUCT 	ps;
17 | 			HDC 			hdc;
18 | 			BITMAP 			bitmap;
19 | 			HDC 			hdcMem;
20 | 			HGDIOBJ 		oldBitmap;
21 | 
22 | 			hdc = BeginPaint(hWnd, &ps);
23 | 
24 | 			hdcMem = CreateCompatibleDC(hdc);
25 | 			oldBitmap = SelectObject(hdcMem, hBitmap);
26 | 
27 | 			GetObject(hBitmap, sizeof(bitmap), &bitmap);
28 | 			BitBlt(hdc, 0, 0, bitmap.bmWidth, bitmap.bmHeight, hdcMem, 0, 0, SRCCOPY);
29 | 
30 | 			SelectObject(hdcMem, oldBitmap);
31 | 			DeleteDC(hdcMem);
32 | 
33 | 			EndPaint(hWnd, &ps);
34 | 		break;
35 | 		case WM_DESTROY:
36 | 			DeleteObject(hBitmap);
37 | 		break;
38 | 	}
39 | 	LRESULT CALLBACK ret = ((LRESULT(CALLBACK *)(HWND, UINT, WPARAM, LPARAM))0x465E80)(hWnd, message, wParam, lParam);
40 | 
41 | 	return ret;
42 | }
43 | 
44 | void Con_DrawSolidConsole(float frac) {
45 | 	extern cvar_t *cl_console_fraction;
46 | 	((void(*)(float))0x409F30)(frac * cl_console_fraction->value);
47 | }


--------------------------------------------------------------------------------
/crypt.cpp:
--------------------------------------------------------------------------------
 1 | #include "stdafx.h"
 2 | 
 3 | #include <Wincrypt.h>
 4 | #include <sstream>
 5 | 
 6 | std::string GetHashText(const void * data, const size_t data_size, HashType hashType)
 7 | {
 8 | 	HCRYPTPROV hProv = NULL;
 9 | 
10 | 	if (!CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
11 | 		return "";
12 | 	}
13 | 
14 | 	BOOL hash_ok = FALSE;
15 | 	HCRYPTPROV hHash = NULL;
16 | 	switch (hashType) {
17 | 	case HashSha1: hash_ok = CryptCreateHash(hProv, CALG_SHA1, 0, 0, &hHash); break;
18 | 	case HashMd5: hash_ok = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash); break;
19 | 	case HashSha256: hash_ok = CryptCreateHash(hProv, CALG_SHA_256, 0, 0, &hHash); break;
20 | 	}
21 | 
22 | 	if (!hash_ok) {
23 | 		CryptReleaseContext(hProv, 0);
24 | 		return "";
25 | 	}
26 | 
27 | 	if (!CryptHashData(hHash, static_cast<const BYTE *>(data), data_size, 0)) {
28 | 		CryptDestroyHash(hHash);
29 | 		CryptReleaseContext(hProv, 0);
30 | 		return "";
31 | 	}
32 | 
33 | 	DWORD cbHashSize = 0, dwCount = sizeof(DWORD);
34 | 	if (!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE *)&cbHashSize, &dwCount, 0)) {
35 | 		CryptDestroyHash(hHash);
36 | 		CryptReleaseContext(hProv, 0);
37 | 		return "";
38 | 	}
39 | 
40 | 	std::vector<BYTE> buffer(cbHashSize);
41 | 	if (!CryptGetHashParam(hHash, HP_HASHVAL, reinterpret_cast<BYTE*>(&buffer[0]), &cbHashSize, 0)) {
42 | 		CryptDestroyHash(hHash);
43 | 		CryptReleaseContext(hProv, 0);
44 | 		return "";
45 | 	}
46 | 
47 | 	std::ostringstream oss;
48 | 
49 | 	for (std::vector<BYTE>::const_iterator iter = buffer.begin(); iter != buffer.end(); ++iter) {
50 | 		oss.fill('0');
51 | 		oss.width(2);
52 | 		oss << std::hex << static_cast<const int>(*iter);
53 | 	}
54 | 
55 | 	CryptDestroyHash(hHash);
56 | 	CryptReleaseContext(hProv, 0);
57 | 	return oss.str();
58 | }


--------------------------------------------------------------------------------
/cvar.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | 
 3 | Cvar_Get_t Cvar_Get = (Cvar_Get_t)0x439350;
 4 | Cvar_Set_t Cvar_Set = (Cvar_Set_t)0x439650;
 5 | Cvar_FindVar_t Cvar_FindVar = (Cvar_FindVar_t)0x439280;
 6 | 
 7 | float Cvar_VariableValue(const char *var_name) {
 8 | 	cvar_t  *var;
 9 | 
10 | 	var = Cvar_FindVar(var_name);
11 | 	if (!var) {
12 | 		return 0;
13 | 	}
14 | 	return var->value;
15 | }
16 | 
17 | int Cvar_VariableIntegerValue(const char *var_name) {
18 | 	cvar_t  *var;
19 | 
20 | 	var = Cvar_FindVar(var_name);
21 | 	if (!var) {
22 | 		return 0;
23 | 	}
24 | 	return var->integer;
25 | }
26 | 
27 | char *Cvar_VariableString(const char *var_name) {
28 | 	cvar_t *var;
29 | 
30 | 	var = Cvar_FindVar(var_name);
31 | 	if (!var) {
32 | 		return "";
33 | 	}
34 | 	return var->string;
35 | }
36 | 
37 | char* Cvar_VariableStringBuffer(const char *var_name, char *buffer, int bufsize) {
38 | 	cvar_t *var;
39 | 
40 | 	var = Cvar_FindVar(var_name);
41 | 	if (!var) {
42 | 		*buffer = 0;
43 | 	} else {
44 | 		Q_strncpyz(buffer, var->string, bufsize);
45 | 	}
46 | 	return buffer;
47 | }
48 | 
49 | void Cvar_LatchedVariableStringBuffer(const char *var_name, char *buffer, int bufsize) {
50 | 	cvar_t *var;
51 | 
52 | 	var = Cvar_FindVar(var_name);
53 | 	if (!var) {
54 | 		*buffer = 0;
55 | 	} else {
56 | 		if (var->latchedString) {
57 | 			Q_strncpyz(buffer, var->latchedString, bufsize);
58 | 		} else {
59 | 			Q_strncpyz(buffer, var->string, bufsize);
60 | 		}
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/discord.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #include "client.h"
  3 | #pragma comment(lib, "libs/discord/discord-rpc.lib")
  4 | #include "libs/discord/discord_rpc.h"
  5 | #include "libs/discord/discord_register.h"
  6 | 
  7 | // Reference: https://github.com/callofduty4x/CoD4x_Client_pub
  8 | 
  9 | struct discordData_s {
 10 | 	unsigned int nextupdatetime;
 11 | 	// char joinSecret[256];
 12 | 	// char partyId[33];
 13 | 	// int privclients;
 14 | 	// int maxclients;
 15 | };
 16 | static struct discordData_s discordData;
 17 | 
 18 | void Discord_StatusDemo() {
 19 | 	DiscordRichPresence discordPresence;
 20 | 	memset(&discordPresence, 0, sizeof(discordPresence));
 21 | 	discordPresence.state = "Watching a demo";
 22 | 	discordPresence.largeImageKey = "main_small";
 23 | 
 24 | 	Discord_UpdatePresence(&discordPresence);
 25 | }
 26 | 
 27 | void Discord_StatusIdle() {
 28 | 	DiscordRichPresence discordPresence;
 29 | 	memset(&discordPresence, 0, sizeof(discordPresence));
 30 | 	discordPresence.state = "Looking to play";
 31 | 	discordPresence.largeImageKey = "main_small";
 32 | 
 33 | 	Discord_UpdatePresence(&discordPresence);
 34 | }
 35 | 
 36 | void Discord_StatusPlaying() {
 37 | 	char* info = clc_stringData + clc_stringOffsets[0];
 38 | 
 39 | 	char* hostname_p = Info_ValueForKey(info, "sv_hostname");
 40 | 	char hostname[64] = { 0 };
 41 | 	Q_strncpyz(hostname, hostname_p, sizeof(hostname));
 42 | 	char* mapname_p = Info_ValueForKey(info, "mapname");
 43 | 	char mapname[64] = { 0 };
 44 | 	Q_strncpyz(mapname, mapname_p, sizeof(mapname));
 45 | 	char* mapnameClean_p = Info_ValueForKey(info, "mapname");
 46 | 	char mapnameClean[64] = { 0 };
 47 | 	Q_strncpyz(mapnameClean, mapnameClean_p, sizeof(mapnameClean));
 48 | 	char* gametype_p = Info_ValueForKey(info, "g_gametype");
 49 | 	char gametype[64] = { 0 };
 50 | 	Q_strncpyz(gametype, gametype_p, sizeof(gametype));
 51 | 
 52 | 	DiscordRichPresence discordPresence;
 53 | 	memset(&discordPresence, 0, sizeof(discordPresence));
 54 | 
 55 | 	discordPresence.state = Com_GametypeName(gametype, false);
 56 | 	discordPresence.details = Com_CleanHostname(hostname, false);
 57 | 	discordPresence.largeImageKey = mapname;
 58 | 	discordPresence.largeImageText = Com_CleanMapname(mapnameClean); // for some reason this needs a whole new buffer
 59 | 
 60 | 	int player_count = *(int*)CGAME_OFF(0x3020B9FC);
 61 | 	if(player_count > 0 && player_count < 65) {
 62 | 		discordPresence.partySize = player_count;
 63 | 		discordPresence.partyMax = atoi(Info_ValueForKey(info, "sv_maxclients"));
 64 | 	}
 65 | 	
 66 | 	// Discord_SetJoinSecret();
 67 | 	// discordPresence.partyId = discordData.partyId;
 68 | 	// discordPresence.partySize = 1;
 69 | 	// discordPresence.partyMax = 32;
 70 | 	// if (discordData.joinSecret[0]) discordPresence.joinSecret = discordData.joinSecret;
 71 | 
 72 | 	Discord_UpdatePresence(&discordPresence);
 73 | }
 74 | 
 75 | void Discord_Update() {
 76 | 	if (discordData.nextupdatetime < *cls_realtime) {
 77 | 		discordData.nextupdatetime = *cls_realtime + 10 * 1000; // 10 seconds
 78 | 
 79 | 		if (*clc_demoplaying) {
 80 | 			Discord_StatusDemo();
 81 | 		} else if (*cls_state == 6) { // CA_ACTIVE
 82 | 			Discord_StatusPlaying();
 83 | 		} else {
 84 | 			Discord_StatusIdle();
 85 | 		}
 86 | 	}
 87 | }
 88 | 
 89 | void CL_DiscordInitialize() {
 90 | 	DiscordEventHandlers handlers;
 91 | 	memset(&handlers, 0, sizeof(handlers));
 92 | 	// handlers.joinGame = Discord_JoinGame;
 93 | 	// handlers.joinRequest = Discord_JoinRequest;
 94 | 	Discord_Initialize("804794761696509972", &handlers, 1, NULL);
 95 | 
 96 | 	Discord_StatusIdle();
 97 | }
 98 | 
 99 | void CL_DiscordFrame() {
100 | 	Discord_Update();
101 | }
102 | 
103 | void CL_DiscordShutdown() {
104 | 	Discord_Shutdown();
105 | }
106 | 
107 | /* // Code for game invites, "Join", won't bother with this for now.
108 | void Discord_SetJoinSecret() {
109 | 	int i, y;
110 | 	y = 0;
111 | 	netadr_t serverAddress = *clc_serverAddress;
112 | 	qboolean bad = qfalse;
113 | 	char joinSecret[256];
114 | 
115 | 	strcpy(joinSecret, "DISCORD");
116 | 	y = 7;
117 | 	if (serverAddress.type == NA_IP) {
118 | 		joinSecret[y] = '4';
119 | 		++y;
120 | 		for (i = 0; i < 4; ++i) {
121 | 			sprintf(&joinSecret[y], "%02X", serverAddress.ip[i]);
122 | 			y += 2;
123 | 		}
124 | 	} else {
125 | 		bad = qtrue;
126 | 	}
127 | 
128 | 	for (i = 0; i < 2; ++i) {
129 | 		sprintf(&joinSecret[y], "%02X", ((byte*)(&serverAddress.port))[i]);
130 | 		y += 2;
131 | 	}
132 | 
133 | 	joinSecret[y] = 0;
134 | 	if (bad) {
135 | 		discordData.joinSecret[0] = 0;
136 | 	} else {
137 | 		Q_strncpyz(discordData.joinSecret, joinSecret, sizeof(discordData.joinSecret));
138 | 	}
139 | 
140 | 	const char* info = clc_stringData + clc_stringOffsets[0];
141 | 	const char* nummaxcl = Info_ValueForKey(info, "sv_maxclients");
142 | 	const char* numprivcl = Info_ValueForKey(info, "sv_privateclients");
143 | 	discordData.maxclients = atoi(nummaxcl);
144 | 	discordData.privclients = atoi(numprivcl);
145 | 	discordData.nextupdatetime = *cls_realtime + 100;
146 | }
147 | 
148 | void Discord_JoinGame(const char* joinSecret) {
149 | 	printf("Discord: join (%s)\n", joinSecret);
150 | 
151 | 	int k;
152 | 	int i = 0;
153 | 	netadr_t adr;
154 | 	char password[128];
155 | 	char cmdline[1024];
156 | 	char hexbyte[3];
157 | 	unsigned int scanbyte;
158 | 
159 | 	memset(&adr, 0, sizeof(adr));
160 | 
161 | 	if (strncmp(joinSecret, "DISCORD", 7) != 0) {
162 | 		Com_Printf("Bad joinSecret %d\n", i);
163 | 		return;
164 | 	}
165 | 	i += 7;
166 | 	int type = joinSecret[i];
167 | 	++i;
168 | 	hexbyte[2] = 0;
169 | 	if (type == '4') {
170 | 		if (strlen(joinSecret + i) < 10) {
171 | 			Com_Printf("Bad joinSecret %d\n", i);
172 | 			return;
173 | 		}
174 | 		for (k = 0; k < 4; ++k) {
175 | 			hexbyte[0] = joinSecret[i];
176 | 			hexbyte[1] = joinSecret[i + 1];
177 | 
178 | 			sscanf(hexbyte, "%02X", &scanbyte);
179 | 			adr.ip[k] = scanbyte;
180 | 			i += 2;
181 | 		}
182 | 		adr.type = NA_IP;
183 | 	} else {
184 | 		Com_Error(ERR_DROP, "Sorry, but this discord join method is not implemented yet.");
185 | 		return;
186 | 	}
187 | 	for (k = 0; k < 2; ++k) {
188 | 		hexbyte[0] = joinSecret[i];
189 | 		hexbyte[1] = joinSecret[i + 1];
190 | 		sscanf(hexbyte, "%02X", &scanbyte);
191 | 		((byte*)(&adr.port))[k] = scanbyte;
192 | 		i += 2;
193 | 	}
194 | 
195 | 	Com_sprintf(cmdline, sizeof(cmdline), "connect %s\n", NET_AdrToString(adr));
196 | 	CL_AddReliableCommand(cmdline);
197 | 	Cvar_Set("testingggg", cmdline);
198 | }
199 | 
200 | void Discord_JoinRequest(const DiscordUser* request) {
201 | 	Com_Printf("Discord: join request from %s#%s - %s\n", request->username, request->discriminator, request->userId);
202 | 	Discord_Respond(request->userId, DISCORD_REPLY_YES);
203 | }
204 | */
205 | 


--------------------------------------------------------------------------------
/dl_main.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #include "dl_public.h"
  3 | #include "client.h"
  4 | #pragma comment(lib, "libs/libcurl/libcurl_a.lib")
  5 | #include "libs/libcurl/curl.h"
  6 | #include <iostream>
  7 | #include "version.h"
  8 | 
  9 | #define APP_NAME        "ID_DOWNLOAD"
 10 | #define APP_VERSION     "2.0"
 11 | 
 12 | // initialize once
 13 | static int dl_initialized = 0;
 14 | static CURLM *dl_multi = NULL;
 15 | static CURL *dl_request = NULL;
 16 | FILE *dl_file = NULL;
 17 | 
 18 | bool clc_bWWWDl = false;
 19 | 
 20 | /* simple implem */
 21 | 
 22 | size_t write_data(void *ptr, size_t size, size_t nmemb, FILE *stream) {
 23 | 	size_t written;
 24 | 	written = fwrite(ptr, size, nmemb, stream);
 25 | 	return written;
 26 | }
 27 | 
 28 | int create_progress_download(const char *url, FILE *fp, int (*progress_callback)(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow)) {
 29 | 	if (fp == nullptr)
 30 | 		return -1;
 31 | 
 32 | 	CURL *curl = nullptr;
 33 | 	CURLcode res;
 34 | 
 35 | 	curl = curl_easy_init();
 36 | 
 37 | 	if (curl == nullptr)
 38 | 		return -1;
 39 | 
 40 | 	curl_easy_setopt(curl, CURLOPT_URL, url);
 41 | 	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
 42 | 	curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
 43 | 	curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progress_callback);
 44 | 	curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
 45 | 	res = curl_easy_perform(curl);
 46 | 	//if (res != CURLE_OK && CURLE_ABORTED_BY_CALLBACK)
 47 | 		//MsgBox(curl_easy_strerror(res));
 48 | 
 49 | 	curl_easy_cleanup(curl);
 50 | 	fclose(fp);
 51 | 
 52 | 	return res;
 53 | }
 54 | 
 55 | bool simple_download(const char *url, const char *local) {
 56 | 	CURL *curl = NULL;
 57 | 	FILE *fp = NULL;
 58 | 	CURLcode res;
 59 | 
 60 | 	curl = curl_easy_init();
 61 | 
 62 | 	if (curl != NULL) {
 63 | 		fp = fopen(local, "wb");
 64 | 
 65 | 		if (!fp) {
 66 | 			return false;
 67 | 		}
 68 | 		curl_easy_setopt(curl, CURLOPT_URL, url);
 69 | 		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
 70 | 		curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
 71 | 		res = curl_easy_perform(curl);
 72 | 		if (res != CURLE_OK) {
 73 | 			return false;
 74 | 		}
 75 | 		curl_easy_cleanup(curl);
 76 | 		fclose(fp);
 77 | 	}
 78 | 	return true;
 79 | }
 80 | 
 81 | /* end */
 82 | 
 83 | /*
 84 | ** Write to file
 85 | */
 86 | static size_t DL_cb_FWriteFile(void *ptr, size_t size, size_t nmemb, void *stream) {
 87 | 	FILE *file = (FILE*)stream;
 88 | 	return fwrite(ptr, size, nmemb, file);
 89 | }
 90 | 
 91 | /*
 92 | ** Print progress
 93 | */
 94 | static int DL_cb_Progress(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow) {
 95 | 	/* cl_downloadSize and cl_downloadTime are set by the Q3 protocol...
 96 | 	and it would probably be expensive to verify them here.   -zinx */
 97 | 
 98 | 	Cvar_Set("cl_downloadSize", va("%f", (float)dltotal));
 99 | 	Cvar_Set("cl_downloadCount", va("%f", (float)dlnow));
100 | 	return 0;
101 | }
102 | 
103 | void DL_InitDownload() {
104 | 	if (dl_initialized) {
105 | 		return;
106 | 	}
107 | 
108 | 	/* Make sure curl has initialized, so the cleanup doesn't get confused */
109 | 	curl_global_init(CURL_GLOBAL_ALL);
110 | 
111 | 	dl_multi = curl_multi_init();
112 | 	Com_Printf("Client download subsystem initialized\n");
113 | 	dl_initialized = 1;
114 | }
115 | 
116 | /*
117 | ================
118 | DL_Shutdown
119 | 
120 | ================
121 | */
122 | void DL_Shutdown() {
123 | 	if (!dl_initialized) {
124 | 		return;
125 | 	}
126 | 
127 | 	curl_multi_cleanup(dl_multi);
128 | 	dl_multi = NULL;
129 | 
130 | 	curl_global_cleanup();
131 | 	dl_initialized = 0;
132 | }
133 | 
134 | #define LOCAL_DL_PATH "dl.tmp"
135 | 
136 | char localDownloadName[MAX_PATH];
137 | 
138 | int DL_BeginDownload(const char *localName, const char *remoteName, int debug) {
139 | 	char referer[MAX_STRING_CHARS + 5 /*"ET://"*/];
140 | 	if (dl_request) {
141 | 		Com_Printf("ERROR: DL_BeginDownload called with a download request already active\n"); \
142 | 			return 0;
143 | 	}
144 | 
145 | 	if (!localName || !remoteName) {
146 | 		Com_DPrintf("Empty download URL or empty local file name\n");
147 | 		return 0;
148 | 	}
149 | 
150 | 	_snprintf(localDownloadName, MAX_PATH - 1, "%s", localName);
151 | 
152 | 	FS_CreatePath(LOCAL_DL_PATH);
153 | 	dl_file = fopen(LOCAL_DL_PATH, "wb+");
154 | 	if (!dl_file) {
155 | 		Com_Printf("ERROR: DL_BeginDownload unable to open '%s' for writing\n", LOCAL_DL_PATH);
156 | 		return 0;
157 | 	}
158 | 
159 | 	DL_InitDownload();
160 | 
161 | 	/* ET://ip:port */
162 | 	/*
163 | 	strcpy( referer, "ET://" );
164 | 	Q_strncpyz( referer + 5, Cvar_VariableString( "cl_currentServerIP" ), MAX_STRING_CHARS );
165 | 	*/
166 | 
167 | 	dl_request = curl_easy_init();
168 | 	curl_easy_setopt(dl_request, CURLOPT_USERAGENT, va("%s %s", APP_NAME "/" APP_VERSION, curl_version()));
169 | 	//curl_easy_setopt( dl_request, CURLOPT_REFERER, referer );
170 | 	curl_easy_setopt(dl_request, CURLOPT_URL, remoteName);
171 | 	curl_easy_setopt(dl_request, CURLOPT_WRITEFUNCTION, DL_cb_FWriteFile);
172 | 	curl_easy_setopt(dl_request, CURLOPT_WRITEDATA, (void*)dl_file);
173 | 	curl_easy_setopt(dl_request, CURLOPT_PROGRESSFUNCTION, DL_cb_Progress);
174 | 	curl_easy_setopt(dl_request, CURLOPT_NOPROGRESS, 0);
175 | 	curl_easy_setopt(dl_request, CURLOPT_FAILONERROR, 1);
176 | 
177 | 	curl_multi_add_handle(dl_multi, dl_request);
178 | 
179 | 	Cvar_Set("cl_downloadName", va("        %s", (char*)remoteName)); //spaces so whole link is visible now
180 | 	Cvar_Set("dlname_error", (char*)remoteName);
181 | 	return 1;
182 | }
183 | 
184 | // (maybe this should be CL_DL_DownloadLoop)
185 | dlStatus_t DL_DownloadLoop() {
186 | 	CURLMcode status;
187 | 	CURLMsg *msg;
188 | 	int dls = 0;
189 | 	const char *err = NULL;
190 | 
191 | 	if (!dl_request) {
192 | 		Com_DPrintf("DL_DownloadLoop: unexpected call with dl_request == NULL\n");
193 | 		return DL_DONE;
194 | 	}
195 | 
196 | 	if (*cls_state != CA_CONNECTING && *cls_state != CA_CHALLENGING && *cls_state != CA_CONNECTED) {
197 | 		curl_multi_remove_handle(dl_multi, dl_request);
198 | 		curl_easy_cleanup(dl_request);
199 | 		fclose(dl_file);
200 | 		dl_file = NULL;
201 | 		dl_request = NULL;
202 | 		Cvar_Set("ui_dl_running", "0");
203 | 		return DL_DISCONNECTED;
204 | 	}
205 | 
206 | 	if ((status = curl_multi_perform(dl_multi, &dls)) == CURLM_CALL_MULTI_PERFORM && dls) {
207 | 		return DL_CONTINUE;
208 | 	}
209 | 
210 | 	while ((msg = curl_multi_info_read(dl_multi, &dls)) && msg->easy_handle != dl_request)
211 | 		;
212 | 
213 | 	if (!msg || msg->msg != CURLMSG_DONE) {
214 | 		return DL_CONTINUE;
215 | 	}
216 | 
217 | 	if (msg->data.result != CURLE_OK) {
218 | 		err = curl_easy_strerror(msg->data.result);
219 | 	}
220 | 	else {
221 | 		err = NULL;
222 | 	}
223 | 
224 | 	curl_multi_remove_handle(dl_multi, dl_request);
225 | 	curl_easy_cleanup(dl_request);
226 | 	fclose(dl_file);
227 | 	dl_file = NULL;
228 | 
229 | 	dl_request = NULL;
230 | 
231 | 	Cvar_Set("ui_dl_running", "0");
232 | 
233 | 	if (err) {
234 | 		Com_DPrintf("DL_DownloadLoop: request terminated with failure status '%s'\n", err);
235 | 		return DL_FAILED;
236 | 	}
237 | 
238 | 	if (!MoveFileA(LOCAL_DL_PATH, localDownloadName)) {
239 | 		Com_Printf("DL_DownloadFinished: failed to move temporary storage file to '%s'\n", localDownloadName);
240 | 	}
241 | 
242 | 	*localDownloadName = '\0';
243 | 	//((void(*)())0x40F640)(); //CL_Reconnect_f //don't reconnect after each download
244 | 	return DL_DONE;
245 | }
246 | 


--------------------------------------------------------------------------------
/dl_public.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | typedef enum {
 4 | 	DL_CONTINUE,
 5 | 	DL_DONE,
 6 | 	DL_FAILED,
 7 | 	DL_DISCONNECTED,
 8 | } dlStatus_t;
 9 | 
10 | int DL_BeginDownload(const char *localName, const char *remoteName, int debug);
11 | dlStatus_t DL_DownloadLoop();
12 | 
13 | void DL_Shutdown();
14 | 
15 | // bitmask
16 | typedef enum {
17 | 	DL_FLAG_DISCON = 0,
18 | 	DL_FLAG_URL
19 | } dlFlags_t;
20 | 
21 | extern bool clc_bWWWDl;


--------------------------------------------------------------------------------
/dllmain.cpp:
--------------------------------------------------------------------------------
 1 | #include "stdafx.h"
 2 | 
 3 | void codextended();
 4 | void codextended_unload();
 5 | 
 6 | HMODULE hModule;
 7 | HANDLE hLogFile = INVALID_HANDLE_VALUE;
 8 | 
 9 | // PROCESS_DETACH is not called so don't make global declarations which have deconstructors which have to be called.
10 | static BYTE originalCode[5];
11 | static PBYTE originalEP = 0;
12 | void Main_UnprotectModule(HMODULE hModule);
13 | void Main_DoInit()
14 | {
15 | 	// unprotect our entire PE image
16 | 	HMODULE hModule;
17 | 	if (SUCCEEDED(GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCSTR)Main_DoInit, &hModule)))
18 | 	{
19 | 		Main_UnprotectModule(hModule);
20 | 	}
21 | 
22 | 	void patch_opcode_loadlibrary(void);
23 | 
24 | 	// return to the original EP
25 | 	memcpy(originalEP, &originalCode, sizeof(originalCode));
26 | 	__asm jmp originalEP
27 | }
28 | void Main_SetSafeInit()
29 | {
30 | 	// find the entry point for the executable process, set page access, and replace the EP
31 | 	HMODULE hModule = GetModuleHandle(NULL); // passing NULL should be safe even with the loader lock being held (according to ReactOS ldr.c)
32 | 
33 | 	if (hModule)
34 | 	{
35 | 		PIMAGE_DOS_HEADER header = (PIMAGE_DOS_HEADER)hModule;
36 | 		PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((DWORD)hModule + header->e_lfanew);
37 | 
38 | 		Main_UnprotectModule(hModule);
39 | 
40 | 		// back up original code
41 | 		PBYTE ep = (PBYTE)((DWORD)hModule + ntHeader->OptionalHeader.AddressOfEntryPoint);
42 | 		memcpy(originalCode, ep, sizeof(originalCode));
43 | 
44 | 		// patch to call our EP
45 | 		int newEP = (int)Main_DoInit - ((int)ep + 5);
46 | 		ep[0] = 0xE9; // for some reason this doesn't work properly when run under the debugger
47 | 		memcpy(&ep[1], &newEP, 4);
48 | 
49 | 		originalEP = ep;
50 | 	}
51 | }
52 | 
53 | std::string GetExePath()
54 | {
55 | 	char buffer[MAX_PATH];
56 | 	GetModuleFileName(NULL, buffer, MAX_PATH);
57 | 	std::string f = std::string(buffer);
58 | 	return f.substr(0, f.find_last_of("\\/"));
59 | }
60 | 
61 | #ifndef PROJECT_EXE
62 | BOOL APIENTRY DllMain(HMODULE hMod, DWORD ul_reason_for_call, LPVOID lpReserved)
63 | {
64 | #if 0
65 | 
66 | 	if (strstr(szModuleName, "rundll32") != NULL) {
67 | 		return TRUE;
68 | 	}
69 | #endif
70 | 
71 | 	switch (ul_reason_for_call) {
72 | 		case DLL_PROCESS_ATTACH:
73 | 			char szModuleName[MAX_PATH + 1];
74 | 
75 | 			GetModuleFileNameA(NULL, szModuleName, MAX_PATH);
76 | 			void MSS32_Hook();
77 | 			MSS32_Hook();
78 | 
79 | 			// Fix directory problem when game gets ran by e.g. Discord (directory will be Discord folder).
80 | 			SetCurrentDirectoryA(GetExePath().c_str());
81 | 
82 | 			extern bool miles32_loaded;
83 | 			if (!miles32_loaded)
84 | 				return FALSE;
85 | 			Main_SetSafeInit();
86 | 			codextended();
87 | 		break;
88 | 		case DLL_PROCESS_DETACH:
89 | 			// codextended_unload();
90 | 		break;
91 | 	}
92 | 	return TRUE;
93 | }
94 | #endif
95 | 


--------------------------------------------------------------------------------
/exmaster_client.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | #include "exmaster_client.h"
 3 | 
 4 | std::vector<mClient> mClients;
 5 | 
 6 | mClient::mClient(unsigned int _id, const char *_mUID) : serverid(_id) {
 7 | 	memset(mUID, 0, sizeof(mUID));
 8 | 	Q_strncpyz(mUID, _mUID, sizeof(mUID));
 9 | 	this->lastName = "Unknown Client";
10 | }
11 | 
12 | bool mClient::Exists(mClient& mc) {
13 | 	for (auto& it : mClients) {
14 | 		if (it.serverid == mc.serverid)
15 | 			return true;
16 | 	}
17 | 	return false;
18 | }
19 | 
20 | mClient* mClient::Find(unsigned int svid) {
21 | 	for (int i = 0; i < mClients.size(); i++) {
22 | 		if (mClients[i].serverid == svid)
23 | 			return &mClients[i];
24 | 	}
25 | 	return nullptr;
26 | }
27 | 
28 | bool mClient::Exists(unsigned int id) {
29 | 	for (std::vector<mClient>::iterator it = mClients.begin(); it != mClients.end(); ++it) {
30 | 		if (it->serverid == id)
31 | 			return true;
32 | 	}
33 | 	return false;
34 | }


--------------------------------------------------------------------------------
/exmaster_client.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class mClient {
 4 | public:
 5 | 	unsigned int serverid;
 6 | 	char mUID[33];
 7 | 	std::string lastName;
 8 | 
 9 | 	mClient(unsigned int, const char *);
10 | 	static bool Exists(mClient&);
11 | 	static bool Exists(unsigned int);
12 | 
13 | 	static mClient *Find(unsigned int);
14 | };
15 | 
16 | extern std::vector<mClient> mClients; //will print loads of errors when not defined e.g std::vector


--------------------------------------------------------------------------------
/files.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | 
 3 | FS_CreatePath_t FS_CreatePath = (FS_CreatePath_t)0x429000;
 4 | FS_ComparePaks_t FS_ComparePaks = (FS_ComparePaks_t)0x43B830;
 5 | 
 6 | FS_ReadFile_t FS_ReadFile = (FS_ReadFile_t)0x42A8B0;
 7 | FS_FreeFile_t FS_FreeFile = (FS_FreeFile_t)0x42AB50;
 8 | 
 9 | #define PATH_SEP '/'
10 | 
11 | static void FS_ReplaceSeparators(char *path) {
12 | 	char    *s;
13 | 
14 | 	for (s = path; *s; s++) {
15 | 		if (*s == '/' || *s == '\\') {
16 | 			*s = PATH_SEP;
17 | 		}
18 | 	}
19 | }
20 | 
21 | char *FS_BuildOSPath(const char *base, const char *game, const char *qpath) {
22 | 	char temp[MAX_OSPATH];
23 | 	static char ospath[2][MAX_OSPATH];
24 | 	static int toggle;
25 | 
26 | 	toggle ^= 1;        // flip-flop to allow two returns without clash
27 | 
28 | 	if (!game || !game[0]) {
29 | 		game = (const char*)Cvar_VariableString("fs_game");
30 | 	}
31 | 
32 | 	Com_sprintf(temp, sizeof(temp), "/%s/%s", game, qpath);
33 | 	FS_ReplaceSeparators(temp);
34 | 	Com_sprintf(ospath[toggle], sizeof(ospath[0]), "%s%s", base, temp);
35 | 
36 | 	return ospath[toggle];
37 | }
38 | 
39 | int FS_IsLegacyFile(const char* filename) {
40 | 	char *game = Cvar_VariableString("fs_game");
41 | 	if (game && *game)
42 | 		return 0;
43 | 	if (strstr(filename, "localized_"))
44 | 		return 1;
45 | 	for (int i = 0; i < 6; i++) {
46 | 		if (!strcmp(va("pak%d.pk3", i), filename))
47 | 			return 1;
48 | 	}
49 | 	return 0;
50 | }


--------------------------------------------------------------------------------
/fixes.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | 
 3 | static void CLUI_GetCDKey(char* buf, int buflen) {
 4 | 	MessageBoxA(NULL, "If you wish to change your CD-Key, edit the 'codkey' file.\nThis is to prevent servers from stealing your CD-Key.\nIf you see this message and you aren't changing your key then the server is trying to steal your CD-Key.", __TITLE, 0);
 5 | }
 6 | 
 7 | bool fix_bugs() {
 8 | 	bool ret = true;
 9 | 	__call(0x41892B, (int)CLUI_GetCDKey); //self explainatory?
10 | 
11 | 	void DL_Name(const char *localName, char* remoteName); //fix for not full download name on slow dl
12 | 	__call(0x41011C, (int)DL_Name);
13 | 
14 | 	// NOP out the calls to CL_Motd (crash upon startup net not loaded and socket being sent or smth)
15 | 	__nop(0x40F6DA, 0x40F6DA + 5);
16 | 	__nop(0x4117B6, 0x4117B6 + 5);
17 | 	
18 | 	__nop(0x411815, 1);
19 | 
20 | 	/* annoying bugs */
21 | 	__nop(0x42D122, 5); //call Com_AppendCDKey (fixes the invalid cdkey with fs_game)
22 | 	__nop(0x40BC18, 5); //fixes spam with "MAX_PACKET_USERCMDS" if you have 1000 fps
23 | 	__nop(0x43BA04, 5); //Removing second "Need Paks:" because it's useless one is enough
24 | 
25 | 	return ret;
26 | }
27 | 


--------------------------------------------------------------------------------
/game.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | 
 3 | DWORD game_mp;
 4 | 
 5 | extern cvar_t* g_bounce;
 6 | 
 7 | void G_PM_ClipVelocity(vec3_t in, vec3_t normal, vec3_t out) {
 8 | 	float	backoff;
 9 | 	float	change;
10 | 	int		i;
11 | 	float   overbounce = 1.001f;
12 | 
13 | 	backoff = DotProduct(in, normal);
14 | 
15 | 	if (backoff < 0) {
16 | 		backoff *= overbounce;
17 | 	}
18 | 	else {
19 | 		backoff /= overbounce;
20 | 	}
21 | 
22 | 	for (i = 0; i < 3; i++) {
23 | 		change = normal[i] * backoff;
24 | 		out[i] = in[i] - change;
25 | 	}
26 | }
27 | 
28 | // xoxor4d
29 | void G_PM_ProjectVelocity(vec3_t in, vec3_t normal, vec3_t out) {
30 | 	float speedXY, DotNormalXY, normalisedNormalXY, projectionZ, projectionXYZ;
31 | 
32 | 	speedXY = in[1] * in[1] + in[0] * in[0];
33 | 
34 | 	if ((normal[2]) < 0.001f || (speedXY == 0.0f)) {
35 | 		VectorCopy(in, out);
36 | 	}
37 | 	else {
38 | 		DotNormalXY = normal[1] * in[1] + in[0] * normal[0];
39 | 		normalisedNormalXY = -DotNormalXY / normal[2];
40 | 
41 | 		projectionZ = in[2] * in[2] + speedXY;
42 | 
43 | 		projectionXYZ = sqrtf((projectionZ / (speedXY + normalisedNormalXY * normalisedNormalXY)));
44 | 
45 | 		if (projectionXYZ < 1.0f || normalisedNormalXY < 0.0f || in[2] > 0.0f) {
46 | 			out[0] = projectionXYZ * in[0];
47 | 			out[1] = projectionXYZ * in[1];
48 | 			out[2] = projectionXYZ * normalisedNormalXY;
49 | 		}
50 | 	}
51 | }
52 | 
53 | uint32_t G_PM_Bounce(vec3_t in, vec3_t normal, vec3_t out) {
54 | 	if (g_bounce->integer) {
55 | 		G_PM_ProjectVelocity(in, normal, out);
56 | 	}
57 | 	else {
58 | 		G_PM_ClipVelocity(in, normal, out);
59 | 	}
60 | 
61 | 	return GAME_OFF(0x2000D570);
62 | }
63 | 
64 | __declspec(naked) void G_PM_Bounce_Stub()
65 | {
66 | 	__asm
67 | 	{
68 | 		push    esi; // out
69 | 		push    ecx; // normal
70 | 		push    edx; // in
71 | 		call    G_PM_Bounce;
72 | 		add     esp, 12;
73 | 
74 | 		push eax
75 | 			retn;
76 | 	}
77 | }
78 | 
79 | void G_Init(DWORD base) {
80 | 	game_mp = base;
81 | 	__jmp(GAME_OFF(0x2000D56B), (int)G_PM_Bounce_Stub);
82 | }


--------------------------------------------------------------------------------
/hdd_serial_number.h:
--------------------------------------------------------------------------------
  1 | #ifndef _HDD_SERIAL_INFO_H_
  2 | #define _HDD_SERIAL_INFO_H_
  3 | 
  4 | #include <tchar.h>
  5 | #include <string.h>
  6 | #include <windows.h>
  7 | #include <winioctl.h>
  8 | #include <stdio.h>
  9 | #include <vector>
 10 | 
 11 | #pragma pack(1)
 12 | 
 13 | #define  IDENTIFY_BUFFER_SIZE  512
 14 | 
 15 | //  IOCTL commands
 16 | #define  DFP_GET_VERSION          0x00074080
 17 | #define  DFP_SEND_DRIVE_COMMAND   0x0007c084
 18 | #define  DFP_RECEIVE_DRIVE_DATA   0x0007c088
 19 | 
 20 | #define  FILE_DEVICE_SCSI              0x0000001b
 21 | #define  IOCTL_SCSI_MINIPORT_IDENTIFY  ((FILE_DEVICE_SCSI << 16) + 0x0501)
 22 | #define  IOCTL_SCSI_MINIPORT 0x0004D008  //  see NTDDSCSI.H for definition
 23 | 
 24 | #define SMART_GET_VERSION               CTL_CODE(IOCTL_DISK_BASE, 0x0020, METHOD_BUFFERED, FILE_READ_ACCESS)
 25 | #define SMART_SEND_DRIVE_COMMAND        CTL_CODE(IOCTL_DISK_BASE, 0x0021, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
 26 | #define SMART_RCV_DRIVE_DATA            CTL_CODE(IOCTL_DISK_BASE, 0x0022, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
 27 | 
 28 | //  GETVERSIONOUTPARAMS contains the data returned from the 
 29 | //  Get Driver Version function.
 30 | typedef struct _GETVERSIONOUTPARAMS
 31 | {
 32 | 	BYTE bVersion;      // Binary driver version.
 33 | 	BYTE bRevision;     // Binary driver revision.
 34 | 	BYTE bReserved;     // Not used.
 35 | 	BYTE bIDEDeviceMap; // Bit map of IDE devices.
 36 | 	DWORD fCapabilities; // Bit mask of driver capabilities.
 37 | 	DWORD dwReserved[4]; // For future use.
 38 | } GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS;
 39 | 
 40 | 
 41 | //  Bits returned in the fCapabilities member of GETVERSIONOUTPARAMS 
 42 | #define  CAP_IDE_ID_FUNCTION             1  // ATA ID command supported
 43 | #define  CAP_IDE_ATAPI_ID                2  // ATAPI ID command supported
 44 | #define  CAP_IDE_EXECUTE_SMART_FUNCTION  4  // SMART commannds supported
 45 | 
 46 | //  Valid values for the bCommandReg member of IDEREGS.
 47 | #define  IDE_ATAPI_IDENTIFY  0xA1  //  Returns ID sector for ATAPI.
 48 | #define  IDE_ATA_IDENTIFY    0xEC  //  Returns ID sector for ATA.
 49 | 
 50 | // The following struct defines the interesting part of the IDENTIFY
 51 | // buffer:
 52 | typedef struct _IDSECTOR
 53 | {
 54 | 	USHORT  wGenConfig;
 55 | 	USHORT  wNumCyls;
 56 | 	USHORT  wReserved;
 57 | 	USHORT  wNumHeads;
 58 | 	USHORT  wBytesPerTrack;
 59 | 	USHORT  wBytesPerSector;
 60 | 	USHORT  wSectorsPerTrack;
 61 | 	USHORT  wVendorUnique[3];
 62 | 	CHAR    sSerialNumber[20];
 63 | 	USHORT  wBufferType;
 64 | 	USHORT  wBufferSize;
 65 | 	USHORT  wECCSize;
 66 | 	CHAR    sFirmwareRev[8];
 67 | 	CHAR    sModelNumber[40];
 68 | 	USHORT  wMoreVendorUnique;
 69 | 	USHORT  wDoubleWordIO;
 70 | 	USHORT  wCapabilities;
 71 | 	USHORT  wReserved1;
 72 | 	USHORT  wPIOTiming;
 73 | 	USHORT  wDMATiming;
 74 | 	USHORT  wBS;
 75 | 	USHORT  wNumCurrentCyls;
 76 | 	USHORT  wNumCurrentHeads;
 77 | 	USHORT  wNumCurrentSectorsPerTrack;
 78 | 	ULONG   ulCurrentSectorCapacity;
 79 | 	USHORT  wMultSectorStuff;
 80 | 	ULONG   ulTotalAddressableSectors;
 81 | 	USHORT  wSingleWordDMA;
 82 | 	USHORT  wMultiWordDMA;
 83 | 	BYTE    bReserved[128];
 84 | } IDSECTOR, *PIDSECTOR;
 85 | 
 86 | 
 87 | typedef struct _SRB_IO_CONTROL
 88 | {
 89 | 	ULONG HeaderLength;
 90 | 	UCHAR Signature[8];
 91 | 	ULONG Timeout;
 92 | 	ULONG ControlCode;
 93 | 	ULONG ReturnCode;
 94 | 	ULONG Length;
 95 | } SRB_IO_CONTROL, *PSRB_IO_CONTROL;
 96 | 
 97 | //  Max number of drives assuming primary/secondary, master/slave topology
 98 | //	Modified to read only the master serial
 99 | #define  MAX_IDE_DRIVES  1
100 | 
101 | //
102 | // IDENTIFY data (from ATAPI driver source)
103 | //
104 | 
105 | #pragma pack(1)
106 | 
107 | typedef struct _IDENTIFY_DATA {
108 | 	USHORT GeneralConfiguration;            // 00 00
109 | 	USHORT NumberOfCylinders;               // 02  1
110 | 	USHORT Reserved1;                       // 04  2
111 | 	USHORT NumberOfHeads;                   // 06  3
112 | 	USHORT UnformattedBytesPerTrack;        // 08  4
113 | 	USHORT UnformattedBytesPerSector;       // 0A  5
114 | 	USHORT SectorsPerTrack;                 // 0C  6
115 | 	USHORT VendorUnique1[3];                // 0E  7-9
116 | 	USHORT SerialNumber[10];                // 14  10-19
117 | 	USHORT BufferType;                      // 28  20
118 | 	USHORT BufferSectorSize;                // 2A  21
119 | 	USHORT NumberOfEccBytes;                // 2C  22
120 | 	USHORT FirmwareRevision[4];             // 2E  23-26
121 | 	USHORT ModelNumber[20];                 // 36  27-46
122 | 	UCHAR  MaximumBlockTransfer;            // 5E  47
123 | 	UCHAR  VendorUnique2;                   // 5F
124 | 	USHORT DoubleWordIo;                    // 60  48
125 | 	USHORT Capabilities;                    // 62  49
126 | 	USHORT Reserved2;                       // 64  50
127 | 	UCHAR  VendorUnique3;                   // 66  51
128 | 	UCHAR  PioCycleTimingMode;              // 67
129 | 	UCHAR  VendorUnique4;                   // 68  52
130 | 	UCHAR  DmaCycleTimingMode;              // 69
131 | 	USHORT TranslationFieldsValid : 1;        // 6A  53
132 | 	USHORT Reserved3 : 15;
133 | 	USHORT NumberOfCurrentCylinders;        // 6C  54
134 | 	USHORT NumberOfCurrentHeads;            // 6E  55
135 | 	USHORT CurrentSectorsPerTrack;          // 70  56
136 | 	ULONG  CurrentSectorCapacity;           // 72  57-58
137 | 	USHORT CurrentMultiSectorSetting;       //     59
138 | 	ULONG  UserAddressableSectors;          //     60-61
139 | 	USHORT SingleWordDMASupport : 8;        //     62
140 | 	USHORT SingleWordDMAActive : 8;
141 | 	USHORT MultiWordDMASupport : 8;         //     63
142 | 	USHORT MultiWordDMAActive : 8;
143 | 	USHORT AdvancedPIOModes : 8;            //     64
144 | 	USHORT Reserved4 : 8;
145 | 	USHORT MinimumMWXferCycleTime;          //     65
146 | 	USHORT RecommendedMWXferCycleTime;      //     66
147 | 	USHORT MinimumPIOCycleTime;             //     67
148 | 	USHORT MinimumPIOCycleTimeIORDY;        //     68
149 | 	USHORT Reserved5[2];                    //     69-70
150 | 	USHORT ReleaseTimeOverlapped;           //     71
151 | 	USHORT ReleaseTimeServiceCommand;       //     72
152 | 	USHORT MajorRevision;                   //     73
153 | 	USHORT MinorRevision;                   //     74
154 | 	USHORT Reserved6[50];                   //     75-126
155 | 	USHORT SpecialFunctionsEnabled;         //     127
156 | 	USHORT Reserved7[128];                  //     128-255
157 | } IDENTIFY_DATA, *PIDENTIFY_DATA;
158 | 
159 | #pragma pack()
160 | 
161 | //  Required to ensure correct PhysicalDrive IOCTL structure setup
162 | #pragma pack(4)
163 | 
164 | 
165 | //
166 | // IOCTL_STORAGE_QUERY_PROPERTY
167 | //
168 | // Input Buffer:
169 | //      a STORAGE_PROPERTY_QUERY structure which describes what type of query
170 | //      is being done, what property is being queried for, and any additional
171 | //      parameters which a particular property query requires.
172 | //
173 | //  Output Buffer:
174 | //      Contains a buffer to place the results of the query into.  Since all
175 | //      property descriptors can be cast into a STORAGE_DESCRIPTOR_HEADER,
176 | //      the IOCTL can be called once with a small buffer then again using
177 | //      a buffer as large as the header reports is necessary.
178 | //
179 | 
180 | 
181 | //
182 | // Types of queries
183 | //
184 | 
185 | 
186 | //
187 | // define some initial property id's
188 | //
189 | 
190 | 
191 | //
192 | // Query structure - additional parameters for specific queries can follow
193 | // the header
194 | //
195 | 
196 | 
197 | #define IOCTL_STORAGE_QUERY_PROPERTY   CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS)
198 | 
199 | 
200 | //
201 | // Device property descriptor - this is really just a rehash of the inquiry
202 | // data retrieved from a scsi device
203 | //
204 | // This may only be retrieved from a target device.  Sending this to the bus
205 | // will result in an error
206 | //
207 | 
208 | #pragma pack(4)
209 | 
210 | 
211 | // (* Output Bbuffer for the VxD (rt_IdeDinfo record) *)
212 | typedef struct _rt_IdeDInfo_
213 | {
214 | 	BYTE IDEExists[4];
215 | 	BYTE DiskExists[8];
216 | 	WORD DisksRawInfo[8 * 256];
217 | } rt_IdeDInfo, *pt_IdeDInfo;
218 | 
219 | 
220 | // (* IdeDinfo "data fields" *)
221 | typedef struct _rt_DiskInfo_
222 | {
223 | 	BOOL DiskExists;
224 | 	BOOL ATAdevice;
225 | 	BOOL RemovableDevice;
226 | 	WORD TotLogCyl;
227 | 	WORD TotLogHeads;
228 | 	WORD TotLogSPT;
229 | 	char SerialNumber[20];
230 | 	char FirmwareRevision[8];
231 | 	char ModelNumber[40];
232 | 	WORD CurLogCyl;
233 | 	WORD CurLogHeads;
234 | 	WORD CurLogSPT;
235 | } rt_DiskInfo;
236 | 
237 | #define  SENDIDLENGTH  sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE
238 | #define IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
239 | 
240 | class MasterHardDiskSerial
241 | {
242 | public:
243 | 	MasterHardDiskSerial();
244 | 	~MasterHardDiskSerial();
245 | 	char* GetSerialNo();
246 | 	inline int GetErrorMessage(TCHAR* _ptszErrorMessage = NULL);
247 | private:
248 | 	inline char* ConvertToString(DWORD dwDiskdata[256], int iFirstIndex, int iLastIndex, char* pcBuf = NULL);
249 | 	inline BOOL DoIDENTIFY(HANDLE, PSENDCMDINPARAMS, PSENDCMDOUTPARAMS, BYTE, BYTE, PDWORD);
250 | 	inline int ReadPhysicalDriveInNTWithAdminRights(void);
251 | 	inline int	ReadPhysicalDriveInNTUsingSmart(void);
252 | 	inline int	ReadPhysicalDriveInNTWithZeroRights(void);
253 | 	inline int	ReadIdeDriveAsScsiDriveInNT(void);
254 | 	inline char* flipAndCodeBytes(int iPos, int iFlip, const char * pcStr = NULL, char * pcBuf = NULL);
255 | 	inline void PrintIdeInfo(int iDrive, DWORD dwDiskdata[256]);
256 | 	inline long getHardDriveComputerID();
257 | private:
258 | 	char m_cszHardDriveSerialNumber[1024];
259 | 	char m_cszHardDriveModelNumber[1024];
260 | 	char m_cszErrorMessage[256];
261 | 	BYTE byIdOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
262 | };
263 | 
264 | 
265 | #endif // _HDD_SERIAL_INFO_H_


--------------------------------------------------------------------------------
/hook.cpp:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include "shared.h"
  3 | #include "client.h"
  4 | #include "version.h"
  5 | 
  6 | //0046319B E8 10 B1 FA FF  call    sub_40E2B0
  7 | void sub_40E2B0() {
  8 | 	void(*o)();
  9 | 	*(UINT32*)&o = 0x40E2B0;
 10 | 	o();
 11 | 
 12 | 
 13 | 	void Sys_Unload();
 14 | 	Sys_Unload();
 15 | }
 16 | 
 17 | void Main_UnprotectModule(HMODULE hModule)
 18 | {
 19 | 	PIMAGE_DOS_HEADER header = (PIMAGE_DOS_HEADER)hModule;
 20 | 	PIMAGE_NT_HEADERS ntHeader = (PIMAGE_NT_HEADERS)((DWORD)hModule + header->e_lfanew);
 21 | 
 22 | 	// unprotect the entire PE image
 23 | 	SIZE_T size = ntHeader->OptionalHeader.SizeOfImage;
 24 | 	DWORD oldProtect;
 25 | 	VirtualProtect((LPVOID)hModule, size, PAGE_EXECUTE_READWRITE, &oldProtect);
 26 | }
 27 | 
 28 | bool apply_hooks() {
 29 | 	HMODULE hModule;
 30 | 	if (SUCCEEDED(GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCSTR)apply_hooks, &hModule)))
 31 | 	{
 32 | 		Main_UnprotectModule(hModule);
 33 | 	}
 34 | 
 35 | 
 36 | 	void patch_opcode_loadlibrary();
 37 | 	patch_opcode_loadlibrary();
 38 | 	
 39 | 	if (codversion != COD_1)
 40 | 		return true;
 41 | 	
 42 | 	#define PATCH_PUSH_STRING_PTR_VALUE(offset, new_str) \
 43 | 	XUNLOCK((void*)offset, 10); \
 44 | 	*(const char **)(offset + 1) = new_str;
 45 | 
 46 | 	#define PATCH_PUSH_INT_PTR_VALUE(offset, new_int) \
 47 | 	XUNLOCK((void*)offset, 10); \
 48 | 	*(int *)(offset + 1) = new_int;
 49 | 
 50 | 	PATCH_PUSH_STRING_PTR_VALUE(0x50847D, "Call of Duty 1.1x Multiplayer");
 51 | 	PATCH_PUSH_STRING_PTR_VALUE(0x437A78, "1.1x " BUILD);
 52 | 	PATCH_PUSH_STRING_PTR_VALUE(0x4130BB, "1.1x"); //cl_updateoldversion
 53 | 	PATCH_PUSH_STRING_PTR_VALUE(0x4375D3, "1.1x");
 54 | 	PATCH_PUSH_STRING_PTR_VALUE(0x437A4F, "1.1x");
 55 | 	PATCH_PUSH_STRING_PTR_VALUE(0x437A4F, "1.1x");
 56 | 	PATCH_PUSH_STRING_PTR_VALUE(0x437A29, __DATE__);
 57 | 	PATCH_PUSH_STRING_PTR_VALUE(0x437A24, __TIME__);
 58 | 	PATCH_PUSH_INT_PTR_VALUE(0x437A2E, BUILDNUMBER);
 59 | 	PATCH_PUSH_STRING_PTR_VALUE(0x4E9A5E, ""); //Too many visible models more than %i spam fix
 60 | 
 61 | 	__call(0x46319B, (int)sub_40E2B0); //cleanup exit
 62 | 
 63 | 	int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);
 64 | 	__call(0x528948, (int)WinMain);
 65 | 
 66 | 	//__nop(0x437B39, 5); //call NET_Init we're gonna call it a bit sooner cuz we need it ;)
 67 | 
 68 | 	void NET_Init();
 69 | 	__call(0x437B39, (int)NET_Init);
 70 | 
 71 | 	void Con_DrawSolidConsole(float);
 72 | 	__call(0x40A21D, (int)Con_DrawSolidConsole);
 73 | 	__call(0x40A234, (int)Con_DrawSolidConsole);
 74 | 	__call(0x40A257, (int)Con_DrawSolidConsole);
 75 | 
 76 | 	// void Con_Dump();
 77 | 	// __call(0x408BBC, (int)Con_Dump);
 78 | 
 79 | 	void CL_Connect_f();
 80 | 	XUNLOCK((void*)0x41269B, 5);
 81 | 	*(UINT32*)(0x41269B + 1) = (int)CL_Connect_f;
 82 | 
 83 | 	void RB_ExecuteRenderCommands();
 84 | 
 85 | 	unlock_client_structure(); // make some client cls_ structure members writeable etc
 86 | 
 87 | 	void X_CL_NextDownload();
 88 | 	__call(0x410316, (int)X_CL_NextDownload);
 89 | 	__call(0x410376, (int)X_CL_NextDownload);
 90 | 	__call(0x41656C, (int)X_CL_NextDownload);
 91 | 
 92 | 	void CL_Frame(int msec);
 93 | 	__call(0x43822C, (int)CL_Frame);
 94 | 
 95 | 	LRESULT CALLBACK ConsoleWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
 96 | 	XUNLOCK((void*)0x466414, 4);
 97 | 	*(int*)0x466414 = (int)ConsoleWndProc;
 98 | 
 99 | 	void Field_CharEvent_IgnoreTilde();
100 | 	__jmp(0x40CB1E, (int)Field_CharEvent_IgnoreTilde);
101 | 
102 | 	void CL_CharEvent();
103 | 	__call(0x436643, (int)CL_CharEvent);
104 | 
105 | 	void CL_KeyEvent(int, int, unsigned);
106 | 	__call(0x436635, (int)CL_KeyEvent);
107 | 
108 | 	void CL_PacketEvent();
109 | 	__call(0x436794, (int)CL_PacketEvent);
110 | 	__call(0x436743, (int)CL_PacketEvent);
111 | 
112 | 	void CL_Init();
113 | 	__call(0x437B4B, (int)CL_Init);
114 | 	__call(0x438178, (int)CL_Init);
115 | 
116 | 	void SCR_DrawScreenField(stereoFrame_t stereoFrame);
117 | 	__call(0x41703A, (int)SCR_DrawScreenField);
118 | 	__call(0x417048, (int)SCR_DrawScreenField);
119 | 	
120 | 	char* __cdecl CL_SetServerInfo_HostnameStrncpy(char*, char*, size_t);
121 |     __call(0x412A2C, (int)CL_SetServerInfo_HostnameStrncpy);
122 | 
123 | 	void DrawTris(void*);
124 | 	__call(0x5028FD, (int)DrawTris);
125 | 	__nop(0x5028F6, 2);
126 | 	__nop(0x5028EE, 2); //if(r_showtris->integer and some other check
127 | 
128 | 	void RB_ShowImages();
129 | 	__call(0x4D87F5, (int)RB_ShowImages);
130 | 	__nop(0x4D87F0, 5); //cmp and jz for r_showImages->integer
131 | 
132 | 	void* ri_Hunk_AllocAlign(int size);
133 | 	XUNLOCK((void*)0x4FD6AF, 6);
134 | 	*(BYTE*)0x4FD6AF = 0xe8;
135 | 	__call(0x4FD6AF, (int)ri_Hunk_AllocAlign); //cannot call since it's 6 opcodes
136 | 	*(BYTE*)(0x4FD6AF + 5) = 0x90;
137 | 
138 | 	void ScanAndLoadShaderFiles(void);
139 | 	__call(0x4FDB74, (int)ScanAndLoadShaderFiles);
140 | 
141 | 	void AddCustomShader_w();
142 | 	__jmp(0x4FD735, (int)AddCustomShader_w);
143 | 
144 | 	void CL_GlobalServers_f(void);
145 | 	__jmp(0x413890, (int)CL_GlobalServers_f);
146 | 
147 | 	void R_Init();
148 | 	__call(0x5035A2, (int)R_Init);
149 | 	qboolean R_GetModeInfo(int mode, int* height, float* windowAspect, int* width);
150 | 	__jmp(0x4B0EC0, (int)R_GetModeInfo);
151 | 
152 | 	return true;
153 | }


--------------------------------------------------------------------------------
/keycodes.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #define K_MWHEELDOWN 205
 4 | #define K_MWHEELUP 206
 5 | #define K_MOUSE1 200
 6 | #define K_MOUSE2 201
 7 | #define K_LCTRL 159
 8 | 
 9 | typedef struct {
10 | 	int x, y;
11 | } cursorPositionInfo_t;
12 | extern cursorPositionInfo_t *ui_cursor;
13 | 
14 | #define KEYCATCH_CONSOLE        0x0001
15 | #define KEYCATCH_UI             0x0002
16 | #define KEYCATCH_MESSAGE        0x0004
17 | #define KEYCATCH_CGAME          0x0008


--------------------------------------------------------------------------------
/keys.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "keycodes.h"
 3 | 
 4 | #define MAX_KEYS        256
 5 | 
 6 | typedef struct {
 7 | 	int down;
 8 | 	int repeats;                // if > 1, it is autorepeating
 9 | 	char        *binding;
10 | //	int hash; //cod1 doesn't use this anymore
11 | } qkey_t; //size is 0xc
12 | 
13 | 
14 | extern qkey_t *keys;
15 | 
16 | static void(*Key_SetCatcher)(int) = (void(*)(int))0x4180A0;


--------------------------------------------------------------------------------
/lib_export.def:
--------------------------------------------------------------------------------
1 | EXPORTS


--------------------------------------------------------------------------------
/librarymodule.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | #include "gl/gl.h"
 3 | 
 4 | #pragma comment(lib, "libs/detours/detours.lib")
 5 | #include "libs/detours/detours.h"
 6 | 
 7 | __int64 FileSize(std::string name)
 8 | {
 9 | 	WIN32_FILE_ATTRIBUTE_DATA fad;
10 | 	if (!GetFileAttributesEx(name.c_str(), GetFileExInfoStandard, &fad))
11 | 		return -1; // error condition, could call GetLastError to find out more
12 | 	LARGE_INTEGER size;
13 | 	size.HighPart = fad.nFileSizeHigh;
14 | 	size.LowPart = fad.nFileSizeLow;
15 | 	return size.QuadPart;
16 | }
17 | 
18 | HMODULE(WINAPI *orig_LoadLibraryA)(LPCSTR lpFileName);
19 | HMODULE WINAPI hLoadLibraryA(LPSTR lpFileName) {
20 | 	if (strstr(lpFileName, "codextended"))
21 | 		return NULL;
22 | 
23 | 	HMODULE hModule = orig_LoadLibraryA(lpFileName);
24 | 	DWORD pBase = (DWORD)GetModuleHandle(lpFileName);
25 | 
26 | 	if (!pBase)
27 | 		return hModule;
28 | 
29 | 	void Main_UnprotectModule(HMODULE hModule);
30 | 		Main_UnprotectModule(hModule);
31 | 
32 | 	if (strstr(lpFileName, "ui_mp") || strstr(lpFileName, "userinterface")) { /* clients updated by server */
33 | 		if(codversion != COD_1)
34 | 			return hModule;
35 | 		if (strstr(lpFileName, "ui_mp") && FileSize(lpFileName) < 0x249F0) //150kb
36 | 			return hModule;
37 | 
38 | 		void UI_Init(DWORD);
39 | 		UI_Init(pBase);
40 | 
41 | 	}
42 | 	else if (strstr(lpFileName, "cgame_mp") != NULL) {
43 | 		if (codversion != COD_1)
44 | 			return hModule;
45 | 		void CG_Init(DWORD);
46 | 		CG_Init(pBase);
47 | 	}
48 | 	else if (strstr(lpFileName, "game_mp") && !strstr(lpFileName, "cgame")) {
49 | 		void G_Init(DWORD);
50 | 		G_Init(pBase);
51 | 	}
52 | 
53 | 	return hModule;
54 | }
55 | 
56 | void patch_opcode_loadlibrary(void) {
57 | 	orig_LoadLibraryA = (struct HINSTANCE__ *(__stdcall*)(const char*)) \
58 | 	DetourFunction((LPBYTE)LoadLibraryA, (LPBYTE)hLoadLibraryA);
59 | }


--------------------------------------------------------------------------------
/libs/detours/detours.lib:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xtnded/codextended-client/45af251518a390ab08b1c8713a6a1544b70114a1/libs/detours/detours.lib


--------------------------------------------------------------------------------
/libs/discord/discord-rpc.lib:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xtnded/codextended-client/45af251518a390ab08b1c8713a6a1544b70114a1/libs/discord/discord-rpc.lib


--------------------------------------------------------------------------------
/libs/discord/discord_register.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #if defined(DISCORD_DYNAMIC_LIB)
 4 | #if defined(_WIN32)
 5 | #if defined(DISCORD_BUILDING_SDK)
 6 | #define DISCORD_EXPORT __declspec(dllexport)
 7 | #else
 8 | #define DISCORD_EXPORT __declspec(dllimport)
 9 | #endif
10 | #else
11 | #define DISCORD_EXPORT __attribute__((visibility("default")))
12 | #endif
13 | #else
14 | #define DISCORD_EXPORT
15 | #endif
16 | 
17 | #ifdef __cplusplus
18 | extern "C" {
19 | #endif
20 | 
21 | DISCORD_EXPORT void Discord_Register(const char* applicationId, const char* command);
22 | DISCORD_EXPORT void Discord_RegisterSteamGame(const char* applicationId, const char* steamId);
23 | 
24 | #ifdef __cplusplus
25 | }
26 | #endif
27 | 


--------------------------------------------------------------------------------
/libs/discord/discord_rpc.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <stdint.h>
 3 | 
 4 | // clang-format off
 5 | 
 6 | #if defined(DISCORD_DYNAMIC_LIB)
 7 | #  if defined(_WIN32)
 8 | #    if defined(DISCORD_BUILDING_SDK)
 9 | #      define DISCORD_EXPORT __declspec(dllexport)
10 | #    else
11 | #      define DISCORD_EXPORT __declspec(dllimport)
12 | #    endif
13 | #  else
14 | #    define DISCORD_EXPORT __attribute__((visibility("default")))
15 | #  endif
16 | #else
17 | #  define DISCORD_EXPORT
18 | #endif
19 | 
20 | // clang-format on
21 | 
22 | #ifdef __cplusplus
23 | extern "C" {
24 | #endif
25 | 
26 | typedef struct DiscordRichPresence {
27 |     const char* state;   /* max 128 bytes */
28 |     const char* details; /* max 128 bytes */
29 |     int64_t startTimestamp;
30 |     int64_t endTimestamp;
31 |     const char* largeImageKey;  /* max 32 bytes */
32 |     const char* largeImageText; /* max 128 bytes */
33 |     const char* smallImageKey;  /* max 32 bytes */
34 |     const char* smallImageText; /* max 128 bytes */
35 |     const char* partyId;        /* max 128 bytes */
36 |     int partySize;
37 |     int partyMax;
38 |     int partyPrivacy;
39 |     const char* matchSecret;    /* max 128 bytes */
40 |     const char* joinSecret;     /* max 128 bytes */
41 |     const char* spectateSecret; /* max 128 bytes */
42 |     int8_t instance;
43 | } DiscordRichPresence;
44 | 
45 | typedef struct DiscordUser {
46 |     const char* userId;
47 |     const char* username;
48 |     const char* discriminator;
49 |     const char* avatar;
50 | } DiscordUser;
51 | 
52 | typedef struct DiscordEventHandlers {
53 |     void (*ready)(const DiscordUser* request);
54 |     void (*disconnected)(int errorCode, const char* message);
55 |     void (*errored)(int errorCode, const char* message);
56 |     void (*joinGame)(const char* joinSecret);
57 |     void (*spectateGame)(const char* spectateSecret);
58 |     void (*joinRequest)(const DiscordUser* request);
59 | } DiscordEventHandlers;
60 | 
61 | #define DISCORD_REPLY_NO 0
62 | #define DISCORD_REPLY_YES 1
63 | #define DISCORD_REPLY_IGNORE 2
64 | #define DISCORD_PARTY_PRIVATE 0
65 | #define DISCORD_PARTY_PUBLIC 1
66 | 
67 | DISCORD_EXPORT void Discord_Initialize(const char* applicationId,
68 |                                        DiscordEventHandlers* handlers,
69 |                                        int autoRegister,
70 |                                        const char* optionalSteamId);
71 | DISCORD_EXPORT void Discord_Shutdown(void);
72 | 
73 | /* checks for incoming messages, dispatches callbacks */
74 | DISCORD_EXPORT void Discord_RunCallbacks(void);
75 | 
76 | /* If you disable the lib starting its own io thread, you'll need to call this from your own */
77 | #ifdef DISCORD_DISABLE_IO_THREAD
78 | DISCORD_EXPORT void Discord_UpdateConnection(void);
79 | #endif
80 | 
81 | DISCORD_EXPORT void Discord_UpdatePresence(const DiscordRichPresence* presence);
82 | DISCORD_EXPORT void Discord_ClearPresence(void);
83 | 
84 | DISCORD_EXPORT void Discord_Respond(const char* userid, /* DISCORD_REPLY_ */ int reply);
85 | 
86 | DISCORD_EXPORT void Discord_UpdateHandlers(DiscordEventHandlers* handlers);
87 | 
88 | #ifdef __cplusplus
89 | } /* extern "C" */
90 | #endif
91 | 


--------------------------------------------------------------------------------
/libs/libcurl/curlver.h:
--------------------------------------------------------------------------------
 1 | #ifndef CURLINC_CURLVER_H
 2 | #define CURLINC_CURLVER_H
 3 | /***************************************************************************
 4 |  *                                  _   _ ____  _
 5 |  *  Project                     ___| | | |  _ \| |
 6 |  *                             / __| | | | |_) | |
 7 |  *                            | (__| |_| |  _ <| |___
 8 |  *                             \___|\___/|_| \_\_____|
 9 |  *
10 |  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
11 |  *
12 |  * This software is licensed as described in the file COPYING, which
13 |  * you should have received as part of this distribution. The terms
14 |  * are also available at https://curl.se/docs/copyright.html.
15 |  *
16 |  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
17 |  * copies of the Software, and permit persons to whom the Software is
18 |  * furnished to do so, under the terms of the COPYING file.
19 |  *
20 |  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 |  * KIND, either express or implied.
22 |  *
23 |  * SPDX-License-Identifier: curl
24 |  *
25 |  ***************************************************************************/
26 | 
27 | /* This header file contains nothing but libcurl version info, generated by
28 |    a script at release-time. This was made its own header file in 7.11.2 */
29 | 
30 | /* This is the global package copyright */
31 | #define LIBCURL_COPYRIGHT "Daniel Stenberg, <daniel@haxx.se>."
32 | 
33 | /* This is the version number of the libcurl package from which this header
34 |    file origins: */
35 | #define LIBCURL_VERSION "8.5.0"
36 | 
37 | /* The numeric version number is also available "in parts" by using these
38 |    defines: */
39 | #define LIBCURL_VERSION_MAJOR 8
40 | #define LIBCURL_VERSION_MINOR 5
41 | #define LIBCURL_VERSION_PATCH 0
42 | 
43 | /* This is the numeric version of the libcurl version number, meant for easier
44 |    parsing and comparisons by programs. The LIBCURL_VERSION_NUM define will
45 |    always follow this syntax:
46 | 
47 |          0xXXYYZZ
48 | 
49 |    Where XX, YY and ZZ are the main version, release and patch numbers in
50 |    hexadecimal (using 8 bits each). All three numbers are always represented
51 |    using two digits.  1.2 would appear as "0x010200" while version 9.11.7
52 |    appears as "0x090b07".
53 | 
54 |    This 6-digit (24 bits) hexadecimal number does not show pre-release number,
55 |    and it is always a greater number in a more recent release. It makes
56 |    comparisons with greater than and less than work.
57 | 
58 |    Note: This define is the full hex number and _does not_ use the
59 |    CURL_VERSION_BITS() macro since curl's own configure script greps for it
60 |    and needs it to contain the full number.
61 | */
62 | #define LIBCURL_VERSION_NUM 0x080500
63 | 
64 | /*
65 |  * This is the date and time when the full source package was created. The
66 |  * timestamp is not stored in git, as the timestamp is properly set in the
67 |  * tarballs by the maketgz script.
68 |  *
69 |  * The format of the date follows this template:
70 |  *
71 |  * "2007-11-23"
72 |  */
73 | #define LIBCURL_TIMESTAMP "2023-12-06"
74 | 
75 | #define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|(z))
76 | #define CURL_AT_LEAST_VERSION(x,y,z) \
77 |   (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z))
78 | 
79 | #endif /* CURLINC_CURLVER_H */
80 | 


--------------------------------------------------------------------------------
/libs/libcurl/easy.h:
--------------------------------------------------------------------------------
  1 | #ifndef CURLINC_EASY_H
  2 | #define CURLINC_EASY_H
  3 | /***************************************************************************
  4 |  *                                  _   _ ____  _
  5 |  *  Project                     ___| | | |  _ \| |
  6 |  *                             / __| | | | |_) | |
  7 |  *                            | (__| |_| |  _ <| |___
  8 |  *                             \___|\___/|_| \_\_____|
  9 |  *
 10 |  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
 11 |  *
 12 |  * This software is licensed as described in the file COPYING, which
 13 |  * you should have received as part of this distribution. The terms
 14 |  * are also available at https://curl.se/docs/copyright.html.
 15 |  *
 16 |  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 17 |  * copies of the Software, and permit persons to whom the Software is
 18 |  * furnished to do so, under the terms of the COPYING file.
 19 |  *
 20 |  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 21 |  * KIND, either express or implied.
 22 |  *
 23 |  * SPDX-License-Identifier: curl
 24 |  *
 25 |  ***************************************************************************/
 26 | #ifdef  __cplusplus
 27 | extern "C" {
 28 | #endif
 29 | 
 30 | /* Flag bits in the curl_blob struct: */
 31 | #define CURL_BLOB_COPY   1 /* tell libcurl to copy the data */
 32 | #define CURL_BLOB_NOCOPY 0 /* tell libcurl to NOT copy the data */
 33 | 
 34 | struct curl_blob {
 35 |   void *data;
 36 |   size_t len;
 37 |   unsigned int flags; /* bit 0 is defined, the rest are reserved and should be
 38 |                          left zeroes */
 39 | };
 40 | 
 41 | CURL_EXTERN CURL *curl_easy_init(void);
 42 | CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
 43 | CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
 44 | CURL_EXTERN void curl_easy_cleanup(CURL *curl);
 45 | 
 46 | /*
 47 |  * NAME curl_easy_getinfo()
 48 |  *
 49 |  * DESCRIPTION
 50 |  *
 51 |  * Request internal information from the curl session with this function.
 52 |  * The third argument MUST be pointing to the specific type of the used option
 53 |  * which is documented in each man page of the option. The data pointed to
 54 |  * will be filled in accordingly and can be relied upon only if the function
 55 |  * returns CURLE_OK. This function is intended to get used *AFTER* a performed
 56 |  * transfer, all results from this function are undefined until the transfer
 57 |  * is completed.
 58 |  */
 59 | CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
 60 | 
 61 | 
 62 | /*
 63 |  * NAME curl_easy_duphandle()
 64 |  *
 65 |  * DESCRIPTION
 66 |  *
 67 |  * Creates a new curl session handle with the same options set for the handle
 68 |  * passed in. Duplicating a handle could only be a matter of cloning data and
 69 |  * options, internal state info and things like persistent connections cannot
 70 |  * be transferred. It is useful in multithreaded applications when you can run
 71 |  * curl_easy_duphandle() for each new thread to avoid a series of identical
 72 |  * curl_easy_setopt() invokes in every thread.
 73 |  */
 74 | CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl);
 75 | 
 76 | /*
 77 |  * NAME curl_easy_reset()
 78 |  *
 79 |  * DESCRIPTION
 80 |  *
 81 |  * Re-initializes a CURL handle to the default values. This puts back the
 82 |  * handle to the same state as it was in when it was just created.
 83 |  *
 84 |  * It does keep: live connections, the Session ID cache, the DNS cache and the
 85 |  * cookies.
 86 |  */
 87 | CURL_EXTERN void curl_easy_reset(CURL *curl);
 88 | 
 89 | /*
 90 |  * NAME curl_easy_recv()
 91 |  *
 92 |  * DESCRIPTION
 93 |  *
 94 |  * Receives data from the connected socket. Use after successful
 95 |  * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
 96 |  */
 97 | CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
 98 |                                     size_t *n);
 99 | 
100 | /*
101 |  * NAME curl_easy_send()
102 |  *
103 |  * DESCRIPTION
104 |  *
105 |  * Sends data over the connected socket. Use after successful
106 |  * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
107 |  */
108 | CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
109 |                                     size_t buflen, size_t *n);
110 | 
111 | 
112 | /*
113 |  * NAME curl_easy_upkeep()
114 |  *
115 |  * DESCRIPTION
116 |  *
117 |  * Performs connection upkeep for the given session handle.
118 |  */
119 | CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl);
120 | 
121 | #ifdef  __cplusplus
122 | } /* end of extern "C" */
123 | #endif
124 | 
125 | #endif
126 | 


--------------------------------------------------------------------------------
/libs/libcurl/header.h:
--------------------------------------------------------------------------------
 1 | #ifndef CURLINC_HEADER_H
 2 | #define CURLINC_HEADER_H
 3 | /***************************************************************************
 4 |  *                                  _   _ ____  _
 5 |  *  Project                     ___| | | |  _ \| |
 6 |  *                             / __| | | | |_) | |
 7 |  *                            | (__| |_| |  _ <| |___
 8 |  *                             \___|\___/|_| \_\_____|
 9 |  *
10 |  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
11 |  *
12 |  * This software is licensed as described in the file COPYING, which
13 |  * you should have received as part of this distribution. The terms
14 |  * are also available at https://curl.se/docs/copyright.html.
15 |  *
16 |  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
17 |  * copies of the Software, and permit persons to whom the Software is
18 |  * furnished to do so, under the terms of the COPYING file.
19 |  *
20 |  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 |  * KIND, either express or implied.
22 |  *
23 |  * SPDX-License-Identifier: curl
24 |  *
25 |  ***************************************************************************/
26 | 
27 | #ifdef  __cplusplus
28 | extern "C" {
29 | #endif
30 | 
31 | struct curl_header {
32 |   char *name;    /* this might not use the same case */
33 |   char *value;
34 |   size_t amount; /* number of headers using this name  */
35 |   size_t index;  /* ... of this instance, 0 or higher */
36 |   unsigned int origin; /* see bits below */
37 |   void *anchor; /* handle privately used by libcurl */
38 | };
39 | 
40 | /* 'origin' bits */
41 | #define CURLH_HEADER    (1<<0) /* plain server header */
42 | #define CURLH_TRAILER   (1<<1) /* trailers */
43 | #define CURLH_CONNECT   (1<<2) /* CONNECT headers */
44 | #define CURLH_1XX       (1<<3) /* 1xx headers */
45 | #define CURLH_PSEUDO    (1<<4) /* pseudo headers */
46 | 
47 | typedef enum {
48 |   CURLHE_OK,
49 |   CURLHE_BADINDEX,      /* header exists but not with this index */
50 |   CURLHE_MISSING,       /* no such header exists */
51 |   CURLHE_NOHEADERS,     /* no headers at all exist (yet) */
52 |   CURLHE_NOREQUEST,     /* no request with this number was used */
53 |   CURLHE_OUT_OF_MEMORY, /* out of memory while processing */
54 |   CURLHE_BAD_ARGUMENT,  /* a function argument was not okay */
55 |   CURLHE_NOT_BUILT_IN   /* if API was disabled in the build */
56 | } CURLHcode;
57 | 
58 | CURL_EXTERN CURLHcode curl_easy_header(CURL *easy,
59 |                                        const char *name,
60 |                                        size_t index,
61 |                                        unsigned int origin,
62 |                                        int request,
63 |                                        struct curl_header **hout);
64 | 
65 | CURL_EXTERN struct curl_header *curl_easy_nextheader(CURL *easy,
66 |                                                      unsigned int origin,
67 |                                                      int request,
68 |                                                      struct curl_header *prev);
69 | 
70 | #ifdef __cplusplus
71 | } /* end of extern "C" */
72 | #endif
73 | 
74 | #endif /* CURLINC_HEADER_H */
75 | 


--------------------------------------------------------------------------------
/libs/libcurl/libcurl.lib:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xtnded/codextended-client/45af251518a390ab08b1c8713a6a1544b70114a1/libs/libcurl/libcurl.lib


--------------------------------------------------------------------------------
/libs/libcurl/libcurl_a.lib:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xtnded/codextended-client/45af251518a390ab08b1c8713a6a1544b70114a1/libs/libcurl/libcurl_a.lib


--------------------------------------------------------------------------------
/libs/libcurl/mprintf.h:
--------------------------------------------------------------------------------
 1 | #ifndef CURLINC_MPRINTF_H
 2 | #define CURLINC_MPRINTF_H
 3 | /***************************************************************************
 4 |  *                                  _   _ ____  _
 5 |  *  Project                     ___| | | |  _ \| |
 6 |  *                             / __| | | | |_) | |
 7 |  *                            | (__| |_| |  _ <| |___
 8 |  *                             \___|\___/|_| \_\_____|
 9 |  *
10 |  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
11 |  *
12 |  * This software is licensed as described in the file COPYING, which
13 |  * you should have received as part of this distribution. The terms
14 |  * are also available at https://curl.se/docs/copyright.html.
15 |  *
16 |  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
17 |  * copies of the Software, and permit persons to whom the Software is
18 |  * furnished to do so, under the terms of the COPYING file.
19 |  *
20 |  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 |  * KIND, either express or implied.
22 |  *
23 |  * SPDX-License-Identifier: curl
24 |  *
25 |  ***************************************************************************/
26 | 
27 | #include <stdarg.h>
28 | #include <stdio.h> /* needed for FILE */
29 | #include "curl.h"  /* for CURL_EXTERN */
30 | 
31 | #ifdef  __cplusplus
32 | extern "C" {
33 | #endif
34 | 
35 | #if (defined(__GNUC__) || defined(__clang__)) &&                        \
36 |   defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) &&         \
37 |   !defined(__MINGW32__) && !defined(CURL_NO_FMT_CHECKS)
38 | #define CURL_TEMP_PRINTF(a,b) __attribute__ ((format(printf, a, b)))
39 | #else
40 | #define CURL_TEMP_PRINTF(a,b)
41 | #endif
42 | 
43 | CURL_EXTERN int curl_mprintf(const char *format, ...) CURL_TEMP_PRINTF(1, 2);
44 | CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...)
45 |   CURL_TEMP_PRINTF(2, 3);
46 | CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...)
47 |   CURL_TEMP_PRINTF(2, 3);
48 | CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
49 |                                const char *format, ...) CURL_TEMP_PRINTF(3, 4);
50 | CURL_EXTERN int curl_mvprintf(const char *format, va_list args)
51 |   CURL_TEMP_PRINTF(1, 0);
52 | CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args)
53 |   CURL_TEMP_PRINTF(2, 0);
54 | CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args)
55 |   CURL_TEMP_PRINTF(2, 0);
56 | CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
57 |                                 const char *format, va_list args)
58 |   CURL_TEMP_PRINTF(3, 0);
59 | CURL_EXTERN char *curl_maprintf(const char *format, ...)
60 |   CURL_TEMP_PRINTF(1, 2);
61 | CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args)
62 |   CURL_TEMP_PRINTF(1, 0);
63 | 
64 | #undef CURL_TEMP_PRINTF
65 | 
66 | #ifdef  __cplusplus
67 | } /* end of extern "C" */
68 | #endif
69 | 
70 | #endif /* CURLINC_MPRINTF_H */
71 | 


--------------------------------------------------------------------------------
/libs/libcurl/options.h:
--------------------------------------------------------------------------------
 1 | #ifndef CURLINC_OPTIONS_H
 2 | #define CURLINC_OPTIONS_H
 3 | /***************************************************************************
 4 |  *                                  _   _ ____  _
 5 |  *  Project                     ___| | | |  _ \| |
 6 |  *                             / __| | | | |_) | |
 7 |  *                            | (__| |_| |  _ <| |___
 8 |  *                             \___|\___/|_| \_\_____|
 9 |  *
10 |  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
11 |  *
12 |  * This software is licensed as described in the file COPYING, which
13 |  * you should have received as part of this distribution. The terms
14 |  * are also available at https://curl.se/docs/copyright.html.
15 |  *
16 |  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
17 |  * copies of the Software, and permit persons to whom the Software is
18 |  * furnished to do so, under the terms of the COPYING file.
19 |  *
20 |  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 |  * KIND, either express or implied.
22 |  *
23 |  * SPDX-License-Identifier: curl
24 |  *
25 |  ***************************************************************************/
26 | 
27 | #ifdef  __cplusplus
28 | extern "C" {
29 | #endif
30 | 
31 | typedef enum {
32 |   CURLOT_LONG,    /* long (a range of values) */
33 |   CURLOT_VALUES,  /*      (a defined set or bitmask) */
34 |   CURLOT_OFF_T,   /* curl_off_t (a range of values) */
35 |   CURLOT_OBJECT,  /* pointer (void *) */
36 |   CURLOT_STRING,  /*         (char * to null-terminated buffer) */
37 |   CURLOT_SLIST,   /*         (struct curl_slist *) */
38 |   CURLOT_CBPTR,   /*         (void * passed as-is to a callback) */
39 |   CURLOT_BLOB,    /* blob (struct curl_blob *) */
40 |   CURLOT_FUNCTION /* function pointer */
41 | } curl_easytype;
42 | 
43 | /* Flag bits */
44 | 
45 | /* "alias" means it is provided for old programs to remain functional,
46 |    we prefer another name */
47 | #define CURLOT_FLAG_ALIAS (1<<0)
48 | 
49 | /* The CURLOPTTYPE_* id ranges can still be used to figure out what type/size
50 |    to use for curl_easy_setopt() for the given id */
51 | struct curl_easyoption {
52 |   const char *name;
53 |   CURLoption id;
54 |   curl_easytype type;
55 |   unsigned int flags;
56 | };
57 | 
58 | CURL_EXTERN const struct curl_easyoption *
59 | curl_easy_option_by_name(const char *name);
60 | 
61 | CURL_EXTERN const struct curl_easyoption *
62 | curl_easy_option_by_id(CURLoption id);
63 | 
64 | CURL_EXTERN const struct curl_easyoption *
65 | curl_easy_option_next(const struct curl_easyoption *prev);
66 | 
67 | #ifdef __cplusplus
68 | } /* end of extern "C" */
69 | #endif
70 | #endif /* CURLINC_OPTIONS_H */
71 | 


--------------------------------------------------------------------------------
/libs/libcurl/stdcheaders.h:
--------------------------------------------------------------------------------
 1 | #ifndef CURLINC_STDCHEADERS_H
 2 | #define CURLINC_STDCHEADERS_H
 3 | /***************************************************************************
 4 |  *                                  _   _ ____  _
 5 |  *  Project                     ___| | | |  _ \| |
 6 |  *                             / __| | | | |_) | |
 7 |  *                            | (__| |_| |  _ <| |___
 8 |  *                             \___|\___/|_| \_\_____|
 9 |  *
10 |  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
11 |  *
12 |  * This software is licensed as described in the file COPYING, which
13 |  * you should have received as part of this distribution. The terms
14 |  * are also available at https://curl.se/docs/copyright.html.
15 |  *
16 |  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
17 |  * copies of the Software, and permit persons to whom the Software is
18 |  * furnished to do so, under the terms of the COPYING file.
19 |  *
20 |  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 |  * KIND, either express or implied.
22 |  *
23 |  * SPDX-License-Identifier: curl
24 |  *
25 |  ***************************************************************************/
26 | 
27 | #include <sys/types.h>
28 | 
29 | size_t fread(void *, size_t, size_t, FILE *);
30 | size_t fwrite(const void *, size_t, size_t, FILE *);
31 | 
32 | int strcasecmp(const char *, const char *);
33 | int strncasecmp(const char *, const char *, size_t);
34 | 
35 | #endif /* CURLINC_STDCHEADERS_H */
36 | 


--------------------------------------------------------------------------------
/libs/libcurl/urlapi.h:
--------------------------------------------------------------------------------
  1 | #ifndef CURLINC_URLAPI_H
  2 | #define CURLINC_URLAPI_H
  3 | /***************************************************************************
  4 |  *                                  _   _ ____  _
  5 |  *  Project                     ___| | | |  _ \| |
  6 |  *                             / __| | | | |_) | |
  7 |  *                            | (__| |_| |  _ <| |___
  8 |  *                             \___|\___/|_| \_\_____|
  9 |  *
 10 |  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
 11 |  *
 12 |  * This software is licensed as described in the file COPYING, which
 13 |  * you should have received as part of this distribution. The terms
 14 |  * are also available at https://curl.se/docs/copyright.html.
 15 |  *
 16 |  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 17 |  * copies of the Software, and permit persons to whom the Software is
 18 |  * furnished to do so, under the terms of the COPYING file.
 19 |  *
 20 |  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 21 |  * KIND, either express or implied.
 22 |  *
 23 |  * SPDX-License-Identifier: curl
 24 |  *
 25 |  ***************************************************************************/
 26 | 
 27 | #include "curl.h"
 28 | 
 29 | #ifdef  __cplusplus
 30 | extern "C" {
 31 | #endif
 32 | 
 33 | /* the error codes for the URL API */
 34 | typedef enum {
 35 |   CURLUE_OK,
 36 |   CURLUE_BAD_HANDLE,          /* 1 */
 37 |   CURLUE_BAD_PARTPOINTER,     /* 2 */
 38 |   CURLUE_MALFORMED_INPUT,     /* 3 */
 39 |   CURLUE_BAD_PORT_NUMBER,     /* 4 */
 40 |   CURLUE_UNSUPPORTED_SCHEME,  /* 5 */
 41 |   CURLUE_URLDECODE,           /* 6 */
 42 |   CURLUE_OUT_OF_MEMORY,       /* 7 */
 43 |   CURLUE_USER_NOT_ALLOWED,    /* 8 */
 44 |   CURLUE_UNKNOWN_PART,        /* 9 */
 45 |   CURLUE_NO_SCHEME,           /* 10 */
 46 |   CURLUE_NO_USER,             /* 11 */
 47 |   CURLUE_NO_PASSWORD,         /* 12 */
 48 |   CURLUE_NO_OPTIONS,          /* 13 */
 49 |   CURLUE_NO_HOST,             /* 14 */
 50 |   CURLUE_NO_PORT,             /* 15 */
 51 |   CURLUE_NO_QUERY,            /* 16 */
 52 |   CURLUE_NO_FRAGMENT,         /* 17 */
 53 |   CURLUE_NO_ZONEID,           /* 18 */
 54 |   CURLUE_BAD_FILE_URL,        /* 19 */
 55 |   CURLUE_BAD_FRAGMENT,        /* 20 */
 56 |   CURLUE_BAD_HOSTNAME,        /* 21 */
 57 |   CURLUE_BAD_IPV6,            /* 22 */
 58 |   CURLUE_BAD_LOGIN,           /* 23 */
 59 |   CURLUE_BAD_PASSWORD,        /* 24 */
 60 |   CURLUE_BAD_PATH,            /* 25 */
 61 |   CURLUE_BAD_QUERY,           /* 26 */
 62 |   CURLUE_BAD_SCHEME,          /* 27 */
 63 |   CURLUE_BAD_SLASHES,         /* 28 */
 64 |   CURLUE_BAD_USER,            /* 29 */
 65 |   CURLUE_LACKS_IDN,           /* 30 */
 66 |   CURLUE_LAST
 67 | } CURLUcode;
 68 | 
 69 | typedef enum {
 70 |   CURLUPART_URL,
 71 |   CURLUPART_SCHEME,
 72 |   CURLUPART_USER,
 73 |   CURLUPART_PASSWORD,
 74 |   CURLUPART_OPTIONS,
 75 |   CURLUPART_HOST,
 76 |   CURLUPART_PORT,
 77 |   CURLUPART_PATH,
 78 |   CURLUPART_QUERY,
 79 |   CURLUPART_FRAGMENT,
 80 |   CURLUPART_ZONEID /* added in 7.65.0 */
 81 | } CURLUPart;
 82 | 
 83 | #define CURLU_DEFAULT_PORT (1<<0)       /* return default port number */
 84 | #define CURLU_NO_DEFAULT_PORT (1<<1)    /* act as if no port number was set,
 85 |                                            if the port number matches the
 86 |                                            default for the scheme */
 87 | #define CURLU_DEFAULT_SCHEME (1<<2)     /* return default scheme if
 88 |                                            missing */
 89 | #define CURLU_NON_SUPPORT_SCHEME (1<<3) /* allow non-supported scheme */
 90 | #define CURLU_PATH_AS_IS (1<<4)         /* leave dot sequences */
 91 | #define CURLU_DISALLOW_USER (1<<5)      /* no user+password allowed */
 92 | #define CURLU_URLDECODE (1<<6)          /* URL decode on get */
 93 | #define CURLU_URLENCODE (1<<7)          /* URL encode on set */
 94 | #define CURLU_APPENDQUERY (1<<8)        /* append a form style part */
 95 | #define CURLU_GUESS_SCHEME (1<<9)       /* legacy curl-style guessing */
 96 | #define CURLU_NO_AUTHORITY (1<<10)      /* Allow empty authority when the
 97 |                                            scheme is unknown. */
 98 | #define CURLU_ALLOW_SPACE (1<<11)       /* Allow spaces in the URL */
 99 | #define CURLU_PUNYCODE (1<<12)          /* get the host name in punycode */
100 | #define CURLU_PUNY2IDN (1<<13)          /* punycode => IDN conversion */
101 | 
102 | typedef struct Curl_URL CURLU;
103 | 
104 | /*
105 |  * curl_url() creates a new CURLU handle and returns a pointer to it.
106 |  * Must be freed with curl_url_cleanup().
107 |  */
108 | CURL_EXTERN CURLU *curl_url(void);
109 | 
110 | /*
111 |  * curl_url_cleanup() frees the CURLU handle and related resources used for
112 |  * the URL parsing. It will not free strings previously returned with the URL
113 |  * API.
114 |  */
115 | CURL_EXTERN void curl_url_cleanup(CURLU *handle);
116 | 
117 | /*
118 |  * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new
119 |  * handle must also be freed with curl_url_cleanup().
120 |  */
121 | CURL_EXTERN CURLU *curl_url_dup(const CURLU *in);
122 | 
123 | /*
124 |  * curl_url_get() extracts a specific part of the URL from a CURLU
125 |  * handle. Returns error code. The returned pointer MUST be freed with
126 |  * curl_free() afterwards.
127 |  */
128 | CURL_EXTERN CURLUcode curl_url_get(const CURLU *handle, CURLUPart what,
129 |                                    char **part, unsigned int flags);
130 | 
131 | /*
132 |  * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns
133 |  * error code. The passed in string will be copied. Passing a NULL instead of
134 |  * a part string, clears that part.
135 |  */
136 | CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what,
137 |                                    const char *part, unsigned int flags);
138 | 
139 | /*
140 |  * curl_url_strerror() turns a CURLUcode value into the equivalent human
141 |  * readable error string.  This is useful for printing meaningful error
142 |  * messages.
143 |  */
144 | CURL_EXTERN const char *curl_url_strerror(CURLUcode);
145 | 
146 | #ifdef __cplusplus
147 | } /* end of extern "C" */
148 | #endif
149 | 
150 | #endif /* CURLINC_URLAPI_H */
151 | 


--------------------------------------------------------------------------------
/libs/libcurl/websockets.h:
--------------------------------------------------------------------------------
 1 | #ifndef CURLINC_WEBSOCKETS_H
 2 | #define CURLINC_WEBSOCKETS_H
 3 | /***************************************************************************
 4 |  *                                  _   _ ____  _
 5 |  *  Project                     ___| | | |  _ \| |
 6 |  *                             / __| | | | |_) | |
 7 |  *                            | (__| |_| |  _ <| |___
 8 |  *                             \___|\___/|_| \_\_____|
 9 |  *
10 |  * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
11 |  *
12 |  * This software is licensed as described in the file COPYING, which
13 |  * you should have received as part of this distribution. The terms
14 |  * are also available at https://curl.se/docs/copyright.html.
15 |  *
16 |  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
17 |  * copies of the Software, and permit persons to whom the Software is
18 |  * furnished to do so, under the terms of the COPYING file.
19 |  *
20 |  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 |  * KIND, either express or implied.
22 |  *
23 |  * SPDX-License-Identifier: curl
24 |  *
25 |  ***************************************************************************/
26 | 
27 | #ifdef  __cplusplus
28 | extern "C" {
29 | #endif
30 | 
31 | struct curl_ws_frame {
32 |   int age;              /* zero */
33 |   int flags;            /* See the CURLWS_* defines */
34 |   curl_off_t offset;    /* the offset of this data into the frame */
35 |   curl_off_t bytesleft; /* number of pending bytes left of the payload */
36 |   size_t len;           /* size of the current data chunk */
37 | };
38 | 
39 | /* flag bits */
40 | #define CURLWS_TEXT       (1<<0)
41 | #define CURLWS_BINARY     (1<<1)
42 | #define CURLWS_CONT       (1<<2)
43 | #define CURLWS_CLOSE      (1<<3)
44 | #define CURLWS_PING       (1<<4)
45 | #define CURLWS_OFFSET     (1<<5)
46 | 
47 | /*
48 |  * NAME curl_ws_recv()
49 |  *
50 |  * DESCRIPTION
51 |  *
52 |  * Receives data from the websocket connection. Use after successful
53 |  * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
54 |  */
55 | CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen,
56 |                                   size_t *recv,
57 |                                   const struct curl_ws_frame **metap);
58 | 
59 | /* flags for curl_ws_send() */
60 | #define CURLWS_PONG       (1<<6)
61 | 
62 | /*
63 |  * NAME curl_ws_send()
64 |  *
65 |  * DESCRIPTION
66 |  *
67 |  * Sends data over the websocket connection. Use after successful
68 |  * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
69 |  */
70 | CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer,
71 |                                   size_t buflen, size_t *sent,
72 |                                   curl_off_t fragsize,
73 |                                   unsigned int flags);
74 | 
75 | /* bits for the CURLOPT_WS_OPTIONS bitmask: */
76 | #define CURLWS_RAW_MODE (1<<0)
77 | 
78 | CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(CURL *curl);
79 | 
80 | #ifdef  __cplusplus
81 | }
82 | #endif
83 | 
84 | #endif /* CURLINC_WEBSOCKETS_H */
85 | 


--------------------------------------------------------------------------------
/mem_util.h:
--------------------------------------------------------------------------------
  1 | #ifdef _WIN32
  2 | #define JUNK_CODE_ONE        \
  3 |     __asm{push eax}            \
  4 |     __asm{xor eax, eax}        \
  5 |     __asm{setpo al}            \
  6 |     __asm{push edx}            \
  7 |     __asm{xor edx, eax}        \
  8 |     __asm{sal edx, 2}        \
  9 |     __asm{xchg eax, edx}    \
 10 |     __asm{pop edx}            \
 11 |     __asm{or eax, ecx}        \
 12 |     __asm{pop eax}
 13 | #else
 14 | #define JUNK_CODE_ONE
 15 | #endif
 16 | 
 17 | static void XUNLOCK(void *addr, size_t len) {
 18 | #if _WIN32
 19 | 	DWORD tmp;
 20 | #if 0 //kept failing on me "The program issued a command but the command length is incorrect"
 21 | 	MEMORY_BASIC_INFORMATION info;
 22 | 
 23 | 	if (!VirtualQuery(addr, &info, len))
 24 | 		return;
 25 | 	
 26 | 	if (info.Protect != PAGE_EXECUTE_READWRITE)
 27 | #endif
 28 | 		VirtualProtect(addr, len, PAGE_EXECUTE_READWRITE, &tmp);
 29 | #endif
 30 | }
 31 | 
 32 | static void _memset(void* addr, int v, size_t len) {
 33 | #ifdef _WIN32
 34 | 	DWORD tmp;
 35 | 	VirtualProtect((void*)addr, len, PAGE_EXECUTE_READWRITE, &tmp);
 36 | #endif
 37 | 	memset(addr, v, len);
 38 | 	FlushInstructionCache(GetCurrentProcess(), (void*)addr, len);
 39 | #ifdef _WIN32
 40 | 	//VirtualProtect((void*)addr, len, tmp, &tmp);
 41 | #endif
 42 | }
 43 | 
 44 | static void _memcpy(void* v1, void* v2, size_t len) {
 45 | #ifdef _WIN32
 46 | 	DWORD tmp;
 47 | 	VirtualProtect((void*)v1, len, PAGE_EXECUTE_READWRITE, &tmp);
 48 | #endif
 49 | 	memcpy(v1, v2, len);
 50 | 	FlushInstructionCache(GetCurrentProcess(), (void*)v1, len);
 51 | #ifdef _WIN32
 52 | 	//VirtualProtect((void*)v1, len, tmp, &tmp);
 53 | #endif
 54 | }
 55 | 
 56 | static int search_memory(int current, int end, BYTE* bytes, size_t len) {
 57 | 	while ((memcmp((void*)current, bytes, len)) && (current < end))
 58 | 		current++;
 59 | 	return (current == end) ? -1 : current;
 60 | }
 61 | 
 62 | static int patch_memory(int start, int end, BYTE* search_for, BYTE* patched, size_t len) {
 63 | 	int s = search_memory(start, end, search_for, len);
 64 | #ifdef _WIN32
 65 | 	DWORD tmp;
 66 | #endif
 67 | 	if (-1 != s) {
 68 | #ifdef _WIN32
 69 | 		VirtualProtect((void*)s, len, PAGE_EXECUTE_READWRITE, &tmp);
 70 | #endif
 71 | 		memcpy((void*)s, patched, len);
 72 | 		FlushInstructionCache(GetCurrentProcess(), (void*)s, len);
 73 | #ifdef _WIN32
 74 | 		VirtualProtect((void*)s, len, tmp, &tmp);
 75 | #endif
 76 | 	}
 77 | 	return s;
 78 | }
 79 | 
 80 | /*
 81 | Hooking
 82 | */
 83 | 
 84 | static void __nop(unsigned int start, unsigned int end) {
 85 | 	int len = (end < start) ? end : (end - start);
 86 | #ifdef _WIN32
 87 | 	DWORD tmp;
 88 | 	VirtualProtect((void*)start, len, PAGE_EXECUTE_READWRITE, &tmp);
 89 | #endif
 90 | 	memset((void*)start, 0x90, len);
 91 | 	FlushInstructionCache(GetCurrentProcess(), (void*)start, len);
 92 | #ifdef _WIN32
 93 | 	VirtualProtect((void*)start, len, tmp, &tmp);
 94 | #endif
 95 | }
 96 | 
 97 | static void __jmp(unsigned int off, unsigned int loc) {
 98 | #ifdef _WIN32
 99 | 	DWORD tmp;
100 | 	VirtualProtect((void*)off, 5, PAGE_EXECUTE_READWRITE, &tmp);
101 | #endif
102 | 	*(unsigned char*)off = 0xe9;
103 | 	int foffset = loc - (off + 5);
104 | 	memcpy((void*)(off + 1), &foffset, 4);
105 | 	FlushInstructionCache(GetCurrentProcess(), (void*)off, 5);
106 | #ifdef _WIN32
107 | 	VirtualProtect((void*)off, 5, tmp, &tmp);
108 | #endif
109 | }
110 | 
111 | static void __call(unsigned int off, unsigned int loc) {
112 | #ifdef _WIN32
113 | 	DWORD tmp;
114 | 	VirtualProtect((void*)off, 5, PAGE_EXECUTE_READWRITE, &tmp);
115 | #endif
116 | 	int foffset = loc - (off + 5);
117 | 	memcpy((void *)(off + 1), &foffset, 4);
118 | 	FlushInstructionCache(GetCurrentProcess(), (void*)off, 5);
119 | #ifdef _WIN32
120 | 	VirtualProtect((void*)off, 5, tmp, &tmp);
121 | #endif
122 | }
123 | 
124 | 
125 | static void dumpbase(int* base, size_t len, const char *fn) {
126 | 	static char dumpbase_path[64];
127 | 
128 | 	_snprintf(dumpbase_path, 63, "./dumpfiles/%s.dump", fn);
129 | 
130 | 	unsigned int result;
131 | 	float rf;
132 | 	char* rstr;
133 | 
134 | 	FILE* f = fopen(dumpbase_path, "wb");
135 | 	if (f) {
136 | 		fprintf(f, "File: %s\nDUMPFILE\n\n");
137 | 
138 | 		for (unsigned int i = 0; i < len; i++) {
139 | 			result = *(unsigned int*)(base + i);
140 | 			rf = *(float*)(base + i);
141 | 			rstr = (char*)(base + i);
142 | 			fprintf(f, "%d: Hex: %x, Decimal: %d, Float: %f, String: %s\n", i, result, result, rf, rstr);
143 | 		}
144 | 		fclose(f);
145 | 	}
146 | 
147 | 	//Com_Printf("Successfully dumped '%s' to location '%s'.\n", fn, dumpbase_path);
148 | }


--------------------------------------------------------------------------------
/menudef.h:
--------------------------------------------------------------------------------
  1 | #define ITEM_TYPE_TEXT			0	// simple text
  2 | #define ITEM_TYPE_BUTTON		1	// button, basically text with a border 
  3 | #define ITEM_TYPE_RADIOBUTTON		2	// toggle button, may be grouped 
  4 | #define ITEM_TYPE_CHECKBOX		3	// check box
  5 | #define ITEM_TYPE_EDITFIELD 		4	// editable text, associated with a cvar
  6 | #define ITEM_TYPE_COMBO 		5	// drop down list
  7 | #define ITEM_TYPE_LISTBOX		6	// scrollable list	
  8 | #define ITEM_TYPE_MODEL 		7	// model
  9 | #define ITEM_TYPE_OWNERDRAW 		8	// owner draw, name specs what it is
 10 | #define ITEM_TYPE_NUMERICFIELD		9	// editable text, associated with a cvar
 11 | #define ITEM_TYPE_SLIDER		10	// mouse speed, volume, etc.
 12 | #define ITEM_TYPE_YESNO 		11	// yes no cvar setting
 13 | #define ITEM_TYPE_MULTI 		12	// multiple list setting, enumerated
 14 | #define ITEM_TYPE_BIND			13	// multiple list setting, enumerated
 15 | #define ITEM_TYPE_MENUMODEL 		14	// special menu model
 16 | #define ITEM_TYPE_UPREDITFIELD		15	// editable text, associated with a cvar
 17 | 
 18 | #define ITEM_ALIGN_LEFT 		0	// left alignment
 19 | #define ITEM_ALIGN_CENTER		1	// center alignment
 20 | #define ITEM_ALIGN_RIGHT		2	// right alignment
 21 | #define ITEM_ALIGN_CENTER2		3	// center alignment
 22 | 
 23 | #define ITEM_TEXTSTYLE_NORMAL		0	// normal text
 24 | #define ITEM_TEXTSTYLE_BLINK		1	// fast blinking
 25 | #define ITEM_TEXTSTYLE_PULSE		2	// slow pulsing
 26 | #define ITEM_TEXTSTYLE_SHADOWED 	3	// drop shadow ( need a color for this )
 27 | #define ITEM_TEXTSTYLE_OUTLINED 	4	// drop shadow ( need a color for this )
 28 | #define ITEM_TEXTSTYLE_OUTLINESHADOWED	5	// drop shadow ( need a color for this )
 29 | #define ITEM_TEXTSTYLE_SHADOWEDMORE 	6	// drop shadow ( need a color for this )
 30 | 						  
 31 | #define WINDOW_BORDER_NONE		0	// no border
 32 | #define WINDOW_BORDER_FULL		1	// full border based on border color ( single pixel )
 33 | #define WINDOW_BORDER_HORZ		2	// horizontal borders only
 34 | #define WINDOW_BORDER_VERT		3	// vertical borders only 
 35 | #define WINDOW_BORDER_KCGRADIENT	4	// horizontal border using the gradient bars
 36 |   
 37 | #define WINDOW_STYLE_EMPTY		0	// no background
 38 | #define WINDOW_STYLE_FILLED 		1	// filled with background color
 39 | #define WINDOW_STYLE_GRADIENT		2	// gradient bar based on background color 
 40 | #define WINDOW_STYLE_SHADER 		3	// gradient bar based on background color 
 41 | #define WINDOW_STYLE_TEAMCOLOR		4	// team color
 42 | #define WINDOW_STYLE_CINEMATIC		5	// cinematic
 43 | #define WINDOW_STYLE_CVAR_SHADER	6	// draws the shader specified by the cvar
 44 | 
 45 | #define MENU_TRUE			1	// uh.. true
 46 | #define MENU_FALSE			0	// and false
 47 | 
 48 | #define HUD_VERTICAL			0x00
 49 | #define HUD_HORIZONTAL			0x01
 50 | 
 51 | #define RANGETYPE_ABSOLUTE		0
 52 | #define RANGETYPE_RELATIVE		1
 53 | 
 54 | // list box element types
 55 | #define LISTBOX_TEXT			0x00
 56 | #define LISTBOX_IMAGE			0x01
 57 | 
 58 | // list feeders
 59 | #define FEEDER_HEADS			0x00	// model heads
 60 | #define FEEDER_MAPS 			0x01	// text maps based on game type
 61 | #define FEEDER_SERVERS			0x02	// servers
 62 | #define FEEDER_CLANS			0x03	// clan names
 63 | #define FEEDER_ALLMAPS			0x04	// all maps available, in graphic format
 64 | #define FEEDER_REDTEAM_LIST 		0x05	// red team members
 65 | #define FEEDER_BLUETEAM_LIST		0x06	// blue team members
 66 | #define FEEDER_PLAYER_LIST		0x07	// players
 67 | #define FEEDER_TEAM_LIST		0x08	// team members for team voting
 68 | #define FEEDER_MODS 			0x09	// team members for team voting
 69 | #define FEEDER_DEMOS			0x0a	// team members for team voting
 70 | #define FEEDER_SCOREBOARD		0x0b	// team members for team voting
 71 | #define FEEDER_SERVERSTATUS 		0x0d	// server status
 72 | #define FEEDER_FINDPLAYER		0x0e	// find player
 73 | #define FEEDER_CINEMATICS		0x0f	// cinematics
 74 | 
 75 | // display flags
 76 | #define CG_SHOW_BLUE_TEAM_HAS_REDFLAG	0x00000001
 77 | #define CG_SHOW_RED_TEAM_HAS_BLUEFLAG	0x00000002
 78 | #define CG_SHOW_ANYTEAMGAME 		0x00000004
 79 | #define CG_SHOW_CTF 			0x00000020
 80 | #define CG_SHOW_HEALTHCRITICAL		0x00000080
 81 | #define CG_SHOW_SINGLEPLAYER		0x00000100
 82 | #define CG_SHOW_TOURNAMENT		0x00000200
 83 | #define CG_SHOW_DURINGINCOMINGVOICE 	0x00000400
 84 | #define CG_SHOW_IF_PLAYER_HAS_FLAG	0x00000800
 85 | #define CG_SHOW_LANPLAYONLY 		0x00001000
 86 | #define CG_SHOW_MINED			0x00002000
 87 | #define CG_SHOW_HEALTHOK		0x00004000
 88 | #define CG_SHOW_TEAMINFO		0x00008000
 89 | #define CG_SHOW_NOTEAMINFO		0x00010000
 90 | #define CG_SHOW_OTHERTEAMHASFLAG	0x00020000
 91 | #define CG_SHOW_YOURTEAMHASENEMYFLAG	0x00040000
 92 | #define CG_SHOW_ANYNONTEAMGAME		0x00080000
 93 | //(SA)
 94 | #define CG_SHOW_TEXTASINT		0x00200000
 95 | #define CG_SHOW_HIGHLIGHTED		0x00100000
 96 | 
 97 | #define CG_SHOW_NOT_V_CLEAR		0x02000000	//----(SA)	added	// hide on normal, full-view huds
 98 | 
 99 | #define CG_SHOW_2DONLY			0x10000000
100 | 
101 | 
102 | #define UI_SHOW_LEADER			0x00000001
103 | #define UI_SHOW_NOTLEADER		0x00000002
104 | #define UI_SHOW_FAVORITESERVERS 	0x00000004
105 | #define UI_SHOW_ANYNONTEAMGAME		0x00000008
106 | #define UI_SHOW_ANYTEAMGAME 		0x00000010
107 | #define UI_SHOW_NEWHIGHSCORE		0x00000020
108 | #define UI_SHOW_DEMOAVAILABLE		0x00000040
109 | #define UI_SHOW_NEWBESTTIME 		0x00000080
110 | #define UI_SHOW_FFA 			0x00000100
111 | #define UI_SHOW_NOTFFA			0x00000200
112 | #define UI_SHOW_NETANYNONTEAMGAME	0x00000400
113 | #define UI_SHOW_NETANYTEAMGAME		0x00000800
114 | #define UI_SHOW_NOTFAVORITESERVERS	0x00001000
115 | 
116 | 
117 | 
118 | // owner draw types
119 | // ideally these should be done outside of this file but
120 | // this makes it much easier for the macro expansion to 
121 | // convert them for the designers ( from the .menu files )
122 | #define CG_OWNERDRAW_BASE		1
123 | #define CG_PLAYER_HEAD			3
124 | #define CG_PLAYER_HEALTH		4
125 | #define CG_PLAYER_AMMO_VALUE		5
126 | #define CG_PLAYER_AMMO_BACKDROP		6
127 | #define CG_SELECTEDPLAYER_NAME		8
128 | #define CG_SELECTEDPLAYER_LOCATION	9
129 | #define CG_SELECTEDPLAYER_STATUS	10
130 | #define CG_SELECTEDPLAYER_WEAPON	11
131 | #define CG_SELECTEDPLAYER_POWERUP	12
132 | 
133 | #define CG_FLAGCARRIER_NAME 		14
134 | #define CG_FLAGCARRIER_LOCATION 	15
135 | #define CG_FLAGCARRIER_STATUS		16
136 | #define CG_FLAGCARRIER_WEAPON		17
137 | #define CG_FLAGCARRIER_POWERUP		18
138 | 
139 | #define CG_PLAYER_ITEM			19
140 | #define CG_PLAYER_STANCE		20
141 | #define CG_PLAYER_SCORE 		21
142 | 
143 | #define CG_BLUE_FLAGSTATUS		22
144 | #define CG_BLUE_FLAGNAME		23
145 | #define CG_RED_FLAGSTATUS		25
146 | #define CG_RED_FLAGNAME 		26
147 | 
148 | #define CG_BLUE_SCORE			27
149 | #define CG_RED_SCORE			28
150 | #define CG_RED_NAME 			29
151 | #define CG_BLUE_NAME			30
152 | #define CG_PLAYER_LOCATION		33
153 | #define CG_TEAM_COLOR			34
154 | #define CG_CTF_POWERUP			35
155 | 										
156 | #define CG_AREA_POWERUP 		36
157 | #define CG_AREA_LAGOMETER		37	// painted with old system
158 | #define CG_PLAYER_HASFLAG		38			  
159 | #define CG_GAME_TYPE			39	// not done
160 | 
161 | #define CG_SELECTEDPLAYER_HEALTH	41
162 | #define CG_PLAYER_STATUS		42
163 | #define CG_FRAGGED_MSG			43	// painted with old system
164 | #define CG_AREA_FPSINFO 		45	// painted with old system
165 | #define CG_AREA_SYSTEMCHAT		46	// painted with old system
166 | #define CG_AREA_TEAMCHAT		47	// painted with old system
167 | #define CG_AREA_CHAT			48	// painted with old system
168 | #define CG_GAME_STATUS			49
169 | #define CG_KILLER			50
170 | #define CG_ACCURACY 			53
171 | #define CG_ASSISTS			54
172 | #define CG_DEFEND			55
173 | #define CG_EXCELLENT			56
174 | #define CG_IMPRESSIVE			57
175 | #define CG_PERFECT			58
176 | #define CG_GAUNTLET 			59
177 | #define CG_SPECTATORS			60
178 | #define CG_TEAMINFO 			61
179 | #define CG_VOICE_HEAD			62
180 | #define CG_VOICE_NAME			63
181 | #define CG_CAPFRAGLIMIT 		66	 
182 | #define CG_1STPLACE 			67
183 | #define CG_2NDPLACE 			68
184 | #define CG_CAPTURES 			69
185 | 
186 | // (SA) adding
187 | #define CG_PLAYER_AMMOCLIP_VALUE	70	
188 | #define CG_CURSORHINT			72
189 | #define CG_PLAYER_POWERUP		75
190 | #define CG_PLAYER_HOLDABLE		76
191 | #define CG_PLAYER_INVENTORY		77
192 | #define CG_AREA_WEAPON			78	// draw weapons here
193 | #define CG_AREA_HOLDABLE		79	
194 | #define CG_CURSORHINT_STATUS	80
195 | 
196 | #define CG_PLAYER_WEAPON_NAME		81
197 | #define CG_PLAYER_WEAPON_NAME_BACK	82
198 | #define CG_PLAYER_WEAPON_MODE_ICON	83
199 | 
200 | #define CG_PLAYER_COMPASS			84
201 | #define CG_PLAYER_COMPASS_BACK		85
202 | #define CG_PLAYER_COMPASS_POINTERS	86
203 | #define CG_PLAYER_COMPASS_FRIENDS	88
204 | 
205 | #define CG_PLAYER_BAR_HEALTH		89
206 | #define CG_PLAYER_BAR_HEALTH_TITLE	90
207 | 
208 | #define CG_DRAW_SHADER				91
209 | 
210 | #define UI_OWNERDRAW_BASE		200
211 | #define UI_HANDICAP 			200
212 | #define UI_GAMETYPE 			205
213 | #define UI_MAPPREVIEW			206
214 | #define UI_NETSOURCE			220
215 | #define UI_NETMAPPREVIEW		221
216 | #define UI_NETFILTER			222
217 | #define UI_VOTE_KICK			238
218 | #define UI_MAPCINEMATIC 		244
219 | #define UI_NETGAMETYPE			245
220 | #define UI_NETMAPCINEMATIC		246
221 | #define UI_SERVERREFRESHDATE		247
222 | #define UI_SERVERMOTD			248
223 | #define UI_GLINFO			249
224 | #define UI_KEYBINDSTATUS		250
225 | #define UI_JOINGAMETYPE 		253
226 | #define UI_PREVIEWCINEMATIC 		254
227 | #define UI_STARTMAPCINEMATIC		255
228 | 
229 | //----(SA)	added
230 | #define UI_MENUMODEL			257
231 | //----(SA)	end
232 | 
233 | #define VOICECHAT_GETFLAG		"getflag"		// command someone to get the flag
234 | #define VOICECHAT_OFFENSE		"offense"		// command someone to go on offense
235 | #define VOICECHAT_DEFEND		"defend"		// command someone to go on defense
236 | #define VOICECHAT_DEFENDFLAG		"defendflag"		// command someone to defend the flag
237 | #define VOICECHAT_PATROL		"patrol"		// command someone to go on patrol (roam)
238 | #define VOICECHAT_CAMP			"camp"			// command someone to camp (we don't have sounds for this one)
239 | #define VOICECHAT_FOLLOWME		"followme"		// command someone to follow you
240 | #define VOICECHAT_RETURNFLAG		"returnflag"		// command someone to return our flag
241 | #define VOICECHAT_FOLLOWFLAGCARRIER	"followflagcarrier" 	// command someone to follow the flag carrier
242 | #define VOICECHAT_YES			"yes"			// yes, affirmative, etc.
243 | #define VOICECHAT_NO			"no"			// no, negative, etc.
244 | #define VOICECHAT_ONGETFLAG 		"ongetflag" 		// I'm getting the flag
245 | #define VOICECHAT_ONOFFENSE 		"onoffense" 		// I'm on offense
246 | #define VOICECHAT_ONDEFENSE 		"ondefense" 		// I'm on defense
247 | #define VOICECHAT_ONPATROL		"onpatrol"		// I'm on patrol (roaming)
248 | #define VOICECHAT_ONCAMPING 		"oncamp"		// I'm camping somewhere
249 | #define VOICECHAT_ONFOLLOW		"onfollow"		// I'm following
250 | #define VOICECHAT_ONFOLLOWCARRIER	"onfollowcarrier"	// I'm following the flag carrier
251 | #define VOICECHAT_ONRETURNFLAG		"onreturnflag"		// I'm returning our flag
252 | #define VOICECHAT_INPOSITION		"inposition"		// I'm in position
253 | #define VOICECHAT_IHAVEFLAG 		"ihaveflag" 		// I have the flag
254 | #define VOICECHAT_BASEATTACK		"baseattack"		// the base is under attack
255 | #define VOICECHAT_ENEMYHASFLAG		"enemyhasflag"		// the enemy has our flag (CTF)
256 | #define VOICECHAT_STARTLEADER		"startleader"		// I'm the leader
257 | #define VOICECHAT_STOPLEADER		"stopleader"		// I resign leadership
258 | #define VOICECHAT_WHOISLEADER		"whoisleader"		// who is the team leader
259 | #define VOICECHAT_WANTONDEFENSE 	"wantondefense" 	// I want to be on defense
260 | #define VOICECHAT_WANTONOFFENSE 	"wantonoffense" 	// I want to be on offense
261 | #define VOICECHAT_KILLINSULT		"kill_insult"		// I just killed you
262 | #define VOICECHAT_TAUNT 		"taunt" 		// I want to taunt you
263 | #define VOICECHAT_DEATHINSULT		"death_insult"		// you just killed me
264 | #define VOICECHAT_KILLGAUNTLET		"kill_gauntlet" 	// I just killed you with the gauntlet
265 | #define VOICECHAT_PRAISE		"praise"		// you did something good
266 | 
267 | #define UI_FONT_DEFAULT			0
268 | #define UI_FONT_NORMAL			1
269 | #define UI_FONT_BIG			2
270 | #define UI_FONT_SMALL			3
271 | #define UI_FONT_BOLD			4
272 | #define UI_FONT_CONSOLE			5
273 | 
274 | #define WEAPON_NAME_OFS			28	// This defined the amount of space to leave for the weapon mode icon
275 | #define WEAPON_NAME_EDGE_SPACE		8	// space to leave on the left side of the weapon name
276 | 
277 | // size defines for the hud compass
278 | // These are used for both the dynamic & non-dynamic compass drawing
279 | // If these are changed, the cgame should be recompiled
280 | //#define COMPASS_X			6
281 | //#define COMPASS_Y			367
282 | //#define COMPASS_SIZE			106
283 | 
284 | //#define COMPASS_HEALTH_OFF		25
285 | //#define COMPASS_HEALTH_SIZE		56
286 | 
287 | //#define COMPASS_NEEDLE_XOFF		46
288 | //#define COMPASS_NEEDLE_YOFF		29
289 | //#define COMPASS_NEEDLE_WIDTH		14
290 | //#define COMPASS_NEEDLE_HEIGHT		28
291 | 
292 | //#define COMPASS_POINTER_RADIUS	50
293 | //#define COMPASS_POINTER_WIDTH		8
294 | //#define COMPASS_POINTER_HEIGHT	16
295 | 
296 | #define PRONE_BLOCK_X 320
297 | #define PRONE_BLOCK_Y 270
298 | 
299 | #define COMPASS_X			-25	// -40
300 | #define COMPASS_Y			345	// 552
301 | #define COMPASS_SIZE			160	// 256
302 | 
303 | #define COMPASS_HEALTH_OFF		54.375	// 87
304 | #define COMPASS_HEALTH_SIZE		51.25	// 82
305 | 
306 | #define COMPASS_NEEDLE_XOFF		60	// 96
307 | #define COMPASS_NEEDLE_YOFF		50	// 80
308 | #define COMPASS_NEEDLE_WIDTH		40	// 64
309 | #define COMPASS_NEEDLE_HEIGHT		40	// 64
310 | 
311 | #define COMPASS_POINTER_RADIUS		43.75	// 70
312 | #define COMPASS_POINTER_WIDTH		20	// 32
313 | #define COMPASS_POINTER_HEIGHT		20	// 32
314 | 
315 | #define COMPASS_FRIENDLY_WIDTH		10	// 16
316 | #define COMPASS_FRIENDLY_HEIGHT		10	// 16
317 | 
318 | #define OPTIONS_CONTROL_SIZE		350 12
319 | //#define OPTIONS_WINDOW		10 75 360 325
320 | #define OPTIONS_WINDOW_POS		5 75
321 | #define	OPTIONS_WINDOW_SIZE		360 325
322 | #define	OPTIONS_WINDOW_BACKCOLOR	0 0 0 .7
323 | #define OPTIONS_CONTROL_XALIGN		165
324 | #define OPTIONS_CONTROL_YALIGN		11
325 | #define OPTIONS_CONTROL_TXTSCALE	.225
326 | #define OPTIONS_CONTROL_BACKCOLOR	0	0	.25	.3
327 | #define OPTIONS_CONTROL_FORECOLOR	.9 .9 .9 1
328 | 
329 | //menu backgrounds, 1024x768 image split to 1024x512 & 1024x256 images
330 | #define UI_MAIN_BACKGROUND_TOP		main_back_top
331 | #define UI_MAIN_BACKGROUND_BOTTOM	main_back_bottom
332 | 
333 | #define UI_BUTTON_STYLE				1
334 | //#define UI_BUTTON_BACK_COLOR		.84 .82 .45 .8
335 | //#define UI_BUTTON_BACK_COLOR		.26 .3 .28 .8
336 | #define UI_BUTTON_BACK_COLOR		.1747 .1903 .2335 .8
337 | #define UI_BUTTON_BACK_COLOR_HOVER	.50 .45 0 .8
338 | #define UI_BUTTON_BORDER			1
339 | //#define UI_BUTTON_BORDER_COLOR		.64 .92 .48 .2
340 | #define UI_BUTTON_BORDER_COLOR		0 0 0 .4
341 | #define UI_BUTTON_TEXT_COLOR		.9 .9 .95 1
342 | #define UI_BUTTON_TEXT_STYLE		3
343 | 
344 | //#define UI_FOCUS_COLOR				1 .75 0 1
345 | #define UI_FOCUS_COLOR				.98 .96 .39 1


--------------------------------------------------------------------------------
/mss32.VC.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xtnded/codextended-client/45af251518a390ab08b1c8713a6a1544b70114a1/mss32.VC.db


--------------------------------------------------------------------------------
/mss32.filters:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup>
  4 |     <Filter Include="Source Files">
  5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
  6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
  7 |     </Filter>
  8 |     <Filter Include="Header Files">
  9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
 10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
 11 |     </Filter>
 12 |     <Filter Include="Resource Files">
 13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
 14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
 15 |     </Filter>
 16 |     <Filter Include="NewFilter1">
 17 |       <UniqueIdentifier>{2ed725c6-0bd8-442c-a9de-8991ebc960d0}</UniqueIdentifier>
 18 |     </Filter>
 19 |     <Filter Include="Awesomium">
 20 |       <UniqueIdentifier>{7ccb67cd-aabf-4a34-8fe5-26d64f757df6}</UniqueIdentifier>
 21 |     </Filter>
 22 |     <Filter Include="steam_rename_mod_lib">
 23 |       <UniqueIdentifier>{a5ec0fb3-fe62-4286-9050-a94f9aa825ab}</UniqueIdentifier>
 24 |     </Filter>
 25 |   </ItemGroup>
 26 |   <ItemGroup>
 27 |     <Text Include="ReadMe.txt" />
 28 |   </ItemGroup>
 29 |   <ItemGroup>
 30 |     <ClInclude Include="stdafx.h">
 31 |       <Filter>Header Files</Filter>
 32 |     </ClInclude>
 33 |     <ClInclude Include="version_info.h">
 34 |       <Filter>Header Files</Filter>
 35 |     </ClInclude>
 36 |     <ClInclude Include="version.h">
 37 |       <Filter>Header Files</Filter>
 38 |     </ClInclude>
 39 |     <ClInclude Include="mem_util.h">
 40 |       <Filter>Header Files</Filter>
 41 |     </ClInclude>
 42 |     <ClInclude Include="common.h">
 43 |       <Filter>Header Files</Filter>
 44 |     </ClInclude>
 45 |     <ClInclude Include="shared.h">
 46 |       <Filter>Header Files</Filter>
 47 |     </ClInclude>
 48 |     <ClInclude Include="resource.h">
 49 |       <Filter>Header Files</Filter>
 50 |     </ClInclude>
 51 |     <ClInclude Include="hdd_serial_number.h">
 52 |       <Filter>Header Files</Filter>
 53 |     </ClInclude>
 54 |     <ClInclude Include="steam.h">
 55 |       <Filter>Header Files</Filter>
 56 |     </ClInclude>
 57 |     <ClInclude Include="client.h">
 58 |       <Filter>Header Files</Filter>
 59 |     </ClInclude>
 60 |     <ClInclude Include="render.h">
 61 |       <Filter>Header Files</Filter>
 62 |     </ClInclude>
 63 |     <ClInclude Include="detours.h">
 64 |       <Filter>Header Files</Filter>
 65 |     </ClInclude>
 66 |     <ClInclude Include="script.h">
 67 |       <Filter>Header Files</Filter>
 68 |     </ClInclude>
 69 |     <ClInclude Include="dl_public.h">
 70 |       <Filter>Header Files</Filter>
 71 |     </ClInclude>
 72 |     <ClInclude Include="keycodes.h">
 73 |       <Filter>Header Files</Filter>
 74 |     </ClInclude>
 75 |     <ClInclude Include="exmaster_client.h">
 76 |       <Filter>Header Files</Filter>
 77 |     </ClInclude>
 78 |     <ClInclude Include="keys.h">
 79 |       <Filter>Header Files</Filter>
 80 |     </ClInclude>
 81 |     <ClInclude Include="components\steam\ClientEngineMapper.h">
 82 |       <Filter>Header Files</Filter>
 83 |     </ClInclude>
 84 |     <ClInclude Include="components\steam\IClientEngine.h">
 85 |       <Filter>Header Files</Filter>
 86 |     </ClInclude>
 87 |     <ClInclude Include="components\steam\InterfaceMapper.h">
 88 |       <Filter>Header Files</Filter>
 89 |     </ClInclude>
 90 |     <ClInclude Include="components\steam\InterfaceMapperBase.h">
 91 |       <Filter>Header Files</Filter>
 92 |     </ClInclude>
 93 |     <ClInclude Include="components\steam\ISteamClient.h">
 94 |       <Filter>Header Files</Filter>
 95 |     </ClInclude>
 96 |     <ClInclude Include="components\steam\Local.h">
 97 |       <Filter>Header Files</Filter>
 98 |     </ClInclude>
 99 |     <ClInclude Include="components\steam\SafeClientEngine.h">
100 |       <Filter>Header Files</Filter>
101 |     </ClInclude>
102 |     <ClInclude Include="components\steam\StdInc.h">
103 |       <Filter>Header Files</Filter>
104 |     </ClInclude>
105 |     <ClInclude Include="components\steam\SteamComponent.h">
106 |       <Filter>Header Files</Filter>
107 |     </ClInclude>
108 |     <ClInclude Include="components\steam\SteamComponentAPI.h">
109 |       <Filter>Header Files</Filter>
110 |     </ClInclude>
111 |     <ClInclude Include="components\steam\SteamLoader.h">
112 |       <Filter>Header Files</Filter>
113 |     </ClInclude>
114 |     <ClInclude Include="components\steam\libudis86\extern.h">
115 |       <Filter>Header Files</Filter>
116 |     </ClInclude>
117 |     <ClInclude Include="components\steam\libudis86\itab.h">
118 |       <Filter>Header Files</Filter>
119 |     </ClInclude>
120 |     <ClInclude Include="components\steam\libudis86\types.h">
121 |       <Filter>Header Files</Filter>
122 |     </ClInclude>
123 |     <ClInclude Include="components\steam\libudis86\decode.h">
124 |       <Filter>NewFilter1</Filter>
125 |     </ClInclude>
126 |     <ClInclude Include="components\steam\libudis86\syn.h">
127 |       <Filter>NewFilter1</Filter>
128 |     </ClInclude>
129 |     <ClInclude Include="components\steam\libudis86\udint.h">
130 |       <Filter>NewFilter1</Filter>
131 |     </ClInclude>
132 |     <ClInclude Include="texturebuffers.h">
133 |       <Filter>Header Files</Filter>
134 |     </ClInclude>
135 |     <ClInclude Include="xui.h">
136 |       <Filter>Header Files</Filter>
137 |     </ClInclude>
138 |     <ClInclude Include="stockmapinfo.h">
139 |       <Filter>Header Files</Filter>
140 |     </ClInclude>
141 |     <ClInclude Include="Browser\glext.h">
142 |       <Filter>Awesomium</Filter>
143 |     </ClInclude>
144 |     <ClInclude Include="Browser\Browser.h">
145 |       <Filter>Awesomium</Filter>
146 |     </ClInclude>
147 |     <ClInclude Include="Browser\method_dispatcher.h">
148 |       <Filter>Awesomium</Filter>
149 |     </ClInclude>
150 |     <ClInclude Include="Browser\js_delegate.h">
151 |       <Filter>Awesomium</Filter>
152 |     </ClInclude>
153 |     <ClInclude Include="bitstream.h">
154 |       <Filter>Header Files</Filter>
155 |     </ClInclude>
156 |   </ItemGroup>
157 |   <ItemGroup>
158 |     <ClCompile Include="dllmain.cpp">
159 |       <Filter>Source Files</Filter>
160 |     </ClCompile>
161 |     <ClCompile Include="codextended.cpp">
162 |       <Filter>Source Files</Filter>
163 |     </ClCompile>
164 |     <ClCompile Include="hook.cpp">
165 |       <Filter>Source Files</Filter>
166 |     </ClCompile>
167 |     <ClCompile Include="common.cpp">
168 |       <Filter>Source Files</Filter>
169 |     </ClCompile>
170 |     <ClCompile Include="win_main.cpp">
171 |       <Filter>Source Files</Filter>
172 |     </ClCompile>
173 |     <ClCompile Include="win_authority.cpp">
174 |       <Filter>Source Files</Filter>
175 |     </ClCompile>
176 |     <ClCompile Include="console.cpp">
177 |       <Filter>Source Files</Filter>
178 |     </ClCompile>
179 |     <ClCompile Include="cvar.cpp">
180 |       <Filter>Source Files</Filter>
181 |     </ClCompile>
182 |     <ClCompile Include="cl_main.cpp">
183 |       <Filter>Source Files</Filter>
184 |     </ClCompile>
185 |     <ClCompile Include="fixes.cpp">
186 |       <Filter>Source Files</Filter>
187 |     </ClCompile>
188 |     <ClCompile Include="shared.cpp">
189 |       <Filter>Source Files</Filter>
190 |     </ClCompile>
191 |     <ClCompile Include="serverlist_info.cpp">
192 |       <Filter>Source Files</Filter>
193 |     </ClCompile>
194 |     <ClCompile Include="xuid.cpp">
195 |       <Filter>Source Files</Filter>
196 |     </ClCompile>
197 |     <ClCompile Include="librarymodule.cpp">
198 |       <Filter>Source Files</Filter>
199 |     </ClCompile>
200 |     <ClCompile Include="steam.cpp">
201 |       <Filter>Source Files</Filter>
202 |     </ClCompile>
203 |     <ClCompile Include="render.cpp">
204 |       <Filter>Source Files</Filter>
205 |     </ClCompile>
206 |     <ClCompile Include="stdafx.cpp">
207 |       <Filter>Source Files</Filter>
208 |     </ClCompile>
209 |     <ClCompile Include="mss32.cpp">
210 |       <Filter>Source Files</Filter>
211 |     </ClCompile>
212 |     <ClCompile Include="cgame.cpp">
213 |       <Filter>Source Files</Filter>
214 |     </ClCompile>
215 |     <ClCompile Include="game.cpp">
216 |       <Filter>Source Files</Filter>
217 |     </ClCompile>
218 |     <ClCompile Include="crypt.cpp">
219 |       <Filter>Source Files</Filter>
220 |     </ClCompile>
221 |     <ClCompile Include="script.cpp">
222 |       <Filter>Source Files</Filter>
223 |     </ClCompile>
224 |     <ClCompile Include="scr_mysql.cpp">
225 |       <Filter>Source Files</Filter>
226 |     </ClCompile>
227 |     <ClCompile Include="net.cpp">
228 |       <Filter>Source Files</Filter>
229 |     </ClCompile>
230 |     <ClCompile Include="dl_main.cpp">
231 |       <Filter>Source Files</Filter>
232 |     </ClCompile>
233 |     <ClCompile Include="files.cpp">
234 |       <Filter>Source Files</Filter>
235 |     </ClCompile>
236 |     <ClCompile Include="cl_chat.cpp">
237 |       <Filter>Source Files</Filter>
238 |     </ClCompile>
239 |     <ClCompile Include="ui.cpp">
240 |       <Filter>Source Files</Filter>
241 |     </ClCompile>
242 |     <ClCompile Include="cl_input.cpp">
243 |       <Filter>Source Files</Filter>
244 |     </ClCompile>
245 |     <ClCompile Include="exmaster_client.cpp">
246 |       <Filter>Source Files</Filter>
247 |     </ClCompile>
248 |     <ClCompile Include="components\steam\libudis86\decode.c">
249 |       <Filter>NewFilter1</Filter>
250 |     </ClCompile>
251 |     <ClCompile Include="components\steam\libudis86\itab.c">
252 |       <Filter>NewFilter1</Filter>
253 |     </ClCompile>
254 |     <ClCompile Include="components\steam\libudis86\syn.c">
255 |       <Filter>NewFilter1</Filter>
256 |     </ClCompile>
257 |     <ClCompile Include="components\steam\libudis86\syn-att.c">
258 |       <Filter>NewFilter1</Filter>
259 |     </ClCompile>
260 |     <ClCompile Include="components\steam\libudis86\syn-intel.c">
261 |       <Filter>NewFilter1</Filter>
262 |     </ClCompile>
263 |     <ClCompile Include="components\steam\libudis86\udis86.c">
264 |       <Filter>NewFilter1</Filter>
265 |     </ClCompile>
266 |     <ClCompile Include="xtexture.cpp">
267 |       <Filter>Source Files</Filter>
268 |     </ClCompile>
269 |     <ClCompile Include="xuidtool.cpp">
270 |       <Filter>Source Files</Filter>
271 |     </ClCompile>
272 |     <ClCompile Include="xui.cpp">
273 |       <Filter>Source Files</Filter>
274 |     </ClCompile>
275 |     <ClCompile Include="components\steam\SteamLoader.cpp">
276 |       <Filter>steam_rename_mod_lib</Filter>
277 |     </ClCompile>
278 |     <ClCompile Include="components\steam\SteamComponent.cpp">
279 |       <Filter>steam_rename_mod_lib</Filter>
280 |     </ClCompile>
281 |     <ClCompile Include="components\steam\SafeClientEngine.cpp">
282 |       <Filter>steam_rename_mod_lib</Filter>
283 |     </ClCompile>
284 |     <ClCompile Include="components\steam\InterfaceMapper.cpp">
285 |       <Filter>steam_rename_mod_lib</Filter>
286 |     </ClCompile>
287 |     <ClCompile Include="components\steam\ClientEngineMapper.cpp">
288 |       <Filter>steam_rename_mod_lib</Filter>
289 |     </ClCompile>
290 |     <ClCompile Include="xm_phandler.cpp">
291 |       <Filter>Source Files</Filter>
292 |     </ClCompile>
293 |   </ItemGroup>
294 |   <ItemGroup>
295 |     <ResourceCompile Include="mss32.rc">
296 |       <Filter>Resource Files</Filter>
297 |     </ResourceCompile>
298 |   </ItemGroup>
299 |   <ItemGroup>
300 |     <Image Include="cod.bmp">
301 |       <Filter>Resource Files</Filter>
302 |     </Image>
303 |   </ItemGroup>
304 |   <ItemGroup>
305 |     <Library Include="libs/detours/detours.lib" />
306 |     <Library Include="libs/libcurl/libcurl.lib" />
307 |     <Library Include="libs/discord/discord-rpc.lib" />
308 |   </ItemGroup>
309 | </Project>


--------------------------------------------------------------------------------
/mss32.rc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xtnded/codextended-client/45af251518a390ab08b1c8713a6a1544b70114a1/mss32.rc


--------------------------------------------------------------------------------
/mss32.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 14
 4 | VisualStudioVersion = 14.0.25420.1
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mss32", "mss32.vcxproj", "{E5E0EC0F-B28E-4899-A788-80430630F507}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x86 = Debug|x86
11 | 		Dev|x86 = Dev|x86
12 | 		EXE|x86 = EXE|x86
13 | 		Release|x86 = Release|x86
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{E5E0EC0F-B28E-4899-A788-80430630F507}.Debug|x86.ActiveCfg = Debug|Win32
17 | 		{E5E0EC0F-B28E-4899-A788-80430630F507}.Debug|x86.Build.0 = Debug|Win32
18 | 		{E5E0EC0F-B28E-4899-A788-80430630F507}.Dev|x86.ActiveCfg = Dev|Win32
19 | 		{E5E0EC0F-B28E-4899-A788-80430630F507}.Dev|x86.Build.0 = Dev|Win32
20 | 		{E5E0EC0F-B28E-4899-A788-80430630F507}.EXE|x86.ActiveCfg = EXE|Win32
21 | 		{E5E0EC0F-B28E-4899-A788-80430630F507}.EXE|x86.Build.0 = EXE|Win32
22 | 		{E5E0EC0F-B28E-4899-A788-80430630F507}.Release|x86.ActiveCfg = Release|Win32
23 | 		{E5E0EC0F-B28E-4899-A788-80430630F507}.Release|x86.Build.0 = Release|Win32
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | EndGlobal
29 | 


--------------------------------------------------------------------------------
/mss32.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup />
4 | </Project>


--------------------------------------------------------------------------------
/mss32.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup />
4 | </Project>


--------------------------------------------------------------------------------
/net.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #pragma comment(lib, "ws2_32.lib")
  3 | #include <WinSock2.h>
  4 | #include <wsipx.h>
  5 | #include "exmaster_client.h"
  6 | #include "client.h"
  7 | 
  8 | Sys_SendPacket_t Sys_SendPackett = (Sys_SendPacket_t)0x464AA0;
  9 | NET_SendPacket_t NET_SendPacket = (NET_SendPacket_t)0x4493E0;
 10 | 
 11 | NET_OutOfBandPrint_t NET_OutOfBandPrint = (NET_OutOfBandPrint_t)0x449490;
 12 | 
 13 | CL_Netchan_Encode_t CL_Netchan_Encode = (CL_Netchan_Encode_t)0x414710;
 14 | Netchan_Transmit_t Netchan_Transmit = (Netchan_Transmit_t)0x448B70;
 15 | Netchan_TransmitNextFragment_t Netchan_TransmitNextFragment = (Netchan_TransmitNextFragment_t)0x448980;
 16 | 
 17 | MSG_initHuffman_t MSG_initHuffman = (MSG_initHuffman_t)0x448390;
 18 | 
 19 | void MSG_Init(msg_t *buf, byte *data, int length) {
 20 | 	if (!*(int*)0x14073F0)
 21 | 		MSG_initHuffman();
 22 | 	memset(buf, 0, sizeof(*buf));
 23 | 	buf->data = data;
 24 | 	buf->maxsize = length;
 25 | }
 26 | 
 27 | #define DO( src,dest )	  \
 28 | 	copy[0] = s[src];	\
 29 | 	copy[1] = s[src + 1];	\
 30 | 	sscanf( copy, "%x", &val );	  \
 31 | 	( (struct sockaddr_ipx *)sadr )->dest = val
 32 | 
 33 | qboolean Sys_StringToSockaddr(const char *s, struct sockaddr *sadr) {
 34 | 	struct hostent  *h;
 35 | 	int val;
 36 | 	char copy[MAX_STRING_CHARS];
 37 | 
 38 | 	memset(sadr, 0, sizeof(*sadr));
 39 | 
 40 | 	// check for an IPX address
 41 | 	// rain - too easy to falsely match a real hostname
 42 | 	//	if( ( strlen( s ) == 21 ) && ( s[8] == '.' ) ) {
 43 | 	((struct sockaddr_in *)sadr)->sin_family = AF_INET;
 44 | 	((struct sockaddr_in *)sadr)->sin_port = 0;
 45 | 
 46 | 	if (s[0] >= '0' && s[0] <= '9') {
 47 | 		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(s);
 48 | 	}
 49 | 	else {
 50 | 		if ((h = gethostbyname(s)) == 0) {
 51 | 			return qfalse;
 52 | 		}
 53 | 		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0];
 54 | 	}
 55 | 
 56 | 	return qtrue;
 57 | }
 58 | 
 59 | #undef DO
 60 | 
 61 | 
 62 | void SockadrToNetadr(struct sockaddr *s, netadr_t *a) {
 63 | 	a->type = NA_IP;
 64 | 	*(int *)&a->ip = ((struct sockaddr_in *)s)->sin_addr.s_addr;
 65 | 	a->port = ((struct sockaddr_in *)s)->sin_port;
 66 | }
 67 | 
 68 | void NetadrToSockadr(netadr_t *a, struct sockaddr *s) {
 69 | 	memset(s, 0, sizeof(*s));
 70 | 
 71 | 	if (a->type == NA_BROADCAST) {
 72 | 		((struct sockaddr_in *)s)->sin_family = AF_INET;
 73 | 		((struct sockaddr_in *)s)->sin_port = a->port;
 74 | 		((struct sockaddr_in *)s)->sin_addr.s_addr = INADDR_BROADCAST;
 75 | 	}
 76 | 	else if (a->type == NA_IP)    {
 77 | 		((struct sockaddr_in *)s)->sin_family = AF_INET;
 78 | 		((struct sockaddr_in *)s)->sin_addr.s_addr = *(int *)&a->ip;
 79 | 		((struct sockaddr_in *)s)->sin_port = a->port;
 80 | 	}
 81 | }
 82 | 
 83 | qboolean Sys_StringToAdr(const char *s, netadr_t *a) {
 84 | 	struct sockaddr sadr;
 85 | 
 86 | 	if (!Sys_StringToSockaddr(s, &sadr)) {
 87 | 		return qfalse;
 88 | 	}
 89 | 
 90 | 	SockadrToNetadr(&sadr, a);
 91 | 	return qtrue;
 92 | }
 93 | 
 94 | //tmp relocation
 95 | short   BigShort(short l) {
 96 | 	byte b1, b2;
 97 | 
 98 | 	b1 = l & 255;
 99 | 	b2 = (l >> 8) & 255;
100 | 
101 | 	return (b1 << 8) + b2;
102 | }
103 | 
104 | qboolean    NET_StringToAdr(const char *s, netadr_t *a) {
105 | 	qboolean r;
106 | 	char base[MAX_STRING_CHARS];
107 | 	char    *port;
108 | 
109 | 	if (!strcmp(s, "localhost")) {
110 | 		memset(a, 0, sizeof(*a));
111 | 		a->type = NA_LOOPBACK;
112 | 		return qtrue;
113 | 	}
114 | 
115 | 	// look for a port number
116 | 	Q_strncpyz(base, s, sizeof(base));
117 | 	port = strstr(base, ":");
118 | 	if (port) {
119 | 		*port = 0;
120 | 		port++;
121 | 	}
122 | 
123 | 	r = Sys_StringToAdr(base, a);
124 | 
125 | 	if (!r) {
126 | 		a->type = NA_BAD;
127 | 		return qfalse;
128 | 	}
129 | 
130 | 	// inet_addr returns this if out of range
131 | 	if (a->ip[0] == 255 && a->ip[1] == 255 && a->ip[2] == 255 && a->ip[3] == 255) {
132 | 		a->type = NA_BAD;
133 | 		return qfalse;
134 | 	}
135 | 
136 | 	if (port) {
137 | 		a->port = BigShort((short)atoi(port));
138 | 	}
139 | 	else {
140 | 		a->port = BigShort(28960);
141 | 	}
142 | 
143 | 	return qtrue;
144 | }
145 | 
146 | const char  *NET_AdrToString(netadr_t a) {
147 | 	static  char    s[64];
148 | 
149 | 	if (a.type == NA_LOOPBACK) {
150 | 		Com_sprintf(s, sizeof(s), "loopback");
151 | 	}
152 | 	else if (a.type == NA_BOT) {
153 | 		Com_sprintf(s, sizeof(s), "bot");
154 | 	}
155 | 	else if (a.type == NA_IP) {
156 | 		Com_sprintf(s, sizeof(s), "%i.%i.%i.%i:%hu",
157 | 			a.ip[0], a.ip[1], a.ip[2], a.ip[3], BigShort(a.port));
158 | 	}
159 | 	else {
160 | 		Com_sprintf(s, sizeof(s), "%02x%02x%02x%02x.%02x%02x%02x%02x%02x%02x:%hu",
161 | 			a.ipx[0], a.ipx[1], a.ipx[2], a.ipx[3], a.ipx[4], a.ipx[5], a.ipx[6], a.ipx[7], a.ipx[8], a.ipx[9],
162 | 			BigShort(a.port));
163 | 	}
164 | 
165 | 	return s;
166 | }
167 | 
168 | const char  *NET_BaseAdrToString(netadr_t a) {
169 | 	static  char    s[64];
170 | 
171 | 	if (a.type == NA_LOOPBACK) {
172 | 		Com_sprintf(s, sizeof(s), "loopback");
173 | 	}
174 | 	else if (a.type == NA_BOT) {
175 | 		Com_sprintf(s, sizeof(s), "bot");
176 | 	}
177 | 	else if (a.type == NA_IP) {
178 | 		Com_sprintf(s, sizeof(s), "%i.%i.%i.%i",
179 | 			a.ip[0], a.ip[1], a.ip[2], a.ip[3]);
180 | 	}
181 | 	else {
182 | 		Com_sprintf(s, sizeof(s), "%02x%02x%02x%02x.%02x%02x%02x%02x%02x%02x",
183 | 			a.ipx[0], a.ipx[1], a.ipx[2], a.ipx[3], a.ipx[4], a.ipx[5], a.ipx[6], a.ipx[7], a.ipx[8], a.ipx[9]);
184 | 	}
185 | 
186 | 	return s;
187 | }
188 | 
189 | qboolean    NET_CompareAdr(netadr_t a, netadr_t b) {
190 | 	if (a.type != b.type) {
191 | 		return qfalse;
192 | 	}
193 | 
194 | 	if (a.type == NA_LOOPBACK) {
195 | 		return qtrue;
196 | 	}
197 | 
198 | 	if (a.type == NA_IP) {
199 | 		if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3] && a.port == b.port) {
200 | 			return qtrue;
201 | 		}
202 | 		return qfalse;
203 | 	}
204 | 
205 | 	if (a.type == NA_IPX) {
206 | 		if ((memcmp(a.ipx, b.ipx, 10) == 0) && a.port == b.port) {
207 | 			return qtrue;
208 | 		}
209 | 		return qfalse;
210 | 	}
211 | 
212 | 	Com_Printf("NET_CompareAdr: bad address type\n");
213 | 	return qfalse;
214 | }
215 | 
216 | 
217 | bool    NET_IsLocalAddress(netadr_t adr) {
218 | 	return adr.type == NA_LOOPBACK;
219 | }
220 | 
221 | 
222 | qboolean    NET_CompareBaseAdr(netadr_t a, netadr_t b) {
223 | 	if (a.type != b.type) {
224 | 		return qfalse;
225 | 	}
226 | 
227 | 	if (a.type == NA_LOOPBACK) {
228 | 		return qtrue;
229 | 	}
230 | 
231 | 	if (a.type == NA_IP) {
232 | 		if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3]) {
233 | 			return qtrue;
234 | 		}
235 | 		return qfalse;
236 | 	}
237 | 
238 | 	if (a.type == NA_IPX) {
239 | 		if ((memcmp(a.ipx, b.ipx, 10) == 0)) {
240 | 			return qtrue;
241 | 		}
242 | 		return qfalse;
243 | 	}
244 | 
245 | 
246 | 	Com_Printf("NET_CompareBaseAdr: bad address type\n");
247 | 	return qfalse;
248 | }
249 | 
250 | netadr_t ex_master;
251 | 
252 | bool ex_master_resolve() {
253 | 	static bool resolve_try = false;
254 | 	if (resolve_try)
255 | 		return true;
256 | 	if (!NET_StringToAdr(EX_MASTER_NAME, &ex_master)) {
257 | 		Com_Printf("^1Failed to resolve master '%s'\n", EX_MASTER_NAME);
258 | 		return false;
259 | 	}
260 | 	ex_master.port = BigShort(20511);
261 | 	resolve_try = true;
262 | 	return true;
263 | }
264 | 
265 | void Sys_SendPacket(int packet_size, void *packet, netadr_t to) {
266 | 	__asm {
267 | 		/*
268 | 		sub     esp, 14h
269 | 		.text:00449465                 mov     ecx, 5
270 | 		.text:0044946A                 lea     esi, [esp+20h+arg_4]
271 | 		.text:0044946E                 mov     edi, esp
272 | 		.text:00449470                 rep movsd
273 | 		.text:00449472                 mov     ecx, ebp        ; buf
274 | 		.text:00449474                 mov     edx, ebx        ; len
275 | 		.text:00449476                 call    Sys_SendPacket
276 | 		.text:0044947B                 add     esp, 14h
277 | 		*/
278 | 
279 | 		sub esp, 14h
280 | 		mov ecx, 5 // size of netadr_t is 20 / sizeof(32 bit register) = 5
281 | 		lea esi, [to]
282 | 		mov edi, esp
283 | 		rep movsd
284 | 		mov ecx, packet
285 | 		mov edx, packet_size
286 | 		call Sys_SendPackett
287 | 		add esp, 14h
288 | 	}
289 | }
290 | 
291 | bool enc_connected = false;
292 | #include "version_info.h"
293 | #define EXT_NET_VERSION BUILDNUMBER
294 | #define EXT_PACKET_TYPE 0xffff
295 | 
296 | typedef enum {
297 | 	ENC_NULL,
298 | 	ENC_VERIF,
299 | 	ENC_TALK,
300 | 	ENC_GET_KEY,
301 | 	ENC_SV_REQUEST_AUTH,
302 | 	ENC_HEARTBEAT,
303 | 	ENC_UPDATE_REQUEST,
304 | 
305 | 	ENC_BROADCAST,
306 | 	ENC_CLIENT_JOINED,
307 | 	ENC_CLIENT_DISCONNECTED,
308 | 	ENC_FRIEND_REQUEST,
309 | 	ENC_CLIENT_USERINFO_CHANGED,
310 | 	ENC_END
311 | } ext_net_cmd;
312 | 
313 | static char mUID[33] = { 0 };
314 | 
315 | static unsigned int ext_sv_enc_key = 0;
316 | static unsigned int ext_cl_enc_key = 0;
317 | 
318 | static char ext_sv_enc_key_buf[11]{0};
319 | static char ext_cl_enc_key_buf[11]{0};
320 | 
321 | static inline void xor_crypt(char *key, int key_len, char *buffer, int buf_len) {
322 | 	for (int i = 0; i < buf_len; i++)
323 | 		buffer[i] = buffer[i] ^ key[i % key_len];
324 | }
325 | 
326 | #define sPrintf Com_Printf
327 | 
328 | void Enc_SendTalkMessage(const char *chatmsg) {
329 | 
330 | 	rMSG msg;
331 | 	msg.AddInt(EXT_PACKET_TYPE);
332 | 	msg.AddByte(ENC_TALK);
333 | 	msg.AddString(chatmsg);
334 | 	msg.SendEnc(ex_master, ext_cl_enc_key_buf);
335 | }
336 | 
337 | void Enc_SendFriendRequest() {
338 | 	char *var = Cvar_VariableString("cm_pl_selectedid");
339 | 	unsigned id = atoll(var);
340 | 
341 | 	rMSG msg;
342 | 	msg.AddInt(EXT_PACKET_TYPE);
343 | 	msg.AddByte(ENC_FRIEND_REQUEST);
344 | 	msg.AddUInt(id);
345 | 	msg.SendEnc(ex_master, ext_cl_enc_key_buf);
346 | }
347 | 
348 | bool bEncConnected = false;
349 | 
350 | void Enc_SendUserInfo() {
351 | 	if (!bEncConnected)
352 | 		return;
353 | 
354 | 	rMSG reply;
355 | 	reply.AddInt(EXT_PACKET_TYPE);
356 | 	reply.AddByte(ENC_CLIENT_USERINFO_CHANGED);
357 | 
358 | 	char _cs[MAX_STRING_CHARS] = { 0 };
359 | 
360 | 	Info_SetValueForKey(_cs, "name", Cvar_VariableString("name"));
361 | 	Info_SetValueForKey(_cs, "message", "x");
362 | 	reply.AddString(_cs);
363 | 	reply.SendEnc(ex_master, ext_cl_enc_key_buf);
364 | }
365 | 
366 | void Enc_SendHeartbeat() {
367 | 	if (!bEncConnected)
368 | 		return;
369 | 
370 | 	extern cvar_t *clientname;
371 | 
372 | 	if (clientname->modified) {
373 | 		Enc_SendUserInfo();
374 | 		clientname->modified = qfalse;
375 | 		return;
376 | 	}
377 | 
378 | 	static time_t last = time(NULL);
379 | 
380 | 	time_t now = time(NULL);
381 | 	if (difftime(now, last) < 5) {
382 | 		return;
383 | 	}
384 | 	
385 | 	int connectedToServer = 0;
386 | 
387 | 	if (*cls_servername)
388 | 		connectedToServer = 1;
389 | 
390 | 	rMSG msg;
391 | 	msg.AddInt(EXT_PACKET_TYPE);
392 | 	msg.AddByte(ENC_HEARTBEAT);
393 | 	msg.AddUInt(EXT_NET_VERSION);
394 | 	msg.AddInt(connectedToServer);
395 | 	if (connectedToServer)
396 | 		msg.AddString(cls_servername);
397 | 	msg.SendEnc(ex_master, ext_cl_enc_key_buf);
398 | 	last = time(NULL);
399 | }
400 | 
401 | bool GetEncKey() {
402 | 	mClients.clear();
403 | 
404 | 	rMSG msg;
405 | 
406 | 	msg.AddInt(EXT_PACKET_TYPE);
407 | 	msg.AddByte(ENC_GET_KEY);
408 | 	msg.AddUInt(EXT_NET_VERSION);
409 | 	do {
410 | 		ext_cl_enc_key = ((rand() << 16) ^ rand()) ^ time(NULL);
411 | 	} while (!ext_cl_enc_key);
412 | 	Com_sprintf(ext_cl_enc_key_buf, sizeof(ext_cl_enc_key_buf), "%lu", ext_cl_enc_key);
413 | 	//sPrintf("cl enc key = %d\n", ext_cl_enc_key);
414 | 	msg.AddUInt(ext_cl_enc_key);
415 | 	msg.Send(ex_master);
416 | 
417 | 	return true;
418 | }
419 | 
420 | unsigned server_client_build = 0;
421 | 
422 | void ExtServer_Packet(netadr_t from, msg_t *mmsg) {
423 | 	void PH_Handle(netadr_t, char*, size_t);
424 | 	PH_Handle(from, (char*)mmsg->data, mmsg->cursize);
425 | 
426 | 	return; //remove this for original functionality
427 | 
428 | 	if (!NET_CompareBaseAdr(ex_master, from))
429 | 		return;
430 | }
431 | 
432 | void NET_Init() {
433 | 	void(*o)();
434 | 	*(int*)&o = 0x465940;
435 | 	o();
436 | 
437 | 	#if 0
438 | 	if (!ex_master_resolve())
439 | 		return;
440 | 	void PH_Init();
441 | 	PH_Init();
442 | 	#endif
443 | }
444 | 
445 | static FARPROC cl_packetevent_ptr = (FARPROC)0x410FF0;
446 | 
447 | int clpe_pt = 0;
448 | 
449 | void __declspec(naked) CL_PacketEvent() {
450 | 	__asm {
451 | 			mov eax, [ecx + 0Ch]
452 | 			cmp eax, 4
453 | 			jl reg_cont
454 | 			mov eax, [ecx + 4]
455 | 			push eax
456 | 			mov eax, [eax]
457 | 			mov clpe_pt, eax
458 | 			pop eax
459 | 	}
460 | 	if (clpe_pt != -2) //-2
461 | 		goto c_reg_cont;
462 | 			/*
463 | 			cmp dword ptr[eax], 0FFFF0000h
464 | 			jnz reg_cont
465 | 
466 | 			cmp dword ptr[eax], 0FFFFh
467 | 			jnz reg_cont
468 | 			*/
469 | 	__asm {
470 | 			push ecx
471 | 			sub esp, 14h
472 | 			mov ecx, 5
473 | 			//int 3
474 | 			lea esi, [esp + 01Ch]
475 | 			mov edi, esp
476 | 			rep movsd
477 | 			call ExtServer_Packet
478 | 			add esp, 18h
479 | 			retn
480 | 	}
481 | 	c_reg_cont:
482 | 	__asm {
483 | 		reg_cont :
484 | 			mov eax, 410FF0h
485 | 			jmp eax
486 | 	}
487 | }
488 | 
489 | int __stdcall xrecvfrom(SOCKET s, char *buf, int len, int flags, sockaddr *from, int *fromlen) {
490 | 	int __stdcall ret = recvfrom(s, buf, len, flags, from, fromlen);
491 | 	return ret;
492 | }
493 | 
494 | #define HTTP_PORT 80
495 | #define BUFFERSIZE 8196
496 | 
497 | bool download_file(std::string url, char* filename) {
498 | 	std::string request;
499 | 	char buffer[BUFFERSIZE];
500 | 	struct sockaddr_in serveraddr;
501 | 	int sock;
502 | 
503 | 	if (url.find("http://") != -1) {
504 | 		std::string temp = url;
505 | 		url = temp.substr(url.find("http://") + 7);
506 | 	}
507 | 
508 | 	int dm = url.find("/");
509 | 	std::string file = url.substr(dm);
510 | 	std::string shost = url.substr(0, dm);
511 | 
512 | 	request += "GET " + file + " HTTP/1.0\r\n";
513 | 	request += "Host: " + shost + "\r\n";
514 | 	request += "\r\n";
515 | 
516 | 	if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
517 | 		return FALSE;
518 | 
519 | 	memset(&serveraddr, 0, sizeof(serveraddr));
520 | 
521 | 	hostent *record = gethostbyname(shost.c_str());
522 | 	if (record == NULL)
523 | 		return FALSE;
524 | 	in_addr *address = (in_addr *)record->h_addr;
525 | 	std::string ipd = inet_ntoa(*address);
526 | 	const char *ipaddr = ipd.c_str();
527 | 
528 | 	serveraddr.sin_family = AF_INET;
529 | 	serveraddr.sin_addr.s_addr = inet_addr(ipaddr);
530 | 	serveraddr.sin_port = htons(HTTP_PORT);
531 | 
532 | 	if (connect(sock, (struct sockaddr *) &serveraddr, sizeof(serveraddr)) < 0)
533 | 		return FALSE;
534 | 
535 | 	if (send(sock, request.c_str(), request.length(), 0) != request.length())
536 | 		return FALSE;
537 | 
538 | 	int nRecv, npos;
539 | 	nRecv = recv(sock, (char*)&buffer, BUFFERSIZE, 0);
540 | 	std::string str_buff = buffer;
541 | 	npos = str_buff.find("\r\n\r\n");
542 | 
543 | 	HANDLE hFile;
544 | 	hFile = CreateFileA(filename, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
545 | 	SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
546 | 
547 | 	DWORD ss;
548 | 	while ((nRecv > 0) && (nRecv != INVALID_SOCKET)){
549 | 		if (npos > 0){
550 | 			char bf[BUFFERSIZE];
551 | 			// copy from end position of header //
552 | 			memcpy(bf, buffer + (npos + 4), nRecv - (npos + 4));
553 | 			WriteFile(hFile, bf, nRecv - (npos + 4), &ss, NULL);
554 | 		}
555 | 		else{
556 | 			// write normally if end not found //
557 | 			WriteFile(hFile, buffer, nRecv, &ss, NULL);
558 | 		}
559 | 
560 | 		// buffer cleanup  //
561 | 		ZeroMemory(&buffer, sizeof(buffer));
562 | 		nRecv = recv(sock, (char*)&buffer, BUFFERSIZE, 0);
563 | 		str_buff = buffer;
564 | 		npos = str_buff.find("\r\n\r\n");
565 | 	}
566 | 	CloseHandle(hFile);
567 | 	closesocket(sock);
568 | 	return TRUE;
569 | }


--------------------------------------------------------------------------------
/render.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #include "client.h"
  3 | #include "render.h"
  4 | 
  5 | RE_RegisterShaderNoMip_t RE_RegisterShaderNoMip = (RE_RegisterShaderNoMip_t)0x4FCAE0;
  6 | RE_RegisterShader_t RE_RegisterShader = (RE_RegisterShader_t)0x4FCA80;
  7 | R_FindShader_t R_FindShader = (R_FindShader_t)0x4FC5C0;
  8 | SCR_DrawPic_t SCR_DrawPic = (SCR_DrawPic_t)0x4168D0;
  9 | SCR_AdjustFrom640_t SCR_AdjustFrom640 = (SCR_AdjustFrom640_t)0x416810;
 10 | /*
 11 | SCR_DrawSmallStringExt_t SCR_DrawSmallStringExt = (SCR_DrawSmallStringExt_t)0x416A30;
 12 | SCR_DrawSmallChar_t SCR_DrawSmallChar = (SCR_DrawSmallChar_t)0x416980;
 13 | */
 14 | SCR_DrawString_t SCR_DrawString = (SCR_DrawString_t)0x4DF570;
 15 | RE_SetColor_t RE_SetColor = (RE_SetColor_t)0x4DDCF0;
 16 | RB_SetGL2D_t RB_SetGL2D = (RB_SetGL2D_t)0x4D6CB0;
 17 | 
 18 | /* FONTS */
 19 | 
 20 | //HDC hDC = (HDC)0x19BFFE4;
 21 | HWND hWnd = (HWND)0x8E5268;
 22 | HGLRC hGLRC = (HGLRC)0x19BFFE8;
 23 | 
 24 | 
 25 | //GLYPHMETRICSFLOAT gmf[256];
 26 | 
 27 | /* custom shader text adding - Richard */
 28 | 
 29 | char** s_shaderText = (char**)0x11EDD60;
 30 | 
 31 | #define GLOW_SHADER \
 32 | 	"glowshader2d                                        \n" \
 33 | "{                                                   \n" \
 34 | "	nopicmip                                         \n" \
 35 | "	nomipmaps                                        \n" \
 36 | "	{                                                \n" \
 37 | "		rgbgen const ( 0 1 .5 )                      \n" \
 38 | "		blendFunc add                                \n" \
 39 | "	}                                                \n" \
 40 | "	{                                                \n" \
 41 | "		map $whiteImage                              \n" \
 42 | "		rgbgen constLighting ( 0.8 0.632 0.252 )     \n" \
 43 | "		alphaGen wave sin -0.1 1.1 0 .5              \n" \
 44 | "		blendFunc GL_SRC_ALPHA GL_ONE                \n" \
 45 | "	}                                                \n" \
 46 | "}                                                   \n"
 47 | 
 48 | void ScanAndLoadShaderFiles(void) {
 49 | 	void(*o)(void) = (void(*)(void))0x4FD560;
 50 | 	o();
 51 | }
 52 | 
 53 | #define EMPTY_SHADER_TEMPLATE "%s\n{\n\t{\n\t\tmap $whiteimage\n\t}\n}\n"
 54 | 
 55 | void AddCustomShader() {
 56 | 	strcat(*s_shaderText, "\n" GLOW_SHADER);
 57 | }
 58 | 
 59 | void __declspec(naked) AddCustomShader_w() {
 60 | 	__asm
 61 | 	{
 62 | 		call AddCustomShader
 63 | 		mov eax, dword ptr[esp + 0x1c]
 64 | 		push eax
 65 | 		mov eax, 0x4FD73A
 66 | 		jmp eax
 67 | 	}
 68 | }
 69 | 
 70 | void* ri_Hunk_AllocAlign(int size) {
 71 | 	void* (*Hunk_AllocAlign)(int) = (void* (*)(int))0x432160;
 72 | 
 73 | 	int s = size + strlen(GLOW_SHADER) + 2;
 74 | 	return Hunk_AllocAlign(s);
 75 | }
 76 | 
 77 | /* 2d render stuff */
 78 | 
 79 | 
 80 | void InitRender() {
 81 | }
 82 | 
 83 | void DestroyRender() {
 84 | }
 85 | 
 86 | void RB_ShowImages() {
 87 | 	if (*cls_keyCatchers & KEYCATCH_CONSOLE) {
 88 | 
 89 | 	}
 90 | 	else {
 91 | 	}
 92 | }
 93 | 
 94 | /* Render stuff texture / geometry etc */
 95 | 
 96 | shader_t* lastShader;
 97 | extern cvar_t* cl_findshader;
 98 | 
 99 | bool hook_bind = false;
100 | 
101 | void GL_Bind() {
102 | 	/*image_t* image;
103 | 	*/
104 | 	int image;
105 | 	__asm mov image, esi
106 | 
107 | 	void(*call)();
108 | 	*(int*)&call = 0x4D5450;
109 | 	__asm mov esi, image
110 | 	call();
111 | }
112 | 
113 | void RB_EndSurface(void);
114 | cJMP endsurface(0x5027C0, (int)RB_EndSurface);
115 | void RB_EndSurface(void) {
116 | 	endsurface.Restore();
117 | 	void(*call)(void);
118 | 	*(int*)&call = endsurface.from;
119 | 
120 | 	call();
121 | 	endsurface.Apply();
122 | }
123 | //Causing freezing?
124 | //void __stdcall RB_BeginSurface() {
125 | //	shader_t* shader;
126 | //	__asm {
127 | //		mov shader, ecx
128 | //	}
129 | //	lastShader = shader;
130 | //
131 | //	if (strstr(lastShader->name, cl_findshader->string) != NULL) {
132 | //		hook_bind = true;
133 | //	}
134 | //
135 | //	void(__stdcall *call)();
136 | //	*(int*)&call = 0x4FF570;
137 | //	__asm {
138 | //		push 3
139 | //			mov ecx, shader
140 | //	}
141 | //	call();
142 | //}
143 | 
144 | static GLfloat rot = 0.0;
145 | static time_t rot_time = 0;
146 | 
147 | UINT32 pExecuteRenderCommands = 0x4D8AB0;
148 | 
149 | void __declspec(naked) RB_ExecuteRenderCommands() {
150 | 	__asm
151 | 	{
152 | 		call pExecuteRenderCommands
153 | 		//call ExtraRender
154 | 		ret
155 | 	}
156 | }
157 | 
158 | void DrawTris(void* input) {}
159 | 
160 | void R_Init(void) {
161 | 	void(*call)(void);
162 | 	*(int*)&call = 0x4B4590;
163 | 	call();
164 | 
165 | 	if (Cvar_VariableIntegerValue("r_borderless")) {
166 | 		int width, height;
167 | 		GetDesktopResolution(&width, &height);
168 | 		SetWindowLongA(*gameWindow, GWL_EXSTYLE, 0);
169 | 		SetWindowLongA(*gameWindow, GWL_STYLE, WS_VISIBLE | WS_POPUP);
170 | 		MoveWindow(*gameWindow, 0, 0, width, height, 0);
171 | 	}
172 | }
173 | 
174 | // New vid modes with videscreen support. Not yet finalized.
175 | /*
176 | vidmode_t r_vidModes[] =
177 | {
178 | 	{ "Mode  1: 640x480",	640,  480,  1 },
179 | 	{ "Mode  2: 720x480",	720,  480,  1 },
180 | 	{ "Mode  3: 800x600",	800,  600,  1 },
181 | 	{ "Mode  4: 852x480",	852,  480,  1 },
182 | 	{ "Mode  5: 1024x768",	1024, 768,  1 },
183 | 	{ "Mode  6: 1152x864",	1152, 864,  1 },
184 | 	{ "Mode  7: 1280x720",	1280, 720,  1 },
185 | 	{ "Mode  8: 1280x960",	1280, 960,  1 },
186 | 	{ "Mode  9: 1280x1024", 1280, 1024, 1 },
187 | 	{ "Mode  9: 1366x768",  1280, 1024, 1 },
188 | 	{ "Mode 11: 1440x900",	1440, 900,  1 },
189 | 	{ "Mode 12: 1600x900",	1600, 900,  1 },
190 | 	{ "Mode 13: 1600x1200", 1600, 1200, 1 },
191 | 	{ "Mode 14: 1680x1050", 1680, 1050, 1 },
192 | 	{ "Mode 15: 1720x1440", 1720, 1440, 1 },
193 | 	{ "Mode 16: 1920x1080", 1920, 1080, 1 },
194 | 	{ "Mode 17: 1920x1200", 1920, 1200, 1 },
195 | 	{ "Mode 18: 2560x1080", 2560, 1080, 1 },
196 | 	{ "Mode 19: 3440x1440", 3440, 1440, 1 },
197 | 	{ "Mode 20: 3840x2160", 3840, 2160, 1 },
198 | 	{ "Mode 21: 4096x2160", 4096, 2160, 1 },
199 | };
200 | */
201 | //stock cod1 modes
202 | vidmode_t r_vidModes[] =
203 | {
204 | 	{ "Mode  0: 320x240",          320,    240,    1 },
205 | 	{ "Mode  1: 400x300",          400,    300,    1 },
206 | 	{ "Mode  2: 512x384",          512,    384,    1 },
207 | 	{ "Mode  3: 640x480",          640,    480,    1 },
208 | 	{ "Mode  4: 800x600",          800,    600,    1 },
209 | 	{ "Mode  5: 960x720",          960,    720,    1 },
210 | 	{ "Mode  6: 1024x768",         1024,   768,    1 },
211 | 	{ "Mode  7: 1152x864",         1152,   864,    1 },
212 | 	{ "Mode  8: 1280x1024",        1280,   1024,   1 },
213 | 	{ "Mode  9: 1600x1200",        1600,   1200,   1 },
214 | 	{ "Mode 10: 2048x1536",        2048,   1536,   1 },
215 | 	{ "Mode 11: 856x480 (wide)",   856,    480,    1 },
216 | 	{ "Mode 12: 1920x1200 (wide)", 1920,   1200,   1 }
217 | };
218 | static int s_numVidModes = (sizeof(r_vidModes) / sizeof(r_vidModes[0]));
219 | 
220 | qboolean R_GetModeInfo(int mode, int* height, float* windowAspect, int* width) {
221 | 	if (Cvar_VariableIntegerValue("r_borderless")) {
222 | 		GetDesktopResolution(glc_vidWidth, glc_vidHeight);
223 | 		*windowAspect = (float)*glc_vidWidth / *glc_vidHeight;
224 | 		return qtrue;
225 | 	}
226 | 
227 | 	vidmode_t* vm;
228 | 	mode = Cvar_VariableIntegerValue("r_mode");
229 | 
230 | 	if (mode < -1 || mode >= s_numVidModes)
231 | 		return qfalse;
232 | 
233 | 	if (mode == -1) {
234 | 		*glc_vidWidth = Cvar_VariableIntegerValue("r_customwidth");
235 | 		*glc_vidHeight = Cvar_VariableIntegerValue("r_customheight");
236 | 		*windowAspect = Cvar_VariableIntegerValue("r_customaspect");
237 | 		return qtrue;
238 | 	}
239 | 
240 | 	vm = &r_vidModes[mode];
241 | 
242 | 	*glc_vidWidth = vm->width;
243 | 	*glc_vidHeight = vm->height;
244 | 	*windowAspect = (float)vm->width / (vm->height * vm->pixelAspect);
245 | 
246 | 	return qtrue;
247 | }
248 | //__dev__
249 | //void R_ModeList_f() {
250 | //	int i;
251 | //	Com_Printf("\n");
252 | //	for (i = 0; i < s_numVidModes; i++) {
253 | //		Com_Printf("%s\n", r_vidModes[i].description);
254 | //	}
255 | //	Com_Printf("\n");
256 | //}
257 | //__dev__
258 | //void R_AdjustFrom640(float* x, float* y, float* w, float* h) {
259 | //	float widthScale = Cvar_VariableValue("r_scale_w");
260 | //	float heightScale = Cvar_VariableValue("r_scale_h");
261 | //	if (!widthScale) widthScale = 1;
262 | //	if (!heightScale) heightScale = 1;
263 | //
264 | //	float xscale = *((int*)0x15CA614) * 0.0015625;
265 | //	float yscale = *((int*)0x15CA618) * 0.0020833334;
266 | //
267 | //	if (x) *x *= xscale;
268 | //	if (y) *y *= yscale;
269 | //	if (w) *w *= xscale * widthScale;
270 | //	if (h) *h *= yscale * heightScale;
271 | //}
272 | 
273 | //void R_Register() {
274 | //}
275 | //
276 | //void __declspec(naked) R_RegisterStub()
277 | //{
278 | //	const static uint32_t R_Register_func = 0x4B3300; // if that is the address of R_Register
279 | //	const static uint32_t retn_addr = 0x4B46B4; // address of instruction after your hook
280 | //	__asm
281 | //	{
282 | //		call    R_Register_func;
283 | //
284 | //		pushad; // save stack
285 | //		call    R_Register;
286 | //		popad; // restore stack
287 | //		jmp        retn_addr;
288 | //	}
289 | //}


--------------------------------------------------------------------------------
/render.h:
--------------------------------------------------------------------------------
 1 | #include "stdafx.h"
 2 | #include "gl/gl.h"
 3 | #include "gl/glu.h"
 4 | #include "keys.h"
 5 | #include <memory>
 6 | 
 7 | #pragma push(pack, 1)
 8 | typedef struct image_s {
 9 | 	char imgName[MAX_QPATH];
10 | 	char mid[24];
11 | 	unsigned int texnum;
12 | 	char rest[40];
13 | 
14 | 	//at 88 is texnum
15 | } image_t; //size 128
16 | #pragma pop(1)
17 | 
18 | #define tr_numImages (*(UINT32*)0x16C983C)
19 | static image_t **tr_images = (image_t**)0x16C9840;
20 | 
21 | typedef struct shader_s {
22 | 	char name[MAX_QPATH];
23 | } shader_t;
24 | 
25 | #define LIGHTMAP_2D -4
26 | 
27 | #define SMALLCHAR_WIDTH 7
28 | #define SMALLCHAR_HEIGHT 17
29 | #define SMALLCHAR_SCALE 0.3
30 | //taken from 0.3 fontscale
31 | 
32 | static float vColorBlack[4] = { 0,0,0,1 };
33 | static float vColorWhite[4] = { 1, 1, 1, 1 };
34 | static float vColorSelected[4] = { 1, 1, 0, 1 };
35 | 
36 | extern int *whiteShader;
37 | 
38 | static int CG_DrawStrlen(const char *str) {
39 | 	const char *s = str;
40 | 	int count = 0;
41 | 
42 | 	while (*s) {
43 | 		if (Q_IsColorString(s)) {
44 | 			s += 2;
45 | 		}
46 | 		else {
47 | 			count++;
48 | 			s++;
49 | 		}
50 | 	}
51 | 
52 | 	return count;
53 | }
54 | 
55 | int R_RegisterShaderNoMip(const char* name);
56 | 
57 | typedef shader_t* (*R_FindShader_t)(const char*, int, int);
58 | extern R_FindShader_t R_FindShader;
59 | 
60 | typedef int(*RE_RegisterShaderNoMip_t)(const char*);
61 | typedef int(*RE_RegisterShader_t)(const char*);
62 | 
63 | extern RE_RegisterShaderNoMip_t RE_RegisterShaderNoMip;
64 | extern RE_RegisterShader_t RE_RegisterShader;
65 | 
66 | typedef void(__cdecl *SCR_DrawPic_t)(float x, float y, float width, float height, int hShader);
67 | extern SCR_DrawPic_t SCR_DrawPic;
68 | 
69 | typedef void(*RE_SetColor_t)(const float *rgba);
70 | extern RE_SetColor_t RE_SetColor;
71 | 
72 | typedef void(*SCR_AdjustFrom640_t)(float *x, float *y, float *w, float *h);
73 | extern SCR_AdjustFrom640_t SCR_AdjustFrom640;
74 | /*
75 | typedef void (*SCR_DrawSmallStringExt_t)(const char*, float*, int y, int x);
76 | extern SCR_DrawSmallStringExt_t SCR_DrawSmallStringExt;
77 | 
78 | typedef void (*SCR_DrawSmallChar_t)(char,int,int,int);
79 | extern SCR_DrawSmallChar_t SCR_DrawSmallChar;
80 | */
81 | 
82 | typedef void (QDECL *SCR_DrawString_t)(float x, float y, int font, float scale, float* color, const char* text, float spacing, int limit, int flags);
83 | extern SCR_DrawString_t SCR_DrawString;
84 | 
85 | typedef void(*RB_SetGL2D_t)(void);
86 | extern RB_SetGL2D_t RB_SetGL2D;


--------------------------------------------------------------------------------
/resource.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xtnded/codextended-client/45af251518a390ab08b1c8713a6a1544b70114a1/resource.h


--------------------------------------------------------------------------------
/stdafx.cpp:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | 
  3 | void Q_strcat(char *dest, int size, const char *src);
  4 | void Q_strncpyz(char *dest, const char *src, int destsize);
  5 | 
  6 | #include <ShlObj.h>
  7 | #include <Shlwapi.h>
  8 | #pragma comment(lib, "shlwapi.lib")
  9 | 
 10 | #pragma comment(lib, "Comdlg32.lib")
 11 | #include "Commdlg.h"
 12 | 
 13 | int codversion = COD_UNKNOWN;
 14 | 
 15 | std::string file_get_contents(const char *fn) {
 16 | 	FILE *fp = NULL;
 17 | 
 18 | 	fp = fopen(fn, "r");
 19 | 
 20 | 	if (fp == NULL)
 21 | 		return "";
 22 | 
 23 | 	char *buf = NULL;
 24 | 	size_t fs = 0;
 25 | 	fseek(fp, 0, SEEK_END);
 26 | 	fs = ftell(fp);
 27 | 	rewind(fp);
 28 | 
 29 | 	buf = (char*)malloc(fs);
 30 | 	if (fread(buf, 1, fs, fp) != fs) {
 31 | 		fclose(fp);
 32 | 		return "";
 33 | 	}
 34 | 	std::string res(buf);
 35 | 	free(buf);
 36 | 	fclose(fp);
 37 | 	return res;
 38 | }
 39 | 
 40 | std::string GetOpenFileNameS(HWND owner)
 41 | {
 42 | 	char buffer[MAX_PATH] = "";
 43 | 
 44 | 	OPENFILENAME ofn = { 0 };
 45 | 
 46 | 	ofn.lStructSize = sizeof(ofn);
 47 | 	ofn.hwndOwner = owner;
 48 | 	ofn.lpstrFilter = "JPG\0*.jpg\0All Files\0*\0\0";
 49 | 	ofn.nFilterIndex = 1;
 50 | 	ofn.lpstrFile = buffer;
 51 | 	ofn.nMaxFile = MAX_PATH;
 52 | 	ofn.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST;
 53 | 
 54 | 	if (!GetOpenFileName(&ofn))
 55 | 		return "";
 56 | 
 57 | 	return buffer;
 58 | }
 59 | 
 60 | std::string GetLastErrorAsString()
 61 | {
 62 | 	//Get the error message, if any.
 63 | 	DWORD errorMessageID = ::GetLastError();
 64 | 	if (errorMessageID == 0)
 65 | 		return "";
 66 | 
 67 | 	LPSTR messageBuffer = NULL;
 68 | 	size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
 69 | 		NULL, errorMessageID, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);
 70 | 
 71 | 	std::string message(messageBuffer, size);
 72 | 
 73 | 	//Free the buffer.
 74 | 	LocalFree(messageBuffer);
 75 | 
 76 | 	return message;
 77 | }
 78 | 
 79 | int Sys_GetModulePathInfo(HMODULE module, char **path, char **filename, char **extension) {
 80 | 	int sep = '/';
 81 | 	static char szFileName[MAX_PATH + 1];
 82 | 	if (path)
 83 | 		*path = NULL;
 84 | 	if (filename)
 85 | 		*filename = NULL;
 86 | 	if (extension)
 87 | 		*extension = NULL;
 88 | 
 89 | 	GetModuleFileNameA(module, szFileName, MAX_PATH);
 90 | 
 91 | 	char *fn = strrchr(szFileName, sep);
 92 | 	if (fn == nullptr) {
 93 | 		sep = '\\';
 94 | 		fn = strrchr(szFileName, sep);
 95 | 	}
 96 | 	if (fn != NULL) {
 97 | 		*fn++ = 0;
 98 | 
 99 | 		char *ext = strrchr(fn, '.');
100 | 
101 | 		if (ext != NULL) {
102 | 			if (fn != ext) {
103 | 				if (extension)
104 | 					*ext++ = 0;
105 | 				if (path)
106 | 					*path = szFileName;
107 | 				if (filename)
108 | 					*filename = fn;
109 | 				if (extension)
110 | 					*extension = ext;
111 | 			}
112 | 		}
113 | 	}
114 | 	return sep;
115 | }
116 | 
117 | const char *Sys_GetAppDataFolder(char *szPath, int dwLen, bool create) {
118 | 	if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, szPath))) {
119 | 		Q_strncpyz(szPath, szPath, dwLen);
120 | 		Q_strcat(szPath, dwLen, "\\CoDExtended");
121 | 
122 | 		if (!create)
123 | 			return szPath;
124 | 
125 | 		if (!PathFileExists(szPath)) {
126 | 			if (ERROR_SUCCESS != SHCreateDirectoryEx(NULL, szPath, NULL)) {
127 | 				return NULL;
128 | 			}
129 | 
130 | 		}
131 | 	}
132 | 	return szPath;
133 | }


--------------------------------------------------------------------------------
/stdafx.h:
--------------------------------------------------------------------------------
  1 | // stdafx.h : include file for standard system include files,
  2 | // or project specific include files that are used frequently, but
  3 | // are changed infrequently
  4 | //
  5 | 
  6 | #pragma once
  7 | 
  8 | #pragma comment(lib, "Shlwapi.lib")
  9 | #pragma comment(lib, "Shell32.lib")
 10 | 
 11 | #define CURL_STATICLIB
 12 | 
 13 | #include "targetver.h"
 14 | #define __TITLE "Call of Duty Extended"
 15 | 
 16 | #define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
 17 | // Windows Header Files:
 18 | #include <windows.h>
 19 | 
 20 | #if 0
 21 | #ifdef DEBUG
 22 | #define _CRTDBG_MAP_ALLOC
 23 | #include <crtdbg.h>
 24 | #endif
 25 | #endif
 26 | 
 27 | #include <cstdio>
 28 | #include <cstdlib>
 29 | #include <cstring>
 30 | #include <varargs.h>
 31 | #include <ctime>
 32 | 
 33 | #include <string>
 34 | #include <vector>
 35 | #include <map>
 36 | 
 37 | #include "mem_util.h"
 38 | 
 39 | #define QDECL __cdecl
 40 | typedef unsigned char byte;
 41 | 
 42 | #define DLL_EXPORT __declspec(dllexport)
 43 | #define DLL_IMPORT __declspec(dllimport)
 44 | 
 45 | //#define MsgBox(a) MessageBoxA(NULL, a, __TITLE, MB_OK | MB_ICONINFORMATION | MB_APPLMODAL)
 46 | 
 47 | extern bool bDeveloper;
 48 | 
 49 | static bool CopyToClipboard(const char *s) {
 50 | 
 51 | 	if (OpenClipboard(NULL))
 52 | 	{
 53 | 		HGLOBAL clipbuffer;
 54 | 		char * buffer;
 55 | 		EmptyClipboard();
 56 | 		clipbuffer = GlobalAlloc(GMEM_DDESHARE, strlen(s) + 1);
 57 | 		buffer = (char*)GlobalLock(clipbuffer);
 58 | 		strcpy(buffer, s);
 59 | 		GlobalUnlock(clipbuffer);
 60 | 		SetClipboardData(CF_TEXT, clipbuffer);
 61 | 		CloseClipboard();
 62 | 	}
 63 | 	else
 64 | 		return false;
 65 | 	return true;
 66 | }
 67 | 
 68 | static void MsgBox(const char *msg) {
 69 | 	if (bDeveloper) {
 70 | 		if (OpenClipboard(NULL))
 71 | 		{
 72 | 			HGLOBAL clipbuffer;
 73 | 			char * buffer;
 74 | 			EmptyClipboard();
 75 | 			clipbuffer = GlobalAlloc(GMEM_DDESHARE, strlen(msg) + 1);
 76 | 			buffer = (char*)GlobalLock(clipbuffer);
 77 | 			strcpy(buffer, msg);
 78 | 			GlobalUnlock(clipbuffer);
 79 | 			SetClipboardData(CF_TEXT, clipbuffer);
 80 | 			CloseClipboard();
 81 | 		}
 82 | 	}
 83 | 	MessageBoxA(NULL, msg, __TITLE, MB_OK | MB_ICONINFORMATION);
 84 | }
 85 | #define XCRASH _memset((void*)0x400000, 0, 0xffff);
 86 | 
 87 | typedef enum {
 88 | 	COD_UNKNOWN,
 89 | 	COD_1,
 90 | 	COD_1_SP,
 91 | 	COD_5,
 92 | 	COD_5_SP_STEAM,
 93 | 	COD_5_STEAM, //steam version
 94 | 	CODUO_41,
 95 | 	CODUO_51,
 96 | 	
 97 | 	COD2_0,
 98 | 	COD2_1,
 99 | 	COD2_2,
100 | 	COD2_3,
101 | 
102 | 	COD4_7,
103 | 
104 | 
105 | 	COD_END_OF_LIST
106 | } cod_v;
107 | 
108 | static const char *codversion_strings[] = {
109 | 	"UNKNOWN",
110 | 	"1.1",
111 | 	"1.1 SP",
112 | 	"1.5",
113 | 	"1.5 SP Steam",
114 | 	"1.5 Steam",
115 | 	"UO 1.41",
116 | 	"UO 1.51",
117 | 	"2.0",
118 | 	"2.1",
119 | 	"2.2",
120 | 	"2.3",
121 | 	"4 1.7",
122 | 	"end_of_list"
123 | };
124 | 
125 | #define CODVERSION CODUO_51
126 | 
127 | extern int codversion;
128 | 
129 | static const char *get_codversion_string() {
130 | 	return codversion_strings[codversion];
131 | }
132 | 
133 | static void(*Com_Quit_f)() = (void(*)())0x435D80;
134 | 
135 | typedef struct {
136 | 	std::string key;
137 | 	DWORD id;
138 | 	HANDLE handle;
139 | } threadInfo_t;
140 | 
141 | extern std::vector<threadInfo_t> threadsinfo;
142 | 
143 | extern bool thrIsExit;
144 | 
145 | std::string GetLastErrorAsString();
146 | std::string GetOpenFileNameS(HWND owner);
147 | bool download_file(std::string url, char* filename);
148 | 
149 | unsigned int getxuid();
150 | 
151 | static bool FileExists(const char *fn) {
152 | 	DWORD attr = GetFileAttributesA(fn);
153 | 
154 | 	return (attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY));
155 | }
156 | 
157 | const char *Sys_GetAppDataFolder(char *szPath, int dwLen, bool create);
158 | int Sys_GetModulePathInfo(HMODULE module, char **path, char **filename, char **extension);
159 | 
160 | enum HashType
161 | {
162 | 	HashSha1, HashMd5, HashSha256
163 | };
164 | std::string GetHashText(const void * data, const size_t data_size, HashType hashType);
165 | 
166 | 
167 | #define __call6to5(x, y) do {\
168 | XUNLOCK((void*)x, 6); \
169 | *(BYTE*)x = 0xe8; \
170 | __call(x, (int)y); \
171 | *(BYTE*)(x + 5) = 0x90; \
172 | } while (0)
173 | 
174 | static bool is_addr_safe(size_t addr) {
175 | 	__try {
176 | 		*(unsigned char*)(addr);
177 | 	} __except (1) {
178 | 		return false;
179 | 	}
180 | 	return true;
181 | }
182 | 
183 | template <typename T, typename ... Ts> T call(size_t addr, Ts ... ts);
184 | 
185 | template <typename T, typename ... Ts>
186 | T call(size_t addr, Ts ... ts) {
187 | 	T(*f)(...);
188 | 	*(T*)&f = (T)addr;
189 | 	return f(ts...);
190 | }
191 | 
192 | class cJMP {
193 | public:
194 | 	UINT32 from;
195 | 	UINT32 to;
196 | 	BYTE bytes[5];
197 | 	bool active;
198 | 
199 | 	cJMP() : active(false) {}
200 | 
201 | 	cJMP(UINT32 from_, UINT32 to_) : cJMP() {
202 | #ifndef PROJECT_EXE
203 | 		from = from_;
204 | 		to = to_;
205 | 		memcpy((void*)&bytes[0], (void*)from, 5);
206 | #endif
207 | 	}
208 | 
209 | 	void Initialize(UINT32 from_, UINT32 to_) {
210 | 		active = false;
211 | 		from = from_;
212 | 		to = to_;
213 | 		memcpy((void*)&bytes[0], (void*)from, 5);
214 | 	}
215 | 
216 | 	void Initialize(UINT32 from_, UINT32 to_, bool apply) {
217 | 		active = false;
218 | 		from = from_;
219 | 		to = to_;
220 | 		memcpy((void*)&bytes[0], (void*)from, 5);
221 | 		if (apply)
222 | 			this->Apply();
223 | 	}
224 | 
225 | 	void Apply() {
226 | 		if (active)
227 | 			return;
228 | 		__jmp(from, to);
229 | 		active = true;
230 | 	}
231 | 
232 | 	void Restore() {
233 | 		if (!active)
234 | 			return;
235 | 		_memcpy((void*)from, bytes, 5);
236 | 		active = false;
237 | 	}
238 | };


--------------------------------------------------------------------------------
/stockmapinfo.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | static const char *szStockMaps[] = {
 4 | 	"mp_harbor",
 5 | 	"mp_carentan",
 6 | 	"mp_pavlov",
 7 | 	"mp_ship",
 8 | 	"mp_rocket",
 9 | 	"mp_railyard",
10 | 	"mp_powcamp",
11 | 	"mp_hurtgen",
12 | 	"mp_depot",
13 | 	"mp_dawnville",
14 | 	"mp_chateau",
15 | 	"mp_brecourt",
16 | 	nullptr
17 | };


--------------------------------------------------------------------------------
/targetver.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | // Including SDKDDKVer.h defines the highest available Windows platform.
4 | 
5 | // If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
6 | // set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
7 | 
8 | #include <SDKDDKVer.h>
9 | 


--------------------------------------------------------------------------------
/ui.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #include "menudef.h"
  3 | #include "render.h"
  4 | #include "client.h"
  5 | #include "stockmapinfo.h"
  6 | 
  7 | #define WINDOW_MOUSEOVER        0x00000001  // mouse is over it, non exclusive
  8 | #define WINDOW_HASFOCUS         0x00000002  // has cursor focus, exclusive
  9 | #define WINDOW_VISIBLE          0x00000004  // is visible
 10 | #define WINDOW_GREY             0x00000008  // is visible but grey ( non-active )
 11 | #define WINDOW_DECORATION       0x00000010  // for decoration only, no mouse, keyboard, etc..
 12 | #define WINDOW_FADINGOUT        0x00000020  // fading out, non-active
 13 | #define WINDOW_FADINGIN         0x00000040  // fading in
 14 | #define WINDOW_MOUSEOVERTEXT    0x00000080  // mouse is over it, non exclusive
 15 | #define WINDOW_INTRANSITION     0x00000100  // window is in transition
 16 | #define WINDOW_FORECOLORSET     0x00000200  // forecolor was explicitly set ( used to color alpha images or not )
 17 | #define WINDOW_HORIZONTAL       0x00000400  // for list boxes and sliders, vertical is default this is set of horizontal
 18 | #define WINDOW_LB_LEFTARROW     0x00000800  // mouse is over left/up arrow
 19 | #define WINDOW_LB_RIGHTARROW    0x00001000  // mouse is over right/down arrow
 20 | #define WINDOW_LB_THUMB         0x00002000  // mouse is over thumb
 21 | #define WINDOW_LB_PGUP          0x00004000  // mouse is over page up
 22 | #define WINDOW_LB_PGDN          0x00008000  // mouse is over page down
 23 | #define WINDOW_ORBITING         0x00010000  // item is in orbit
 24 | #define WINDOW_OOB_CLICK        0x00020000  // close on out of bounds click
 25 | #define WINDOW_WRAPPED          0x00040000  // manually wrap text
 26 | #define WINDOW_AUTOWRAPPED      0x00080000  // auto wrap text
 27 | #define WINDOW_FORCED           0x00100000  // forced open
 28 | #define WINDOW_POPUP            0x00200000  // popup
 29 | #define WINDOW_BACKCOLORSET     0x00400000  // backcolor was explicitly set
 30 | #define WINDOW_TIMEDVISIBLE     0x00800000  // visibility timing ( NOT implemented )
 31 | #define WINDOW_IGNORE_HUDALPHA  0x01000000  // window will apply cg_hudAlpha value to colors unless this flag is set
 32 | #define WINDOW_DRAWALWAYSONTOP  0x02000000
 33 | #define WINDOW_MODAL            0x04000000 // window is modal, the window to go back to is stored in a stack
 34 | #define WINDOW_FOCUSPULSE       0x08000000
 35 | #define WINDOW_TEXTASINT        0x10000000
 36 | #define WINDOW_TEXTASFLOAT      0x20000000
 37 | #define WINDOW_LB_SOMEWHERE     0x40000000
 38 | 
 39 | DWORD ui_mp;
 40 | 
 41 | //#define UI_FILE_OFF(x) (ui_mp + (x - 0x400076A0)) //vmMain in IDA offset
 42 | #define UI_FILE_OFF(x) (ui_mp + (x - 0x40000000)) //vmMain in IDA offset
 43 | 
 44 | typedef int vm_t;
 45 | 
 46 | vm_t *uivm;
 47 | 
 48 | unsigned int prevVM;
 49 | 
 50 | #define VM_SET_UI prevVM = *(UINT*)0x14073cc; *(UINT*)0x14073cc = 0x161747C
 51 | #define VM_SET_PREV (*(int*)0x14073cc = prevVM)
 52 | 
 53 | typedef struct rectDef_s {
 54 | 	float x;    // horiz position
 55 | 	float y;    // vert position
 56 | 	float w;    // width
 57 | 	float h;    // height;
 58 | } rectDef_t;
 59 | 
 60 | typedef rectDef_t qRectangle;
 61 | 
 62 | typedef struct {
 63 | 	qRectangle rect;                 // client coord rectangle
 64 | 	qRectangle rectClient;           // screen coord rectangle
 65 | 	const char *name;
 66 | 	char _stuff[0x24];
 67 | 	int flags;
 68 | } menuDef_t;
 69 | 
 70 | cursorPositionInfo_t *ui_cursor = NULL;
 71 | 
 72 | int *ui_get_mouse_coords() {
 73 | 	if (ui_cursor == NULL)
 74 | 		return NULL;
 75 | 
 76 | 	return &ui_cursor->x;
 77 | }
 78 | 
 79 | typedef void(__fastcall *Menu_SetFeederSelection_t)(menuDef_t*, int, int, const char*);
 80 | Menu_SetFeederSelection_t Menu_SetFeederSelection;
 81 | 
 82 | FARPROC pMenus_CloseByName;
 83 | FARPROC pMenus_OpenByName;
 84 | FARPROC pMenus_Open;
 85 | 
 86 | void(*Menus_CloseAll)();
 87 | menuDef_t*(*Menus_FindByName)(const char*);
 88 | 
 89 | bool Menu_IsOpen(const char *s) {
 90 | 	menuDef_t *m = Menus_FindByName(s);
 91 | 
 92 | 	if (m != NULL) {
 93 | 		if (m->flags & (WINDOW_VISIBLE | WINDOW_HASFOCUS))
 94 | 			return true;
 95 | 	}
 96 | 	return false;
 97 | }
 98 | 
 99 | menuDef_t *menu_main = NULL;
100 | 
101 | bool Menu_IsMainOpen() {
102 | 	if (menu_main == NULL)
103 | 		return false;
104 | 
105 | 	if (menu_main->flags & (WINDOW_VISIBLE | WINDOW_HASFOCUS)) {
106 | 		return true;
107 | 	}
108 | 	return false;
109 | }
110 | 
111 | void Menus_OpenByName(const char *name, int bModelStack) { /* unsure about the 2nd arg */
112 | 	__asm {
113 | 		push eax
114 | 		push ecx
115 | 		mov eax, name
116 | 		mov ecx, bModelStack
117 | 		call pMenus_OpenByName
118 | 		pop ecx
119 | 		pop eax
120 | 	}
121 | }
122 | 
123 | void Menus_CloseByName(const char *name) {
124 | 	__asm {
125 | 		push eax
126 | 		mov eax, name
127 | 		call pMenus_CloseByName
128 | 		pop eax
129 | 	}
130 | }
131 | 
132 | void _UI_MouseEvent(int dx, int dy) {
133 | 	void(*o)(int, int);
134 | 	*(int*)&o = UI_FILE_OFF(0x4000D790);
135 | 	o(dx, dy);
136 | 
137 | 
138 | 	Com_Printf("dx = %d, dy = %d\n", dx, dy);
139 | }
140 | 
141 | void(*oUI_RunMenuScript)(char**);
142 | 
143 | qboolean String_Parse(char **p, const char **out) { /* out must be freed */
144 | 	char *token;
145 | 
146 | 	char *COM_ParseExt(char **data_p, qboolean allowLineBreaks);
147 | 	token = COM_ParseExt(p, qfalse);
148 | 	if (token && token[0] != 0) {
149 | 		*(out) = strdup(token);
150 | 		return qtrue;
151 | 	}
152 | 	return qfalse;
153 | }
154 | 
155 | void Q_strcat(char *dest, int size, const char *src);
156 | int Q_stricmp(const char *s1, const char *s2);
157 | 
158 | void UI_RunMenuScript(char **args) {
159 | 
160 | 	char script[4096], *p;
161 | 	memset(script, 0, sizeof(script));
162 | 	Q_strcat(script, sizeof(script), *args);
163 | 	p = (char*)script;
164 | 
165 | 	char *name = NULL;
166 | 
167 | 	if (String_Parse(&p, (const char**)&name)) {
168 | 		free(name);
169 | 	}
170 | 
171 | 	static BYTE orig_bytes[5] = { 0x81, 0xEC, 0x4C, 0x8, 0 };
172 | 	_memcpy((void*)UI_FILE_OFF(0x4000A5F0), orig_bytes, sizeof(orig_bytes));
173 | 	oUI_RunMenuScript(args);
174 | 	__jmp(UI_FILE_OFF(0x4000A5F0), (int)UI_RunMenuScript);
175 | }
176 | 
177 | UINT_PTR pMenu_PaintAll;
178 | 
179 | void Menu_PaintAll() {
180 | 	__asm
181 | 	{
182 | 		call pMenu_PaintAll
183 | 	}
184 | 
185 | 	RE_SetColor(vColorWhite);
186 | }
187 | 
188 | image_t *cursorImage = nullptr;
189 | 
190 | void _UI_Init(int inGameLoad) {
191 | 	Cvar_Set("ui_netSource", "1"); // Set default netSource to Internet before the cached servers load.
192 | 
193 | 	void(*o)(int);
194 | 	*(int*)&o = UI_FILE_OFF(0x4000D310);
195 | 
196 | 	o(inGameLoad);
197 | 	
198 | 	menu_main = Menus_FindByName("main");
199 | 	
200 | 	image_t *image;
201 | 
202 | 	for (int i = 0; i < tr_numImages; i++) {
203 | 		image = tr_images[i];
204 | 
205 | 		if(strstr(image->imgName, "cursor")) {
206 | 			cursorImage = image;
207 | 			break;
208 | 		}
209 | 	}
210 | }
211 | 
212 | static bool isUIRunning = false;
213 | 
214 | void CL_ShutdownUI_Cleanup() {
215 | 
216 | 		isUIRunning = false;
217 | }
218 | 
219 | UINT32 pInterceptCallToShutdownUI;
220 | void __declspec(naked) InterceptCallToShutdownUI() {
221 | 	__asm
222 | 	{
223 | 		call CL_ShutdownUI_Cleanup
224 | 		call pInterceptCallToShutdownUI
225 | 		retn
226 | 	}
227 | }
228 | 
229 | void UI_DrawConnectScreen(int overlay) {
230 | #define TEXT_WIDTH 8
231 | #define TEXT_HEIGHT 16
232 | 	if (overlay) {
233 | 		vec4_t colorBlack = { 0, 0, 0, 1 };
234 | 		vec4_t colorWhite = { 1,1,1, 1 };
235 | 
236 | 		RE_SetColor(colorBlack);
237 | 		SCR_DrawPic(0, 0, 640, 480, *whiteShader);
238 | 		RE_SetColor(NULL);
239 | 
240 | #define LOAD_BAR_HEIGHT 240
241 | 
242 | 		char* info = clc_stringData + clc_stringOffsets[0];
243 | 		char *mapname_p = Info_ValueForKey(info, "mapname");
244 | 		char mapname[64] = { 0 };
245 | 		Q_strncpyz(mapname, mapname_p, sizeof(mapname));
246 | 		char *mappath = va("levelshots/%s.tga", mapname);
247 | 		int mapshader = RE_RegisterShaderNoMip(mappath);
248 | 		if (!mapshader)
249 | 			mapshader = RE_RegisterShaderNoMip("menu/art/unknownmap");
250 | 
251 | 		SCR_DrawPic(0, 0, 640, 512, mapshader);
252 | 
253 | 		vec4_t opacity = { .3,.3,.3, .88 };
254 | 
255 | 		char gametype[64] = { 0 };
256 | 		Q_strncpyz(gametype, Info_ValueForKey(info, "g_gametype"), sizeof(gametype));
257 | 
258 | 		int total = atol(Cvar_VariableString("com_expectedhunkusage"));
259 | 		if (total > 0) {
260 | 			int cur = *(int*)0x163A204;
261 | 			float frac = cur / (float)total;
262 | 			if (frac < 0.f) {
263 | 				frac = 0.f;
264 | 			}
265 | 			if (frac > 1.f) {
266 | 				frac = 1.f;
267 | 			}
268 | 			RE_SetColor(opacity);
269 | 			SCR_DrawPic(0, 400, frac * 640, LOAD_BAR_HEIGHT, *whiteShader);
270 | 			RE_SetColor(NULL);
271 | 			char *cstring = va("%s - %s", Com_CleanMapname(mapname_p), Com_GametypeName(gametype, true));
272 | 			int clen = CG_DrawStrlen(cstring) * 12;
273 | 			SCR_DrawString(320 - clen / 2, 400 + 30, 1, .6, colorWhite, cstring, NULL, NULL, NULL);
274 | 		}
275 | 		return;
276 | 	}
277 | 	int blackShader = RE_RegisterShaderNoMip("black");
278 | 	vec4_t whiteColor = { 1, 1, 1, 1 };
279 | 	vec4_t blackColor = { 0, 0, 0, 1 };
280 | 	vec4_t greyColor = { .5, .5, .5, 1 };
281 | 	RE_SetColor(blackColor);
282 | 	SCR_DrawPic(0, 0, 640, 480, blackShader);
283 | 	RE_SetColor(NULL);
284 | 
285 | 	static int connect_dots = 0;
286 | 	static int connect_dots_time = *cls_realtime;
287 | 	char szdots[50] = { 0 };
288 | 	for (int i = 0; i < connect_dots; i++)
289 | 		szdots[i] = '.';
290 | 	
291 | 	char *text = nullptr;
292 | 
293 | 	if (*cls_state < CA_CONNECTED) {
294 | 		vec4_t yellowColor = { 1, 1, 0, 1 };
295 | 		char *serverMessage = (char*)0x15CE888;
296 | 		int len = CG_DrawStrlen(serverMessage) * 6;
297 | 		SCR_DrawString(320 - len / 2, 200, 2, .27, yellowColor, serverMessage, NULL, NULL, NULL);
298 | 	}
299 | 
300 | 	switch (*cls_state) {
301 | 		case CA_CONNECTING:
302 | 			text = va("Connecting to %s%s", cls_servername, szdots);
303 | 		break;
304 | 		case CA_CHALLENGING:
305 | 			text = va("Challenging%s", szdots);
306 | 		break;
307 | 		case CA_CONNECTED:
308 | 			char *downloadName = Cvar_VariableString("cl_downloadName");
309 | 			if (*downloadName) {
310 | 				//downloadname,centerPoint,ystart,scale
311 | 				void(*UI_DisplayDownloadInfo)(char*, float, float, float) = (void(*)(char*, float, float, float))UI_FILE_OFF(0x4000DEA0);
312 | 				UI_DisplayDownloadInfo(downloadName, 320, 55, 0.25);
313 | 				return;
314 | 			}
315 | 
316 | 			text = va("Synchronizing game settings%s", szdots);
317 | 		break;
318 | 	}
319 | 
320 | 	if (text != nullptr) {
321 | 		int txtlen = (CG_DrawStrlen(text) - connect_dots) * 9;
322 | 		SCR_DrawString(320 - txtlen / 2 + 2, 140 + 2, 1, .4, greyColor, text, NULL, NULL, NULL);
323 | 		SCR_DrawString(320 - txtlen / 2, 140, 1, .4, whiteColor, text, NULL, NULL, NULL);
324 | 	}
325 | 	if (*cls_realtime - connect_dots_time > 500) {
326 | 		connect_dots = (connect_dots++ % 3);
327 | 		connect_dots_time = *cls_realtime;
328 | 	}
329 | }
330 | 
331 | void UI_StartServerRefresh(qboolean full) {
332 | 	if (*((bool*)UI_FILE_OFF(0x401EA698))) return;
333 | 
334 | 	void(*o)(qboolean);
335 | 	*(int*)&o = UI_FILE_OFF(0x4000EA90);
336 | 	o(full);
337 | }
338 | 
339 | void UI_DisplayDownloadInfo(const char* downloadName, float centerPoint, float yStart, float scale) {
340 | 	void(*DisplayText)(const char*, float, float, float);
341 | 	*(int*)&DisplayText = UI_FILE_OFF(0x4000DEA0);
342 | 	DisplayText(downloadName, centerPoint, yStart, 0.25);
343 | }
344 | 
345 | void UI_Init(DWORD base) {
346 | 	ui_mp = base;
347 | 	isUIRunning = true;
348 | 
349 | 	Menu_SetFeederSelection = (Menu_SetFeederSelection_t)UI_FILE_OFF(0x40016A10);
350 | 	pMenus_OpenByName = (FARPROC)UI_FILE_OFF(0x400134B0);
351 | 	pMenus_CloseByName = (FARPROC)UI_FILE_OFF(0x40010640);
352 | 	pMenus_Open = (FARPROC)UI_FILE_OFF(0x40013400);
353 | 	pMenu_PaintAll = (UINT_PTR)UI_FILE_OFF(0x400189B0);
354 | 	*(int*)&oUI_RunMenuScript = UI_FILE_OFF(0x4000A5F0);
355 | 	Menus_CloseAll = (void(*)())UI_FILE_OFF(0x40010660);
356 | 	*(int*)&Menus_FindByName = UI_FILE_OFF(0x40010560);
357 | 	ui_cursor = (cursorPositionInfo_t*)UI_FILE_OFF(0x401C3DD4);
358 | 
359 | 	__call(UI_FILE_OFF(0x4000AA55), (int)UI_StartServerRefresh);
360 | 
361 | 	__call(UI_FILE_OFF(0x4000E895), (int)UI_DisplayDownloadInfo); // Smaller download text (UDP only).
362 | 
363 | 	pInterceptCallToShutdownUI = UI_FILE_OFF(0x40007C20);
364 | 	__call(UI_FILE_OFF(0x400076C8), (int)InterceptCallToShutdownUI);
365 | 
366 | 	char *szPath;
367 | 	for (int i = 0; szStockMaps[i] != NULL; i++) {
368 | 		szPath = va("levelshots/%s.dds", szStockMaps[i]);
369 | 	}
370 | 
371 | 	void InitRender();
372 | 	InitRender();
373 | 
374 | 	#define PATCH_PUSH_STRING_PTR_VALUE(offset, new_str) \
375 | 	XUNLOCK((void*)offset, 10); \
376 | 	*(const char **)(offset + 1) = new_str;
377 | 
378 | 	PATCH_PUSH_STRING_PTR_VALUE(UI_FILE_OFF(0x4000B86B), "1.1x");
379 | 	PATCH_PUSH_STRING_PTR_VALUE(UI_FILE_OFF(0X4000E575), "1.1x");
380 | }
381 | 


--------------------------------------------------------------------------------
/version.h:
--------------------------------------------------------------------------------
1 | #define BUILDNUMBER 2691
2 | #define BUILD "2691"


--------------------------------------------------------------------------------
/version_info.h:
--------------------------------------------------------------------------------
1 | #include "version.h"


--------------------------------------------------------------------------------
/win_authority.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | 
  3 | #include "Commctrl.h"
  4 | #include "ShlObj.h"
  5 | #include "Shellapi.h"
  6 | 
  7 | void up_privilege() {
  8 | 	HANDLE hToken;
  9 | 	TOKEN_PRIVILEGES tkp;
 10 | 
 11 | 	OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);
 12 | 
 13 | 	LookupPrivilegeValueA(NULL, "SeDebugPrivileges", &tkp.Privileges[0].Luid);
 14 | 
 15 | 	tkp.PrivilegeCount = 1;
 16 | 	tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 17 | 
 18 | 	AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, NULL, 0);
 19 | }
 20 | 
 21 | int Sys_IsAdmin() {
 22 | 	int b;
 23 | 	SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
 24 | 	PSID AdministratorsGroup;
 25 | 	b = AllocateAndInitializeSid(
 26 | 		&NtAuthority,
 27 | 		2,
 28 | 		SECURITY_BUILTIN_DOMAIN_RID,
 29 | 		DOMAIN_ALIAS_RID_ADMINS,
 30 | 		0, 0, 0, 0, 0, 0,
 31 | 		&AdministratorsGroup);
 32 | 	if (b)
 33 | 	{
 34 | 		if (!CheckTokenMembership(NULL, AdministratorsGroup, &b))
 35 | 		{
 36 | 			b = FALSE;
 37 | 		}
 38 | 		FreeSid(AdministratorsGroup);
 39 | 	}
 40 | 
 41 | 	return(b);
 42 | }
 43 | 
 44 | extern char sys_cmdline[MAX_STRING_CHARS];
 45 | 
 46 | #define ERROR_MSG(x) do \
 47 | 	MessageBox(0, va("Call of Duty caught an error whilst trying to do something.\nFile: %s, Line: %d\nErrorcode: %d (0x%x)\nError: %s" \
 48 | 				"Please report this error at the forums.",__FILE__,__LINE__,x,x,GetLastErrorAsString().c_str()), __TITLE, MB_ICONERROR | MB_OK); \
 49 | 								while(0)
 50 | 
 51 | void Sys_ElevateProgram() {
 52 | 	if (Sys_IsAdmin())
 53 | 		return; //we already are admin
 54 | 
 55 | 	char *fn;
 56 | 
 57 | 	Sys_GetModulePathInfo(NULL, NULL, &fn, NULL);
 58 | 
 59 | 	char *arg = va("allowdupe %s", sys_cmdline);
 60 | 
 61 | 	DWORD err = ERROR_SUCCESS;
 62 | 	ShellExecuteA(NULL, "runas", fn, arg, ".", SW_SHOWNORMAL | SW_SHOW);
 63 | 	if ((err = GetLastError()) != ERROR_SUCCESS)
 64 | 		if (err != ERROR_CANCELLED)
 65 | 			ERROR_MSG(err);
 66 | 
 67 | 	Com_Quit_f();
 68 | }
 69 | 
 70 | void Sys_RestartProgram(bool bAsAdmin) {
 71 | 	char *fn;
 72 | 
 73 | 	Sys_GetModulePathInfo(NULL, NULL, &fn, NULL);
 74 | 
 75 | 	char *arg = va("allowdupe %s", sys_cmdline);
 76 | 
 77 | 	DWORD err = ERROR_SUCCESS;
 78 | 	ShellExecuteA(NULL, bAsAdmin ? "runas" : "open", fn, arg, ".", SW_SHOWNORMAL | SW_SHOW);
 79 | 	if ((err = GetLastError()) != ERROR_SUCCESS)
 80 | 		if (err != ERROR_CANCELLED)
 81 | 			ERROR_MSG(err);
 82 | 
 83 | quit:
 84 | 	Com_Quit_f();
 85 | }
 86 | 
 87 | typedef struct {
 88 | 	int ver;
 89 | 	char *md5;
 90 | } cod_v_pair;
 91 | 
 92 | cod_v_pair cod_v_info[] = {
 93 | 	{ COD_1, "7b54e0259b24d32c16467ac454228418" }, // Modified, proper entry points, loads cod1x.dll instead of mss32.dll. f19da0d804bb20231572ee17225af339 - polish 7b54e0259b24d32c16467ac454228418 - md5 of english .exe
 94 | 	{ COD_1_SP, "9fa83933bbf659050a2f213c217b624c" },
 95 | 	//{ COD_1, "766345d1ceaf79caf7fe88a214b2f3ec" }, //from spect (different codmp entry points RVA import)
 96 | 	{ CODUO_51, "928dd08dc169bd85fdd12d2db28def70" },
 97 | 	{ COD_5_SP_STEAM, "acdf185fe7767d711fc99cb57df46044" },
 98 | 	{ COD_5_STEAM, "4f4596b1cdb21f9eb62e6683ecf48dc6" },
 99 | 	{ COD_5, "4bdf293d8e6fb32208d1b0942a1ba6bc" },
100 | 	{ COD_UNKNOWN, NULL }
101 | 
102 | };
103 | 
104 | 
105 | int WINAPI WinMain_upd(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
106 | 
107 | 	char *tempFileName = va("codmp_%u.download", rand());
108 | 	bool simple_download(const char *url, const char *local);
109 | 	if (!simple_download("http://cod1.eu/bin/codmp_1.bin", tempFileName)) {
110 | 		MessageBoxA(NULL, "Failed to download patch CoDMP.exe! Run the program as Administrator!\n", __TITLE, MB_ICONERROR | MB_OK);
111 | 		ExitProcess(0);
112 | 	}
113 | #if 1
114 | 	char cur_fn[MAX_PATH + 1];
115 | 	GetModuleFileNameA(NULL, cur_fn, MAX_PATH);
116 | 
117 | 	MoveFile(cur_fn, "cod_tmp_del_file");
118 | 	DeleteFileA("cod_tmp_del_file");
119 | 	MoveFileA(tempFileName, cur_fn);
120 | 	Sys_RestartProgram(true);
121 | 	ExitProcess(0);
122 | #endif
123 | }
124 | 
125 | bool determine_cod_version() {
126 | 	FILE *fp = NULL;
127 | 
128 | 	char szFileName[MAX_PATH + 1];
129 | 	GetModuleFileName(NULL, szFileName, MAX_PATH);
130 | 
131 | 	if (GetLastError() != ERROR_SUCCESS) {
132 | 		MessageBoxA(NULL, "Too long filepath/name", "", 0);
133 | 		return false;
134 | 	}
135 | 
136 | 	char *fn;
137 | 	Sys_GetModulePathInfo(NULL, NULL, &fn, NULL);
138 | 
139 | 	fp = fopen(fn, "rb");
140 | 
141 | 	if (!fp) {
142 | 		MessageBoxA(NULL, va("Error reading '%s'\nRun Call of Duty as Administrator.", fn), __TITLE, MB_OK);
143 | 		return false;
144 | 	}
145 | 
146 | 	BYTE *buf = NULL;
147 | 	size_t fs = 0;
148 | 	fseek(fp, 0, SEEK_END);
149 | 	fs = ftell(fp);
150 | 	rewind(fp);
151 | 
152 | 	buf = new BYTE[fs];
153 | 
154 | 	if (fread(buf, 1, fs, fp) != fs) {
155 | 		MessageBox(NULL, va("Reading error '%s'\n", fn), __TITLE, MB_OK | MB_ICONERROR);
156 | 		delete[] buf;
157 | 		fclose(fp);
158 | 		return false;
159 | 	}
160 | 
161 | 
162 | 	std::string hash = GetHashText(buf, fs, HashMd5);
163 | 
164 | 	delete[] buf;
165 | 	fclose(fp);
166 | 	fp = NULL;
167 | 
168 | 	for (int i = 0; cod_v_info[i].md5 != NULL; i++) {
169 | 		if (!strncmp(cod_v_info[i].md5, hash.c_str(), 32)) {
170 | 			codversion = cod_v_info[i].ver;
171 | 			break;
172 | 		} else if (!strncmp(hash.c_str(), "766345d1ceaf79caf7fe88a214b2f3ec", 32)) { // If hash != [that] update DLL?
173 | 			__call(0x528B38, (int)WinMain_upd);
174 | 			break;
175 | 		}
176 | 	}
177 | 
178 | 	return (codversion != COD_UNKNOWN);
179 | }
180 | 
181 | bool find_cod_version() {
182 | 	if (!is_addr_safe(0x566C18))
183 | 		return false;
184 | 
185 | 	char *l_1 = (char*)0x566C18;
186 | 
187 | 	if (!l_1)
188 | 		return false;
189 | 
190 | 	if (!strcmp(l_1, "1.1")) {
191 | 		codversion = COD_1;
192 | 		return true;
193 | 	}
194 | 	return false;
195 | }
196 | 
197 | bool has_authority() {
198 | 	up_privilege();
199 | 
200 | 	if (Sys_IsAdmin())
201 | 		return true;
202 | 
203 | 	Sys_ElevateProgram();
204 | 
205 | 	return false;
206 | }


--------------------------------------------------------------------------------
/win_main.cpp:
--------------------------------------------------------------------------------
  1 | #include "shared.h"
  2 | #include "Commctrl.h"
  3 | #include "ShlObj.h"
  4 | #include "Shlwapi.h"
  5 | #include "Shellapi.h"
  6 | #include "resource.h"
  7 | 
  8 | #include <tchar.h>
  9 | 
 10 | static int(__stdcall *main)(HINSTANCE, HINSTANCE, LPSTR, int) = (int(__stdcall*)(HINSTANCE, HINSTANCE, LPSTR, int))0x4640B0;
 11 | 
 12 | char sys_cmdline[MAX_STRING_CHARS];
 13 | char szAppData[MAX_PATH + 1];
 14 | 
 15 | std::vector<threadInfo_t> threadsinfo;
 16 | bool thrIsExit = false;
 17 | 
 18 | extern HMODULE hModule;
 19 | HINSTANCE hInst;
 20 | 
 21 | HWND hSplashScreen = (HWND)0x8E5268;
 22 | 
 23 | bool bNullClient = false;
 24 | bool bDeveloper = false;
 25 | 
 26 | HWND g_Dialog = nullptr;
 27 | int dwCancelDownload = 0;
 28 | 
 29 | BOOL CALLBACK DlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 30 | {
 31 | 	switch (uMsg)
 32 | 	{
 33 | 	case WM_CLOSE:
 34 | 		//EndDialog(hWnd, 0);
 35 | 		//MessageBoxA(hWnd, "Successfully updated!", __TITLE, MB_OK);
 36 | 
 37 | 		if (g_Dialog != nullptr) {
 38 | 			DestroyWindow(g_Dialog);
 39 | 			g_Dialog = nullptr;
 40 | 		}
 41 | 		dwCancelDownload = 1;
 42 | 		PostQuitMessage(0);
 43 | 		break;
 44 | 
 45 | 	case WM_INITDIALOG: {
 46 | 		SendDlgItemMessage(hWnd, IDC_PROGRESS1, PBM_SETRANGE, 1, MAKELONG(0, 100));
 47 | 		SendDlgItemMessage(hWnd, IDC_PROGRESS1, PBM_SETSTEP, 0, 0);
 48 | 		//SendDlgItemMessage(hWnd, IDC_PROGRESS1, PBM_STEPIT, 0, 0);
 49 | 		} return 0;
 50 | 
 51 | 	default:
 52 | 		return FALSE;
 53 | 	}
 54 | 	return TRUE;
 55 | }
 56 | 
 57 | DWORD WINAPI thr_LoadingBar(LPVOID parm) {
 58 | 	HWND hWnd;
 59 | 	//DialogBoxParam(hInstance, MAKEINTRESOURCEA(IDD_DIALOGBAR), NULL, (DLGPROC)DlgProc, (LPARAM)NULL);
 60 | 	g_Dialog = CreateDialogA(hModule, MAKEINTRESOURCEA(IDD_DIALOGBAR), NULL, (DLGPROC)DlgProc);
 61 | 
 62 | 	if (g_Dialog != nullptr)
 63 | 		ShowWindow(g_Dialog, SW_NORMAL);
 64 | 	else
 65 | 		return 0;
 66 | 	MSG msg;
 67 | 	while (!thrIsExit && GetMessageA(&msg, NULL, 0, 0)) {
 68 | 		if (!IsDialogMessage(g_Dialog, &msg)) {
 69 | 			TranslateMessage(&msg);
 70 | 			DispatchMessage(&msg);
 71 | 		}
 72 | 	}
 73 | 
 74 | 	if (g_Dialog != nullptr)
 75 | 		DestroyWindow(g_Dialog);
 76 | 	return 0;
 77 | }
 78 | 
 79 | void RemoveThread(threadInfo_t *ti) {
 80 | 	if (!ti)
 81 | 		return;
 82 | 	DWORD exitCode;
 83 | 	for (auto it = threadsinfo.begin(); it != threadsinfo.end();) {
 84 | 		if (it->handle == ti->handle) {
 85 | 			if (GetExitCodeThread(it->handle, &exitCode) != 0) {
 86 | 				if (exitCode == STILL_ACTIVE) {
 87 | 					//MessageBox(NULL, va("waiting on thread %d", it->id), __TITLE, MB_OK);
 88 | 					if (WaitForSingleObject(it->handle, INFINITE) != WAIT_OBJECT_0)
 89 | 						MsgBox("fail wait");
 90 | 				}
 91 | 				CloseHandle(it->handle);
 92 | 			}
 93 | 			it = threadsinfo.erase(it);
 94 | 
 95 | 			break;
 96 | 		}
 97 | 		else
 98 | 			++it;
 99 | 	}
100 | }
101 | 
102 | void CleanupThreads() {
103 | 	thrIsExit = true;
104 | 
105 | 	DWORD exitCode;
106 | 	for (std::vector<threadInfo_t>::iterator it = threadsinfo.begin(); it != threadsinfo.end();) {
107 | 		if (!it->handle)
108 | 			goto just_del;
109 | 		if (GetExitCodeThread(it->handle, &exitCode) != 0) {
110 | 			if (exitCode == STILL_ACTIVE) {
111 | 				//MessageBox(NULL, va("waiting on thread %d", it->id), __TITLE, MB_OK);
112 | 				if (WaitForSingleObject(it->handle, INFINITE) != WAIT_OBJECT_0)
113 | 					MsgBox("fail wait");
114 | 			}
115 | 			CloseHandle(it->handle);
116 | 			just_del:
117 | 			it->handle = NULL;
118 | 			it = threadsinfo.erase(it);
119 | 			continue;
120 | 		}
121 | 		++it;
122 | 	}
123 | 
124 | 	//MsgBox("cleaned up closing process now\n");
125 | }
126 | 
127 | threadInfo_t *AddThread(std::string key, DWORD(WINAPI *thr_func)(LPVOID)) {
128 | 	threadInfo_t ti;
129 | 	ti.key = key;
130 | 	ti.handle = (HANDLE)CreateThread(0, 0, thr_func, 0, 0, &ti.id);
131 | 	int idx = threadsinfo.size();
132 | 	threadsinfo.push_back(ti);
133 | 	return &threadsinfo[idx];
134 | }
135 | 
136 | int create_progress_download(const char *url, FILE *fp, int(*progress_callback)(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow));
137 | 
138 | static int dl_progress_cb(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow) {
139 | 	//SendDlgItemMessage(g_Dialog, IDC_PROGRESS1, PBM_SETRANGE, 1, MAKELONG(0, 10));
140 | 	SendDlgItemMessage(g_Dialog, IDC_PROGRESS1, PBM_SETPOS, (WPARAM)(dlnow/dltotal*100), 0);
141 | 	SendDlgItemMessage(g_Dialog, IDC_PROGRESS1, PBM_STEPIT, 0, 0);
142 | 	Sleep(20); //just to put here to make it seem cooler
143 | 	return dwCancelDownload;
144 | }
145 | 
146 | bool Sys_UpdateExtended(const char *uri) {
147 | 	int Sys_IsAdmin();
148 | 	if (!Sys_IsAdmin()) {
149 | 		void Sys_ElevateProgram();
150 | 		Sys_ElevateProgram();
151 | 		return false;
152 | 	}
153 | 
154 | 	char *fn, *path;
155 | 	Sys_GetModulePathInfo(NULL, &path, &fn, NULL);
156 | 
157 | 	char szUpdateFile[MAX_PATH + 1] = { 0 };
158 | 	_snprintf(szUpdateFile, MAX_PATH, "%s\\codupdatefile.%u", szAppData, (unsigned)rand());
159 | 
160 | #define DEST_FILE "mss32.dll"
161 | 
162 | 	FILE *fp = fopen(szUpdateFile, "wb");
163 | 
164 | 	if (fp == nullptr)
165 | 		return false;
166 | 
167 | 	threadInfo_t *thr = AddThread("loadingbar", thr_LoadingBar);
168 | 	
169 | 	if (create_progress_download(uri, fp, dl_progress_cb) == 42) {
170 | 		MessageBoxA(NULL, "Cancelled updating Call of Duty.", __TITLE, MB_OK | MB_ICONINFORMATION);
171 | 		goto fail;
172 | 	}
173 | 	else {
174 | 		char dest_file[MAX_PATH + 1] = { 0 };
175 | 		_snprintf(dest_file, MAX_PATH, "%s\\%s", path, DEST_FILE);
176 | #include "version_info.h"
177 | 		char *dest_file_old = va("%s\\%s.old", szAppData, DEST_FILE);
178 | 		
179 | 		if (FileExists(dest_file_old) && !DeleteFileA(dest_file_old))
180 | 			goto fail;
181 | 
182 | 		if (!MoveFileA(dest_file, dest_file_old)) {
183 | 			goto fail;
184 | 		}
185 | 
186 | 		if (!MoveFileA(szUpdateFile, dest_file))
187 | 			goto fail;
188 | 	}
189 | 
190 | 	SendMessage(g_Dialog, WM_CLOSE, 0, 0);
191 | 	WaitForSingleObject(g_Dialog, INFINITE);
192 | 	void Sys_RestartProgram(bool);
193 | 	Sys_RestartProgram(false);
194 | 	return true; // wont reach
195 | 
196 | fail:
197 | 
198 | 	SendMessage(g_Dialog, WM_CLOSE, 0, 0);
199 | 	WaitForSingleObject(g_Dialog, INFINITE);
200 | 	Com_Quit_f();
201 | 	return false;
202 | }
203 | 
204 | extern "C" bool bClosing = false;
205 | 
206 | void Sys_Unload() {
207 | 	bClosing = true;
208 | 	static bool unloaded = false;
209 | 
210 | 	if (unloaded)
211 | 		return;
212 | 	unloaded = true;
213 | 
214 | 	void CleanupThreads();
215 | 	CleanupThreads();
216 | 
217 | 	void CL_DiscordShutdown();
218 | 	CL_DiscordShutdown();
219 | }
220 | 
221 | void RegistryAddURLProtocol() {
222 | 	HKEY hkey;
223 | 	char gamePath[MAX_PATH], szExe[MAX_PATH * 2];
224 | 	GetModuleFileName(NULL, gamePath, MAX_PATH);
225 | 	LPCTSTR defaultIcon = TEXT("CoDMP.exe,0");
226 | 
227 | 	if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Classes\\cod1x", &hkey) == ERROR_SUCCESS) {
228 | 		RegSetValueExA(hkey, "URL Protocol", 0, REG_SZ, (PBYTE)"", 1);
229 | 		RegSetValueExA(hkey, "DefaultIcon", 0, REG_SZ, (LPBYTE)defaultIcon, _tcslen(defaultIcon) * sizeof(TCHAR));
230 | 		RegCloseKey(hkey);
231 | 	}
232 | 
233 | 	if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Classes\\cod1x\\shell\\open\\command", &hkey) == ERROR_SUCCESS) {
234 | 		Com_sprintf(szExe, sizeof(szExe), "%s %%1", gamePath);
235 | 		RegSetValueA(hkey, NULL, REG_SZ, szExe, strlen(szExe));
236 | 		RegCloseKey(hkey);
237 | 	}
238 | }
239 | 
240 | int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
241 | 	hInst = hInstance;
242 | 	strncpy(sys_cmdline, lpCmdLine, sizeof(sys_cmdline) - 1);
243 | 
244 | 	// Custom URL protocol: cod1x://1.2.3.4 to connect to a server.
245 | 	std::string strCmdLine = std::string(lpCmdLine);
246 | 	if (strCmdLine.rfind("cod1x://", 0) == 0) {
247 | 		// Remove cod1x:// and ending slash from string.
248 | 		strCmdLine.erase(0, 8);
249 | 		if (strCmdLine.back() == '/')
250 | 			strCmdLine.pop_back();
251 | 
252 | 		// Check is IP valid.
253 | 		netadr_t ip;
254 | 		if (NET_StringToAdr(strCmdLine.c_str(), &ip)) {
255 | 			// Set "connect ip" command to the command line.
256 | 			strCmdLine = "connect " + strCmdLine;
257 | 			lpCmdLine = const_cast<char*>(strCmdLine.c_str());
258 | 		}
259 | 	}
260 | 	else { // Add the registry keys for the protocol.
261 | 		RegistryAddURLProtocol();
262 | }
263 | 
264 | #ifdef PROJECT_EXE
265 | 	threadInfo_t *thr = AddThread("loadingbar", thr_LoadingBar);
266 | 	DWORD exitCode = STILL_ACTIVE;
267 | 	
268 | 	FILE *fp = fopen("C:/Users/R/Desktop/testsounds.pk3", "wb");
269 | 
270 | 	if (fp == nullptr)
271 | 		return 0;
272 | 
273 | 	if (create_progress_download("http://cod1.eu/dl/zz_deathrun_sounds.pk3", fp, dl_progress_cb) == 42) {
274 | 		MsgBox("cancelled");
275 | 	}
276 | 
277 | 	SendMessage(g_Dialog, WM_CLOSE, 0, 0);
278 | 	CleanupThreads();
279 | 	return 0;
280 | #else
281 | 	if (strstr(lpCmdLine, "steamchild") != NULL) {
282 | 		return 0;
283 | 	}
284 | 
285 | 	if (Sys_GetAppDataFolder(szAppData, MAX_PATH, true) == NULL) {
286 | 		MsgBox("Failed to create data folder.");
287 | 		return 0;
288 | 	}
289 | 
290 | 	void MSS32_Hook();
291 | 	MSS32_Hook();
292 | 
293 | 	extern bool miles32_loaded;
294 | 	if (!miles32_loaded)
295 | 		return 0;
296 | 
297 | 	return main(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
298 | #endif
299 | }


--------------------------------------------------------------------------------
/xm_phandler.cpp:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | #include "common.h"
 3 | #include "version.h"
 4 | 
 5 | void RemoveThread(threadInfo_t*);
 6 | threadInfo_t *AddThread(std::string key, DWORD(WINAPI *thr_func)(LPVOID));
 7 | volatile bool g_bConnectedToMaster = false;
 8 | 
 9 | typedef enum {
10 | 	k_EPacketTypeInvalid,
11 | 	k_EPacketTypeGetClientVersion,
12 | 	k_EPacketTypeGetChallenge,
13 | 	k_EPacketTypeConnect,
14 | 
15 | 	k_EPacketTypeHeartbeat,
16 | } k_EPacketTypes;
17 | 
18 | void dump_bytes(char *buf, size_t bufsz) {
19 | 	Com_Printf("Bytes: ");
20 | 	for (size_t i = 0; i < bufsz; i++) {
21 | 		Com_Printf("0x%02X, ", (unsigned char)buf[i]);
22 | 	}
23 | 	Com_Printf("\n");
24 | }
25 | 
26 | qboolean    NET_CompareBaseAdr(netadr_t a, netadr_t b);
27 | 
28 | void PH_Init() {
29 | }
30 | 
31 | void PH_Handle(netadr_t from, char *buf, size_t bufsz) {
32 | 
33 | 	if (!NET_CompareBaseAdr(ex_master, from))
34 | 		return;
35 | }
36 | 
37 | void PH_Shutdown() {
38 | 
39 | }


--------------------------------------------------------------------------------
/xuid.cpp:
--------------------------------------------------------------------------------
 1 | #include "hdd_serial_number.h"
 2 | #include <string.h>
 3 | 
 4 | /*
 5 | stolen from sample code && AlterIw/fourdeltaone uses this too
 6 | */
 7 | 
 8 | static unsigned int xuid = 0;
 9 | 
10 | inline unsigned int jenkins_one_at_a_time_hash(char *key, size_t len)
11 | {
12 | 	unsigned int hash, i;
13 | 	for (hash = i = 0; i < len; ++i)
14 | 	{
15 | 		hash += key[i];
16 | 		hash += (hash << 10);
17 | 		hash ^= (hash >> 6);
18 | 	}
19 | 	hash += (hash << 3);
20 | 	hash ^= (hash >> 11);
21 | 	hash += (hash << 15);
22 | 	return hash;
23 | }
24 | 
25 | unsigned int getxuid()
26 | {
27 | 	if (xuid)
28 | 		return xuid;
29 | 
30 | 
31 | 	MasterHardDiskSerial diskSerial;
32 | 	char *serial = diskSerial.GetSerialNo();
33 | 	xuid = jenkins_one_at_a_time_hash(serial, strlen(serial));
34 | 	return xuid;
35 | }


--------------------------------------------------------------------------------