sys/netinet/libalias/alias_proxy.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2001 Charles Mott <cm@linktel.net>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 /* file: alias_proxy.c
  33
  34     This file encapsulates special operations related to transparent
  35     proxy redirection.  This is where packets with a particular destination,
  36     usually tcp port 80, are redirected to a proxy server.
  37
  38     When packets are proxied, the destination address and port are
  39     modified.  In certain cases, it is necessary to somehow encode
  40     the original address/port info into the packet.  Two methods are
  41     presently supported: addition of a [DEST addr port] string at the
  42     beginning of a tcp stream, or inclusion of an optional field
  43     in the IP header.
  44
  45     There is one public API function:
  46
  47         PacketAliasProxyRule()    -- Adds and deletes proxy
  48                                      rules.
  49
  50     Rules are stored in a linear linked list, so lookup efficiency
  51     won't be too good for large lists.
  52
  53     Initial development: April, 1998 (cjm)
  54 */
  55
  56 /* System includes */
  57 #ifdef _KERNEL
  58 #include <sys/param.h>
  59 #include <sys/ctype.h>
  60 #include <sys/libkern.h>
  61 #include <sys/limits.h>
  62 #else
  63 #include <sys/types.h>
  64 #include <ctype.h>
  65 #include <stdio.h>
  66 #include <stdlib.h>
  67 #include <netdb.h>
  68 #include <string.h>
  69 #endif
  70
  71 #include <netinet/tcp.h>
  72
  73 #ifdef _KERNEL
  74 #include <netinet/libalias/alias.h>
  75 #include <netinet/libalias/alias_local.h>
  76 #include <netinet/libalias/alias_mod.h>
  77 #else
  78 #include <arpa/inet.h>
  79
  80 #include "alias.h"              /* Public API functions for libalias */
  81 #include "alias_local.h"        /* Functions used by alias*.c */
  82 #endif
  83
  84 /*
  85     Data structures
  86  */
  87
  88 /*
  89  * A linked list of arbitrary length, based on struct proxy_entry is
  90  * used to store proxy rules.
  91  */
  92 struct proxy_entry {
  93         struct libalias *la;
  94 #define PROXY_TYPE_ENCODE_NONE      1
  95 #define PROXY_TYPE_ENCODE_TCPSTREAM 2
  96 #define PROXY_TYPE_ENCODE_IPHDR     3
  97         int             rule_index;
  98         int             proxy_type;
  99         u_char          proto;
 100         u_short         proxy_port;
 101         u_short         server_port;
 102
 103         struct in_addr  server_addr;
 104
 105         struct in_addr  src_addr;
 106         struct in_addr  src_mask;
 107
 108         struct in_addr  dst_addr;
 109         struct in_addr  dst_mask;
 110
 111         struct proxy_entry *next;
 112         struct proxy_entry *last;
 113 };
 114
 115 /*
 116     File scope variables
 117 */
 118
 119 /* Local (static) functions:
 120
 121     IpMask()                 -- Utility function for creating IP
 122                                 masks from integer (1-32) specification.
 123     IpAddr()                 -- Utility function for converting string
 124                                 to IP address
 125     IpPort()                 -- Utility function for converting string
 126                                 to port number
 127     RuleAdd()                -- Adds an element to the rule list.
 128     RuleDelete()             -- Removes an element from the rule list.
 129     RuleNumberDelete()       -- Removes all elements from the rule list
 130                                 having a certain rule number.
 131     ProxyEncodeTcpStream()   -- Adds [DEST x.x.x.x xxxx] to the beginning
 132                                 of a TCP stream.
 133     ProxyEncodeIpHeader()    -- Adds an IP option indicating the true
 134                                 destination of a proxied IP packet
 135 */
 136
 137 static int      IpMask(int, struct in_addr *);
 138 static int      IpAddr(char *, struct in_addr *);
 139 static int      IpPort(char *, int, int *);
 140 static void     RuleAdd(struct libalias *la, struct proxy_entry *);
 141 static void     RuleDelete(struct proxy_entry *);
 142 static int      RuleNumberDelete(struct libalias *la, int);
 143 static void     ProxyEncodeTcpStream(struct alias_link *, struct ip *, int);
 144 static void     ProxyEncodeIpHeader(struct ip *, int);
 145
 146 static int
 147 IpMask(int nbits, struct in_addr *mask)
 148 {
 149         int i;
 150         u_int imask;
 151
 152         if (nbits < 0 || nbits > 32)
 153                 return (-1);
 154
 155         imask = 0;
 156         for (i = 0; i < nbits; i++)
 157                 imask = (imask >> 1) + 0x80000000;
 158         mask->s_addr = htonl(imask);
 159
 160         return (0);
 161 }
 162
 163 static int
 164 IpAddr(char *s, struct in_addr *addr)
 165 {
 166         if (inet_aton(s, addr) == 0)
 167                 return (-1);
 168         else
 169                 return (0);
 170 }
 171
 172 static int
 173 IpPort(char *s, int proto, int *port)
 174 {
 175         int n;
 176
 177         n = sscanf(s, "%d", port);
 178         if (n != 1)
 179 #ifndef _KERNEL /* XXX: we accept only numeric ports in kernel */
 180         {
 181                 struct servent *se;
 182
 183                 if (proto == IPPROTO_TCP)
 184                         se = getservbyname(s, "tcp");
 185                 else if (proto == IPPROTO_UDP)
 186                         se = getservbyname(s, "udp");
 187                 else
 188                         return (-1);
 189
 190                 if (se == NULL)
 191                         return (-1);
 192
 193                 *port = (u_int)ntohs(se->s_port);
 194         }
 195 #else
 196                 return (-1);
 197 #endif
 198         return (0);
 199 }
 200
 201 void
 202 RuleAdd(struct libalias *la, struct proxy_entry *entry)
 203 {
 204         int rule_index;
 205         struct proxy_entry *ptr;
 206         struct proxy_entry *ptr_last;
 207
 208         LIBALIAS_LOCK_ASSERT(la);
 209
 210         entry->la = la;
 211         if (la->proxyList == NULL) {
 212                 la->proxyList = entry;
 213                 entry->last = NULL;
 214                 entry->next = NULL;
 215                 return;
 216         }
 217
 218         rule_index = entry->rule_index;
 219         ptr = la->proxyList;
 220         ptr_last = NULL;
 221         while (ptr != NULL) {
 222                 if (ptr->rule_index >= rule_index) {
 223                         if (ptr_last == NULL) {
 224                                 entry->next = la->proxyList;
 225                                 entry->last = NULL;
 226                                 la->proxyList->last = entry;
 227                                 la->proxyList = entry;
 228                                 return;
 229                         }
 230                         ptr_last->next = entry;
 231                         ptr->last = entry;
 232                         entry->last = ptr->last;
 233                         entry->next = ptr;
 234                         return;
 235                 }
 236                 ptr_last = ptr;
 237                 ptr = ptr->next;
 238         }
 239
 240         ptr_last->next = entry;
 241         entry->last = ptr_last;
 242         entry->next = NULL;
 243 }
 244
 245 static void
 246 RuleDelete(struct proxy_entry *entry)
 247 {
 248         struct libalias *la;
 249
 250         la = entry->la;
 251         LIBALIAS_LOCK_ASSERT(la);
 252         if (entry->last != NULL)
 253                 entry->last->next = entry->next;
 254         else
 255                 la->proxyList = entry->next;
 256
 257         if (entry->next != NULL)
 258                 entry->next->last = entry->last;
 259
 260         free(entry);
 261 }
 262
 263 static int
 264 RuleNumberDelete(struct libalias *la, int rule_index)
 265 {
 266         int err;
 267         struct proxy_entry *ptr;
 268
 269         LIBALIAS_LOCK_ASSERT(la);
 270         err = -1;
 271         ptr = la->proxyList;
 272         while (ptr != NULL) {
 273                 struct proxy_entry *ptr_next;
 274
 275                 ptr_next = ptr->next;
 276                 if (ptr->rule_index == rule_index) {
 277                         err = 0;
 278                         RuleDelete(ptr);
 279                 }
 280                 ptr = ptr_next;
 281         }
 282
 283         return (err);
 284 }
 285
 286 static void
 287 ProxyEncodeTcpStream(struct alias_link *lnk,
 288     struct ip *pip,
 289     int maxpacketsize)
 290 {
 291         int slen;
 292         char buffer[40];
 293         struct tcphdr *tc;
 294         char addrbuf[INET_ADDRSTRLEN];
 295
 296         /* Compute pointer to tcp header */
 297         tc = (struct tcphdr *)ip_next(pip);
 298
 299         /* Don't modify if once already modified */
 300         if (GetAckModified(lnk))
 301                 return;
 302
 303         /* Translate destination address and port to string form */
 304         snprintf(buffer, sizeof(buffer) - 2, "[DEST %s %d]",
 305             inet_ntoa_r(GetProxyAddress(lnk), INET_NTOA_BUF(addrbuf)),
 306             (u_int)ntohs(GetProxyPort(lnk)));
 307
 308         /* Pad string out to a multiple of two in length */
 309         slen = strlen(buffer);
 310         switch (slen % 2) {
 311         case 0:
 312                 strcat(buffer, " \n");
 313                 slen += 2;
 314                 break;
 315         case 1:
 316                 strcat(buffer, "\n");
 317                 slen += 1;
 318         }
 319
 320         /* Check for packet overflow */
 321         if ((int)(ntohs(pip->ip_len) + strlen(buffer)) > maxpacketsize)
 322                 return;
 323
 324         /* Shift existing TCP data and insert destination string */
 325         {
 326                 int dlen;
 327                 int hlen;
 328                 char *p;
 329
 330                 hlen = (pip->ip_hl + tc->th_off) << 2;
 331                 dlen = ntohs(pip->ip_len) - hlen;
 332
 333                 /* Modify first packet that has data in it */
 334                 if (dlen == 0)
 335                         return;
 336
 337                 p = (char *)pip;
 338                 p += hlen;
 339
 340                 bcopy(p, p + slen, dlen);
 341                 memcpy(p, buffer, slen);
 342         }
 343
 344         /* Save information about modified sequence number */
 345         {
 346                 int delta;
 347
 348                 SetAckModified(lnk);
 349                 tc = (struct tcphdr *)ip_next(pip);
 350                 delta = GetDeltaSeqOut(tc->th_seq, lnk);
 351                 AddSeq(lnk, delta + slen, pip->ip_hl, pip->ip_len, tc->th_seq,
 352                     tc->th_off);
 353         }
 354
 355         /* Update IP header packet length and checksum */
 356         {
 357                 int accumulate;
 358
 359                 accumulate = pip->ip_len;
 360                 pip->ip_len = htons(ntohs(pip->ip_len) + slen);
 361                 accumulate -= pip->ip_len;
 362
 363                 ADJUST_CHECKSUM(accumulate, pip->ip_sum);
 364         }
 365
 366         /* Update TCP checksum, Use TcpChecksum since so many things have
 367            already changed. */
 368
 369         tc->th_sum = 0;
 370 #ifdef _KERNEL
 371         tc->th_x2 = (TH_RES1 >> 8);
 372 #else
 373         tc->th_sum = TcpChecksum(pip);
 374 #endif
 375 }
 376
 377 static void
 378 ProxyEncodeIpHeader(struct ip *pip, int maxpacketsize)
 379 {
 380 #define OPTION_LEN_BYTES  8
 381 #define OPTION_LEN_INT16  4
 382 #define OPTION_LEN_INT32  2
 383         _Alignas(_Alignof(u_short)) u_char option[OPTION_LEN_BYTES];
 384
 385 #ifdef LIBALIAS_DEBUG
 386         fprintf(stdout, " ip cksum 1 = %x\n", (u_int)IpChecksum(pip));
 387         fprintf(stdout, "tcp cksum 1 = %x\n", (u_int)TcpChecksum(pip));
 388 #endif
 389
 390         (void)maxpacketsize;
 391
 392         /* Check to see that there is room to add an IP option */
 393         if (pip->ip_hl > (0x0f - OPTION_LEN_INT32))
 394                 return;
 395
 396         /* Build option and copy into packet */
 397         {
 398                 u_char *ptr;
 399                 struct tcphdr *tc;
 400
 401                 ptr = (u_char *) pip;
 402                 ptr += 20;
 403                 memcpy(ptr + OPTION_LEN_BYTES, ptr, ntohs(pip->ip_len) - 20);
 404
 405                 option[0] = 0x64;       /* class: 3 (reserved), option 4 */
 406                 option[1] = OPTION_LEN_BYTES;
 407
 408                 memcpy(&option[2], (u_char *)&pip->ip_dst, 4);
 409
 410                 tc = (struct tcphdr *)ip_next(pip);
 411                 memcpy(&option[6], (u_char *)&tc->th_sport, 2);
 412
 413                 memcpy(ptr, option, 8);
 414         }
 415
 416         /* Update checksum, header length and packet length */
 417         {
 418                 int i;
 419                 int accumulate;
 420                 u_short *sptr;
 421
 422                 sptr = (u_short *) option;
 423                 accumulate = 0;
 424                 for (i = 0; i < OPTION_LEN_INT16; i++)
 425                         accumulate -= *(sptr++);
 426
 427                 sptr = (u_short *) pip;
 428                 accumulate += *sptr;
 429                 pip->ip_hl += OPTION_LEN_INT32;
 430                 accumulate -= *sptr;
 431
 432                 accumulate += pip->ip_len;
 433                 pip->ip_len = htons(ntohs(pip->ip_len) + OPTION_LEN_BYTES);
 434                 accumulate -= pip->ip_len;
 435
 436                 ADJUST_CHECKSUM(accumulate, pip->ip_sum);
 437         }
 438 #undef OPTION_LEN_BYTES
 439 #undef OPTION_LEN_INT16
 440 #undef OPTION_LEN_INT32
 441 #ifdef LIBALIAS_DEBUG
 442         fprintf(stdout, " ip cksum 2 = %x\n", (u_int)IpChecksum(pip));
 443         fprintf(stdout, "tcp cksum 2 = %x\n", (u_int)TcpChecksum(pip));
 444 #endif
 445 }
 446
 447 /* Functions by other packet alias source files
 448
 449     ProxyCheck()         -- Checks whether an outgoing packet should
 450                             be proxied.
 451     ProxyModify()        -- Encodes the original destination address/port
 452                             for a packet which is to be redirected to
 453                             a proxy server.
 454 */
 455
 456 int
 457 ProxyCheck(struct libalias *la, struct in_addr *proxy_server_addr,
 458     u_short * proxy_server_port, struct in_addr src_addr,
 459     struct in_addr dst_addr, u_short dst_port, u_char ip_p)
 460 {
 461         struct proxy_entry *ptr;
 462
 463         LIBALIAS_LOCK_ASSERT(la);
 464
 465         ptr = la->proxyList;
 466         while (ptr != NULL) {
 467                 u_short proxy_port;
 468
 469                 proxy_port = ptr->proxy_port;
 470                 if ((dst_port == proxy_port || proxy_port == 0)
 471                     && ip_p == ptr->proto
 472                     && src_addr.s_addr != ptr->server_addr.s_addr) {
 473                         struct in_addr src_addr_masked;
 474                         struct in_addr dst_addr_masked;
 475
 476                         src_addr_masked.s_addr = src_addr.s_addr & ptr->src_mask.s_addr;
 477                         dst_addr_masked.s_addr = dst_addr.s_addr & ptr->dst_mask.s_addr;
 478
 479                         if ((src_addr_masked.s_addr == ptr->src_addr.s_addr)
 480                             && (dst_addr_masked.s_addr == ptr->dst_addr.s_addr)) {
 481                                 if ((*proxy_server_port = ptr->server_port) == 0)
 482                                         *proxy_server_port = dst_port;
 483                                 *proxy_server_addr = ptr->server_addr;
 484                                 return (ptr->proxy_type);
 485                         }
 486                 }
 487                 ptr = ptr->next;
 488         }
 489
 490         return (0);
 491 }
 492
 493 void
 494 ProxyModify(struct libalias *la, struct alias_link *lnk,
 495     struct ip *pip,
 496     int maxpacketsize,
 497     int proxy_type)
 498 {
 499         LIBALIAS_LOCK_ASSERT(la);
 500         (void)la;
 501
 502         switch (proxy_type) {
 503         case PROXY_TYPE_ENCODE_IPHDR:
 504                 ProxyEncodeIpHeader(pip, maxpacketsize);
 505                 break;
 506
 507         case PROXY_TYPE_ENCODE_TCPSTREAM:
 508                 ProxyEncodeTcpStream(lnk, pip, maxpacketsize);
 509                 break;
 510         }
 511 }
 512
 513 /*
 514     Public API functions
 515 */
 516
 517 /*
 518  * This function takes command strings of the form:
 519  *
 520  *   server <addr>[:<port>]
 521  *   [port <port>]
 522  *   [rule n]
 523  *   [proto tcp|udp]
 524  *   [src <addr>[/n]]
 525  *   [dst <addr>[/n]]
 526  *   [type encode_tcp_stream|encode_ip_hdr|no_encode]
 527  *
 528  *   delete <rule number>
 529  *
 530  * Subfields can be in arbitrary order.  Port numbers and addresses
 531  * must be in either numeric or symbolic form. An optional rule number
 532  * is used to control the order in which rules are searched.  If two
 533  * rules have the same number, then search order cannot be guaranteed,
 534  * and the rules should be disjoint.  If no rule number is specified,
 535  * then 0 is used, and group 0 rules are always checked before any
 536  * others.
 537  */
 538 int
 539 LibAliasProxyRule(struct libalias *la, const char *cmd)
 540 {
 541         int i, n, len, ret;
 542         int cmd_len;
 543         int token_count;
 544         int state;
 545         char *token;
 546         char buffer[256];
 547         char str_port[sizeof(buffer)];
 548         char str_server_port[sizeof(buffer)];
 549         char *res = buffer;
 550
 551         int rule_index;
 552         int proto;
 553         int proxy_type;
 554         int proxy_port;
 555         int server_port;
 556         struct in_addr server_addr;
 557         struct in_addr src_addr, src_mask;
 558         struct in_addr dst_addr, dst_mask;
 559         struct proxy_entry *proxy_entry;
 560
 561         LIBALIAS_LOCK(la);
 562         ret = 0;
 563
 564         /* Copy command line into a buffer */
 565         cmd += strspn(cmd, " \t");
 566         cmd_len = strlen(cmd);
 567         if (cmd_len > (int)(sizeof(buffer) - 1)) {
 568                 ret = -1;
 569                 goto getout;
 570         }
 571         strcpy(buffer, cmd);
 572
 573         /* Convert to lower case */
 574         len = strlen(buffer);
 575         for (i = 0; i < len; i++)
 576                 buffer[i] = tolower((unsigned char)buffer[i]);
 577
 578         /* Set default proxy type */
 579
 580         /* Set up default values */
 581         rule_index = 0;
 582         proxy_type = PROXY_TYPE_ENCODE_NONE;
 583         proto = IPPROTO_TCP;
 584         proxy_port = 0;
 585         server_addr.s_addr = 0;
 586         server_port = 0;
 587         src_addr.s_addr = 0;
 588         IpMask(0, &src_mask);
 589         dst_addr.s_addr = 0;
 590         IpMask(0, &dst_mask);
 591
 592         str_port[0] = 0;
 593         str_server_port[0] = 0;
 594
 595         /* Parse command string with state machine */
 596 #define STATE_READ_KEYWORD    0
 597 #define STATE_READ_TYPE       1
 598 #define STATE_READ_PORT       2
 599 #define STATE_READ_SERVER     3
 600 #define STATE_READ_RULE       4
 601 #define STATE_READ_DELETE     5
 602 #define STATE_READ_PROTO      6
 603 #define STATE_READ_SRC        7
 604 #define STATE_READ_DST        8
 605         state = STATE_READ_KEYWORD;
 606         token = strsep(&res, " \t");
 607         token_count = 0;
 608         while (token != NULL) {
 609                 token_count++;
 610                 switch (state) {
 611                 case STATE_READ_KEYWORD:
 612                         if (strcmp(token, "type") == 0)
 613                                 state = STATE_READ_TYPE;
 614                         else if (strcmp(token, "port") == 0)
 615                                 state = STATE_READ_PORT;
 616                         else if (strcmp(token, "server") == 0)
 617                                 state = STATE_READ_SERVER;
 618                         else if (strcmp(token, "rule") == 0)
 619                                 state = STATE_READ_RULE;
 620                         else if (strcmp(token, "delete") == 0)
 621                                 state = STATE_READ_DELETE;
 622                         else if (strcmp(token, "proto") == 0)
 623                                 state = STATE_READ_PROTO;
 624                         else if (strcmp(token, "src") == 0)
 625                                 state = STATE_READ_SRC;
 626                         else if (strcmp(token, "dst") == 0)
 627                                 state = STATE_READ_DST;
 628                         else {
 629                                 ret = -1;
 630                                 goto getout;
 631                         }
 632                         break;
 633
 634                 case STATE_READ_TYPE:
 635                         if (strcmp(token, "encode_ip_hdr") == 0)
 636                                 proxy_type = PROXY_TYPE_ENCODE_IPHDR;
 637                         else if (strcmp(token, "encode_tcp_stream") == 0)
 638                                 proxy_type = PROXY_TYPE_ENCODE_TCPSTREAM;
 639                         else if (strcmp(token, "no_encode") == 0)
 640                                 proxy_type = PROXY_TYPE_ENCODE_NONE;
 641                         else {
 642                                 ret = -1;
 643                                 goto getout;
 644                         }
 645                         state = STATE_READ_KEYWORD;
 646                         break;
 647
 648                 case STATE_READ_PORT:
 649                         strcpy(str_port, token);
 650                         state = STATE_READ_KEYWORD;
 651                         break;
 652
 653                 case STATE_READ_SERVER: {
 654                         int err;
 655                         char *p;
 656                         char s[sizeof(buffer)];
 657
 658                         p = token;
 659                         while (*p != ':' && *p != 0)
 660                                 p++;
 661
 662                         if (*p != ':') {
 663                                 err = IpAddr(token, &server_addr);
 664                                 if (err) {
 665                                         ret = -1;
 666                                         goto getout;
 667                                 }
 668                         } else {
 669                                 *p = ' ';
 670
 671                                 n = sscanf(token, "%s %s", s, str_server_port);
 672                                 if (n != 2) {
 673                                         ret = -1;
 674                                         goto getout;
 675                                 }
 676
 677                                 err = IpAddr(s, &server_addr);
 678                                 if (err) {
 679                                         ret = -1;
 680                                         goto getout;
 681                                 }
 682                         }
 683
 684                         state = STATE_READ_KEYWORD;
 685                         break;
 686                 }
 687                 case STATE_READ_RULE:
 688                         n = sscanf(token, "%d", &rule_index);
 689                         if (n != 1 || rule_index < 0) {
 690                                 ret = -1;
 691                                 goto getout;
 692                         }
 693                         state = STATE_READ_KEYWORD;
 694                         break;
 695
 696                 case STATE_READ_DELETE: {
 697                         int err;
 698                         int rule_to_delete;
 699
 700                         if (token_count != 2) {
 701                                 ret = -1;
 702                                 goto getout;
 703                         }
 704
 705                         n = sscanf(token, "%d", &rule_to_delete);
 706                         if (n != 1) {
 707                                 ret = -1;
 708                                 goto getout;
 709                         }
 710                         err = RuleNumberDelete(la, rule_to_delete);
 711                         if (err)
 712                                 ret = -1;
 713                         else
 714                                 ret = 0;
 715                         goto getout;
 716                 }
 717
 718                 case STATE_READ_PROTO:
 719                         if (strcmp(token, "tcp") == 0)
 720                                 proto = IPPROTO_TCP;
 721                         else if (strcmp(token, "udp") == 0)
 722                                 proto = IPPROTO_UDP;
 723                         else {
 724                                 ret = -1;
 725                                 goto getout;
 726                         }
 727                         state = STATE_READ_KEYWORD;
 728                         break;
 729
 730                 case STATE_READ_SRC:
 731                 case STATE_READ_DST: {
 732                         int err;
 733                         char *p;
 734                         struct in_addr mask;
 735                         struct in_addr addr;
 736
 737                         p = token;
 738                         while (*p != '/' && *p != 0)
 739                                 p++;
 740
 741                         if (*p != '/') {
 742                                 IpMask(32, &mask);
 743                                 err = IpAddr(token, &addr);
 744                                 if (err) {
 745                                         ret = -1;
 746                                         goto getout;
 747                                 }
 748                         } else {
 749                                 int nbits;
 750                                 char s[sizeof(buffer)];
 751
 752                                 *p = ' ';
 753                                 n = sscanf(token, "%s %d", s, &nbits);
 754                                 if (n != 2) {
 755                                         ret = -1;
 756                                         goto getout;
 757                                 }
 758
 759                                 err = IpAddr(s, &addr);
 760                                 if (err) {
 761                                         ret = -1;
 762                                         goto getout;
 763                                 }
 764
 765                                 err = IpMask(nbits, &mask);
 766                                 if (err) {
 767                                         ret = -1;
 768                                         goto getout;
 769                                 }
 770                         }
 771
 772                         if (state == STATE_READ_SRC) {
 773                                 src_addr = addr;
 774                                 src_mask = mask;
 775                         } else {
 776                                 dst_addr = addr;
 777                                 dst_mask = mask;
 778                         }
 779
 780                         state = STATE_READ_KEYWORD;
 781                         break;
 782                 }
 783
 784                 default:
 785                         ret = -1;
 786                         goto getout;
 787                         break;
 788                 }
 789
 790                 do {
 791                         token = strsep(&res, " \t");
 792                 } while (token != NULL && !*token);
 793         }
 794 #undef STATE_READ_KEYWORD
 795 #undef STATE_READ_TYPE
 796 #undef STATE_READ_PORT
 797 #undef STATE_READ_SERVER
 798 #undef STATE_READ_RULE
 799 #undef STATE_READ_DELETE
 800 #undef STATE_READ_PROTO
 801 #undef STATE_READ_SRC
 802 #undef STATE_READ_DST
 803
 804         /* Convert port strings to numbers.
 805            This needs to be done after the string is parsed, because
 806            the prototype might not be designated before the ports
 807            (which might be symbolic entries in /etc/services) */
 808
 809         if (strlen(str_port) != 0) {
 810                 int err;
 811
 812                 err = IpPort(str_port, proto, &proxy_port);
 813                 if (err) {
 814                         ret = -1;
 815                         goto getout;
 816                 }
 817         } else {
 818                 proxy_port = 0;
 819         }
 820
 821         if (strlen(str_server_port) != 0) {
 822                 int err;
 823
 824                 err = IpPort(str_server_port, proto, &server_port);
 825                 if (err) {
 826                         ret = -1;
 827                         goto getout;
 828                 }
 829         } else {
 830                 server_port = 0;
 831         }
 832
 833         /* Check that at least the server address has been defined */
 834         if (server_addr.s_addr == 0) {
 835                 ret = -1;
 836                 goto getout;
 837         }
 838
 839         /* Add to linked list */
 840         proxy_entry = malloc(sizeof(struct proxy_entry));
 841         if (proxy_entry == NULL) {
 842                 ret = -1;
 843                 goto getout;
 844         }
 845
 846         proxy_entry->proxy_type = proxy_type;
 847         proxy_entry->rule_index = rule_index;
 848         proxy_entry->proto = proto;
 849         proxy_entry->proxy_port = htons(proxy_port);
 850         proxy_entry->server_port = htons(server_port);
 851         proxy_entry->server_addr = server_addr;
 852         proxy_entry->src_addr.s_addr = src_addr.s_addr & src_mask.s_addr;
 853         proxy_entry->dst_addr.s_addr = dst_addr.s_addr & dst_mask.s_addr;
 854         proxy_entry->src_mask = src_mask;
 855         proxy_entry->dst_mask = dst_mask;
 856
 857         RuleAdd(la, proxy_entry);
 858
 859 getout:
 860         LIBALIAS_UNLOCK(la);
 861         return (ret);
 862 }