source: swig/libtrace_wrap.c @ 47de0aa

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since 47de0aa was 47de0aa, checked in by Daniel Lawson <dlawson@…>, 15 years ago
  • Cosmetic changes to trace_help() output
  • inclusion of some m4 handlers to deal with swig and python, lifted from http://autoconf-archive.cryp.to/. These are GPLd, which needs to be taken into account if libtrace licensing changes!
  • updated the swig bindings for python. Mostly api compliant now. Still possibly a memory leak to do with displaying ip addresses - I haven't touched this particular part of the code yet.
  • Property mode set to 100644
File size: 170.0 KB
Line 
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11#define SWIGPYTHON
12/***********************************************************************
13 *
14 *  This section contains generic SWIG labels for method/variable
15 *  declarations/attributes, and other compiler dependent labels.
16 *
17 ************************************************************************/
18
19/* template workaround for compilers that cannot correctly implement the C++ standard */
20#ifndef SWIGTEMPLATEDISAMBIGUATOR
21#  if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22#    define SWIGTEMPLATEDISAMBIGUATOR template
23#  else
24#    define SWIGTEMPLATEDISAMBIGUATOR
25#  endif
26#endif
27
28/* inline attribute */
29#ifndef SWIGINLINE
30# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
31#   define SWIGINLINE inline
32# else
33#   define SWIGINLINE
34# endif
35#endif
36
37/* attribute recognised by some compilers to avoid 'unused' warnings */
38#ifndef SWIGUNUSED
39# if defined(__GNUC__) || defined(__ICC)
40#   define SWIGUNUSED __attribute__ ((unused))
41# else
42#   define SWIGUNUSED
43# endif
44#endif
45
46/* internal SWIG method */
47#ifndef SWIGINTERN
48# define SWIGINTERN static SWIGUNUSED
49#endif
50
51/* internal inline SWIG method */
52#ifndef SWIGINTERNINLINE
53# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
54#endif
55
56/* exporting methods for Windows DLLs */
57#ifndef SWIGEXPORT
58# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
59#   if defined(STATIC_LINKED)
60#     define SWIGEXPORT
61#   else
62#     define SWIGEXPORT __declspec(dllexport)
63#   endif
64# else
65#   define SWIGEXPORT
66# endif
67#endif
68
69/* calling conventions for Windows */
70#ifndef SWIGSTDCALL
71# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
72#   define SWIGSTDCALL __stdcall
73# else
74#   define SWIGSTDCALL
75# endif
76#endif
77
78
79
80#include <Python.h>
81
82/***********************************************************************
83 * swigrun.swg
84 *
85 *     This file contains generic CAPI SWIG runtime support for pointer
86 *     type checking.
87 *
88 ************************************************************************/
89
90/* This should only be incremented when either the layout of swig_type_info changes,
91   or for whatever reason, the runtime changes incompatibly */
92#define SWIG_RUNTIME_VERSION "2"
93
94/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
95#ifdef SWIG_TYPE_TABLE
96# define SWIG_QUOTE_STRING(x) #x
97# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
98# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
99#else
100# define SWIG_TYPE_TABLE_NAME
101#endif
102
103/*
104  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
105  creating a static or dynamic library from the swig runtime code.
106  In 99.9% of the cases, swig just needs to declare them as 'static'.
107 
108  But only do this if is strictly necessary, ie, if you have problems
109  with your compiler or so.
110*/
111
112#ifndef SWIGRUNTIME
113# define SWIGRUNTIME SWIGINTERN
114#endif
115
116#ifndef SWIGRUNTIMEINLINE
117# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
118#endif
119
120#include <string.h>
121
122#ifdef __cplusplus
123extern "C" {
124#endif
125
126typedef void *(*swig_converter_func)(void *);
127typedef struct swig_type_info *(*swig_dycast_func)(void **);
128
129/* Structure to store inforomation on one type */
130typedef struct swig_type_info {
131  const char             *name;                 /* mangled name of this type */
132  const char             *str;                  /* human readable name of this type */
133  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
134  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
135  void                   *clientdata;           /* language specific type data */
136} swig_type_info;
137
138/* Structure to store a type and conversion function used for casting */
139typedef struct swig_cast_info {
140  swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
141  swig_converter_func     converter;            /* function to cast the void pointers */
142  struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
143  struct swig_cast_info  *prev;                 /* pointer to the previous cast */
144} swig_cast_info;
145
146/* Structure used to store module information
147 * Each module generates one structure like this, and the runtime collects
148 * all of these structures and stores them in a circularly linked list.*/
149typedef struct swig_module_info {
150  swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
151  size_t                 size;                  /* Number of types in this module */
152  struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
153  swig_type_info         **type_initial;        /* Array of initially generated type structures */
154  swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
155  void                    *clientdata;          /* Language specific module data */
156} swig_module_info;
157
158
159/*
160  Compare two type names skipping the space characters, therefore
161  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
162
163  Return 0 when the two name types are equivalent, as in
164  strncmp, but skipping ' '.
165*/
166SWIGRUNTIME int
167SWIG_TypeNameComp(const char *f1, const char *l1,
168                  const char *f2, const char *l2) {
169  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
170    while ((*f1 == ' ') && (f1 != l1)) ++f1;
171    while ((*f2 == ' ') && (f2 != l2)) ++f2;
172    if (*f1 != *f2) return (int)(*f1 - *f2);
173  }
174  return (l1 - f1) - (l2 - f2);
175}
176
177/*
178  Check type equivalence in a name list like <name1>|<name2>|...
179  Return 0 if not equal, 1 if equal
180*/
181SWIGRUNTIME int
182SWIG_TypeEquiv(const char *nb, const char *tb) {
183  int equiv = 0;
184  const char* te = tb + strlen(tb);
185  const char* ne = nb;
186  while (!equiv && *ne) {
187    for (nb = ne; *ne; ++ne) {
188      if (*ne == '|') break;
189    }
190    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
191    if (*ne) ++ne;
192  }
193  return equiv;
194}
195
196/*
197  Check type equivalence in a name list like <name1>|<name2>|...
198  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
199*/
200SWIGRUNTIME int
201SWIG_TypeCompare(const char *nb, const char *tb) {
202  int equiv = 0;
203  const char* te = tb + strlen(tb);
204  const char* ne = nb;
205  while (!equiv && *ne) {
206    for (nb = ne; *ne; ++ne) {
207      if (*ne == '|') break;
208    }
209    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
210    if (*ne) ++ne;
211  }
212  return equiv;
213}
214
215
216/* think of this as a c++ template<> or a scheme macro */
217#define SWIG_TypeCheck_Template(comparison, ty)         \
218  if (ty) {                                             \
219    swig_cast_info *iter = ty->cast;                    \
220    while (iter) {                                      \
221      if (comparison) {                                 \
222        if (iter == ty->cast) return iter;              \
223        /* Move iter to the top of the linked list */   \
224        iter->prev->next = iter->next;                  \
225        if (iter->next)                                 \
226          iter->next->prev = iter->prev;                \
227        iter->next = ty->cast;                          \
228        iter->prev = 0;                                 \
229        if (ty->cast) ty->cast->prev = iter;            \
230        ty->cast = iter;                                \
231        return iter;                                    \
232      }                                                 \
233      iter = iter->next;                                \
234    }                                                   \
235  }                                                     \
236  return 0
237
238/*
239  Check the typename
240*/
241SWIGRUNTIME swig_cast_info *
242SWIG_TypeCheck(const char *c, swig_type_info *ty) {
243  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
244}
245
246/* Same as previous function, except strcmp is replaced with a pointer comparison */
247SWIGRUNTIME swig_cast_info *
248SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
249  SWIG_TypeCheck_Template(iter->type == from, into);
250}
251
252/*
253  Cast a pointer up an inheritance hierarchy
254*/
255SWIGRUNTIMEINLINE void *
256SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
257  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
258}
259
260/*
261   Dynamic pointer casting. Down an inheritance hierarchy
262*/
263SWIGRUNTIME swig_type_info *
264SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
265  swig_type_info *lastty = ty;
266  if (!ty || !ty->dcast) return ty;
267  while (ty && (ty->dcast)) {
268    ty = (*ty->dcast)(ptr);
269    if (ty) lastty = ty;
270  }
271  return lastty;
272}
273
274/*
275  Return the name associated with this type
276*/
277SWIGRUNTIMEINLINE const char *
278SWIG_TypeName(const swig_type_info *ty) {
279  return ty->name;
280}
281
282/*
283  Return the pretty name associated with this type,
284  that is an unmangled type name in a form presentable to the user.
285*/
286SWIGRUNTIME const char *
287SWIG_TypePrettyName(const swig_type_info *type) {
288  /* The "str" field contains the equivalent pretty names of the
289     type, separated by vertical-bar characters.  We choose
290     to print the last name, as it is often (?) the most
291     specific. */
292  if (type->str != NULL) {
293    const char *last_name = type->str;
294    const char *s;
295    for (s = type->str; *s; s++)
296      if (*s == '|') last_name = s+1;
297    return last_name;
298  }
299  else
300    return type->name;
301}
302
303/*
304   Set the clientdata field for a type
305*/
306SWIGRUNTIME void
307SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
308  swig_cast_info *cast = ti->cast;
309  /* if (ti->clientdata == clientdata) return; */
310  ti->clientdata = clientdata;
311 
312  while (cast) {
313    if (!cast->converter) {
314      swig_type_info *tc = cast->type;
315      if (!tc->clientdata) {
316        SWIG_TypeClientData(tc, clientdata);
317      }
318    }   
319    cast = cast->next;
320  }
321}
322
323/*
324  Search for a swig_type_info structure only by mangled name
325  Search is a O(log #types)
326 
327  We start searching at module start, and finish searching when start == end. 
328  Note: if start == end at the beginning of the function, we go all the way around
329  the circular list.
330*/
331SWIGRUNTIME swig_type_info *
332SWIG_MangledTypeQueryModule(swig_module_info *start, 
333                            swig_module_info *end, 
334                            const char *name) {
335  swig_module_info *iter = start;
336  do {
337    if (iter->size) {
338      register size_t l = 0;
339      register size_t r = iter->size - 1;
340      do {
341        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
342        register size_t i = (l + r) >> 1; 
343        const char *iname = iter->types[i]->name;
344        if (iname) {
345          register int compare = strcmp(name, iname);
346          if (compare == 0) {       
347            return iter->types[i];
348          } else if (compare < 0) {
349            if (i) {
350              r = i - 1;
351            } else {
352              break;
353            }
354          } else if (compare > 0) {
355            l = i + 1;
356          }
357        } else {
358          break; /* should never happen */
359        }
360      } while (l <= r);
361    }
362    iter = iter->next;
363  } while (iter != end);
364  return 0;
365}
366
367/*
368  Search for a swig_type_info structure for either a mangled name or a human readable name.
369  It first searches the mangled names of the types, which is a O(log #types)
370  If a type is not found it then searches the human readable names, which is O(#types).
371 
372  We start searching at module start, and finish searching when start == end. 
373  Note: if start == end at the beginning of the function, we go all the way around
374  the circular list.
375*/
376SWIGRUNTIME swig_type_info *
377SWIG_TypeQueryModule(swig_module_info *start, 
378                     swig_module_info *end, 
379                     const char *name) {
380  /* STEP 1: Search the name field using binary search */
381  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
382  if (ret) {
383    return ret;
384  } else {
385    /* STEP 2: If the type hasn't been found, do a complete search
386       of the str field (the human readable name) */
387    swig_module_info *iter = start;
388    do {
389      register size_t i = 0;
390      for (; i < iter->size; ++i) {
391        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
392          return iter->types[i];
393      }
394      iter = iter->next;
395    } while (iter != end);
396  }
397 
398  /* neither found a match */
399  return 0;
400}
401
402
403/*
404   Pack binary data into a string
405*/
406SWIGRUNTIME char *
407SWIG_PackData(char *c, void *ptr, size_t sz) {
408  static const char hex[17] = "0123456789abcdef";
409  register const unsigned char *u = (unsigned char *) ptr;
410  register const unsigned char *eu =  u + sz;
411  for (; u != eu; ++u) {
412    register unsigned char uu = *u;
413    *(c++) = hex[(uu & 0xf0) >> 4];
414    *(c++) = hex[uu & 0xf];
415  }
416  return c;
417}
418
419/*
420   Unpack binary data from a string
421*/
422SWIGRUNTIME const char *
423SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
424  register unsigned char *u = (unsigned char *) ptr;
425  register const unsigned char *eu = u + sz;
426  for (; u != eu; ++u) {
427    register char d = *(c++);
428    register unsigned char uu = 0;
429    if ((d >= '0') && (d <= '9'))
430      uu = ((d - '0') << 4);
431    else if ((d >= 'a') && (d <= 'f'))
432      uu = ((d - ('a'-10)) << 4);
433    else 
434      return (char *) 0;
435    d = *(c++);
436    if ((d >= '0') && (d <= '9'))
437      uu |= (d - '0');
438    else if ((d >= 'a') && (d <= 'f'))
439      uu |= (d - ('a'-10));
440    else 
441      return (char *) 0;
442    *u = uu;
443  }
444  return c;
445}
446
447/*
448   Pack 'void *' into a string buffer.
449*/
450SWIGRUNTIME char *
451SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
452  char *r = buff;
453  if ((2*sizeof(void *) + 2) > bsz) return 0;
454  *(r++) = '_';
455  r = SWIG_PackData(r,&ptr,sizeof(void *));
456  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
457  strcpy(r,name);
458  return buff;
459}
460
461SWIGRUNTIME const char *
462SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
463  if (*c != '_') {
464    if (strcmp(c,"NULL") == 0) {
465      *ptr = (void *) 0;
466      return name;
467    } else {
468      return 0;
469    }
470  }
471  return SWIG_UnpackData(++c,ptr,sizeof(void *));
472}
473
474SWIGRUNTIME char *
475SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
476  char *r = buff;
477  size_t lname = (name ? strlen(name) : 0);
478  if ((2*sz + 2 + lname) > bsz) return 0;
479  *(r++) = '_';
480  r = SWIG_PackData(r,ptr,sz);
481  if (lname) {
482    strncpy(r,name,lname+1);
483  } else {
484    *r = 0;
485  }
486  return buff;
487}
488
489SWIGRUNTIME const char *
490SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
491  if (*c != '_') {
492    if (strcmp(c,"NULL") == 0) {
493      memset(ptr,0,sz);
494      return name;
495    } else {
496      return 0;
497    }
498  }
499  return SWIG_UnpackData(++c,ptr,sz);
500}
501
502#ifdef __cplusplus
503}
504#endif
505
506/* -----------------------------------------------------------------------------
507 * SWIG API. Portion that goes into the runtime
508 * ----------------------------------------------------------------------------- */
509
510#ifdef __cplusplus
511extern "C" {
512#endif
513
514/* -----------------------------------------------------------------------------
515 * for internal method declarations
516 * ----------------------------------------------------------------------------- */
517
518#ifndef SWIGINTERN
519#  define SWIGINTERN static SWIGUNUSED
520#endif
521
522#ifndef SWIGINTERNINLINE
523#  define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
524#endif
525
526/*
527  Exception handling in wrappers
528*/
529#define SWIG_fail                goto fail
530#define SWIG_arg_fail(arg)       SWIG_Python_ArgFail(arg)
531#define SWIG_append_errmsg(msg)   SWIG_Python_AddErrMesg(msg,0)
532#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
533#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
534#define SWIG_null_ref(type)       SWIG_Python_NullRef(type)
535
536/*
537  Contract support
538*/
539#define SWIG_contract_assert(expr, msg) \
540 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
541
542/* -----------------------------------------------------------------------------
543 * Constant declarations
544 * ----------------------------------------------------------------------------- */
545
546/* Constant Types */
547#define SWIG_PY_INT     1
548#define SWIG_PY_FLOAT   2
549#define SWIG_PY_STRING  3
550#define SWIG_PY_POINTER 4
551#define SWIG_PY_BINARY  5
552
553/* Constant information structure */
554typedef struct swig_const_info {
555    int type;
556    char *name;
557    long lvalue;
558    double dvalue;
559    void   *pvalue;
560    swig_type_info **ptype;
561} swig_const_info;
562
563
564/* -----------------------------------------------------------------------------
565 * Alloc. memory flags
566 * ----------------------------------------------------------------------------- */
567#define SWIG_OLDOBJ  1
568#define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
569#define SWIG_PYSTR   SWIG_NEWOBJ + 1
570
571#ifdef __cplusplus
572}
573#endif
574
575
576/***********************************************************************
577 * pyrun.swg
578 *
579 *     This file contains the runtime support for Python modules
580 *     and includes code for managing global variables and pointer
581 *     type checking.
582 *
583 * Author : David Beazley (beazley@cs.uchicago.edu)
584 ************************************************************************/
585
586/* Common SWIG API */
587#define SWIG_ConvertPtr(obj, pp, type, flags)    SWIG_Python_ConvertPtr(obj, pp, type, flags)
588#define SWIG_NewPointerObj(p, type, flags)       SWIG_Python_NewPointerObj(p, type, flags)
589#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
590 
591
592/* Python-specific SWIG API */
593#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags)   SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
594#define SWIG_NewPackedObj(ptr, sz, type)              SWIG_Python_NewPackedObj(ptr, sz, type)
595
596/* Runtime API */
597#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
598#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
599
600/* -----------------------------------------------------------------------------
601 * Pointer declarations
602 * ----------------------------------------------------------------------------- */
603/*
604  Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
605  C/C++ pointers in the python side. Very useful for debugging, but
606  not always safe.
607*/
608#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
609#  define SWIG_COBJECT_TYPES
610#endif
611
612/* Flags for pointer conversion */
613#define SWIG_POINTER_EXCEPTION     0x1
614#define SWIG_POINTER_DISOWN        0x2
615
616
617/* Add PyOS_snprintf for old Pythons */
618#if PY_VERSION_HEX < 0x02020000
619#define PyOS_snprintf snprintf
620#endif
621
622#ifdef __cplusplus
623extern "C" {
624#endif
625
626/* -----------------------------------------------------------------------------
627 * Create a new pointer string
628 * ----------------------------------------------------------------------------- */
629#ifndef SWIG_BUFFER_SIZE
630#define SWIG_BUFFER_SIZE 1024
631#endif
632
633/* A crude PyString_FromFormat implementation for old Pythons */
634#if PY_VERSION_HEX < 0x02020000
635static PyObject *
636PyString_FromFormat(const char *fmt, ...) {
637  va_list ap;
638  char buf[SWIG_BUFFER_SIZE * 2];
639  int res;
640  va_start(ap, fmt);
641  res = vsnprintf(buf, sizeof(buf), fmt, ap);
642  va_end(ap);
643  return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
644}
645#endif
646
647#if PY_VERSION_HEX < 0x01060000
648#define PyObject_Del(op) PyMem_DEL((op))
649#endif
650
651#if defined(SWIG_COBJECT_TYPES)
652#if !defined(SWIG_COBJECT_PYTHON)
653/* -----------------------------------------------------------------------------
654 * Implements a simple Swig Object type, and use it instead of PyCObject
655 * ----------------------------------------------------------------------------- */
656
657typedef struct {
658  PyObject_HEAD
659  void *ptr;
660  const char *desc;
661} PySwigObject;
662
663/* Declarations for objects of type PySwigObject */
664
665SWIGRUNTIME int
666PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
667{
668  char result[SWIG_BUFFER_SIZE];
669  flags = flags;
670  if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
671    fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
672    return 0; 
673  } else {
674    return 1; 
675  }
676}
677 
678SWIGRUNTIME PyObject *
679PySwigObject_repr(PySwigObject *v)
680{
681  char result[SWIG_BUFFER_SIZE];
682  return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
683    PyString_FromFormat("<Swig Object at %s>", result) : 0;
684}
685
686SWIGRUNTIME PyObject *
687PySwigObject_str(PySwigObject *v)
688{
689  char result[SWIG_BUFFER_SIZE];
690  return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
691    PyString_FromString(result) : 0;
692}
693
694SWIGRUNTIME PyObject *
695PySwigObject_long(PySwigObject *v)
696{
697  return PyLong_FromVoidPtr(v->ptr);
698}
699
700SWIGRUNTIME PyObject *
701PySwigObject_format(const char* fmt, PySwigObject *v)
702{
703  PyObject *res = NULL;
704  PyObject *args = PyTuple_New(1);
705  if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
706    PyObject *ofmt = PyString_FromString(fmt);
707    if (ofmt) {
708      res = PyString_Format(ofmt,args);
709      Py_DECREF(ofmt);
710    }
711    Py_DECREF(args);
712  } 
713  return res;
714}
715
716SWIGRUNTIME PyObject *
717PySwigObject_oct(PySwigObject *v)
718{
719  return PySwigObject_format("%o",v);
720}
721
722SWIGRUNTIME PyObject *
723PySwigObject_hex(PySwigObject *v)
724{
725  return PySwigObject_format("%x",v);
726}
727
728SWIGRUNTIME int
729PySwigObject_compare(PySwigObject *v, PySwigObject *w)
730{
731  int c = strcmp(v->desc, w->desc);
732  if (c) {
733    return (c > 0) ? 1 : -1;
734  } else {
735    void *i = v->ptr;
736    void *j = w->ptr;
737    return (i < j) ? -1 : ((i > j) ? 1 : 0);
738  }
739}
740
741SWIGRUNTIME void
742PySwigObject_dealloc(PySwigObject *self)
743{
744  PyObject_Del(self);
745}
746
747SWIGRUNTIME PyTypeObject*
748PySwigObject_type(void) {
749  static char pyswigobject_type__doc__[] = 
750    "Swig object carries a C/C++ instance pointer";
751 
752  static PyNumberMethods PySwigObject_as_number = {
753    (binaryfunc)0, /*nb_add*/
754    (binaryfunc)0, /*nb_subtract*/
755    (binaryfunc)0, /*nb_multiply*/
756    (binaryfunc)0, /*nb_divide*/
757    (binaryfunc)0, /*nb_remainder*/
758    (binaryfunc)0, /*nb_divmod*/
759    (ternaryfunc)0,/*nb_power*/
760    (unaryfunc)0,  /*nb_negative*/
761    (unaryfunc)0,  /*nb_positive*/
762    (unaryfunc)0,  /*nb_absolute*/
763    (inquiry)0,    /*nb_nonzero*/
764    0,             /*nb_invert*/
765    0,             /*nb_lshift*/
766    0,             /*nb_rshift*/
767    0,             /*nb_and*/
768    0,             /*nb_xor*/
769    0,             /*nb_or*/
770    (coercion)0,   /*nb_coerce*/
771    (unaryfunc)PySwigObject_long, /*nb_int*/
772    (unaryfunc)PySwigObject_long, /*nb_long*/
773    (unaryfunc)0,                 /*nb_float*/
774    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
775    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
776#if PY_VERSION_HEX >= 0x02020000
777    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
778#elif PY_VERSION_HEX >= 0x02000000
779    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
780#endif
781  };
782
783  static PyTypeObject pyswigobject_type
784#if !defined(__cplusplus)
785  ; 
786  static int type_init = 0;
787  if (!type_init) {
788    PyTypeObject tmp
789#endif
790    = {
791    PyObject_HEAD_INIT(&PyType_Type)
792    0,                                  /*ob_size*/
793    (char *)"PySwigObject",             /*tp_name*/
794    sizeof(PySwigObject),               /*tp_basicsize*/
795    0,                                  /*tp_itemsize*/
796    /* methods */
797    (destructor)PySwigObject_dealloc,   /*tp_dealloc*/
798    (printfunc)PySwigObject_print,      /*tp_print*/
799    (getattrfunc)0,                     /*tp_getattr*/
800    (setattrfunc)0,                     /*tp_setattr*/
801    (cmpfunc)PySwigObject_compare,      /*tp_compare*/
802    (reprfunc)PySwigObject_repr,        /*tp_repr*/
803    &PySwigObject_as_number,            /*tp_as_number*/
804    0,                                  /*tp_as_sequence*/
805    0,                                  /*tp_as_mapping*/
806    (hashfunc)0,                        /*tp_hash*/
807    (ternaryfunc)0,                     /*tp_call*/
808    (reprfunc)PySwigObject_str,         /*tp_str*/
809    /* Space for future expansion */
810    0,0,0,0,
811    pyswigobject_type__doc__,           /* Documentation string */
812#if PY_VERSION_HEX >= 0x02000000
813    0,                                  /* tp_traverse */
814    0,                                  /* tp_clear */
815#endif
816#if PY_VERSION_HEX >= 0x02010000
817    0,                                  /* tp_richcompare */
818    0,                                  /* tp_weaklistoffset */
819#endif
820#if PY_VERSION_HEX >= 0x02020000
821    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
822#endif
823#if PY_VERSION_HEX >= 0x02030000
824    0,                                  /* tp_del */
825#endif
826#ifdef COUNT_ALLOCS
827    0,0,0,0                             /* tp_alloc -> tp_next */
828#endif
829    };
830#if !defined(__cplusplus)
831    pyswigobject_type = tmp;
832    type_init = 1;
833  }
834#endif
835  return &pyswigobject_type;
836}
837
838SWIGRUNTIME PyObject *
839PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
840{
841  PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
842  if (self) {
843    self->ptr = ptr;
844    self->desc = desc;
845  }
846  return (PyObject *)self;
847}
848
849SWIGRUNTIMEINLINE void *
850PySwigObject_AsVoidPtr(PyObject *self)
851{
852  return ((PySwigObject *)self)->ptr;
853}
854
855SWIGRUNTIMEINLINE const char *
856PySwigObject_GetDesc(PyObject *self)
857{
858  return ((PySwigObject *)self)->desc;
859}
860
861SWIGRUNTIMEINLINE int
862PySwigObject_Check(PyObject *op) {
863  return ((op)->ob_type == PySwigObject_type()) 
864    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
865}
866
867/* -----------------------------------------------------------------------------
868 * Implements a simple Swig Packed type, and use it instead of string
869 * ----------------------------------------------------------------------------- */
870
871typedef struct {
872  PyObject_HEAD
873  void *pack;
874  const char *desc;
875  size_t size;
876} PySwigPacked;
877
878SWIGRUNTIME int
879PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
880{
881  char result[SWIG_BUFFER_SIZE];
882  flags = flags;
883  fputs("<Swig Packed ", fp); 
884  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
885    fputs("at ", fp); 
886    fputs(result, fp); 
887  }
888  fputs(v->desc,fp); 
889  fputs(">", fp);
890  return 0; 
891}
892 
893SWIGRUNTIME PyObject *
894PySwigPacked_repr(PySwigPacked *v)
895{
896  char result[SWIG_BUFFER_SIZE];
897  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
898    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
899  } else {
900    return PyString_FromFormat("<Swig Packed %s>", v->desc);
901  } 
902}
903
904SWIGRUNTIME PyObject *
905PySwigPacked_str(PySwigPacked *v)
906{
907  char result[SWIG_BUFFER_SIZE];
908  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
909    return PyString_FromFormat("%s%s", result, v->desc);
910  } else {
911    return PyString_FromString(v->desc);
912  } 
913}
914
915SWIGRUNTIME int
916PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
917{
918  int c = strcmp(v->desc, w->desc);
919  if (c) {
920    return (c > 0) ? 1 : -1;
921  } else {
922    size_t i = v->size;
923    size_t j = w->size;
924    int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
925    return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
926  }
927}
928
929SWIGRUNTIME void
930PySwigPacked_dealloc(PySwigPacked *self)
931{
932  free(self->pack);
933  PyObject_Del(self);
934}
935
936SWIGRUNTIME PyTypeObject*
937PySwigPacked_type(void) {
938  static char pyswigpacked_type__doc__[] = 
939    "Swig object carries a C/C++ instance pointer";
940  static PyTypeObject pyswigpacked_type
941#if !defined(__cplusplus)
942  ;
943  static int type_init = 0; 
944  if (!type_init) {
945    PyTypeObject tmp
946#endif
947    = {
948    PyObject_HEAD_INIT(&PyType_Type)
949    0,                                  /*ob_size*/
950    (char *)"PySwigPacked",             /*tp_name*/
951    sizeof(PySwigPacked),               /*tp_basicsize*/
952    0,                                  /*tp_itemsize*/
953    /* methods */
954    (destructor)PySwigPacked_dealloc,   /*tp_dealloc*/
955    (printfunc)PySwigPacked_print,      /*tp_print*/
956    (getattrfunc)0,                     /*tp_getattr*/
957    (setattrfunc)0,                     /*tp_setattr*/
958    (cmpfunc)PySwigPacked_compare,      /*tp_compare*/
959    (reprfunc)PySwigPacked_repr,        /*tp_repr*/
960    0,                                  /*tp_as_number*/
961    0,                                  /*tp_as_sequence*/
962    0,                                  /*tp_as_mapping*/
963    (hashfunc)0,                        /*tp_hash*/
964    (ternaryfunc)0,                     /*tp_call*/
965    (reprfunc)PySwigPacked_str,         /*tp_str*/
966    /* Space for future expansion */
967    0,0,0,0,
968    pyswigpacked_type__doc__,           /* Documentation string */
969#if PY_VERSION_HEX >= 0x02000000
970    0,                                  /* tp_traverse */
971    0,                                  /* tp_clear */
972#endif
973#if PY_VERSION_HEX >= 0x02010000
974    0,                                  /* tp_richcompare */
975    0,                                  /* tp_weaklistoffset */
976#endif
977#if PY_VERSION_HEX >= 0x02020000         
978    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
979#endif
980#if PY_VERSION_HEX >= 0x02030000
981    0,                                  /* tp_del */
982#endif
983#ifdef COUNT_ALLOCS
984    0,0,0,0                             /* tp_alloc -> tp_next */
985#endif
986    };
987#if !defined(__cplusplus)
988    pyswigpacked_type = tmp;
989    type_init = 1;
990  }
991#endif
992  return &pyswigpacked_type;
993}
994
995SWIGRUNTIME PyObject *
996PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
997{
998  PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
999  if (self == NULL) {
1000    return NULL;
1001  } else {
1002    void *pack = malloc(size);
1003    if (pack) {
1004      memcpy(pack, ptr, size);
1005      self->pack = pack;
1006      self->desc = desc;
1007      self->size = size;
1008      return (PyObject *) self;
1009    }
1010    return NULL;
1011  }
1012}
1013
1014SWIGRUNTIMEINLINE const char *
1015PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1016{
1017  PySwigPacked *self = (PySwigPacked *)obj;
1018  if (self->size != size) return 0;
1019  memcpy(ptr, self->pack, size);
1020  return self->desc;
1021}
1022
1023SWIGRUNTIMEINLINE const char *
1024PySwigPacked_GetDesc(PyObject *self)
1025{
1026  return ((PySwigPacked *)self)->desc;
1027}
1028
1029SWIGRUNTIMEINLINE int
1030PySwigPacked_Check(PyObject *op) {
1031  return ((op)->ob_type == PySwigPacked_type()) 
1032    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1033}
1034
1035#else
1036/* -----------------------------------------------------------------------------
1037 * Use the old Python PyCObject instead of PySwigObject
1038 * ----------------------------------------------------------------------------- */
1039
1040#define PySwigObject_GetDesc(obj)                  PyCObject_GetDesc(obj)
1041#define PySwigObject_Check(obj)            PyCObject_Check(obj)
1042#define PySwigObject_AsVoidPtr(obj)        PyCObject_AsVoidPtr(obj)
1043#define PySwigObject_FromVoidPtrAndDesc(p, d)  PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1044
1045#endif
1046
1047#endif
1048
1049/* -----------------------------------------------------------------------------
1050 * errors manipulation
1051 * ----------------------------------------------------------------------------- */
1052
1053SWIGRUNTIME void
1054SWIG_Python_TypeError(const char *type, PyObject *obj)
1055{
1056  if (type) {
1057#if defined(SWIG_COBJECT_TYPES)
1058    if (obj && PySwigObject_Check(obj)) {
1059      const char *otype = (const char *) PySwigObject_GetDesc(obj);
1060      if (otype) {
1061        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1062                     type, otype);
1063        return;
1064      }
1065    } else 
1066#endif     
1067    {
1068      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
1069      if (otype) {
1070        PyObject *str = PyObject_Str(obj);
1071        const char *cstr = str ? PyString_AsString(str) : 0;
1072        if (cstr) {
1073          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1074                       type, otype, cstr);
1075        } else {
1076          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1077                       type, otype);
1078        }
1079        Py_XDECREF(str);
1080        return;
1081      }
1082    }   
1083    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1084  } else {
1085    PyErr_Format(PyExc_TypeError, "unexpected type is received");
1086  }
1087}
1088
1089SWIGRUNTIMEINLINE void
1090SWIG_Python_NullRef(const char *type)
1091{
1092  if (type) {
1093    PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1094  } else {
1095    PyErr_Format(PyExc_TypeError, "null reference was received");
1096  }
1097}
1098
1099SWIGRUNTIME int
1100SWIG_Python_AddErrMesg(const char* mesg, int infront)
1101{
1102  if (PyErr_Occurred()) {
1103    PyObject *type = 0;
1104    PyObject *value = 0;
1105    PyObject *traceback = 0;
1106    PyErr_Fetch(&type, &value, &traceback);
1107    if (value) {
1108      PyObject *old_str = PyObject_Str(value);
1109      Py_XINCREF(type);
1110      PyErr_Clear();
1111      if (infront) {
1112        PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1113      } else {
1114        PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1115      }
1116      Py_DECREF(old_str);
1117    }
1118    return 1;
1119  } else {
1120    return 0;
1121  }
1122}
1123
1124SWIGRUNTIME int
1125SWIG_Python_ArgFail(int argnum)
1126{
1127  if (PyErr_Occurred()) {
1128    /* add information about failing argument */
1129    char mesg[256];
1130    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1131    return SWIG_Python_AddErrMesg(mesg, 1);
1132  } else {
1133    return 0;
1134  }
1135}
1136
1137
1138/* -----------------------------------------------------------------------------
1139 * pointers/data manipulation
1140 * ----------------------------------------------------------------------------- */
1141
1142/* Convert a pointer value */
1143SWIGRUNTIME int
1144SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1145  swig_cast_info *tc;
1146  const char *c = 0;
1147  static PyObject *SWIG_this = 0;
1148  int    newref = 0;
1149  PyObject  *pyobj = 0;
1150  void *vptr;
1151 
1152  if (!obj) return 0;
1153  if (obj == Py_None) {
1154    *ptr = 0;
1155    return 0;
1156  }
1157
1158#ifdef SWIG_COBJECT_TYPES
1159  if (!(PySwigObject_Check(obj))) {
1160    if (!SWIG_this)
1161      SWIG_this = PyString_FromString("this");
1162    pyobj = obj;
1163    obj = PyObject_GetAttr(obj,SWIG_this);
1164    newref = 1;
1165    if (!obj) goto type_error;
1166    if (!PySwigObject_Check(obj)) {
1167      Py_DECREF(obj);
1168      goto type_error;
1169    }
1170  } 
1171  vptr = PySwigObject_AsVoidPtr(obj);
1172  c = (const char *) PySwigObject_GetDesc(obj);
1173  if (newref) { Py_DECREF(obj); }
1174  goto type_check;
1175#else
1176  if (!(PyString_Check(obj))) {
1177    if (!SWIG_this)
1178      SWIG_this = PyString_FromString("this");
1179    pyobj = obj;
1180    obj = PyObject_GetAttr(obj,SWIG_this);
1181    newref = 1;
1182    if (!obj) goto type_error;
1183    if (!PyString_Check(obj)) {
1184      Py_DECREF(obj);
1185      goto type_error;
1186    }
1187  } 
1188  c = PyString_AsString(obj);
1189  /* Pointer values must start with leading underscore */
1190  c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1191  if (newref) { Py_DECREF(obj); }
1192  if (!c) goto type_error;
1193#endif
1194
1195type_check:
1196  if (ty) {
1197    tc = SWIG_TypeCheck(c,ty);
1198    if (!tc) goto type_error;
1199    *ptr = SWIG_TypeCast(tc,vptr);
1200  } else {
1201    *ptr = vptr;
1202  }
1203  if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1204    PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1205  }
1206  return 0;
1207
1208type_error:
1209  PyErr_Clear();
1210  if (pyobj && !obj) {   
1211    obj = pyobj;
1212    if (PyCFunction_Check(obj)) {
1213      /* here we get the method pointer for callbacks */
1214      char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1215      c = doc ? strstr(doc, "swig_ptr: ") : 0;
1216      if (c) {
1217        c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1218        if (!c) goto type_error;
1219        goto type_check;
1220      }
1221    }
1222  }
1223  if (flags & SWIG_POINTER_EXCEPTION) {
1224    if (ty) {
1225      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1226    } else {
1227      SWIG_Python_TypeError("C/C++ pointer", obj);
1228    }
1229  }
1230  return -1;
1231}
1232
1233/* Convert a pointer value, signal an exception on a type mismatch */
1234SWIGRUNTIME void *
1235SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1236  void *result;
1237  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1238    PyErr_Clear();
1239    if (flags & SWIG_POINTER_EXCEPTION) {
1240      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1241      SWIG_Python_ArgFail(argnum);
1242    }
1243  }
1244  return result;
1245}
1246
1247/* Convert a packed value value */
1248SWIGRUNTIME int
1249SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1250  swig_cast_info *tc;
1251  const char *c = 0;
1252
1253#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1254  c = PySwigPacked_UnpackData(obj, ptr, sz);
1255#else
1256  if ((!obj) || (!PyString_Check(obj))) goto type_error;
1257  c = PyString_AsString(obj);
1258  /* Pointer values must start with leading underscore */
1259  c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1260#endif
1261  if (!c) goto type_error;
1262  if (ty) {
1263    tc = SWIG_TypeCheck(c,ty);
1264    if (!tc) goto type_error;
1265  }
1266  return 0;
1267
1268type_error:
1269  PyErr_Clear();
1270  if (flags & SWIG_POINTER_EXCEPTION) {
1271    if (ty) {
1272      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1273    } else {
1274      SWIG_Python_TypeError("C/C++ packed data", obj);
1275    }
1276  }
1277  return -1;
1278} 
1279
1280/* Create a new array object */
1281SWIGRUNTIME PyObject *
1282SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1283  PyObject *robj = 0;
1284  if (!type) {
1285    if (!PyErr_Occurred()) {
1286      PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1287    }
1288    return robj;
1289  }
1290  if (!ptr) {
1291    Py_INCREF(Py_None);
1292    return Py_None;
1293  }
1294#ifdef SWIG_COBJECT_TYPES
1295  robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1296#else
1297  {
1298    char result[SWIG_BUFFER_SIZE];
1299    robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1300      PyString_FromString(result) : 0;
1301  }
1302#endif
1303  if (!robj || (robj == Py_None)) return robj;
1304  if (type->clientdata) {
1305    PyObject *inst;
1306    PyObject *args = Py_BuildValue((char*)"(O)", robj);
1307    Py_DECREF(robj);
1308    inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1309    Py_DECREF(args);
1310    if (inst) {
1311      if (own) {
1312        PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1313      }
1314      robj = inst;
1315    }
1316  }
1317  return robj;
1318}
1319
1320SWIGRUNTIME PyObject *
1321SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1322  PyObject *robj = 0;
1323  if (!ptr) {
1324    Py_INCREF(Py_None);
1325    return Py_None;
1326  }
1327#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1328  robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1329#else
1330  {
1331    char result[SWIG_BUFFER_SIZE];
1332    robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1333      PyString_FromString(result) : 0;
1334  }
1335#endif
1336  return robj;
1337}
1338
1339/* -----------------------------------------------------------------------------*
1340 *  Get type list
1341 * -----------------------------------------------------------------------------*/
1342
1343#ifdef SWIG_LINK_RUNTIME
1344void *SWIG_ReturnGlobalTypeList(void *);
1345#endif
1346
1347SWIGRUNTIME swig_module_info *
1348SWIG_Python_GetModule(void) {
1349  static void *type_pointer = (void *)0;
1350  /* first check if module already created */
1351  if (!type_pointer) {
1352#ifdef SWIG_LINK_RUNTIME
1353    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1354#else
1355    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1356                                    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1357    if (PyErr_Occurred()) {
1358      PyErr_Clear();
1359      type_pointer = (void *)0;
1360    }
1361#endif
1362  }
1363  return (swig_module_info *) type_pointer;
1364}
1365
1366#if PY_MAJOR_VERSION < 2
1367/* PyModule_AddObject function was introduced in Python 2.0.  The following function
1368is copied out of Python/modsupport.c in python version 2.3.4 */
1369SWIGINTERN int
1370PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1371{
1372  PyObject *dict;
1373  if (!PyModule_Check(m)) {
1374    PyErr_SetString(PyExc_TypeError,
1375                    "PyModule_AddObject() needs module as first arg");
1376    return -1;
1377  }
1378  if (!o) {
1379    PyErr_SetString(PyExc_TypeError,
1380                    "PyModule_AddObject() needs non-NULL value");
1381    return -1;
1382  }
1383 
1384  dict = PyModule_GetDict(m);
1385  if (dict == NULL) {
1386    /* Internal error -- modules must have a dict! */
1387    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1388                 PyModule_GetName(m));
1389    return -1;
1390  }
1391  if (PyDict_SetItemString(dict, name, o))
1392    return -1;
1393  Py_DECREF(o);
1394  return 0;
1395}
1396#endif
1397
1398SWIGRUNTIME void
1399SWIG_Python_SetModule(swig_module_info *swig_module) {
1400  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1401
1402  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1403                                   swig_empty_runtime_method_table);
1404  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1405  if (pointer && module) {
1406    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1407  }
1408}
1409
1410#ifdef __cplusplus
1411}
1412#endif
1413
1414
1415/* -------- TYPES TABLE (BEGIN) -------- */
1416
1417#define SWIGTYPE_p_char swig_types[0]
1418#define SWIGTYPE_p_in_addr swig_types[1]
1419#define SWIGTYPE_p_int8_t swig_types[2]
1420#define SWIGTYPE_p_libtrace_err_t swig_types[3]
1421#define SWIGTYPE_p_libtrace_filter_t swig_types[4]
1422#define SWIGTYPE_p_libtrace_icmp swig_types[5]
1423#define SWIGTYPE_p_libtrace_icmp_un swig_types[6]
1424#define SWIGTYPE_p_libtrace_icmp_un_echo swig_types[7]
1425#define SWIGTYPE_p_libtrace_icmp_un_frag swig_types[8]
1426#define SWIGTYPE_p_libtrace_ip swig_types[9]
1427#define SWIGTYPE_p_libtrace_linktype_t swig_types[10]
1428#define SWIGTYPE_p_libtrace_out_t swig_types[11]
1429#define SWIGTYPE_p_libtrace_packet_t swig_types[12]
1430#define SWIGTYPE_p_libtrace_t swig_types[13]
1431#define SWIGTYPE_p_libtrace_tcp swig_types[14]
1432#define SWIGTYPE_p_libtrace_udp swig_types[15]
1433#define SWIGTYPE_p_timeval swig_types[16]
1434#define SWIGTYPE_p_trace_option_output_t swig_types[17]
1435#define SWIGTYPE_p_trace_option_t swig_types[18]
1436#define SWIGTYPE_p_uint64_t swig_types[19]
1437#define SWIGTYPE_p_unsigned_char swig_types[20]
1438#define SWIGTYPE_p_unsigned_int swig_types[21]
1439#define SWIGTYPE_p_unsigned_short swig_types[22]
1440#define SWIGTYPE_p_void swig_types[23]
1441#define SWIGTYPE_ptrdiff_t swig_types[24]
1442#define SWIGTYPE_size_t swig_types[25]
1443static swig_type_info *swig_types[27];
1444static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0};
1445#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1446#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1447
1448/* -------- TYPES TABLE (END) -------- */
1449
1450
1451/*-----------------------------------------------
1452              @(target):= _libtrace.so
1453  ------------------------------------------------*/
1454#define SWIG_init    init_libtrace
1455
1456#define SWIG_name    "_libtrace"
1457
1458#include <arpa/inet.h>
1459#include "libtrace.h"
1460
1461
1462#include <stdlib.h>
1463
1464
1465#include <limits.h>
1466
1467
1468SWIGINTERN int
1469  SWIG_CheckLongInRange(long value, long min_value, long max_value,
1470                        const char *errmsg)
1471{
1472  if (value < min_value) {
1473    if (errmsg) {
1474      PyErr_Format(PyExc_OverflowError, 
1475                   "value %ld is less than '%s' minimum %ld", 
1476                   value, errmsg, min_value);
1477    }
1478    return 0;   
1479  } else if (value > max_value) {
1480    if (errmsg) {
1481      PyErr_Format(PyExc_OverflowError,
1482                   "value %ld is greater than '%s' maximum %ld", 
1483                   value, errmsg, max_value);
1484    }
1485    return 0;
1486  }
1487  return 1;
1488}
1489
1490
1491SWIGINTERN int
1492  SWIG_AsVal_long(PyObject * obj, long* val)
1493{
1494  if (PyLong_Check(obj)) {
1495    long v = PyLong_AsLong(obj);
1496    if (!PyErr_Occurred()) {
1497      if (val) *val = v;
1498      return 1;
1499    } else {
1500      if (!val) PyErr_Clear();
1501      return 0;
1502    }
1503  }
1504  if (PyInt_Check(obj)) {
1505    if (val) *val = PyInt_AsLong(obj);
1506    return 1;
1507  }
1508  if (val) {
1509    SWIG_type_error("long", obj);
1510  }
1511  return 0;
1512 }
1513
1514
1515#if INT_MAX != LONG_MAX
1516SWIGINTERN int
1517  SWIG_AsVal_int(PyObject *obj, int *val)
1518{ 
1519  const char* errmsg = val ? "int" : (char*)0;
1520  long v;
1521  if (SWIG_AsVal_long(obj, &v)) {
1522    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1523      if (val) *val = (int)(v);
1524      return 1;
1525    } else {
1526      return 0;
1527    }
1528  } else {
1529    PyErr_Clear();
1530  }
1531  if (val) {
1532    SWIG_type_error(errmsg, obj);
1533  }
1534  return 0;   
1535}
1536#else
1537SWIGINTERNINLINE int
1538  SWIG_AsVal_int(PyObject *obj, int *val)
1539{
1540  return SWIG_AsVal_long(obj,(long*)val);
1541}
1542#endif
1543
1544
1545SWIGINTERNINLINE int
1546SWIG_As_int(PyObject* obj)
1547{
1548  int v;
1549  if (!SWIG_AsVal_int(obj, &v)) {
1550    /*
1551      this is needed to make valgrind/purify happier.
1552     */
1553    memset((void*)&v, 0, sizeof(int));
1554  }
1555  return v;
1556}
1557
1558 
1559SWIGINTERNINLINE int
1560SWIG_Check_int(PyObject* obj)
1561{
1562  return SWIG_AsVal_int(obj, (int*)0);
1563}
1564
1565
1566  /*@/usr/share/swig1.3/python/pymacros.swg,72,SWIG_define@*/
1567#define SWIG_From_int PyInt_FromLong
1568/*@@*/
1569
1570
1571SWIGINTERNINLINE int
1572  SWIG_CheckUnsignedLongInRange(unsigned long value,
1573                                unsigned long max_value,
1574                                const char *errmsg) 
1575{
1576  if (value > max_value) {
1577    if (errmsg) {
1578      PyErr_Format(PyExc_OverflowError,
1579                   "value %lu is greater than '%s' minimum %lu",
1580                   value, errmsg, max_value);
1581    }
1582    return 0;
1583  }
1584  return 1;
1585 }
1586
1587
1588SWIGINTERN int
1589  SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) 
1590{
1591  if (PyLong_Check(obj)) {
1592    unsigned long v = PyLong_AsUnsignedLong(obj);
1593    if (!PyErr_Occurred()) {
1594      if (val) *val = v;
1595      return 1;
1596    } else {
1597      if (!val) PyErr_Clear();
1598      return 0;
1599    }
1600  } 
1601  if (PyInt_Check(obj)) {
1602    long v = PyInt_AsLong(obj);
1603    if (v >= 0) {
1604      if (val) *val = v;
1605      return 1;
1606    }   
1607  }
1608  if (val) {
1609    SWIG_type_error("unsigned long", obj);
1610  }
1611  return 0;
1612}
1613
1614
1615#if UINT_MAX != ULONG_MAX
1616SWIGINTERN int
1617  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1618{ 
1619  const char* errmsg = val ? "unsigned int" : (char*)0;
1620  unsigned long v;
1621  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1622    if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1623      if (val) *val = (unsigned int)(v);
1624      return 1;
1625    }
1626  } else {
1627    PyErr_Clear();
1628  }
1629  if (val) {
1630    SWIG_type_error(errmsg, obj);
1631  }
1632  return 0;   
1633}
1634#else
1635SWIGINTERNINLINE unsigned int
1636  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1637{
1638  return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1639}
1640#endif
1641
1642
1643SWIGINTERNINLINE unsigned int
1644SWIG_As_unsigned_SS_int(PyObject* obj)
1645{
1646  unsigned int v;
1647  if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1648    /*
1649      this is needed to make valgrind/purify happier.
1650     */
1651    memset((void*)&v, 0, sizeof(unsigned int));
1652  }
1653  return v;
1654}
1655
1656 
1657SWIGINTERNINLINE int
1658SWIG_Check_unsigned_SS_int(PyObject* obj)
1659{
1660  return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1661}
1662
1663
1664  /*@/usr/share/swig1.3/python/pymacros.swg,72,SWIG_define@*/
1665#define SWIG_From_long PyInt_FromLong
1666/*@@*/
1667
1668
1669SWIGINTERNINLINE PyObject* 
1670  SWIG_From_unsigned_SS_long(unsigned long value)
1671{
1672  return (value > LONG_MAX) ?
1673    PyLong_FromUnsignedLong(value) 
1674    : PyInt_FromLong((long)(value)); 
1675}
1676
1677
1678#if UINT_MAX < LONG_MAX
1679/*@/usr/share/swig1.3/python/pymacros.swg,72,SWIG_define@*/
1680#define SWIG_From_unsigned_SS_int SWIG_From_long
1681/*@@*/
1682#else
1683/*@/usr/share/swig1.3/python/pymacros.swg,72,SWIG_define@*/
1684#define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
1685/*@@*/
1686#endif
1687
1688
1689SWIGINTERN int
1690  SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1691{ 
1692  const char* errmsg = val ? "unsigned char" : (char*)0;
1693  unsigned long v;
1694  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1695    if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1696      if (val) *val = (unsigned char)(v);
1697      return 1;
1698    } else {
1699      return 0;
1700    }
1701  } else {
1702    PyErr_Clear();
1703  }
1704  if (val) {
1705    SWIG_type_error(errmsg, obj);
1706  }
1707  return 0;
1708}
1709
1710
1711SWIGINTERNINLINE unsigned char
1712SWIG_As_unsigned_SS_char(PyObject* obj)
1713{
1714  unsigned char v;
1715  if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1716    /*
1717      this is needed to make valgrind/purify happier.
1718     */
1719    memset((void*)&v, 0, sizeof(unsigned char));
1720  }
1721  return v;
1722}
1723
1724 
1725SWIGINTERNINLINE int
1726SWIG_Check_unsigned_SS_char(PyObject* obj)
1727{
1728  return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1729}
1730
1731
1732  /*@/usr/share/swig1.3/python/pymacros.swg,72,SWIG_define@*/
1733#define SWIG_From_unsigned_SS_char PyInt_FromLong
1734/*@@*/
1735
1736
1737  /*@/usr/share/swig1.3/python/pymacros.swg,72,SWIG_define@*/
1738#define SWIG_From_unsigned_SS_short PyInt_FromLong
1739/*@@*/
1740
1741
1742SWIGINTERN PyObject *
1743SWIG_FromCharPtr(const char* cptr)
1744{ 
1745  if (cptr) {
1746    size_t size = strlen(cptr);
1747    if (size > INT_MAX) {
1748      return SWIG_NewPointerObj((char*)(cptr), 
1749                                SWIG_TypeQuery("char *"), 0);
1750    } else {
1751      if (size != 0) {
1752        return PyString_FromStringAndSize(cptr, size);
1753      } else {
1754        return PyString_FromString(cptr);
1755      }
1756    }
1757  }
1758  Py_INCREF(Py_None);
1759  return Py_None;
1760}
1761
1762
1763#define MAKE_NTOHS(class,member) \
1764            uint16_t class ## _ ## member ## _get (struct class *self) { \
1765                return ntohs(self->member); \
1766            }
1767
1768#define MAKE_NTOHL(class,member) \
1769            uint32_t class ## _ ## member ## _get (struct class *self) { \
1770                return ntohl(self->member); \
1771            }
1772
1773            MAKE_NTOHS(libtrace_ip,ip_sum);
1774            MAKE_NTOHS(libtrace_ip,ip_len);
1775            MAKE_NTOHS(libtrace_ip,ip_id);
1776            MAKE_NTOHS(libtrace_ip,ip_off);
1777            char *libtrace_ip_ip_src_get(struct libtrace_ip *self) {
1778                return strdup(inet_ntoa(self->ip_src));
1779            }
1780            char *libtrace_ip_ip_dst_get(struct libtrace_ip *self) {
1781                return strdup(inet_ntoa(self->ip_dst));
1782            }
1783
1784
1785SWIGINTERN int
1786  SWIG_AsVal_unsigned_SS_short(PyObject *obj, unsigned short *val)
1787{ 
1788  const char* errmsg = val ? "unsigned short" : (char*)0;
1789  unsigned long v;
1790  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1791    if (SWIG_CheckUnsignedLongInRange(v, USHRT_MAX, errmsg)) {
1792      if (val) *val = (unsigned short)(v);
1793      return 1;
1794    } else {
1795      return 0;
1796    }
1797  } else {
1798    PyErr_Clear();
1799  }
1800  if (val) {
1801    SWIG_type_error(errmsg, obj);
1802  }
1803  return 0;
1804}
1805
1806
1807SWIGINTERNINLINE unsigned short
1808SWIG_As_unsigned_SS_short(PyObject* obj)
1809{
1810  unsigned short v;
1811  if (!SWIG_AsVal_unsigned_SS_short(obj, &v)) {
1812    /*
1813      this is needed to make valgrind/purify happier.
1814     */
1815    memset((void*)&v, 0, sizeof(unsigned short));
1816  }
1817  return v;
1818}
1819
1820 
1821SWIGINTERNINLINE int
1822SWIG_Check_unsigned_SS_short(PyObject* obj)
1823{
1824  return SWIG_AsVal_unsigned_SS_short(obj, (unsigned short*)0);
1825}
1826
1827
1828 MAKE_NTOHS(libtrace_tcp,source)
1829 MAKE_NTOHS(libtrace_tcp,dest)
1830 MAKE_NTOHS(libtrace_tcp,window)
1831 MAKE_NTOHS(libtrace_tcp,check)
1832 MAKE_NTOHS(libtrace_tcp,urg_ptr)
1833
1834 MAKE_NTOHL(libtrace_tcp,seq)
1835 MAKE_NTOHL(libtrace_tcp,ack_seq)
1836
1837
1838 MAKE_NTOHS(libtrace_udp,source)
1839 MAKE_NTOHS(libtrace_udp,dest)
1840 MAKE_NTOHS(libtrace_udp,len)
1841 MAKE_NTOHS(libtrace_udp,check)
1842
1843
1844typedef union {
1845    struct     {
1846      uint16_t  id;
1847      uint16_t  sequence;
1848    } echo;                     /* echo datagram */
1849    uint32_t    gateway;        /* gateway address */
1850    struct     {
1851      uint16_t  __unused;
1852      uint16_t  mtu;
1853    } frag;                     /* path mtu discovery */
1854  } libtrace_icmp_un;
1855
1856
1857
1858typedef struct {
1859      uint16_t  __unused;
1860      uint16_t  mtu;
1861    } libtrace_icmp_un_frag;
1862
1863
1864
1865typedef struct {
1866      uint16_t  id;
1867      uint16_t  sequence;
1868    } libtrace_icmp_un_echo;
1869
1870
1871static struct libtrace_packet_t *new_libtrace_packet_t(){ 
1872                struct libtrace_packet_t *packet = trace_create_packet();
1873                return packet;
1874                }
1875static void delete_libtrace_packet_t(struct libtrace_packet_t *self){ 
1876                trace_destroy_packet(self);
1877                }
1878static libtrace_packet_t *libtrace_packet_t_trace_copy_packet(struct libtrace_packet_t *self){
1879                return trace_copy_packet(self);
1880        }
1881static void *libtrace_packet_t_trace_get_link(struct libtrace_packet_t *self){
1882                return trace_get_link(self);
1883        }
1884static void *libtrace_packet_t_trace_get_transport(struct libtrace_packet_t *self,uint8_t *proto,uint32_t *remaining){
1885                return trace_get_transport(self, proto, remaining);
1886        }
1887static struct libtrace_ip *libtrace_packet_t_trace_get_ip(struct libtrace_packet_t *self){
1888                return trace_get_ip(self);
1889        }
1890static struct libtrace_tcp *libtrace_packet_t_trace_get_tcp(struct libtrace_packet_t *self){
1891                return trace_get_tcp(self);
1892        }
1893static struct libtrace_udp *libtrace_packet_t_trace_get_udp(struct libtrace_packet_t *self){
1894                return trace_get_udp(self);
1895        }
1896static struct libtrace_icmp *libtrace_packet_t_trace_get_icmp(struct libtrace_packet_t *self){
1897                return trace_get_icmp(self);
1898        }
1899static char *libtrace_packet_t_trace_get_destination_mac(struct libtrace_packet_t *self){
1900                return trace_ether_ntoa(trace_get_destination_mac(self),0);
1901        }
1902static char *libtrace_packet_t_trace_get_source_mac(struct libtrace_packet_t *self){
1903                return trace_ether_ntoa(trace_get_source_mac(self),0);
1904        }
1905static char *libtrace_packet_t_trace_ether_ntoa(struct libtrace_packet_t *self,uint8_t *mac){
1906                return trace_ether_ntoa(mac, 0);
1907        }
1908static uint16_t libtrace_packet_t_trace_get_source_port(struct libtrace_packet_t *self){
1909                return trace_get_source_port(self);
1910        }
1911static uint16_t libtrace_packet_t_trace_get_destination_port(struct libtrace_packet_t *self){
1912                return trace_get_destination_port(self);
1913        }
1914static double libtrace_packet_t_trace_get_seconds(struct libtrace_packet_t *self){
1915                return trace_get_seconds(self);
1916        }
1917
1918  /*@/usr/share/swig1.3/python/pymacros.swg,72,SWIG_define@*/
1919#define SWIG_From_double PyFloat_FromDouble
1920/*@@*/
1921
1922static uint64_t libtrace_packet_t_trace_get_erf_timestamp(struct libtrace_packet_t *self){
1923                return trace_get_erf_timestamp(self);
1924        }
1925static struct timeval libtrace_packet_t_trace_get_timeval(struct libtrace_packet_t *self){
1926                return trace_get_timeval(self);
1927        }
1928static int libtrace_packet_t_trace_get_capture_length(struct libtrace_packet_t *self){
1929                return trace_get_capture_length(self);
1930        }
1931
1932SWIGINTERNINLINE unsigned long
1933SWIG_As_unsigned_SS_long(PyObject* obj)
1934{
1935  unsigned long v;
1936  if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1937    /*
1938      this is needed to make valgrind/purify happier.
1939     */
1940    memset((void*)&v, 0, sizeof(unsigned long));
1941  }
1942  return v;
1943}
1944
1945 
1946SWIGINTERNINLINE int
1947SWIG_Check_unsigned_SS_long(PyObject* obj)
1948{
1949  return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1950}
1951
1952static size_t libtrace_packet_t_trace_set_capture_length(struct libtrace_packet_t *self,size_t size){
1953                return trace_set_capture_length(self,size);
1954        }
1955static int libtrace_packet_t_trace_get_wire_lenth(struct libtrace_packet_t *self){
1956                return trace_get_wire_length(self);
1957        }
1958static int libtrace_packet_t_trace_get_framing_length(struct libtrace_packet_t *self){
1959                return trace_get_framing_length(self);
1960        }
1961static libtrace_linktype_t libtrace_packet_t_trace_get_link_type(struct libtrace_packet_t *self){
1962                return trace_get_link_type(self);
1963        }
1964static int8_t libtrace_packet_t_trace_get_direction(struct libtrace_packet_t *self){
1965                return trace_get_direction(self);
1966        }
1967static int8_t libtrace_packet_t_trace_set_direction(struct libtrace_packet_t *self,int8_t direction){
1968                return trace_set_direction(self,direction);
1969        }
1970static int libtrace_packet_t_trace_apply_filter(struct libtrace_packet_t *self,struct libtrace_filter_t *filter){
1971                return trace_apply_filter(filter,self);
1972        }
1973static uint8_t libtrace_packet_t_trace_get_server_port(struct libtrace_packet_t *self,uint8_t protocol,uint16_t source,uint16_t dest){
1974                return trace_get_server_port(protocol,source,dest);
1975        }
1976
1977/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1978SWIGINTERN int
1979SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1980{
1981  static swig_type_info* pchar_info = 0;
1982  char* vptr = 0;
1983  if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1984  if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1985    if (cptr) *cptr = vptr;
1986    if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1987    return SWIG_OLDOBJ;
1988  } else {
1989    PyErr_Clear();
1990    if (PyString_Check(obj)) {
1991      if (cptr) {
1992        *cptr = PyString_AS_STRING(obj);
1993        if (psize) {
1994          *psize = PyString_GET_SIZE(obj) + 1;
1995        }
1996      }
1997      return SWIG_PYSTR;
1998    }
1999  }
2000  if (cptr) {
2001    SWIG_type_error("char *", obj);
2002  }
2003  return 0;
2004}
2005
2006
2007SWIGINTERNINLINE int
2008SWIG_AsCharPtr(PyObject *obj, char **val)
2009{
2010  if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2011    return 1;
2012  }
2013  if (val) {
2014    PyErr_Clear();
2015    SWIG_type_error("char *", obj);
2016  }
2017  return 0;
2018}
2019
2020static struct libtrace_filter_t *new_libtrace_filter_t(char *filterstring){ 
2021                return trace_create_filter(filterstring); 
2022        }
2023static void delete_libtrace_filter_t(struct libtrace_filter_t *self){
2024                trace_destroy_filter(self);
2025        }
2026static int libtrace_filter_t_trace_apply_filter(struct libtrace_filter_t *self,struct libtrace_packet_t *packet){
2027                return trace_apply_filter(self,packet);
2028        }
2029static struct libtrace_t *new_libtrace_t(char *uri){ return trace_create(uri); }
2030static void delete_libtrace_t(struct libtrace_t *self){ trace_destroy(self); }
2031static int libtrace_t_trace_read_packet(struct libtrace_t *self,struct libtrace_packet_t *packet){ 
2032                return trace_read_packet(self,packet);
2033        }
2034static int libtrace_t_trace_start(struct libtrace_t *self){
2035                return trace_start(self);
2036        }
2037static int libtrace_t_trace_pause(struct libtrace_t *self){
2038                return trace_pause(self);
2039        }
2040static void libtrace_t_trace_help(struct libtrace_t *self){
2041                trace_help();
2042        }
2043static int libtrace_t_trace_config(struct libtrace_t *self,trace_option_t option,void *value){
2044                return trace_config(self, option, value); 
2045        }
2046static libtrace_err_t libtrace_t_trace_get_err(struct libtrace_t *self){
2047                return trace_get_err(self);
2048        }
2049static bool libtrace_t_trace_is_err(struct libtrace_t *self){
2050                return trace_is_err(self);
2051        }
2052
2053SWIGINTERNINLINE PyObject*
2054  SWIG_From_bool(bool value)
2055{
2056  PyObject *obj = value ? Py_True : Py_False;
2057  Py_INCREF(obj);
2058  return obj;
2059}
2060
2061static struct libtrace_out_t *new_libtrace_out_t(char *uri){ return trace_create_output(uri); }
2062static void delete_libtrace_out_t(struct libtrace_out_t *self){ trace_destroy_output(self); }
2063static int libtrace_out_t_trace_start_output(struct libtrace_out_t *self){
2064                return trace_start_output(self);
2065        }
2066static int libtrace_out_t_trace_config_output(struct libtrace_out_t *self,trace_option_output_t option,void *value){
2067                return trace_config_output(self, option, value);
2068        }
2069static libtrace_err_t libtrace_out_t_trace_get_err_output(struct libtrace_out_t *self){
2070                return trace_get_err_output(self);
2071        }
2072static bool libtrace_out_t_trace_is_err_output(struct libtrace_out_t *self){
2073                return trace_is_err_output(self);
2074        }
2075static int libtrace_out_t_trace_write_packet(struct libtrace_out_t *self,libtrace_packet_t *packet){
2076                return trace_write_packet(self, packet);
2077        }
2078#ifdef __cplusplus
2079extern "C" {
2080#endif
2081static PyObject *_wrap_in_addr_s_addr_set(PyObject *self, PyObject *args) {
2082    PyObject *resultobj = NULL;
2083    struct in_addr *arg1 = (struct in_addr *) 0 ;
2084    int arg2 ;
2085    PyObject * obj0 = 0 ;
2086    PyObject * obj1 = 0 ;
2087   
2088    if(!PyArg_ParseTuple(args,(char *)"OO:in_addr_s_addr_set",&obj0,&obj1)) goto fail;
2089    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_in_addr, SWIG_POINTER_EXCEPTION | 0);
2090    if (SWIG_arg_fail(1)) SWIG_fail;
2091    {
2092        arg2 = (int)(SWIG_As_int(obj1)); 
2093        if (SWIG_arg_fail(2)) SWIG_fail;
2094    }
2095    if (arg1) (arg1)->s_addr = arg2;
2096   
2097    Py_INCREF(Py_None); resultobj = Py_None;
2098    return resultobj;
2099    fail:
2100    return NULL;
2101}
2102
2103
2104static PyObject *_wrap_in_addr_s_addr_get(PyObject *self, PyObject *args) {
2105    PyObject *resultobj = NULL;
2106    struct in_addr *arg1 = (struct in_addr *) 0 ;
2107    int result;
2108    PyObject * obj0 = 0 ;
2109   
2110    if(!PyArg_ParseTuple(args,(char *)"O:in_addr_s_addr_get",&obj0)) goto fail;
2111    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_in_addr, SWIG_POINTER_EXCEPTION | 0);
2112    if (SWIG_arg_fail(1)) SWIG_fail;
2113    result = (int) ((arg1)->s_addr);
2114   
2115    {
2116        resultobj = SWIG_From_int((int)(result)); 
2117    }
2118    return resultobj;
2119    fail:
2120    return NULL;
2121}
2122
2123
2124static PyObject * in_addr_swigregister(PyObject *self, PyObject *args) {
2125    PyObject *obj;
2126    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2127    SWIG_TypeClientData(SWIGTYPE_p_in_addr, obj);
2128    Py_INCREF(obj);
2129    return Py_BuildValue((char *)"");
2130}
2131static PyObject *_wrap_libtrace_ip_ip_hl_set(PyObject *self, PyObject *args) {
2132    PyObject *resultobj = NULL;
2133    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2134    unsigned int arg2 ;
2135    PyObject * obj0 = 0 ;
2136    PyObject * obj1 = 0 ;
2137   
2138    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_ip_ip_hl_set",&obj0,&obj1)) goto fail;
2139    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2140    if (SWIG_arg_fail(1)) SWIG_fail;
2141    {
2142        arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1)); 
2143        if (SWIG_arg_fail(2)) SWIG_fail;
2144    }
2145    if (arg1) (arg1)->ip_hl = arg2;
2146   
2147    Py_INCREF(Py_None); resultobj = Py_None;
2148    return resultobj;
2149    fail:
2150    return NULL;
2151}
2152
2153
2154static PyObject *_wrap_libtrace_ip_ip_hl_get(PyObject *self, PyObject *args) {
2155    PyObject *resultobj = NULL;
2156    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2157    unsigned int result;
2158    PyObject * obj0 = 0 ;
2159   
2160    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_hl_get",&obj0)) goto fail;
2161    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2162    if (SWIG_arg_fail(1)) SWIG_fail;
2163    result = (unsigned int) ((arg1)->ip_hl);
2164   
2165    {
2166        resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 
2167    }
2168    return resultobj;
2169    fail:
2170    return NULL;
2171}
2172
2173
2174static PyObject *_wrap_libtrace_ip_ip_v_set(PyObject *self, PyObject *args) {
2175    PyObject *resultobj = NULL;
2176    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2177    unsigned int arg2 ;
2178    PyObject * obj0 = 0 ;
2179    PyObject * obj1 = 0 ;
2180   
2181    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_ip_ip_v_set",&obj0,&obj1)) goto fail;
2182    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2183    if (SWIG_arg_fail(1)) SWIG_fail;
2184    {
2185        arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1)); 
2186        if (SWIG_arg_fail(2)) SWIG_fail;
2187    }
2188    if (arg1) (arg1)->ip_v = arg2;
2189   
2190    Py_INCREF(Py_None); resultobj = Py_None;
2191    return resultobj;
2192    fail:
2193    return NULL;
2194}
2195
2196
2197static PyObject *_wrap_libtrace_ip_ip_v_get(PyObject *self, PyObject *args) {
2198    PyObject *resultobj = NULL;
2199    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2200    unsigned int result;
2201    PyObject * obj0 = 0 ;
2202   
2203    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_v_get",&obj0)) goto fail;
2204    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2205    if (SWIG_arg_fail(1)) SWIG_fail;
2206    result = (unsigned int) ((arg1)->ip_v);
2207   
2208    {
2209        resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 
2210    }
2211    return resultobj;
2212    fail:
2213    return NULL;
2214}
2215
2216
2217static PyObject *_wrap_libtrace_ip_ip_tos_set(PyObject *self, PyObject *args) {
2218    PyObject *resultobj = NULL;
2219    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2220    uint8_t arg2 ;
2221    PyObject * obj0 = 0 ;
2222    PyObject * obj1 = 0 ;
2223   
2224    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_ip_ip_tos_set",&obj0,&obj1)) goto fail;
2225    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2226    if (SWIG_arg_fail(1)) SWIG_fail;
2227    {
2228        arg2 = (uint8_t)(SWIG_As_unsigned_SS_char(obj1)); 
2229        if (SWIG_arg_fail(2)) SWIG_fail;
2230    }
2231    if (arg1) (arg1)->ip_tos = arg2;
2232   
2233    Py_INCREF(Py_None); resultobj = Py_None;
2234    return resultobj;
2235    fail:
2236    return NULL;
2237}
2238
2239
2240static PyObject *_wrap_libtrace_ip_ip_tos_get(PyObject *self, PyObject *args) {
2241    PyObject *resultobj = NULL;
2242    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2243    uint8_t result;
2244    PyObject * obj0 = 0 ;
2245   
2246    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_tos_get",&obj0)) goto fail;
2247    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2248    if (SWIG_arg_fail(1)) SWIG_fail;
2249    result = (uint8_t) ((arg1)->ip_tos);
2250   
2251    {
2252        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
2253    }
2254    return resultobj;
2255    fail:
2256    return NULL;
2257}
2258
2259
2260static PyObject *_wrap_libtrace_ip_ip_ttl_set(PyObject *self, PyObject *args) {
2261    PyObject *resultobj = NULL;
2262    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2263    uint8_t arg2 ;
2264    PyObject * obj0 = 0 ;
2265    PyObject * obj1 = 0 ;
2266   
2267    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_ip_ip_ttl_set",&obj0,&obj1)) goto fail;
2268    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2269    if (SWIG_arg_fail(1)) SWIG_fail;
2270    {
2271        arg2 = (uint8_t)(SWIG_As_unsigned_SS_char(obj1)); 
2272        if (SWIG_arg_fail(2)) SWIG_fail;
2273    }
2274    if (arg1) (arg1)->ip_ttl = arg2;
2275   
2276    Py_INCREF(Py_None); resultobj = Py_None;
2277    return resultobj;
2278    fail:
2279    return NULL;
2280}
2281
2282
2283static PyObject *_wrap_libtrace_ip_ip_ttl_get(PyObject *self, PyObject *args) {
2284    PyObject *resultobj = NULL;
2285    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2286    uint8_t result;
2287    PyObject * obj0 = 0 ;
2288   
2289    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_ttl_get",&obj0)) goto fail;
2290    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2291    if (SWIG_arg_fail(1)) SWIG_fail;
2292    result = (uint8_t) ((arg1)->ip_ttl);
2293   
2294    {
2295        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
2296    }
2297    return resultobj;
2298    fail:
2299    return NULL;
2300}
2301
2302
2303static PyObject *_wrap_libtrace_ip_ip_p_set(PyObject *self, PyObject *args) {
2304    PyObject *resultobj = NULL;
2305    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2306    uint8_t arg2 ;
2307    PyObject * obj0 = 0 ;
2308    PyObject * obj1 = 0 ;
2309   
2310    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_ip_ip_p_set",&obj0,&obj1)) goto fail;
2311    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2312    if (SWIG_arg_fail(1)) SWIG_fail;
2313    {
2314        arg2 = (uint8_t)(SWIG_As_unsigned_SS_char(obj1)); 
2315        if (SWIG_arg_fail(2)) SWIG_fail;
2316    }
2317    if (arg1) (arg1)->ip_p = arg2;
2318   
2319    Py_INCREF(Py_None); resultobj = Py_None;
2320    return resultobj;
2321    fail:
2322    return NULL;
2323}
2324
2325
2326static PyObject *_wrap_libtrace_ip_ip_p_get(PyObject *self, PyObject *args) {
2327    PyObject *resultobj = NULL;
2328    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2329    uint8_t result;
2330    PyObject * obj0 = 0 ;
2331   
2332    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_p_get",&obj0)) goto fail;
2333    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2334    if (SWIG_arg_fail(1)) SWIG_fail;
2335    result = (uint8_t) ((arg1)->ip_p);
2336   
2337    {
2338        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
2339    }
2340    return resultobj;
2341    fail:
2342    return NULL;
2343}
2344
2345
2346static PyObject *_wrap_libtrace_ip_ip_sum_get(PyObject *self, PyObject *args) {
2347    PyObject *resultobj = NULL;
2348    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2349    uint16_t result;
2350    PyObject * obj0 = 0 ;
2351   
2352    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_sum_get",&obj0)) goto fail;
2353    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2354    if (SWIG_arg_fail(1)) SWIG_fail;
2355    result = (uint16_t)libtrace_ip_ip_sum_get(arg1);
2356   
2357    {
2358        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2359    }
2360    return resultobj;
2361    fail:
2362    return NULL;
2363}
2364
2365
2366static PyObject *_wrap_libtrace_ip_ip_len_get(PyObject *self, PyObject *args) {
2367    PyObject *resultobj = NULL;
2368    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2369    uint16_t result;
2370    PyObject * obj0 = 0 ;
2371   
2372    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_len_get",&obj0)) goto fail;
2373    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2374    if (SWIG_arg_fail(1)) SWIG_fail;
2375    result = (uint16_t)libtrace_ip_ip_len_get(arg1);
2376   
2377    {
2378        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2379    }
2380    return resultobj;
2381    fail:
2382    return NULL;
2383}
2384
2385
2386static PyObject *_wrap_libtrace_ip_ip_id_get(PyObject *self, PyObject *args) {
2387    PyObject *resultobj = NULL;
2388    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2389    uint16_t result;
2390    PyObject * obj0 = 0 ;
2391   
2392    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_id_get",&obj0)) goto fail;
2393    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2394    if (SWIG_arg_fail(1)) SWIG_fail;
2395    result = (uint16_t)libtrace_ip_ip_id_get(arg1);
2396   
2397    {
2398        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2399    }
2400    return resultobj;
2401    fail:
2402    return NULL;
2403}
2404
2405
2406static PyObject *_wrap_libtrace_ip_ip_off_get(PyObject *self, PyObject *args) {
2407    PyObject *resultobj = NULL;
2408    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2409    uint16_t result;
2410    PyObject * obj0 = 0 ;
2411   
2412    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_off_get",&obj0)) goto fail;
2413    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2414    if (SWIG_arg_fail(1)) SWIG_fail;
2415    result = (uint16_t)libtrace_ip_ip_off_get(arg1);
2416   
2417    {
2418        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2419    }
2420    return resultobj;
2421    fail:
2422    return NULL;
2423}
2424
2425
2426static PyObject *_wrap_libtrace_ip_ip_src_get(PyObject *self, PyObject *args) {
2427    PyObject *resultobj = NULL;
2428    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2429    char *result;
2430    PyObject * obj0 = 0 ;
2431   
2432    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_src_get",&obj0)) goto fail;
2433    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2434    if (SWIG_arg_fail(1)) SWIG_fail;
2435    result = (char *)libtrace_ip_ip_src_get(arg1);
2436   
2437    resultobj = SWIG_FromCharPtr(result);
2438    free(result);
2439    return resultobj;
2440    fail:
2441    return NULL;
2442}
2443
2444
2445static PyObject *_wrap_libtrace_ip_ip_dst_get(PyObject *self, PyObject *args) {
2446    PyObject *resultobj = NULL;
2447    struct libtrace_ip *arg1 = (struct libtrace_ip *) 0 ;
2448    char *result;
2449    PyObject * obj0 = 0 ;
2450   
2451    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_ip_ip_dst_get",&obj0)) goto fail;
2452    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_ip, SWIG_POINTER_EXCEPTION | 0);
2453    if (SWIG_arg_fail(1)) SWIG_fail;
2454    result = (char *)libtrace_ip_ip_dst_get(arg1);
2455   
2456    resultobj = SWIG_FromCharPtr(result);
2457    free(result);
2458    return resultobj;
2459    fail:
2460    return NULL;
2461}
2462
2463
2464static PyObject * libtrace_ip_swigregister(PyObject *self, PyObject *args) {
2465    PyObject *obj;
2466    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2467    SWIG_TypeClientData(SWIGTYPE_p_libtrace_ip, obj);
2468    Py_INCREF(obj);
2469    return Py_BuildValue((char *)"");
2470}
2471static PyObject *_wrap_libtrace_tcp_res1_set(PyObject *self, PyObject *args) {
2472    PyObject *resultobj = NULL;
2473    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2474    uint16_t arg2 ;
2475    PyObject * obj0 = 0 ;
2476    PyObject * obj1 = 0 ;
2477   
2478    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_res1_set",&obj0,&obj1)) goto fail;
2479    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2480    if (SWIG_arg_fail(1)) SWIG_fail;
2481    {
2482        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2483        if (SWIG_arg_fail(2)) SWIG_fail;
2484    }
2485    if (arg1) (arg1)->res1 = arg2;
2486   
2487    Py_INCREF(Py_None); resultobj = Py_None;
2488    return resultobj;
2489    fail:
2490    return NULL;
2491}
2492
2493
2494static PyObject *_wrap_libtrace_tcp_res1_get(PyObject *self, PyObject *args) {
2495    PyObject *resultobj = NULL;
2496    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2497    uint16_t result;
2498    PyObject * obj0 = 0 ;
2499   
2500    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_res1_get",&obj0)) goto fail;
2501    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2502    if (SWIG_arg_fail(1)) SWIG_fail;
2503    result = (uint16_t) ((arg1)->res1);
2504   
2505    {
2506        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2507    }
2508    return resultobj;
2509    fail:
2510    return NULL;
2511}
2512
2513
2514static PyObject *_wrap_libtrace_tcp_doff_set(PyObject *self, PyObject *args) {
2515    PyObject *resultobj = NULL;
2516    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2517    uint16_t arg2 ;
2518    PyObject * obj0 = 0 ;
2519    PyObject * obj1 = 0 ;
2520   
2521    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_doff_set",&obj0,&obj1)) goto fail;
2522    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2523    if (SWIG_arg_fail(1)) SWIG_fail;
2524    {
2525        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2526        if (SWIG_arg_fail(2)) SWIG_fail;
2527    }
2528    if (arg1) (arg1)->doff = arg2;
2529   
2530    Py_INCREF(Py_None); resultobj = Py_None;
2531    return resultobj;
2532    fail:
2533    return NULL;
2534}
2535
2536
2537static PyObject *_wrap_libtrace_tcp_doff_get(PyObject *self, PyObject *args) {
2538    PyObject *resultobj = NULL;
2539    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2540    uint16_t result;
2541    PyObject * obj0 = 0 ;
2542   
2543    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_doff_get",&obj0)) goto fail;
2544    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2545    if (SWIG_arg_fail(1)) SWIG_fail;
2546    result = (uint16_t) ((arg1)->doff);
2547   
2548    {
2549        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2550    }
2551    return resultobj;
2552    fail:
2553    return NULL;
2554}
2555
2556
2557static PyObject *_wrap_libtrace_tcp_fin_set(PyObject *self, PyObject *args) {
2558    PyObject *resultobj = NULL;
2559    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2560    uint16_t arg2 ;
2561    PyObject * obj0 = 0 ;
2562    PyObject * obj1 = 0 ;
2563   
2564    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_fin_set",&obj0,&obj1)) goto fail;
2565    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2566    if (SWIG_arg_fail(1)) SWIG_fail;
2567    {
2568        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2569        if (SWIG_arg_fail(2)) SWIG_fail;
2570    }
2571    if (arg1) (arg1)->fin = arg2;
2572   
2573    Py_INCREF(Py_None); resultobj = Py_None;
2574    return resultobj;
2575    fail:
2576    return NULL;
2577}
2578
2579
2580static PyObject *_wrap_libtrace_tcp_fin_get(PyObject *self, PyObject *args) {
2581    PyObject *resultobj = NULL;
2582    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2583    uint16_t result;
2584    PyObject * obj0 = 0 ;
2585   
2586    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_fin_get",&obj0)) goto fail;
2587    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2588    if (SWIG_arg_fail(1)) SWIG_fail;
2589    result = (uint16_t) ((arg1)->fin);
2590   
2591    {
2592        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2593    }
2594    return resultobj;
2595    fail:
2596    return NULL;
2597}
2598
2599
2600static PyObject *_wrap_libtrace_tcp_syn_set(PyObject *self, PyObject *args) {
2601    PyObject *resultobj = NULL;
2602    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2603    uint16_t arg2 ;
2604    PyObject * obj0 = 0 ;
2605    PyObject * obj1 = 0 ;
2606   
2607    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_syn_set",&obj0,&obj1)) goto fail;
2608    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2609    if (SWIG_arg_fail(1)) SWIG_fail;
2610    {
2611        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2612        if (SWIG_arg_fail(2)) SWIG_fail;
2613    }
2614    if (arg1) (arg1)->syn = arg2;
2615   
2616    Py_INCREF(Py_None); resultobj = Py_None;
2617    return resultobj;
2618    fail:
2619    return NULL;
2620}
2621
2622
2623static PyObject *_wrap_libtrace_tcp_syn_get(PyObject *self, PyObject *args) {
2624    PyObject *resultobj = NULL;
2625    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2626    uint16_t result;
2627    PyObject * obj0 = 0 ;
2628   
2629    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_syn_get",&obj0)) goto fail;
2630    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2631    if (SWIG_arg_fail(1)) SWIG_fail;
2632    result = (uint16_t) ((arg1)->syn);
2633   
2634    {
2635        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2636    }
2637    return resultobj;
2638    fail:
2639    return NULL;
2640}
2641
2642
2643static PyObject *_wrap_libtrace_tcp_rst_set(PyObject *self, PyObject *args) {
2644    PyObject *resultobj = NULL;
2645    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2646    uint16_t arg2 ;
2647    PyObject * obj0 = 0 ;
2648    PyObject * obj1 = 0 ;
2649   
2650    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_rst_set",&obj0,&obj1)) goto fail;
2651    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2652    if (SWIG_arg_fail(1)) SWIG_fail;
2653    {
2654        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2655        if (SWIG_arg_fail(2)) SWIG_fail;
2656    }
2657    if (arg1) (arg1)->rst = arg2;
2658   
2659    Py_INCREF(Py_None); resultobj = Py_None;
2660    return resultobj;
2661    fail:
2662    return NULL;
2663}
2664
2665
2666static PyObject *_wrap_libtrace_tcp_rst_get(PyObject *self, PyObject *args) {
2667    PyObject *resultobj = NULL;
2668    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2669    uint16_t result;
2670    PyObject * obj0 = 0 ;
2671   
2672    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_rst_get",&obj0)) goto fail;
2673    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2674    if (SWIG_arg_fail(1)) SWIG_fail;
2675    result = (uint16_t) ((arg1)->rst);
2676   
2677    {
2678        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2679    }
2680    return resultobj;
2681    fail:
2682    return NULL;
2683}
2684
2685
2686static PyObject *_wrap_libtrace_tcp_psh_set(PyObject *self, PyObject *args) {
2687    PyObject *resultobj = NULL;
2688    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2689    uint16_t arg2 ;
2690    PyObject * obj0 = 0 ;
2691    PyObject * obj1 = 0 ;
2692   
2693    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_psh_set",&obj0,&obj1)) goto fail;
2694    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2695    if (SWIG_arg_fail(1)) SWIG_fail;
2696    {
2697        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2698        if (SWIG_arg_fail(2)) SWIG_fail;
2699    }
2700    if (arg1) (arg1)->psh = arg2;
2701   
2702    Py_INCREF(Py_None); resultobj = Py_None;
2703    return resultobj;
2704    fail:
2705    return NULL;
2706}
2707
2708
2709static PyObject *_wrap_libtrace_tcp_psh_get(PyObject *self, PyObject *args) {
2710    PyObject *resultobj = NULL;
2711    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2712    uint16_t result;
2713    PyObject * obj0 = 0 ;
2714   
2715    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_psh_get",&obj0)) goto fail;
2716    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2717    if (SWIG_arg_fail(1)) SWIG_fail;
2718    result = (uint16_t) ((arg1)->psh);
2719   
2720    {
2721        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2722    }
2723    return resultobj;
2724    fail:
2725    return NULL;
2726}
2727
2728
2729static PyObject *_wrap_libtrace_tcp_ack_set(PyObject *self, PyObject *args) {
2730    PyObject *resultobj = NULL;
2731    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2732    uint16_t arg2 ;
2733    PyObject * obj0 = 0 ;
2734    PyObject * obj1 = 0 ;
2735   
2736    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_ack_set",&obj0,&obj1)) goto fail;
2737    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2738    if (SWIG_arg_fail(1)) SWIG_fail;
2739    {
2740        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2741        if (SWIG_arg_fail(2)) SWIG_fail;
2742    }
2743    if (arg1) (arg1)->ack = arg2;
2744   
2745    Py_INCREF(Py_None); resultobj = Py_None;
2746    return resultobj;
2747    fail:
2748    return NULL;
2749}
2750
2751
2752static PyObject *_wrap_libtrace_tcp_ack_get(PyObject *self, PyObject *args) {
2753    PyObject *resultobj = NULL;
2754    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2755    uint16_t result;
2756    PyObject * obj0 = 0 ;
2757   
2758    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_ack_get",&obj0)) goto fail;
2759    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2760    if (SWIG_arg_fail(1)) SWIG_fail;
2761    result = (uint16_t) ((arg1)->ack);
2762   
2763    {
2764        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2765    }
2766    return resultobj;
2767    fail:
2768    return NULL;
2769}
2770
2771
2772static PyObject *_wrap_libtrace_tcp_urg_set(PyObject *self, PyObject *args) {
2773    PyObject *resultobj = NULL;
2774    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2775    uint16_t arg2 ;
2776    PyObject * obj0 = 0 ;
2777    PyObject * obj1 = 0 ;
2778   
2779    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_urg_set",&obj0,&obj1)) goto fail;
2780    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2781    if (SWIG_arg_fail(1)) SWIG_fail;
2782    {
2783        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2784        if (SWIG_arg_fail(2)) SWIG_fail;
2785    }
2786    if (arg1) (arg1)->urg = arg2;
2787   
2788    Py_INCREF(Py_None); resultobj = Py_None;
2789    return resultobj;
2790    fail:
2791    return NULL;
2792}
2793
2794
2795static PyObject *_wrap_libtrace_tcp_urg_get(PyObject *self, PyObject *args) {
2796    PyObject *resultobj = NULL;
2797    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2798    uint16_t result;
2799    PyObject * obj0 = 0 ;
2800   
2801    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_urg_get",&obj0)) goto fail;
2802    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2803    if (SWIG_arg_fail(1)) SWIG_fail;
2804    result = (uint16_t) ((arg1)->urg);
2805   
2806    {
2807        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2808    }
2809    return resultobj;
2810    fail:
2811    return NULL;
2812}
2813
2814
2815static PyObject *_wrap_libtrace_tcp_res2_set(PyObject *self, PyObject *args) {
2816    PyObject *resultobj = NULL;
2817    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2818    uint16_t arg2 ;
2819    PyObject * obj0 = 0 ;
2820    PyObject * obj1 = 0 ;
2821   
2822    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_tcp_res2_set",&obj0,&obj1)) goto fail;
2823    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2824    if (SWIG_arg_fail(1)) SWIG_fail;
2825    {
2826        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
2827        if (SWIG_arg_fail(2)) SWIG_fail;
2828    }
2829    if (arg1) (arg1)->res2 = arg2;
2830   
2831    Py_INCREF(Py_None); resultobj = Py_None;
2832    return resultobj;
2833    fail:
2834    return NULL;
2835}
2836
2837
2838static PyObject *_wrap_libtrace_tcp_res2_get(PyObject *self, PyObject *args) {
2839    PyObject *resultobj = NULL;
2840    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2841    uint16_t result;
2842    PyObject * obj0 = 0 ;
2843   
2844    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_res2_get",&obj0)) goto fail;
2845    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2846    if (SWIG_arg_fail(1)) SWIG_fail;
2847    result = (uint16_t) ((arg1)->res2);
2848   
2849    {
2850        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2851    }
2852    return resultobj;
2853    fail:
2854    return NULL;
2855}
2856
2857
2858static PyObject *_wrap_libtrace_tcp_source_get(PyObject *self, PyObject *args) {
2859    PyObject *resultobj = NULL;
2860    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2861    uint16_t result;
2862    PyObject * obj0 = 0 ;
2863   
2864    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_source_get",&obj0)) goto fail;
2865    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2866    if (SWIG_arg_fail(1)) SWIG_fail;
2867    result = (uint16_t)libtrace_tcp_source_get(arg1);
2868   
2869    {
2870        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2871    }
2872    return resultobj;
2873    fail:
2874    return NULL;
2875}
2876
2877
2878static PyObject *_wrap_libtrace_tcp_dest_get(PyObject *self, PyObject *args) {
2879    PyObject *resultobj = NULL;
2880    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2881    uint16_t result;
2882    PyObject * obj0 = 0 ;
2883   
2884    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_dest_get",&obj0)) goto fail;
2885    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2886    if (SWIG_arg_fail(1)) SWIG_fail;
2887    result = (uint16_t)libtrace_tcp_dest_get(arg1);
2888   
2889    {
2890        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2891    }
2892    return resultobj;
2893    fail:
2894    return NULL;
2895}
2896
2897
2898static PyObject *_wrap_libtrace_tcp_window_get(PyObject *self, PyObject *args) {
2899    PyObject *resultobj = NULL;
2900    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2901    uint16_t result;
2902    PyObject * obj0 = 0 ;
2903   
2904    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_window_get",&obj0)) goto fail;
2905    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2906    if (SWIG_arg_fail(1)) SWIG_fail;
2907    result = (uint16_t)libtrace_tcp_window_get(arg1);
2908   
2909    {
2910        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2911    }
2912    return resultobj;
2913    fail:
2914    return NULL;
2915}
2916
2917
2918static PyObject *_wrap_libtrace_tcp_check_get(PyObject *self, PyObject *args) {
2919    PyObject *resultobj = NULL;
2920    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2921    uint16_t result;
2922    PyObject * obj0 = 0 ;
2923   
2924    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_check_get",&obj0)) goto fail;
2925    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2926    if (SWIG_arg_fail(1)) SWIG_fail;
2927    result = (uint16_t)libtrace_tcp_check_get(arg1);
2928   
2929    {
2930        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2931    }
2932    return resultobj;
2933    fail:
2934    return NULL;
2935}
2936
2937
2938static PyObject *_wrap_libtrace_tcp_urg_ptr_get(PyObject *self, PyObject *args) {
2939    PyObject *resultobj = NULL;
2940    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2941    uint16_t result;
2942    PyObject * obj0 = 0 ;
2943   
2944    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_urg_ptr_get",&obj0)) goto fail;
2945    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2946    if (SWIG_arg_fail(1)) SWIG_fail;
2947    result = (uint16_t)libtrace_tcp_urg_ptr_get(arg1);
2948   
2949    {
2950        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
2951    }
2952    return resultobj;
2953    fail:
2954    return NULL;
2955}
2956
2957
2958static PyObject *_wrap_libtrace_tcp_seq_get(PyObject *self, PyObject *args) {
2959    PyObject *resultobj = NULL;
2960    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2961    uint32_t result;
2962    PyObject * obj0 = 0 ;
2963   
2964    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_seq_get",&obj0)) goto fail;
2965    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2966    if (SWIG_arg_fail(1)) SWIG_fail;
2967    result = (uint32_t)libtrace_tcp_seq_get(arg1);
2968   
2969    {
2970        resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 
2971    }
2972    return resultobj;
2973    fail:
2974    return NULL;
2975}
2976
2977
2978static PyObject *_wrap_libtrace_tcp_ack_seq_get(PyObject *self, PyObject *args) {
2979    PyObject *resultobj = NULL;
2980    struct libtrace_tcp *arg1 = (struct libtrace_tcp *) 0 ;
2981    uint32_t result;
2982    PyObject * obj0 = 0 ;
2983   
2984    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_tcp_ack_seq_get",&obj0)) goto fail;
2985    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_tcp, SWIG_POINTER_EXCEPTION | 0);
2986    if (SWIG_arg_fail(1)) SWIG_fail;
2987    result = (uint32_t)libtrace_tcp_ack_seq_get(arg1);
2988   
2989    {
2990        resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 
2991    }
2992    return resultobj;
2993    fail:
2994    return NULL;
2995}
2996
2997
2998static PyObject * libtrace_tcp_swigregister(PyObject *self, PyObject *args) {
2999    PyObject *obj;
3000    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3001    SWIG_TypeClientData(SWIGTYPE_p_libtrace_tcp, obj);
3002    Py_INCREF(obj);
3003    return Py_BuildValue((char *)"");
3004}
3005static PyObject *_wrap_libtrace_udp_source_get(PyObject *self, PyObject *args) {
3006    PyObject *resultobj = NULL;
3007    struct libtrace_udp *arg1 = (struct libtrace_udp *) 0 ;
3008    uint16_t result;
3009    PyObject * obj0 = 0 ;
3010   
3011    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_udp_source_get",&obj0)) goto fail;
3012    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_udp, SWIG_POINTER_EXCEPTION | 0);
3013    if (SWIG_arg_fail(1)) SWIG_fail;
3014    result = (uint16_t)libtrace_udp_source_get(arg1);
3015   
3016    {
3017        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3018    }
3019    return resultobj;
3020    fail:
3021    return NULL;
3022}
3023
3024
3025static PyObject *_wrap_libtrace_udp_dest_get(PyObject *self, PyObject *args) {
3026    PyObject *resultobj = NULL;
3027    struct libtrace_udp *arg1 = (struct libtrace_udp *) 0 ;
3028    uint16_t result;
3029    PyObject * obj0 = 0 ;
3030   
3031    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_udp_dest_get",&obj0)) goto fail;
3032    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_udp, SWIG_POINTER_EXCEPTION | 0);
3033    if (SWIG_arg_fail(1)) SWIG_fail;
3034    result = (uint16_t)libtrace_udp_dest_get(arg1);
3035   
3036    {
3037        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3038    }
3039    return resultobj;
3040    fail:
3041    return NULL;
3042}
3043
3044
3045static PyObject *_wrap_libtrace_udp_len_get(PyObject *self, PyObject *args) {
3046    PyObject *resultobj = NULL;
3047    struct libtrace_udp *arg1 = (struct libtrace_udp *) 0 ;
3048    uint16_t result;
3049    PyObject * obj0 = 0 ;
3050   
3051    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_udp_len_get",&obj0)) goto fail;
3052    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_udp, SWIG_POINTER_EXCEPTION | 0);
3053    if (SWIG_arg_fail(1)) SWIG_fail;
3054    result = (uint16_t)libtrace_udp_len_get(arg1);
3055   
3056    {
3057        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3058    }
3059    return resultobj;
3060    fail:
3061    return NULL;
3062}
3063
3064
3065static PyObject *_wrap_libtrace_udp_check_get(PyObject *self, PyObject *args) {
3066    PyObject *resultobj = NULL;
3067    struct libtrace_udp *arg1 = (struct libtrace_udp *) 0 ;
3068    uint16_t result;
3069    PyObject * obj0 = 0 ;
3070   
3071    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_udp_check_get",&obj0)) goto fail;
3072    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_udp, SWIG_POINTER_EXCEPTION | 0);
3073    if (SWIG_arg_fail(1)) SWIG_fail;
3074    result = (uint16_t)libtrace_udp_check_get(arg1);
3075   
3076    {
3077        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3078    }
3079    return resultobj;
3080    fail:
3081    return NULL;
3082}
3083
3084
3085static PyObject * libtrace_udp_swigregister(PyObject *self, PyObject *args) {
3086    PyObject *obj;
3087    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3088    SWIG_TypeClientData(SWIGTYPE_p_libtrace_udp, obj);
3089    Py_INCREF(obj);
3090    return Py_BuildValue((char *)"");
3091}
3092static PyObject *_wrap_libtrace_icmp_type_set(PyObject *self, PyObject *args) {
3093    PyObject *resultobj = NULL;
3094    struct libtrace_icmp *arg1 = (struct libtrace_icmp *) 0 ;
3095    uint8_t arg2 ;
3096    PyObject * obj0 = 0 ;
3097    PyObject * obj1 = 0 ;
3098   
3099    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_icmp_type_set",&obj0,&obj1)) goto fail;
3100    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp, SWIG_POINTER_EXCEPTION | 0);
3101    if (SWIG_arg_fail(1)) SWIG_fail;
3102    {
3103        arg2 = (uint8_t)(SWIG_As_unsigned_SS_char(obj1)); 
3104        if (SWIG_arg_fail(2)) SWIG_fail;
3105    }
3106    if (arg1) (arg1)->type = arg2;
3107   
3108    Py_INCREF(Py_None); resultobj = Py_None;
3109    return resultobj;
3110    fail:
3111    return NULL;
3112}
3113
3114
3115static PyObject *_wrap_libtrace_icmp_type_get(PyObject *self, PyObject *args) {
3116    PyObject *resultobj = NULL;
3117    struct libtrace_icmp *arg1 = (struct libtrace_icmp *) 0 ;
3118    uint8_t result;
3119    PyObject * obj0 = 0 ;
3120   
3121    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_type_get",&obj0)) goto fail;
3122    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp, SWIG_POINTER_EXCEPTION | 0);
3123    if (SWIG_arg_fail(1)) SWIG_fail;
3124    result = (uint8_t) ((arg1)->type);
3125   
3126    {
3127        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
3128    }
3129    return resultobj;
3130    fail:
3131    return NULL;
3132}
3133
3134
3135static PyObject *_wrap_libtrace_icmp_code_set(PyObject *self, PyObject *args) {
3136    PyObject *resultobj = NULL;
3137    struct libtrace_icmp *arg1 = (struct libtrace_icmp *) 0 ;
3138    uint8_t arg2 ;
3139    PyObject * obj0 = 0 ;
3140    PyObject * obj1 = 0 ;
3141   
3142    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_icmp_code_set",&obj0,&obj1)) goto fail;
3143    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp, SWIG_POINTER_EXCEPTION | 0);
3144    if (SWIG_arg_fail(1)) SWIG_fail;
3145    {
3146        arg2 = (uint8_t)(SWIG_As_unsigned_SS_char(obj1)); 
3147        if (SWIG_arg_fail(2)) SWIG_fail;
3148    }
3149    if (arg1) (arg1)->code = arg2;
3150   
3151    Py_INCREF(Py_None); resultobj = Py_None;
3152    return resultobj;
3153    fail:
3154    return NULL;
3155}
3156
3157
3158static PyObject *_wrap_libtrace_icmp_code_get(PyObject *self, PyObject *args) {
3159    PyObject *resultobj = NULL;
3160    struct libtrace_icmp *arg1 = (struct libtrace_icmp *) 0 ;
3161    uint8_t result;
3162    PyObject * obj0 = 0 ;
3163   
3164    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_code_get",&obj0)) goto fail;
3165    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp, SWIG_POINTER_EXCEPTION | 0);
3166    if (SWIG_arg_fail(1)) SWIG_fail;
3167    result = (uint8_t) ((arg1)->code);
3168   
3169    {
3170        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
3171    }
3172    return resultobj;
3173    fail:
3174    return NULL;
3175}
3176
3177
3178static PyObject *_wrap_libtrace_icmp_checksum_set(PyObject *self, PyObject *args) {
3179    PyObject *resultobj = NULL;
3180    struct libtrace_icmp *arg1 = (struct libtrace_icmp *) 0 ;
3181    uint16_t arg2 ;
3182    PyObject * obj0 = 0 ;
3183    PyObject * obj1 = 0 ;
3184   
3185    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_icmp_checksum_set",&obj0,&obj1)) goto fail;
3186    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp, SWIG_POINTER_EXCEPTION | 0);
3187    if (SWIG_arg_fail(1)) SWIG_fail;
3188    {
3189        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
3190        if (SWIG_arg_fail(2)) SWIG_fail;
3191    }
3192    if (arg1) (arg1)->checksum = arg2;
3193   
3194    Py_INCREF(Py_None); resultobj = Py_None;
3195    return resultobj;
3196    fail:
3197    return NULL;
3198}
3199
3200
3201static PyObject *_wrap_libtrace_icmp_checksum_get(PyObject *self, PyObject *args) {
3202    PyObject *resultobj = NULL;
3203    struct libtrace_icmp *arg1 = (struct libtrace_icmp *) 0 ;
3204    uint16_t result;
3205    PyObject * obj0 = 0 ;
3206   
3207    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_checksum_get",&obj0)) goto fail;
3208    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp, SWIG_POINTER_EXCEPTION | 0);
3209    if (SWIG_arg_fail(1)) SWIG_fail;
3210    result = (uint16_t) ((arg1)->checksum);
3211   
3212    {
3213        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3214    }
3215    return resultobj;
3216    fail:
3217    return NULL;
3218}
3219
3220
3221static PyObject *_wrap_libtrace_icmp_un_get(PyObject *self, PyObject *args) {
3222    PyObject *resultobj = NULL;
3223    struct libtrace_icmp *arg1 = (struct libtrace_icmp *) 0 ;
3224    libtrace_icmp_un *result;
3225    PyObject * obj0 = 0 ;
3226   
3227    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_un_get",&obj0)) goto fail;
3228    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp, SWIG_POINTER_EXCEPTION | 0);
3229    if (SWIG_arg_fail(1)) SWIG_fail;
3230    result = (libtrace_icmp_un *)& ((arg1)->un);
3231   
3232    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_icmp_un, 0);
3233    return resultobj;
3234    fail:
3235    return NULL;
3236}
3237
3238
3239static PyObject * libtrace_icmp_swigregister(PyObject *self, PyObject *args) {
3240    PyObject *obj;
3241    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3242    SWIG_TypeClientData(SWIGTYPE_p_libtrace_icmp, obj);
3243    Py_INCREF(obj);
3244    return Py_BuildValue((char *)"");
3245}
3246static PyObject *_wrap_libtrace_icmp_un_gateway_set(PyObject *self, PyObject *args) {
3247    PyObject *resultobj = NULL;
3248    libtrace_icmp_un *arg1 = (libtrace_icmp_un *) 0 ;
3249    uint32_t arg2 ;
3250    PyObject * obj0 = 0 ;
3251    PyObject * obj1 = 0 ;
3252   
3253    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_icmp_un_gateway_set",&obj0,&obj1)) goto fail;
3254    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un, SWIG_POINTER_EXCEPTION | 0);
3255    if (SWIG_arg_fail(1)) SWIG_fail;
3256    {
3257        arg2 = (uint32_t)(SWIG_As_unsigned_SS_int(obj1)); 
3258        if (SWIG_arg_fail(2)) SWIG_fail;
3259    }
3260    if (arg1) (arg1)->gateway = arg2;
3261   
3262    Py_INCREF(Py_None); resultobj = Py_None;
3263    return resultobj;
3264    fail:
3265    return NULL;
3266}
3267
3268
3269static PyObject *_wrap_libtrace_icmp_un_gateway_get(PyObject *self, PyObject *args) {
3270    PyObject *resultobj = NULL;
3271    libtrace_icmp_un *arg1 = (libtrace_icmp_un *) 0 ;
3272    uint32_t result;
3273    PyObject * obj0 = 0 ;
3274   
3275    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_un_gateway_get",&obj0)) goto fail;
3276    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un, SWIG_POINTER_EXCEPTION | 0);
3277    if (SWIG_arg_fail(1)) SWIG_fail;
3278    result = (uint32_t) ((arg1)->gateway);
3279   
3280    {
3281        resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 
3282    }
3283    return resultobj;
3284    fail:
3285    return NULL;
3286}
3287
3288
3289static PyObject *_wrap_libtrace_icmp_un_frag_get(PyObject *self, PyObject *args) {
3290    PyObject *resultobj = NULL;
3291    libtrace_icmp_un *arg1 = (libtrace_icmp_un *) 0 ;
3292    libtrace_icmp_un_frag *result;
3293    PyObject * obj0 = 0 ;
3294   
3295    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_un_frag_get",&obj0)) goto fail;
3296    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un, SWIG_POINTER_EXCEPTION | 0);
3297    if (SWIG_arg_fail(1)) SWIG_fail;
3298    result = (libtrace_icmp_un_frag *)& ((arg1)->frag);
3299   
3300    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_icmp_un_frag, 0);
3301    return resultobj;
3302    fail:
3303    return NULL;
3304}
3305
3306
3307static PyObject *_wrap_libtrace_icmp_un_echo_get(PyObject *self, PyObject *args) {
3308    PyObject *resultobj = NULL;
3309    libtrace_icmp_un *arg1 = (libtrace_icmp_un *) 0 ;
3310    libtrace_icmp_un_echo *result;
3311    PyObject * obj0 = 0 ;
3312   
3313    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_un_echo_get",&obj0)) goto fail;
3314    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un, SWIG_POINTER_EXCEPTION | 0);
3315    if (SWIG_arg_fail(1)) SWIG_fail;
3316    result = (libtrace_icmp_un_echo *)& ((arg1)->echo);
3317   
3318    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_icmp_un_echo, 0);
3319    return resultobj;
3320    fail:
3321    return NULL;
3322}
3323
3324
3325static PyObject * libtrace_icmp_un_swigregister(PyObject *self, PyObject *args) {
3326    PyObject *obj;
3327    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3328    SWIG_TypeClientData(SWIGTYPE_p_libtrace_icmp_un, obj);
3329    Py_INCREF(obj);
3330    return Py_BuildValue((char *)"");
3331}
3332static PyObject *_wrap_libtrace_icmp_un_frag___unused_set(PyObject *self, PyObject *args) {
3333    PyObject *resultobj = NULL;
3334    libtrace_icmp_un_frag *arg1 = (libtrace_icmp_un_frag *) 0 ;
3335    uint16_t arg2 ;
3336    PyObject * obj0 = 0 ;
3337    PyObject * obj1 = 0 ;
3338   
3339    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_icmp_un_frag___unused_set",&obj0,&obj1)) goto fail;
3340    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un_frag, SWIG_POINTER_EXCEPTION | 0);
3341    if (SWIG_arg_fail(1)) SWIG_fail;
3342    {
3343        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
3344        if (SWIG_arg_fail(2)) SWIG_fail;
3345    }
3346    if (arg1) (arg1)->__unused = arg2;
3347   
3348    Py_INCREF(Py_None); resultobj = Py_None;
3349    return resultobj;
3350    fail:
3351    return NULL;
3352}
3353
3354
3355static PyObject *_wrap_libtrace_icmp_un_frag___unused_get(PyObject *self, PyObject *args) {
3356    PyObject *resultobj = NULL;
3357    libtrace_icmp_un_frag *arg1 = (libtrace_icmp_un_frag *) 0 ;
3358    uint16_t result;
3359    PyObject * obj0 = 0 ;
3360   
3361    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_un_frag___unused_get",&obj0)) goto fail;
3362    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un_frag, SWIG_POINTER_EXCEPTION | 0);
3363    if (SWIG_arg_fail(1)) SWIG_fail;
3364    result = (uint16_t) ((arg1)->__unused);
3365   
3366    {
3367        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3368    }
3369    return resultobj;
3370    fail:
3371    return NULL;
3372}
3373
3374
3375static PyObject *_wrap_libtrace_icmp_un_frag_mtu_set(PyObject *self, PyObject *args) {
3376    PyObject *resultobj = NULL;
3377    libtrace_icmp_un_frag *arg1 = (libtrace_icmp_un_frag *) 0 ;
3378    uint16_t arg2 ;
3379    PyObject * obj0 = 0 ;
3380    PyObject * obj1 = 0 ;
3381   
3382    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_icmp_un_frag_mtu_set",&obj0,&obj1)) goto fail;
3383    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un_frag, SWIG_POINTER_EXCEPTION | 0);
3384    if (SWIG_arg_fail(1)) SWIG_fail;
3385    {
3386        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
3387        if (SWIG_arg_fail(2)) SWIG_fail;
3388    }
3389    if (arg1) (arg1)->mtu = arg2;
3390   
3391    Py_INCREF(Py_None); resultobj = Py_None;
3392    return resultobj;
3393    fail:
3394    return NULL;
3395}
3396
3397
3398static PyObject *_wrap_libtrace_icmp_un_frag_mtu_get(PyObject *self, PyObject *args) {
3399    PyObject *resultobj = NULL;
3400    libtrace_icmp_un_frag *arg1 = (libtrace_icmp_un_frag *) 0 ;
3401    uint16_t result;
3402    PyObject * obj0 = 0 ;
3403   
3404    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_un_frag_mtu_get",&obj0)) goto fail;
3405    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un_frag, SWIG_POINTER_EXCEPTION | 0);
3406    if (SWIG_arg_fail(1)) SWIG_fail;
3407    result = (uint16_t) ((arg1)->mtu);
3408   
3409    {
3410        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3411    }
3412    return resultobj;
3413    fail:
3414    return NULL;
3415}
3416
3417
3418static PyObject * libtrace_icmp_un_frag_swigregister(PyObject *self, PyObject *args) {
3419    PyObject *obj;
3420    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3421    SWIG_TypeClientData(SWIGTYPE_p_libtrace_icmp_un_frag, obj);
3422    Py_INCREF(obj);
3423    return Py_BuildValue((char *)"");
3424}
3425static PyObject *_wrap_libtrace_icmp_un_echo_id_set(PyObject *self, PyObject *args) {
3426    PyObject *resultobj = NULL;
3427    libtrace_icmp_un_echo *arg1 = (libtrace_icmp_un_echo *) 0 ;
3428    uint16_t arg2 ;
3429    PyObject * obj0 = 0 ;
3430    PyObject * obj1 = 0 ;
3431   
3432    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_icmp_un_echo_id_set",&obj0,&obj1)) goto fail;
3433    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un_echo, SWIG_POINTER_EXCEPTION | 0);
3434    if (SWIG_arg_fail(1)) SWIG_fail;
3435    {
3436        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
3437        if (SWIG_arg_fail(2)) SWIG_fail;
3438    }
3439    if (arg1) (arg1)->id = arg2;
3440   
3441    Py_INCREF(Py_None); resultobj = Py_None;
3442    return resultobj;
3443    fail:
3444    return NULL;
3445}
3446
3447
3448static PyObject *_wrap_libtrace_icmp_un_echo_id_get(PyObject *self, PyObject *args) {
3449    PyObject *resultobj = NULL;
3450    libtrace_icmp_un_echo *arg1 = (libtrace_icmp_un_echo *) 0 ;
3451    uint16_t result;
3452    PyObject * obj0 = 0 ;
3453   
3454    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_un_echo_id_get",&obj0)) goto fail;
3455    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un_echo, SWIG_POINTER_EXCEPTION | 0);
3456    if (SWIG_arg_fail(1)) SWIG_fail;
3457    result = (uint16_t) ((arg1)->id);
3458   
3459    {
3460        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3461    }
3462    return resultobj;
3463    fail:
3464    return NULL;
3465}
3466
3467
3468static PyObject *_wrap_libtrace_icmp_un_echo_sequence_set(PyObject *self, PyObject *args) {
3469    PyObject *resultobj = NULL;
3470    libtrace_icmp_un_echo *arg1 = (libtrace_icmp_un_echo *) 0 ;
3471    uint16_t arg2 ;
3472    PyObject * obj0 = 0 ;
3473    PyObject * obj1 = 0 ;
3474   
3475    if(!PyArg_ParseTuple(args,(char *)"OO:libtrace_icmp_un_echo_sequence_set",&obj0,&obj1)) goto fail;
3476    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un_echo, SWIG_POINTER_EXCEPTION | 0);
3477    if (SWIG_arg_fail(1)) SWIG_fail;
3478    {
3479        arg2 = (uint16_t)(SWIG_As_unsigned_SS_short(obj1)); 
3480        if (SWIG_arg_fail(2)) SWIG_fail;
3481    }
3482    if (arg1) (arg1)->sequence = arg2;
3483   
3484    Py_INCREF(Py_None); resultobj = Py_None;
3485    return resultobj;
3486    fail:
3487    return NULL;
3488}
3489
3490
3491static PyObject *_wrap_libtrace_icmp_un_echo_sequence_get(PyObject *self, PyObject *args) {
3492    PyObject *resultobj = NULL;
3493    libtrace_icmp_un_echo *arg1 = (libtrace_icmp_un_echo *) 0 ;
3494    uint16_t result;
3495    PyObject * obj0 = 0 ;
3496   
3497    if(!PyArg_ParseTuple(args,(char *)"O:libtrace_icmp_un_echo_sequence_get",&obj0)) goto fail;
3498    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_icmp_un_echo, SWIG_POINTER_EXCEPTION | 0);
3499    if (SWIG_arg_fail(1)) SWIG_fail;
3500    result = (uint16_t) ((arg1)->sequence);
3501   
3502    {
3503        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3504    }
3505    return resultobj;
3506    fail:
3507    return NULL;
3508}
3509
3510
3511static PyObject * libtrace_icmp_un_echo_swigregister(PyObject *self, PyObject *args) {
3512    PyObject *obj;
3513    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3514    SWIG_TypeClientData(SWIGTYPE_p_libtrace_icmp_un_echo, obj);
3515    Py_INCREF(obj);
3516    return Py_BuildValue((char *)"");
3517}
3518static PyObject *_wrap_new_Packet(PyObject *self, PyObject *args) {
3519    PyObject *resultobj = NULL;
3520    struct libtrace_packet_t *result;
3521   
3522    if(!PyArg_ParseTuple(args,(char *)":new_Packet")) goto fail;
3523    result = (struct libtrace_packet_t *)new_libtrace_packet_t();
3524   
3525    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_packet_t, 1);
3526    return resultobj;
3527    fail:
3528    return NULL;
3529}
3530
3531
3532static PyObject *_wrap_delete_Packet(PyObject *self, PyObject *args) {
3533    PyObject *resultobj = NULL;
3534    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3535    PyObject * obj0 = 0 ;
3536   
3537    if(!PyArg_ParseTuple(args,(char *)"O:delete_Packet",&obj0)) goto fail;
3538    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3539    if (SWIG_arg_fail(1)) SWIG_fail;
3540    delete_libtrace_packet_t(arg1);
3541   
3542    Py_INCREF(Py_None); resultobj = Py_None;
3543    return resultobj;
3544    fail:
3545    return NULL;
3546}
3547
3548
3549static PyObject *_wrap_Packet_trace_copy_packet(PyObject *self, PyObject *args) {
3550    PyObject *resultobj = NULL;
3551    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3552    libtrace_packet_t *result;
3553    PyObject * obj0 = 0 ;
3554   
3555    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_copy_packet",&obj0)) goto fail;
3556    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3557    if (SWIG_arg_fail(1)) SWIG_fail;
3558    result = (libtrace_packet_t *)libtrace_packet_t_trace_copy_packet(arg1);
3559   
3560    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_packet_t, 0);
3561    return resultobj;
3562    fail:
3563    return NULL;
3564}
3565
3566
3567static PyObject *_wrap_Packet_trace_get_link(PyObject *self, PyObject *args) {
3568    PyObject *resultobj = NULL;
3569    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3570    void *result;
3571    PyObject * obj0 = 0 ;
3572   
3573    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_link",&obj0)) goto fail;
3574    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3575    if (SWIG_arg_fail(1)) SWIG_fail;
3576    result = (void *)libtrace_packet_t_trace_get_link(arg1);
3577   
3578    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
3579    return resultobj;
3580    fail:
3581    return NULL;
3582}
3583
3584
3585static PyObject *_wrap_Packet_trace_get_transport(PyObject *self, PyObject *args) {
3586    PyObject *resultobj = NULL;
3587    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3588    uint8_t *arg2 = (uint8_t *) 0 ;
3589    uint32_t *arg3 = (uint32_t *) 0 ;
3590    void *result;
3591    PyObject * obj0 = 0 ;
3592    PyObject * obj1 = 0 ;
3593    PyObject * obj2 = 0 ;
3594   
3595    if(!PyArg_ParseTuple(args,(char *)"OOO:Packet_trace_get_transport",&obj0,&obj1,&obj2)) goto fail;
3596    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3597    if (SWIG_arg_fail(1)) SWIG_fail;
3598    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
3599    if (SWIG_arg_fail(2)) SWIG_fail;
3600    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_int, SWIG_POINTER_EXCEPTION | 0);
3601    if (SWIG_arg_fail(3)) SWIG_fail;
3602    result = (void *)libtrace_packet_t_trace_get_transport(arg1,arg2,arg3);
3603   
3604    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
3605    return resultobj;
3606    fail:
3607    return NULL;
3608}
3609
3610
3611static PyObject *_wrap_Packet_trace_get_ip(PyObject *self, PyObject *args) {
3612    PyObject *resultobj = NULL;
3613    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3614    struct libtrace_ip *result;
3615    PyObject * obj0 = 0 ;
3616   
3617    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_ip",&obj0)) goto fail;
3618    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3619    if (SWIG_arg_fail(1)) SWIG_fail;
3620    result = (struct libtrace_ip *)libtrace_packet_t_trace_get_ip(arg1);
3621   
3622    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_ip, 0);
3623    return resultobj;
3624    fail:
3625    return NULL;
3626}
3627
3628
3629static PyObject *_wrap_Packet_trace_get_tcp(PyObject *self, PyObject *args) {
3630    PyObject *resultobj = NULL;
3631    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3632    struct libtrace_tcp *result;
3633    PyObject * obj0 = 0 ;
3634   
3635    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_tcp",&obj0)) goto fail;
3636    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3637    if (SWIG_arg_fail(1)) SWIG_fail;
3638    result = (struct libtrace_tcp *)libtrace_packet_t_trace_get_tcp(arg1);
3639   
3640    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_tcp, 0);
3641    return resultobj;
3642    fail:
3643    return NULL;
3644}
3645
3646
3647static PyObject *_wrap_Packet_trace_get_udp(PyObject *self, PyObject *args) {
3648    PyObject *resultobj = NULL;
3649    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3650    struct libtrace_udp *result;
3651    PyObject * obj0 = 0 ;
3652   
3653    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_udp",&obj0)) goto fail;
3654    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3655    if (SWIG_arg_fail(1)) SWIG_fail;
3656    result = (struct libtrace_udp *)libtrace_packet_t_trace_get_udp(arg1);
3657   
3658    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_udp, 0);
3659    return resultobj;
3660    fail:
3661    return NULL;
3662}
3663
3664
3665static PyObject *_wrap_Packet_trace_get_icmp(PyObject *self, PyObject *args) {
3666    PyObject *resultobj = NULL;
3667    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3668    struct libtrace_icmp *result;
3669    PyObject * obj0 = 0 ;
3670   
3671    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_icmp",&obj0)) goto fail;
3672    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3673    if (SWIG_arg_fail(1)) SWIG_fail;
3674    result = (struct libtrace_icmp *)libtrace_packet_t_trace_get_icmp(arg1);
3675   
3676    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_icmp, 0);
3677    return resultobj;
3678    fail:
3679    return NULL;
3680}
3681
3682
3683static PyObject *_wrap_Packet_trace_get_destination_mac(PyObject *self, PyObject *args) {
3684    PyObject *resultobj = NULL;
3685    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3686    char *result;
3687    PyObject * obj0 = 0 ;
3688   
3689    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_destination_mac",&obj0)) goto fail;
3690    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3691    if (SWIG_arg_fail(1)) SWIG_fail;
3692    result = (char *)libtrace_packet_t_trace_get_destination_mac(arg1);
3693   
3694    resultobj = SWIG_FromCharPtr(result);
3695    return resultobj;
3696    fail:
3697    return NULL;
3698}
3699
3700
3701static PyObject *_wrap_Packet_trace_get_source_mac(PyObject *self, PyObject *args) {
3702    PyObject *resultobj = NULL;
3703    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3704    char *result;
3705    PyObject * obj0 = 0 ;
3706   
3707    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_source_mac",&obj0)) goto fail;
3708    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3709    if (SWIG_arg_fail(1)) SWIG_fail;
3710    result = (char *)libtrace_packet_t_trace_get_source_mac(arg1);
3711   
3712    resultobj = SWIG_FromCharPtr(result);
3713    return resultobj;
3714    fail:
3715    return NULL;
3716}
3717
3718
3719static PyObject *_wrap_Packet_trace_ether_ntoa(PyObject *self, PyObject *args) {
3720    PyObject *resultobj = NULL;
3721    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3722    uint8_t *arg2 = (uint8_t *) 0 ;
3723    char *result;
3724    PyObject * obj0 = 0 ;
3725    PyObject * obj1 = 0 ;
3726   
3727    if(!PyArg_ParseTuple(args,(char *)"OO:Packet_trace_ether_ntoa",&obj0,&obj1)) goto fail;
3728    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3729    if (SWIG_arg_fail(1)) SWIG_fail;
3730    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
3731    if (SWIG_arg_fail(2)) SWIG_fail;
3732    result = (char *)libtrace_packet_t_trace_ether_ntoa(arg1,arg2);
3733   
3734    resultobj = SWIG_FromCharPtr(result);
3735    return resultobj;
3736    fail:
3737    return NULL;
3738}
3739
3740
3741static PyObject *_wrap_Packet_trace_get_source_port(PyObject *self, PyObject *args) {
3742    PyObject *resultobj = NULL;
3743    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3744    uint16_t result;
3745    PyObject * obj0 = 0 ;
3746   
3747    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_source_port",&obj0)) goto fail;
3748    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3749    if (SWIG_arg_fail(1)) SWIG_fail;
3750    result = (uint16_t)libtrace_packet_t_trace_get_source_port(arg1);
3751   
3752    {
3753        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3754    }
3755    return resultobj;
3756    fail:
3757    return NULL;
3758}
3759
3760
3761static PyObject *_wrap_Packet_trace_get_destination_port(PyObject *self, PyObject *args) {
3762    PyObject *resultobj = NULL;
3763    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3764    uint16_t result;
3765    PyObject * obj0 = 0 ;
3766   
3767    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_destination_port",&obj0)) goto fail;
3768    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3769    if (SWIG_arg_fail(1)) SWIG_fail;
3770    result = (uint16_t)libtrace_packet_t_trace_get_destination_port(arg1);
3771   
3772    {
3773        resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result)); 
3774    }
3775    return resultobj;
3776    fail:
3777    return NULL;
3778}
3779
3780
3781static PyObject *_wrap_Packet_trace_get_seconds(PyObject *self, PyObject *args) {
3782    PyObject *resultobj = NULL;
3783    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3784    double result;
3785    PyObject * obj0 = 0 ;
3786   
3787    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_seconds",&obj0)) goto fail;
3788    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3789    if (SWIG_arg_fail(1)) SWIG_fail;
3790    result = (double)libtrace_packet_t_trace_get_seconds(arg1);
3791   
3792    {
3793        resultobj = SWIG_From_double((double)(result)); 
3794    }
3795    return resultobj;
3796    fail:
3797    return NULL;
3798}
3799
3800
3801static PyObject *_wrap_Packet_trace_get_erf_timestamp(PyObject *self, PyObject *args) {
3802    PyObject *resultobj = NULL;
3803    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3804    uint64_t result;
3805    PyObject * obj0 = 0 ;
3806   
3807    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_erf_timestamp",&obj0)) goto fail;
3808    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3809    if (SWIG_arg_fail(1)) SWIG_fail;
3810    result = libtrace_packet_t_trace_get_erf_timestamp(arg1);
3811   
3812    {
3813        uint64_t * resultptr;
3814        resultptr = (uint64_t *) malloc(sizeof(uint64_t));
3815        if (resultptr) memcpy(resultptr, &result, sizeof(uint64_t));
3816        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_uint64_t, 1);
3817    }
3818    return resultobj;
3819    fail:
3820    return NULL;
3821}
3822
3823
3824static PyObject *_wrap_Packet_trace_get_timeval(PyObject *self, PyObject *args) {
3825    PyObject *resultobj = NULL;
3826    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3827    struct timeval result;
3828    PyObject * obj0 = 0 ;
3829   
3830    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_timeval",&obj0)) goto fail;
3831    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3832    if (SWIG_arg_fail(1)) SWIG_fail;
3833    result = libtrace_packet_t_trace_get_timeval(arg1);
3834   
3835    {
3836        struct timeval * resultptr;
3837        resultptr = (struct timeval *) malloc(sizeof(struct timeval));
3838        if (resultptr) memcpy(resultptr, &result, sizeof(struct timeval));
3839        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_timeval, 1);
3840    }
3841    return resultobj;
3842    fail:
3843    return NULL;
3844}
3845
3846
3847static PyObject *_wrap_Packet_trace_get_capture_length(PyObject *self, PyObject *args) {
3848    PyObject *resultobj = NULL;
3849    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3850    int result;
3851    PyObject * obj0 = 0 ;
3852   
3853    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_capture_length",&obj0)) goto fail;
3854    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3855    if (SWIG_arg_fail(1)) SWIG_fail;
3856    result = (int)libtrace_packet_t_trace_get_capture_length(arg1);
3857   
3858    {
3859        resultobj = SWIG_From_int((int)(result)); 
3860    }
3861    return resultobj;
3862    fail:
3863    return NULL;
3864}
3865
3866
3867static PyObject *_wrap_Packet_trace_set_capture_length(PyObject *self, PyObject *args) {
3868    PyObject *resultobj = NULL;
3869    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3870    size_t arg2 ;
3871    size_t result;
3872    PyObject * obj0 = 0 ;
3873    PyObject * obj1 = 0 ;
3874   
3875    if(!PyArg_ParseTuple(args,(char *)"OO:Packet_trace_set_capture_length",&obj0,&obj1)) goto fail;
3876    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3877    if (SWIG_arg_fail(1)) SWIG_fail;
3878    {
3879        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
3880        if (SWIG_arg_fail(2)) SWIG_fail;
3881    }
3882    result = libtrace_packet_t_trace_set_capture_length(arg1,arg2);
3883   
3884    {
3885        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
3886    }
3887    return resultobj;
3888    fail:
3889    return NULL;
3890}
3891
3892
3893static PyObject *_wrap_Packet_trace_get_wire_lenth(PyObject *self, PyObject *args) {
3894    PyObject *resultobj = NULL;
3895    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3896    int result;
3897    PyObject * obj0 = 0 ;
3898   
3899    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_wire_lenth",&obj0)) goto fail;
3900    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3901    if (SWIG_arg_fail(1)) SWIG_fail;
3902    result = (int)libtrace_packet_t_trace_get_wire_lenth(arg1);
3903   
3904    {
3905        resultobj = SWIG_From_int((int)(result)); 
3906    }
3907    return resultobj;
3908    fail:
3909    return NULL;
3910}
3911
3912
3913static PyObject *_wrap_Packet_trace_get_framing_length(PyObject *self, PyObject *args) {
3914    PyObject *resultobj = NULL;
3915    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3916    int result;
3917    PyObject * obj0 = 0 ;
3918   
3919    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_framing_length",&obj0)) goto fail;
3920    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3921    if (SWIG_arg_fail(1)) SWIG_fail;
3922    result = (int)libtrace_packet_t_trace_get_framing_length(arg1);
3923   
3924    {
3925        resultobj = SWIG_From_int((int)(result)); 
3926    }
3927    return resultobj;
3928    fail:
3929    return NULL;
3930}
3931
3932
3933static PyObject *_wrap_Packet_trace_get_link_type(PyObject *self, PyObject *args) {
3934    PyObject *resultobj = NULL;
3935    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3936    libtrace_linktype_t result;
3937    PyObject * obj0 = 0 ;
3938   
3939    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_link_type",&obj0)) goto fail;
3940    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3941    if (SWIG_arg_fail(1)) SWIG_fail;
3942    result = libtrace_packet_t_trace_get_link_type(arg1);
3943   
3944    {
3945        libtrace_linktype_t * resultptr;
3946        resultptr = (libtrace_linktype_t *) malloc(sizeof(libtrace_linktype_t));
3947        if (resultptr) memcpy(resultptr, &result, sizeof(libtrace_linktype_t));
3948        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_libtrace_linktype_t, 1);
3949    }
3950    return resultobj;
3951    fail:
3952    return NULL;
3953}
3954
3955
3956static PyObject *_wrap_Packet_trace_get_direction(PyObject *self, PyObject *args) {
3957    PyObject *resultobj = NULL;
3958    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3959    int8_t result;
3960    PyObject * obj0 = 0 ;
3961   
3962    if(!PyArg_ParseTuple(args,(char *)"O:Packet_trace_get_direction",&obj0)) goto fail;
3963    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3964    if (SWIG_arg_fail(1)) SWIG_fail;
3965    result = libtrace_packet_t_trace_get_direction(arg1);
3966   
3967    {
3968        int8_t * resultptr;
3969        resultptr = (int8_t *) malloc(sizeof(int8_t));
3970        if (resultptr) memcpy(resultptr, &result, sizeof(int8_t));
3971        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_int8_t, 1);
3972    }
3973    return resultobj;
3974    fail:
3975    return NULL;
3976}
3977
3978
3979static PyObject *_wrap_Packet_trace_set_direction(PyObject *self, PyObject *args) {
3980    PyObject *resultobj = NULL;
3981    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
3982    int8_t arg2 ;
3983    int8_t result;
3984    PyObject * obj0 = 0 ;
3985    PyObject * obj1 = 0 ;
3986   
3987    if(!PyArg_ParseTuple(args,(char *)"OO:Packet_trace_set_direction",&obj0,&obj1)) goto fail;
3988    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
3989    if (SWIG_arg_fail(1)) SWIG_fail;
3990    {
3991        int8_t * argp;
3992        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_int8_t, SWIG_POINTER_EXCEPTION);
3993        if (SWIG_arg_fail(2)) SWIG_fail;
3994        if (argp == NULL) {
3995            SWIG_null_ref("int8_t");
3996        }
3997        if (SWIG_arg_fail(2)) SWIG_fail;
3998        arg2 = *argp;
3999    }
4000    result = libtrace_packet_t_trace_set_direction(arg1,arg2);
4001   
4002    {
4003        int8_t * resultptr;
4004        resultptr = (int8_t *) malloc(sizeof(int8_t));
4005        if (resultptr) memcpy(resultptr, &result, sizeof(int8_t));
4006        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_int8_t, 1);
4007    }
4008    return resultobj;
4009    fail:
4010    return NULL;
4011}
4012
4013
4014static PyObject *_wrap_Packet_trace_apply_filter(PyObject *self, PyObject *args) {
4015    PyObject *resultobj = NULL;
4016    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
4017    struct libtrace_filter_t *arg2 = (struct libtrace_filter_t *) 0 ;
4018    int result;
4019    PyObject * obj0 = 0 ;
4020    PyObject * obj1 = 0 ;
4021   
4022    if(!PyArg_ParseTuple(args,(char *)"OO:Packet_trace_apply_filter",&obj0,&obj1)) goto fail;
4023    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
4024    if (SWIG_arg_fail(1)) SWIG_fail;
4025    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_libtrace_filter_t, SWIG_POINTER_EXCEPTION | 0);
4026    if (SWIG_arg_fail(2)) SWIG_fail;
4027    result = (int)libtrace_packet_t_trace_apply_filter(arg1,arg2);
4028   
4029    {
4030        resultobj = SWIG_From_int((int)(result)); 
4031    }
4032    return resultobj;
4033    fail:
4034    return NULL;
4035}
4036
4037
4038static PyObject *_wrap_Packet_trace_get_server_port(PyObject *self, PyObject *args) {
4039    PyObject *resultobj = NULL;
4040    struct libtrace_packet_t *arg1 = (struct libtrace_packet_t *) 0 ;
4041    uint8_t arg2 ;
4042    uint16_t arg3 ;
4043    uint16_t arg4 ;
4044    uint8_t result;
4045    PyObject * obj0 = 0 ;
4046    PyObject * obj1 = 0 ;
4047    PyObject * obj2 = 0 ;
4048    PyObject * obj3 = 0 ;
4049   
4050    if(!PyArg_ParseTuple(args,(char *)"OOOO:Packet_trace_get_server_port",&obj0,&obj1,&obj2,&obj3)) goto fail;
4051    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
4052    if (SWIG_arg_fail(1)) SWIG_fail;
4053    {
4054        arg2 = (uint8_t)(SWIG_As_unsigned_SS_char(obj1)); 
4055        if (SWIG_arg_fail(2)) SWIG_fail;
4056    }
4057    {
4058        arg3 = (uint16_t)(SWIG_As_unsigned_SS_short(obj2)); 
4059        if (SWIG_arg_fail(3)) SWIG_fail;
4060    }
4061    {
4062        arg4 = (uint16_t)(SWIG_As_unsigned_SS_short(obj3)); 
4063        if (SWIG_arg_fail(4)) SWIG_fail;
4064    }
4065    result = (uint8_t)libtrace_packet_t_trace_get_server_port(arg1,arg2,arg3,arg4);
4066   
4067    {
4068        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
4069    }
4070    return resultobj;
4071    fail:
4072    return NULL;
4073}
4074
4075
4076static PyObject * Packet_swigregister(PyObject *self, PyObject *args) {
4077    PyObject *obj;
4078    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4079    SWIG_TypeClientData(SWIGTYPE_p_libtrace_packet_t, obj);
4080    Py_INCREF(obj);
4081    return Py_BuildValue((char *)"");
4082}
4083static PyObject *_wrap_new_Filter(PyObject *self, PyObject *args) {
4084    PyObject *resultobj = NULL;
4085    char *arg1 = (char *) 0 ;
4086    struct libtrace_filter_t *result;
4087    PyObject * obj0 = 0 ;
4088   
4089    if(!PyArg_ParseTuple(args,(char *)"O:new_Filter",&obj0)) goto fail;
4090    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
4091        SWIG_arg_fail(1);SWIG_fail;
4092    }
4093    result = (struct libtrace_filter_t *)new_libtrace_filter_t(arg1);
4094   
4095    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_filter_t, 1);
4096    return resultobj;
4097    fail:
4098    return NULL;
4099}
4100
4101
4102static PyObject *_wrap_delete_Filter(PyObject *self, PyObject *args) {
4103    PyObject *resultobj = NULL;
4104    struct libtrace_filter_t *arg1 = (struct libtrace_filter_t *) 0 ;
4105    PyObject * obj0 = 0 ;
4106   
4107    if(!PyArg_ParseTuple(args,(char *)"O:delete_Filter",&obj0)) goto fail;
4108    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_filter_t, SWIG_POINTER_EXCEPTION | 0);
4109    if (SWIG_arg_fail(1)) SWIG_fail;
4110    delete_libtrace_filter_t(arg1);
4111   
4112    Py_INCREF(Py_None); resultobj = Py_None;
4113    return resultobj;
4114    fail:
4115    return NULL;
4116}
4117
4118
4119static PyObject *_wrap_Filter_trace_apply_filter(PyObject *self, PyObject *args) {
4120    PyObject *resultobj = NULL;
4121    struct libtrace_filter_t *arg1 = (struct libtrace_filter_t *) 0 ;
4122    struct libtrace_packet_t *arg2 = (struct libtrace_packet_t *) 0 ;
4123    int result;
4124    PyObject * obj0 = 0 ;
4125    PyObject * obj1 = 0 ;
4126   
4127    if(!PyArg_ParseTuple(args,(char *)"OO:Filter_trace_apply_filter",&obj0,&obj1)) goto fail;
4128    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_filter_t, SWIG_POINTER_EXCEPTION | 0);
4129    if (SWIG_arg_fail(1)) SWIG_fail;
4130    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
4131    if (SWIG_arg_fail(2)) SWIG_fail;
4132    result = (int)libtrace_filter_t_trace_apply_filter(arg1,arg2);
4133   
4134    {
4135        resultobj = SWIG_From_int((int)(result)); 
4136    }
4137    return resultobj;
4138    fail:
4139    return NULL;
4140}
4141
4142
4143static PyObject * Filter_swigregister(PyObject *self, PyObject *args) {
4144    PyObject *obj;
4145    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4146    SWIG_TypeClientData(SWIGTYPE_p_libtrace_filter_t, obj);
4147    Py_INCREF(obj);
4148    return Py_BuildValue((char *)"");
4149}
4150static PyObject *_wrap_new_Trace(PyObject *self, PyObject *args) {
4151    PyObject *resultobj = NULL;
4152    char *arg1 = (char *) 0 ;
4153    struct libtrace_t *result;
4154    PyObject * obj0 = 0 ;
4155   
4156    if(!PyArg_ParseTuple(args,(char *)"O:new_Trace",&obj0)) goto fail;
4157    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
4158        SWIG_arg_fail(1);SWIG_fail;
4159    }
4160    result = (struct libtrace_t *)new_libtrace_t(arg1);
4161   
4162    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_t, 1);
4163    return resultobj;
4164    fail:
4165    return NULL;
4166}
4167
4168
4169static PyObject *_wrap_delete_Trace(PyObject *self, PyObject *args) {
4170    PyObject *resultobj = NULL;
4171    struct libtrace_t *arg1 = (struct libtrace_t *) 0 ;
4172    PyObject * obj0 = 0 ;
4173   
4174    if(!PyArg_ParseTuple(args,(char *)"O:delete_Trace",&obj0)) goto fail;
4175    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_t, SWIG_POINTER_EXCEPTION | 0);
4176    if (SWIG_arg_fail(1)) SWIG_fail;
4177    delete_libtrace_t(arg1);
4178   
4179    Py_INCREF(Py_None); resultobj = Py_None;
4180    return resultobj;
4181    fail:
4182    return NULL;
4183}
4184
4185
4186static PyObject *_wrap_Trace_trace_read_packet(PyObject *self, PyObject *args) {
4187    PyObject *resultobj = NULL;
4188    struct libtrace_t *arg1 = (struct libtrace_t *) 0 ;
4189    struct libtrace_packet_t *arg2 = (struct libtrace_packet_t *) 0 ;
4190    int result;
4191    PyObject * obj0 = 0 ;
4192    PyObject * obj1 = 0 ;
4193   
4194    if(!PyArg_ParseTuple(args,(char *)"OO:Trace_trace_read_packet",&obj0,&obj1)) goto fail;
4195    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_t, SWIG_POINTER_EXCEPTION | 0);
4196    if (SWIG_arg_fail(1)) SWIG_fail;
4197    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
4198    if (SWIG_arg_fail(2)) SWIG_fail;
4199    result = (int)libtrace_t_trace_read_packet(arg1,arg2);
4200   
4201    {
4202        resultobj = SWIG_From_int((int)(result)); 
4203    }
4204    return resultobj;
4205    fail:
4206    return NULL;
4207}
4208
4209
4210static PyObject *_wrap_Trace_trace_start(PyObject *self, PyObject *args) {
4211    PyObject *resultobj = NULL;
4212    struct libtrace_t *arg1 = (struct libtrace_t *) 0 ;
4213    int result;
4214    PyObject * obj0 = 0 ;
4215   
4216    if(!PyArg_ParseTuple(args,(char *)"O:Trace_trace_start",&obj0)) goto fail;
4217    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_t, SWIG_POINTER_EXCEPTION | 0);
4218    if (SWIG_arg_fail(1)) SWIG_fail;
4219    result = (int)libtrace_t_trace_start(arg1);
4220   
4221    {
4222        resultobj = SWIG_From_int((int)(result)); 
4223    }
4224    return resultobj;
4225    fail:
4226    return NULL;
4227}
4228
4229
4230static PyObject *_wrap_Trace_trace_pause(PyObject *self, PyObject *args) {
4231    PyObject *resultobj = NULL;
4232    struct libtrace_t *arg1 = (struct libtrace_t *) 0 ;
4233    int result;
4234    PyObject * obj0 = 0 ;
4235   
4236    if(!PyArg_ParseTuple(args,(char *)"O:Trace_trace_pause",&obj0)) goto fail;
4237    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_t, SWIG_POINTER_EXCEPTION | 0);
4238    if (SWIG_arg_fail(1)) SWIG_fail;
4239    result = (int)libtrace_t_trace_pause(arg1);
4240   
4241    {
4242        resultobj = SWIG_From_int((int)(result)); 
4243    }
4244    return resultobj;
4245    fail:
4246    return NULL;
4247}
4248
4249
4250static PyObject *_wrap_Trace_trace_help(PyObject *self, PyObject *args) {
4251    PyObject *resultobj = NULL;
4252    struct libtrace_t *arg1 = (struct libtrace_t *) 0 ;
4253    PyObject * obj0 = 0 ;
4254   
4255    if(!PyArg_ParseTuple(args,(char *)"O:Trace_trace_help",&obj0)) goto fail;
4256    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_t, SWIG_POINTER_EXCEPTION | 0);
4257    if (SWIG_arg_fail(1)) SWIG_fail;
4258    libtrace_t_trace_help(arg1);
4259   
4260    Py_INCREF(Py_None); resultobj = Py_None;
4261    return resultobj;
4262    fail:
4263    return NULL;
4264}
4265
4266
4267static PyObject *_wrap_Trace_trace_config(PyObject *self, PyObject *args) {
4268    PyObject *resultobj = NULL;
4269    struct libtrace_t *arg1 = (struct libtrace_t *) 0 ;
4270    trace_option_t arg2 ;
4271    void *arg3 = (void *) 0 ;
4272    int result;
4273    PyObject * obj0 = 0 ;
4274    PyObject * obj1 = 0 ;
4275    PyObject * obj2 = 0 ;
4276   
4277    if(!PyArg_ParseTuple(args,(char *)"OOO:Trace_trace_config",&obj0,&obj1,&obj2)) goto fail;
4278    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_t, SWIG_POINTER_EXCEPTION | 0);
4279    if (SWIG_arg_fail(1)) SWIG_fail;
4280    {
4281        trace_option_t * argp;
4282        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_trace_option_t, SWIG_POINTER_EXCEPTION);
4283        if (SWIG_arg_fail(2)) SWIG_fail;
4284        if (argp == NULL) {
4285            SWIG_null_ref("trace_option_t");
4286        }
4287        if (SWIG_arg_fail(2)) SWIG_fail;
4288        arg2 = *argp;
4289    }
4290    {
4291        if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) {
4292            SWIG_arg_fail(3);SWIG_fail;
4293        }
4294    }
4295    result = (int)libtrace_t_trace_config(arg1,arg2,arg3);
4296   
4297    {
4298        resultobj = SWIG_From_int((int)(result)); 
4299    }
4300    return resultobj;
4301    fail:
4302    return NULL;
4303}
4304
4305
4306static PyObject *_wrap_Trace_trace_get_err(PyObject *self, PyObject *args) {
4307    PyObject *resultobj = NULL;
4308    struct libtrace_t *arg1 = (struct libtrace_t *) 0 ;
4309    libtrace_err_t result;
4310    PyObject * obj0 = 0 ;
4311   
4312    if(!PyArg_ParseTuple(args,(char *)"O:Trace_trace_get_err",&obj0)) goto fail;
4313    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_t, SWIG_POINTER_EXCEPTION | 0);
4314    if (SWIG_arg_fail(1)) SWIG_fail;
4315    result = libtrace_t_trace_get_err(arg1);
4316   
4317    {
4318        libtrace_err_t * resultptr;
4319        resultptr = (libtrace_err_t *) malloc(sizeof(libtrace_err_t));
4320        if (resultptr) memcpy(resultptr, &result, sizeof(libtrace_err_t));
4321        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_libtrace_err_t, 1);
4322    }
4323    return resultobj;
4324    fail:
4325    return NULL;
4326}
4327
4328
4329static PyObject *_wrap_Trace_trace_is_err(PyObject *self, PyObject *args) {
4330    PyObject *resultobj = NULL;
4331    struct libtrace_t *arg1 = (struct libtrace_t *) 0 ;
4332    bool result;
4333    PyObject * obj0 = 0 ;
4334   
4335    if(!PyArg_ParseTuple(args,(char *)"O:Trace_trace_is_err",&obj0)) goto fail;
4336    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_t, SWIG_POINTER_EXCEPTION | 0);
4337    if (SWIG_arg_fail(1)) SWIG_fail;
4338    result = (bool)libtrace_t_trace_is_err(arg1);
4339   
4340    {
4341        resultobj = SWIG_From_bool((bool)(result)); 
4342    }
4343    return resultobj;
4344    fail:
4345    return NULL;
4346}
4347
4348
4349static PyObject * Trace_swigregister(PyObject *self, PyObject *args) {
4350    PyObject *obj;
4351    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4352    SWIG_TypeClientData(SWIGTYPE_p_libtrace_t, obj);
4353    Py_INCREF(obj);
4354    return Py_BuildValue((char *)"");
4355}
4356static PyObject *_wrap_new_OutputTrace(PyObject *self, PyObject *args) {
4357    PyObject *resultobj = NULL;
4358    char *arg1 = (char *) 0 ;
4359    struct libtrace_out_t *result;
4360    PyObject * obj0 = 0 ;
4361   
4362    if(!PyArg_ParseTuple(args,(char *)"O:new_OutputTrace",&obj0)) goto fail;
4363    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
4364        SWIG_arg_fail(1);SWIG_fail;
4365    }
4366    result = (struct libtrace_out_t *)new_libtrace_out_t(arg1);
4367   
4368    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_libtrace_out_t, 1);
4369    return resultobj;
4370    fail:
4371    return NULL;
4372}
4373
4374
4375static PyObject *_wrap_delete_OutputTrace(PyObject *self, PyObject *args) {
4376    PyObject *resultobj = NULL;
4377    struct libtrace_out_t *arg1 = (struct libtrace_out_t *) 0 ;
4378    PyObject * obj0 = 0 ;
4379   
4380    if(!PyArg_ParseTuple(args,(char *)"O:delete_OutputTrace",&obj0)) goto fail;
4381    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_out_t, SWIG_POINTER_EXCEPTION | 0);
4382    if (SWIG_arg_fail(1)) SWIG_fail;
4383    delete_libtrace_out_t(arg1);
4384   
4385    Py_INCREF(Py_None); resultobj = Py_None;
4386    return resultobj;
4387    fail:
4388    return NULL;
4389}
4390
4391
4392static PyObject *_wrap_OutputTrace_trace_start_output(PyObject *self, PyObject *args) {
4393    PyObject *resultobj = NULL;
4394    struct libtrace_out_t *arg1 = (struct libtrace_out_t *) 0 ;
4395    int result;
4396    PyObject * obj0 = 0 ;
4397   
4398    if(!PyArg_ParseTuple(args,(char *)"O:OutputTrace_trace_start_output",&obj0)) goto fail;
4399    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_out_t, SWIG_POINTER_EXCEPTION | 0);
4400    if (SWIG_arg_fail(1)) SWIG_fail;
4401    result = (int)libtrace_out_t_trace_start_output(arg1);
4402   
4403    {
4404        resultobj = SWIG_From_int((int)(result)); 
4405    }
4406    return resultobj;
4407    fail:
4408    return NULL;
4409}
4410
4411
4412static PyObject *_wrap_OutputTrace_trace_config_output(PyObject *self, PyObject *args) {
4413    PyObject *resultobj = NULL;
4414    struct libtrace_out_t *arg1 = (struct libtrace_out_t *) 0 ;
4415    trace_option_output_t arg2 ;
4416    void *arg3 = (void *) 0 ;
4417    int result;
4418    PyObject * obj0 = 0 ;
4419    PyObject * obj1 = 0 ;
4420    PyObject * obj2 = 0 ;
4421   
4422    if(!PyArg_ParseTuple(args,(char *)"OOO:OutputTrace_trace_config_output",&obj0,&obj1,&obj2)) goto fail;
4423    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_out_t, SWIG_POINTER_EXCEPTION | 0);
4424    if (SWIG_arg_fail(1)) SWIG_fail;
4425    {
4426        trace_option_output_t * argp;
4427        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_trace_option_output_t, SWIG_POINTER_EXCEPTION);
4428        if (SWIG_arg_fail(2)) SWIG_fail;
4429        if (argp == NULL) {
4430            SWIG_null_ref("trace_option_output_t");
4431        }
4432        if (SWIG_arg_fail(2)) SWIG_fail;
4433        arg2 = *argp;
4434    }
4435    {
4436        if ((SWIG_ConvertPtr(obj2,(void **)(&arg3),0,SWIG_POINTER_EXCEPTION|0))== -1) {
4437            SWIG_arg_fail(3);SWIG_fail;
4438        }
4439    }
4440    result = (int)libtrace_out_t_trace_config_output(arg1,arg2,arg3);
4441   
4442    {
4443        resultobj = SWIG_From_int((int)(result)); 
4444    }
4445    return resultobj;
4446    fail:
4447    return NULL;
4448}
4449
4450
4451static PyObject *_wrap_OutputTrace_trace_get_err_output(PyObject *self, PyObject *args) {
4452    PyObject *resultobj = NULL;
4453    struct libtrace_out_t *arg1 = (struct libtrace_out_t *) 0 ;
4454    libtrace_err_t result;
4455    PyObject * obj0 = 0 ;
4456   
4457    if(!PyArg_ParseTuple(args,(char *)"O:OutputTrace_trace_get_err_output",&obj0)) goto fail;
4458    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_out_t, SWIG_POINTER_EXCEPTION | 0);
4459    if (SWIG_arg_fail(1)) SWIG_fail;
4460    result = libtrace_out_t_trace_get_err_output(arg1);
4461   
4462    {
4463        libtrace_err_t * resultptr;
4464        resultptr = (libtrace_err_t *) malloc(sizeof(libtrace_err_t));
4465        if (resultptr) memcpy(resultptr, &result, sizeof(libtrace_err_t));
4466        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_libtrace_err_t, 1);
4467    }
4468    return resultobj;
4469    fail:
4470    return NULL;
4471}
4472
4473
4474static PyObject *_wrap_OutputTrace_trace_is_err_output(PyObject *self, PyObject *args) {
4475    PyObject *resultobj = NULL;
4476    struct libtrace_out_t *arg1 = (struct libtrace_out_t *) 0 ;
4477    bool result;
4478    PyObject * obj0 = 0 ;
4479   
4480    if(!PyArg_ParseTuple(args,(char *)"O:OutputTrace_trace_is_err_output",&obj0)) goto fail;
4481    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_out_t, SWIG_POINTER_EXCEPTION | 0);
4482    if (SWIG_arg_fail(1)) SWIG_fail;
4483    result = (bool)libtrace_out_t_trace_is_err_output(arg1);
4484   
4485    {
4486        resultobj = SWIG_From_bool((bool)(result)); 
4487    }
4488    return resultobj;
4489    fail:
4490    return NULL;
4491}
4492
4493
4494static PyObject *_wrap_OutputTrace_trace_write_packet(PyObject *self, PyObject *args) {
4495    PyObject *resultobj = NULL;
4496    struct libtrace_out_t *arg1 = (struct libtrace_out_t *) 0 ;
4497    libtrace_packet_t *arg2 = (libtrace_packet_t *) 0 ;
4498    int result;
4499    PyObject * obj0 = 0 ;
4500    PyObject * obj1 = 0 ;
4501   
4502    if(!PyArg_ParseTuple(args,(char *)"OO:OutputTrace_trace_write_packet",&obj0,&obj1)) goto fail;
4503    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_libtrace_out_t, SWIG_POINTER_EXCEPTION | 0);
4504    if (SWIG_arg_fail(1)) SWIG_fail;
4505    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_libtrace_packet_t, SWIG_POINTER_EXCEPTION | 0);
4506    if (SWIG_arg_fail(2)) SWIG_fail;
4507    result = (int)libtrace_out_t_trace_write_packet(arg1,arg2);
4508   
4509    {
4510        resultobj = SWIG_From_int((int)(result)); 
4511    }
4512    return resultobj;
4513    fail:
4514    return NULL;
4515}
4516
4517
4518static PyObject * OutputTrace_swigregister(PyObject *self, PyObject *args) {
4519    PyObject *obj;
4520    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4521    SWIG_TypeClientData(SWIGTYPE_p_libtrace_out_t, obj);
4522    Py_INCREF(obj);
4523    return Py_BuildValue((char *)"");
4524}
4525static PyMethodDef SwigMethods[] = {
4526         { (char *)"in_addr_s_addr_set", _wrap_in_addr_s_addr_set, METH_VARARGS, NULL},
4527         { (char *)"in_addr_s_addr_get", _wrap_in_addr_s_addr_get, METH_VARARGS, NULL},
4528         { (char *)"in_addr_swigregister", in_addr_swigregister, METH_VARARGS, NULL},
4529         { (char *)"libtrace_ip_ip_hl_set", _wrap_libtrace_ip_ip_hl_set, METH_VARARGS, NULL},
4530         { (char *)"libtrace_ip_ip_hl_get", _wrap_libtrace_ip_ip_hl_get, METH_VARARGS, NULL},
4531         { (char *)"libtrace_ip_ip_v_set", _wrap_libtrace_ip_ip_v_set, METH_VARARGS, NULL},
4532         { (char *)"libtrace_ip_ip_v_get", _wrap_libtrace_ip_ip_v_get, METH_VARARGS, NULL},
4533         { (char *)"libtrace_ip_ip_tos_set", _wrap_libtrace_ip_ip_tos_set, METH_VARARGS, NULL},
4534         { (char *)"libtrace_ip_ip_tos_get", _wrap_libtrace_ip_ip_tos_get, METH_VARARGS, NULL},
4535         { (char *)"libtrace_ip_ip_ttl_set", _wrap_libtrace_ip_ip_ttl_set, METH_VARARGS, NULL},
4536         { (char *)"libtrace_ip_ip_ttl_get", _wrap_libtrace_ip_ip_ttl_get, METH_VARARGS, NULL},
4537         { (char *)"libtrace_ip_ip_p_set", _wrap_libtrace_ip_ip_p_set, METH_VARARGS, NULL},
4538         { (char *)"libtrace_ip_ip_p_get", _wrap_libtrace_ip_ip_p_get, METH_VARARGS, NULL},
4539         { (char *)"libtrace_ip_ip_sum_get", _wrap_libtrace_ip_ip_sum_get, METH_VARARGS, NULL},
4540         { (char *)"libtrace_ip_ip_len_get", _wrap_libtrace_ip_ip_len_get, METH_VARARGS, NULL},
4541         { (char *)"libtrace_ip_ip_id_get", _wrap_libtrace_ip_ip_id_get, METH_VARARGS, NULL},
4542         { (char *)"libtrace_ip_ip_off_get", _wrap_libtrace_ip_ip_off_get, METH_VARARGS, NULL},
4543         { (char *)"libtrace_ip_ip_src_get", _wrap_libtrace_ip_ip_src_get, METH_VARARGS, NULL},
4544         { (char *)"libtrace_ip_ip_dst_get", _wrap_libtrace_ip_ip_dst_get, METH_VARARGS, NULL},
4545         { (char *)"libtrace_ip_swigregister", libtrace_ip_swigregister, METH_VARARGS, NULL},
4546         { (char *)"libtrace_tcp_res1_set", _wrap_libtrace_tcp_res1_set, METH_VARARGS, NULL},
4547         { (char *)"libtrace_tcp_res1_get", _wrap_libtrace_tcp_res1_get, METH_VARARGS, NULL},
4548         { (char *)"libtrace_tcp_doff_set", _wrap_libtrace_tcp_doff_set, METH_VARARGS, NULL},
4549         { (char *)"libtrace_tcp_doff_get", _wrap_libtrace_tcp_doff_get, METH_VARARGS, NULL},
4550         { (char *)"libtrace_tcp_fin_set", _wrap_libtrace_tcp_fin_set, METH_VARARGS, NULL},
4551         { (char *)"libtrace_tcp_fin_get", _wrap_libtrace_tcp_fin_get, METH_VARARGS, NULL},
4552         { (char *)"libtrace_tcp_syn_set", _wrap_libtrace_tcp_syn_set, METH_VARARGS, NULL},
4553         { (char *)"libtrace_tcp_syn_get", _wrap_libtrace_tcp_syn_get, METH_VARARGS, NULL},
4554         { (char *)"libtrace_tcp_rst_set", _wrap_libtrace_tcp_rst_set, METH_VARARGS, NULL},
4555         { (char *)"libtrace_tcp_rst_get", _wrap_libtrace_tcp_rst_get, METH_VARARGS, NULL},
4556         { (char *)"libtrace_tcp_psh_set", _wrap_libtrace_tcp_psh_set, METH_VARARGS, NULL},
4557         { (char *)"libtrace_tcp_psh_get", _wrap_libtrace_tcp_psh_get, METH_VARARGS, NULL},
4558         { (char *)"libtrace_tcp_ack_set", _wrap_libtrace_tcp_ack_set, METH_VARARGS, NULL},
4559         { (char *)"libtrace_tcp_ack_get", _wrap_libtrace_tcp_ack_get, METH_VARARGS, NULL},
4560         { (char *)"libtrace_tcp_urg_set", _wrap_libtrace_tcp_urg_set, METH_VARARGS, NULL},
4561         { (char *)"libtrace_tcp_urg_get", _wrap_libtrace_tcp_urg_get, METH_VARARGS, NULL},
4562         { (char *)"libtrace_tcp_res2_set", _wrap_libtrace_tcp_res2_set, METH_VARARGS, NULL},
4563         { (char *)"libtrace_tcp_res2_get", _wrap_libtrace_tcp_res2_get, METH_VARARGS, NULL},
4564         { (char *)"libtrace_tcp_source_get", _wrap_libtrace_tcp_source_get, METH_VARARGS, NULL},
4565         { (char *)"libtrace_tcp_dest_get", _wrap_libtrace_tcp_dest_get, METH_VARARGS, NULL},
4566         { (char *)"libtrace_tcp_window_get", _wrap_libtrace_tcp_window_get, METH_VARARGS, NULL},
4567         { (char *)"libtrace_tcp_check_get", _wrap_libtrace_tcp_check_get, METH_VARARGS, NULL},
4568         { (char *)"libtrace_tcp_urg_ptr_get", _wrap_libtrace_tcp_urg_ptr_get, METH_VARARGS, NULL},
4569         { (char *)"libtrace_tcp_seq_get", _wrap_libtrace_tcp_seq_get, METH_VARARGS, NULL},
4570         { (char *)"libtrace_tcp_ack_seq_get", _wrap_libtrace_tcp_ack_seq_get, METH_VARARGS, NULL},
4571         { (char *)"libtrace_tcp_swigregister", libtrace_tcp_swigregister, METH_VARARGS, NULL},
4572         { (char *)"libtrace_udp_source_get", _wrap_libtrace_udp_source_get, METH_VARARGS, NULL},
4573         { (char *)"libtrace_udp_dest_get", _wrap_libtrace_udp_dest_get, METH_VARARGS, NULL},
4574         { (char *)"libtrace_udp_len_get", _wrap_libtrace_udp_len_get, METH_VARARGS, NULL},
4575         { (char *)"libtrace_udp_check_get", _wrap_libtrace_udp_check_get, METH_VARARGS, NULL},
4576         { (char *)"libtrace_udp_swigregister", libtrace_udp_swigregister, METH_VARARGS, NULL},
4577         { (char *)"libtrace_icmp_type_set", _wrap_libtrace_icmp_type_set, METH_VARARGS, NULL},
4578         { (char *)"libtrace_icmp_type_get", _wrap_libtrace_icmp_type_get, METH_VARARGS, NULL},
4579         { (char *)"libtrace_icmp_code_set", _wrap_libtrace_icmp_code_set, METH_VARARGS, NULL},
4580         { (char *)"libtrace_icmp_code_get", _wrap_libtrace_icmp_code_get, METH_VARARGS, NULL},
4581         { (char *)"libtrace_icmp_checksum_set", _wrap_libtrace_icmp_checksum_set, METH_VARARGS, NULL},
4582         { (char *)"libtrace_icmp_checksum_get", _wrap_libtrace_icmp_checksum_get, METH_VARARGS, NULL},
4583         { (char *)"libtrace_icmp_un_get", _wrap_libtrace_icmp_un_get, METH_VARARGS, NULL},
4584         { (char *)"libtrace_icmp_swigregister", libtrace_icmp_swigregister, METH_VARARGS, NULL},
4585         { (char *)"libtrace_icmp_un_gateway_set", _wrap_libtrace_icmp_un_gateway_set, METH_VARARGS, NULL},
4586         { (char *)"libtrace_icmp_un_gateway_get", _wrap_libtrace_icmp_un_gateway_get, METH_VARARGS, NULL},
4587         { (char *)"libtrace_icmp_un_frag_get", _wrap_libtrace_icmp_un_frag_get, METH_VARARGS, NULL},
4588         { (char *)"libtrace_icmp_un_echo_get", _wrap_libtrace_icmp_un_echo_get, METH_VARARGS, NULL},
4589         { (char *)"libtrace_icmp_un_swigregister", libtrace_icmp_un_swigregister, METH_VARARGS, NULL},
4590         { (char *)"libtrace_icmp_un_frag___unused_set", _wrap_libtrace_icmp_un_frag___unused_set, METH_VARARGS, NULL},
4591         { (char *)"libtrace_icmp_un_frag___unused_get", _wrap_libtrace_icmp_un_frag___unused_get, METH_VARARGS, NULL},
4592         { (char *)"libtrace_icmp_un_frag_mtu_set", _wrap_libtrace_icmp_un_frag_mtu_set, METH_VARARGS, NULL},
4593         { (char *)"libtrace_icmp_un_frag_mtu_get", _wrap_libtrace_icmp_un_frag_mtu_get, METH_VARARGS, NULL},
4594         { (char *)"libtrace_icmp_un_frag_swigregister", libtrace_icmp_un_frag_swigregister, METH_VARARGS, NULL},
4595         { (char *)"libtrace_icmp_un_echo_id_set", _wrap_libtrace_icmp_un_echo_id_set, METH_VARARGS, NULL},
4596         { (char *)"libtrace_icmp_un_echo_id_get", _wrap_libtrace_icmp_un_echo_id_get, METH_VARARGS, NULL},
4597         { (char *)"libtrace_icmp_un_echo_sequence_set", _wrap_libtrace_icmp_un_echo_sequence_set, METH_VARARGS, NULL},
4598         { (char *)"libtrace_icmp_un_echo_sequence_get", _wrap_libtrace_icmp_un_echo_sequence_get, METH_VARARGS, NULL},
4599         { (char *)"libtrace_icmp_un_echo_swigregister", libtrace_icmp_un_echo_swigregister, METH_VARARGS, NULL},
4600         { (char *)"new_Packet", _wrap_new_Packet, METH_VARARGS, NULL},
4601         { (char *)"delete_Packet", _wrap_delete_Packet, METH_VARARGS, NULL},
4602         { (char *)"Packet_trace_copy_packet", _wrap_Packet_trace_copy_packet, METH_VARARGS, NULL},
4603         { (char *)"Packet_trace_get_link", _wrap_Packet_trace_get_link, METH_VARARGS, NULL},
4604         { (char *)"Packet_trace_get_transport", _wrap_Packet_trace_get_transport, METH_VARARGS, NULL},
4605         { (char *)"Packet_trace_get_ip", _wrap_Packet_trace_get_ip, METH_VARARGS, NULL},
4606         { (char *)"Packet_trace_get_tcp", _wrap_Packet_trace_get_tcp, METH_VARARGS, NULL},
4607         { (char *)"Packet_trace_get_udp", _wrap_Packet_trace_get_udp, METH_VARARGS, NULL},
4608         { (char *)"Packet_trace_get_icmp", _wrap_Packet_trace_get_icmp, METH_VARARGS, NULL},
4609         { (char *)"Packet_trace_get_destination_mac", _wrap_Packet_trace_get_destination_mac, METH_VARARGS, NULL},
4610         { (char *)"Packet_trace_get_source_mac", _wrap_Packet_trace_get_source_mac, METH_VARARGS, NULL},
4611         { (char *)"Packet_trace_ether_ntoa", _wrap_Packet_trace_ether_ntoa, METH_VARARGS, NULL},
4612         { (char *)"Packet_trace_get_source_port", _wrap_Packet_trace_get_source_port, METH_VARARGS, NULL},
4613         { (char *)"Packet_trace_get_destination_port", _wrap_Packet_trace_get_destination_port, METH_VARARGS, NULL},
4614         { (char *)"Packet_trace_get_seconds", _wrap_Packet_trace_get_seconds, METH_VARARGS, NULL},
4615         { (char *)"Packet_trace_get_erf_timestamp", _wrap_Packet_trace_get_erf_timestamp, METH_VARARGS, NULL},
4616         { (char *)"Packet_trace_get_timeval", _wrap_Packet_trace_get_timeval, METH_VARARGS, NULL},
4617         { (char *)"Packet_trace_get_capture_length", _wrap_Packet_trace_get_capture_length, METH_VARARGS, NULL},
4618         { (char *)"Packet_trace_set_capture_length", _wrap_Packet_trace_set_capture_length, METH_VARARGS, NULL},
4619         { (char *)"Packet_trace_get_wire_lenth", _wrap_Packet_trace_get_wire_lenth, METH_VARARGS, NULL},
4620         { (char *)"Packet_trace_get_framing_length", _wrap_Packet_trace_get_framing_length, METH_VARARGS, NULL},
4621         { (char *)"Packet_trace_get_link_type", _wrap_Packet_trace_get_link_type, METH_VARARGS, NULL},
4622         { (char *)"Packet_trace_get_direction", _wrap_Packet_trace_get_direction, METH_VARARGS, NULL},
4623         { (char *)"Packet_trace_set_direction", _wrap_Packet_trace_set_direction, METH_VARARGS, NULL},
4624         { (char *)"Packet_trace_apply_filter", _wrap_Packet_trace_apply_filter, METH_VARARGS, NULL},
4625         { (char *)"Packet_trace_get_server_port", _wrap_Packet_trace_get_server_port, METH_VARARGS, NULL},
4626         { (char *)"Packet_swigregister", Packet_swigregister, METH_VARARGS, NULL},
4627         { (char *)"new_Filter", _wrap_new_Filter, METH_VARARGS, NULL},
4628         { (char *)"delete_Filter", _wrap_delete_Filter, METH_VARARGS, NULL},
4629         { (char *)"Filter_trace_apply_filter", _wrap_Filter_trace_apply_filter, METH_VARARGS, NULL},
4630         { (char *)"Filter_swigregister", Filter_swigregister, METH_VARARGS, NULL},
4631         { (char *)"new_Trace", _wrap_new_Trace, METH_VARARGS, NULL},
4632         { (char *)"delete_Trace", _wrap_delete_Trace, METH_VARARGS, NULL},
4633         { (char *)"Trace_trace_read_packet", _wrap_Trace_trace_read_packet, METH_VARARGS, NULL},
4634         { (char *)"Trace_trace_start", _wrap_Trace_trace_start, METH_VARARGS, NULL},
4635         { (char *)"Trace_trace_pause", _wrap_Trace_trace_pause, METH_VARARGS, NULL},
4636         { (char *)"Trace_trace_help", _wrap_Trace_trace_help, METH_VARARGS, NULL},
4637         { (char *)"Trace_trace_config", _wrap_Trace_trace_config, METH_VARARGS, NULL},
4638         { (char *)"Trace_trace_get_err", _wrap_Trace_trace_get_err, METH_VARARGS, NULL},
4639         { (char *)"Trace_trace_is_err", _wrap_Trace_trace_is_err, METH_VARARGS, NULL},
4640         { (char *)"Trace_swigregister", Trace_swigregister, METH_VARARGS, NULL},
4641         { (char *)"new_OutputTrace", _wrap_new_OutputTrace, METH_VARARGS, NULL},
4642         { (char *)"delete_OutputTrace", _wrap_delete_OutputTrace, METH_VARARGS, NULL},
4643         { (char *)"OutputTrace_trace_start_output", _wrap_OutputTrace_trace_start_output, METH_VARARGS, NULL},
4644         { (char *)"OutputTrace_trace_config_output", _wrap_OutputTrace_trace_config_output, METH_VARARGS, NULL},
4645         { (char *)"OutputTrace_trace_get_err_output", _wrap_OutputTrace_trace_get_err_output, METH_VARARGS, NULL},
4646         { (char *)"OutputTrace_trace_is_err_output", _wrap_OutputTrace_trace_is_err_output, METH_VARARGS, NULL},
4647         { (char *)"OutputTrace_trace_write_packet", _wrap_OutputTrace_trace_write_packet, METH_VARARGS, NULL},
4648         { (char *)"OutputTrace_swigregister", OutputTrace_swigregister, METH_VARARGS, NULL},
4649         { NULL, NULL, 0, NULL }
4650};
4651
4652
4653/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4654
4655static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
4656static swig_type_info _swigt__p_in_addr = {"_p_in_addr", "in_addr *", 0, 0, 0};
4657static swig_type_info _swigt__p_int8_t = {"_p_int8_t", "int8_t *", 0, 0, 0};
4658static swig_type_info _swigt__p_libtrace_err_t = {"_p_libtrace_err_t", "libtrace_err_t *", 0, 0, 0};
4659static swig_type_info _swigt__p_libtrace_filter_t = {"_p_libtrace_filter_t", "libtrace_filter_t *", 0, 0, 0};
4660static swig_type_info _swigt__p_libtrace_icmp = {"_p_libtrace_icmp", "struct libtrace_icmp *", 0, 0, 0};
4661static swig_type_info _swigt__p_libtrace_icmp_un = {"_p_libtrace_icmp_un", "libtrace_icmp_un *", 0, 0, 0};
4662static swig_type_info _swigt__p_libtrace_icmp_un_echo = {"_p_libtrace_icmp_un_echo", "libtrace_icmp_un_echo *", 0, 0, 0};
4663static swig_type_info _swigt__p_libtrace_icmp_un_frag = {"_p_libtrace_icmp_un_frag", "libtrace_icmp_un_frag *", 0, 0, 0};
4664static swig_type_info _swigt__p_libtrace_ip = {"_p_libtrace_ip", "struct libtrace_ip *", 0, 0, 0};
4665static swig_type_info _swigt__p_libtrace_linktype_t = {"_p_libtrace_linktype_t", "libtrace_linktype_t *", 0, 0, 0};
4666static swig_type_info _swigt__p_libtrace_out_t = {"_p_libtrace_out_t", "libtrace_out_t *", 0, 0, 0};
4667static swig_type_info _swigt__p_libtrace_packet_t = {"_p_libtrace_packet_t", "libtrace_packet_t *", 0, 0, 0};
4668static swig_type_info _swigt__p_libtrace_t = {"_p_libtrace_t", "libtrace_t *", 0, 0, 0};
4669static swig_type_info _swigt__p_libtrace_tcp = {"_p_libtrace_tcp", "struct libtrace_tcp *", 0, 0, 0};
4670static swig_type_info _swigt__p_libtrace_udp = {"_p_libtrace_udp", "struct libtrace_udp *", 0, 0, 0};
4671static swig_type_info _swigt__p_timeval = {"_p_timeval", "struct timeval *", 0, 0, 0};
4672static swig_type_info _swigt__p_trace_option_output_t = {"_p_trace_option_output_t", "trace_option_output_t *", 0, 0, 0};
4673static swig_type_info _swigt__p_trace_option_t = {"_p_trace_option_t", "trace_option_t *", 0, 0, 0};
4674static swig_type_info _swigt__p_uint64_t = {"_p_uint64_t", "uint64_t *", 0, 0, 0};
4675static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint8_t *", 0, 0, 0};
4676static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|uint32_t *", 0, 0, 0};
4677static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint16_t *", 0, 0, 0};
4678static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, 0};
4679static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
4680static swig_type_info _swigt__size_t = {"_size_t", "size_t", 0, 0, 0};
4681
4682static swig_type_info *swig_type_initial[] = {
4683  &_swigt__p_char,
4684  &_swigt__p_in_addr,
4685  &_swigt__p_int8_t,
4686  &_swigt__p_libtrace_err_t,
4687  &_swigt__p_libtrace_filter_t,
4688  &_swigt__p_libtrace_icmp,
4689  &_swigt__p_libtrace_icmp_un,
4690  &_swigt__p_libtrace_icmp_un_echo,
4691  &_swigt__p_libtrace_icmp_un_frag,
4692  &_swigt__p_libtrace_ip,
4693  &_swigt__p_libtrace_linktype_t,
4694  &_swigt__p_libtrace_out_t,
4695  &_swigt__p_libtrace_packet_t,
4696  &_swigt__p_libtrace_t,
4697  &_swigt__p_libtrace_tcp,
4698  &_swigt__p_libtrace_udp,
4699  &_swigt__p_timeval,
4700  &_swigt__p_trace_option_output_t,
4701  &_swigt__p_trace_option_t,
4702  &_swigt__p_uint64_t,
4703  &_swigt__p_unsigned_char,
4704  &_swigt__p_unsigned_int,
4705  &_swigt__p_unsigned_short,
4706  &_swigt__p_void,
4707  &_swigt__ptrdiff_t,
4708  &_swigt__size_t,
4709};
4710
4711static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4712static swig_cast_info _swigc__p_in_addr[] = {  {&_swigt__p_in_addr, 0, 0, 0},{0, 0, 0, 0}};
4713static swig_cast_info _swigc__p_int8_t[] = {  {&_swigt__p_int8_t, 0, 0, 0},{0, 0, 0, 0}};
4714static swig_cast_info _swigc__p_libtrace_err_t[] = {  {&_swigt__p_libtrace_err_t, 0, 0, 0},{0, 0, 0, 0}};
4715static swig_cast_info _swigc__p_libtrace_filter_t[] = {  {&_swigt__p_libtrace_filter_t, 0, 0, 0},{0, 0, 0, 0}};
4716static swig_cast_info _swigc__p_libtrace_icmp[] = {  {&_swigt__p_libtrace_icmp, 0, 0, 0},{0, 0, 0, 0}};
4717static swig_cast_info _swigc__p_libtrace_icmp_un[] = {  {&_swigt__p_libtrace_icmp_un, 0, 0, 0},{0, 0, 0, 0}};
4718static swig_cast_info _swigc__p_libtrace_icmp_un_echo[] = {  {&_swigt__p_libtrace_icmp_un_echo, 0, 0, 0},{0, 0, 0, 0}};
4719static swig_cast_info _swigc__p_libtrace_icmp_un_frag[] = {  {&_swigt__p_libtrace_icmp_un_frag, 0, 0, 0},{0, 0, 0, 0}};
4720static swig_cast_info _swigc__p_libtrace_ip[] = {  {&_swigt__p_libtrace_ip, 0, 0, 0},{0, 0, 0, 0}};
4721static swig_cast_info _swigc__p_libtrace_linktype_t[] = {  {&_swigt__p_libtrace_linktype_t, 0, 0, 0},{0, 0, 0, 0}};
4722static swig_cast_info _swigc__p_libtrace_out_t[] = {  {&_swigt__p_libtrace_out_t, 0, 0, 0},{0, 0, 0, 0}};
4723static swig_cast_info _swigc__p_libtrace_packet_t[] = {  {&_swigt__p_libtrace_packet_t, 0, 0, 0},{0, 0, 0, 0}};
4724static swig_cast_info _swigc__p_libtrace_t[] = {  {&_swigt__p_libtrace_t, 0, 0, 0},{0, 0, 0, 0}};
4725static swig_cast_info _swigc__p_libtrace_tcp[] = {  {&_swigt__p_libtrace_tcp, 0, 0, 0},{0, 0, 0, 0}};
4726static swig_cast_info _swigc__p_libtrace_udp[] = {  {&_swigt__p_libtrace_udp, 0, 0, 0},{0, 0, 0, 0}};
4727static swig_cast_info _swigc__p_timeval[] = {  {&_swigt__p_timeval, 0, 0, 0},{0, 0, 0, 0}};
4728static swig_cast_info _swigc__p_trace_option_output_t[] = {  {&_swigt__p_trace_option_output_t, 0, 0, 0},{0, 0, 0, 0}};
4729static swig_cast_info _swigc__p_trace_option_t[] = {  {&_swigt__p_trace_option_t, 0, 0, 0},{0, 0, 0, 0}};
4730static swig_cast_info _swigc__p_uint64_t[] = {  {&_swigt__p_uint64_t, 0, 0, 0},{0, 0, 0, 0}};
4731static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
4732static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
4733static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
4734static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
4735static swig_cast_info _swigc__ptrdiff_t[] = {  {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
4736static swig_cast_info _swigc__size_t[] = {  {&_swigt__size_t, 0, 0, 0},{0, 0, 0, 0}};
4737
4738static swig_cast_info *swig_cast_initial[] = {
4739  _swigc__p_char,
4740  _swigc__p_in_addr,
4741  _swigc__p_int8_t,
4742  _swigc__p_libtrace_err_t,
4743  _swigc__p_libtrace_filter_t,
4744  _swigc__p_libtrace_icmp,
4745  _swigc__p_libtrace_icmp_un,
4746  _swigc__p_libtrace_icmp_un_echo,
4747  _swigc__p_libtrace_icmp_un_frag,
4748  _swigc__p_libtrace_ip,
4749  _swigc__p_libtrace_linktype_t,
4750  _swigc__p_libtrace_out_t,
4751  _swigc__p_libtrace_packet_t,
4752  _swigc__p_libtrace_t,
4753  _swigc__p_libtrace_tcp,
4754  _swigc__p_libtrace_udp,
4755  _swigc__p_timeval,
4756  _swigc__p_trace_option_output_t,
4757  _swigc__p_trace_option_t,
4758  _swigc__p_uint64_t,
4759  _swigc__p_unsigned_char,
4760  _swigc__p_unsigned_int,
4761  _swigc__p_unsigned_short,
4762  _swigc__p_void,
4763  _swigc__ptrdiff_t,
4764  _swigc__size_t,
4765};
4766
4767
4768/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4769
4770static swig_const_info swig_const_table[] = {
4771{0, 0, 0, 0.0, 0, 0}};
4772
4773#ifdef __cplusplus
4774}
4775#endif
4776/*************************************************************************
4777 * Type initialization:
4778 * This problem is tough by the requirement that no dynamic
4779 * memory is used. Also, since swig_type_info structures store pointers to
4780 * swig_cast_info structures and swig_cast_info structures store pointers back
4781 * to swig_type_info structures, we need some lookup code at initialization.
4782 * The idea is that swig generates all the structures that are needed.
4783 * The runtime then collects these partially filled structures.
4784 * The SWIG_InitializeModule function takes these initial arrays out of
4785 * swig_module, and does all the lookup, filling in the swig_module.types
4786 * array with the correct data and linking the correct swig_cast_info
4787 * structures together.
4788
4789 * The generated swig_type_info structures are assigned staticly to an initial
4790 * array. We just loop though that array, and handle each type individually.
4791 * First we lookup if this type has been already loaded, and if so, use the
4792 * loaded structure instead of the generated one. Then we have to fill in the
4793 * cast linked list. The cast data is initially stored in something like a
4794 * two-dimensional array. Each row corresponds to a type (there are the same
4795 * number of rows as there are in the swig_type_initial array). Each entry in
4796 * a column is one of the swig_cast_info structures for that type.
4797 * The cast_initial array is actually an array of arrays, because each row has
4798 * a variable number of columns. So to actually build the cast linked list,
4799 * we find the array of casts associated with the type, and loop through it
4800 * adding the casts to the list. The one last trick we need to do is making
4801 * sure the type pointer in the swig_cast_info struct is correct.
4802
4803 * First off, we lookup the cast->type name to see if it is already loaded.
4804 * There are three cases to handle:
4805 *  1) If the cast->type has already been loaded AND the type we are adding
4806 *     casting info to has not been loaded (it is in this module), THEN we
4807 *     replace the cast->type pointer with the type pointer that has already
4808 *     been loaded.
4809 *  2) If BOTH types (the one we are adding casting info to, and the
4810 *     cast->type) are loaded, THEN the cast info has already been loaded by
4811 *     the previous module so we just ignore it.
4812 *  3) Finally, if cast->type has not already been loaded, then we add that
4813 *     swig_cast_info to the linked list (because the cast->type) pointer will
4814 *     be correct.
4815**/
4816
4817#ifdef __cplusplus
4818extern "C" {
4819#endif
4820   
4821    SWIGRUNTIME void
4822    SWIG_InitializeModule(void *clientdata) {
4823        swig_type_info *type, *ret;
4824        swig_cast_info *cast;
4825        size_t i;
4826        swig_module_info *module_head;
4827        static int init_run = 0;
4828       
4829        clientdata = clientdata;
4830       
4831        if (init_run) return;
4832        init_run = 1;
4833       
4834        /* Initialize the swig_module */
4835        swig_module.type_initial = swig_type_initial;
4836        swig_module.cast_initial = swig_cast_initial;
4837       
4838        /* Try and load any already created modules */
4839        module_head = SWIG_GetModule(clientdata);
4840        if (module_head) {
4841            swig_module.next = module_head->next;
4842            module_head->next = &swig_module;
4843        } else {
4844            /* This is the first module loaded */
4845            swig_module.next = &swig_module;
4846            SWIG_SetModule(clientdata, &swig_module);
4847        }
4848       
4849        /* Now work on filling in swig_module.types */
4850        for (i = 0; i < swig_module.size; ++i) {
4851            type = 0;
4852           
4853            /* if there is another module already loaded */
4854            if (swig_module.next != &swig_module) {
4855                type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4856            }
4857            if (type) {
4858                /* Overwrite clientdata field */
4859                if (swig_module.type_initial[i]->clientdata) type->clientdata = swig_module.type_initial[i]->clientdata;
4860            } else {
4861                type = swig_module.type_initial[i];
4862            }
4863           
4864            /* Insert casting types */
4865            cast = swig_module.cast_initial[i];
4866            while (cast->type) {
4867                /* Don't need to add information already in the list */
4868                ret = 0;
4869                if (swig_module.next != &swig_module) {
4870                    ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4871                }
4872                if (ret && type == swig_module.type_initial[i]) {
4873                    cast->type = ret;
4874                    ret = 0;
4875                }
4876               
4877                if (!ret) {
4878                    if (type->cast) {
4879                        type->cast->prev = cast;
4880                        cast->next = type->cast;
4881                    }
4882                    type->cast = cast;
4883                }
4884               
4885                cast++;
4886            }
4887           
4888            /* Set entry in modules->types array equal to the type */
4889            swig_module.types[i] = type;
4890        }
4891        swig_module.types[i] = 0;
4892    }
4893   
4894    /* This function will propagate the clientdata field of type to
4895    * any new swig_type_info structures that have been added into the list
4896    * of equivalent types.  It is like calling
4897    * SWIG_TypeClientData(type, clientdata) a second time.
4898    */
4899    SWIGRUNTIME void
4900    SWIG_PropagateClientData(void) {
4901        size_t i;
4902        swig_cast_info *equiv;
4903        static int init_run = 0;
4904       
4905        if (init_run) return;
4906        init_run = 1;
4907       
4908        for (i = 0; i < swig_module.size; i++) {
4909            if (swig_module.types[i]->clientdata) {
4910                equiv = swig_module.types[i]->cast;
4911                while (equiv) {
4912                    if (!equiv->converter) {
4913                        if (equiv->type && !equiv->type->clientdata)
4914                        SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4915                    }
4916                    equiv = equiv->next;
4917                }
4918            }
4919        }
4920    }
4921   
4922#ifdef __cplusplus
4923}
4924#endif
4925
4926
4927
4928#ifdef __cplusplus
4929extern "C" {
4930#endif
4931   
4932    /* Python-specific SWIG API */
4933#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
4934#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
4935#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
4936   
4937    /* -----------------------------------------------------------------------------
4938     * global variable support code.
4939     * ----------------------------------------------------------------------------- */
4940   
4941    typedef struct swig_globalvar {
4942        char       *name;                  /* Name of global variable */
4943        PyObject *(*get_attr)(void);       /* Return the current value */
4944        int       (*set_attr)(PyObject *); /* Set the value */
4945        struct swig_globalvar *next;
4946    } swig_globalvar;
4947   
4948    typedef struct swig_varlinkobject {
4949        PyObject_HEAD
4950        swig_globalvar *vars;
4951    } swig_varlinkobject;
4952   
4953    SWIGINTERN PyObject *
4954    swig_varlink_repr(swig_varlinkobject *v) {
4955        v = v;
4956        return PyString_FromString("<Swig global variables>");
4957    }
4958   
4959    SWIGINTERN int
4960    swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
4961        swig_globalvar  *var;
4962        flags = flags;
4963        fprintf(fp,"Swig global variables { ");
4964        for (var = v->vars; var; var=var->next) {
4965            fprintf(fp,"%s", var->name);
4966            if (var->next) fprintf(fp,", ");
4967        }
4968        fprintf(fp," }\n");
4969        return 0;
4970    }
4971   
4972    SWIGINTERN PyObject *
4973    swig_varlink_getattr(swig_varlinkobject *v, char *n) {
4974        swig_globalvar *var = v->vars;
4975        while (var) {
4976            if (strcmp(var->name,n) == 0) {
4977                return (*var->get_attr)();
4978            }
4979            var = var->next;
4980        }
4981        PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4982        return NULL;
4983    }
4984   
4985    SWIGINTERN int
4986    swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
4987        swig_globalvar *var = v->vars;
4988        while (var) {
4989            if (strcmp(var->name,n) == 0) {
4990                return (*var->set_attr)(p);
4991            }
4992            var = var->next;
4993        }
4994        PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4995        return 1;
4996    }
4997   
4998    SWIGINTERN PyTypeObject*
4999    swig_varlink_type(void) {
5000        static char varlink__doc__[] = "Swig var link object";
5001        static PyTypeObject varlink_type
5002#if !defined(__cplusplus)
5003        ;
5004        static int type_init = 0; 
5005        if (!type_init) {
5006            PyTypeObject tmp
5007#endif
5008            = {
5009                PyObject_HEAD_INIT(&PyType_Type)
5010                0,                                  /* Number of items in variable part (ob_size) */
5011                (char *)"swigvarlink",              /* Type name (tp_name) */
5012                sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
5013                0,                                  /* Itemsize (tp_itemsize) */
5014                0,                                  /* Deallocator (tp_dealloc) */ 
5015                (printfunc) swig_varlink_print,     /* Print (tp_print) */
5016                (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
5017                (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
5018                0,                                  /* tp_compare */
5019                (reprfunc) swig_varlink_repr,       /* tp_repr */
5020                0,                                  /* tp_as_number */
5021                0,                                  /* tp_as_sequence */
5022                0,                                  /* tp_as_mapping */
5023                0,                                  /* tp_hash */
5024                0,                                  /* tp_call */
5025                0,                                  /* tp_str */
5026                0,                                  /* tp_getattro */
5027                0,                                  /* tp_setattro */
5028                0,                                  /* tp_as_buffer */
5029                0,                                  /* tp_flags */
5030                varlink__doc__,                     /* tp_doc */
5031#if PY_VERSION_HEX >= 0x02000000
5032                0,                                  /* tp_traverse */
5033                0,                                  /* tp_clear */
5034#endif
5035#if PY_VERSION_HEX >= 0x02010000
5036                0,                                  /* tp_richcompare */
5037                0,                                  /* tp_weaklistoffset */
5038#endif
5039#if PY_VERSION_HEX >= 0x02020000
5040                0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
5041#endif
5042#if PY_VERSION_HEX >= 0x02030000
5043                0,                                  /* tp_del */
5044#endif
5045#ifdef COUNT_ALLOCS
5046                0,0,0,0                             /* tp_alloc -> tp_next */
5047#endif
5048            };
5049#if !defined(__cplusplus)
5050            varlink_type = tmp;
5051            type_init = 1;
5052        }
5053#endif
5054        return &varlink_type;
5055    }
5056   
5057    /* Create a variable linking object for use later */
5058    SWIGINTERN PyObject *
5059    SWIG_Python_newvarlink(void) {
5060        swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
5061        if (result) {
5062            result->vars = 0;
5063        }
5064        return ((PyObject*) result);
5065    }
5066   
5067    SWIGINTERN void 
5068    SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
5069        swig_varlinkobject *v = (swig_varlinkobject *) p;
5070        swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
5071        if (gv) {
5072            size_t size = strlen(name)+1;
5073            gv->name = (char *)malloc(size);
5074            if (gv->name) {
5075                strncpy(gv->name,name,size);
5076                gv->get_attr = get_attr;
5077                gv->set_attr = set_attr;
5078                gv->next = v->vars;
5079            }
5080        }
5081        v->vars = gv;
5082    }
5083   
5084    /* -----------------------------------------------------------------------------
5085     * constants/methods manipulation
5086     * ----------------------------------------------------------------------------- */
5087   
5088    /* Install Constants */
5089    SWIGINTERN void
5090    SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
5091        PyObject *obj = 0;
5092        size_t i;
5093        for (i = 0; constants[i].type; ++i) {
5094            switch(constants[i].type) {
5095                case SWIG_PY_INT:
5096                obj = PyInt_FromLong(constants[i].lvalue);
5097                break;
5098                case SWIG_PY_FLOAT:
5099                obj = PyFloat_FromDouble(constants[i].dvalue);
5100                break;
5101                case SWIG_PY_STRING:
5102                if (constants[i].pvalue) {
5103                    obj = PyString_FromString((char *) constants[i].pvalue);
5104                } else {
5105                    Py_INCREF(Py_None);
5106                    obj = Py_None;
5107                }
5108                break;
5109                case SWIG_PY_POINTER:
5110                obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
5111                break;
5112                case SWIG_PY_BINARY:
5113                obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
5114                break;
5115                default:
5116                obj = 0;
5117                break;
5118            }
5119            if (obj) {
5120                PyDict_SetItemString(d,constants[i].name,obj);
5121                Py_DECREF(obj);
5122            }
5123        }
5124    }
5125   
5126    /* -----------------------------------------------------------------------------*/
5127    /* Fix SwigMethods to carry the callback ptrs when needed */
5128    /* -----------------------------------------------------------------------------*/
5129   
5130    SWIGINTERN void
5131    SWIG_Python_FixMethods(PyMethodDef *methods,
5132    swig_const_info *const_table,
5133    swig_type_info **types,
5134    swig_type_info **types_initial) {
5135        size_t i;
5136        for (i = 0; methods[i].ml_name; ++i) {
5137            char *c = methods[i].ml_doc;
5138            if (c && (c = strstr(c, "swig_ptr: "))) {
5139                int j;
5140                swig_const_info *ci = 0;
5141                char *name = c + 10;
5142                for (j = 0; const_table[j].type; ++j) {
5143                    if (strncmp(const_table[j].name, name, 
5144                    strlen(const_table[j].name)) == 0) {
5145                        ci = &(const_table[j]);
5146                        break;
5147                    }
5148                }
5149                if (ci) {
5150                    size_t shift = (ci->ptype) - types;
5151                    swig_type_info *ty = types_initial[shift];
5152                    size_t ldoc = (c - methods[i].ml_doc);
5153                    size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
5154                    char *ndoc = (char*)malloc(ldoc + lptr + 10);
5155                    if (ndoc) {
5156                        char *buff = ndoc;
5157                        void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
5158                        if (ptr) {
5159                            strncpy(buff, methods[i].ml_doc, ldoc);
5160                            buff += ldoc;
5161                            strncpy(buff, "swig_ptr: ", 10);
5162                            buff += 10;
5163                            SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
5164                            methods[i].ml_doc = ndoc;
5165                        }
5166                    }
5167                }
5168            }
5169        }
5170    }
5171   
5172    /* -----------------------------------------------------------------------------*
5173     *  Initialize type list
5174     * -----------------------------------------------------------------------------*/
5175   
5176#ifdef __cplusplus
5177}
5178#endif
5179
5180/* -----------------------------------------------------------------------------*
5181 *  Partial Init method
5182 * -----------------------------------------------------------------------------*/
5183
5184#ifdef __cplusplus
5185extern "C"
5186#endif
5187SWIGEXPORT void SWIG_init(void) {
5188    static PyObject *SWIG_globals = 0; 
5189    PyObject *m, *d;
5190    if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
5191   
5192    /* Fix SwigMethods to carry the callback ptrs when needed */
5193    SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
5194   
5195    m = Py_InitModule((char *) SWIG_name, SwigMethods);
5196    d = PyModule_GetDict(m);
5197   
5198    SWIG_InitializeModule(0);
5199    SWIG_InstallConstants(d,swig_const_table);
5200   
5201    {
5202        PyDict_SetItemString(d,"IP_RF", SWIG_From_int((int)(0x8000))); 
5203    }
5204    {
5205        PyDict_SetItemString(d,"IP_DF", SWIG_From_int((int)(0x4000))); 
5206    }
5207    {
5208        PyDict_SetItemString(d,"IP_MF", SWIG_From_int((int)(0x2000))); 
5209    }
5210    {
5211        PyDict_SetItemString(d,"IP_OFFMASK", SWIG_From_int((int)(0x1fff))); 
5212    }
5213}
5214
Note: See TracBrowser for help on using the repository browser.