1 /* $FreeBSD: stable/9/contrib/ipfilter/iplang/iplang_y.y 170268 2007-06-04 02:54:36Z darrenr $ */
2
3 %{
4 /*
5 * Copyright (C) 1997-1998 by Darren Reed.
6 *
7 * See the IPFILTER.LICENCE file for details on licencing.
8 *
9 * Id: iplang_y.y,v 2.9.2.4 2006/03/17 12:11:29 darrenr Exp $
10 * $FreeBSD: stable/9/contrib/ipfilter/iplang/iplang_y.y 170268 2007-06-04 02:54:36Z darrenr $
11 */
12
13 #include <stdio.h>
14 #include <string.h>
15 #include <fcntl.h>
16 #if !defined(__SVR4) && !defined(__svr4__)
17 # include <strings.h>
18 #else
19 # include <sys/byteorder.h>
20 #endif
21 #include <sys/types.h>
22 #include <sys/stat.h>
23 #include <sys/param.h>
24 #include <sys/time.h>
25 #include <stdlib.h>
26 #include <unistd.h>
27 #include <stddef.h>
28 #include <sys/socket.h>
29 #include <netinet/in.h>
30 #include <netinet/in_systm.h>
31 #include <netinet/ip.h>
32 #ifndef linux
33 # include <netinet/ip_var.h>
34 #endif
35 #ifdef __osf__
36 # include "radix_ipf_local.h"
37 #endif
38 #include <net/if.h>
39 #ifndef linux
40 # include <netinet/if_ether.h>
41 #endif
42 #include <netdb.h>
43 #include <arpa/nameser.h>
44 #include <arpa/inet.h>
45 #include <resolv.h>
46 #include <ctype.h>
47 #include "ipsend.h"
48 #include "ip_compat.h"
49 #include "ipf.h"
50 #include "iplang.h"
51
52 #if !defined(__NetBSD__) && (!defined(__FreeBSD_version) && \
53 __FreeBSD_version < 400020) && (!SOLARIS || SOLARIS2 < 10)
54 extern struct ether_addr *ether_aton __P((char *));
55 #endif
56
57 extern int opts;
58 extern struct ipopt_names ionames[];
59 extern int state, state, lineNum, token;
60 extern int yylineno;
61 extern char yytext[];
62 extern FILE *yyin;
63 int yylex __P((void));
64 #define YYDEBUG 1
65 #if !defined(ultrix) && !defined(hpux)
66 int yydebug = 1;
67 #else
68 extern int yydebug;
69 #endif
70
71 iface_t *iflist = NULL, **iftail = &iflist;
72 iface_t *cifp = NULL;
73 arp_t *arplist = NULL, **arptail = &arplist, *carp = NULL;
74 struct in_addr defrouter;
75 send_t sending;
76 char *sclass = NULL;
77 u_short c_chksum __P((u_short *, u_int, u_long));
78 u_long p_chksum __P((u_short *, u_int));
79
80 u_long ipbuffer[67584/sizeof(u_long)]; /* 66K */
81 aniphdr_t *aniphead = NULL, *canip = NULL, **aniptail = &aniphead;
82 ip_t *ip = NULL;
83 udphdr_t *udp = NULL;
84 tcphdr_t *tcp = NULL;
85 icmphdr_t *icmp = NULL;
86
87 struct statetoopt {
88 int sto_st;
89 int sto_op;
90 };
91
92 struct in_addr getipv4addr __P((char *arg));
93 u_short getportnum __P((char *, char *));
94 struct ether_addr *geteaddr __P((char *, struct ether_addr *));
95 void *new_header __P((int));
96 void free_aniplist __P((void));
97 void inc_anipheaders __P((int));
98 void new_data __P((void));
99 void set_datalen __P((char **));
100 void set_datafile __P((char **));
101 void set_data __P((char **));
102 void new_packet __P((void));
103 void set_ipv4proto __P((char **));
104 void set_ipv4src __P((char **));
105 void set_ipv4dst __P((char **));
106 void set_ipv4off __P((char **));
107 void set_ipv4v __P((char **));
108 void set_ipv4hl __P((char **));
109 void set_ipv4ttl __P((char **));
110 void set_ipv4tos __P((char **));
111 void set_ipv4id __P((char **));
112 void set_ipv4sum __P((char **));
113 void set_ipv4len __P((char **));
114 void new_tcpheader __P((void));
115 void set_tcpsport __P((char **));
116 void set_tcpdport __P((char **));
117 void set_tcpseq __P((char **));
118 void set_tcpack __P((char **));
119 void set_tcpoff __P((char **));
120 void set_tcpurp __P((char **));
121 void set_tcpwin __P((char **));
122 void set_tcpsum __P((char **));
123 void set_tcpflags __P((char **));
124 void set_tcpopt __P((int, char **));
125 void end_tcpopt __P((void));
126 void new_udpheader __P((void));
127 void set_udplen __P((char **));
128 void set_udpsum __P((char **));
129 void prep_packet __P((void));
130 void packet_done __P((void));
131 void new_interface __P((void));
132 void check_interface __P((void));
133 void set_ifname __P((char **));
134 void set_ifmtu __P((int));
135 void set_ifv4addr __P((char **));
136 void set_ifeaddr __P((char **));
137 void new_arp __P((void));
138 void set_arpeaddr __P((char **));
139 void set_arpv4addr __P((char **));
140 void reset_send __P((void));
141 void set_sendif __P((char **));
142 void set_sendvia __P((char **));
143 void set_defaultrouter __P((char **));
144 void new_icmpheader __P((void));
145 void set_icmpcode __P((int));
146 void set_icmptype __P((int));
147 void set_icmpcodetok __P((char **));
148 void set_icmptypetok __P((char **));
149 void set_icmpid __P((int));
150 void set_icmpseq __P((int));
151 void set_icmpotime __P((int));
152 void set_icmprtime __P((int));
153 void set_icmpttime __P((int));
154 void set_icmpmtu __P((int));
155 void set_redir __P((int, char **));
156 void new_ipv4opt __P((void));
157 void set_icmppprob __P((int));
158 void add_ipopt __P((int, void *));
159 void end_ipopt __P((void));
160 void set_secclass __P((char **));
161 void free_anipheader __P((void));
162 void end_ipv4 __P((void));
163 void end_icmp __P((void));
164 void end_udp __P((void));
165 void end_tcp __P((void));
166 void end_data __P((void));
167 void yyerror __P((char *));
168 void iplang __P((FILE *));
169 int arp_getipv4 __P((char *, char *));
170 int yyparse __P((void));
171 %}
172 %union {
173 char *str;
174 int num;
175 }
176 %token <num> IL_NUMBER
177 %type <num> number digits optnumber
178 %token <str> IL_TOKEN
179 %type <str> token optoken
180 %token IL_HEXDIGIT IL_COLON IL_DOT IL_EOF IL_COMMENT
181 %token IL_INTERFACE IL_IFNAME IL_MTU IL_EADDR
182 %token IL_IPV4 IL_V4PROTO IL_V4SRC IL_V4DST IL_V4OFF IL_V4V IL_V4HL IL_V4TTL
183 %token IL_V4TOS IL_V4SUM IL_V4LEN IL_V4OPT IL_V4ID
184 %token IL_TCP IL_SPORT IL_DPORT IL_TCPFL IL_TCPSEQ IL_TCPACK IL_TCPOFF
185 %token IL_TCPWIN IL_TCPSUM IL_TCPURP IL_TCPOPT IL_TCPO_NOP IL_TCPO_EOL
186 %token IL_TCPO_MSS IL_TCPO_WSCALE IL_TCPO_TS
187 %token IL_UDP IL_UDPLEN IL_UDPSUM
188 %token IL_ICMP IL_ICMPTYPE IL_ICMPCODE
189 %token IL_SEND IL_VIA
190 %token IL_ARP
191 %token IL_DEFROUTER
192 %token IL_SUM IL_OFF IL_LEN IL_V4ADDR IL_OPT
193 %token IL_DATA IL_DLEN IL_DVALUE IL_DFILE
194 %token IL_IPO_NOP IL_IPO_RR IL_IPO_ZSU IL_IPO_MTUP IL_IPO_MTUR IL_IPO_EOL
195 %token IL_IPO_TS IL_IPO_TR IL_IPO_SEC IL_IPO_LSRR IL_IPO_ESEC
196 %token IL_IPO_SATID IL_IPO_SSRR IL_IPO_ADDEXT IL_IPO_VISA IL_IPO_IMITD
197 %token IL_IPO_EIP IL_IPO_FINN IL_IPO_SECCLASS IL_IPO_CIPSO IL_IPO_ENCODE
198 %token <str> IL_IPS_RESERV4 IL_IPS_TOPSECRET IL_IPS_SECRET IL_IPS_RESERV3
199 %token <str> IL_IPS_CONFID IL_IPS_UNCLASS IL_IPS_RESERV2 IL_IPS_RESERV1
200 %token IL_ICMP_ECHOREPLY IL_ICMP_UNREACH IL_ICMP_UNREACH_NET
201 %token IL_ICMP_UNREACH_HOST IL_ICMP_UNREACH_PROTOCOL IL_ICMP_UNREACH_PORT
202 %token IL_ICMP_UNREACH_NEEDFRAG IL_ICMP_UNREACH_SRCFAIL
203 %token IL_ICMP_UNREACH_NET_UNKNOWN IL_ICMP_UNREACH_HOST_UNKNOWN
204 %token IL_ICMP_UNREACH_ISOLATED IL_ICMP_UNREACH_NET_PROHIB
205 %token IL_ICMP_UNREACH_HOST_PROHIB IL_ICMP_UNREACH_TOSNET
206 %token IL_ICMP_UNREACH_TOSHOST IL_ICMP_UNREACH_FILTER_PROHIB
207 %token IL_ICMP_UNREACH_HOST_PRECEDENCE IL_ICMP_UNREACH_PRECEDENCE_CUTOFF
208 %token IL_ICMP_SOURCEQUENCH IL_ICMP_REDIRECT IL_ICMP_REDIRECT_NET
209 %token IL_ICMP_REDIRECT_HOST IL_ICMP_REDIRECT_TOSNET
210 %token IL_ICMP_REDIRECT_TOSHOST IL_ICMP_ECHO IL_ICMP_ROUTERADVERT
211 %token IL_ICMP_ROUTERSOLICIT IL_ICMP_TIMXCEED IL_ICMP_TIMXCEED_INTRANS
212 %token IL_ICMP_TIMXCEED_REASS IL_ICMP_PARAMPROB IL_ICMP_PARAMPROB_OPTABSENT
213 %token IL_ICMP_TSTAMP IL_ICMP_TSTAMPREPLY IL_ICMP_IREQ IL_ICMP_IREQREPLY
214 %token IL_ICMP_MASKREQ IL_ICMP_MASKREPLY IL_ICMP_SEQ IL_ICMP_ID
215 %token IL_ICMP_OTIME IL_ICMP_RTIME IL_ICMP_TTIME
216
217 %%
218 file: line
219 | line file
220 | IL_COMMENT
221 | IL_COMMENT file
222 ;
223
224 line: iface
225 | arp
226 | send
227 | defrouter
228 | ipline
229 ;
230
231 iface: ifhdr '{' ifaceopts '}' ';' { check_interface(); }
232 ;
233
234 ifhdr: IL_INTERFACE { new_interface(); }
235 ;
236
237 ifaceopts:
238 ifaceopt
239 | ifaceopt ifaceopts
240 ;
241
242 ifaceopt:
243 IL_IFNAME token { set_ifname(&$2); }
244 | IL_MTU number { set_ifmtu($2); }
245 | IL_V4ADDR token { set_ifv4addr(&$2); }
246 | IL_EADDR token { set_ifeaddr(&$2); }
247 ;
248
249 send: sendhdr '{' sendbody '}' ';' { packet_done(); }
250 | sendhdr ';' { packet_done(); }
251 ;
252
253 sendhdr:
254 IL_SEND { reset_send(); }
255 ;
256
257 sendbody:
258 sendopt
259 | sendbody sendopt
260 ;
261
262 sendopt:
263 IL_IFNAME token { set_sendif(&$2); }
264 | IL_VIA token { set_sendvia(&$2); }
265 ;
266
267 arp: arphdr '{' arpbody '}' ';'
268 ;
269
270 arphdr: IL_ARP { new_arp(); }
271 ;
272
273 arpbody:
274 arpopt
275 | arpbody arpopt
276 ;
277
278 arpopt: IL_V4ADDR token { set_arpv4addr(&$2); }
279 | IL_EADDR token { set_arpeaddr(&$2); }
280 ;
281
282 defrouter:
283 IL_DEFROUTER token { set_defaultrouter(&$2); }
284 ;
285
286 bodyline:
287 ipline
288 | tcp tcpline
289 | udp udpline
290 | icmp icmpline
291 | data dataline
292 ;
293
294 ipline: ipv4 '{' ipv4body '}' ';' { end_ipv4(); }
295 ;
296
297 ipv4: IL_IPV4 { new_packet(); }
298
299 ipv4body:
300 ipv4type
301 | ipv4type ipv4body
302 | bodyline
303 ;
304
305 ipv4type:
306 IL_V4PROTO token { set_ipv4proto(&$2); }
307 | IL_V4SRC token { set_ipv4src(&$2); }
308 | IL_V4DST token { set_ipv4dst(&$2); }
309 | IL_V4OFF token { set_ipv4off(&$2); }
310 | IL_V4V token { set_ipv4v(&$2); }
311 | IL_V4HL token { set_ipv4hl(&$2); }
312 | IL_V4ID token { set_ipv4id(&$2); }
313 | IL_V4TTL token { set_ipv4ttl(&$2); }
314 | IL_V4TOS token { set_ipv4tos(&$2); }
315 | IL_V4SUM token { set_ipv4sum(&$2); }
316 | IL_V4LEN token { set_ipv4len(&$2); }
317 | ipv4opt '{' ipv4optlist '}' ';' { end_ipopt(); }
318 ;
319
320 tcp: IL_TCP { new_tcpheader(); }
321 ;
322
323 tcpline:
324 '{' tcpheader '}' ';' { end_tcp(); }
325 ;
326
327 tcpheader:
328 tcpbody
329 | tcpbody tcpheader
330 | bodyline
331 ;
332
333 tcpbody:
334 IL_SPORT token { set_tcpsport(&$2); }
335 | IL_DPORT token { set_tcpdport(&$2); }
336 | IL_TCPSEQ token { set_tcpseq(&$2); }
337 | IL_TCPACK token { set_tcpack(&$2); }
338 | IL_TCPOFF token { set_tcpoff(&$2); }
339 | IL_TCPURP token { set_tcpurp(&$2); }
340 | IL_TCPWIN token { set_tcpwin(&$2); }
341 | IL_TCPSUM token { set_tcpsum(&$2); }
342 | IL_TCPFL token { set_tcpflags(&$2); }
343 | IL_TCPOPT '{' tcpopts '}' ';' { end_tcpopt(); }
344 ;
345
346 tcpopts:
347 | tcpopt tcpopts
348 ;
349
350 tcpopt: IL_TCPO_NOP ';' { set_tcpopt(IL_TCPO_NOP, NULL); }
351 | IL_TCPO_EOL ';' { set_tcpopt(IL_TCPO_EOL, NULL); }
352 | IL_TCPO_MSS optoken { set_tcpopt(IL_TCPO_MSS,&$2);}
353 | IL_TCPO_WSCALE optoken { set_tcpopt(IL_TCPO_WSCALE,&$2);}
354 | IL_TCPO_TS optoken { set_tcpopt(IL_TCPO_TS, &$2);}
355 ;
356
357 udp: IL_UDP { new_udpheader(); }
358 ;
359
360 udpline:
361 '{' udpheader '}' ';' { end_udp(); }
362 ;
363
364
365 udpheader:
366 udpbody
367 | udpbody udpheader
368 | bodyline
369 ;
370
371 udpbody:
372 IL_SPORT token { set_tcpsport(&$2); }
373 | IL_DPORT token { set_tcpdport(&$2); }
374 | IL_UDPLEN token { set_udplen(&$2); }
375 | IL_UDPSUM token { set_udpsum(&$2); }
376 ;
377
378 icmp: IL_ICMP { new_icmpheader(); }
379 ;
380
381 icmpline:
382 '{' icmpbody '}' ';' { end_icmp(); }
383 ;
384
385 icmpbody:
386 icmpheader
387 | icmpheader bodyline
388 ;
389
390 icmpheader:
391 IL_ICMPTYPE icmptype
392 | IL_ICMPTYPE icmptype icmpcode
393 ;
394
395 icmpcode:
396 IL_ICMPCODE token { set_icmpcodetok(&$2); }
397 ;
398
399 icmptype:
400 IL_ICMP_ECHOREPLY ';' { set_icmptype(ICMP_ECHOREPLY); }
401 | IL_ICMP_ECHOREPLY '{' icmpechoopts '}' ';'
402 | unreach
403 | IL_ICMP_SOURCEQUENCH ';' { set_icmptype(ICMP_SOURCEQUENCH); }
404 | redirect
405 | IL_ICMP_ROUTERADVERT ';' { set_icmptype(ICMP_ROUTERADVERT); }
406 | IL_ICMP_ROUTERSOLICIT ';' { set_icmptype(ICMP_ROUTERSOLICIT); }
407 | IL_ICMP_ECHO ';' { set_icmptype(ICMP_ECHO); }
408 | IL_ICMP_ECHO '{' icmpechoopts '}' ';'
409 | IL_ICMP_TIMXCEED ';' { set_icmptype(ICMP_TIMXCEED); }
410 | IL_ICMP_TIMXCEED '{' exceed '}' ';'
411 | IL_ICMP_TSTAMP ';' { set_icmptype(ICMP_TSTAMP); }
412 | IL_ICMP_TSTAMPREPLY ';' { set_icmptype(ICMP_TSTAMPREPLY); }
413 | IL_ICMP_TSTAMPREPLY '{' icmptsopts '}' ';'
414 | IL_ICMP_IREQ ';' { set_icmptype(ICMP_IREQ); }
415 | IL_ICMP_IREQREPLY ';' { set_icmptype(ICMP_IREQREPLY); }
416 | IL_ICMP_IREQREPLY '{' data dataline '}' ';'
417 | IL_ICMP_MASKREQ ';' { set_icmptype(ICMP_MASKREQ); }
418 | IL_ICMP_MASKREPLY ';' { set_icmptype(ICMP_MASKREPLY); }
419 | IL_ICMP_MASKREPLY '{' token '}' ';'
420 | IL_ICMP_PARAMPROB ';' { set_icmptype(ICMP_PARAMPROB); }
421 | IL_ICMP_PARAMPROB '{' paramprob '}' ';'
422 | IL_TOKEN ';' { set_icmptypetok(&$1); }
423 ;
424
425 icmpechoopts:
426 | icmpechoopts icmpecho
427 ;
428
429 icmpecho:
430 IL_ICMP_SEQ number { set_icmpseq($2); }
431 | IL_ICMP_ID number { set_icmpid($2); }
432 ;
433
434 icmptsopts:
435 | icmptsopts icmpts ';'
436 ;
437
438 icmpts: IL_ICMP_OTIME number { set_icmpotime($2); }
439 | IL_ICMP_RTIME number { set_icmprtime($2); }
440 | IL_ICMP_TTIME number { set_icmpttime($2); }
441 ;
442
443 unreach:
444 IL_ICMP_UNREACH
445 | IL_ICMP_UNREACH '{' unreachopts '}' ';'
446 ;
447
448 unreachopts:
449 IL_ICMP_UNREACH_NET line
450 | IL_ICMP_UNREACH_HOST line
451 | IL_ICMP_UNREACH_PROTOCOL line
452 | IL_ICMP_UNREACH_PORT line
453 | IL_ICMP_UNREACH_NEEDFRAG number ';' { set_icmpmtu($2); }
454 | IL_ICMP_UNREACH_SRCFAIL line
455 | IL_ICMP_UNREACH_NET_UNKNOWN line
456 | IL_ICMP_UNREACH_HOST_UNKNOWN line
457 | IL_ICMP_UNREACH_ISOLATED line
458 | IL_ICMP_UNREACH_NET_PROHIB line
459 | IL_ICMP_UNREACH_HOST_PROHIB line
460 | IL_ICMP_UNREACH_TOSNET line
461 | IL_ICMP_UNREACH_TOSHOST line
462 | IL_ICMP_UNREACH_FILTER_PROHIB line
463 | IL_ICMP_UNREACH_HOST_PRECEDENCE line
464 | IL_ICMP_UNREACH_PRECEDENCE_CUTOFF line
465 ;
466
467 redirect:
468 IL_ICMP_REDIRECT
469 | IL_ICMP_REDIRECT '{' redirectopts '}' ';'
470 ;
471
472 redirectopts:
473 | IL_ICMP_REDIRECT_NET token { set_redir(0, &$2); }
474 | IL_ICMP_REDIRECT_HOST token { set_redir(1, &$2); }
475 | IL_ICMP_REDIRECT_TOSNET token { set_redir(2, &$2); }
476 | IL_ICMP_REDIRECT_TOSHOST token { set_redir(3, &$2); }
477 ;
478
479 exceed:
480 IL_ICMP_TIMXCEED_INTRANS line
481 | IL_ICMP_TIMXCEED_REASS line
482 ;
483
484 paramprob:
485 IL_ICMP_PARAMPROB_OPTABSENT
486 | IL_ICMP_PARAMPROB_OPTABSENT paraprobarg
487
488 paraprobarg:
489 '{' number '}' ';' { set_icmppprob($2); }
490 ;
491
492 ipv4opt: IL_V4OPT { new_ipv4opt(); }
493 ;
494
495 ipv4optlist:
496 | ipv4opts ipv4optlist
497 ;
498
499 ipv4opts:
500 IL_IPO_NOP ';' { add_ipopt(IL_IPO_NOP, NULL); }
501 | IL_IPO_RR optnumber { add_ipopt(IL_IPO_RR, &$2); }
502 | IL_IPO_ZSU ';' { add_ipopt(IL_IPO_ZSU, NULL); }
503 | IL_IPO_MTUP ';' { add_ipopt(IL_IPO_MTUP, NULL); }
504 | IL_IPO_MTUR ';' { add_ipopt(IL_IPO_MTUR, NULL); }
505 | IL_IPO_ENCODE ';' { add_ipopt(IL_IPO_ENCODE, NULL); }
506 | IL_IPO_TS ';' { add_ipopt(IL_IPO_TS, NULL); }
507 | IL_IPO_TR ';' { add_ipopt(IL_IPO_TR, NULL); }
508 | IL_IPO_SEC ';' { add_ipopt(IL_IPO_SEC, NULL); }
509 | IL_IPO_SECCLASS secclass { add_ipopt(IL_IPO_SECCLASS, sclass); }
510 | IL_IPO_LSRR token { add_ipopt(IL_IPO_LSRR,&$2); }
511 | IL_IPO_ESEC ';' { add_ipopt(IL_IPO_ESEC, NULL); }
512 | IL_IPO_CIPSO ';' { add_ipopt(IL_IPO_CIPSO, NULL); }
513 | IL_IPO_SATID optnumber { add_ipopt(IL_IPO_SATID,&$2);}
514 | IL_IPO_SSRR token { add_ipopt(IL_IPO_SSRR,&$2); }
515 | IL_IPO_ADDEXT ';' { add_ipopt(IL_IPO_ADDEXT, NULL); }
516 | IL_IPO_VISA ';' { add_ipopt(IL_IPO_VISA, NULL); }
517 | IL_IPO_IMITD ';' { add_ipopt(IL_IPO_IMITD, NULL); }
518 | IL_IPO_EIP ';' { add_ipopt(IL_IPO_EIP, NULL); }
519 | IL_IPO_FINN ';' { add_ipopt(IL_IPO_FINN, NULL); }
520 ;
521
522 secclass:
523 IL_IPS_RESERV4 ';' { set_secclass(&$1); }
524 | IL_IPS_TOPSECRET ';' { set_secclass(&$1); }
525 | IL_IPS_SECRET ';' { set_secclass(&$1); }
526 | IL_IPS_RESERV3 ';' { set_secclass(&$1); }
527 | IL_IPS_CONFID ';' { set_secclass(&$1); }
528 | IL_IPS_UNCLASS ';' { set_secclass(&$1); }
529 | IL_IPS_RESERV2 ';' { set_secclass(&$1); }
530 | IL_IPS_RESERV1 ';' { set_secclass(&$1); }
531 ;
532
533 data: IL_DATA { new_data(); }
534 ;
535
536 dataline:
537 '{' databody '}' ';' { end_data(); }
538 ;
539
540 databody: dataopts
541 | dataopts databody
542 ;
543
544 dataopts:
545 IL_DLEN token { set_datalen(&$2); }
546 | IL_DVALUE token { set_data(&$2); }
547 | IL_DFILE token { set_datafile(&$2); }
548 ;
549
550 token: IL_TOKEN ';'
551 ;
552
553 optoken: ';' { $$ = ""; }
554 | token
555 ;
556
557 number: digits ';'
558 ;
559
560 optnumber: ';' { $$ = 0; }
561 | number
562 ;
563
564 digits: IL_NUMBER
565 | digits IL_NUMBER
566 ;
567 %%
568
569 struct statetoopt toipopts[] = {
570 { IL_IPO_NOP, IPOPT_NOP },
571 { IL_IPO_RR, IPOPT_RR },
572 { IL_IPO_ZSU, IPOPT_ZSU },
573 { IL_IPO_MTUP, IPOPT_MTUP },
574 { IL_IPO_MTUR, IPOPT_MTUR },
575 { IL_IPO_ENCODE, IPOPT_ENCODE },
576 { IL_IPO_TS, IPOPT_TS },
577 { IL_IPO_TR, IPOPT_TR },
578 { IL_IPO_SEC, IPOPT_SECURITY },
579 { IL_IPO_SECCLASS, IPOPT_SECURITY },
580 { IL_IPO_LSRR, IPOPT_LSRR },
581 { IL_IPO_ESEC, IPOPT_E_SEC },
582 { IL_IPO_CIPSO, IPOPT_CIPSO },
583 { IL_IPO_SATID, IPOPT_SATID },
584 { IL_IPO_SSRR, IPOPT_SSRR },
585 { IL_IPO_ADDEXT, IPOPT_ADDEXT },
586 { IL_IPO_VISA, IPOPT_VISA },
587 { IL_IPO_IMITD, IPOPT_IMITD },
588 { IL_IPO_EIP, IPOPT_EIP },
589 { IL_IPO_FINN, IPOPT_FINN },
590 { 0, 0 }
591 };
592
593 struct statetoopt tosecopts[] = {
594 { IL_IPS_RESERV4, IPSO_CLASS_RES4 },
595 { IL_IPS_TOPSECRET, IPSO_CLASS_TOPS },
596 { IL_IPS_SECRET, IPSO_CLASS_SECR },
597 { IL_IPS_RESERV3, IPSO_CLASS_RES3 },
598 { IL_IPS_CONFID, IPSO_CLASS_CONF },
599 { IL_IPS_UNCLASS, IPSO_CLASS_UNCL },
600 { IL_IPS_RESERV2, IPSO_CLASS_RES2 },
601 { IL_IPS_RESERV1, IPSO_CLASS_RES1 },
602 { 0, 0 }
603 };
604
605 #ifdef bsdi
606 struct ether_addr *
ether_aton(s)607 ether_aton(s)
608 char *s;
609 {
610 static struct ether_addr n;
611 u_int i[6];
612
613 if (sscanf(s, " %x:%x:%x:%x:%x:%x ", &i[0], &i[1],
614 &i[2], &i[3], &i[4], &i[5]) == 6) {
615 n.ether_addr_octet[0] = (u_char)i[0];
616 n.ether_addr_octet[1] = (u_char)i[1];
617 n.ether_addr_octet[2] = (u_char)i[2];
618 n.ether_addr_octet[3] = (u_char)i[3];
619 n.ether_addr_octet[4] = (u_char)i[4];
620 n.ether_addr_octet[5] = (u_char)i[5];
621 return &n;
622 }
623 return NULL;
624 }
625 #endif
626
627
getipv4addr(arg)628 struct in_addr getipv4addr(arg)
629 char *arg;
630 {
631 struct hostent *hp;
632 struct in_addr in;
633
634 in.s_addr = 0xffffffff;
635
636 if ((hp = gethostbyname(arg)))
637 bcopy(hp->h_addr, &in.s_addr, sizeof(struct in_addr));
638 else
639 in.s_addr = inet_addr(arg);
640 return in;
641 }
642
643
getportnum(pr,name)644 u_short getportnum(pr, name)
645 char *pr, *name;
646 {
647 struct servent *sp;
648
649 if (!(sp = getservbyname(name, pr)))
650 return htons(atoi(name));
651 return sp->s_port;
652 }
653
654
geteaddr(arg,buf)655 struct ether_addr *geteaddr(arg, buf)
656 char *arg;
657 struct ether_addr *buf;
658 {
659 struct ether_addr *e;
660
661 #if !defined(hpux) && !defined(linux)
662 e = ether_aton(arg);
663 if (!e)
664 fprintf(stderr, "Invalid ethernet address: %s\n", arg);
665 else
666 # ifdef __FreeBSD__
667 bcopy(e->octet, buf->octet, sizeof(e->octet));
668 # else
669 bcopy(e->ether_addr_octet, buf->ether_addr_octet,
670 sizeof(e->ether_addr_octet));
671 # endif
672 return e;
673 #else
674 return NULL;
675 #endif
676 }
677
678
new_header(type)679 void *new_header(type)
680 int type;
681 {
682 aniphdr_t *aip, *oip = canip;
683 int sz = 0;
684
685 aip = (aniphdr_t *)calloc(1, sizeof(*aip));
686 *aniptail = aip;
687 aniptail = &aip->ah_next;
688 aip->ah_p = type;
689 aip->ah_prev = oip;
690 canip = aip;
691
692 if (type == IPPROTO_UDP)
693 sz = sizeof(udphdr_t);
694 else if (type == IPPROTO_TCP)
695 sz = sizeof(tcphdr_t);
696 else if (type == IPPROTO_ICMP)
697 sz = sizeof(icmphdr_t);
698 else if (type == IPPROTO_IP)
699 sz = sizeof(ip_t);
700
701 if (oip)
702 canip->ah_data = oip->ah_data + oip->ah_len;
703 else
704 canip->ah_data = (char *)ipbuffer;
705
706 /*
707 * Increase the size fields in all wrapping headers.
708 */
709 for (aip = aniphead; aip; aip = aip->ah_next) {
710 aip->ah_len += sz;
711 if (aip->ah_p == IPPROTO_IP)
712 aip->ah_ip->ip_len += sz;
713 else if (aip->ah_p == IPPROTO_UDP)
714 aip->ah_udp->uh_ulen += sz;
715 }
716 return (void *)canip->ah_data;
717 }
718
719
free_aniplist()720 void free_aniplist()
721 {
722 aniphdr_t *aip, **aipp = &aniphead;
723
724 while ((aip = *aipp)) {
725 *aipp = aip->ah_next;
726 free(aip);
727 }
728 aniptail = &aniphead;
729 }
730
731
inc_anipheaders(inc)732 void inc_anipheaders(inc)
733 int inc;
734 {
735 aniphdr_t *aip;
736
737 for (aip = aniphead; aip; aip = aip->ah_next) {
738 aip->ah_len += inc;
739 if (aip->ah_p == IPPROTO_IP)
740 aip->ah_ip->ip_len += inc;
741 else if (aip->ah_p == IPPROTO_UDP)
742 aip->ah_udp->uh_ulen += inc;
743 }
744 }
745
746
new_data()747 void new_data()
748 {
749 (void) new_header(-1);
750 canip->ah_len = 0;
751 }
752
753
set_datalen(arg)754 void set_datalen(arg)
755 char **arg;
756 {
757 int len;
758
759 len = strtol(*arg, NULL, 0);
760 inc_anipheaders(len);
761 free(*arg);
762 *arg = NULL;
763 }
764
765
set_data(arg)766 void set_data(arg)
767 char **arg;
768 {
769 u_char *s = (u_char *)*arg, *t = (u_char *)canip->ah_data, c;
770 int len = 0, todo = 0, quote = 0, val = 0;
771
772 while ((c = *s++)) {
773 if (todo) {
774 if (ISDIGIT(c)) {
775 todo--;
776 if (c > '7') {
777 fprintf(stderr, "octal with %c!\n", c);
778 break;
779 }
780 val <<= 3;
781 val |= (c - '0');
782 }
783 if (!ISDIGIT(c) || !todo) {
784 *t++ = (u_char)(val & 0xff);
785 todo = 0;
786 }
787 if (todo)
788 continue;
789 }
790 if (quote) {
791 if (ISDIGIT(c)) {
792 todo = 2;
793 if (c > '7') {
794 fprintf(stderr, "octal with %c!\n", c);
795 break;
796 }
797 val = (c - '0');
798 } else {
799 switch (c)
800 {
801 case '\"' :
802 *t++ = '\"';
803 break;
804 case '\\' :
805 *t++ = '\\';
806 break;
807 case 'n' :
808 *t++ = '\n';
809 break;
810 case 'r' :
811 *t++ = '\r';
812 break;
813 case 't' :
814 *t++ = '\t';
815 break;
816 }
817 }
818 quote = 0;
819 continue;
820 }
821
822 if (c == '\\')
823 quote = 1;
824 else
825 *t++ = c;
826 }
827 if (todo)
828 *t++ = (u_char)(val & 0xff);
829 if (quote)
830 *t++ = '\\';
831 len = t - (u_char *)canip->ah_data;
832 inc_anipheaders(len - canip->ah_len);
833 canip->ah_len = len;
834 }
835
836
set_datafile(arg)837 void set_datafile(arg)
838 char **arg;
839 {
840 struct stat sb;
841 char *file = *arg;
842 int fd, len;
843
844 if ((fd = open(file, O_RDONLY)) == -1) {
845 perror("open");
846 exit(-1);
847 }
848
849 if (fstat(fd, &sb) == -1) {
850 perror("fstat");
851 exit(-1);
852 }
853
854 if ((sb.st_size + aniphead->ah_len ) > 65535) {
855 fprintf(stderr, "data file %s too big to include.\n", file);
856 close(fd);
857 return;
858 }
859 if ((len = read(fd, canip->ah_data, sb.st_size)) == -1) {
860 perror("read");
861 close(fd);
862 return;
863 }
864 inc_anipheaders(len);
865 canip->ah_len += len;
866 close(fd);
867 }
868
869
new_packet()870 void new_packet()
871 {
872 static u_short id = 0;
873
874 if (!aniphead)
875 bzero((char *)ipbuffer, sizeof(ipbuffer));
876
877 ip = (ip_t *)new_header(IPPROTO_IP);
878 ip->ip_v = IPVERSION;
879 ip->ip_hl = sizeof(ip_t) >> 2;
880 ip->ip_len = sizeof(ip_t);
881 ip->ip_ttl = 63;
882 ip->ip_id = htons(id++);
883 }
884
885
set_ipv4proto(arg)886 void set_ipv4proto(arg)
887 char **arg;
888 {
889 struct protoent *pr;
890
891 if ((pr = getprotobyname(*arg)))
892 ip->ip_p = pr->p_proto;
893 else
894 if (!(ip->ip_p = atoi(*arg)))
895 fprintf(stderr, "unknown protocol %s\n", *arg);
896 free(*arg);
897 *arg = NULL;
898 }
899
900
set_ipv4src(arg)901 void set_ipv4src(arg)
902 char **arg;
903 {
904 ip->ip_src = getipv4addr(*arg);
905 free(*arg);
906 *arg = NULL;
907 }
908
909
set_ipv4dst(arg)910 void set_ipv4dst(arg)
911 char **arg;
912 {
913 ip->ip_dst = getipv4addr(*arg);
914 free(*arg);
915 *arg = NULL;
916 }
917
918
set_ipv4off(arg)919 void set_ipv4off(arg)
920 char **arg;
921 {
922 ip->ip_off = htons(strtol(*arg, NULL, 0));
923 free(*arg);
924 *arg = NULL;
925 }
926
927
set_ipv4v(arg)928 void set_ipv4v(arg)
929 char **arg;
930 {
931 ip->ip_v = strtol(*arg, NULL, 0);
932 free(*arg);
933 *arg = NULL;
934 }
935
936
set_ipv4hl(arg)937 void set_ipv4hl(arg)
938 char **arg;
939 {
940 int newhl, inc;
941
942 newhl = strtol(*arg, NULL, 0);
943 inc = (newhl - ip->ip_hl) << 2;
944 ip->ip_len += inc;
945 ip->ip_hl = newhl;
946 canip->ah_len += inc;
947 free(*arg);
948 *arg = NULL;
949 }
950
951
set_ipv4ttl(arg)952 void set_ipv4ttl(arg)
953 char **arg;
954 {
955 ip->ip_ttl = strtol(*arg, NULL, 0);
956 free(*arg);
957 *arg = NULL;
958 }
959
960
set_ipv4tos(arg)961 void set_ipv4tos(arg)
962 char **arg;
963 {
964 ip->ip_tos = strtol(*arg, NULL, 0);
965 free(*arg);
966 *arg = NULL;
967 }
968
969
set_ipv4id(arg)970 void set_ipv4id(arg)
971 char **arg;
972 {
973 ip->ip_id = htons(strtol(*arg, NULL, 0));
974 free(*arg);
975 *arg = NULL;
976 }
977
978
set_ipv4sum(arg)979 void set_ipv4sum(arg)
980 char **arg;
981 {
982 ip->ip_sum = strtol(*arg, NULL, 0);
983 free(*arg);
984 *arg = NULL;
985 }
986
987
set_ipv4len(arg)988 void set_ipv4len(arg)
989 char **arg;
990 {
991 int len;
992
993 len = strtol(*arg, NULL, 0);
994 inc_anipheaders(len - ip->ip_len);
995 ip->ip_len = len;
996 free(*arg);
997 *arg = NULL;
998 }
999
1000
new_tcpheader()1001 void new_tcpheader()
1002 {
1003
1004 if ((ip->ip_p) && (ip->ip_p != IPPROTO_TCP)) {
1005 fprintf(stderr, "protocol %d specified with TCP!\n", ip->ip_p);
1006 return;
1007 }
1008 ip->ip_p = IPPROTO_TCP;
1009
1010 tcp = (tcphdr_t *)new_header(IPPROTO_TCP);
1011 tcp->th_win = htons(4096);
1012 tcp->th_off = sizeof(*tcp) >> 2;
1013 }
1014
1015
set_tcpsport(arg)1016 void set_tcpsport(arg)
1017 char **arg;
1018 {
1019 u_short *port;
1020 char *pr;
1021
1022 if (ip->ip_p == IPPROTO_UDP) {
1023 port = &udp->uh_sport;
1024 pr = "udp";
1025 } else {
1026 port = &tcp->th_sport;
1027 pr = "udp";
1028 }
1029
1030 *port = getportnum(pr, *arg);
1031 free(*arg);
1032 *arg = NULL;
1033 }
1034
1035
set_tcpdport(arg)1036 void set_tcpdport(arg)
1037 char **arg;
1038 {
1039 u_short *port;
1040 char *pr;
1041
1042 if (ip->ip_p == IPPROTO_UDP) {
1043 port = &udp->uh_dport;
1044 pr = "udp";
1045 } else {
1046 port = &tcp->th_dport;
1047 pr = "udp";
1048 }
1049
1050 *port = getportnum(pr, *arg);
1051 free(*arg);
1052 *arg = NULL;
1053 }
1054
1055
set_tcpseq(arg)1056 void set_tcpseq(arg)
1057 char **arg;
1058 {
1059 tcp->th_seq = htonl(strtol(*arg, NULL, 0));
1060 free(*arg);
1061 *arg = NULL;
1062 }
1063
1064
set_tcpack(arg)1065 void set_tcpack(arg)
1066 char **arg;
1067 {
1068 tcp->th_ack = htonl(strtol(*arg, NULL, 0));
1069 free(*arg);
1070 *arg = NULL;
1071 }
1072
1073
set_tcpoff(arg)1074 void set_tcpoff(arg)
1075 char **arg;
1076 {
1077 int off;
1078
1079 off = strtol(*arg, NULL, 0);
1080 inc_anipheaders((off - tcp->th_off) << 2);
1081 tcp->th_off = off;
1082 free(*arg);
1083 *arg = NULL;
1084 }
1085
1086
set_tcpurp(arg)1087 void set_tcpurp(arg)
1088 char **arg;
1089 {
1090 tcp->th_urp = htons(strtol(*arg, NULL, 0));
1091 free(*arg);
1092 *arg = NULL;
1093 }
1094
1095
set_tcpwin(arg)1096 void set_tcpwin(arg)
1097 char **arg;
1098 {
1099 tcp->th_win = htons(strtol(*arg, NULL, 0));
1100 free(*arg);
1101 *arg = NULL;
1102 }
1103
1104
set_tcpsum(arg)1105 void set_tcpsum(arg)
1106 char **arg;
1107 {
1108 tcp->th_sum = strtol(*arg, NULL, 0);
1109 free(*arg);
1110 *arg = NULL;
1111 }
1112
1113
set_tcpflags(arg)1114 void set_tcpflags(arg)
1115 char **arg;
1116 {
1117 static char flags[] = "ASURPF";
1118 static int flagv[] = { TH_ACK, TH_SYN, TH_URG, TH_RST, TH_PUSH,
1119 TH_FIN } ;
1120 char *s, *t;
1121
1122 for (s = *arg; *s; s++)
1123 if (!(t = strchr(flags, *s))) {
1124 if (s - *arg) {
1125 fprintf(stderr, "unknown TCP flag %c\n", *s);
1126 break;
1127 }
1128 tcp->th_flags = strtol(*arg, NULL, 0);
1129 break;
1130 } else
1131 tcp->th_flags |= flagv[t - flags];
1132 free(*arg);
1133 *arg = NULL;
1134 }
1135
1136
set_tcpopt(state,arg)1137 void set_tcpopt(state, arg)
1138 int state;
1139 char **arg;
1140 {
1141 u_char *s;
1142 int val, len, val2, pad, optval;
1143
1144 if (arg && *arg)
1145 val = atoi(*arg);
1146 else
1147 val = 0;
1148
1149 s = (u_char *)tcp + sizeof(*tcp) + canip->ah_optlen;
1150 switch (state)
1151 {
1152 case IL_TCPO_EOL :
1153 optval = 0;
1154 len = 1;
1155 break;
1156 case IL_TCPO_NOP :
1157 optval = 1;
1158 len = 1;
1159 break;
1160 case IL_TCPO_MSS :
1161 optval = 2;
1162 len = 4;
1163 break;
1164 case IL_TCPO_WSCALE :
1165 optval = 3;
1166 len = 3;
1167 break;
1168 case IL_TCPO_TS :
1169 optval = 8;
1170 len = 10;
1171 break;
1172 default :
1173 optval = 0;
1174 len = 0;
1175 break;
1176 }
1177
1178 if (len > 1) {
1179 /*
1180 * prepend padding - if required.
1181 */
1182 if (len & 3)
1183 for (pad = 4 - (len & 3); pad; pad--) {
1184 *s++ = 1;
1185 canip->ah_optlen++;
1186 }
1187 /*
1188 * build tcp option
1189 */
1190 *s++ = (u_char)optval;
1191 *s++ = (u_char)len;
1192 if (len > 2) {
1193 if (len == 3) { /* 1 byte - char */
1194 *s++ = (u_char)val;
1195 } else if (len == 4) { /* 2 bytes - short */
1196 *s++ = (u_char)((val >> 8) & 0xff);
1197 *s++ = (u_char)(val & 0xff);
1198 } else if (len >= 6) { /* 4 bytes - long */
1199 val2 = htonl(val);
1200 bcopy((char *)&val2, s, 4);
1201 }
1202 s += (len - 2);
1203 }
1204 } else
1205 *s++ = (u_char)optval;
1206
1207 canip->ah_lastopt = optval;
1208 canip->ah_optlen += len;
1209
1210 if (arg && *arg) {
1211 free(*arg);
1212 *arg = NULL;
1213 }
1214 }
1215
1216
end_tcpopt()1217 void end_tcpopt()
1218 {
1219 int pad;
1220 char *s = (char *)tcp;
1221
1222 s += sizeof(*tcp) + canip->ah_optlen;
1223 /*
1224 * pad out so that we have a multiple of 4 bytes in size fo the
1225 * options. make sure last byte is EOL.
1226 */
1227 if (canip->ah_optlen & 3) {
1228 if (canip->ah_lastopt != 1) {
1229 for (pad = 3 - (canip->ah_optlen & 3); pad; pad--) {
1230 *s++ = 1;
1231 canip->ah_optlen++;
1232 }
1233 canip->ah_optlen++;
1234 } else {
1235 s -= 1;
1236
1237 for (pad = 3 - (canip->ah_optlen & 3); pad; pad--) {
1238 *s++ = 1;
1239 canip->ah_optlen++;
1240 }
1241 }
1242 *s++ = 0;
1243 }
1244 tcp->th_off = (sizeof(*tcp) + canip->ah_optlen) >> 2;
1245 inc_anipheaders(canip->ah_optlen);
1246 }
1247
1248
new_udpheader()1249 void new_udpheader()
1250 {
1251 if ((ip->ip_p) && (ip->ip_p != IPPROTO_UDP)) {
1252 fprintf(stderr, "protocol %d specified with UDP!\n", ip->ip_p);
1253 return;
1254 }
1255 ip->ip_p = IPPROTO_UDP;
1256
1257 udp = (udphdr_t *)new_header(IPPROTO_UDP);
1258 udp->uh_ulen = sizeof(*udp);
1259 }
1260
1261
set_udplen(arg)1262 void set_udplen(arg)
1263 char **arg;
1264 {
1265 int len;
1266
1267 len = strtol(*arg, NULL, 0);
1268 inc_anipheaders(len - udp->uh_ulen);
1269 udp->uh_ulen = len;
1270 free(*arg);
1271 *arg = NULL;
1272 }
1273
1274
set_udpsum(arg)1275 void set_udpsum(arg)
1276 char **arg;
1277 {
1278 udp->uh_sum = strtol(*arg, NULL, 0);
1279 free(*arg);
1280 *arg = NULL;
1281 }
1282
1283
prep_packet()1284 void prep_packet()
1285 {
1286 iface_t *ifp;
1287 struct in_addr gwip;
1288
1289 ifp = sending.snd_if;
1290 if (!ifp) {
1291 fprintf(stderr, "no interface defined for sending!\n");
1292 return;
1293 }
1294 if (ifp->if_fd == -1)
1295 ifp->if_fd = initdevice(ifp->if_name, 5);
1296 gwip = sending.snd_gw;
1297 if (!gwip.s_addr) {
1298 if (aniphead == NULL) {
1299 fprintf(stderr,
1300 "no destination address defined for sending\n");
1301 return;
1302 }
1303 gwip = aniphead->ah_ip->ip_dst;
1304 }
1305 (void) send_ip(ifp->if_fd, ifp->if_MTU, (ip_t *)ipbuffer, gwip, 2);
1306 }
1307
1308
packet_done()1309 void packet_done()
1310 {
1311 char outline[80];
1312 int i, j, k;
1313 u_char *s = (u_char *)ipbuffer, *t = (u_char *)outline;
1314
1315 if (opts & OPT_VERBOSE) {
1316 ip->ip_len = htons(ip->ip_len);
1317 for (i = ntohs(ip->ip_len), j = 0; i; i--, j++, s++) {
1318 if (j && !(j & 0xf)) {
1319 *t++ = '\n';
1320 *t = '\0';
1321 fputs(outline, stdout);
1322 fflush(stdout);
1323 t = (u_char *)outline;
1324 *t = '\0';
1325 }
1326 sprintf((char *)t, "%02x", *s & 0xff);
1327 t += 2;
1328 if (!((j + 1) & 0xf)) {
1329 s -= 15;
1330 sprintf((char *)t, " ");
1331 t += 8;
1332 for (k = 16; k; k--, s++)
1333 *t++ = (ISPRINT(*s) ? *s : '.');
1334 s--;
1335 }
1336
1337 if ((j + 1) & 0xf)
1338 *t++ = ' ';;
1339 }
1340
1341 if (j & 0xf) {
1342 for (k = 16 - (j & 0xf); k; k--) {
1343 *t++ = ' ';
1344 *t++ = ' ';
1345 *t++ = ' ';
1346 }
1347 sprintf((char *)t, " ");
1348 t += 7;
1349 s -= j & 0xf;
1350 for (k = j & 0xf; k; k--, s++)
1351 *t++ = (ISPRINT(*s) ? *s : '.');
1352 *t++ = '\n';
1353 *t = '\0';
1354 }
1355 fputs(outline, stdout);
1356 fflush(stdout);
1357 ip->ip_len = ntohs(ip->ip_len);
1358 }
1359
1360 prep_packet();
1361 free_aniplist();
1362 }
1363
1364
new_interface()1365 void new_interface()
1366 {
1367 cifp = (iface_t *)calloc(1, sizeof(iface_t));
1368 *iftail = cifp;
1369 iftail = &cifp->if_next;
1370 cifp->if_fd = -1;
1371 }
1372
1373
check_interface()1374 void check_interface()
1375 {
1376 if (!cifp->if_name || !*cifp->if_name)
1377 fprintf(stderr, "No interface name given!\n");
1378 if (!cifp->if_MTU || !*cifp->if_name)
1379 fprintf(stderr, "Interface %s has an MTU of 0!\n",
1380 cifp->if_name);
1381 }
1382
1383
set_ifname(arg)1384 void set_ifname(arg)
1385 char **arg;
1386 {
1387 cifp->if_name = *arg;
1388 *arg = NULL;
1389 }
1390
1391
set_ifmtu(arg)1392 void set_ifmtu(arg)
1393 int arg;
1394 {
1395 cifp->if_MTU = arg;
1396 }
1397
1398
set_ifv4addr(arg)1399 void set_ifv4addr(arg)
1400 char **arg;
1401 {
1402 cifp->if_addr = getipv4addr(*arg);
1403 free(*arg);
1404 *arg = NULL;
1405 }
1406
1407
set_ifeaddr(arg)1408 void set_ifeaddr(arg)
1409 char **arg;
1410 {
1411 (void) geteaddr(*arg, &cifp->if_eaddr);
1412 free(*arg);
1413 *arg = NULL;
1414 }
1415
1416
new_arp()1417 void new_arp()
1418 {
1419 carp = (arp_t *)calloc(1, sizeof(arp_t));
1420 *arptail = carp;
1421 arptail = &carp->arp_next;
1422 }
1423
1424
set_arpeaddr(arg)1425 void set_arpeaddr(arg)
1426 char **arg;
1427 {
1428 (void) geteaddr(*arg, &carp->arp_eaddr);
1429 free(*arg);
1430 *arg = NULL;
1431 }
1432
1433
set_arpv4addr(arg)1434 void set_arpv4addr(arg)
1435 char **arg;
1436 {
1437 carp->arp_addr = getipv4addr(*arg);
1438 free(*arg);
1439 *arg = NULL;
1440 }
1441
1442
arp_getipv4(ip,addr)1443 int arp_getipv4(ip, addr)
1444 char *ip;
1445 char *addr;
1446 {
1447 arp_t *a;
1448
1449 for (a = arplist; a; a = a->arp_next)
1450 if (!bcmp(ip, (char *)&a->arp_addr, 4)) {
1451 bcopy((char *)&a->arp_eaddr, addr, 6);
1452 return 0;
1453 }
1454 return -1;
1455 }
1456
1457
reset_send()1458 void reset_send()
1459 {
1460 sending.snd_if = iflist;
1461 sending.snd_gw = defrouter;
1462 }
1463
1464
set_sendif(arg)1465 void set_sendif(arg)
1466 char **arg;
1467 {
1468 iface_t *ifp;
1469
1470 for (ifp = iflist; ifp; ifp = ifp->if_next)
1471 if (ifp->if_name && !strcmp(ifp->if_name, *arg))
1472 break;
1473 sending.snd_if = ifp;
1474 if (!ifp)
1475 fprintf(stderr, "couldn't find interface %s\n", *arg);
1476 free(*arg);
1477 *arg = NULL;
1478 }
1479
1480
set_sendvia(arg)1481 void set_sendvia(arg)
1482 char **arg;
1483 {
1484 sending.snd_gw = getipv4addr(*arg);
1485 free(*arg);
1486 *arg = NULL;
1487 }
1488
1489
set_defaultrouter(arg)1490 void set_defaultrouter(arg)
1491 char **arg;
1492 {
1493 defrouter = getipv4addr(*arg);
1494 free(*arg);
1495 *arg = NULL;
1496 }
1497
1498
new_icmpheader()1499 void new_icmpheader()
1500 {
1501 if ((ip->ip_p) && (ip->ip_p != IPPROTO_ICMP)) {
1502 fprintf(stderr, "protocol %d specified with ICMP!\n",
1503 ip->ip_p);
1504 return;
1505 }
1506 ip->ip_p = IPPROTO_ICMP;
1507 icmp = (icmphdr_t *)new_header(IPPROTO_ICMP);
1508 }
1509
1510
set_icmpcode(code)1511 void set_icmpcode(code)
1512 int code;
1513 {
1514 icmp->icmp_code = code;
1515 }
1516
1517
set_icmptype(type)1518 void set_icmptype(type)
1519 int type;
1520 {
1521 icmp->icmp_type = type;
1522 }
1523
1524
set_icmpcodetok(code)1525 void set_icmpcodetok(code)
1526 char **code;
1527 {
1528 char *s;
1529 int i;
1530
1531 for (i = 0; (s = icmpcodes[i]); i++)
1532 if (!strcmp(s, *code)) {
1533 icmp->icmp_code = i;
1534 break;
1535 }
1536 if (!s)
1537 fprintf(stderr, "unknown ICMP code %s\n", *code);
1538 free(*code);
1539 *code = NULL;
1540 }
1541
1542
set_icmptypetok(type)1543 void set_icmptypetok(type)
1544 char **type;
1545 {
1546 char *s;
1547 int i, done = 0;
1548
1549 for (i = 0; !(s = icmptypes[i]) || strcmp(s, "END"); i++)
1550 if (s && !strcmp(s, *type)) {
1551 icmp->icmp_type = i;
1552 done = 1;
1553 break;
1554 }
1555 if (!done)
1556 fprintf(stderr, "unknown ICMP type %s\n", *type);
1557 free(*type);
1558 *type = NULL;
1559 }
1560
1561
set_icmpid(arg)1562 void set_icmpid(arg)
1563 int arg;
1564 {
1565 icmp->icmp_id = htons(arg);
1566 }
1567
1568
set_icmpseq(arg)1569 void set_icmpseq(arg)
1570 int arg;
1571 {
1572 icmp->icmp_seq = htons(arg);
1573 }
1574
1575
set_icmpotime(arg)1576 void set_icmpotime(arg)
1577 int arg;
1578 {
1579 icmp->icmp_otime = htonl(arg);
1580 }
1581
1582
set_icmprtime(arg)1583 void set_icmprtime(arg)
1584 int arg;
1585 {
1586 icmp->icmp_rtime = htonl(arg);
1587 }
1588
1589
set_icmpttime(arg)1590 void set_icmpttime(arg)
1591 int arg;
1592 {
1593 icmp->icmp_ttime = htonl(arg);
1594 }
1595
1596
set_icmpmtu(arg)1597 void set_icmpmtu(arg)
1598 int arg;
1599 {
1600 #if BSD >= 199306
1601 icmp->icmp_nextmtu = htons(arg);
1602 #endif
1603 }
1604
1605
set_redir(redir,arg)1606 void set_redir(redir, arg)
1607 int redir;
1608 char **arg;
1609 {
1610 icmp->icmp_code = redir;
1611 icmp->icmp_gwaddr = getipv4addr(*arg);
1612 free(*arg);
1613 *arg = NULL;
1614 }
1615
1616
set_icmppprob(num)1617 void set_icmppprob(num)
1618 int num;
1619 {
1620 icmp->icmp_pptr = num;
1621 }
1622
1623
new_ipv4opt()1624 void new_ipv4opt()
1625 {
1626 new_header(-2);
1627 }
1628
1629
add_ipopt(state,ptr)1630 void add_ipopt(state, ptr)
1631 int state;
1632 void *ptr;
1633 {
1634 struct ipopt_names *io;
1635 struct statetoopt *sto;
1636 char numbuf[16], *arg, **param = ptr;
1637 int inc, hlen;
1638
1639 if (state == IL_IPO_RR || state == IL_IPO_SATID) {
1640 if (param)
1641 sprintf(numbuf, "%d", *(int *)param);
1642 else
1643 strcpy(numbuf, "0");
1644 arg = numbuf;
1645 } else
1646 arg = param ? *param : NULL;
1647
1648 if (canip->ah_next) {
1649 fprintf(stderr, "cannot specify options after data body\n");
1650 return;
1651 }
1652 for (sto = toipopts; sto->sto_st; sto++)
1653 if (sto->sto_st == state)
1654 break;
1655 if (!sto->sto_st) {
1656 fprintf(stderr, "No mapping for state %d to IP option\n",
1657 state);
1658 return;
1659 }
1660
1661 hlen = sizeof(ip_t) + canip->ah_optlen;
1662 for (io = ionames; io->on_name; io++)
1663 if (io->on_value == sto->sto_op)
1664 break;
1665 canip->ah_lastopt = io->on_value;
1666
1667 if (io->on_name) {
1668 inc = addipopt((char *)ip + hlen, io, hlen - sizeof(ip_t),arg);
1669 if (inc > 0) {
1670 while (inc & 3) {
1671 ((char *)ip)[sizeof(*ip) + inc] = IPOPT_NOP;
1672 canip->ah_lastopt = IPOPT_NOP;
1673 inc++;
1674 }
1675 hlen += inc;
1676 }
1677 }
1678
1679 canip->ah_optlen = hlen - sizeof(ip_t);
1680
1681 if (state != IL_IPO_RR && state != IL_IPO_SATID)
1682 if (param && *param) {
1683 free(*param);
1684 *param = NULL;
1685 }
1686 sclass = NULL;
1687 }
1688
1689
end_ipopt()1690 void end_ipopt()
1691 {
1692 int pad;
1693 char *s, *buf = (char *)ip;
1694
1695 /*
1696 * pad out so that we have a multiple of 4 bytes in size fo the
1697 * options. make sure last byte is EOL.
1698 */
1699 if (canip->ah_lastopt == IPOPT_NOP) {
1700 buf[sizeof(*ip) + canip->ah_optlen - 1] = IPOPT_EOL;
1701 } else if (canip->ah_lastopt != IPOPT_EOL) {
1702 s = buf + sizeof(*ip) + canip->ah_optlen;
1703
1704 for (pad = 3 - (canip->ah_optlen & 3); pad; pad--) {
1705 *s++ = IPOPT_NOP;
1706 *s = IPOPT_EOL;
1707 canip->ah_optlen++;
1708 }
1709 canip->ah_optlen++;
1710 } else {
1711 s = buf + sizeof(*ip) + canip->ah_optlen - 1;
1712
1713 for (pad = 3 - (canip->ah_optlen & 3); pad; pad--) {
1714 *s++ = IPOPT_NOP;
1715 *s = IPOPT_EOL;
1716 canip->ah_optlen++;
1717 }
1718 }
1719 ip->ip_hl = (sizeof(*ip) + canip->ah_optlen) >> 2;
1720 inc_anipheaders(canip->ah_optlen);
1721 free_anipheader();
1722 }
1723
1724
set_secclass(arg)1725 void set_secclass(arg)
1726 char **arg;
1727 {
1728 sclass = *arg;
1729 *arg = NULL;
1730 }
1731
1732
free_anipheader()1733 void free_anipheader()
1734 {
1735 aniphdr_t *aip;
1736
1737 aip = canip;
1738 if ((canip = aip->ah_prev)) {
1739 canip->ah_next = NULL;
1740 aniptail = &canip->ah_next;
1741 }
1742
1743 if (canip)
1744 free(aip);
1745 }
1746
1747
end_ipv4()1748 void end_ipv4()
1749 {
1750 aniphdr_t *aip;
1751
1752 ip->ip_sum = 0;
1753 ip->ip_len = htons(ip->ip_len);
1754 ip->ip_sum = chksum((u_short *)ip, ip->ip_hl << 2);
1755 ip->ip_len = ntohs(ip->ip_len);
1756 free_anipheader();
1757 for (aip = aniphead, ip = NULL; aip; aip = aip->ah_next)
1758 if (aip->ah_p == IPPROTO_IP)
1759 ip = aip->ah_ip;
1760 }
1761
1762
end_icmp()1763 void end_icmp()
1764 {
1765 aniphdr_t *aip;
1766
1767 icmp->icmp_cksum = 0;
1768 icmp->icmp_cksum = chksum((u_short *)icmp, canip->ah_len);
1769 free_anipheader();
1770 for (aip = aniphead, icmp = NULL; aip; aip = aip->ah_next)
1771 if (aip->ah_p == IPPROTO_ICMP)
1772 icmp = aip->ah_icmp;
1773 }
1774
1775
end_udp()1776 void end_udp()
1777 {
1778 u_long sum;
1779 aniphdr_t *aip;
1780 ip_t iptmp;
1781
1782 bzero((char *)&iptmp, sizeof(iptmp));
1783 iptmp.ip_p = ip->ip_p;
1784 iptmp.ip_src = ip->ip_src;
1785 iptmp.ip_dst = ip->ip_dst;
1786 iptmp.ip_len = htons(ip->ip_len - (ip->ip_hl << 2));
1787 sum = p_chksum((u_short *)&iptmp, (u_int)sizeof(iptmp));
1788 udp->uh_ulen = htons(udp->uh_ulen);
1789 udp->uh_sum = c_chksum((u_short *)udp, (u_int)ntohs(iptmp.ip_len), sum);
1790 free_anipheader();
1791 for (aip = aniphead, udp = NULL; aip; aip = aip->ah_next)
1792 if (aip->ah_p == IPPROTO_UDP)
1793 udp = aip->ah_udp;
1794 }
1795
1796
end_tcp()1797 void end_tcp()
1798 {
1799 u_long sum;
1800 aniphdr_t *aip;
1801 ip_t iptmp;
1802
1803 bzero((char *)&iptmp, sizeof(iptmp));
1804 iptmp.ip_p = ip->ip_p;
1805 iptmp.ip_src = ip->ip_src;
1806 iptmp.ip_dst = ip->ip_dst;
1807 iptmp.ip_len = htons(ip->ip_len - (ip->ip_hl << 2));
1808 sum = p_chksum((u_short *)&iptmp, (u_int)sizeof(iptmp));
1809 tcp->th_sum = 0;
1810 tcp->th_sum = c_chksum((u_short *)tcp, (u_int)ntohs(iptmp.ip_len), sum);
1811 free_anipheader();
1812 for (aip = aniphead, tcp = NULL; aip; aip = aip->ah_next)
1813 if (aip->ah_p == IPPROTO_TCP)
1814 tcp = aip->ah_tcp;
1815 }
1816
1817
end_data()1818 void end_data()
1819 {
1820 free_anipheader();
1821 }
1822
1823
iplang(fp)1824 void iplang(fp)
1825 FILE *fp;
1826 {
1827 yyin = fp;
1828
1829 yydebug = (opts & OPT_DEBUG) ? 1 : 0;
1830
1831 while (!feof(fp))
1832 yyparse();
1833 }
1834
1835
c_chksum(buf,len,init)1836 u_short c_chksum(buf, len, init)
1837 u_short *buf;
1838 u_int len;
1839 u_long init;
1840 {
1841 u_long sum = init;
1842 int nwords = len >> 1;
1843
1844 for(; nwords > 0; nwords--)
1845 sum += *buf++;
1846 sum = (sum>>16) + (sum & 0xffff);
1847 sum += (sum >>16);
1848 return (~sum);
1849 }
1850
1851
p_chksum(buf,len)1852 u_long p_chksum(buf,len)
1853 u_short *buf;
1854 u_int len;
1855 {
1856 u_long sum = 0;
1857 int nwords = len >> 1;
1858
1859 for(; nwords > 0; nwords--)
1860 sum += *buf++;
1861 return sum;
1862 }
1863