/* $NetBSD: parse.y,v 1.4 2023/03/17 17:12:54 andvar Exp $ */

/*-
* Copyright (c) 2010 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

%{
#include <sys/cdefs.h>

#ifndef lint
__RCSID("$NetBSD: parse.y,v 1.4 2023/03/17 17:12:54 andvar Exp $");
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include <inttypes.h>
#include <errno.h>

#include <net/if.h>
#include <netinet/in.h>
#include <net/pfvar.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/tcp_fsm.h>

#include "parser.h"

int lineno;

struct pfioc_states* states;
size_t allocated;

// XXX it is really correct ?
extern const char * const tcpstates[];


struct pfsync_state global_state;
struct pfsync_state_peer *src_peer, *dst_peer;
struct pfsync_state_peer current_peer;

static void parse_init(void);
static void add_state(void);
static bool get_pfsync_host(const char*, struct pfsync_state_host*, sa_family_t*);
static uint8_t retrieve_peer_state(const char*, int);
static bool retrieve_seq(const char*, struct pfsync_state_peer*);
static bool strtou32(const char*, uint32_t*);

%}

%union {
       uintmax_t num;
       char* str;
}

%token STATE
%token IN OUT
%token ON PROTO
%token FROM TO USING
%token ID CID EXPIRE TIMEOUT
%token SRC DST
%token SEQ  MAX_WIN WSCALE MSS
%token NOSCRUB SCRUB FLAGS TTL MODE
%token NUMBER STRING

%type <str> STRING
%type <num> NUMBER
%%

states
       : /* NOTHING */
       | state states  { parse_init(); }
       ;

state
       : STATE direction iface proto addrs id cid expire timeout src_peer dst_peer {
                       add_state();
               }
       ;

direction
       : IN {
                  global_state.direction = PF_IN;
                  src_peer = &global_state.dst;
                  dst_peer = &global_state.src;
               }
       | OUT {
                        global_state.direction = PF_OUT;
                        src_peer = &global_state.src;
                        dst_peer = &global_state.dst;
               }
       ;

iface
       : ON STRING {
                       strlcpy(global_state.ifname, $2, sizeof(global_state.ifname));
                       free($2);
               }
       ;

proto
       : PROTO STRING {
                       struct protoent *p;
                       p = getprotobyname($2);
                       if (p == NULL)
                               yyfatal("Invalid protocol name");
                       global_state.proto = p->p_proto;
                       free($2);
                       }
       | PROTO NUMBER {
                       // check that the number may be valid proto ?
                       global_state.proto = $2;
                       }
       ;

addrs
       : FROM STRING TO STRING {
               get_pfsync_host($2, &global_state.lan, &global_state.af);
               get_pfsync_host($4, &global_state.ext, &global_state.af);
               memcpy(&global_state.gwy, &global_state.lan, sizeof(struct pfsync_state_host));
               free($2);
               free($4);
               }
       | FROM STRING TO STRING USING STRING {
               get_pfsync_host($2, &global_state.lan, &global_state.af);
               get_pfsync_host($4, &global_state.ext, &global_state.af);
               get_pfsync_host($6, &global_state.gwy, &global_state.af);
               free($2);
               free($4);
               free($6);
               }
       ;

id
       : ID NUMBER {
                       if ( $2 > UINT64_MAX)
                               yyfatal("id is too big");
                       uint64_t value = (uint64_t)$2;
                       memcpy(global_state.id, &value, sizeof(global_state.id));
               }
       ;

cid
       : CID NUMBER {
                       if ( $2 > UINT32_MAX)
                               yyfatal("creator id is too big");
                       global_state.creatorid = (uint32_t)$2;
               }
       ;

expire
       : EXPIRE NUMBER {
                       if ( $2 > UINT32_MAX)
                               yyfatal("expire time is too big");
                       global_state.expire = (uint32_t) $2;
               }
       ;

timeout
       : TIMEOUT NUMBER {
                       if ($2 > UINT8_MAX)
                               yyfatal("timeout time is too big");
                       global_state.timeout = (uint8_t) $2;
               }
       ;

