{
struct nl_cache *cache;
int err;
-
+
if (!(cache = nl_cache_alloc(ops)))
return -NLE_NOMEM;
NL_DBG(3, "Moving object %p from cache %p to cache %p\n",
obj, obj->ce_cache, cache);
-
+
/* Acquire reference, if already in a cache this will be
* reverted during removal */
nl_object_get(obj);
*/
void nl_cache_set_arg1(struct nl_cache *cache, int arg)
{
- cache->c_iarg1 = arg;
+ cache->c_iarg1 = arg;
}
/**
*/
void nl_cache_set_arg2(struct nl_cache *cache, int arg)
{
- cache->c_iarg2 = arg;
+ cache->c_iarg2 = arg;
}
/**
obj = nl_hash_table_lookup(cache->hashtable, needle);
if (obj) {
- nl_object_get(obj);
- return obj;
+ nl_object_get(obj);
+ return obj;
}
return NULL;
{ "ematch", 1, 0, 'e' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "ht:e:", long_opts, &optidx);
if (c == -1)
break;
rtnl_basic_set_ematch(cls, tree);
break;
}
- }
+ }
}
static struct nl_cli_tc_module basic_module =
{ "ematch", 1, 0, 'e' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "he:", long_opts, &optidx);
if (c == -1)
break;
rtnl_cgroup_set_ematch(cls, tree);
break;
}
- }
+ }
}
static struct nl_cli_tc_module cgroup_module =
{ "limit", 1, 0, ARG_LIMIT },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "h", long_opts, &optidx);
if (c == -1)
break;
rtnl_qdisc_fifo_set_limit(qdisc, limit);
break;
}
- }
+ }
}
static struct nl_cli_tc_module bfifo_module =
{ "help", 0, 0, 'h' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "h", long_opts, &optidx);
if (c == -1)
break;
print_usage();
return;
}
- }
+ }
}
static struct nl_cli_tc_module blackhole_module =
{ "target", 1, 0, ARG_TARGET},
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "h", long_opts, &optidx);
if (c == -1)
break;
break;
}
- }
+ }
}
static struct nl_cli_tc_module fq_codel_module =
{ "default", 1, 0, ARG_DEFAULT },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "hv", long_opts, &optidx);
if (c == -1)
break;
rtnl_htb_set_defcls(qdisc, nl_cli_parse_u32(optarg));
break;
}
- }
+ }
}
static void print_class_usage(void)
{ "cburst", 1, 0, ARG_CBURST },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "h", long_opts, &optidx);
if (c == -1)
break;
rtnl_htb_set_cbuffer(class, rate);
break;
}
- }
+ }
}
static struct nl_cli_tc_module htb_qdisc_module =
{ "limit", 1, 0, ARG_LIMIT },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "h", long_opts, &optidx);
if (c == -1)
break;
rtnl_qdisc_fifo_set_limit(qdisc, nl_cli_parse_u32(optarg));
break;
}
- }
+ }
}
static struct nl_cli_tc_module pfifo_module =
{ "release-indefinite", 0, 0, ARG_RELEASE_INDEFINITE },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "h", long_opts, &optidx);
if (c == -1)
break;
break;
case ARG_RELEASE_ONE:
- rtnl_qdisc_plug_release_one(qdisc);
+ rtnl_qdisc_plug_release_one(qdisc);
break;
case ARG_RELEASE_INDEFINITE:
rtnl_qdisc_plug_release_indefinite(qdisc);
break;
}
- }
+ }
}
static struct nl_cli_tc_module plug_module =
*/
char * idiagnl_shutdown2str(uint8_t shutdown, char *buf, size_t len)
{
- if (shutdown == 0) {
- snprintf(buf, len, " ");
- return buf;
- } else if (shutdown == 1) {
- snprintf(buf, len, "receive shutdown");
- return buf;
- } else if (shutdown == 2) {
- snprintf(buf, len, "send shutdown");
- return buf;
- }
+ if (shutdown == 0) {
+ snprintf(buf, len, " ");
+ return buf;
+ } else if (shutdown == 1) {
+ snprintf(buf, len, "receive shutdown");
+ return buf;
+ } else if (shutdown == 2) {
+ snprintf(buf, len, "send shutdown");
+ return buf;
+ }
- return NULL;
+ return NULL;
}
/** @} */
struct nl_addr *addr;
int err;
- err = nla_parse_nested(tb, CTA_IP_MAX, attr, ct_ip_policy);
+ err = nla_parse_nested(tb, CTA_IP_MAX, attr, ct_ip_policy);
if (err < 0)
goto errout;
int nfnl_ct_str2tcp_state(const char *name)
{
- return __str2type(name, tcp_states, ARRAY_SIZE(tcp_states));
+ return __str2type(name, tcp_states, ARRAY_SIZE(tcp_states));
}
void nfnl_ct_set_status(struct nfnl_ct *ct, uint32_t status)
dst->exp_mask.dst = addr;
}
- // NAT
+ // NAT
if (src->exp_nat.src) {
addr = nl_addr_clone(src->exp_nat.src);
if (!addr)
if (nfnl_exp_test_dst(exp, i))
tuple_dst = nfnl_exp_get_dst(exp, i);
- // Don't have tests for individual ports/types/codes/ids,
+ // Don't have tests for individual ports/types/codes/ids,
if (nfnl_exp_test_l4protonum(exp, i)) {
nl_dump(p, "%s ",
nl_ip_proto2str(nfnl_exp_get_l4protonum(exp, i), buf, sizeof(buf)));
// Must return 0 for match, 1 for mismatch
int d = 0;
d = ( (a->port.src != b->port.src) ||
- (a->port.dst != b->port.dst) );
+ (a->port.dst != b->port.dst) );
return d;
}
static int exp_cmp_l4proto_icmp (union nfnl_exp_protodata *a, union nfnl_exp_protodata *b) {
- // Must return 0 for match, 1 for mismatch
+ // Must return 0 for match, 1 for mismatch
int d = 0;
d = ( (a->icmp.code != b->icmp.code) ||
- (a->icmp.type != b->icmp.type) ||
- (a->icmp.id != b->icmp.id) );
+ (a->icmp.type != b->icmp.type) ||
+ (a->icmp.id != b->icmp.id) );
return d;
}
goto retry;
}
- if (flags != 0) {
+ if (flags != 0) {
/* Buffer is big enough, do the actual reading */
flags = 0;
goto retry;
/* Error message reported back from kernel. */
if (cb->cb_err) {
err = cb->cb_err(&nla, e,
- cb->cb_err_arg);
+ cb->cb_err_arg);
if (err < 0)
goto out;
else if (err == NL_SKIP)
struct nl_cb *cb;
int err;
struct pickup_param pp = {
- .parser = parser,
+ .parser = parser,
};
cb = nl_cb_clone(sk->s_cb);
void nl_object_dump_buf(struct nl_object *obj, char *buf, size_t len)
{
- struct nl_dump_params dp = {
- .dp_buf = buf,
- .dp_buflen = len,
- };
+ struct nl_dump_params dp = {
+ .dp_buf = buf,
+ .dp_buflen = len,
+ };
- return nl_object_dump(obj, &dp);
+ return nl_object_dump(obj, &dp);
}
/**
{
struct rtnl_act *a, **ap;
- for (ap = head; (a = *ap) != NULL; ap = &a->a_next)
- if (a == act)
- break;
- if (a) {
- *ap = a->a_next;
- a->a_next = NULL;
- return 0;
- }
+ for (ap = head; (a = *ap) != NULL; ap = &a->a_next)
+ if (a == act)
+ break;
+ if (a) {
+ *ap = a->a_next;
+ a->a_next = NULL;
+ return 0;
+ }
return -NLE_OBJ_NOTFOUND;
}
static void yyerror(void *scanner, char **errp, struct nl_list_head *root, const char *msg)
{
if (msg)
- *errp = strdup(msg);
- else
- *errp = NULL;
+ *errp = strdup(msg);
+ else
+ *errp = NULL;
}
%}
nla_memcpy(&st, tb[IFLA_STATS64],
sizeof(struct rtnl_link_stats64));
-
+
link->l_stats[RTNL_LINK_RX_PACKETS] = st.rx_packets;
link->l_stats[RTNL_LINK_TX_PACKETS] = st.tx_packets;
link->l_stats[RTNL_LINK_RX_BYTES] = st.rx_bytes;
link->l_flags = ifi->ifi_flags;
link->l_change = ifi->ifi_change;
link->ce_mask = (LINK_ATTR_IFNAME | LINK_ATTR_FAMILY |
- LINK_ATTR_ARPTYPE| LINK_ATTR_IFINDEX |
- LINK_ATTR_FLAGS | LINK_ATTR_CHANGE);
+ LINK_ATTR_ARPTYPE| LINK_ATTR_IFINDEX |
+ LINK_ATTR_FLAGS | LINK_ATTR_CHANGE);
if ((af_ops_family = af_ops = af_lookup_and_alloc(link, family))) {
if (af_ops->ao_protinfo_policy) {
struct rtnl_link *link = (struct rtnl_link *) obj;
char *unit, fmt[64];
float res;
-
+
link_dump_details(obj, p);
nl_dump_line(p, " Stats: bytes packets errors "
strcpy(fmt, " RX %X.2f %s %10" PRIu64 " %10" PRIu64 " %10" PRIu64 " %10" PRIu64 " %10" PRIu64 "\n");
fmt[9] = *unit == 'B' ? '9' : '7';
-
+
nl_dump_line(p, fmt, res, unit,
link->l_stats[RTNL_LINK_RX_PACKETS],
link->l_stats[RTNL_LINK_RX_ERRORS],
strcpy(fmt, " TX %X.2f %s %10" PRIu64 " %10" PRIu64 " %10" PRIu64 " %10" PRIu64 " %10" PRIu64 "\n");
fmt[9] = *unit == 'B' ? '9' : '7';
-
+
nl_dump_line(p, fmt, res, unit,
link->l_stats[RTNL_LINK_TX_PACKETS],
link->l_stats[RTNL_LINK_TX_ERRORS],
nl_dump_line(p, " aborted carrier heartbeat "
" window collision\n");
-
+
nl_dump_line(p, " TX %10" PRIu64 " %10" PRIu64 " %10"
PRIu64 " %10" PRIu64 " %10" PRIu64 "\n",
link->l_stats[RTNL_LINK_TX_ABORT_ERR],
{
struct nl_cache * cache;
int err;
-
+
cache = nl_cache_alloc(&rtnl_link_ops);
if (!cache)
return -NLE_NOMEM;
*result = (struct rtnl_link *) obj;
/* If an object has been returned, we also need to wait for the ACK */
- if (err == 0 && obj)
- wait_for_ack(sk);
+ if (err == 0 && obj)
+ wait_for_ack(sk);
return 0;
}
{
int ifindex = 0;
struct rtnl_link *link;
-
+
link = rtnl_link_get_by_name(cache, name);
if (link) {
ifindex = link->l_index;
{
struct nl_msg *msg;
int err;
-
+
err = rtnl_link_build_add_request(link, flags, &msg);
if (err < 0)
return err;
{
struct nl_msg *msg;
int err;
-
+
err = rtnl_link_build_change_request(orig, changes, flags, &msg);
if (err < 0)
return err;
{
struct nl_msg *msg;
int err;
-
+
if ((err = rtnl_link_build_delete_request(link, &msg)) < 0)
return err;
rtnl_link_set_ifindex(link, slave);
rtnl_link_set_master(link, master);
-
+
if ((err = rtnl_link_change(sock, link, link, 0)) < 0)
goto errout;
err = 0;
- errout:
+errout:
return err;
}
nla_nest_end(msg, data);
- nla_put_failure:
+nla_put_failure:
return 0;
}
- /*
+/*
* lib/route/link/ipvti.c IPVTI Link Info
*
* This library is free software; you can redistribute it and/or
err = 0;
- errout:
+errout:
return err;
}
err = 0;
- errout:
+errout:
return err;
}
ntbl->ce_msgtype = n->nlmsg_type;
rtmsg = nlmsg_data(n);
-
+
err = nlmsg_parse(n, sizeof(*rtmsg), tb, NDTA_MAX, neightbl_policy);
if (err < 0)
goto errout;
if (ntbl->nt_parms.ntp_mask & NEIGHTBLPARM_ATTR_IFINDEX) {
struct nl_cache *link_cache;
-
+
link_cache = nl_cache_mngt_require_safe("route/link");
if (link_cache) {
ntbl->nt_config.ndtc_key_len,
ntbl->nt_config.ndtc_entry_size,
nl_msec2str(ntbl->nt_config.ndtc_last_flush,
- x, sizeof(x)));
+ x, sizeof(x)));
nl_dump_line(p, " gc threshold %u/%u/%u interval %s " \
- "chain-position %u\n",
+ "chain-position %u\n",
ntbl->nt_gc_thresh1, ntbl->nt_gc_thresh2,
ntbl->nt_gc_thresh3,
nl_msec2str(ntbl->nt_gc_interval, x, sizeof(x)),
ntbl->nt_config.ndtc_hash_rnd,
ntbl->nt_config.ndtc_hash_mask,
nl_msec2str(ntbl->nt_config.ndtc_last_rand,
- x, sizeof(x)));
+ x, sizeof(x)));
}
if (ntbl->ce_mask & NEIGHTBL_ATTR_PARMS) {
struct rtnl_neightbl_parms *pa = &ntbl->nt_parms;
nl_dump_line(p, " refcnt %u pending-queue-limit %u " \
- "proxy-delayed-queue-limit %u\n",
+ "proxy-delayed-queue-limit %u\n",
pa->ntp_refcnt,
pa->ntp_queue_len,
pa->ntp_proxy_qlen);
nl_dump_line(p, " num-userspace-probes %u num-unicast-probes " \
- "%u num-multicast-probes %u\n",
+ "%u num-multicast-probes %u\n",
pa->ntp_app_probes,
pa->ntp_ucast_probes,
pa->ntp_mcast_probes);
nl_dump_line(p, " min-age %s base-reachable-time %s " \
- "stale-check-interval %s\n",
+ "stale-check-interval %s\n",
nl_msec2str(pa->ntp_locktime, x, sizeof(x)),
nl_msec2str(pa->ntp_base_reachable_time,
- y, sizeof(y)),
+ y, sizeof(y)),
nl_msec2str(pa->ntp_gc_stale_time, z, sizeof(z)));
nl_dump_line(p, " initial-probe-delay %s answer-delay %s " \
- "proxy-answer-delay %s\n",
+ "proxy-answer-delay %s\n",
nl_msec2str(pa->ntp_probe_delay, x, sizeof(x)),
nl_msec2str(pa->ntp_anycast_delay, y, sizeof(y)),
nl_msec2str(pa->ntp_proxy_delay, z, sizeof(z)));
return;
nl_dump_line(p, " " \
- " lookups %" PRIu64 \
- " hits %" PRIu64 \
- " failed %" PRIu64 \
- " allocations %" PRIu64 \
- " destroys %" PRIu64 \
- "\n",
+ " lookups %" PRIu64 \
+ " hits %" PRIu64 \
+ " failed %" PRIu64 \
+ " allocations %" PRIu64 \
+ " destroys %" PRIu64 \
+ "\n",
ntbl->nt_stats.ndts_lookups,
ntbl->nt_stats.ndts_hits,
ntbl->nt_stats.ndts_res_failed,
ntbl->nt_stats.ndts_destroys);
nl_dump_line(p, " " \
- " hash-grows %" PRIu64 \
- " forced-gc-runs %" PRIu64 \
- " periodic-gc-runs %" PRIu64 \
- "\n",
+ " hash-grows %" PRIu64 \
+ " forced-gc-runs %" PRIu64 \
+ " periodic-gc-runs %" PRIu64 \
+ "\n",
ntbl->nt_stats.ndts_hash_grows,
ntbl->nt_stats.ndts_forced_gc_runs,
ntbl->nt_stats.ndts_periodic_gc_runs);
nl_dump_line(p, " " \
- " rcv-unicast-probes %" PRIu64 \
- " rcv-multicast-probes %" PRIu64 \
- "\n",
+ " rcv-unicast-probes %" PRIu64 \
+ " rcv-multicast-probes %" PRIu64 \
+ "\n",
ntbl->nt_stats.ndts_rcv_probes_ucast,
ntbl->nt_stats.ndts_rcv_probes_mcast);
}
if ((err = tca_parse(tb, TCA_HTB_MAX, tc, htb_policy)) < 0)
return err;
-
+
if (tb[TCA_HTB_INIT]) {
struct tc_htb_glob opts;
if ((err = tca_parse(tb, TCA_HTB_MAX, tc, htb_policy)) < 0)
return err;
-
+
if (tb[TCA_HTB_PARMS]) {
struct tc_htb_opt opts;
{
struct rtnl_htb_qdisc *htb = data;
struct tc_htb_glob opts = {
- .version = TC_HTB_PROTOVER,
- .rate2quantum = 10,
- };
+ .version = TC_HTB_PROTOVER,
+ .rate2quantum = 10,
+ };
if (htb) {
if (htb->qh_mask & SCH_HTB_HAS_RATE2QUANTUM)
netem->qnm_mask |= (SCH_NETEM_ATTR_RO_PROB |
SCH_NETEM_ATTR_RO_CORR);
}
-
+
if (tb[TCA_NETEM_CORRUPT]) {
struct tc_netem_corrupt corrupt;
-
+
nla_memcpy(&corrupt, tb[TCA_NETEM_CORRUPT], sizeof(corrupt));
netem->qnm_crpt.nmcr_probability = corrupt.probability;
netem->qnm_crpt.nmcr_correlation = corrupt.correlation;
-
+
netem->qnm_mask |= (SCH_NETEM_ATTR_CORRUPT_PROB |
SCH_NETEM_ATTR_CORRUPT_CORR);
}
-
+
/* sch_netem does not currently dump TCA_NETEM_DELAY_DIST */
netem->qnm_dist.dist_data = NULL;
netem->qnm_dist.dist_size = 0;
static void netem_free_data(struct rtnl_tc *tc, void *data)
{
struct rtnl_netem *netem = data;
-
+
if (!netem)
return;
-
+
free(netem->qnm_dist.dist_data);
}
struct tc_netem_reorder reorder;
struct tc_netem_corrupt corrupt;
struct rtnl_netem *netem = data;
-
+
unsigned char set_correlation = 0, set_reorder = 0,
set_corrupt = 0, set_dist = 0;
memset(&corrupt, 0, sizeof(corrupt));
msg->nm_nlh->nlmsg_flags |= NLM_F_REQUEST;
-
+
if ( netem->qnm_ro.nmro_probability != 0 ) {
if (netem->qnm_latency == 0) {
return -NLE_MISSING_ATTR;
}
set_correlation = 1;
}
-
+
if ( netem->qnm_corr.nmc_loss != 0 ) {
if ( netem->qnm_loss == 0 ) {
return -NLE_MISSING_ATTR;
}
set_correlation = 1;
}
-
+
if ( netem->qnm_ro.nmro_probability != 0 ) set_reorder = 1;
else if ( netem->qnm_ro.nmro_correlation != 0 ) {
return -NLE_MISSING_ATTR;
}
-
+
if ( netem->qnm_crpt.nmcr_probability != 0 ) set_corrupt = 1;
else if ( netem->qnm_crpt.nmcr_correlation != 0 ) {
return -NLE_MISSING_ATTR;
}
-
+
if ( netem->qnm_dist.dist_data && netem->qnm_dist.dist_size ) {
if (netem->qnm_latency == 0 || netem->qnm_jitter == 0) {
return -NLE_MISSING_ATTR;
/* Resize to accomodate the large distribution table */
int new_msg_len = msg->nm_size + netem->qnm_dist.dist_size *
sizeof(netem->qnm_dist.dist_data[0]);
-
+
msg->nm_nlh = (struct nlmsghdr *) realloc(msg->nm_nlh, new_msg_len);
if ( msg->nm_nlh == NULL )
return -NLE_NOMEM;
set_dist = 1;
}
}
-
+
opts.latency = netem->qnm_latency;
opts.limit = netem->qnm_limit ? netem->qnm_limit : 1000;
opts.loss = netem->qnm_loss;
opts.gap = netem->qnm_gap;
opts.duplicate = netem->qnm_duplicate;
opts.jitter = netem->qnm_jitter;
-
+
NLA_PUT(msg, TCA_OPTIONS, sizeof(opts), &opts);
-
+
if ( set_correlation ) {
cor.delay_corr = netem->qnm_corr.nmc_delay;
cor.loss_corr = netem->qnm_corr.nmc_loss;
NLA_PUT(msg, TCA_NETEM_CORR, sizeof(cor), &cor);
}
-
+
if ( set_reorder ) {
reorder.probability = netem->qnm_ro.nmro_probability;
reorder.correlation = netem->qnm_ro.nmro_correlation;
NLA_PUT(msg, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
}
-
+
if ( set_corrupt ) {
corrupt.probability = netem->qnm_crpt.nmcr_probability;
corrupt.correlation = netem->qnm_crpt.nmcr_correlation;
NLA_PUT(msg, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
}
-
+
if ( set_dist ) {
NLA_PUT(msg, TCA_NETEM_DELAY_DIST,
netem->qnm_dist.dist_size * sizeof(netem->qnm_dist.dist_data[0]),
*/
struct nlattr* head = (struct nlattr *)(NLMSG_DATA(msg->nm_nlh) +
NLMSG_LENGTH(sizeof(struct tcmsg)) - NLMSG_ALIGNTO);
-
+
struct nlattr* tail = (struct nlattr *)(((void *) (msg->nm_nlh)) +
NLMSG_ALIGN(msg->nm_nlh->nlmsg_len));
-
+
int old_len = head->nla_len;
head->nla_len = (void *)tail - (void *)head;
msg->nm_nlh->nlmsg_len += (head->nla_len - old_len);
-
+
return err;
nla_put_failure:
return -NLE_MSGSIZE;
if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
BUG();
-
+
netem->qnm_limit = limit;
netem->qnm_mask |= SCH_NETEM_ATTR_LIMIT;
}
* @name Corruption
* @{
*/
-
+
/**
* Set corruption probability of netem qdisc.
* @arg qdisc Netem qdisc to be modified.
if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
BUG();
-
+
FILE *f;
int n = 0;
size_t i;
char *line;
char name[NAME_MAX];
char dist_suffix[] = ".dist";
-
+
/* If the given filename already ends in .dist, don't append it later */
char *test_suffix = strstr(dist_type, dist_suffix);
if (test_suffix != NULL && strlen(test_suffix) == 5)
strcpy(dist_suffix, "");
-
+
/* Check several locations for the dist file */
char *test_path[] = { "", "./", "/usr/lib/tc/", "/usr/local/lib/tc/" };
-
+
for (i = 0; i < ARRAY_SIZE(test_path); i++) {
snprintf(name, NAME_MAX, "%s%s%s", test_path[i], dist_type, dist_suffix);
if ((f = fopen(name, "r")))
break;
}
-
+
if ( f == NULL )
return -nl_syserr2nlerr(errno);
-
+
netem->qnm_dist.dist_data = (int16_t *) calloc (MAXDIST, sizeof(int16_t));
-
+
line = (char *) calloc (sizeof(char), len + 1);
-
+
while (getline(&line, &len, f) != -1) {
char *p, *endp;
-
+
if (*line == '\n' || *line == '#')
continue;
return -NLE_INVAL;
}
netem->qnm_dist.dist_data[n++] = x;
- }
+ }
}
-
+
free(line);
-
+
netem->qnm_dist.dist_size = n;
netem->qnm_mask |= SCH_NETEM_ATTR_DIST;
-
+
fclose(f);
- return 0;
+ return 0;
}
/** @} */
nl_addr_get(addr);
route->rt_dst = addr;
-
+
route->ce_mask |= (ROUTE_ATTR_DST | ROUTE_ATTR_FAMILY);
return 0;
void *arg)
{
struct rtnl_nexthop *nh;
-
+
if (r->ce_mask & ROUTE_ATTR_MULTIPATH) {
nl_list_for_each_entry(nh, &r->rt_nexthops, rtnh_list) {
- cb(nh, arg);
+ cb(nh, arg);
}
}
}
{
struct rtnl_nexthop *nh;
uint32_t i;
-
+
if (r->ce_mask & ROUTE_ATTR_MULTIPATH && r->rt_nr_nh > n) {
i = 0;
nl_list_for_each_entry(nh, &r->rt_nexthops, rtnh_list) {
- if (i == n) return nh;
+ if (i == n) return nh;
i++;
}
}
- return NULL;
+ return NULL;
}
/** @} */
if (ntb[RTA_FLOW]) {
uint32_t realms;
-
+
realms = nla_get_u32(ntb[RTA_FLOW]);
rtnl_route_nh_set_realms(nh, realms);
}
struct nl_sock *nl_socket_alloc(void)
{
struct nl_cb *cb;
- struct nl_sock *sk;
+ struct nl_sock *sk;
cb = nl_cb_alloc(default_cb);
if (!cb)
return NULL;
- /* will increment cb reference count on success */
+ /* will increment cb reference count on success */
sk = __alloc_socket(cb);
- nl_cb_put(cb);
+ nl_cb_put(cb);
- return sk;
+ return sk;
}
/**
void nl_socket_set_cb(struct nl_sock *sk, struct nl_cb *cb)
{
- if (cb == NULL)
- BUG();
+ if (cb == NULL)
+ BUG();
nl_cb_put(sk->s_cb);
sk->s_cb = nl_cb_get(cb);
if (sk->s_fd == -1)
return -NLE_BAD_SOCK;
-
+
err = setsockopt(sk->s_fd, SOL_SOCKET, SO_SNDBUF,
&txbuf, sizeof(txbuf));
if (err < 0) {
static void __init nl_debug_init(void)
{
char *nldbg, *end;
-
+
if ((nldbg = getenv("NLDBG"))) {
long level = strtol(nldbg, &end, 0);
if (nldbg != end)
case NL_BYTE_RATE:
frac = nl_cancel_down_bytes(rate, &unit);
break;
-
+
case NL_BIT_RATE:
frac = nl_cancel_down_bits(rate, &unit);
break;
-
+
default:
BUG();
}
getenv("PROC_ROOT"));
else
strncpy(name, "/proc/net/psched", sizeof(name) - 1);
-
+
if ((fd = fopen(name, "r"))) {
unsigned int ns_per_usec, ns_per_tick, nom, denom;
if (fscanf(fd, "%08x %08x %08x %08x",
&ns_per_usec, &ns_per_tick, &nom, &denom) != 4) {
- NL_DBG(1, "Fatal error: can not read psched settings from \"%s\". " \
- "Try to set TICKS_PER_USEC, PROC_NET_PSCHED or PROC_ROOT " \
- "environment variables\n", name);
- exit(1);
- }
+ NL_DBG(1, "Fatal error: can not read psched settings from \"%s\". " \
+ "Try to set TICKS_PER_USEC, PROC_NET_PSCHED or PROC_ROOT " \
+ "environment variables\n", name);
+ exit(1);
+ }
- ticks_per_usec = (double) ns_per_usec /
+ ticks_per_usec = (double) ns_per_usec /
(double) ns_per_tick;
if (nom == 1000000)
for (;;) {
if (*p == ' ')
p++;
-
+
t = strchr(p, ',');
len = t ? t - p : strlen(p);
for (i = 0; i < tbl_len; i++)
*result = (struct xfrmnl_ae *) obj;
/* If an object has been returned, we also need to wait for the ACK */
- if (err == 0 && obj)
- nl_wait_for_ack(sock);
+ if (err == 0 && obj)
+ nl_wait_for_ack(sock);
return 0;
}
*result = (struct xfrmnl_sa *) obj;
/* If an object has been returned, we also need to wait for the ACK */
- if (err == 0 && obj)
- nl_wait_for_ack(sock);
+ if (err == 0 && obj)
+ nl_wait_for_ack(sock);
return 0;
}
*/
struct nl_addr* xfrmnl_sel_get_daddr (struct xfrmnl_sel* sel)
{
- return sel->daddr;
+ return sel->daddr;
}
int xfrmnl_sel_set_daddr (struct xfrmnl_sel* sel, struct nl_addr* addr)
struct nl_addr* xfrmnl_sel_get_saddr (struct xfrmnl_sel* sel)
{
- return sel->saddr;
+ return sel->saddr;
}
int xfrmnl_sel_set_saddr (struct xfrmnl_sel* sel, struct nl_addr* addr)
nl_dump_line(p, "\tUser template: \n");
nl_list_for_each_entry(utmpl, &sp->usertmpl_list, utmpl_list)
- xfrmnl_user_tmpl_dump (utmpl, p);
+ xfrmnl_user_tmpl_dump (utmpl, p);
}
if (sp->ce_mask & XFRM_SP_ATTR_MARK)
*result = (struct xfrmnl_sp *) obj;
/* If an object has been returned, we also need to wait for the ACK */
- if (err == 0 && obj)
- nl_wait_for_ack(sock);
+ if (err == 0 && obj)
+ nl_wait_for_ack(sock);
return 0;
}
*/
struct nl_addr* xfrmnl_user_tmpl_get_daddr (struct xfrmnl_user_tmpl* utmpl)
{
- return utmpl->id.daddr;
+ return utmpl->id.daddr;
}
int xfrmnl_user_tmpl_set_daddr (struct xfrmnl_user_tmpl* utmpl, struct nl_addr* addr)
struct nl_addr* xfrmnl_user_tmpl_get_saddr (struct xfrmnl_user_tmpl* utmpl)
{
- return utmpl->saddr;
+ return utmpl->saddr;
}
int xfrmnl_user_tmpl_set_saddr (struct xfrmnl_user_tmpl* utmpl, struct nl_addr* addr)
static struct nl_cache *alloc_genl_family_cache(struct nl_sock *sk)
{
return nl_cli_alloc_cache(sk, "generic netlink family",
- genl_ctrl_alloc_cache);
+ genl_ctrl_alloc_cache);
}
static void print_usage(void)
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_GENERIC);
family_cache = alloc_genl_family_cache(sock);
-
+
for (;;) {
int c, optidx = 0;
static struct option long_opts[] = {
{ "version", 0, 0, 'v' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "df:hv", long_opts, &optidx);
if (c == -1)
break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
}
- }
+ }
nl_cache_dump(family_cache, ¶ms);
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
-
- ct = nl_cli_ct_alloc();
-
+
+ ct = nl_cli_ct_alloc();
+
for (;;) {
int c, optidx = 0;
enum {
{ "refcnt", 1, 0, ARG_REFCNT },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "46f:hvi:p:F:", long_opts, &optidx);
if (c == -1)
break;
case ARG_REFCNT: nl_cli_ct_parse_use(ct, optarg); break;
case ARG_FLAGS: nl_cli_ct_parse_status(ct, optarg); break;
}
- }
+ }
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_NETFILTER);
};
int err, nlflags = NLM_F_CREATE;
- exp = nl_cli_exp_alloc();
-
+ exp = nl_cli_exp_alloc();
+
for (;;) {
int c, optidx = 0;
enum {
ARG_MASK_SPORT,
ARG_MASK_DST,
ARG_MASK_DPORT,
- ARG_NAT_PROTO,
- ARG_NAT_SRC,
- ARG_NAT_SPORT,
- ARG_NAT_DST,
- ARG_NAT_DPORT,
- ARG_NAT_DIR,
+ ARG_NAT_PROTO,
+ ARG_NAT_SRC,
+ ARG_NAT_SPORT,
+ ARG_NAT_DST,
+ ARG_NAT_DPORT,
+ ARG_NAT_DIR,
ARG_TIMEOUT,
ARG_HELPER_NAME,
ARG_REPLACE,
{ "mask-sport", 1, 0, ARG_MASK_SPORT },
{ "mask-dst", 1, 0, ARG_MASK_DST },
{ "mask-dport", 1, 0, ARG_MASK_DPORT },
- { "nat-proto", 1, 0, ARG_NAT_PROTO },
- { "nat-src", 1, 0, ARG_NAT_SRC },
- { "nat-sport", 1, 0, ARG_NAT_SPORT },
- { "nat-dst", 1, 0, ARG_NAT_DST },
- { "nat-dport", 1, 0, ARG_NAT_DPORT },
- { "nat-dir", 1, 0, ARG_NAT_DIR },
+ { "nat-proto", 1, 0, ARG_NAT_PROTO },
+ { "nat-src", 1, 0, ARG_NAT_SRC },
+ { "nat-sport", 1, 0, ARG_NAT_SPORT },
+ { "nat-dst", 1, 0, ARG_NAT_DST },
+ { "nat-dport", 1, 0, ARG_NAT_DPORT },
+ { "nat-dir", 1, 0, ARG_NAT_DIR },
{ "family", 1, 0, 'F' },
{ "timeout", 1, 0, ARG_TIMEOUT },
{ "helper", 1, 0, ARG_HELPER_NAME },
{ "flags", 1, 0, ARG_FLAGS},
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "46f:hvi:p:F:", long_opts, &optidx);
if (c == -1)
break;
case ARG_MASK_SPORT: nl_cli_exp_parse_src_port(exp, NFNL_EXP_TUPLE_MASK, optarg); break;
case ARG_MASK_DST: nl_cli_exp_parse_dst(exp, NFNL_EXP_TUPLE_MASK, optarg); break;
case ARG_MASK_DPORT: nl_cli_exp_parse_dst_port(exp, NFNL_EXP_TUPLE_MASK, optarg); break;
- case ARG_NAT_PROTO: nl_cli_exp_parse_l4protonum(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
- case ARG_NAT_SRC: nl_cli_exp_parse_src(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
- case ARG_NAT_SPORT: nl_cli_exp_parse_src_port(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
- case ARG_NAT_DST: nl_cli_exp_parse_dst(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
- case ARG_NAT_DPORT: nl_cli_exp_parse_dst_port(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
- case ARG_NAT_DIR: nl_cli_exp_parse_nat_dir(exp, optarg); break;
+ case ARG_NAT_PROTO: nl_cli_exp_parse_l4protonum(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
+ case ARG_NAT_SRC: nl_cli_exp_parse_src(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
+ case ARG_NAT_SPORT: nl_cli_exp_parse_src_port(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
+ case ARG_NAT_DST: nl_cli_exp_parse_dst(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
+ case ARG_NAT_DPORT: nl_cli_exp_parse_dst_port(exp, NFNL_EXP_TUPLE_NAT, optarg); break;
+ case ARG_NAT_DIR: nl_cli_exp_parse_nat_dir(exp, optarg); break;
case 'F': nl_cli_exp_parse_family(exp, optarg); break;
case ARG_TIMEOUT: nl_cli_exp_parse_timeout(exp, optarg); break;
case ARG_HELPER_NAME: nl_cli_exp_parse_helper_name(exp, optarg); break;
case ARG_FLAGS: nl_cli_exp_parse_flags(exp, optarg); break;
}
- }
+ }
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_NETFILTER);
};
int err, nlflags = 0;
- exp = nl_cli_exp_alloc();
-
+ exp = nl_cli_exp_alloc();
+
for (;;) {
int c, optidx = 0;
enum {
ARG_MASTER_SPORT,
ARG_MASTER_DST,
ARG_MASTER_DPORT,
- ARG_MASK_PROTO,
- ARG_MASK_SRC,
+ ARG_MASK_PROTO,
+ ARG_MASK_SRC,
ARG_MASK_SPORT,
ARG_MASK_DST,
ARG_MASK_DPORT,
ARG_TIMEOUT,
- ARG_HELPER_NAME,
+ ARG_HELPER_NAME,
ARG_FLAGS,
};
static struct option long_opts[] = {
- { "quiet", 0, 0, 'q' },
+ { "quiet", 0, 0, 'q' },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "id", 1, 0, 'i' },
{ "master-dst", 1, 0, ARG_MASTER_DST },
{ "master-dport", 1, 0, ARG_MASTER_DPORT },
{ "mask-proto", 1, 0, ARG_MASK_PROTO },
- { "mask-src", 1, 0, ARG_MASK_SRC },
- { "mask-sport", 1, 0, ARG_MASK_SPORT },
- { "mask-dst", 1, 0, ARG_MASK_DST },
- { "mask-dport", 1, 0, ARG_MASK_DPORT },
+ { "mask-src", 1, 0, ARG_MASK_SRC },
+ { "mask-sport", 1, 0, ARG_MASK_SPORT },
+ { "mask-dst", 1, 0, ARG_MASK_DST },
+ { "mask-dport", 1, 0, ARG_MASK_DPORT },
{ "family", 1, 0, 'F' },
{ "timeout", 1, 0, ARG_TIMEOUT },
{ "helper", 1, 0, ARG_HELPER_NAME },
- { "flags", 1, 0, ARG_FLAGS},
+ { "flags", 1, 0, ARG_FLAGS},
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "46f:hvi:p:F:", long_opts, &optidx);
if (c == -1)
break;
case ARG_MASK_SRC: nl_cli_exp_parse_src(exp, NFNL_EXP_TUPLE_MASK, optarg); break;
case ARG_MASK_SPORT: nl_cli_exp_parse_src_port(exp, NFNL_EXP_TUPLE_MASK, optarg); break;
case ARG_MASK_DST: nl_cli_exp_parse_dst(exp, NFNL_EXP_TUPLE_MASK, optarg); break;
- case ARG_MASK_DPORT: nl_cli_exp_parse_dst_port(exp, NFNL_EXP_TUPLE_MASK, optarg); break;
+ case ARG_MASK_DPORT: nl_cli_exp_parse_dst_port(exp, NFNL_EXP_TUPLE_MASK, optarg); break;
case 'F': nl_cli_exp_parse_family(exp, optarg); break;
case ARG_TIMEOUT: nl_cli_exp_parse_timeout(exp, optarg); break;
case ARG_HELPER_NAME: nl_cli_exp_parse_helper_name(exp, optarg); break;
case ARG_FLAGS: nl_cli_exp_parse_flags(exp, optarg); break;
}
- }
+ }
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_NETFILTER);
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
-
- exp = nl_cli_exp_alloc();
-
+
+ exp = nl_cli_exp_alloc();
+
for (;;) {
int c, optidx = 0;
enum {
ARG_MASTER_DST,
ARG_MASTER_DPORT,
ARG_TIMEOUT,
- ARG_HELPER_NAME,
+ ARG_HELPER_NAME,
ARG_FLAGS,
};
static struct option long_opts[] = {
{ "flags", 1, 0, ARG_FLAGS},
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "46f:hvi:p:F:", long_opts, &optidx);
if (c == -1)
break;
case ARG_HELPER_NAME: nl_cli_exp_parse_helper_name(exp, optarg); break;
case ARG_FLAGS: nl_cli_exp_parse_flags(exp, optarg); break;
}
- }
+ }
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_NETFILTER);
.dp_fd = stdout,
};
int err, nlflags = NLM_F_CREATE;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- addr = nl_cli_addr_alloc();
-
+ addr = nl_cli_addr_alloc();
+
for (;;) {
int c, optidx = 0;
enum {
{ "valid", 1, 0, ARG_VALID },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "qhva:d:", long_opts, &optidx);
if (c == -1)
break;
case ARG_PREFERRED: nl_cli_addr_parse_preferred(addr, optarg); break;
case ARG_VALID: nl_cli_addr_parse_valid(addr, optarg); break;
}
- }
+ }
if ((err = rtnl_addr_add(sock, addr, nlflags)) < 0)
nl_cli_fatal(err, "Unable to add address: %s",
if (!quiet) {
printf("Added ");
nl_object_dump(OBJ_CAST(addr), &dp);
- }
+ }
return 0;
}
{ "valid", 1, 0, ARG_VALID },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "iqhva:d:", long_opts, &optidx);
if (c == -1)
break;
case ARG_PREFERRED: nl_cli_addr_parse_preferred(addr, optarg); break;
case ARG_VALID: nl_cli_addr_parse_valid(addr, optarg); break;
}
- }
+ }
nl_cache_foreach_filter(addr_cache, OBJ_CAST(addr), delete_cb, NULL);
struct rtnl_tc_ops *ops;
int err, flags = NLM_F_CREATE | NLM_F_EXCL;
char *kind, *id = NULL;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- class = nl_cli_class_alloc();
+ class = nl_cli_class_alloc();
tc = (struct rtnl_tc *) class;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "linktype", 1, 0, ARG_LINKTYPE },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "+qhvd:p:i:",
long_opts, &optidx);
if (c == -1)
case ARG_OVERHEAD: nl_cli_tc_parse_overhead(tc, optarg); break;
case ARG_LINKTYPE: nl_cli_tc_parse_linktype(tc, optarg); break;
}
- }
+ }
if (optind >= argc)
print_usage();
if (!quiet) {
printf("Adding ");
nl_object_dump(OBJ_CAST(class), &dp);
- }
+ }
if ((err = rtnl_class_add(sock, class, flags)) < 0)
nl_cli_fatal(EINVAL, "Unable to add class: %s", nl_geterror(err));
struct rtnl_class *class;
struct rtnl_tc *tc;
struct nl_cache *link_cache, *class_cache;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- class = nl_cli_class_alloc();
+ class = nl_cli_class_alloc();
tc = (struct rtnl_tc *) class;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "kind", 1, 0, 'k' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "qhvd:p:i:k:", long_opts, &optidx);
if (c == -1)
break;
case 'i': nl_cli_tc_parse_handle(tc, optarg, 0); break;
case 'k': nl_cli_tc_parse_kind(tc, optarg); break;
}
- }
+ }
if (!rtnl_tc_get_ifindex(tc))
nl_cli_fatal(EINVAL, "You must specify a network device (--dev=XXX)");
struct rtnl_tc *tc;
struct nl_cache *link_cache;
int ifindex;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- class = nl_cli_class_alloc();
+ class = nl_cli_class_alloc();
tc = (struct rtnl_tc *) class;
params.dp_fd = stdout;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "kind", 1, 0, 'k' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "hvd:p:i:k:", long_opts, &optidx);
if (c == -1)
break;
case 'i': nl_cli_tc_parse_handle(tc, optarg, 0); break;
case 'k': nl_cli_tc_parse_kind(tc, optarg); break;
}
- }
+ }
if ((ifindex = rtnl_tc_get_ifindex(tc)))
__dump_class(ifindex, class);
- else
+ else
nl_cache_foreach(link_cache, dump_class, class);
return 0;
{ "raw", 0, 0, ARG_RAW },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "hvr", long_opts, &optidx);
if (c == -1)
break;
case 'r': reverse = 1; break;
case ARG_RAW: raw = 1; break;
}
- }
+ }
if (optind >= argc)
print_usage();
struct rtnl_tc_ops *ops;
int err, flags = NLM_F_CREATE | NLM_F_EXCL;
char *kind, *id = NULL;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- cls = nl_cli_cls_alloc();
+ cls = nl_cli_cls_alloc();
tc = (struct rtnl_tc *) cls;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "linktype", 1, 0, ARG_LINKTYPE },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "+qhvd:p:i:",
long_opts, &optidx);
if (c == -1)
rtnl_cls_set_prio(cls, nl_cli_parse_u32(optarg));
break;
}
- }
+ }
if (optind >= argc)
print_usage();
if (!quiet) {
printf("Adding ");
nl_object_dump(OBJ_CAST(cls), &dp);
- }
+ }
if ((err = rtnl_cls_add(sock, cls, flags)) < 0)
nl_cli_fatal(EINVAL, "Unable to add classifier: %s", nl_geterror(err));
struct rtnl_tc *tc;
struct nl_cache *link_cache;
int ifindex;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- cls = nl_cli_cls_alloc();
+ cls = nl_cli_cls_alloc();
tc = (struct rtnl_tc *) cls;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "prio", 1, 0, ARG_PRIO },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "qhvd:p:i:k:", long_opts, &optidx);
if (c == -1)
break;
rtnl_cls_set_prio(cls, nl_cli_parse_u32(optarg));
break;
}
- }
+ }
if ((ifindex = rtnl_tc_get_ifindex(tc)))
__delete_link(ifindex, cls);
- else
+ else
nl_cache_foreach(link_cache, delete_link, cls);
if (!quiet)
struct rtnl_tc *tc;
struct nl_cache *link_cache;
int ifindex;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- cls = nl_cli_cls_alloc();
+ cls = nl_cli_cls_alloc();
tc = (struct rtnl_tc *) cls;
params.dp_fd = stdout;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "prio", 1, 0, ARG_PRIO },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "hvd:p:i:k:", long_opts, &optidx);
if (c == -1)
break;
rtnl_cls_set_prio(cls, nl_cli_parse_u32(optarg));
break;
}
- }
+ }
if ((ifindex = rtnl_tc_get_ifindex(tc)))
__dump_link(ifindex, cls);
- else
+ else
nl_cache_foreach(link_cache, dump_link, cls);
return 0;
.dp_fd = stdout,
};
int err, ok = 0, nlflags = NLM_F_REPLACE | NLM_F_CREATE;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- neigh = nl_cli_neigh_alloc();
-
+ neigh = nl_cli_neigh_alloc();
+
for (;;) {
int c, optidx = 0;
enum {
{ "state", 1, 0, ARG_STATE },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "qhva:l:d:", long_opts, &optidx);
if (c == -1)
break;
case 'd': nl_cli_neigh_parse_dev(neigh, link_cache, optarg); break;
case ARG_STATE: nl_cli_neigh_parse_state(neigh, optarg); break;
}
- }
+ }
if (!ok)
print_usage();
if (!quiet) {
printf("Added ");
nl_object_dump(OBJ_CAST(neigh), &dp);
- }
+ }
return 0;
}
{
struct rtnl_neigh *neigh;
struct nl_cache *link_cache, *neigh_cache;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
neigh_cache = nl_cli_neigh_alloc_cache(sock);
- neigh = nl_cli_neigh_alloc();
-
+ neigh = nl_cli_neigh_alloc();
+
for (;;) {
int c, optidx = 0;
enum {
{ "state", 1, 0, ARG_STATE },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "qhva:l:d:", long_opts, &optidx);
if (c == -1)
break;
case ARG_FAMILY: nl_cli_neigh_parse_family(neigh, optarg); break;
case ARG_STATE: nl_cli_neigh_parse_state(neigh, optarg); break;
}
- }
+ }
nl_cache_foreach_filter(neigh_cache, OBJ_CAST(neigh), delete_cb, NULL);
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache_flags(sock, NL_CACHE_AF_ITER);
neigh_cache = nl_cli_neigh_alloc_cache(sock);
- neigh = nl_cli_neigh_alloc();
-
+ neigh = nl_cli_neigh_alloc();
+
for (;;) {
int c, optidx = 0;
enum {
{ "state", 1, 0, ARG_STATE },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "f:hva:l:d:", long_opts, &optidx);
if (c == -1)
break;
case ARG_FAMILY: nl_cli_neigh_parse_family(neigh, optarg); break;
case ARG_STATE: nl_cli_neigh_parse_state(neigh, optarg); break;
}
- }
+ }
nl_cache_dump_filter(neigh_cache, ¶ms, OBJ_CAST(neigh));
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
nl_cli_link_alloc_cache(sock);
neightbl_cache = nl_cli_alloc_cache(sock, "neighbour table",
rtnl_neightbl_alloc_cache);
-
+
for (;;) {
int c, optidx = 0;
static struct option long_opts[] = {
{ "version", 0, 0, 'v' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "f:hv", long_opts, &optidx);
if (c == -1)
break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
}
- }
+ }
nl_cache_dump(neightbl_cache, ¶ms);
{ "u32", 1, 0, ARG_U32 },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "hvl", long_opts, &optidx);
if (c == -1)
break;
uvalue = nl_cli_parse_u32(optarg);
break;
}
- }
+ }
if (optind >= argc)
print_usage();
struct rtnl_tc_ops *ops;
int err, flags = NLM_F_CREATE | NLM_F_EXCL;
char *kind, *id = NULL;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
- qdisc = nl_cli_qdisc_alloc();
+ qdisc = nl_cli_qdisc_alloc();
tc = (struct rtnl_tc *) qdisc;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "update-only", 0, 0, ARG_UPDATE_ONLY },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "+qhvd:p:i:",
long_opts, &optidx);
if (c == -1)
case ARG_UPDATE_ONLY: flags = 0; break;
case ARG_REPLACE_ONLY: flags = NLM_F_REPLACE; break;
}
- }
+ }
if (optind >= argc)
print_usage();
if (!quiet) {
printf("Adding ");
nl_object_dump(OBJ_CAST(qdisc), &dp);
- }
+ }
if ((err = rtnl_qdisc_add(sock, qdisc, flags)) < 0)
nl_cli_fatal(EINVAL, "Unable to add qdisc: %s", nl_geterror(err));
struct rtnl_tc *tc;
struct nl_cache *link_cache, *qdisc_cache;
int nfilter = 0;
-
+
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
qdisc_cache = nl_cli_qdisc_alloc_cache(sock);
- qdisc = nl_cli_qdisc_alloc();
+ qdisc = nl_cli_qdisc_alloc();
tc = (struct rtnl_tc *) qdisc;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "kind", 1, 0, 'k' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "qhvd:p:i:k:", long_opts, &optidx);
if (c == -1)
break;
nl_cli_tc_parse_kind(tc, optarg);
break;
}
- }
+ }
if (nfilter == 0 && !interactive && !default_yes) {
nl_cli_fatal(EINVAL,
struct rtnl_qdisc *qdisc;
struct rtnl_tc *tc;
struct nl_cache *link_cache, *qdisc_cache;
-
+
params.dp_fd = stdout;
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
qdisc_cache = nl_cli_qdisc_alloc_cache(sock);
- qdisc = nl_cli_qdisc_alloc();
+ qdisc = nl_cli_qdisc_alloc();
tc = (struct rtnl_tc *) qdisc;
-
+
for (;;) {
int c, optidx = 0;
enum {
{ "kind", 1, 0, 'k' },
{ 0, 0, 0, 0 }
};
-
+
c = getopt_long(argc, argv, "rhvd:p:i:k:", long_opts, &optidx);
if (c == -1)
break;
case 'i': nl_cli_tc_parse_handle(tc, optarg, 0); break;
case 'k': nl_cli_tc_parse_kind(tc, optarg); break;
}
- }
+ }
if (recursive)
nl_cache_foreach_filter(qdisc_cache, OBJ_CAST(qdisc), list_qdisc, NULL);
projects / libnl / commitdiff