-
Notifications
You must be signed in to change notification settings - Fork 106
/
y_hooks_impl.inc
1449 lines (1352 loc) · 47.9 KB
/
y_hooks_impl.inc
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
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
Legal:
Version: MPL 1.1
The contents of this file are subject to the Mozilla Public License Version
1.1 the "License"; you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
for the specific language governing rights and limitations under the
License.
The Original Code is the YSI framework.
The Initial Developer of the Original Code is Alex "Y_Less" Cole.
Portions created by the Initial Developer are Copyright C 2011
the Initial Developer. All Rights Reserved.
Contributors:
Y_Less
koolk
JoeBullet/Google63
g_aSlice/Slice
Misiur
samphunter
tianmeta
maddinat0r
spacemud
Crayder
Dayvison
Ahmad45123
Zeex
irinel1996
Yiin-
Chaprnks
Konstantinos
Masterchen09
Southclaws
PatchwerkQWER
m0k1
paulommu
udan111
Thanks:
JoeBullet/Google63 - Handy arbitrary ASM jump code using SCTRL.
ZeeX - Very productive conversations.
koolk - IsPlayerinAreaEx code.
TheAlpha - Danish translation.
breadfish - German translation.
Fireburn - Dutch translation.
yom - French translation.
50p - Polish translation.
Zamaroht - Spanish translation.
Los - Portuguese translation.
Dracoblue, sintax, mabako, Xtreme, other coders - Producing other modes for
me to strive to better.
Pixels^ - Running XScripters where the idea was born.
Matite - Pestering me to release it and using it.
Very special thanks to:
Thiadmer - PAWN, whose limits continue to amaze me!
Kye/Kalcor - SA:MP.
SA:MP Team past, present and future - SA:MP.
Optional plugins:
Gamer_Z - GPS.
Incognito - Streamer.
Me - sscanf2, fixes2, Whirlpool.
*/
/*
ad88888ba
d8" "8b ,d
Y8, 88
`Y8aaaaa, ,adPPYba, MM88MMM 88 88 8b,dPPYba,
`"""""8b, a8P_____88 88 88 88 88P' "8a
`8b 8PP""""""" 88 88 88 88 d8
Y8a a8P "8b, ,aa 88, "8a, ,a88 88b, ,a8"
"Y88888P" `"Ybbd8"' "Y888 `"YbbdP'Y8 88`YbbdP"'
88
88
*/
enum E_CHAIN_HOOK
{
E_CHAIN_HOOK_NAME[16],
E_CHAIN_HOOK_VALUE
}
DEFINE_HOOK_RETURN__(OnPlayerCommandText, 0);
DEFINE_HOOK_RETURN__(OnRconCommand, 0);
// Create the default replacements.
DEFINE_HOOK_REPLACEMENT__(Checkpoint, CP );
DEFINE_HOOK_REPLACEMENT__(Container , Cnt);
DEFINE_HOOK_REPLACEMENT__(Inventory , Inv);
DEFINE_HOOK_REPLACEMENT__(Dynamic , Dyn);
DEFINE_HOOK_REPLACEMENT__(TextDraw , TD );
DEFINE_HOOK_REPLACEMENT__(Update , Upd);
DEFINE_HOOK_REPLACEMENT__(Object , Obj);
DEFINE_HOOK_REPLACEMENT__(Command , Cmd);
// SPECIAL HACK! The streamer plugin already shortens "Checkpoint" to "CP", without this line
// y_hooks will try to expand it again to `OnPlayerEnterDynamicCheckpoint`, which is a valid
// callback name, but the wrong one. Thus we prevent the final expansion with this seemingly
// pointless replacement. This is an internal detail you don't really need to worry about.
DEFINE_HOOK_REPLACEMENT__(DynamicCP , DynamicCP);
enum E_HOOK_NAME_REPLACEMENT_DATA
{
E_HOOK_NAME_REPLACEMENT_SHORT[16],
E_HOOK_NAME_REPLACEMENT_LONG[16],
E_HOOK_NAME_REPLACEMENT_MIN,
E_HOOK_NAME_REPLACEMENT_MAX
}
static stock
YSI_g_sReplacements[MAX_HOOK_REPLACEMENTS][E_HOOK_NAME_REPLACEMENT_DATA],
YSI_g_sReplacementsLongOrder[MAX_HOOK_REPLACEMENTS],
YSI_g_sReplacementsShortOrder[MAX_HOOK_REPLACEMENTS],
YSI_g_sReplacePtr = 0,
YSI_g_sInitFSPtr = 0,
YSI_g_sInitFSIdx = -1,
YSI_g_sInitFSRep = 0,
YSI_g_sInitGMPtr = 0,
YSI_g_sInitGMIdx = -1,
YSI_g_sInitGMRep = 0,
YSI_g_sInitPublicDiff = 0,
YSI_g_sActiveHooks = 0,
bool:YSI_g_sSortedOnce = false;
/*-------------------------------------------------------------------------*//**
* <param name="name">Function name to modify.</param>
* <remarks>
* Expands all name parts like "CP" and "Obj" to their full versions (in this
* example "Checkpoint" and "Object").
* </remarks>
*//*------------------------------------------------------------------------**/
stock Hooks_MakeLongName(name[64])
{
new
end = 0,
i = 0,
pos = -1,
idx = YSI_g_sReplacementsShortOrder[0];
while (i != YSI_g_sReplacePtr)
{
// Allow for multiple replacements of the same string.
if ((pos = strfind(name, YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_SHORT], false, pos + 1)) == -1)
{
++i,
idx = YSI_g_sReplacementsShortOrder[i];
}
// This assumes CamelCase. If the letter immediately following the end
// of the string is lower-case, then the short word found is not a
// complete word and should not be replaced.
else if ('a' <= name[(end = pos + YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_MIN])] <= 'z')
continue;
else
{
P:5("Found hook name replacement: %d, %s", pos, YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_SHORT]);
// Found a complete word according to CamelCase rules.
strdel(name, pos + 1, end),
name[pos] = 0x80000000 | idx;
}
}
// All the replacements have been found and marked. Now actually insert.
// If "end" is "0", it means that it was never assigned to within the loop
// above, which means that no replacements were found.
if (end)
{
// "pos" must be "-1" at the start of this loop.
while (name[++pos])
{
P:7("Hooks_MakeLongName main loop: [%d] = 0x%04x%04x \"%s\"", pos, name[pos] >>> 16, name[pos] & 0xFFFF, name);
if (name[pos] < '\0')
{
// Negative number instead of a character. Used to indicate
// where a replacement should be inserted. They are not done
// inline in the loop above because some replacements may be
// contained within others - we don't want those to be both done
// within each other.
P:5("Inserting hook name replacement: %d, %s", pos, YSI_g_sReplacements[name[pos] & ~0x80000000][E_HOOK_NAME_REPLACEMENT_LONG]);
P:6("Current character: 0x%04x%04x", name[pos] >>> 16, name[pos] & 0xFFFF);
// It took me ages to find a bug in this code. For some reason,
// "strins" was packing the result. This was because the value
// in "name[pos]" was not a real character, so was seen as an
// indication that the string was packed. I fixed it by moving
// the assignment to "name[pos]" above "strins". So while the
// two lines look independent, they aren't!
i = name[pos] & ~0x80000000,
name[pos] = YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_LONG];
// Use the original "strins" - we know this string is not
// packed, but it might sometimes look like it is. The "fixed"
// version is designed for working with packed strings, but thus
// breaks on not packed strings that just look packed.
#if defined BAD_strins
BAD_strins
#else
strins
#endif
(name, YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_LONG + E_HOOK_NAME_REPLACEMENT_DATA:1], pos + 1);
pos += YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_MAX] - 1;
P:6("New string: %s", name);
}
}
}
// It is possible for the expansions to become TOO big.
return Hooks_MakeShortName(name);
}
/*-------------------------------------------------------------------------*//**
* <param name="name">Function name to modify.</param>
* <remarks>
* Compresses function names when required to fit within 32 characters
* according to well defined rules (see "YSI_g_sReplacements").
* </remarks>
*//*------------------------------------------------------------------------**/
stock Hooks_MakeShortName(name[64])
{
// Easy one.
new
len = 0,
pos = -1,
idx = YSI_g_sReplacementsLongOrder[0];
for (new i = 0; (len = strlen(name)) >= 32 && i != YSI_g_sReplacePtr; )
{
if ((pos = strfind(name, YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_LONG], false, pos + 1)) == -1)
{
++i,
idx = YSI_g_sReplacementsLongOrder[i];
}
else
{
strdel(name, pos, pos + YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_MAX]),
strins(name, YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_SHORT], pos);
}
}
return len;
}
/*-------------------------------------------------------------------------*//**
* <param name="name">The string to get the hooked function name from.</param>
* <returns>
* The input string without y_hooks name decorations.
* </returns>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC Hooks_IsolateName(string:name[])
{
P:4("Hooks_IsolateName called");
new
pos = strfind(name, "@", false, 4);
// Make "pos" a legal value inside the error message.
if (pos == -1) P:E("Invalid hook name: %s", unpack(name), ++pos);
name[pos] = '\0',
strdel(name, 0, 4);
}
/*-------------------------------------------------------------------------*//**
* <param name="preloads">Desination in which to store all the preloads.</param>
* <param name="precount">Number of found preload libraries.</param>
* <param name="size">Maximum number of libraries to store.</param>
* <remarks>
* Some includes, like "fixes.inc" and anti-cheats MUST come before all other
* includes in order for everything to function correctly (at least fixes.inc
* must). This function looks for these definitions:
*
* PRE_HOOK(FIXES)
*
* Which tell y_hooks that any "FIXES_" prefixed callbacks are part of one of
* these chains.
* </remarks>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC stock Hooks_GetPreloadLibraries(preloads[][E_CHAIN_HOOK], &precount, size = sizeof (preloads))
{
P:4("Hooks_GetPreloadLibraries called");
--size,
precount = 0;
new
entry = 0,
idx = 0;
{
new
name[32 char],
addr = 0;
while ((idx = AMX_GetPublicEntryPrefix(idx, entry, _A<@CO_>)))
{
if (precount == size)
{
P:E("y_hooks prehook array filled");
break;
}
addr = AMX_Read(entry);
AMX_ReadString(AMX_Read(entry + 4) + AMX_BASE_ADDRESS + 4, name),
strunpack(preloads[precount][E_CHAIN_HOOK_NAME], name, 16),
preloads[precount][E_CHAIN_HOOK_VALUE] = CallFunction(addr),
++precount;
if (strlen(name) > 15)
P:E("Overflow in prehook name \"%s\"", unpack(name));
// {
// new buffer[32];
// strunpack(buffer, name);
// printf("preload: %s", buffer);
// }
// Remove this public from the publics table. Means that future public
// function calls will be faster by having a smaller search space.
Hooks_InvalidateName(entry);
}
}
// Sort the preload libraries.
{
new
tmp[E_CHAIN_HOOK];
for (entry = precount - 1; entry > 0; --entry)
{
for (idx = 0; idx != entry; ++idx)
{
if (preloads[idx][E_CHAIN_HOOK_VALUE] > preloads[idx + 1][E_CHAIN_HOOK_VALUE])
{
tmp = preloads[idx],
preloads[idx] = preloads[idx + 1],
preloads[idx + 1] = tmp;
}
}
}
}
}
/*-------------------------------------------------------------------------*//**
* <param name="preloads">Names of libraries that come before y_hooks.</param>
* <param name="precount">Number of pre libraries.</param>
* <param name="name">Name of the callback.</param>
* <param name="hooks">Destination in which to store the headers.</param>
* <param name="count">Number of headers found.</param>
* <remarks>
* Finds all the AMX file headers for functions with a similar name to the
* given callback that should be called before (or near) the given callback.
* </remarks>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC stock Hooks_GetPreHooks(const preloads[][E_CHAIN_HOOK], precount, const name[64], hooks[], &count)
{
P:4("Hooks_GetPreHooks called");
new
idx = 0,
lfunc[64];
// Collect all the functions with something like this name.
P:2("Hooks_GetPreHooks start: %s", unpack(name));
do
{
strcat(lfunc, name),
Hooks_MakeShortName(lfunc);
P:5("Hooks_GetPreHooks: search = %s", unpack(lfunc));
P:C(new oc = count;);
if (AMX_GetPublicEntry(0, hooks[count], lfunc, true)) ++count;
P:C(if (oc != count) { new buffer[32]; AMX_ReadString(AMX_Read(hooks[count] + 4) + AMX_BASE_ADDRESS, buffer); P:5("Hooks_GetPreHooks: found = %s", unpack(buffer)); });
strcpy(lfunc, preloads[idx][E_CHAIN_HOOK_NAME]),
strcat(lfunc, "_");
}
while (++idx <= precount);
}
/*-------------------------------------------------------------------------*//**
* <param name="hooks">All the prehooks for this callback.</param>
* <param name="num">The number of prehooks.</param>
* <param name="ptr">A pointer to write the new stub address to.</param>
* <param name="next">The pointer for the function called after y_hooks.</param>
* <param name="name">The name of the callback being processed.</param>
* <param name="nlen">Space available in the header to write text in.</param>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC stock Hooks_GetPointerRewrite(const hooks[], num, &ptr, &next, const name[], nlen)
{
P:4("Hooks_GetPointerRewrite called");
P:5("Hooks_GetPointerRewrite: (%s), num: %d, hoks: %08x, %08x, %08x, %08x", name, num, AMX_Read(hooks[0]), AMX_Read(hooks[1]), AMX_Read(hooks[2]), AMX_Read(hooks[3]));
switch (num)
{
case 0:
{
next = 0;
new
len = strlen(name);
if (nlen >= len)
{
// We don't have an existing callback with this name, only hooks.
// We need to add the name of the callback to the AMX header,
// and we have enough space in which to do so.
new
str[32];
strpack(str, name),
AMX_WriteString(AMX_BASE_ADDRESS + AMX_Read(ptr + 4), str, len);
}
else
{
P:F("Could not write function name in \"Hooks_MakePublicPointer\".");
// TODO: Fix this. Use an alternate memory location (the actual
// code segment in which we are writing seems like a good
// choice).
}
}
case 1:
{
// No "fixes.inc", but this callback already exists. In that case,
// just replace the pointer address.
next = ptr = hooks[0];
}
default:
{
// Special hooks. Optimise them.
for (new cur = 1; cur != num; ++cur)
{
ptr = hooks[cur];
new
tmp = AMX_Read(ptr),
nt = Hooks_GetStubEntry(tmp);
tmp += AMX_HEADER_COD,
AMX_Write(tmp, _:RelocateOpcode(OP_JUMP));
switch (nt)
{
case -1: ptr = tmp + 4, next = 0;
case 0: next = 0;
default:
{
ptr = tmp + 4,
next = tmp + nt,
nt = AMX_Read(next),
// Chain those not hooked.
AMX_Write(ptr, nt),
// Store the possible next address.
AMX_Write(next, nt - (AMX_REAL_DATA + AMX_HEADER_COD));
}
}
}
}
}
}
/*-------------------------------------------------------------------------*//**
* <param name="stub">Starting address of the function.</param>
* <returns>
* The address at which the actual code in this function starts.
* </returns>
* <remarks>
* This handles three cases. Regular functions end instantly as found.
* Functions that start with a switch (even before "PROC") are assumed to be
* state-based functions, and we find the most likely state to be used (i.e. we
* remove all future state changes).
* </remarks>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC stock Hooks_GetStubEntry(stub)
{
P:4("Hooks_GetStubEntry called");
// Get the address of the next function from the ALS state stub.
new
ctx[DisasmContext];
DisasmInit(ctx, stub, stub + 64);
switch (DisasmNextInsn(ctx))
{
case OP_LOAD_PRI:
{
if (DisasmNextInsn(ctx) == OP_SWITCH && DisasmNextInsn(ctx) == OP_CASETBL)
{
// Get the number of items in the casetable.
if (DisasmGetNumOperands(ctx) == 3) // 2 means no used hook.
{
// Got a hook to return. Find it.
new
h0 = DisasmGetOperand(ctx, 3),
h1 = DisasmGetOperand(ctx, 5),
h2 = DisasmGetOperand(ctx, 7);
if (h1 == h2) return 8 * 4; // Most likely.
else if (h0 == h2) return 10 * 4;
else if (h0 == h1) return 12 * 4;
else P:E("y_hooks could not extract state stub jump");
}
else return -1;
}
}
case OP_JUMP:
{
// Already replaced once (shouldn't happen, but may if two different
// hooks use two different short versions of a callback).
return 4; // DisasmGetOperand(ctx, 0);
}
case OP_PROC:
{
//return stub;
P:E("y_hooks attempting to redirect a PROC hook");
}
}
return 0;
}
/*-------------------------------------------------------------------------*//**
* <param name="name">The name of the callback (with y_hooks prefix).</param>
* <param name="hooks">Array in which to store the function headers.</param>
* <param name="idx">Current position in the AMX header.</param>
* <param name="namelen">Min bound of space used by all these names.</param>
* <returns>
* The number of hooks found.
* </returns>
* <remarks>
* The name of the function currently being processed is derived from the first
* found hook. This means we already know of one hook, but to simplify the
* code we get that one again here. Above we only know the name not the
* address. Hence the "- 1" in "i = idx - 1" (to go back one function name).
*
* Our "namelen" variable already contains the full length of the first found
* hook - this is the length of "name", plus N extra characters. The following
* are all valid, and may occur when orders are played with:
*
* @yH_OnX@
* @yH_OnX@1
* @yH_OnX@01
* @yH_OnX@024
* @yH_OnX@ZZZ
* @yH_OnX@999@024
*
* If we want to get the EXACT space taken up by all these hook names we would
* need to get the string of the name in this function then measure it. There
* is really no point in doing this - if we have a second we will always have
* enough space for our new names. Instead, we assume that they are all just
*
* @yH_OnX@
*
* And add on that minimum length accordingly (plus 1 for the NULL character).
*
* This length is used if the original callback doesn't exist but hooks do. In
* that case we need to add the callback to the AMX header, and there is a tiny
* chance that the original name will be longer than one hook's name. In that
* case, having two or more hooks will (AFAIK) always ensure that we have
* enough space to write the longer name.
*
* If there is only one hook, no original function, and the name of the hook is
* shorter than the name of the original function then we have an issue and
* will have to do something else instead.
* </remarks>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC stock Hooks_GetAllHooks(const name[], hooks[], idx, &namelen, size = sizeof (hooks))
{
P:4("Hooks_GetAllHooks called: %s %d", name, idx);
// Start from the very start - repeats the first item.
new
len = strlen(name) + 1,
count = 0,
tmpName[64];
while ((idx = AMX_GetPublicEntryPrefix(idx, hooks[count], _A<@yH_>)))
{
AMX_GetStringFromEntry(hooks[count], tmpName),
len = strlen(tmpName),
strunpack(tmpName, tmpName),
Hooks_IsolateName(tmpName),
Hooks_MakeLongName(tmpName);
// Check if the fully expanded name is the name.
P:6("Hooks_GetAllHooks found: %s ?= %s %d", name, tmpName, idx);
if (!strcmp(tmpName, name))
{
Hooks_InvalidateName(hooks[count]);
// Record how much consecutive space we have to play with in the
// AMX. I'm slightly concerned that this code assumes that the
// hooks are all consecutive, when they might not be thanks to
// replacements.
if (count) namelen += len; // The first hook was already counted.
// Increment and count how many hooks of this type we have.
if (++count == size)
{
P:W("Hooks_GetAllHooks: Potential overflow." "\n" \
"\n" \
" `MAX_Y_HOOKS` is currently `%d`, recompile with a higher value for more hooks of a single callback:" "\n" \
"\n" \
" #define MAX_Y_HOOKS (%d)" "\n" \
"\n" \
, MAX_Y_HOOKS, MAX_Y_HOOKS * 2);
break;
}
}
}
return count;
}
_Y_HOOKS_STATIC stock Hooks_DoAllHooks()
{
P:4("Hooks_DoAllHooks called");
// Get the preloaders.
new
precount = 0,
preloads[32][E_CHAIN_HOOK];
Hooks_GetPreloadLibraries(preloads, precount);
// Main loop
new
name[32],
idx = 0;
// Get the next hook type.
while ((idx = AMX_GetPublicNamePrefix(idx, name, _A<@yH_>)))
{
// Collect all the hooks of this function, and rewrite the call code.
Hooks_Collate(preloads, precount, name, idx - 1);
}
}
_Y_HOOKS_STATIC stock Hooks_Collate(const preloads[][E_CHAIN_HOOK], precount, const name[32], idx)
{
P:4("Hooks_Collate called: %s %d", unpack(name), idx);
// This records the amount of space available in the nametable, currently
// taken up by the names of hooks that we are about to destroy.
new
namelen = strlen(name);
// For this function, note that:
//
// hook OnPlayerConnect(playerid)
//
// Compiles as:
//
// public @yH_OnPlayerConnect@XXX(playerid)
//
// Where "XXX" is some unique number (the exact value is irrelevant, it just
// means that multiple hooks of the same function have different names).
static
sName[64],
sHooks[MAX_Y_HOOKS];
// The above now becomes:
//
// OnPlayerConnect
//
// This also handles cases such as:
//
// @yH_OnPlayerEnterRaceCheckpoint@162
//
// Being invalid (too long), so instead converts the shortened:
//
// @yH_OnPlayerEnterRaceCP@162
//
// To:
//
// OnPlayerEnterRaceCheckpoint
//
// Thus expanding common name length reductions.
strunpack(sName, name),
Hooks_IsolateName(sName),
Hooks_MakeLongName(sName);
new
// Get all the hooks of this type. They are stored alphabetically.
hookCount = Hooks_GetAllHooks(sName, sHooks, idx, namelen),
writePtr = sHooks[0], // Header for the first found hook.
nextPtr = 0,
pc = 0,
ph[16];
// Get the preloads.
Hooks_GetPreHooks(preloads, precount, sName, ph, pc),
// Get where in the chain we are being inserted.
Hooks_GetPointerRewrite(ph, pc, writePtr, nextPtr, sName, namelen);
// Add ALS hooks to the end of the list.
if ((sHooks[hookCount] = nextPtr)) ++hookCount;
// Write the code.
Hooks_GenerateCode(sName, sHooks, hookCount, writePtr, pc > 1);
}
/*-------------------------------------------------------------------------*//**
* <param name="name">Name of the function to generate.</param>
* <param name="hooks">All the functions to call.</param>
* <param name="count">Number of functions to call.</param>
* <param name="write">Where to write the new function's pointer.</param>
* <param name="hasprehooks">Needs to call other stuff first.</param>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC Hooks_GenerateCode(const name[64], const hooks[], count, write, bool:hasprehooks)
{
P:4("Hooks_GenerateCode called");
// We now have:
//
// 1) All the hooks of this function.
// 2) The original function if it exists.
// 3) Special ALS chained functions if they exists.
//
// This took huge chunks of complex code in the old version. Now not so
// much! I don't know if this code is faster (I suspect it is), but it is
// absolutely simpler!
new
size = Hooks_WriteFunction(hooks, count, Hooks_GetDefaultReturn(name));
P:4("Hooks_GenerateCode %32s called: %6d %6d %08x %d", name[4], hasprehooks, size, hasprehooks ? (write - AMX_HEADER_COD) : (write - AMX_BASE_ADDRESS), CGen_GetCodeSpace());
if (size)
{
//AMX_Write(write, 40);
if (hasprehooks) AMX_Write(write, CGen_GetCodeSpace() + AMX_REAL_DATA);
else AMX_Write(write, CGen_GetCodeSpace() - AMX_HEADER_COD);
CGen_AddCodeSpace(size);
}
else
{
if (hasprehooks) AMX_Write(write, AMX_Read(hooks[0]) + (AMX_REAL_DATA + AMX_HEADER_COD));
else AMX_Write(write, AMX_Read(hooks[0]));
}
}
/*-------------------------------------------------------------------------*//**
* <param name="entry">The public function slot to destroy.</param>
* <remarks>
* Basically, once we know a function has been included, wipe it from the AMX
* header.
* </remarks>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC Hooks_InvalidateName(entry)
{
P:4("Hooks_InvalidateName called");
AMX_Write(AMX_BASE_ADDRESS + AMX_Read(entry + 4), 0);
}
/*
88888888888 88 88 ad88
88 ,d "" 88 d8"
88 88 88 88
88aaaaa 88 88 8b,dPPYba, ,adPPYba, MM88MMM 88 ,adPPYba, 8b,dPPYba, 88 8b,dPPYba, MM88MMM ,adPPYba,
88""""" 88 88 88P' `"8a a8" "" 88 88 a8" "8a 88P' `"8a 88 88P' `"8a 88 a8" "8a
88 88 88 88 88 8b 88 88 8b d8 88 88 88 88 88 88 8b d8
88 "8a, ,a88 88 88 "8a, ,aa 88, 88 "8a, ,a8" 88 88 88 88 88 88 "8a, ,a8"
88 `"YbbdP'Y8 88 88 `"Ybbd8"' "Y888 88 `"YbbdP"' 88 88 88 88 88 88 `"YbbdP"'
*/
/*-------------------------------------------------------------------------*//**
* <param name="name">The function to get the address pointer of.</param>
* <param name="write">Destination variable.</param>
* <returns>
* The address at which this function's pointer is stored in the AMX header, if
* the function exists of course.
* </returns>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC stock Hooks_GetFunctionWritePoint(const name[], &write)
{
P:4("Hooks_GetFunctionWritePoint called");
AMX_GetPublicEntry(0, write, name, true);
}
/*-------------------------------------------------------------------------*//**
* <param name="name">The function to get the default return of.</param>
* <returns>
* The default return for a callback, normally 1.
* </returns>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC stock Hooks_GetDefaultReturn(const name[64])
{
P:4("Hooks_GetDefaultReturn called");
new
dest[64] = "@y_H";
strcat(dest, name);
Hooks_MakeShortName(dest);
new
ptr = 0;
if (AMX_GetPublicEntry(0, ptr, dest, true))
{
// A "RET_OnWhatever" function exists - rationalise the return.
return CallFunction(AMX_Read(ptr)) ? 1 : 0;
}
return 1;
}
/*
,ad8888ba, 88
d8"' `"8b 88
d8' 88
88 ,adPPYba, ,adPPYb,88 ,adPPYba, ,adPPYb,d8 ,adPPYba, 8b,dPPYba,
88 a8" "8a a8" `Y88 a8P_____88 a8" `Y88 a8P_____88 88P' `"8a
Y8, 8b d8 8b 88 8PP""""""" 8b 88 8PP""""""" 88 88
Y8a. .a8P "8a, ,a8" "8a, ,d88 "8b, ,aa "8a, ,d88 "8b, ,aa 88 88
`"Y8888Y"' `"YbbdP"' `"8bbdP"Y8 `"Ybbd8"' `"YbbdP"Y8 `"Ybbd8"' 88 88
aa, ,88
"Y8bbdP"
*/
/*-------------------------------------------------------------------------*//**
* <param name="pointers">The hooks to link together.</param>
* <param name="size">The number of functions in the array.</param>
* <param name="ret">The default return.</param>
* <param name="skipable">Can future hooks be ignored on -1?</param>
* <returns>
* The number of bytes written to memory.
* </returns>
* <remarks>
* Generate some new code, very nicely :D.
* </remarks>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC Hooks_WriteFunction(const pointers[], const size, const ret = 1, const skipable = true)
{
P:4("Hooks_WriteFunction called");
if (size == 0)
{
P:E("Hooks_WriteFunction: size is 0");
return 0;
}
new
bool:multiple = size != 1,
base = (AMX_HEADER_COD - AMX_BASE_ADDRESS) + AMX_REAL_ADDRESS,
ctx[AsmContext];
// Make sure the underlying system doesn't change without us. Now supported
// natively.
CGen_UseCodeSpace(ctx);
// Start of the function.
@emit PROC // 1
// Allocate space for our "ret" variable at "frm - 4" (may be unused).
@emit PUSH.C ret // 3
// Create the current active hooks stack at "frm - 8".
@emit PUSH ref(YSI_g_sActiveHooks) // 5
@emit ADDR.pri -8 // 7
@emit STOR.pri ref(YSI_g_sActiveHooks) // 9
// Copy the stack to itself (MOVS).
// Allocate space.
@emit LOAD.S.pri 8 // 11
@emit JZER.label Hooks_NoStackCopy // 13
@emit MOVE.alt // 14
@emit LCTRL 4 // 16
@emit SUB // 17
@emit SCTRL 4 // 19
@emit XCHG // 20
if (Server_JITExists())
{
// Need to use memcpy to move about in the stack.
@emit PUSH.C 4096
@emit PUSH.pri
@emit PUSH.C 0
@emit LCTRL 5
@emit ADD.C 12
@emit PUSH.pri
@emit PUSH.alt
@emit PUSH.C 20
@emit SYSREQ "memcpy"
@emit STACK 24
}
else
{
// The "MOVS" OpCode only takes a constant, not a variable, so we need
// to generate self-modifying code (just to be UBER meta)! This code is
// generated AFTER the file is loaded so we bypass the data segment
// checks and can freely write wherever we want.
@emit STOR.pri (CGen_GetCodeSpace() + (27 * 4)) // 22
// Do the copying. "alt" is already "STK", load the "FRM" offset.
@emit LCTRL 5 // 24
@emit ADD.C 12 // 26
// This is the instruction we want to modify...
@emit MOVS 0 // 28 (- 1) = 27 (see above).
}
@emit Hooks_NoStackCopy:
// Push the (fake) number of parameters.
@emit PUSH.C -4
// Now loop over all our functions and insert "CALL" opcodes for them.
if (multiple)
{
for (new i = 0; ; )
{
// Get the absolute offset from here.
@emit CALL (AMX_Read(pointers[i]) + base) // 2
if (skipable)
{
// =====================================
// THIS SECTION IS CURRENTLY 10 CELLS.
// =====================================
// Note: Including the original call...
//
// if (func() < 0) break;
// else ret = ret & func();
//
@emit ZERO.alt // 3
@emit JSLESS.label Hooks_EndCall // 5
// =========================
// JUMP OVER THIS SECTION.
// =========================
}
@emit LOAD.S.alt -4 // 7
if (ret) @emit AND // 8
else @emit OR // 8
// Loop and do the very first items last.
if (++i == size) break;
else @emit STOR.S.pri -4 // 10
}
if (skipable)
{
@emit JUMP.label Hooks_SkipInvert // 10
// This is the point the large "JSLESS" above goes to.
// -1 = 0, -2 = 1
@emit Hooks_EndCall:
@emit INVERT
}
}
else if (skipable)
{
// Still need this code as they may hook a function that doesn't exist,
// but we still need to correctly process -1 or -2.
@emit CALL (AMX_Read(pointers[0]) + base)
@emit ZERO.alt
@emit JSGEQ.label Hooks_SkipInvert
@emit INVERT
}
else
{
// Just replace the original (turns out, this takes no code). Basically
// just discard everything we've written so far (reclaims the memory).
return 0;
}
@emit Hooks_SkipInvert:
// This is the point the small "JUMP" above goes to.
@emit MOVE.alt
// Pop from the active hooks stack.
@emit LOAD.S.pri -8
@emit STOR.pri ref(YSI_g_sActiveHooks)
// Remove the whole stack then get the return value.
@emit LCTRL 5
@emit SCTRL 4
@emit MOVE.pri
// Return.
@emit RETN
// Return the number of bytes written.
return ctx[AsmContext_buffer_offset];
}
/*
ad88888ba 88
d8" "8b ,d ""
Y8, 88
`Y8aaaaa, ,adPPYba, 8b,dPPYba, MM88MMM 88 8b,dPPYba, ,adPPYb,d8
`"""""8b, a8" "8a 88P' "Y8 88 88 88P' `"8a a8" `Y88
`8b 8b d8 88 88 88 88 88 8b 88
Y8a a8P "8a, ,a8" 88 88, 88 88 88 "8a, ,d88
"Y88888P" `"YbbdP"' 88 "Y888 88 88 88 `"YbbdP"Y8
aa, ,88
"Y8bbdP"
*/
/*-------------------------------------------------------------------------*//**
* <param name="addr0">The 1st address to read.</param>
* <param name="addr1">The 2nd address to read.</param>
* <returns>
* -1 - The first address is bigger.
* 0 - The addresses are the same
* 1 - The second address is bigger.
* </returns>
* <remarks>
* Reads two addresses, converts them to big endian, and compares them as four
* characters of a string at once.
* </remarks>
*//*------------------------------------------------------------------------**/
_Y_HOOKS_STATIC Hooks_CompareNextCell(addr0, addr1)
{
// P:4("Hooks_CompareNextCell called");
new
s0 = Cell_ReverseBytes(AMX_Read(addr0)),
s1 = Cell_ReverseBytes(AMX_Read(addr1));
// Propogate NULLs.
if (!(s0 & 0xFF000000)) s0 = 0;
else if (!(s0 & 0x00FF0000)) s0 &= 0xFF000000;
else if (!(s0 & 0x0000FF00)) s0 &= 0xFFFF0000;
else if (!(s0 & 0x000000FF)) s0 &= 0xFFFFFF00;
if (!(s1 & 0xFF000000)) s1 = 0;
else if (!(s1 & 0x00FF0000)) s1 &= 0xFF000000;
else if (!(s1 & 0x0000FF00)) s1 &= 0xFFFF0000;
else if (!(s1 & 0x000000FF)) s1 &= 0xFFFFFF00;
// We need the numbers to be compared as big-endian. Now any trailing NULLs
// don't matter at all.
if (s1 > s0) return 1;
else if (s1 < s0) return -1;
else return 0;
}
/*-------------------------------------------------------------------------*//**
* <param name="idx0">The index of the 1st public.</param>
* <param name="idx1">The index of the 2nd public.</param>
* <remarks>
* Compares two public function entries, and if need-be, swaps them over.