src_peer
       : SRC peer {
                       memcpy(src_peer, &current_peer, sizeof(current_peer));
               }
       ;

dst_peer
       : DST peer {
                       memcpy(dst_peer, &current_peer, sizeof(current_peer));
               }
       ;

peer
       : peer_state scrub
       | peer_state tcp_options scrub
       ;

peer_state
       : STATE STRING {
                       current_peer.state = retrieve_peer_state($2, global_state.proto);
                       free($2);
               }
       | STATE NUMBER {
               if ( $2 > UINT8_MAX)
                       yyfatal("peer state is too big");
               current_peer.state = $2;
               }
       ;

tcp_options
       : SEQ seqs MAX_WIN NUMBER WSCALE NUMBER {
                       if ($4 > UINT16_MAX)
                               yyfatal("max_win is too big");
                       current_peer.max_win = $4;

                       if ($6 > UINT8_MAX)
                               yyfatal("wscale is too big");
                       current_peer.wscale = $6;
               }
       | SEQ seqs MAX_WIN NUMBER WSCALE NUMBER MSS NUMBER {
                       if ($4 > UINT16_MAX)
                               yyfatal("max_win is too big");
                       current_peer.max_win = $4;

                       if ($6 > UINT8_MAX)
                               yyfatal("wscale is too big");
                       current_peer.wscale = $6;

                       if ($8 > UINT16_MAX)
                               yyfatal("mss is too big");
                       current_peer.mss = $8;
               }
       ;

seqs
       : STRING {
               if (!retrieve_seq($1, &current_peer))
                       yyfatal("invalid seq number");

               free($1);
               }
       ;

scrub
       : NOSCRUB { current_peer.scrub.scrub_flag= 0;}
       | SCRUB FLAGS NUMBER MODE NUMBER TTL NUMBER {
                       current_peer.scrub.scrub_flag= PFSYNC_SCRUB_FLAG_VALID;
                       if ($3 > UINT16_MAX)
                               yyfatal("scrub flags is too big");
                       current_peer.scrub.pfss_flags = $3;

                       if ($5 > UINT32_MAX)
                               yyfatal("scrub mode is too big");
                       current_peer.scrub.pfss_ts_mod = $5;

                       if ($7 > UINT8_MAX)
                               yyfatal("scrub ttl is too big");
                       current_peer.scrub.pfss_ttl = $7;
               }
       ;


%%

static void
parse_init(void)
{
       memset(&global_state, 0, sizeof(global_state));
       memset(&current_peer, 0, sizeof(current_peer));
       src_peer = NULL;
       dst_peer = NULL;
}

static bool
get_pfsync_host(const char* str, struct pfsync_state_host* host, sa_family_t* af)
{
       size_t count_colon, addr_len, port_len;
       const char* p, *last_colon, *first_bracket, *last_bracket;
       char buf[48];
       char buf_port[6];

       if (str == NULL || *str == '\0')
               return false;

       p = str;
       last_colon = NULL;
       count_colon = 0;

       while (*p != '\0') {
               if (*p == ':') {
                       count_colon++;
                       last_colon = p;
               }
               p++;
       }

       /*
        * If no colon, it is not an expected addr
        * If there are more than one colon, we guess that af = AF_INET6
        */

       if (count_colon == 0)
               return false;

       if (count_colon == 1)
               *af = AF_INET;
       else
               *af = AF_INET6;

       /*
        * First bracket must be next character after last colon
        * Last bracket must be the last character
        * distance between both must be <= 7
        */

       if (*(last_colon+1) == '[')
               first_bracket = last_colon + 1;
       else
               return false;

       last_bracket = str + (strlen(str) - 1);
       if (*last_bracket != ']')
               return false;

       port_len = last_bracket - first_bracket;
       if (last_bracket - first_bracket > 7)
               return false;

       memcpy(buf_port, first_bracket +1, port_len - 1);
       buf_port[port_len-1]= '\0';

       addr_len = last_colon - str;
       if (addr_len >= sizeof(buf))
               return false;
       memcpy(buf, str, addr_len);
       buf[addr_len] = '\0';

       if (inet_pton(*af, buf, &host->addr) != 1)
               return false;

       host->port = htons(atoi(buf_port));

       return true;
}

