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