trafgen_proto.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Subject to the GPL, version 2.
   4  */
   5
   6 #include <stddef.h>
   7 #include <string.h>
   8 #include <netinet/in.h>
   9 #include <linux/if_ether.h>
  10
  11 #include "dev.h"
  12 #include "xmalloc.h"
  13 #include "trafgen_conf.h"
  14 #include "trafgen_l2.h"
  15 #include "trafgen_l3.h"
  16 #include "trafgen_l4.h"
  17 #include "trafgen_proto.h"
  18
  19 #define field_shift_and_mask(f, v) (((v) << (f)->shift) & \
  20                 ((f)->mask ? (f)->mask : (0xffffffff)))
  21
  22 #define field_unmask_and_unshift(f, v) (((v) & \
  23                 ((f)->mask ? (f)->mask : (0xffffffff))) >> (f)->shift)
  24
  25 struct ctx {
  26         const char *dev;
  27 };
  28 static struct ctx ctx;
  29
  30 static const struct proto_ops *registered_ops[__PROTO_MAX];
  31
  32 struct proto_hdr *proto_lower_header(struct proto_hdr *hdr)
  33 {
  34         struct packet *pkt = packet_get(hdr->pkt_id);
  35         struct proto_hdr **headers = &pkt->headers[0];
  36
  37         if (hdr->index == 0)
  38                 return NULL;
  39
  40         return headers[hdr->index - 1];
  41 }
  42
  43 struct proto_hdr *proto_upper_header(struct proto_hdr *hdr)
  44 {
  45         struct packet *pkt = packet_get(hdr->pkt_id);
  46         struct proto_hdr **headers = &pkt->headers[0];
  47         size_t headers_count = pkt->headers_count;
  48
  49         if (hdr->index == headers_count - 1)
  50                 return NULL;
  51
  52         return headers[hdr->index + 1];
  53 }
  54
  55 uint8_t *proto_header_ptr(struct proto_hdr *hdr)
  56 {
  57         return &packet_get(hdr->pkt_id)->payload[hdr->pkt_offset];
  58 }
  59
  60 static const struct proto_ops *proto_ops_by_id(enum proto_id id)
  61 {
  62         const struct proto_ops *ops = registered_ops[id];
  63
  64         bug_on(ops->id != id);
  65         return ops;
  66 }
  67
  68 void proto_ops_register(const struct proto_ops *ops)
  69 {
  70         bug_on(ops->id >= __PROTO_MAX);
  71         registered_ops[ops->id] = ops;
  72 }
  73
  74 static void proto_fields_realloc(struct proto_hdr *hdr, size_t count)
  75 {
  76         hdr->fields = xrealloc(hdr->fields, count * sizeof(*hdr->fields));
  77         hdr->fields_count = count;
  78 }
  79
  80 void proto_header_fields_add(struct proto_hdr *hdr,
  81                              const struct proto_field *fields, size_t count)
  82 {
  83         struct packet *pkt = packet_get(hdr->pkt_id);
  84         struct proto_field *f;
  85         int i;
  86
  87         if (!hdr->fields)
  88                 hdr->pkt_offset = pkt->len;
  89
  90         proto_fields_realloc(hdr, hdr->fields_count + count);
  91
  92         for (i = 0; count >= 1; count--, i++) {
  93                 f = &hdr->fields[hdr->fields_count - count];
  94
  95                 f->id = fields[i].id;
  96                 f->len = fields[i].len;
  97                 f->is_set = false;
  98                 f->shift = fields[i].shift;
  99                 f->mask = fields[i].mask;
 100                 f->pkt_offset = hdr->pkt_offset + fields[i].offset;
 101                 f->hdr = hdr;
 102
 103                 if (f->pkt_offset + f->len > pkt->len) {
 104                         hdr->len += f->len;
 105                         set_fill(0, (f->pkt_offset + f->len) - pkt->len);
 106                 }
 107         }
 108 }
 109
 110 struct proto_field *proto_field_by_id(struct proto_hdr *hdr, uint32_t fid)
 111 {
 112         /* Assume the fields are stored in the same order as the respective
 113          * enum, so the index can be used for faster lookup here.
 114          */
 115         bug_on(hdr->fields[fid].id != fid);
 116
 117         return &hdr->fields[fid];
 118 }
 119
 120 bool proto_field_is_set(struct proto_hdr *hdr, uint32_t fid)
 121 {
 122         struct proto_field *field = proto_field_by_id(hdr, fid);
 123
 124         return field ? field->is_set : false;
 125 }
 126
 127 struct proto_hdr *proto_header_push(enum proto_id pid)
 128 {
 129         struct packet *pkt = current_packet();
 130         struct proto_hdr **headers = &pkt->headers[0];
 131         const struct proto_ops *ops = proto_ops_by_id(pid);
 132         struct proto_hdr *hdr;
 133
 134         bug_on(pkt->headers_count >= PROTO_MAX_LAYERS);
 135
 136         hdr = xzmalloc(sizeof(*hdr));
 137         hdr->ops = ops;
 138         hdr->pkt_id = current_packet_id();
 139
 140         if (ops && ops->header_init)
 141                 ops->header_init(hdr);
 142
 143         /* This is very important to have it after header_init as
 144          * pkt->headers_count might be changed by adding default lower headers */
 145         hdr->index = pkt->headers_count;
 146
 147         headers[pkt->headers_count++] = hdr;
 148         return hdr;
 149 }
 150
 151 void proto_header_finish(struct proto_hdr *hdr)
 152 {
 153         if (hdr && hdr->ops && hdr->ops->header_finish)
 154                 hdr->ops->header_finish(hdr);
 155 }
 156
 157 struct proto_hdr *proto_lower_default_add(struct proto_hdr *upper,
 158                                           enum proto_id pid)
 159 {
 160         struct proto_hdr *current;
 161         size_t headers_count = current_packet()->headers_count;
 162         const struct proto_ops *ops;
 163
 164         if (headers_count > 0) {
 165                 current = current_packet()->headers[headers_count - 1];
 166                 ops = current->ops;
 167
 168                 if (ops->layer >= proto_ops_by_id(pid)->layer)
 169                         goto set_proto;
 170                 if (ops->id == pid)
 171                         goto set_proto;
 172         }
 173
 174         current = proto_header_push(pid);
 175         ops = current->ops;
 176
 177 set_proto:
 178         if (ops && ops->set_next_proto)
 179                 ops->set_next_proto(current, upper->ops->id);
 180
 181         return current;
 182 }
 183
 184 static void __proto_field_set_bytes(struct proto_hdr *hdr, uint32_t fid,
 185                                     const uint8_t *bytes, bool is_default,
 186                                     bool is_be)
 187 {
 188         struct proto_field *field;
 189         uint8_t *payload, *p8;
 190         uint16_t *p16;
 191         uint32_t *p32;
 192         uint32_t v32;
 193         uint16_t v16;
 194         uint8_t v8;
 195
 196         field = proto_field_by_id(hdr, fid);
 197
 198         if (is_default && field->is_set)
 199                 return;
 200
 201         payload = &packet_get(hdr->pkt_id)->payload[field->pkt_offset];
 202
 203         if (field->len == 1) {
 204                 p8 = payload;
 205                 *p8 = field->mask ? *p8 & ~field->mask : *p8;
 206
 207                 v8 = field_shift_and_mask(field, *bytes);
 208                 v8 = field->mask ? (v8 | *p8) : v8;
 209
 210                 bytes = &v8;
 211         } else if (field->len == 2) {
 212                 p16 = (uint16_t *)payload;
 213                 *p16 = be16_to_cpu(*p16);
 214                 *p16 = cpu_to_be16(field->mask ? *p16 & ~field->mask : *p16);
 215
 216                 v16 = field_shift_and_mask(field, *(const uint16_t *)bytes);
 217                 v16 = is_be ? cpu_to_be16(v16) : v16;
 218                 v16 = field->mask ? (v16 | *p16) : v16;
 219
 220                 bytes = (uint8_t *)&v16;
 221         } else if (field->len == 4) {
 222                 p32 = (uint32_t *)payload;
 223                 *p32 = be32_to_cpu(*p32);
 224                 *p32 = cpu_to_be32(field->mask ? *p32 & ~field->mask : *p32);
 225
 226                 v32 = field_shift_and_mask(field, *(const uint32_t *)bytes);
 227                 v32 = is_be ? cpu_to_be32(v32) : v32;
 228                 v32 = field->mask ? (v32 | *p32) : v32;
 229
 230                 bytes = (uint8_t *)&v32;
 231         }
 232
 233         memcpy(payload, bytes, field->len);
 234
 235         if (!is_default)
 236                 field->is_set = true;
 237 }
 238
 239 void proto_field_set_bytes(struct proto_hdr *hdr, uint32_t fid,
 240                            const uint8_t *bytes)
 241 {
 242         __proto_field_set_bytes(hdr, fid, bytes, false, false);
 243 }
 244
 245 static uint8_t *__proto_field_get_bytes(struct proto_field *field)
 246 {
 247         return &packet_get(field->hdr->pkt_id)->payload[field->pkt_offset];
 248 }
 249
 250 void proto_field_set_u8(struct proto_hdr *hdr, uint32_t fid, uint8_t val)
 251 {
 252         proto_field_set_bytes(hdr, fid, (uint8_t *)&val);
 253 }
 254
 255 uint8_t proto_field_get_u8(struct proto_hdr *hdr, uint32_t fid)
 256 {
 257         struct proto_field *field = proto_field_by_id(hdr, fid);
 258         uint8_t val = *__proto_field_get_bytes(field);
 259
 260         return field_unmask_and_unshift(field, val);
 261 }
 262
 263 void proto_field_set_u16(struct proto_hdr *hdr, uint32_t fid, uint16_t val)
 264 {
 265         proto_field_set_bytes(hdr, fid, (uint8_t *)&val);
 266 }
 267
 268 uint16_t proto_field_get_u16(struct proto_hdr *hdr, uint32_t fid)
 269 {
 270         struct proto_field *field = proto_field_by_id(hdr, fid);
 271         uint16_t val = *(uint16_t *)__proto_field_get_bytes(field);
 272
 273         return field_unmask_and_unshift(field, be16_to_cpu(val));
 274 }
 275
 276 void proto_field_set_u32(struct proto_hdr *hdr, uint32_t fid, uint32_t val)
 277 {
 278         proto_field_set_bytes(hdr, fid, (uint8_t *)&val);
 279 }
 280
 281 uint32_t proto_field_get_u32(struct proto_hdr *hdr, uint32_t fid)
 282 {
 283         struct proto_field *field = proto_field_by_id(hdr, fid);
 284         uint32_t val = *(uint32_t *)__proto_field_get_bytes(field);
 285
 286         return field_unmask_and_unshift(field, be32_to_cpu(val));
 287 }
 288
 289 void proto_field_set_default_bytes(struct proto_hdr *hdr, uint32_t fid,
 290                                    const uint8_t *bytes)
 291 {
 292         __proto_field_set_bytes(hdr, fid, bytes, true, false);
 293 }
 294
 295 void proto_field_set_default_u8(struct proto_hdr *hdr, uint32_t fid, uint8_t val)
 296 {
 297         __proto_field_set_bytes(hdr, fid, (uint8_t *)&val, true, false);
 298 }
 299
 300 void proto_field_set_default_u16(struct proto_hdr *hdr, uint32_t fid, uint16_t val)
 301 {
 302         __proto_field_set_bytes(hdr, fid, (uint8_t *)&val, true, false);
 303 }
 304
 305 void proto_field_set_default_u32(struct proto_hdr *hdr, uint32_t fid, uint32_t val)
 306 {
 307         __proto_field_set_bytes(hdr, fid, (uint8_t *)&val, true, false);
 308 }
 309
 310 void proto_field_set_be16(struct proto_hdr *hdr, uint32_t fid, uint16_t val)
 311 {
 312         __proto_field_set_bytes(hdr, fid, (uint8_t *)&val, false, true);
 313 }
 314
 315 void proto_field_set_be32(struct proto_hdr *hdr, uint32_t fid, uint32_t val)
 316 {
 317         __proto_field_set_bytes(hdr, fid, (uint8_t *)&val, false, true);
 318 }
 319
 320 void proto_field_set_default_be16(struct proto_hdr *hdr, uint32_t fid, uint16_t val)
 321 {
 322         __proto_field_set_bytes(hdr, fid, (uint8_t *)&val, true, true);
 323 }
 324
 325 void proto_field_set_default_be32(struct proto_hdr *hdr, uint32_t fid, uint32_t val)
 326 {
 327         __proto_field_set_bytes(hdr, fid, (uint8_t *)&val, true, true);
 328 }
 329
 330 static void __proto_field_set_dev_mac(struct proto_hdr *hdr, uint32_t fid,
 331                                       bool is_default)
 332 {
 333         uint8_t mac[ETH_ALEN];
 334         int ret;
 335
 336         if (proto_field_is_set(hdr, fid))
 337                 return;
 338
 339         ret = device_hw_address(ctx.dev, mac, sizeof(mac));
 340         if (ret < 0)
 341                 panic("Could not get device hw address\n");
 342
 343         __proto_field_set_bytes(hdr, fid, mac, is_default, false);
 344 }
 345
 346 void proto_field_set_dev_mac(struct proto_hdr *hdr, uint32_t fid)
 347 {
 348         __proto_field_set_dev_mac(hdr, fid, false);
 349 }
 350
 351 void proto_field_set_default_dev_mac(struct proto_hdr *hdr, uint32_t fid)
 352 {
 353         __proto_field_set_dev_mac(hdr, fid, true);
 354 }
 355
 356 static void __proto_field_set_dev_ipv4(struct proto_hdr *hdr, uint32_t fid,
 357                                        bool is_default)
 358 {
 359         struct sockaddr_storage ss = { };
 360         struct sockaddr_in *ss4;
 361         int ret;
 362
 363         if (proto_field_is_set(hdr, fid))
 364                 return;
 365
 366         ret = device_address(ctx.dev, AF_INET, &ss);
 367         if (ret < 0) {
 368                 fprintf(stderr, "Warning: Could not get device IPv4 address for %s\n", ctx.dev);
 369                 return;
 370         }
 371
 372         ss4 = (struct sockaddr_in *) &ss;
 373         __proto_field_set_bytes(hdr, fid, (uint8_t *)&ss4->sin_addr.s_addr, is_default, false);
 374 }
 375
 376 void proto_field_set_dev_ipv4(struct proto_hdr *hdr, uint32_t fid)
 377 {
 378         __proto_field_set_dev_ipv4(hdr, fid, false);
 379 }
 380
 381 void proto_field_set_default_dev_ipv4(struct proto_hdr *hdr, uint32_t fid)
 382 {
 383         __proto_field_set_dev_ipv4(hdr, fid, true);
 384 }
 385
 386 static void __proto_field_set_dev_ipv6(struct proto_hdr *hdr, uint32_t fid,
 387                                        bool is_default)
 388 {
 389         struct sockaddr_storage ss = { };
 390         struct sockaddr_in6 *ss6;
 391         int ret;
 392
 393         if (proto_field_is_set(hdr, fid))
 394                 return;
 395
 396         ret = device_address(ctx.dev, AF_INET6, &ss);
 397         if (ret < 0) {
 398                 fprintf(stderr, "Warning: Could not get device IPv6 address for %s\n", ctx.dev);
 399                 return;
 400         }
 401
 402         ss6 = (struct sockaddr_in6 *) &ss;
 403         __proto_field_set_bytes(hdr, fid, (uint8_t *)&ss6->sin6_addr.s6_addr, is_default, false);
 404 }
 405
 406 void proto_field_set_dev_ipv6(struct proto_hdr *hdr, uint32_t fid)
 407 {
 408         __proto_field_set_dev_ipv6(hdr, fid, false);
 409 }
 410
 411 void proto_field_set_default_dev_ipv6(struct proto_hdr *hdr, uint32_t fid)
 412 {
 413         __proto_field_set_dev_ipv6(hdr, fid, true);
 414 }
 415
 416 void protos_init(const char *dev)
 417 {
 418         ctx.dev = dev;
 419
 420         protos_l2_init();
 421         protos_l3_init();
 422         protos_l4_init();
 423 }
 424
 425 void proto_packet_update(uint32_t idx)
 426 {
 427         struct packet *pkt = packet_get(idx);
 428         ssize_t i;
 429
 430         for (i = pkt->headers_count - 1; i >= 0; i--) {
 431                 struct proto_hdr *hdr = pkt->headers[i];
 432
 433                 if (hdr->ops->packet_update)
 434                         hdr->ops->packet_update(hdr);
 435         }
 436 }
 437
 438 void proto_packet_finish(void)
 439 {
 440         struct proto_hdr **headers = current_packet()->headers;
 441         size_t headers_count = current_packet()->headers_count;
 442         ssize_t i;
 443
 444         /* Go down from upper layers to do last calculations (checksum) */
 445         for (i = headers_count - 1; i >= 0; i--) {
 446                 struct proto_hdr *hdr = headers[i];
 447                 const struct proto_ops *ops = hdr->ops;
 448
 449                 if (ops && ops->packet_finish)
 450                         ops->packet_finish(hdr);
 451         }
 452 }
 453
 454 static inline uint32_t field_inc(struct proto_field *field)
 455 {
 456         uint32_t min = field->func.min;
 457         uint32_t max = field->func.max;
 458         uint32_t val = field->func.val;
 459         uint32_t inc = field->func.inc;
 460         uint32_t next;
 461
 462         next = (val + inc) % (max + 1);
 463         field->func.val = max(next, min);
 464
 465         return val;
 466 }
 467
 468 static void field_inc_func(struct proto_field *field)
 469 {
 470         if (field->len == 1) {
 471                 proto_field_set_u8(field->hdr, field->id, field_inc(field));
 472         } else if (field->len == 2) {
 473                 proto_field_set_be16(field->hdr, field->id, field_inc(field));
 474         } else if (field->len == 4) {
 475                 proto_field_set_be32(field->hdr, field->id, field_inc(field));
 476         } else if (field->len > 4) {
 477                 uint8_t *bytes = __proto_field_get_bytes(field);
 478
 479                 bytes += field->len - 4;
 480
 481                 *(uint32_t *)bytes = bswap_32(field_inc(field));
 482         }
 483 }
 484
 485 static inline uint32_t field_rand(struct proto_field *field)
 486 {
 487         return field->func.min + (rand() % ((field->func.max - field->func.min) + 1));
 488 }
 489
 490 static void field_rnd_func(struct proto_field *field)
 491 {
 492         if (field->len == 1) {
 493                 proto_field_set_u8(field->hdr, field->id,
 494                                     (uint8_t) field_rand(field));
 495         } else if (field->len == 2) {
 496                 proto_field_set_be16(field->hdr, field->id,
 497                                     (uint16_t) field_rand(field));
 498         } else if (field->len == 4) {
 499                 proto_field_set_be32(field->hdr, field->id,
 500                                     (uint32_t) field_rand(field));
 501         } else if (field->len > 4) {
 502                 uint8_t *bytes = __proto_field_get_bytes(field);
 503                 uint32_t i;
 504
 505                 for (i = 0; i < field->len; i++)
 506                         bytes[i] = (uint8_t) field_rand(field);
 507         }
 508 }
 509
 510 void proto_field_func_add(struct proto_hdr *hdr, uint32_t fid,
 511                           struct proto_field_func *func)
 512 {
 513         struct proto_field *field = proto_field_by_id(hdr, fid);
 514
 515         bug_on(!func);
 516
 517         field->func.update_field = func->update_field;
 518         field->func.type = func->type;
 519         field->func.max = func->max ?: UINT32_MAX - 1;
 520         field->func.min = func->min;
 521         field->func.inc = func->inc;
 522
 523         if (func->type & PROTO_FIELD_FUNC_INC) {
 524                 if (func->type & PROTO_FIELD_FUNC_MIN)
 525                         field->func.val = func->min;
 526                 else if (field->len == 1)
 527                         field->func.val = proto_field_get_u8(hdr, fid);
 528                 else if (field->len == 2)
 529                         field->func.val = proto_field_get_u16(hdr, fid);
 530                 else if (field->len == 4)
 531                         field->func.val = proto_field_get_u32(hdr, fid);
 532                 else if (field->len > 4) {
 533                         uint8_t *bytes = __proto_field_get_bytes(field);
 534
 535                         bytes += field->len - 4;
 536                         field->func.val = bswap_32(*(uint32_t *)bytes);
 537                 }
 538
 539                 field->func.update_field = field_inc_func;
 540         } else if (func->type & PROTO_FIELD_FUNC_RND) {
 541                 field->func.update_field = field_rnd_func;
 542         }
 543 }
 544
 545 void proto_field_dyn_apply(struct proto_field *field)
 546 {
 547         if (field->func.update_field)
 548                 field->func.update_field(field);
 549
 550         if (field->hdr->ops->field_changed)
 551                 field->hdr->ops->field_changed(field);
 552 }