libnd_packet

Name

libnd_packet -- 

Synopsis

enum                LND_PacketObserverOp;
gboolean            (*LND_PacketFunc)                   (LND_Packet *packet,
                                                         LND_ProtoData *pd,
                                                         void *user_data);
LND_Packet *        libnd_packet_new                    (LND_TracePart *tp,
                                                         guint data_size);
void                libnd_packet_free                   (LND_Packet *packet);
void                libnd_packet_remove                 (LND_Packet *packet);
LND_Trace *         libnd_packet_get_trace              (const LND_Packet *packet);
void                libnd_packet_dump                   (const LND_Packet *packet,
                                                         pcap_dumper_t *dumper);
void                libnd_packet_set_data               (LND_Packet *packet,
                                                         const struct pcap_pkthdr *hdr,
                                                         const guchar *data);
LND_Packet *        libnd_packet_duplicate              (LND_Packet *packet);
void                libnd_packet_set_filtered           (LND_Packet *packet,
                                                         gboolean filtered);
gboolean            libnd_packet_is_filtered            (LND_Packet *packet);
void                libnd_packet_init                   (LND_Packet *packet);
void                libnd_packet_init_from_pcap         (LND_Packet *packet,
                                                         pcap_t *pcap);
gboolean            libnd_packet_is_complete            (const LND_Packet *packet);
void                libnd_packet_update                 (LND_Packet *packet,
                                                         LND_Protocol *proto,
                                                         guint nesting);
guchar *            libnd_packet_get_data               (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);
guchar *            libnd_packet_get_data_end           (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);
void                libnd_packet_add_proto_data         (LND_Packet *packet,
                                                         LND_Protocol *proto,
                                                         guchar *data,
                                                         guchar *data_end);
LND_ProtoData *     libnd_packet_get_proto_data         (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);
guchar *            libnd_packet_get_end                (const LND_Packet *packet);
gboolean            libnd_packet_has_complete_header    (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);
gboolean            libnd_packet_has_proto              (const LND_Packet *packet,
                                                         const LND_Protocol *proto);
gboolean            libnd_packet_has_proto_nested       (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);
LND_ProtoData *     libnd_packet_get_last_nonraw        (const LND_Packet *packet);
void                libnd_packet_update_proto_state     (LND_Packet *packet,
                                                         int index);
void                libnd_packet_foreach_proto          (LND_Packet *packet,
                                                         LND_PacketFunc cb,
                                                         void *user_data);
void                libnd_packet_foreach_proto_backward (LND_Packet *packet,
                                                         LND_PacketFunc cb,
                                                         void *user_data);
void                libnd_packet_modified               (LND_Packet *packet);
int                 libnd_packet_get_index              (const LND_Packet *packet);
int                 libnd_packet_get_proto_nesting      (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guchar *data);
gboolean            libnd_packet_fix                    (LND_Packet *packet);
LND_PacketObserver * libnd_packet_observer_new          (void);
void                libnd_packet_observer_free          (LND_PacketObserver *ob);
void                libnd_packet_add_observer           (LND_PacketObserver *ob);
void                libnd_packet_del_observer           (LND_PacketObserver *ob);
void                libnd_packet_tell_observers         (LND_Packet *packet,
                                                         LND_PacketObserverOp op,
                                                         void *data);

Description

Details

enum LND_PacketObserverOp

typedef enum {
  LND_PACKET_INITIALIZED  = (1 << 0),    /* Packet got initialized */
  LND_PACKET_MODIFIED     = (1 << 1),    /* Packet got modified */
  LND_PACKET_DELETE_PRE   = (1 << 2),    /* Packet gets deleted (pre-action) */
  LND_PACKET_DELETE_POST  = (1 << 3),    /* Packet got deleted (post-action) */
  LND_PACKET_INSERT_PRE   = (1 << 4),    /* Packet gets inserted (pre-action) */
  LND_PACKET_INSERT_POST  = (1 << 5),    /* Packet got inserted (post-action) */
  LND_PACKET_DUPLICATED   = (1 << 6),    /* Packet got duplicated */
  LND_PACKET_VISIBILITY   = (1 << 7),    /* Packet visibility changed */
  LND_PACKET_UPDATED      = (1 << 8),    /* Packet got updated (partial initialization) */
  LND_PACKET_FIXED        = (1 << 9),    /* Packet checksums got fixed */
  LND_PACKET_LEN_CHANGED  = (1 << 10),   /* Packet's wire size changed */
  LND_PACKET_CAPLEN_CHANGED = (1 << 11), /* Packet's caplen changed */
  
  /* If you add something here, also add a callback invocation in
   * libnd_packet_tell_observers().
   */
} LND_PacketObserverOp;


