struct LQLQDiscNetem

struct LQLQDiscNetem;

lql_qdisc_netem_new ()

LQLQDiscNetem* lql_qdisc_netem_new          (void);

Build a new instance of LQLQDiscNetem.

lql_qdisc_netem_get_latencyCorrelation ()

float       lql_qdisc_netem_get_latencyCorrelation
                                            (LQLQDiscNetem *self);

Network delay variation isn't purely random, so to emulate this there is a latency correlation value. This correlation is expressed as a precentage. For example, a value of 25% means the next packets latency is 25% dependant on the previous packet.

lql_qdisc_netem_set_latencyCorrelation ()

gboolean    lql_qdisc_netem_set_latencyCorrelation
                                            (LQLQDiscNetem *self,
                                             float latency);

Set the current latency correlation value.

lql_qdisc_netem_get_duplicate ()

float       lql_qdisc_netem_get_duplicate   (LQLQDiscNetem *self);

The duplicate value is the percentage of packets that are duplicated. This is expressed as a float number between 0 and 100.

lql_qdisc_netem_set_duplicate ()

gboolean    lql_qdisc_netem_set_duplicate   (LQLQDiscNetem *self,
                                             float duplicate);

Set the percentage of packets that are being duplicated.

lql_qdisc_netem_get_duplicateCorrelation ()

float       lql_qdisc_netem_get_duplicateCorrelation
                                            (LQLQDiscNetem *self);

Network duplication variation isn't purely random, so to emulate this there is a duplication correlation value. This correlation is expressed as a precentage. For example, a value of 25% means the next packets chance of being duplicated is 25% dependant on the previous packet.

lql_qdisc_netem_set_duplicateCorrelation ()

gboolean    lql_qdisc_netem_set_duplicateCorrelation
                                            (LQLQDiscNetem *self,
                                             float duplicate);

Set the duplication correlation value.

lql_qdisc_netem_get_gap ()

guint32     lql_qdisc_netem_get_gap         (LQLQDiscNetem *self);

The gap value tells the Netem instance which packets are effected by the Netem parameters. For example, gap=5 means the 5th, 10th, 15th ... packets are effected while the rest are not.

lql_qdisc_netem_set_gap ()

gboolean    lql_qdisc_netem_set_gap         (LQLQDiscNetem *self,
                                             guint32 gap);

Set the current gap value.

lql_qdisc_netem_get_jitter ()

guint32     lql_qdisc_netem_get_jitter      (LQLQDiscNetem *self);

Get the amount of jitter (in ms) applied to packets.

lql_qdisc_netem_set_jitter ()

gboolean    lql_qdisc_netem_set_jitter      (LQLQDiscNetem *self,
                                             guint32 jitter);

Set the amount of jitter (in ms) that is applied to packets.

lql_qdisc_netem_get_latency ()

guint32     lql_qdisc_netem_get_latency     (LQLQDiscNetem *self);

Return the amount of latency in ms that the netem qdisc is adding to packets.

lql_qdisc_netem_set_latency ()

gboolean    lql_qdisc_netem_set_latency     (LQLQDiscNetem *self,
                                             guint32 latency);

Set the amount of latency in ms that the netem qdisc adds to packets.

lql_qdisc_netem_get_limit ()

guint32     lql_qdisc_netem_get_limit       (LQLQDiscNetem *self);

Get the maximum number of packets this Netem instance will hold. The default value is 1000. In order to change latency Netem must hold onto packets. This value puts a upper limit on the number of packets held.

lql_qdisc_netem_set_limit ()

gboolean    lql_qdisc_netem_set_limit       (LQLQDiscNetem *self,
                                             guint32 limit);

Set the maximum number of packets that the Netem instance will hold.

lql_qdisc_netem_get_loss ()

float       lql_qdisc_netem_get_loss        (LQLQDiscNetem *self);

Get the current percentage of packets being dropped by this qdisc. This is expressed as a float value between 0 and 100.

lql_qdisc_netem_set_loss ()

gboolean    lql_qdisc_netem_set_loss        (LQLQDiscNetem *self,
                                             float loss);

Set the current percentage of packets being dropped by this qdisc. This is expressed as a float value between 0 and 100.

lql_qdisc_netem_get_lossCorrelation ()

float       lql_qdisc_netem_get_lossCorrelation
                                            (LQLQDiscNetem *self);

Network loss variation isn't purely random, so to emulate this there is a loss correlation value. This correlation is expressed as a precentage. For example, a value of 25% means the next packets chance of being dropped is 25% dependant on the previous packet.

lql_qdisc_netem_set_lossCorrelation ()

gboolean    lql_qdisc_netem_set_lossCorrelation
                                            (LQLQDiscNetem *self,
                                             float loss);

Set the current loss correlation value.