libnd_tpm

enum LND_TPM_NavMode

typedef enum {
  LND_TPM_SPACE,
  LND_TPM_TIME,
  LND_TPM_ERROR
} LND_TPM_NavMode;

libnd_tpm_new ()

LND_TPM*    libnd_tpm_new                   (LND_Trace *trace);

The function allocates a new trace part manager, sets up basic stuff and returns it. It does not load any packets yet.

libnd_tpm_free ()

void        libnd_tpm_free                  (LND_TPM *tpm);

The function shuts down tpm properly and releases any memory occupied. It also takes care of freeing all related trace parts, removing temporary files etc.

libnd_tpm_read_packet ()

gboolean    libnd_tpm_read_packet           (LND_TPM *tpm,
                                             LND_Packet *packet);

The function tries to read a single packet from the current location in the trace. The resulting packet data is read into packet. NOTE: Upon return, packet is not initialized, and its raw packet data points to volatile storage. If you want to keep the packet around after further calls to this function, you need to libnd_packet_duplicate() the packet!

libnd_tpm_load_packets ()

void        libnd_tpm_load_packets          (LND_TPM *tpm);

This function loads as many packets into memory as configured by the user, and fires an LND_TRACE_RELOAD event after the packets have been loaded.

libnd_tpm_load_prev_part ()

void        libnd_tpm_load_prev_part        (LND_TPM *tpm);

The function is function loads as many packets into memory as the user has configured, so that the last packet is located before the first one of the current trace part. After the packets are loaded, an LND_TRACE_RELOAD event is fired.

libnd_tpm_load_next_part ()

void        libnd_tpm_load_next_part        (LND_TPM *tpm);

libnd_tpm_set_output_file ()

void        libnd_tpm_set_output_file       (LND_TPM *tpm,
                                             const char *filename);

The function sets filename as the new base file name to write to. Handle with care, you shouldn't really need this function. It's used e.g. when a trace is saved to cause the packets to be written to the original filename.

libnd_tpm_num_memory_packets ()

guint       libnd_tpm_num_memory_packets    ();

This is a helper function returning the maximum number of packets to keep in memory at any one point, as configured by the user.

libnd_tpm_clear_current_part ()

void        libnd_tpm_clear_current_part    (LND_TPM *tpm,
                                             gboolean emit_signal);

The function releases tpm's current trace part. If the part got modified, it is added to the layers of trace parts on top of the base file, otherwise it is simply freed. Depending on emit_signal, a LND_TRACE_CLEAR signal is delivered to registered trace observers or not.

libnd_tpm_add_part ()

void        libnd_tpm_add_part              (LND_TPM *tpm,
                                             LND_TracePart *tp);

The function adds tp to tpm's trace parts.

libnd_tpm_remove_part ()

gboolean    libnd_tpm_remove_part           (LND_TPM *tpm,
                                             LND_TracePart *tp);

The function removes tp from tpm's trace parts. This only works when tp is a plateau, that is, when there are no other parts stacked on top of it.

libnd_tpm_goto_ts ()

pcapnav_result_t libnd_tpm_goto_ts          (LND_TPM *tpm,
                                             struct bpf_timeval *timestamp);

The function jumps to the packet whose timestamp has a timestamp closest to timestamp. If the current trace part was previously modified, it is swapped out to disk first. If the jump succeeded, an LND_TRACE_JUMPED event is fired.

libnd_tpm_goto_fraction ()

pcapnav_result_t libnd_tpm_goto_fraction    (LND_TPM *tpm,
                                             double fraction);

The function jumps to the packet closest to the given size fraction of the full trace. If the current trace part was previously modified, it is swapped out to disk first. If the jump succeeded, an LND_TRACE_JUMPED event is fired.

libnd_tpm_goto_loc ()

gboolean    libnd_tpm_goto_loc              (LND_TPM *tpm,
                                             LND_TraceLoc *loc);

The function jumps to the location given by loc. You can calculate a location in three ways: using libnd_tpm_find_offset(), libnd_tpm_find_fraction() and libnd_tpm_find_timestamp(). If the jump succeeded, an LND_TRACE_JUMPED event is fired.

libnd_tpm_is_tp_overlap ()