LND_PacketFunc ()

gboolean            (*LND_PacketFunc)                   (LND_Packet *packet,
                                                         LND_ProtoData *pd,
                                                         void *user_data);


libnd_packet_new ()

LND_Packet *        libnd_packet_new                    (LND_TracePart *tp,
                                                         guint data_size);


libnd_packet_free ()

void                libnd_packet_free                   (LND_Packet *packet);


libnd_packet_remove ()

void                libnd_packet_remove                 (LND_Packet *packet);


libnd_packet_get_trace ()

LND_Trace *         libnd_packet_get_trace              (const LND_Packet *packet);


libnd_packet_dump ()

void                libnd_packet_dump                   (const LND_Packet *packet,
                                                         pcap_dumper_t *dumper);


libnd_packet_set_data ()

void                libnd_packet_set_data               (LND_Packet *packet,
                                                         const struct pcap_pkthdr *hdr,
                                                         const guchar *data);


libnd_packet_duplicate ()

LND_Packet *        libnd_packet_duplicate              (LND_Packet *packet);


libnd_packet_set_filtered ()

void                libnd_packet_set_filtered           (LND_Packet *packet,
                                                         gboolean filtered);


libnd_packet_is_filtered ()

gboolean            libnd_packet_is_filtered            (LND_Packet *packet);


libnd_packet_init ()

void                libnd_packet_init                   (LND_Packet *packet);


libnd_packet_init_from_pcap ()

void                libnd_packet_init_from_pcap         (LND_Packet *packet,
                                                         pcap_t *pcap);


libnd_packet_is_complete ()

gboolean            libnd_packet_is_complete            (const LND_Packet *packet);


libnd_packet_update ()

void                libnd_packet_update                 (LND_Packet *packet,
                                                         LND_Protocol *proto,
                                                         guint nesting);


libnd_packet_get_data ()

guchar *            libnd_packet_get_data               (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);


libnd_packet_get_data_end ()

guchar *            libnd_packet_get_data_end           (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);


libnd_packet_add_proto_data ()

void                libnd_packet_add_proto_data         (LND_Packet *packet,
                                                         LND_Protocol *proto,
                                                         guchar *data,
                                                         guchar *data_end);


libnd_packet_get_proto_data ()

LND_ProtoData *     libnd_packet_get_proto_data         (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);


libnd_packet_get_end ()

guchar *            libnd_packet_get_end                (const LND_Packet *packet);


libnd_packet_has_complete_header ()

gboolean            libnd_packet_has_complete_header    (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);


libnd_packet_has_proto ()

gboolean            libnd_packet_has_proto              (const LND_Packet *packet,
                                                         const LND_Protocol *proto);


libnd_packet_has_proto_nested ()

gboolean            libnd_packet_has_proto_nested       (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guint nesting);


libnd_packet_get_last_nonraw ()

LND_ProtoData *     libnd_packet_get_last_nonraw        (const LND_Packet *packet);


libnd_packet_update_proto_state ()

void                libnd_packet_update_proto_state     (LND_Packet *packet,
                                                         int index);


libnd_packet_foreach_proto ()

void                libnd_packet_foreach_proto          (LND_Packet *packet,
                                                         LND_PacketFunc cb,
                                                         void *user_data);


libnd_packet_foreach_proto_backward ()

void                libnd_packet_foreach_proto_backward (LND_Packet *packet,
                                                         LND_PacketFunc cb,
                                                         void *user_data);


libnd_packet_modified ()

void                libnd_packet_modified               (LND_Packet *packet);


libnd_packet_get_index ()

int                 libnd_packet_get_index              (const LND_Packet *packet);


libnd_packet_get_proto_nesting ()

int                 libnd_packet_get_proto_nesting      (const LND_Packet *packet,
                                                         const LND_Protocol *proto,
                                                         guchar *data);


libnd_packet_fix ()

gboolean            libnd_packet_fix                    (LND_Packet *packet);


libnd_packet_observer_new ()

LND_PacketObserver * libnd_packet_observer_new          (void);


libnd_packet_observer_free ()

void                libnd_packet_observer_free          (LND_PacketObserver *ob);


libnd_packet_add_observer ()

void                libnd_packet_add_observer           (LND_PacketObserver *ob);


libnd_packet_del_observer ()

void                libnd_packet_del_observer           (LND_PacketObserver *ob);


libnd_packet_tell_observers ()

void                libnd_packet_tell_observers         (LND_Packet *packet,
                                                         LND_PacketObserverOp op,
                                                         void *data);