nmaprs 0.1.0

High-performance parallel network scanner with nmap-compatible CLI surface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

/* Nmap `expr_match` excerpt from osscan.cc — Nmap Public Source License (NPSL). */
#include <cctype>
#include <cstring>

/* Lengths are always supplied by Rust (`str` is not NUL-terminated). Do not use strlen. */

static inline const char *strchr_p(const char *start, const char *end, char c) {
  while (start < end && *start != c)
    start++;
  return (start < end) ? start : nullptr;
}

static bool expr_match(const char *val, size_t vlen, const char *expr, size_t explen, bool do_nested) {
  const char *p, *q, *q1;

  if (explen == 0) {
    return vlen == 0;
  }

  p = expr;
  const char *const p_end = p + explen;

  do {
    const char *nest = NULL;
    const char *subval = val;
    size_t sublen;
    q = strchr_p(p, p_end, '|');
    nest = strchr_p(p, q ? q : p_end, '[');

    if (vlen == 0) {
      if (q == p || p == p_end) {
        return true;
      } else if (!nest) {
        goto next_expr;
      }
    }

    if (do_nested && nest) {
      while (nest) {
        q1 = strchr_p(nest, p_end, ']');
        if (!q1)
          goto next_expr;
        if (q && q < q1) {
          q = strchr_p(q1, p_end, '|');
        }
        sublen = (size_t)(nest - p);
        if (strncmp(p, subval, sublen) != 0) {
          goto next_expr;
        }
        nest++;
        subval += sublen;
        size_t nlen = 0;
        while (isxdigit((unsigned char)subval[nlen])) {
          nlen++;
        }
        p = q1 + 1;
        if (nlen > 0 && expr_match(subval, nlen, nest, (size_t)(q1 - nest), false)) {
          subval += nlen;
          nest = strchr_p(p, q ? q : p_end, '[');
        } else {
          goto next_expr;
        }
      }
      sublen = vlen - (size_t)(subval - val);
      if ((explen - (size_t)(p - expr)) == sublen && strncmp(subval, p, sublen) == 0) {
        return true;
      } else {
        goto next_expr;
      }
    }
    sublen = q ? (size_t)(q - p) : explen - (size_t)(p - expr);
    if (isxdigit((unsigned char)*subval)) {
      while (*subval == '0' && vlen > 1) {
        subval++;
        vlen--;
      }
      if (*p == '>') {
        do {
          p++;
          sublen--;
        } while (*p == '0' && sublen > 1);
        if ((vlen > sublen) || (vlen == sublen && strncmp(subval, p, vlen) > 0)) {
          return true;
        }
        goto next_expr;
      } else if (*p == '<') {
        do {
          p++;
          sublen--;
        } while (*p == '0' && sublen > 1);
        if ((vlen < sublen) || (vlen == sublen && strncmp(subval, p, vlen) < 0)) {
          return true;
        }
        goto next_expr;
      } else if (isxdigit((unsigned char)*p)) {
        while (sublen > 1 && *p == '0') {
          p++;
          sublen--;
        }
        q1 = strchr_p(p, q ? q : p_end, '-');
        if (q1 != NULL) {
          if (q1 == p) {
            p--;
            sublen++;
          }
          size_t sublen1 = (size_t)(q1 - p);
          if ((vlen > sublen1) || (vlen == sublen1 && strncmp(subval, p, vlen) >= 0)) {
            p = q1 + 1;
            sublen -= (sublen1 + 1);
            while (sublen > 1 && *p == '0') {
              p++;
              sublen--;
            }
            if ((vlen < sublen) || (vlen == sublen && strncmp(subval, p, vlen) <= 0)) {
              return true;
            }
          }
          goto next_expr;
        }
      } else {
        goto next_expr;
      }
    }
    if (vlen == sublen && strncmp(p, subval, vlen) == 0) {
      return true;
    }
  next_expr:
    if (q)
      p = q + 1;
  } while (q);

  return false;
}

extern "C" unsigned char nmap_expr_match(const char *val, size_t vlen, const char *expr, size_t explen,
                                         int do_nested_i) {
  return expr_match(val, vlen, expr, explen, do_nested_i != 0) ? 1 : 0;
}