gstpcapparse.c 16.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
 * Copyright 2007 Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/**
 * SECTION:element-pcapparse
 *
23
24
 * Extracts payloads from Ethernet-encapsulated IP packets.
 * Use #GstPcapParse:src-ip, #GstPcapParse:dst-ip,
25
26
27
 * #GstPcapParse:src-port and #GstPcapParse:dst-port to restrict which packets
 * should be included.
 *
28
 * <refsect2>
29
30
31
32
33
34
 * <title>Example pipelines</title>
 * |[
 * gst-launch-0.10 filesrc location=h264crasher.pcap ! pcapparse ! rtph264depay
 * ! ffdec_h264 ! fakesink
 * ]| Read from a pcap dump file using filesrc, extract the raw UDP packets,
 * depayload and decode them.
35
36
37
38
39
40
41
42
43
 * </refsect2>
 */

/* TODO:
 * - React on state-change and update state accordingly.
 * - Implement support for timestamping the buffers.
 */

#ifdef HAVE_CONFIG_H
44
#include <config.h>
45
46
#endif

47
48
#include "gstpcapparse.h"

49
50
#include <string.h>

51
#ifndef G_OS_WIN32
52
53
#include <arpa/inet.h>
#include <netinet/in.h>
54
#include <string.h>
55
56
57
58
59
60
61
62
63
64
65
#else
#include <winsock2.h>
#endif

enum
{
  PROP_0,
  PROP_SRC_IP,
  PROP_DST_IP,
  PROP_SRC_PORT,
  PROP_DST_PORT,
Wim Taymans's avatar
Wim Taymans committed
66
  PROP_CAPS,
67
  PROP_OFFSET,
Wim Taymans's avatar
Wim Taymans committed
68
  PROP_LAST
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
};

GST_DEBUG_CATEGORY_STATIC (gst_pcap_parse_debug);
#define GST_CAT_DEFAULT gst_pcap_parse_debug

static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("raw/x-pcap"));

static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS_ANY);

Wim Taymans's avatar
Wim Taymans committed
84
static void gst_pcap_parse_finalize (GObject * object);
85
86
87
88
89
90
91
92
static void gst_pcap_parse_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec);
static void gst_pcap_parse_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec);

static void gst_pcap_parse_reset (GstPcapParse * self);

static GstFlowReturn gst_pcap_parse_chain (GstPad * pad, GstBuffer * buffer);
93
static gboolean gst_pcap_sink_event (GstPad * pad, GstEvent * event);
94
95
96
97
98
99
100
101
102
103
104
105
106

GST_BOILERPLATE (GstPcapParse, gst_pcap_parse, GstElement, GST_TYPE_ELEMENT);

static void
gst_pcap_parse_base_init (gpointer gclass)
{
  GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);

  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&sink_template));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&src_template));

107
108
109
110
  gst_element_class_set_details_simple (element_class, "PCapParse",
      "Raw/Parser",
      "Parses a raw pcap stream",
      "Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>");
111
112
113
114
115
116
117
}