gboolean    libnd_tpm_is_tp_overlap         (const LND_TPM *tpm,
                                             const LND_TracePart *tp1,
                                             const LND_TracePart *tp2);

The function tests two trace parts for overlap.

libnd_tpm_map_loc_to_offset ()

off_t       libnd_tpm_map_loc_to_offset     (const LND_TPM *tpm,
                                             const LND_TraceLoc *loc);

The function takes a trace location as input an calculates the global offset in tpm's trace that corresponds to this location. Opposite to libnd_tpm_map_offset_to_loc().

libnd_tpm_map_offset_to_loc ()

pcapnav_result_t libnd_tpm_map_offset_to_loc
                                            (const LND_TPM *tpm,
                                             off_t offset,
                                             LND_TraceLoc *loc);

The function takes offset as input and calculates the trace location for the packet closest to offset in tpm's current trace part arrangement. Opposite of libnd_tpm_map_location_to_offset(). The resulting location is reported in loc.

libnd_tpm_map_loc_to_timestamp ()

gboolean    libnd_tpm_map_loc_to_timestamp  (LND_TPM *tpm,
                                             LND_TraceLoc *loc,
                                             struct bpf_timeval *tv);

The function takes trace location loc as input and looks up the timestamp of the packet that is closest to this location in tpm's current trace part scenario.

libnd_tpm_map_fraction_to_loc ()

pcapnav_result_t libnd_tpm_map_fraction_to_loc
                                            (const LND_TPM *tpm,
                                             double fraction,
                                             LND_TraceLoc *loc);

This function calculates the location (i.e., trace part and offset within that trace part) of a fractional offset in the trace (for example, 0.5 is the middle of the trace). The resulting trace location is reported in loc upon return.

libnd_tpm_map_timestamp_to_loc ()

pcapnav_result_t libnd_tpm_map_timestamp_to_loc
                                            (const LND_TPM *tpm,
                                             struct bpf_timeval *timestamp,
                                             LND_TraceLoc *loc);

This function calculates the location (i.e., trace part and offset within that trace part) of the packet with a timestamp closest to timestamp. The resulting trace location is reported in loc upon return.

libnd_tpm_get_offset ()

off_t       libnd_tpm_get_offset            (const LND_TPM *tpm);

libnd_tpm_find_locs ()

gboolean    libnd_tpm_find_locs             (const LND_TPM *tpm,
                                             LND_TraceArea *area,
                                             LND_TraceLoc *start,
                                             LND_TraceLoc *end);

The function takes the trace area pointed to by area as input and calculates the start and end trace locations that the boundaries of this area correspond to in tpm's current trace part arrangement. The results are returned through start and end, respectively.

libnd_tpm_get_space_fraction ()

double      libnd_tpm_get_space_fraction    (const LND_TPM *tpm,
                                             off_t offset);

The function returns the fraction in the trace where offset is located. 0.5 means that we're currently in the middle of the file, 1.0 that we're at the end.

libnd_tpm_get_time_fraction ()

double      libnd_tpm_get_time_fraction     (const LND_TPM *tpm,
                                             const struct bpf_timeval *tv);

The function returns the fraction in the trace where the packet with timestamp tv is located. 0.5 means that we're currently at the point in trace whose packets are in the middle between the start- and end times of the full trace.

libnd_tpm_get_rel_size ()

double      libnd_tpm_get_rel_size          (const LND_TPM *tpm);

The function compares the size (in bytes) of the trace part that is currently loaded into memory to the size of the entire trace, and returns that ration.

libnd_tpm_get_packets ()

LND_Packet* libnd_tpm_get_packets           (LND_TPM *tpm);

libnd_tpm_get_sel ()

LND_Packet* libnd_tpm_get_sel               (LND_TPM *tpm);

libnd_tpm_pcap_read_handler ()

void        libnd_tpm_pcap_read_handler     (u_char *data,
                                             const struct pcap_pkthdr *h,
                                             const u_char *pdata);

This is a pcap read handler that expects the data ptr to be an LND_TracePart *. It adds the passed packet to this trace part.

libnd_tpm_dump_parts ()

void        libnd_tpm_dump_parts            (LND_TPM *tpm);

This debugging function prints a textual description of the current trace part arrangement to the console.