summaryrefslogtreecommitdiffhomepage
path: root/src/sst.c
blob: 5f0999166553fc5eec8914ca0aed3df766368ac4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
/*
 * Copyright © 2024 Michael Smith <mikesmiffy128@gmail.com>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include <string.h>

#ifdef _WIN32
#include <Windows.h>
#include <shlwapi.h>
#else
#include <stdlib.h> // unsetenv
#include <sys/uio.h>
#endif

#include "con_.h"
#include "engineapi.h"
#include "errmsg.h"
#include "event.h"
#include "fixes.h"
#include "gamedata.h"
#include "gameinfo.h"
#include "gametype.h"
#include "hook.h"
#include "intdefs.h"
#include "langext.h"
#include "os.h"
#include "sst.h"
#include "vcall.h"
#include "version.h"

#ifdef _WIN32
#define fS "S"
#else
#define fS "s"
#endif

static int ifacever;

// XXX: exposing this clumsily to portalcolours. we should have a better way of
// exposing lib handles in general, probably.
void *clientlib = 0;

bool sst_earlyloaded = false; // see deferinit() below
bool sst_userunloaded = false; // see hook_plugin_unload_cb() below

#define VDFBASENAME "SourceSpeedrunTools"

#ifdef _WIN32
extern long __ImageBase; // this is actually the PE header struct but don't care
static inline void *ownhandle(void) { return &__ImageBase; }
#else
// sigh, _GNU_SOURCE crap. define here instead >:(
typedef struct {
	const char *dli_fname;
	void *dli_fbase;
	const char *dli_sname;
	void *dli_saddr;
} Dl_info;
int dladdr1(const void *addr, Dl_info *info, void **extra_info, int flags);
static void *ownhandle(void) {
	static void *cached = 0;
	Dl_info dontcare;
	if_cold (!cached) {
		dladdr1((void *)&ownhandle, &dontcare, &cached, /*RTLD_DL_LINKMAP*/ 2);
	}
	return cached;
}
#endif

#ifdef _WIN32
// not a proper check, just a short-circuit check to avoid doing more work.
static inline bool checksamedrive(const ushort *restrict path1,
		const ushort *restrict path2) {
	bool ret = (path1[0] | 32) == (path2[0] | 32);
	if_cold (!ret) errmsg_errorx("game and plugin must be on the same drive\n");
	return ret;
}
#endif