static void
gst_pcap_parse_class_init (GstPcapParseClass * klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

Wim Taymans's avatar
Wim Taymans committed
118
  gobject_class->finalize = gst_pcap_parse_finalize;
119
120
121
122
123
  gobject_class->get_property = gst_pcap_parse_get_property;
  gobject_class->set_property = gst_pcap_parse_set_property;

  g_object_class_install_property (gobject_class,
      PROP_SRC_IP, g_param_spec_string ("src-ip", "Source IP",
124
125
          "Source IP to restrict to", "",
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
126
127
128

  g_object_class_install_property (gobject_class,
      PROP_DST_IP, g_param_spec_string ("dst-ip", "Destination IP",
129
130
          "Destination IP to restrict to", "",
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
131
132
133
134

  g_object_class_install_property (gobject_class,
      PROP_SRC_PORT, g_param_spec_int ("src-port", "Source port",
          "Source port to restrict to", -1, G_MAXUINT16, -1,
135
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
136
137
138
139

  g_object_class_install_property (gobject_class,
      PROP_DST_PORT, g_param_spec_int ("dst-port", "Destination port",
          "Destination port to restrict to", -1, G_MAXUINT16, -1,
140
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
141

Wim Taymans's avatar
Wim Taymans committed
142
143
  g_object_class_install_property (gobject_class, PROP_CAPS,
      g_param_spec_boxed ("caps", "Caps",
144
145
          "The caps of the source pad", GST_TYPE_CAPS,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
Wim Taymans's avatar
Wim Taymans committed
146

147
148
149
150
151
  g_object_class_install_property (gobject_class, PROP_OFFSET,
      g_param_spec_int64 ("offset", "Offset",
          "Relative timestamp offset (ns) to apply (-1 = use absolute packet time)",
          -1, G_MAXINT64, -1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

152
153
154
155
156
157
158
159
160
161
  GST_DEBUG_CATEGORY_INIT (gst_pcap_parse_debug, "pcapparse", 0, "pcap parser");
}

static void
gst_pcap_parse_init (GstPcapParse * self, GstPcapParseClass * gclass)
{
  self->sink_pad = gst_pad_new_from_static_template (&sink_template, "sink");
  gst_pad_set_chain_function (self->sink_pad,
      GST_DEBUG_FUNCPTR (gst_pcap_parse_chain));
  gst_pad_use_fixed_caps (self->sink_pad);
162
163
  gst_pad_set_event_function (self->sink_pad,
      GST_DEBUG_FUNCPTR (gst_pcap_sink_event));
164
165
166
167
168
169
170
171
172
173
  gst_element_add_pad (GST_ELEMENT (self), self->sink_pad);

  self->src_pad = gst_pad_new_from_static_template (&src_template, "src");
  gst_pad_use_fixed_caps (self->src_pad);
  gst_element_add_pad (GST_ELEMENT (self), self->src_pad);

  self->src_ip = -1;
  self->dst_ip = -1;
  self->src_port = -1;
  self->dst_port = -1;
174
  self->offset = -1;
175
176
177
178
179
180
181

  self->adapter = gst_adapter_new ();

  gst_pcap_parse_reset (self);
}

static void
Wim Taymans's avatar
Wim Taymans committed
182
gst_pcap_parse_finalize (GObject * object)
183
184
185
186
{
  GstPcapParse *self = GST_PCAP_PARSE (object);

  g_object_unref (self->adapter);
Wim Taymans's avatar
Wim Taymans committed
187
188
  if (self->caps)
    gst_caps_unref (self->caps);
189

Wim Taymans's avatar
Wim Taymans committed
190
  G_OBJECT_CLASS (parent_class)->finalize (object);
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
}

static const gchar *
get_ip_address_as_string (gint64 ip_addr)
{
  if (ip_addr >= 0) {
    struct in_addr addr;
    addr.s_addr = ip_addr;
    return inet_ntoa (addr);
  } else {
    return "";
  }
}

static void
set_ip_address_from_string (gint64 * ip_addr, const gchar * ip_str)
{
  if (ip_str[0] != '\0') {
    gulong addr = inet_addr (ip_str);
    if (addr != INADDR_NONE)
      *ip_addr = addr;
  } else {
    *ip_addr = -1;
  }
}

static void
gst_pcap_parse_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstPcapParse *self = GST_PCAP_PARSE (object);

  switch (prop_id) {
    case PROP_SRC_IP:
      g_value_set_string (value, get_ip_address_as_string (self->src_ip));
      break;

    case PROP_DST_IP:
      g_value_set_string (value, get_ip_address_as_string (self->dst_ip));
      break;

    case PROP_SRC_PORT:
      g_value_set_int (value, self->src_port);
      break;

    case PROP_DST_PORT:
      g_value_set_int (value, self->dst_port);
      break;

Wim Taymans's avatar
Wim Taymans committed
240
241
242
243
    case PROP_CAPS:
      gst_value_set_caps (value, self->caps);
      break;

244
245
246
247
    case PROP_OFFSET:
      g_value_set_int64 (value, self->offset);
      break;

248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_pcap_parse_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstPcapParse *self = GST_PCAP_PARSE (object);

  switch (prop_id) {
    case PROP_SRC_IP:
      set_ip_address_from_string (&self->src_ip, g_value_get_string (value));
      break;

    case PROP_DST_IP:
      set_ip_address_from_string (&self->dst_ip, g_value_get_string (value));
      break;

    case PROP_SRC_PORT:
      self->src_port = g_value_get_int (value);
      break;

    case PROP_DST_PORT:
      self->dst_port = g_value_get_int (value);
      break;

Wim Taymans's avatar
Wim Taymans committed
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
    case PROP_CAPS:
    {
      const GstCaps *new_caps_val;
      GstCaps *new_caps, *old_caps;

      new_caps_val = gst_value_get_caps (value);
      if (new_caps_val == NULL) {
        new_caps = gst_caps_new_any ();
      } else {
        new_caps = gst_caps_copy (new_caps_val);
      }

      old_caps = self->caps;
      self->caps = new_caps;
      if (old_caps)
        gst_caps_unref (old_caps);

      gst_pad_set_caps (self->src_pad, new_caps);
      break;
    }
297
298
299
300
301

    case PROP_OFFSET:
      self->offset = g_value_get_int64 (value);
      break;

302
303
304
305
306
307
308
309
310
311
312
313
314
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_pcap_parse_reset (GstPcapParse * self)
{
  self->initialized = FALSE;
  self->swap_endian = FALSE;
  self->cur_packet_size = -1;
  self->buffer_offset = 0;
315
  self->cur_ts = GST_CLOCK_TIME_NONE;
316
  self->base_ts = GST_CLOCK_TIME_NONE;
317
  self->newsegment_sent = FALSE;
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338

  gst_adapter_clear (self->adapter);
}

static guint32
gst_pcap_parse_read_uint32 (GstPcapParse * self, const guint8 * p)
{
  guint32 val = *((guint32 *) p);

  if (self->swap_endian) {
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
    return GUINT32_FROM_BE (val);
#else
    return GUINT32_FROM_LE (val);
#endif
  } else {
    return val;
  }
}

#define ETH_HEADER_LEN    14
339
#define SLL_HEADER_LEN    16
340
341
342
343
#define IP_HEADER_MIN_LEN 20
#define UDP_HEADER_LEN     8

#define IP_PROTO_UDP      17
344
345
#define IP_PROTO_TCP      6

346
347
348
349
350
351

static gboolean
gst_pcap_parse_scan_frame (GstPcapParse * self,
    const guint8 * buf,
    gint buf_size, const guint8 ** payload, gint * payload_size)
{
352
  const guint8 *buf_ip = 0;
353
  const guint8 *buf_proto;
354
355
356
357
358
359
  guint16 eth_type;
  guint8 b;
  guint8 ip_header_size;
  guint8 ip_protocol;
  guint32 ip_src_addr;
  guint32 ip_dst_addr;
360
361
362
  guint16 src_port;
  guint16 dst_port;
  guint16 len;
363

364
365
366
367
  switch (self->linktype) {
    case DLT_ETHER:
      if (buf_size < ETH_HEADER_LEN + IP_HEADER_MIN_LEN + UDP_HEADER_LEN)
        return FALSE;
368

369
370
371
372
373
374
375
376
377
378
379
      eth_type = GUINT16_FROM_BE (*((guint16 *) (buf + 12)));
      if (eth_type != 0x800)
        return FALSE;

      buf_ip = buf + ETH_HEADER_LEN;
      break;
    case DLT_SLL:
      if (buf_size < SLL_HEADER_LEN + IP_HEADER_MIN_LEN + UDP_HEADER_LEN)
        return FALSE;

      eth_type = GUINT16_FROM_BE (*((guint16 *) (buf + 2)));
380

381
382
383
384
385
386
      if (eth_type != 1)
        return FALSE;

      buf_ip = buf + SLL_HEADER_LEN;
      break;
  }
387
388
389
390
391
392
393
394
395
396

  b = *buf_ip;
  if (((b >> 4) & 0x0f) != 4)
    return FALSE;

  ip_header_size = (b & 0x0f) * 4;
  if (buf_ip + ip_header_size > buf + buf_size)
    return FALSE;

  ip_protocol = *(buf_ip + 9);
397
  GST_LOG_OBJECT (self, "ip proto %d", (gint) ip_protocol);
398

399
  if (ip_protocol != IP_PROTO_UDP && ip_protocol != IP_PROTO_TCP)
400
401
    return FALSE;

402
403
  /* ip info */
  ip_src_addr = *((guint32 *) (buf_ip + 12));
404
  ip_dst_addr = *((guint32 *) (buf_ip + 16));
405
  buf_proto = buf_ip + ip_header_size;
406

407
408
409
  /* ok for tcp and udp */
  src_port = GUINT16_FROM_BE (*((guint16 *) (buf_proto + 0)));
  dst_port = GUINT16_FROM_BE (*((guint16 *) (buf_proto + 2)));
410

411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
  /* extract some params and data according to protocol */
  if (ip_protocol == IP_PROTO_UDP) {
    len = GUINT16_FROM_BE (*((guint16 *) (buf_proto + 4)));
    if (len < UDP_HEADER_LEN || buf_proto + len > buf + buf_size)
      return FALSE;

    *payload = buf_proto + UDP_HEADER_LEN;
    *payload_size = len - UDP_HEADER_LEN;
  } else {
    if (buf_proto + 12 >= buf + buf_size)
      return FALSE;
    len = (buf_proto[12] >> 4) * 4;
    if (buf_proto + len > buf + buf_size)
      return FALSE;

    /* all remaining data following tcp header is payload */
    *payload = buf_proto + len;
    *payload_size = self->cur_packet_size - (buf_proto - buf) - len;
  }

  /* but still filter as configured */
  if (self->src_ip >= 0 && ip_src_addr != self->src_ip)
433
434
    return FALSE;

435
  if (self->dst_ip >= 0 && ip_dst_addr != self->dst_ip)
436
437
    return FALSE;

438
  if (self->src_port >= 0 && src_port != self->src_port)
439
440
    return FALSE;

441
442
  if (self->dst_port >= 0 && dst_port != self->dst_port)
    return FALSE;
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476

  return TRUE;
}

static GstFlowReturn
gst_pcap_parse_chain (GstPad * pad, GstBuffer * buffer)
{
  GstPcapParse *self = GST_PCAP_PARSE (GST_PAD_PARENT (pad));
  GstFlowReturn ret = GST_FLOW_OK;

  gst_adapter_push (self->adapter, buffer);

  while (ret == GST_FLOW_OK) {
    gint avail;
    const guint8 *data;

    avail = gst_adapter_available (self->adapter);

    if (self->initialized) {
      if (self->cur_packet_size >= 0) {
        if (avail < self->cur_packet_size)
          break;

        if (self->cur_packet_size > 0) {
          const guint8 *payload_data;
          gint payload_size;

          data = gst_adapter_peek (self->adapter, self->cur_packet_size);

          if (gst_pcap_parse_scan_frame (self, data, self->cur_packet_size,
                  &payload_data, &payload_size)) {
            GstBuffer *out_buf;

            ret = gst_pad_alloc_buffer_and_set_caps (self->src_pad,
Wim Taymans's avatar
Wim Taymans committed
477
                self->buffer_offset, payload_size, self->caps, &out_buf);
478
479

            if (ret == GST_FLOW_OK) {
480

481
482
483
              if (GST_CLOCK_TIME_IS_VALID (self->cur_ts)) {
                if (!GST_CLOCK_TIME_IS_VALID (self->base_ts))
                  self->base_ts = self->cur_ts;
484
485
486
487
                if (self->offset >= 0) {
                  self->cur_ts -= self->base_ts;
                  self->cur_ts += self->offset;
                }
488
489
              }

490
              memcpy (GST_BUFFER_DATA (out_buf), payload_data, payload_size);
491
492
493
494
495
496
497
498
499
500
              GST_BUFFER_TIMESTAMP (out_buf) = self->cur_ts;

              if (!self->newsegment_sent &&
                  GST_CLOCK_TIME_IS_VALID (self->cur_ts)) {
                GstEvent *newsegment =
                    gst_event_new_new_segment (FALSE, 1, GST_FORMAT_TIME,
                    self->cur_ts, -1, 0);
                gst_pad_push_event (self->src_pad, newsegment);
                self->newsegment_sent = TRUE;
              }
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524

              ret = gst_pad_push (self->src_pad, out_buf);

              self->buffer_offset += payload_size;
            }
          }

          gst_adapter_flush (self->adapter, self->cur_packet_size);
        }

        self->cur_packet_size = -1;
      } else {
        guint32 ts_sec;
        guint32 ts_usec;
        guint32 incl_len;

        if (avail < 16)
          break;

        data = gst_adapter_peek (self->adapter, 16);

        ts_sec = gst_pcap_parse_read_uint32 (self, data + 0);
        ts_usec = gst_pcap_parse_read_uint32 (self, data + 4);
        incl_len = gst_pcap_parse_read_uint32 (self, data + 8);
525
        /* orig_len = gst_pcap_parse_read_uint32 (self, data + 12); */
526
527
528

        gst_adapter_flush (self->adapter, 16);

529
        self->cur_ts = ts_sec * GST_SECOND + ts_usec * GST_USECOND;
530
531
532
        self->cur_packet_size = incl_len;
      }
    } else {
533
534
535
      guint32 magic;
      guint32 linktype;
      guint16 major_version;
536
537
538
539
540
541
542

      if (avail < 24)
        break;

      data = gst_adapter_peek (self->adapter, 24);

      magic = *((guint32 *) data);
543
      major_version = *((guint16 *) (data + 4));
544

545
      if (magic == 0xa1b2c3d4) {
546
        self->swap_endian = FALSE;
547
      } else if (magic == 0xd4c3b2a1) {
548
        self->swap_endian = TRUE;
549
550
551
552
553
554
555
556
557
        major_version = major_version << 8 | major_version >> 8;
      } else {
        GST_ELEMENT_ERROR (self, STREAM, WRONG_TYPE, (NULL),
            ("File is not a libpcap file, magic is %X", magic));
        ret = GST_FLOW_ERROR;
        goto out;
      }

      if (major_version != 2) {
558
        GST_ELEMENT_ERROR (self, STREAM, WRONG_TYPE, (NULL),
559
            ("File is not a libpcap major version 2, but %u", major_version));
560
        ret = GST_FLOW_ERROR;
561
        goto out;
562
      }
563

564
565
      linktype = gst_pcap_parse_read_uint32 (self, data + 20);

566
      if (linktype != DLT_ETHER && linktype != DLT_SLL) {
567
        GST_ELEMENT_ERROR (self, STREAM, WRONG_TYPE, (NULL),
568
            ("Only dumps of type Ethernet or Linux Coooked (SLL) understood,"
569
570
571
572
573
                " type %d unknown", linktype));
        ret = GST_FLOW_ERROR;
        goto out;
      }

574
575
      self->linktype = linktype;

576
577
      gst_adapter_flush (self->adapter, 24);
      self->initialized = TRUE;
578
579
580
    }
  }

581
out:
582
583
584
585
586
587
  if (ret != GST_FLOW_OK)
    gst_pcap_parse_reset (self);

  return ret;
}

588
589
590
591
592
593
594
595
596
static gboolean
gst_pcap_sink_event (GstPad * pad, GstEvent * event)
{
  gboolean ret = TRUE;
  GstPcapParse *self = GST_PCAP_PARSE (gst_pad_get_parent (pad));

  switch (GST_EVENT_TYPE (event)) {
    case GST_EVENT_NEWSEGMENT:
      /* Drop it, we'll replace it with our own */
Wim Taymans's avatar
Wim Taymans committed
597
      gst_event_unref (event);
598
599
600
      break;
    default:
      ret = gst_pad_push_event (self->src_pad, event);
Wim Taymans's avatar
Wim Taymans committed
601
      break;
602
603
604
605
606
607
608
609
  }

  gst_object_unref (self);

  return ret;
}


610
611
612
613
614
615
616
617
618
619
620
621
static gboolean
plugin_init (GstPlugin * plugin)
{
  return gst_element_register (plugin, "pcapparse",
      GST_RANK_NONE, GST_TYPE_PCAP_PARSE);
}

GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
    GST_VERSION_MINOR,
    "pcapparse",
    "Element parsing raw pcap streams",
    plugin_init, VERSION, "LGPL", "GStreamer", "http://gstreamer.net/")