/*
* NPF state tracking tests.
*
* Public Domain.
*/

#ifdef _KERNEL
#include <sys/types.h>
#include <sys/kmem.h>
#endif

#include "npf_impl.h"
#include "npf_test.h"

typedef struct {
       int             tcpfl;          /* TCP flags. */
       int             tlen;           /* TCP data length. */
       uint32_t        seq;            /* SEQ number. */
       uint32_t        ack;            /* ACK number. */
       uint32_t        win;            /* TCP Window. */
       int             flags;          /* Direction et al. */
} tcp_meta_t;

#define S       TH_SYN
#define A       TH_ACK
#define F       TH_FIN
#define OUT     0x1
#define IN      0x2
#define ERR     0x4
#define CLEAR   .flags = 0

static const tcp_meta_t packet_sequence[] = {
       /*
        *      TCP data        SEQ     ACK             WIN
        */

       /* Out of order ACK. */
       { S,    0,              9999,   0,              4096,   OUT     },
       { S|A,  0,              9,      10000,          2048,   IN      },
       { A,    0,              10000,  10,             4096,   OUT     },
       /* --- */
       { A,    0,              10,     10000,          2048,   IN      },
       { A,    1000,           10000,  10,             4096,   OUT     },
       { A,    1000,           11000,  10,             4096,   OUT     },
       { A,    0,              10,     12000,          2048,   IN      },
       { A,    0,              10,     13000,          2048,   IN      },
       { A,    1000,           12000,  10,             4096,   OUT     },
       { A,    0,              10,     11000,          1048,   IN      },
       /* --- */
       { A,    1000,           14000,  10,             4096,   OUT     },
       { A,    0,              10,     13000,          2048,   IN      },
       { CLEAR },

       /* Retransmission after out of order ACK and missing ACK. */
       { S,    0,              9999,   0,              1000,   OUT     },
       { S|A,  0,              9,      10000,          4000,   IN      },
       { A,    0,              10000,  10,             1000,   OUT     },
       /* --- */
       { A,    1000,           10000,  10,             1000,   OUT     },
       { A,    0,              10,     11000,          4000,   IN      },
       { A,    1000,           11000,  10,             1000,   OUT     },
       { A,    1000,           12000,  10,             1000,   OUT     },
       { A,    1000,           13000,  10,             1000,   OUT     },
       { A,    1000,           14000,  10,             1000,   OUT     },
       /* --- Assume the first was delayed; second was lost after us. */
       { A,    0,              10,     15000,          4000,   IN      },
       { A,    0,              10,     15000,          2000,   IN      },
       /* --- */
       { A,    1000,           12000,  10,             1000,   OUT     },
       { CLEAR },

       /* FIN exchange with retransmit. */
       { S,    0,              999,    0,              1000,   OUT     },
       { S|A,  0,              9,      1000,           2000,   IN      },
       { A,    0,              1000,   10,             1000,   OUT     },
       /* --- */
       { F,    0,              10,     1000,           2000,   IN      },
       { F,    0,              1000,   10,             1000,   OUT     },
       { A,    0,              1000,   11,             1000,   OUT     },
       /* --- */
       { F,    0,              1000,   11,             1000,   OUT     },
       { F,    0,              1000,   11,             1000,   OUT     },
       { A,    0,              11,     1001,           2000,   OUT     },
       { CLEAR },

       /* Out of window. */
       { S,    0,              9,      0,              8760,   OUT     },
       { S|A,  0,              9999,   10,             1000,   IN      },
       { A,    0,              10,     10000,          8760,   OUT     },
       /* --- */
       { A,    1460,           10000,  10,             1000,   IN      },
       { A,    1460,           11460,  10,             1000,   IN      },
       { A,    0,              10,     12920,          8760,   OUT     },
       { A,    1460,           12920,  10,             1000,   IN      },
       { A,    0,              10,     14380,          8760,   OUT     },
       { A,    1460,           17300,  10,             1000,   IN      },
       { A,    0,              10,     14380,          8760,   OUT     },
       { A,    1460,           18760,  10,             1000,   IN      },
       { A,    0,              10,     14380,          8760,   OUT     },
       { A,    1460,           20220,  10,             1000,   IN      },
       { A,    0,              10,     14380,          8760,   OUT     },
       { A,    1460,           21680,  10,             1000,   IN      },
       { A,    0,              10,     14380,          8760,   OUT     },
       /* --- */
       { A,    1460,           14380,  10,             1000,   IN      },
       { A,    1460,           23140,  10,             1000,   IN|ERR  },
       { CLEAR },

};

#undef S
#undef A
#undef F

static struct mbuf *
construct_packet(const tcp_meta_t *p)
{
       struct mbuf *m = mbuf_construct(IPPROTO_TCP);
       struct ip *ip;
       struct tcphdr *th;

       th = mbuf_return_hdrs(m, false, &ip);

       /* Imitate TCP payload, set TCP sequence numbers, flags and window. */
       ip->ip_len = htons(sizeof(struct ip) + sizeof(struct tcphdr) + p->tlen);
       th->th_seq = htonl(p->seq);
       th->th_ack = htonl(p->ack);
       th->th_flags = p->tcpfl;
       th->th_win = htons(p->win);
       return m;
}

static bool
process_packet(const int i, npf_state_t *nst, bool *snew)
{
       const tcp_meta_t *p = &packet_sequence[i];
       npf_cache_t *npc;
       int ret;

       if (p->flags == 0) {
               npf_state_destroy(nst);
               *snew = true;
               return true;
       }

       npc = get_cached_pkt(construct_packet(p), NULL, NPF_RULE_LAYER_3);
       if (*snew) {
               ret = npf_state_init(npc, nst);
               KASSERT(ret == true);
               *snew = false;
       }
       ret = npf_state_inspect(npc, nst,
           (p->flags == OUT) ? NPF_FLOW_FORW : NPF_FLOW_BACK);
       put_cached_pkt(npc);

       return ret ? true : (p->flags & ERR) != 0;
}

bool
npf_state_test(bool verbose)
{
       npf_state_t nst;
       bool snew = true;
       bool ok = true;

       for (unsigned i = 0; i < __arraycount(packet_sequence); i++) {
               if (process_packet(i, &nst, &snew)) {
                       continue;
               }
               if (verbose) {
                       printf("Failed on packet %d, state dump:\n", i);
                       npf_state_dump(&nst);
               }
               ok = false;
       }
       return ok;
}

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.