funzione codice macchina x86-64, 53 48 byte
changelog:
- -2
jz rispetto al turno invece di utilizzare un turno a 64 bit per gestire il >>(32-0)caso speciale.
- -3 ritorna in ZF invece di AL, risparmiando 3 byte per a
setnz al .
(Vedi anche la risposta del codice macchina a 32 bit di Daniel Schepler basata su questo, che poi si è evoluto per usare alcune altre idee che avevamo. Sto includendo la mia ultima versione di quella in fondo a questa risposta.)
Restituisce ZF = 0 per l'host no nella sottorete, ZF = 1 per nella sottorete, quindi puoi diramare il risultato conje host_matches_subnet
Callable con la convenzione di chiamata System V x86-64 come
bool not_in_subnet(int dummy_rdi, const char *input_rsi); se si aggiungesse setnz al.
La stringa di input contiene sia l'host che la rete, separati da esattamente 1 carattere non cifra. La memoria che segue la fine della larghezza CIDR deve contenere almeno 3 byte senza cifre prima della fine di una pagina. (Non dovrebbe essere un problema nella maggior parte dei casi, come per un cmdline arg.) La versione a 32 bit di Daniel non ha questa limitazione.
Eseguiamo lo stesso ciclo di analisi tratteggiato quad-quadruplo 3 volte, ottenendo i due indirizzi IPv4 e ottenendo il /masknumero intero nel byte alto di una parola. (Questo è il motivo per cui ci deve essere una memoria leggibile dopo il /mask, ma non importa se ci sono cifre ASCII.)
Facciamo (host ^ subnet) >> (32-mask)spostare i bit dell'host (quelli a cui non è possibile corrispondere), lasciando solo la differenza tra la sottorete e l'host. Per risolvere il /0caso speciale in cui dobbiamo spostare di 32, saltiamo sopra lo spostamento conteggio = 0. ( neg climposta ZF, che possiamo ramificare e lasciare come valore di ritorno se non spostiamo.) Notate che 32-mask mod 32 = -mask, e gli spostamenti scalari x86 mascherano il loro conteggio di & 31o & 63.
line addr machine NASM source. (from nasm -felf64 -l/dev/stdout)
num code bytes
1 %use smartalign
2
3 ;10.4.1.33 10.4.0.0/23 true
4 ;10.4.1.33 10.4.0.0/24 false
5
6 ;; /codegolf/185005/im-in-your-subnets-golfing-your-code
7 %ifidn __OUTPUT_FORMAT__, elf64
8 in_subnet:
9
10 00000000 6A03 push 3
11 00000002 5F pop rdi ; edi = 3 dotted-quads to parse, sort of.
12 .parseloop:
13
14 ;xor ebx,ebx ; doesn't need to be zeroed first; we end up shifting out the original contents
15 ;lea ecx, [rbx+4]
16 00000003 6A04 push 4
17 00000005 59 pop rcx ; rcx = 4 integers in a dotted-quad
18 .quadloop:
19
20 00000006 31D2 xor edx,edx ; standard edx=atoi(rdi) loop terminated by a non-digit char
21 00000008 EB05 jmp .digit_entry
22 .digitloop:
23 0000000A 6BD20A imul edx, 10
24 0000000D 00C2 add dl, al
25 .digit_entry:
26 0000000F AC lodsb
27 00000010 2C30 sub al, '0'
28 00000012 3C09 cmp al, 9
29 00000014 76F4 jbe .digitloop
30 ; al=non-digit character - '0'
31 ; RDI pointing to the next character.
32 ; EDX = integer
33
34 00000016 C1E308 shl ebx, 8
35 00000019 88D3 mov bl, dl ; build a quad 1 byte at a time, ending with the lowest byte
36 0000001B E2E9 loop .quadloop
37
38 0000001D 53 push rbx ; push result to be collected after parsing 3 times
39 0000001E FFCF dec edi
40 00000020 75E1 jnz .parseloop
41
42 00000022 59 pop rcx ; /mask (at the top of a dword)
43 00000023 5A pop rdx ; subnet
44 00000024 58 pop rax ; host
45 00000025 0FC9 bswap ecx ; cl=network bits (reusing the quad parse loop left it in the high byte)
49 00000027 F6D9 neg cl
50 00000029 7404 jz .all_net ; skip the count=32 special case
51
52 0000002B 31D0 xor eax, edx ; host ^ subnet
53 0000002D D3E8 shr eax, cl ; shift out the host bits, keeping only the diff of subnet bits
54
55 .all_net:
56 ; setnz al ; return ZF=1 match, ZF=0 not in subnet
57 0000002F C3 ret
58 00000030 30 .size: db $ - in_subnet
0x30 = 48 bytes
(non aggiornato con l'ultima versione)
Provalo online!
tra cui un _startche lo chiama argv[1]e restituisce uno stato di uscita.
## on my desktop
$ ./ipv4-subnet "10.4.1.33 10.4.0.0/24" && echo "$? : in subnet" || echo "$? : not in subnet"
not in subnet
$ ./ipv4-subnet "10.4.1.33 10.4.0.0/23" && echo "$? : in subnet" || echo "$? : not in subnet"
in subnet
Funziona bene se si passa un arg della riga di comando contenente una nuova riga anziché uno spazio. Ma deve essere invece , non pure.
x86 Funzione codice macchina a 32 bit, 38 byte
Esegui 9 numeri interi -> uint8_t analizza e "inseriscili" nello stack, dove li espelliamo come password o utilizziamo l'ultimo ancora in CL. Evita di leggere oltre la fine della stringa.
Inoltre, decè solo 1 byte in modalità 32 bit.
72 in_subnet:
73 00000000 89E7 mov edi, esp
74 00000002 51 push ecx
75 00000003 51 push ecx ; sub esp,8
76 .byteloop:
77
78 00000004 31C9 xor ecx,ecx ; standard ecx=atoi(rdi) loop terminated by a non-digit char
79 ; runs 9 times: 8 in two dotted-quads, 1 mask length
80 00000006 EB05 jmp .digit_entry
81 .digitloop:
82 00000008 6BC90A imul ecx, 10
83 0000000B 00C1 add cl, al
84 .digit_entry:
85 0000000D AC lodsb
86 0000000E 2C30 sub al, '0'
87 00000010 3C09 cmp al, 9
88 00000012 76F4 jbe .digitloop
89 ; RDI pointing to the next character.
90 ; EDX = integer
91
92 00000014 4F dec edi
93 00000015 880F mov [edi], cl ; /mask store goes below ESP but we don't reload it
94 00000017 39E7 cmp edi, esp
95 00000019 73E9 jae .byteloop
96
97 ;; CL = /mask still there from the last conversion
98 ;; ESP pointing at subnet and host on the stack, EDI = ESP-1
99
100 0000001B 5A pop edx ; subnet
101 0000001C 58 pop eax ; host
102
103 0000001D 31D0 xor eax, edx ; host ^ subnet
104 0000001F F6D9 neg cl ; -mask = (32-mask) mod 32; x86 shifts mask their count
105 00000021 7402 jz .end ; 32-n = 32 special case
106 00000023 D3E8 shr eax, cl
107 .end:
108 ; setz al ; just return in ZF
109 00000025 C3 ret
110 00000026 26 .size: db $ - in_subnet
0x26 = 38 bytes
Prova il chiamante
113 global _start
114 _start:
115 00000027 8B742408 mov esi, [esp+8] ; argv[1]
116 0000002B E8D0FFFFFF call in_subnet
117 00000030 0F95C3 setnz bl
118 00000033 B801000000 mov eax, 1 ; _exit syscall
119 00000038 CD80 int 0x80