static uint8_t
retrieve_peer_state(const char* str, int proto)
{
       uint8_t i;

       if (proto == IPPROTO_TCP) {
               i = 0;
               while (i < TCP_NSTATES) {
                       if (strcmp(str, tcpstates[i]) == 0)
                               return i;
                       i++;
               }
               yyfatal("Invalid peer state");

       } else {
               if (proto == IPPROTO_UDP) {
                       const char* mystates[] = PFUDPS_NAMES;
                       i = 0;

                       while (i < PFUDPS_NSTATES) {
                               if (strcmp(str, mystates[i]) == 0)
                                       return i;
                               i++;
                       }

                       yyfatal("Invalid peer state");
               } else {
                       const char *mystates[] = PFOTHERS_NAMES;
                       i = 0;

                       while (i < PFOTHERS_NSTATES) {
                               if (strcmp(str, mystates[i]) == 0)
                                       return i;
                               i++;
                       }

                       yyfatal("Invalid peer state");
               }
       }
    /*NOTREACHED*/
       return 0;
}

static bool
strtou32(const char* str, uint32_t* res)
{
       uintmax_t u;
       errno = 0;
       u = strtoumax(str, NULL, 10);
       if (errno == ERANGE && u == UINTMAX_MAX)
               return false;
       if (u > UINT32_MAX)
               return false;
       *res = (uint32_t) u;
       return true;
}

static bool
retrieve_seq(const char* str, struct pfsync_state_peer* peer)
{
       const char* p, *p_colon, *p_comma;
       char buf[100];
       size_t size;

       if (str == NULL || *str == '\0')
               return false;

       if (*str != '[' || *(str+(strlen(str) -1)) != ']')
               return false;

       p = str;
       p_colon = NULL;
       p_comma = NULL;
       while (*p != '\0') {
               if (*p == ':') {
                       if (p_colon !=NULL)
                               return false;
                       else
                               p_colon = p;
               }

               if (*p == ',') {
                       if (p_comma != NULL)
                               return false;
                       else
                               p_comma = p;
               }
               p++;
       }

       size = p_colon - str;
       if (size > sizeof(buf))
               return false;
       memcpy(buf, str+1, size-1);
       buf[size-1] = '\0';

       if (!strtou32(buf, &peer->seqlo))
               return false;


       if (p_comma == NULL)
               size = str + strlen(str) - 1 - p_colon;
       else
               size = p_comma - p_colon;

       if (size > sizeof(buf))
               return false;
       memcpy(buf, p_colon+1, size -1);
       buf[size-1] = '\0';

       if (!strtou32(buf, &peer->seqhi))
               return false;

       if (p_comma == NULL) {
               peer->seqdiff = 0;
       } else {
               size = str + strlen(str) - 1 - p_comma;
               if (size > sizeof(buf))
                       return false;
               memcpy(buf, p_comma +1, size -1);
               buf[size-1] = '\0';

               if (!strtou32(buf, &peer->seqdiff))
                       return false;
       }

       return true;
}

static void
add_state(void)
{

       if (allocated == 0) {
               allocated = 5;
               states->ps_buf = malloc(allocated * sizeof(struct pfsync_state));
               if (states->ps_buf == NULL)
                       yyfatal("Not enough memory");
       }

       if (allocated == (states->ps_len / sizeof(struct pfsync_state))) {
               void *buf;
               allocated = allocated * 2 + 1;
               buf = realloc(states->ps_buf, allocated * sizeof(struct pfsync_state));
               if (buf == NULL) {
                       free(states->ps_buf);
                       yyfatal("Not enough memory");
               }
               states->ps_buf = buf;
       }

}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.