DEF_CCMD_HERE(sst_autoload_enable, "Register SST to load on game startup", 0) {
	os_char path[PATH_MAX];
	if_cold (os_dlfile(ownhandle(), path, countof(path)) == -1) {
		// hopefully by this point this won't happen, but, like, never know
		errmsg_errordl("failed to get path to plugin");
		return;
	}
	os_char _startdir[PATH_MAX];
	const os_char *startdir;
	if (ifacever == 2) {
		startdir = _startdir;
		os_getcwd(_startdir);
#ifdef _WIN32
		// note: strictly speaking we *could* allow this with an absolute path
		// since old builds allow absolute plugin_load paths but since it's less
		// reliable if e.g. a disk is removed, and also doesn't work for all
		// games, just rule it out entirely to keep things simple.
		if_cold (!checksamedrive(path, startdir)) return;
#endif
		int len = os_strlen(startdir);
		if_cold (len + ssizeof("/bin") >= PATH_MAX) {
			errmsg_errorx("path to game is too long");
			return;
		}
#ifdef _WIN32
		// PathRelativePathToW actually NEEDS a backslash, UGH
		os_spancopy(_startdir + len, L"\\bin", 5);
#else
		os_spancopy(_startdir + len, L"/bin", 5);
#endif
	}
	else /* ifacever == 3 */ {
		// newer games load from the mod dir instead of engine bin, and search
		// in inherited search paths too, although we don't bother with those as
		// the actual VDF is only read from the mod itself so it's always enough
		// to make the path relative to that (and that makes the actual plugin
		// search fast too as it should find it in the first place it looks).
		// we *still* refuse to autoload across different drives even if some
		// obscure gameinfo.txt arrangement could technically allow that to work
		startdir = gameinfo_gamedir;
#ifdef _WIN32
		if_cold (!checksamedrive(path, startdir)) return;
#endif
	}
	os_char relpath[PATH_MAX];
#ifdef _WIN32
	// note: dll isn't actually in gamedir if it's in a base mod directory
	// note: gamedir doesn't account for if the dll is in a base mod's
	// directory, although it will yield a valid/working relative path anyway.
	if_cold (!PathRelativePathToW(relpath, startdir, FILE_ATTRIBUTE_DIRECTORY,
			path, 0)) {
		errmsg_errorsys("couldn't compute a relative path");
		return;
	}
	// arbitrary aesthetic judgement - use forward slashes. while we're at it,
	// also make sure there's no unicode in there, just in case...
	int rellen = 0;
	for (ushort *p = relpath; *p; ++p, ++rellen) {
		if_cold (*p > 127) {
			errmsg_errorx("mod dir contains Unicode characters which Source "
					"doesn't handle well - autoload file not created");
			return;
		}
		if_random (*p == L'\\') *p = L'/';
	}
#else
	const char *p = path, *q = startdir;
	int slash = 0;
	int i = 1;
	for (;; ++i) {
		if (p[i] == '/' && (q[i] == '/' || q[i] == '\0')) slash = i;
		if (p[i] != q[i]) break;
	}
	int rellen = strlen(p + slash + 1) + 1; // include \0
	char *r = relpath;
	if (q[i]) {
		if (r - relpath >= PATH_MAX - 3 - rellen) {
			errmsg_errorx("path to game is too long"); // eh...
			return;
		}
		for (;;) {
			r[0] = '.'; r[1] = '.'; r[2] = '/';
			r += 3;
			for (;;) {
				if (q[++i] == '/') break;
				if (!q[i]) goto c;
			}
		}
	}
c:	memcpy(r, p + slash + 1, rellen);
#endif
	int len = os_strlen(gameinfo_gamedir);
	if (len + ssizeof("/addons/" VDFBASENAME ".vdf") > countof(path)) {
		errmsg_errorx("path to VDF is too long");
		return;
	}
	os_spancopy(path, gameinfo_gamedir, len);
	os_spancopy(path + len, OS_LIT("/addons"), 8);
	if (!os_mkdir(path)) if_cold (os_lasterror() != OS_EEXIST) {
		errmsg_errorsys("couldn't create %" fS, path);
		return;
	}
	os_spancopy(path + len + ssizeof("/addons") - 1,
			OS_LIT("/") OS_LIT(VDFBASENAME) OS_LIT(".vdf"),
			ssizeof("/" VDFBASENAME ".vdf"));
	int f = os_open_write(path);
	if_cold (f == -1) { errmsg_errorsys("couldn't open %" fS, path); return; }
#ifdef _WIN32
	char buf[19 + PATH_MAX];
	memcpy(buf, "Plugin { file \"", 15);
	for (int i = 0; i < rellen; ++i) buf[i + 15] = relpath[i];
	memcpy(buf + 15 + rellen, "\" }\n", 4);
	if_cold (os_write(f, buf, rellen + 19) == -1) { // blegh
#else
	struct iovec iov[3] = {
		{"Plugin { file \"", 15},
		{relpath, rellen},
		{"\" }\n", 4}
	};
	if_cold (writev(fd, &iov, 3) == -1) {
#endif
		errmsg_errorsys("couldn't write to %" fS, path);
	}
	os_close(f);
}

DEF_CCMD_HERE(sst_autoload_disable, "Stop loading SST on game startup", 0) {
	os_char path[PATH_MAX];
	int len = os_strlen(gameinfo_gamedir);
	if_cold (len + ssizeof("/addons/" VDFBASENAME ".vdf") > countof(path)) {
		errmsg_errorx("path to VDF is too long");
		return;
	}
	os_spancopy(path, gameinfo_gamedir, len);
	os_spancopy(path + len, OS_LIT("/addons/") OS_LIT(VDFBASENAME) OS_LIT(".vdf"),
			ssizeof("/addons/" VDFBASENAME ".vdf"));
	if (!os_unlink(path)) if_cold (os_lasterror() != OS_ENOENT) {
		errmsg_warnsys("couldn't delete %" fS, path);
	}
}

DEF_CCMD_HERE(sst_printversion, "Display plugin version information", 0) {
	con_msg("v" VERSION "\n");
}

// ugly temporary hack until demo verification things are fleshed out: let
// interested parties identify the version of SST used by just writing a dummy
// cvar to the top of the demo. this will be removed later, once there's a less
// stupid way of achieving the same goal.
#if VERSION_MAJOR != 0 || VERSION_MINOR != 9
#error Need to change this manually, since codegen requires it to be spelled \
out in DEF_CVAR - better yet, can we get rid of this yet?
#endif
DEF_CVAR(__sst_0_9_beta, "", 0, CON_HIDDEN | CON_DEMO)

// most plugin callbacks are unused - define dummy functions for each signature
static void VCALLCONV nop_v_v(void *this) {}
static void VCALLCONV nop_p_v(void *this, void *p) {}
static void VCALLCONV nop_pp_v(void *this, void *p1, void *p2) {}
static void VCALLCONV nop_pii_v(void *this, void *p, int i1, int i2) {}
static int VCALLCONV nop_p_i(void *this, void *p) { return 0; }
static int VCALLCONV nop_pp_i(void *this, void *p1, void *p2) { return 0; }
static int VCALLCONV nop_5pi_i(void *this, void *p1, void *p2, void *p3,
		void *p4, void *p5, int i) { return 0; }
static void VCALLCONV nop_ipipp_v(void *this, int i1, void *p1, int i2,
		void *p2, void *p3) {}

// more source spaghetti wow!
static void VCALLCONV SetCommandClient(void *this, int i) { con_cmdclient = i; }

// this is where we start dynamically adding virtual functions, see vtable[]
// array below
static const void **vtable_firstdiff;
static const void *const *const plugin_obj;

static bool already_loaded = false, skip_unload = false;

// auto-update message. see below in do_featureinit()
static const char *updatenotes = "\
* More behind-the-scenes changes, as always\n\
";

#include <featureinit.gen.h> // generated by build/codegen.c

static void do_featureinit(void) {
	engineapi_lateinit();
	// load libs that might not be there early (...at least on Linux???)
	clientlib = os_dlhandle(OS_LIT("client") OS_LIT(OS_DLSUFFIX));
	if_cold (!clientlib) {
		errmsg_warndl("couldn't get the game's client library");
	}
	else if_cold (!(factory_client = (ifacefactory)os_dlsym(clientlib,
			"CreateInterface"))) {
		errmsg_warndl("couldn't get client's CreateInterface");
	}
	void *inputsystemlib = os_dlhandle(OS_LIT("bin/") OS_LIT("inputsystem")
			OS_LIT(OS_DLSUFFIX));
	if_cold (!inputsystemlib) {
		errmsg_warndl("couldn't get the input system library");
	}
	else if_cold (!(factory_inputsystem = (ifacefactory)os_dlsym(inputsystemlib,
			"CreateInterface"))) {
		errmsg_warndl("couldn't get input system's CreateInterface");
	}
	else if_cold (!(inputsystem = factory_inputsystem(
			"InputSystemVersion001", 0))) {
		errmsg_warnx("missing input system interface");
	}
	// ... and now for the real magic!
	initfeatures();

	// if we're autoloaded and the external autoupdate script downloaded a new
	// version, let the user know about the cool new stuff!
	if_cold (getenv("SST_UPDATED")) {
		// avoid displaying again if we're unloaded and reloaded in one session
#ifdef _WIN32
		SetEnvironmentVariableA("SST_UPDATED", 0);
#else
		unsetenv("SST_UPDATED");
#endif
		struct rgba gold = {255, 210, 0, 255};
		struct rgba white = {255, 255, 255, 255};
		con_colourmsg(&white, "\n" NAME " was just ");
		con_colourmsg(&gold, "UPDATED");
		con_colourmsg(&white, " to version ");
		con_colourmsg(&gold, "%s", VERSION);
		con_colourmsg(&white, "!\n\nNew in this version:\n%s\n", updatenotes);
	}
}

typedef void (*VCALLCONV VGuiConnect_func)(void *this);
static VGuiConnect_func orig_VGuiConnect;
static void VCALLCONV hook_VGuiConnect(void *this) {
	orig_VGuiConnect(this);
	do_featureinit();
	fixes_apply();
	unhook_vtable(*(void ***)vgui, vtidx_VGuiConnect, (void *)orig_VGuiConnect);
}

DECL_VFUNC_DYN(bool, VGuiIsInitialized)

// --- Magical deferred load order hack nonsense! ---
// VDF plugins load right after server.dll, but long before most other stuff. We
// want to be able to load via VDF so archived cvars in config.cfg can get set,
// but don't want to be so early that most of the game's interfaces haven't been
// brought up yet. Hook CEngineVGui::Connect(), which is called very late in
// startup, in order to init the features properly.
//
// Route credit to bill for helping figure a lot of this out - mike
static bool deferinit(void) {
	if_cold (!vgui) {
		errmsg_warnx("can't use VEngineVGui for deferred feature setup");
		goto e;
	}
	// Arbitrary check to infer whether we've been early- or late-loaded.
	// We used to just see whether gameui.dll/libgameui.so was loaded, but
	// Portal 2 does away with the separate gameui library, so now we just call
	// CEngineVGui::IsInitialized() which works everywhere.
	if (VGuiIsInitialized(vgui)) return false;
	sst_earlyloaded = true; // let other code know
	if_cold (!os_mprot(*(void ***)vgui + vtidx_VGuiConnect, ssizeof(void *),
			PAGE_READWRITE)) {
		errmsg_warnsys("couldn't make CEngineVGui vtable writable for deferred "
				"feature setup");
		goto e;
	}
	orig_VGuiConnect = (VGuiConnect_func)hook_vtable(*(void ***)vgui,
			vtidx_VGuiConnect, (void *)&hook_VGuiConnect);
	return true;

e:	con_warn("!!! SOME FEATURES MAY BE BROKEN !!!\n");
	// Lesser of two evils: just init features now. Unlikely to happen anyway.
	return false;
}

DEF_PREDICATE(AllowPluginLoading, bool)
DEF_EVENT(PluginLoaded, void)
DEF_EVENT(PluginUnloaded, void)

static struct con_cmd *cmd_plugin_load, *cmd_plugin_unload;
static con_cmdcb orig_plugin_load_cb, orig_plugin_unload_cb;

static int ownidx; // XXX: super hacky way of getting this to do_unload()

static bool ispluginv1(const struct CPlugin *plugin) {
	// basename string is set with strncmp(), so if there's null bytes with more
	// stuff after, we can't be looking at a v2 struct. and we expect null bytes
	// in ifacever, since it's a small int value
	return (plugin->v2.basename[0] == 0 || plugin->v2.basename[0] == 1) &&
			plugin->v1.theplugin && plugin->v1.ifacever < 256 &&
			plugin->v1.ifacever;
}

static void hook_plugin_load_cb(const struct con_cmdargs *args) {
	if (args->argc == 1) return;
	if (!CHECK_AllowPluginLoading(true)) return;
	orig_plugin_load_cb(args);
	EMIT_PluginLoaded();
}
static void hook_plugin_unload_cb(const struct con_cmdargs *args) {
	if (args->argc == 1) return;
	if (!CHECK_AllowPluginLoading(false)) return;
	int idx = atoi(args->argv[1]);
	struct CPlugin **plugins = pluginhandler->plugins.m.mem;
	if_hot (idx >= 0 && idx < pluginhandler->plugins.sz) {
		const struct CPlugin *plugin = plugins[idx];
		// XXX: *could* memoise the ispluginv1 call, but... meh. effort.
		const struct CPlugin_common *common = ispluginv1(plugin) ?
				&plugin->v1: &plugin->v2.common;
		if (common->theplugin == &plugin_obj) {
			sst_userunloaded = true;
			ownidx = idx;
		}
#ifdef __clang__
		// thanks clang for forcing use of return here and THEN warning about it
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpedantic"
		__attribute__((musttail)) return orig_plugin_unload_cb(args);
#pragma clang diagnostic pop
#else
#error We are tied to clang without an assembly solution for this!
#endif
	}
	// if it's some other plugin being unloaded, we can keep doing stuff after
	orig_plugin_unload_cb(args);
	EMIT_PluginUnloaded();
}

static bool do_load(ifacefactory enginef, ifacefactory serverf) {
	if_cold (!hook_init()) {
		errmsg_warnsys("couldn't set up memory for function hooking");
		return false;
	}
	factory_engine = enginef; factory_server = serverf;
	if_cold (!engineapi_init(ifacever)) return false;
	const void **p = vtable_firstdiff;
	if (GAMETYPE_MATCHES(Portal2)) *p++ = (void *)&nop_p_v; // ClientFullyConnect
	*p++ = (void *)&nop_p_v;		  // ClientDisconnect
	*p++ = (void *)&nop_pp_v;		  // ClientPutInServer
	*p++ = (void *)&SetCommandClient; // SetCommandClient
	*p++ = (void *)&nop_p_v;		  // ClientSettingsChanged
	*p++ = (void *)&nop_5pi_i;		  // ClientConnect
	*p++ = ifacever > 1 ? (void *)&nop_pp_i : (void *)&nop_p_i; // ClientCommand
	// remaining stuff here is backwards compatible, so added unconditionally
	*p++ = (void *)&nop_pp_i;		  // NetworkIDValidated
	*p++ = (void *)&nop_ipipp_v;	  // OnQueryCvarValueFinished (002+)
	*p++ = (void *)&nop_p_v;		  // OnEdictAllocated
	*p   = (void *)&nop_p_v;		  // OnEdictFreed
	if (!deferinit()) { do_featureinit(); fixes_apply(); }
	if_hot (pluginhandler) {
		cmd_plugin_load = con_findcmd("plugin_load");
		orig_plugin_load_cb = cmd_plugin_load->cb;
		cmd_plugin_load->cb = &hook_plugin_load_cb;
		cmd_plugin_unload = con_findcmd("plugin_unload");
		orig_plugin_unload_cb = cmd_plugin_unload->cb;
		cmd_plugin_unload->cb = &hook_plugin_unload_cb;
	}
	return true;
}

static void do_unload(void) {
	// slow path: reloading shouldn't happen all the time, prioritise fast exit
	if_cold (sst_userunloaded) { // note: if we're here, pluginhandler is set
		cmd_plugin_load->cb = orig_plugin_load_cb;
		cmd_plugin_unload->cb = orig_plugin_unload_cb;
#ifdef _WIN32 // this bit is only relevant in builds that predate linux support
		struct CPlugin **plugins = pluginhandler->plugins.m.mem;
		// see comment in CPlugin struct. setting this to the real handle right
		// before the engine tries to unload us allows it to actually do so. in
		// newer branches this is redundant but doesn't do any harm so it's just
		// unconditional (for v1). NOTE: old engines ALSO just leak the handle
		// and never call Unload() if Load() fails; can't really do anything
		// about that.
		struct CPlugin *plugin = plugins[ownidx];
		if (ispluginv1(plugin)) plugins[ownidx]->v1.module = ownhandle();
#endif
	}
	endfeatures();
	con_disconnect();
}

static bool VCALLCONV Load(void *this, ifacefactory enginef,
		ifacefactory serverf) {
	if_cold (already_loaded) {
		con_warn("Already loaded! Doing nothing!\n");
		skip_unload = true;
		return false;
	}
	already_loaded = do_load(enginef, serverf);
	skip_unload = !already_loaded;
	return already_loaded;
}

static void VCALLCONV Unload(void *this) {
	// the game tries to unload on a failed load, for some reason
	if_cold (skip_unload) { skip_unload = false; return; }
	do_unload();
}

static void VCALLCONV Pause(void *this) {
	con_warn(NAME " doesn't support plugin_pause - ignoring\n");
}
static void VCALLCONV UnPause(void *this) {
	con_warn(NAME " doesn't support plugin_unpause - ignoring\n");
}

static const char *VCALLCONV GetPluginDescription(void *this) {
	return LONGNAME " v" VERSION;
}

DEF_EVENT(ClientActive, struct edict */*player*/)
DEF_EVENT(Tick, bool /*simulating*/)

// Quick and easy server tick event. Eventually, we might want a deeper hook
// for anything timing-sensitive, but this will do for our current needs.
static void VCALLCONV GameFrame(void *this, bool simulating) {
	EMIT_Tick(simulating);
}

static void VCALLCONV ClientActive(void *this, struct edict *player) {
	EMIT_ClientActive(player);
}

#define MAX_VTABLE_FUNCS 21
static const void *vtable[MAX_VTABLE_FUNCS] = {
	// start off with the members which (thankfully...) are totally stable
	// between interface versions - the *remaining* members get filled in just
	// in time by do_load() once we've figured out what engine branch we're on
	(void *)&Load,
	(void *)&Unload,
	(void *)&Pause,
	(void *)&UnPause,
	(void *)&GetPluginDescription,
	(void *)&nop_p_v,	// LevelInit
	(void *)&nop_pii_v,	// ServerActivate
	(void *)&GameFrame,
	(void *)&nop_v_v,	// LevelShutdown
	(void *)&ClientActive
	// At this point, Alien Swarm and Portal 2 add ClientFullyConnect, so we
	// can't hardcode any more of the layout!
};
// end MUST point AFTER the last of the above entries
static const void **vtable_firstdiff = vtable + 10;
// this is equivalent to a class with no members!
static const void *const *const plugin_obj = vtable;

export const void *CreateInterface(const char *name, int *ret) {
	if_hot (!strncmp(name, "ISERVERPLUGINCALLBACKS00", 24)) {
		if_hot (name[24] >= '1' && name[24] <= '3' && name[25] == '\0') {
			if (ret) *ret = 0;
			ifacever = name[24] - '0';
			return &plugin_obj;
		}
	}
	if (ret) *ret = 1;
	return 0;
}

// no better place to put this lol
#include <evglue.gen.h> // generated by src/build/codegen.c

// vi: sw=4 ts=4 noet tw=80 cc=80