Home | History | Annotate | Line # | Download | only in tools 
      1 /*	$NetBSD: ippool_y.y,v 1.1.1.2 2012/07/22 13:44:58 darrenr Exp $	*/
      2 
      3 /*
      4  * Copyright (C) 2012 by Darren Reed.
      5  *
      6  * See the IPFILTER.LICENCE file for details on licencing.
      7  */
      8 %{
      9 #include <sys/types.h>
     10 #include <sys/time.h>
     11 #include <sys/param.h>
     12 #include <sys/socket.h>
     13 #if defined(BSD) && (BSD >= 199306)
     14 # include <sys/cdefs.h>
     15 #endif
     16 #include <sys/ioctl.h>
     17 
     18 #include <net/if.h>
     19 #if __FreeBSD_version >= 300000
     20 # include <net/if_var.h>
     21 #endif
     22 #include <netinet/in.h>
     23 
     24 #include <arpa/inet.h>
     25 
     26 #include <stdio.h>
     27 #include <fcntl.h>
     28 #include <stdlib.h>
     29 #include <string.h>
     30 #include <netdb.h>
     31 #include <ctype.h>
     32 #include <unistd.h>
     33 
     34 #include "ipf.h"
     35 #include "netinet/ip_lookup.h"
     36 #include "netinet/ip_pool.h"
     37 #include "netinet/ip_htable.h"
     38 #include "netinet/ip_dstlist.h"
     39 #include "ippool_l.h"
     40 #include "kmem.h"
     41 
     42 #define	YYDEBUG	1
     43 #define	YYSTACKSIZE	0x00ffffff
     44 
     45 extern	int	yyparse __P((void));
     46 extern	int	yydebug;
     47 extern	FILE	*yyin;
     48 
     49 static	iphtable_t	ipht;
     50 static	iphtent_t	iphte;
     51 static	ip_pool_t	iplo;
     52 static	ippool_dst_t	ipld;
     53 static	ioctlfunc_t	poolioctl = NULL;
     54 static	char		poolname[FR_GROUPLEN];
     55 
     56 static iphtent_t *add_htablehosts __P((char *));
     57 static ip_pool_node_t *add_poolhosts __P((char *));
     58 static ip_pool_node_t *read_whoisfile __P((char *));
     59 static void setadflen __P((addrfamily_t *));
     60 
     61 %}
     62 
     63 %union	{
     64 	char	*str;
     65 	u_32_t	num;
     66 	struct	in_addr	ip4;
     67 	struct	alist_s	*alist;
     68 	addrfamily_t	adrmsk[2];
     69 	iphtent_t	*ipe;
     70 	ip_pool_node_t	*ipp;
     71 	ipf_dstnode_t	*ipd;
     72 	addrfamily_t	ipa;
     73 	i6addr_t	ip6;
     74 }
     75 
     76 %token  <num>	YY_NUMBER YY_HEX
     77 %token  <str>	YY_STR
     78 %token  <ip6>	YY_IPV6
     79 %token	YY_COMMENT
     80 %token	YY_CMP_EQ YY_CMP_NE YY_CMP_LE YY_CMP_GE YY_CMP_LT YY_CMP_GT
     81 %token	YY_RANGE_OUT YY_RANGE_IN
     82 %token	IPT_IPF IPT_NAT IPT_COUNT IPT_AUTH IPT_IN IPT_OUT IPT_ALL
     83 %token	IPT_TABLE IPT_GROUPMAP IPT_HASH IPT_SRCHASH IPT_DSTHASH
     84 %token	IPT_ROLE IPT_TYPE IPT_TREE
     85 %token	IPT_GROUP IPT_SIZE IPT_SEED IPT_NUM IPT_NAME IPT_POLICY
     86 %token	IPT_POOL IPT_DSTLIST IPT_ROUNDROBIN
     87 %token	IPT_WEIGHTED IPT_RANDOM IPT_CONNECTION
     88 %token	IPT_WHOIS IPT_FILE
     89 %type	<num> role table inout unit dstopts weighting
     90 %type	<ipp> ipftree range addrlist
     91 %type	<adrmsk> addrmask
     92 %type	<ipe> ipfgroup ipfhash hashlist hashentry
     93 %type	<ipe> groupentry setgrouplist grouplist
     94 %type	<ipa> ipaddr mask
     95 %type	<ip4> ipv4
     96 %type	<str> number setgroup name
     97 %type	<ipd> dstentry dstentries dstlist
     98 
     99 %%
    100 file:	line
    101 	| assign
    102 	| file line
    103 	| file assign
    104 	;
    105 
    106 line:	table role ipftree eol		{ ip_pool_node_t *n;
    107 					  iplo.ipo_unit = $2;
    108 					  iplo.ipo_list = $3;
    109 					  load_pool(&iplo, poolioctl);
    110 					  while ((n = $3) != NULL) {
    111 						$3 = n->ipn_next;
    112 						free(n);
    113 					  }
    114 					  resetlexer();
    115 					  use_inet6 = 0;
    116 					}
    117 	| table role ipfhash eol	{ iphtent_t *h;
    118 					  ipht.iph_unit = $2;
    119 					  ipht.iph_type = IPHASH_LOOKUP;
    120 					  load_hash(&ipht, $3, poolioctl);
    121 					  while ((h = $3) != NULL) {
    122 						$3 = h->ipe_next;
    123 						free(h);
    124 					  }
    125 					  resetlexer();
    126 					  use_inet6 = 0;
    127 					}
    128 	| groupmap role number ipfgroup eol
    129 					{ iphtent_t *h;
    130 					  ipht.iph_unit = $2;
    131 					  strncpy(ipht.iph_name, $3,
    132 						  sizeof(ipht.iph_name));
    133 					  ipht.iph_type = IPHASH_GROUPMAP;
    134 					  load_hash(&ipht, $4, poolioctl);
    135 					  while ((h = $4) != NULL) {
    136 						$4 = h->ipe_next;
    137 						free(h);
    138 					  }
    139 					  resetlexer();
    140 					  use_inet6 = 0;
    141 					}
    142 	| YY_COMMENT
    143 	| poolline eol
    144 	;
    145 
    146 eol:	';'
    147 	;
    148 
    149 assign:	YY_STR assigning YY_STR ';'	{ set_variable($1, $3);
    150 					  resetlexer();
    151 					  free($1);
    152 					  free($3);
    153 					  yyvarnext = 0;
    154 					}
    155 	;
    156 
    157 assigning:
    158 	'='				{ yyvarnext = 1; }
    159 	;
    160 
    161 table:	IPT_TABLE		{ bzero((char *)&ipht, sizeof(ipht));
    162 				  bzero((char *)&iphte, sizeof(iphte));
    163 				  bzero((char *)&iplo, sizeof(iplo));
    164 				  bzero((char *)&ipld, sizeof(ipld));
    165 				  *ipht.iph_name = '\0';
    166 				  iplo.ipo_flags = IPHASH_ANON;
    167 				  iplo.ipo_name[0] = '\0';
    168 				}
    169 	;
    170 
    171 groupmap:
    172 	IPT_GROUPMAP inout	{ bzero((char *)&ipht, sizeof(ipht));
    173 				  bzero((char *)&iphte, sizeof(iphte));
    174 				  *ipht.iph_name = '\0';
    175 				  ipht.iph_unit = IPHASH_GROUPMAP;
    176 				  ipht.iph_flags = $2;
    177 				}
    178 	;
    179 
    180 inout:	IPT_IN				{ $$ = FR_INQUE; }
    181 	| IPT_OUT			{ $$ = FR_OUTQUE; }
    182 	;
    183 
    184 role:	IPT_ROLE '=' unit		{ $$ = $3; }
    185 	;
    186 
    187 unit:	IPT_IPF				{ $$ = IPL_LOGIPF; }
    188 	| IPT_NAT			{ $$ = IPL_LOGNAT; }
    189 	| IPT_AUTH			{ $$ = IPL_LOGAUTH; }
    190 	| IPT_COUNT			{ $$ = IPL_LOGCOUNT; }
    191 	| IPT_ALL			{ $$ = IPL_LOGALL; }
    192 	;
    193 
    194 ipftree:
    195 	IPT_TYPE '=' IPT_TREE number start addrlist end
    196 					{ strncpy(iplo.ipo_name, $4,
    197 						  sizeof(iplo.ipo_name));
    198 					  $$ = $6;
    199 					}
    200 	;
    201 
    202 ipfhash:
    203 	IPT_TYPE '=' IPT_HASH number hashopts start hashlist end
    204 					{ strncpy(ipht.iph_name, $4,
    205 						  sizeof(ipht.iph_name));
    206 					  $$ = $7;
    207 					}
    208 	;
    209 
    210 ipfgroup:
    211 	setgroup hashopts start grouplist end
    212 					{ iphtent_t *e;
    213 					  for (e = $4; e != NULL;
    214 					       e = e->ipe_next)
    215 						if (e->ipe_group[0] == '\0')
    216 							strncpy(e->ipe_group,
    217 								$1,
    218 								FR_GROUPLEN);
    219 					  $$ = $4;
    220 					  free($1);
    221 					}
    222 	| hashopts start setgrouplist end
    223 					{ $$ = $3; }
    224 	;
    225 
    226 number:	IPT_NUM '=' YY_NUMBER			{ sprintf(poolname, "%u", $3);
    227 						  $$ = poolname;
    228 						}
    229 	| IPT_NAME '=' YY_STR			{ strncpy(poolname, $3,
    230 							  FR_GROUPLEN);
    231 						  poolname[FR_GROUPLEN-1]='\0';
    232 						  free($3);
    233 						  $$ = poolname;
    234 						}
    235 	|					{ $$ = ""; }
    236 	;
    237 
    238 setgroup:
    239 	IPT_GROUP '=' YY_STR		{ char tmp[FR_GROUPLEN+1];
    240 					  strncpy(tmp, $3, FR_GROUPLEN);
    241 					  $$ = strdup(tmp);
    242 					  free($3);
    243 					}
    244 	| IPT_GROUP '=' YY_NUMBER	{ char tmp[FR_GROUPLEN+1];
    245 					  sprintf(tmp, "%u", $3);
    246 					  $$ = strdup(tmp);
    247 					}
    248 	;
    249 
    250 hashopts:
    251 	| size
    252 	| seed
    253 	| size seed
    254 	;
    255 
    256 addrlist:
    257 	';'				{ $$ = NULL; }
    258 	| range next addrlist		{ $$ = $1;
    259 					  while ($1->ipn_next != NULL)
    260 						$1 = $1->ipn_next;
    261 					  $1->ipn_next = $3;
    262 					}
    263 	| range next			{ $$ = $1; }
    264 	;
    265 
    266 grouplist:
    267 	';'				{ $$ = NULL; }
    268 	| groupentry next grouplist	{ $$ = $1; $1->ipe_next = $3; }
    269 	| addrmask next grouplist	{ $$ = calloc(1, sizeof(iphtent_t));
    270 					  $$->ipe_addr = $1[0].adf_addr;
    271 					  $$->ipe_mask = $1[1].adf_addr;
    272 					  $$->ipe_family = $1[0].adf_family;
    273 					  $$->ipe_next = $3;
    274 					}
    275 	| groupentry next		{ $$ = $1; }
    276 	| addrmask next			{ $$ = calloc(1, sizeof(iphtent_t));
    277 					  $$->ipe_addr = $1[0].adf_addr;
    278 					  $$->ipe_mask = $1[1].adf_addr;
    279 #ifdef AF_INET6
    280 					  if (use_inet6)
    281 						$$->ipe_family = AF_INET6;
    282 					  else
    283 #endif
    284 						$$->ipe_family = AF_INET;
    285 					}
    286 	| YY_STR			{ $$ = add_htablehosts($1);
    287 					  free($1);
    288 					}
    289 	;
    290 
    291 setgrouplist:
    292 	';'				{ $$ = NULL; }
    293 	| groupentry next		{ $$ = $1; }
    294 	| groupentry next setgrouplist	{ $1->ipe_next = $3; $$ = $1; }
    295 	;
    296 
    297 groupentry:
    298 	addrmask ',' setgroup		{ $$ = calloc(1, sizeof(iphtent_t));
    299 					  $$->ipe_addr = $1[0].adf_addr;
    300 					  $$->ipe_mask = $1[1].adf_addr;
    301 					  strncpy($$->ipe_group, $3,
    302 						  FR_GROUPLEN);
    303 #ifdef AF_INET6
    304 					  if (use_inet6)
    305 						$$->ipe_family = AF_INET6;
    306 					  else
    307 #endif
    308 						$$->ipe_family = AF_INET;
    309 					  free($3);
    310 					}
    311 	;
    312 
    313 range:	addrmask			{ $$ = calloc(1, sizeof(*$$));
    314 					  $$->ipn_info = 0;
    315 					  $$->ipn_addr = $1[0];
    316 					  $$->ipn_mask = $1[1];
    317 					}
    318 	| '!' addrmask			{ $$ = calloc(1, sizeof(*$$));
    319 					  $$->ipn_info = 1;
    320 					  $$->ipn_addr = $2[0];
    321 					  $$->ipn_mask = $2[1];
    322 					}
    323 	| YY_STR			{ $$ = add_poolhosts($1);
    324 					  free($1);
    325 					}
    326 	| IPT_WHOIS IPT_FILE YY_STR	{ $$ = read_whoisfile($3);
    327 					  free($3);
    328 					}
    329 	;
    330 
    331 hashlist:
    332 	';'				{ $$ = NULL; }
    333 	| hashentry next		{ $$ = $1; }
    334 	| hashentry next hashlist	{ $1->ipe_next = $3; $$ = $1; }
    335 	;
    336 
    337 hashentry:
    338 	addrmask 		{ $$ = calloc(1, sizeof(iphtent_t));
    339 				  $$->ipe_addr = $1[0].adf_addr;
    340 				  $$->ipe_mask = $1[1].adf_addr;
    341 #ifdef USE_INET6
    342 				  if (use_inet6)
    343 					$$->ipe_family = AF_INET6;
    344 				  else
    345 #endif
    346 					$$->ipe_family = AF_INET;
    347 				}
    348 	| YY_STR		{ $$ = add_htablehosts($1);
    349 				  free($1);
    350 				}
    351 	;
    352 
    353 addrmask:
    354 	ipaddr '/' mask		{ $$[0] = $1;
    355 				  setadflen(&$$[0]);
    356 				  $$[1] = $3;
    357 				  $$[1].adf_len = $$[0].adf_len;
    358 				}
    359 	| ipaddr		{ $$[0] = $1;
    360 				  setadflen(&$$[1]);
    361 				  $$[1].adf_len = $$[0].adf_len;
    362 #ifdef USE_INET6
    363 				  if (use_inet6)
    364 					memset(&$$[1].adf_addr, 0xff,
    365 					       sizeof($$[1].adf_addr.in6));
    366 				  else
    367 #endif
    368 					memset(&$$[1].adf_addr, 0xff,
    369 					       sizeof($$[1].adf_addr.in4));
    370 				}
    371 	;
    372 
    373 ipaddr:	ipv4			{ $$.adf_addr.in4 = $1;
    374 				  $$.adf_family = AF_INET;
    375 				  setadflen(&$$);
    376 				  use_inet6 = 0;
    377 				}
    378 	| YY_NUMBER		{ $$.adf_addr.in4.s_addr = htonl($1);
    379 				  $$.adf_family = AF_INET;
    380 				  setadflen(&$$);
    381 				  use_inet6 = 0;
    382 				}
    383 	| YY_IPV6		{ $$.adf_addr = $1;
    384 				  $$.adf_family = AF_INET6;
    385 				  setadflen(&$$);
    386 				  use_inet6 = 1;
    387 				}
    388 	;
    389 
    390 mask:	YY_NUMBER	{ bzero(&$$, sizeof($$));
    391 			  if (use_inet6) {
    392 				if (ntomask(AF_INET6, $1,
    393 					    (u_32_t *)&$$.adf_addr) == -1)
    394 					yyerror("bad bitmask");
    395 			  } else {
    396 				if (ntomask(AF_INET, $1,
    397 					    (u_32_t *)&$$.adf_addr.in4) == -1)
    398 					yyerror("bad bitmask");
    399 			  }
    400 			}
    401 	| ipv4		{ bzero(&$$, sizeof($$));
    402 			  $$.adf_addr.in4 = $1;
    403 			}
    404 	| YY_IPV6	{ bzero(&$$, sizeof($$));
    405 			  $$.adf_addr = $1;
    406 			}
    407 	;
    408 
    409 size:	IPT_SIZE '=' YY_NUMBER		{ ipht.iph_size = $3; }
    410 	;
    411 
    412 seed:	IPT_SEED '=' YY_NUMBER		{ ipht.iph_seed = $3; }
    413 	;
    414 
    415 ipv4:	YY_NUMBER '.' YY_NUMBER '.' YY_NUMBER '.' YY_NUMBER
    416 		{ if ($1 > 255 || $3 > 255 || $5 > 255 || $7 > 255) {
    417 			yyerror("Invalid octet string for IP address");
    418 			return 0;
    419 		  }
    420 		  $$.s_addr = ($1 << 24) | ($3 << 16) | ($5 << 8) | $7;
    421 		  $$.s_addr = htonl($$.s_addr);
    422 		}
    423 	;
    424 
    425 next:	';'				{ yyexpectaddr = 1; }
    426 	;
    427 
    428 start:	'{'				{ yyexpectaddr = 1; }
    429 	;
    430 
    431 end:	'}'				{ yyexpectaddr = 0; }
    432 	;
    433 
    434 poolline:
    435 	IPT_POOL unit '/' IPT_DSTLIST '(' name ';' dstopts ')'
    436 	start dstlist end
    437 					{ bzero((char *)&ipld, sizeof(ipld));
    438 					  strncpy(ipld.ipld_name, $6,
    439 						  sizeof(ipld.ipld_name));
    440 					  ipld.ipld_unit = $2;
    441 					  ipld.ipld_policy = $8;
    442 					  load_dstlist(&ipld, poolioctl, $11);
    443 					  resetlexer();
    444 					  use_inet6 = 0;
    445 					  free($6);
    446 					}
    447 	| IPT_POOL unit '/' IPT_TREE '(' name ';' ')'
    448 	  start addrlist end
    449 					{ bzero((char *)&iplo, sizeof(iplo));
    450 					  strncpy(iplo.ipo_name, $6,
    451 						  sizeof(iplo.ipo_name));
    452 					  iplo.ipo_list = $10;
    453 					  iplo.ipo_unit = $2;
    454 					  load_pool(&iplo, poolioctl);
    455 					  resetlexer();
    456 					  use_inet6 = 0;
    457 					  free($6);
    458 					}
    459 	| IPT_POOL '(' name ';' ')' start addrlist end
    460 					{ bzero((char *)&iplo, sizeof(iplo));
    461 					  strncpy(iplo.ipo_name, $3,
    462 						  sizeof(iplo.ipo_name));
    463 					  iplo.ipo_list = $7;
    464 					  iplo.ipo_unit = IPL_LOGALL;
    465 					  load_pool(&iplo, poolioctl);
    466 					  resetlexer();
    467 					  use_inet6 = 0;
    468 					  free($3);
    469 					}
    470 	| IPT_POOL unit '/' IPT_HASH '(' name ';' hashoptlist ')'
    471 	  start hashlist end
    472 					{ iphtent_t *h;
    473 					  bzero((char *)&ipht, sizeof(ipht));
    474 					  strncpy(ipht.iph_name, $6,
    475 						  sizeof(ipht.iph_name));
    476 					  ipht.iph_unit = $2;
    477 					  load_hash(&ipht, $11, poolioctl);
    478 					  while ((h = ipht.iph_list) != NULL) {
    479 						ipht.iph_list = h->ipe_next;
    480 						free(h);
    481 					  }
    482 					  resetlexer();
    483 					  use_inet6 = 0;
    484 					  free($6);
    485 					}
    486 	| IPT_GROUPMAP '(' name ';' inout ';' ')'
    487 	  start setgrouplist end
    488 					{ iphtent_t *h;
    489 					  bzero((char *)&ipht, sizeof(ipht));
    490 					  strncpy(ipht.iph_name, $3,
    491 						  sizeof(ipht.iph_name));
    492 					  ipht.iph_type = IPHASH_GROUPMAP;
    493 					  ipht.iph_unit = IPL_LOGIPF;
    494 					  ipht.iph_flags = $5;
    495 					  load_hash(&ipht, $9, poolioctl);
    496 					  while ((h = ipht.iph_list) != NULL) {
    497 						ipht.iph_list = h->ipe_next;
    498 						free(h);
    499 					  }
    500 					  resetlexer();
    501 					  use_inet6 = 0;
    502 					  free($3);
    503 					}
    504 	;
    505 
    506 name:	IPT_NAME YY_STR			{ $$ = $2; }
    507 	| IPT_NUM YY_NUMBER		{ char name[80];
    508 					  sprintf(name, "%d", $2);
    509 					  $$ = strdup(name);
    510 					}
    511 	;
    512 
    513 hashoptlist:
    514 	| hashopt ';'
    515 	| hashoptlist ';' hashopt ';'
    516 	;
    517 hashopt:
    518 	IPT_SIZE YY_NUMBER
    519 	| IPT_SEED YY_NUMBER
    520 	;
    521 
    522 dstlist:
    523 	dstentries			{ $$ = $1; }
    524 	| ';'				{ $$ = NULL; }
    525 	;
    526 
    527 dstentries:
    528 	dstentry next			{ $$ = $1; }
    529 	| dstentry next dstentries	{ $1->ipfd_next = $3; $$ = $1; }
    530 	;
    531 
    532 dstentry:
    533 	YY_STR ':' ipaddr	{ int size = sizeof(*$$) + strlen($1) + 1;
    534 				  $$ = calloc(1, size);
    535 				  if ($$ != NULL) {
    536 					$$->ipfd_dest.fd_name = strlen($1) + 1;
    537 					bcopy($1, $$->ipfd_names,
    538 					      $$->ipfd_dest.fd_name);
    539 					$$->ipfd_dest.fd_addr = $3;
    540 					$$->ipfd_size = size;
    541 				  }
    542 				  free($1);
    543 				}
    544 	| ipaddr		{ $$ = calloc(1, sizeof(*$$));
    545 				  if ($$ != NULL) {
    546 					$$->ipfd_dest.fd_name = -1;
    547 					$$->ipfd_dest.fd_addr = $1;
    548 					$$->ipfd_size = sizeof(*$$);
    549 				  }
    550 				}
    551 	;
    552 
    553 dstopts:
    554 						{ $$ = IPLDP_NONE; }
    555 	| IPT_POLICY IPT_ROUNDROBIN ';'		{ $$ = IPLDP_ROUNDROBIN; }
    556 	| IPT_POLICY IPT_WEIGHTED weighting ';'	{ $$ = $3; }
    557 	| IPT_POLICY IPT_RANDOM ';'		{ $$ = IPLDP_RANDOM; }
    558 	| IPT_POLICY IPT_HASH ';'		{ $$ = IPLDP_HASHED; }
    559 	| IPT_POLICY IPT_SRCHASH ';'		{ $$ = IPLDP_SRCHASH; }
    560 	| IPT_POLICY IPT_DSTHASH ';'		{ $$ = IPLDP_DSTHASH; }
    561 	;
    562 
    563 weighting:
    564 	IPT_CONNECTION				{ $$ = IPLDP_CONNECTION; }
    565 	;
    566 %%
    567 static	wordtab_t	yywords[] = {
    568 	{ "all",		IPT_ALL },
    569 	{ "auth",		IPT_AUTH },
    570 	{ "connection",		IPT_CONNECTION },
    571 	{ "count",		IPT_COUNT },
    572 	{ "dst-hash",		IPT_DSTHASH },
    573 	{ "dstlist",		IPT_DSTLIST },
    574 	{ "file",		IPT_FILE },
    575 	{ "group",		IPT_GROUP },
    576 	{ "group-map",		IPT_GROUPMAP },
    577 	{ "hash",		IPT_HASH },
    578 	{ "in",			IPT_IN },
    579 	{ "ipf",		IPT_IPF },
    580 	{ "name",		IPT_NAME },
    581 	{ "nat",		IPT_NAT },
    582 	{ "number",		IPT_NUM },
    583 	{ "out",		IPT_OUT },
    584 	{ "policy",		IPT_POLICY },
    585 	{ "pool",		IPT_POOL },
    586 	{ "random",		IPT_RANDOM },
    587 	{ "round-robin",	IPT_ROUNDROBIN },
    588 	{ "role",		IPT_ROLE },
    589 	{ "seed",		IPT_SEED },
    590 	{ "size",		IPT_SIZE },
    591 	{ "src-hash",		IPT_SRCHASH },
    592 	{ "table",		IPT_TABLE },
    593 	{ "tree",		IPT_TREE },
    594 	{ "type",		IPT_TYPE },
    595 	{ "weighted",		IPT_WEIGHTED },
    596 	{ "whois",		IPT_WHOIS },
    597 	{ NULL,			0 }
    598 };
    599 
    600 
    601 int ippool_parsefile(fd, filename, iocfunc)
    602 int fd;
    603 char *filename;
    604 ioctlfunc_t iocfunc;
    605 {
    606 	FILE *fp = NULL;
    607 	char *s;
    608 
    609 	yylineNum = 1;
    610 	(void) yysettab(yywords);
    611 
    612 	s = getenv("YYDEBUG");
    613 	if (s)
    614 		yydebug = atoi(s);
    615 	else
    616 		yydebug = 0;
    617 
    618 	if (strcmp(filename, "-")) {
    619 		fp = fopen(filename, "r");
    620 		if (!fp) {
    621 			fprintf(stderr, "fopen(%s) failed: %s\n", filename,
    622 				STRERROR(errno));
    623 			return -1;
    624 		}
    625 	} else
    626 		fp = stdin;
    627 
    628 	while (ippool_parsesome(fd, fp, iocfunc) == 1)
    629 		;
    630 	if (fp != NULL)
    631 		fclose(fp);
    632 	return 0;
    633 }
    634 
    635 
    636 int ippool_parsesome(fd, fp, iocfunc)
    637 int fd;
    638 FILE *fp;
    639 ioctlfunc_t iocfunc;
    640 {
    641 	char *s;
    642 	int i;
    643 
    644 	poolioctl = iocfunc;
    645 
    646 	if (feof(fp))
    647 		return 0;
    648 	i = fgetc(fp);
    649 	if (i == EOF)
    650 		return 0;
    651 	if (ungetc(i, fp) == EOF)
    652 		return 0;
    653 	if (feof(fp))
    654 		return 0;
    655 	s = getenv("YYDEBUG");
    656 	if (s)
    657 		yydebug = atoi(s);
    658 	else
    659 		yydebug = 0;
    660 
    661 	yyin = fp;
    662 	yyparse();
    663 	return 1;
    664 }
    665 
    666 
    667 static iphtent_t *
    668 add_htablehosts(url)
    669 char *url;
    670 {
    671 	iphtent_t *htop, *hbot, *h;
    672 	alist_t *a, *hlist;
    673 
    674 	if (!strncmp(url, "file://", 7) || !strncmp(url, "http://", 7)) {
    675 		hlist = load_url(url);
    676 	} else {
    677 		use_inet6 = 0;
    678 
    679 		hlist = calloc(1, sizeof(*hlist));
    680 		if (hlist == NULL)
    681 			return NULL;
    682 
    683 		if (gethost(hlist->al_family, url, &hlist->al_i6addr) == -1) {
    684 			yyerror("Unknown hostname");
    685 		}
    686 	}
    687 
    688 	hbot = NULL;
    689 	htop = NULL;
    690 
    691 	for (a = hlist; a != NULL; a = a->al_next) {
    692 		h = calloc(1, sizeof(*h));
    693 		if (h == NULL)
    694 			break;
    695 
    696 		h->ipe_family = a->al_family;
    697 		h->ipe_addr = a->al_i6addr;
    698 		h->ipe_mask = a->al_i6mask;
    699 
    700 		if (hbot != NULL)
    701 			hbot->ipe_next = h;
    702 		else
    703 			htop = h;
    704 		hbot = h;
    705 	}
    706 
    707 	alist_free(hlist);
    708 
    709 	return htop;
    710 }
    711 
    712 
    713 static ip_pool_node_t *
    714 add_poolhosts(url)
    715 char *url;
    716 {
    717 	ip_pool_node_t *ptop, *pbot, *p;
    718 	alist_t *a, *hlist;
    719 
    720 	if (!strncmp(url, "file://", 7) || !strncmp(url, "http://", 7)) {
    721 		hlist = load_url(url);
    722 	} else {
    723 		use_inet6 = 0;
    724 
    725 		hlist = calloc(1, sizeof(*hlist));
    726 		if (hlist == NULL)
    727 			return NULL;
    728 
    729 		if (gethost(hlist->al_family, url, &hlist->al_i6addr) == -1) {
    730 			yyerror("Unknown hostname");
    731 		}
    732 	}
    733 
    734 	pbot = NULL;
    735 	ptop = NULL;
    736 
    737 	for (a = hlist; a != NULL; a = a->al_next) {
    738 		p = calloc(1, sizeof(*p));
    739 		if (p == NULL)
    740 			break;
    741 		p->ipn_mask.adf_addr = a->al_i6mask;
    742 
    743 		if (a->al_family == AF_INET) {
    744 			p->ipn_addr.adf_family = AF_INET;
    745 #ifdef USE_INET6
    746 		} else if (a->al_family == AF_INET6) {
    747 			p->ipn_addr.adf_family = AF_INET6;
    748 #endif
    749 		}
    750 		setadflen(&p->ipn_addr);
    751 		p->ipn_addr.adf_addr = a->al_i6addr;
    752 		p->ipn_info = a->al_not;
    753 		p->ipn_mask.adf_len = p->ipn_addr.adf_len;
    754 
    755 		if (pbot != NULL)
    756 			pbot->ipn_next = p;
    757 		else
    758 			ptop = p;
    759 		pbot = p;
    760 	}
    761 
    762 	alist_free(hlist);
    763 
    764 	return ptop;
    765 }
    766 
    767 
    768 ip_pool_node_t *
    769 read_whoisfile(file)
    770 	char *file;
    771 {
    772 	ip_pool_node_t *ntop, *ipn, node, *last;
    773 	char line[1024];
    774 	FILE *fp;
    775 
    776 	fp = fopen(file, "r");
    777 	if (fp == NULL)
    778 		return NULL;
    779 
    780 	last = NULL;
    781 	ntop = NULL;
    782 	while (fgets(line, sizeof(line) - 1, fp) != NULL) {
    783 		line[sizeof(line) - 1] = '\0';
    784 
    785 		if (parsewhoisline(line, &node.ipn_addr, &node.ipn_mask))
    786 			continue;
    787 		ipn = calloc(1, sizeof(*ipn));
    788 		if (ipn == NULL)
    789 			continue;
    790 		ipn->ipn_addr = node.ipn_addr;
    791 		ipn->ipn_mask = node.ipn_mask;
    792 		if (last == NULL)
    793 			ntop = ipn;
    794 		else
    795 			last->ipn_next = ipn;
    796 		last = ipn;
    797 	}
    798 	fclose(fp);
    799 	return ntop;
    800 }
    801 
    802 
    803 static void
    804 setadflen(afp)
    805 	addrfamily_t *afp;
    806 {
    807 	afp->adf_len = offsetof(addrfamily_t, adf_addr);
    808 	switch (afp->adf_family)
    809 	{
    810 	case AF_INET :
    811 		afp->adf_len += sizeof(struct in_addr);
    812 		break;
    813 #ifdef USE_INET6
    814 	case AF_INET6 :
    815 		afp->adf_len += sizeof(struct in6_addr);
    816 		break;
    817 #endif
    818 	default :
    819 		break;
    820 	}
    821 }
    822