static int nftnl_expr_log_set(struct nftnl_expr *e, uint16_t type, const void *data, uint32_t data_len) { struct nftnl_expr_log *log = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_LOG_PREFIX: if (log->prefix) xfree(log->prefix); log->prefix = strdup(data); break; case NFTNL_EXPR_LOG_GROUP: log->group = *((uint16_t *)data); break; case NFTNL_EXPR_LOG_SNAPLEN: log->snaplen = *((uint32_t *)data); break; case NFTNL_EXPR_LOG_QTHRESHOLD: log->qthreshold = *((uint16_t *)data); break; case NFTNL_EXPR_LOG_LEVEL: log->level = *((uint32_t *)data); break; case NFTNL_EXPR_LOG_FLAGS: log->flags = *((uint32_t *)data); break; default: return -1; } return 0; }
static int nftnl_expr_lookup_set(struct nftnl_expr *e, uint16_t type, const void *data, uint32_t data_len) { struct nftnl_expr_lookup *lookup = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_LOOKUP_SREG: lookup->sreg = *((uint32_t *)data); break; case NFTNL_EXPR_LOOKUP_DREG: lookup->dreg = *((uint32_t *)data); break; case NFTNL_EXPR_LOOKUP_SET: snprintf(lookup->set_name, sizeof(lookup->set_name), "%s", (const char *)data); break; case NFTNL_EXPR_LOOKUP_SET_ID: lookup->set_id = *((uint32_t *)data); break; default: return -1; } return 0; }
static int nftnl_expr_lookup_parse(struct nftnl_expr *e, struct nlattr *attr) { struct nftnl_expr_lookup *lookup = nftnl_expr_data(e); struct nlattr *tb[NFTA_LOOKUP_MAX+1] = {}; int ret = 0; if (mnl_attr_parse_nested(attr, nftnl_expr_lookup_cb, tb) < 0) return -1; if (tb[NFTA_LOOKUP_SREG]) { lookup->sreg = ntohl(mnl_attr_get_u32(tb[NFTA_LOOKUP_SREG])); e->flags |= (1 << NFTNL_EXPR_LOOKUP_SREG); } if (tb[NFTA_LOOKUP_DREG]) { lookup->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_LOOKUP_DREG])); e->flags |= (1 << NFTNL_EXPR_LOOKUP_DREG); } if (tb[NFTA_LOOKUP_SET]) { strcpy(lookup->set_name, mnl_attr_get_str(tb[NFTA_LOOKUP_SET])); e->flags |= (1 << NFTNL_EXPR_LOOKUP_SET); } if (tb[NFTA_LOOKUP_SET_ID]) { lookup->set_id = ntohl(mnl_attr_get_u32(tb[NFTA_LOOKUP_SET_ID])); e->flags |= (1 << NFTNL_EXPR_LOOKUP_SET_ID); } return ret; }
static int nftnl_expr_target_set(struct nftnl_expr *e, uint16_t type, const void *data, uint32_t data_len) { struct nftnl_expr_target *tg = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_TG_NAME: snprintf(tg->name, sizeof(tg->name), "%.*s", data_len, (const char *) data); break; case NFTNL_EXPR_TG_REV: tg->rev = *((uint32_t *)data); break; case NFTNL_EXPR_TG_INFO: if (e->flags & (1 << NFTNL_EXPR_TG_INFO)) xfree(tg->data); tg->data = data; tg->data_len = data_len; break; default: return -1; } return 0; }
static const void * nftnl_expr_payload_get(const struct nftnl_expr *e, uint16_t type, uint32_t *data_len) { struct nftnl_expr_payload *payload = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_PAYLOAD_SREG: *data_len = sizeof(payload->sreg); return &payload->sreg; case NFTNL_EXPR_PAYLOAD_DREG: *data_len = sizeof(payload->dreg); return &payload->dreg; case NFTNL_EXPR_PAYLOAD_BASE: *data_len = sizeof(payload->base); return &payload->base; case NFTNL_EXPR_PAYLOAD_OFFSET: *data_len = sizeof(payload->offset); return &payload->offset; case NFTNL_EXPR_PAYLOAD_LEN: *data_len = sizeof(payload->len); return &payload->len; case NFTNL_EXPR_PAYLOAD_CSUM_TYPE: *data_len = sizeof(payload->csum_type); return &payload->csum_type; case NFTNL_EXPR_PAYLOAD_CSUM_OFFSET: *data_len = sizeof(payload->csum_offset); return &payload->csum_offset; } return NULL; }
static int nftnl_expr_queue_snprintf_default(char *buf, size_t len, struct nftnl_expr *e) { struct nftnl_expr_queue *queue = nftnl_expr_data(e); int ret, size = len, offset = 0; uint16_t total_queues; total_queues = queue->queuenum + queue->queues_total -1; ret = snprintf(buf + offset, len, "num %u", queue->queuenum); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); if (queue->queues_total && total_queues != queue->queuenum) { ret = snprintf(buf + offset, len, "-%u", total_queues); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } if (e->flags & (1 << NFTNL_EXPR_QUEUE_FLAGS)) { if (queue->flags & (NFT_QUEUE_FLAG_BYPASS)) { ret = snprintf(buf + offset, len, " bypass"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } if (queue->flags & (NFT_QUEUE_FLAG_CPU_FANOUT)) { ret = snprintf(buf + offset, len, " fanout"); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } } return offset; }
static int nftnl_expr_payload_set(struct nftnl_expr *e, uint16_t type, const void *data, uint32_t data_len) { struct nftnl_expr_payload *payload = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_PAYLOAD_SREG: payload->sreg = *((uint32_t *)data); break; case NFTNL_EXPR_PAYLOAD_DREG: payload->dreg = *((uint32_t *)data); break; case NFTNL_EXPR_PAYLOAD_BASE: payload->base = *((uint32_t *)data); break; case NFTNL_EXPR_PAYLOAD_OFFSET: payload->offset = *((unsigned int *)data); break; case NFTNL_EXPR_PAYLOAD_LEN: payload->len = *((unsigned int *)data); break; case NFTNL_EXPR_PAYLOAD_CSUM_TYPE: payload->csum_type = *((uint32_t *)data); break; case NFTNL_EXPR_PAYLOAD_CSUM_OFFSET: payload->csum_offset = *((uint32_t *)data); break; default: return -1; } return 0; }
static int nftnl_expr_payload_snprintf(char *buf, size_t len, uint32_t type, uint32_t flags, struct nftnl_expr *e) { struct nftnl_expr_payload *payload = nftnl_expr_data(e); switch (type) { case NFTNL_OUTPUT_DEFAULT: if (payload->sreg) return snprintf(buf, len, "write reg %u => %ub @ %s header + %u csum_type %u csum_off %u ", payload->sreg, payload->len, base2str(payload->base), payload->offset, payload->csum_type, payload->csum_offset); else return snprintf(buf, len, "load %ub @ %s header + %u => reg %u ", payload->len, base2str(payload->base), payload->offset, payload->dreg); case NFTNL_OUTPUT_XML: case NFTNL_OUTPUT_JSON: return nftnl_expr_payload_export(buf, len, flags, e, type); default: break; } return -1; }
static const void * nftnl_expr_log_get(const struct nftnl_expr *e, uint16_t type, uint32_t *data_len) { struct nftnl_expr_log *log = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_LOG_PREFIX: *data_len = strlen(log->prefix)+1; return log->prefix; case NFTNL_EXPR_LOG_GROUP: *data_len = sizeof(log->group); return &log->group; case NFTNL_EXPR_LOG_SNAPLEN: *data_len = sizeof(log->snaplen); return &log->snaplen; case NFTNL_EXPR_LOG_QTHRESHOLD: *data_len = sizeof(log->qthreshold); return &log->qthreshold; case NFTNL_EXPR_LOG_LEVEL: *data_len = sizeof(log->level); return &log->level; case NFTNL_EXPR_LOG_FLAGS: *data_len = sizeof(log->flags); return &log->flags; } return NULL; }
static int nftnl_expr_match_set(struct nftnl_expr *e, uint16_t type, const void *data, uint32_t data_len) { struct nftnl_expr_match *mt = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_MT_NAME: snprintf(mt->name, sizeof(mt->name), "%.*s", data_len, (const char *)data); break; case NFTNL_EXPR_MT_REV: mt->rev = *((uint32_t *)data); break; case NFTNL_EXPR_MT_INFO: if (mt->data) xfree(mt->data); mt->data = data; mt->data_len = data_len; break; default: return -1; } return 0; }
static int nftnl_expr_payload_parse(struct nftnl_expr *e, struct nlattr *attr) { struct nftnl_expr_payload *payload = nftnl_expr_data(e); struct nlattr *tb[NFTA_PAYLOAD_MAX+1] = {}; if (mnl_attr_parse_nested(attr, nftnl_expr_payload_cb, tb) < 0) return -1; if (tb[NFTA_PAYLOAD_DREG]) { payload->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_PAYLOAD_DREG])); e->flags |= (1 << NFTNL_EXPR_PAYLOAD_DREG); } if (tb[NFTA_PAYLOAD_BASE]) { payload->base = ntohl(mnl_attr_get_u32(tb[NFTA_PAYLOAD_BASE])); e->flags |= (1 << NFTNL_EXPR_PAYLOAD_BASE); } if (tb[NFTA_PAYLOAD_OFFSET]) { payload->offset = ntohl(mnl_attr_get_u32(tb[NFTA_PAYLOAD_OFFSET])); e->flags |= (1 << NFTNL_EXPR_PAYLOAD_OFFSET); } if (tb[NFTA_PAYLOAD_LEN]) { payload->len = ntohl(mnl_attr_get_u32(tb[NFTA_PAYLOAD_LEN])); e->flags |= (1 << NFTNL_EXPR_PAYLOAD_LEN); } return 0; }
static int nftnl_expr_match_export(char *buf, size_t size, struct nftnl_expr *e, int type) { struct nftnl_expr_match *mt = nftnl_expr_data(e); NFTNL_BUF_INIT(b, buf, size); if (e->flags & (1 << NFTNL_EXPR_MT_NAME)) nftnl_buf_str(&b, type, mt->name, NAME); return nftnl_buf_done(&b); }
static int nftnl_rule_exp_target_export(char *buf, size_t size, const struct nftnl_expr *e, int type) { struct nftnl_expr_target *target = nftnl_expr_data(e); NFTNL_BUF_INIT(b, buf, size); if (e->flags & (1 << NFTNL_EXPR_TG_NAME)) nftnl_buf_str(&b, type, target->name, NAME); return nftnl_buf_done(&b); }
static void nftnl_expr_queue_build(struct nlmsghdr *nlh, struct nftnl_expr *e) { struct nftnl_expr_queue *queue = nftnl_expr_data(e); if (e->flags & (1 << NFTNL_EXPR_QUEUE_NUM)) mnl_attr_put_u16(nlh, NFTA_QUEUE_NUM, htons(queue->queuenum)); if (e->flags & (1 << NFTNL_EXPR_QUEUE_TOTAL)) mnl_attr_put_u16(nlh, NFTA_QUEUE_TOTAL, htons(queue->queues_total)); if (e->flags & (1 << NFTNL_EXPR_QUEUE_FLAGS)) mnl_attr_put_u16(nlh, NFTA_QUEUE_FLAGS, htons(queue->flags)); }
static void nftnl_expr_target_build(struct nlmsghdr *nlh, const struct nftnl_expr *e) { struct nftnl_expr_target *tg = nftnl_expr_data(e); if (e->flags & (1 << NFTNL_EXPR_TG_NAME)) mnl_attr_put_strz(nlh, NFTA_TARGET_NAME, tg->name); if (e->flags & (1 << NFTNL_EXPR_TG_REV)) mnl_attr_put_u32(nlh, NFTA_TARGET_REV, htonl(tg->rev)); if (e->flags & (1 << NFTNL_EXPR_TG_INFO)) mnl_attr_put(nlh, NFTA_TARGET_INFO, tg->data_len, tg->data); }
static void nftnl_expr_match_build(struct nlmsghdr *nlh, struct nftnl_expr *e) { struct nftnl_expr_match *mt = nftnl_expr_data(e); if (e->flags & (1 << NFTNL_EXPR_MT_NAME)) mnl_attr_put_strz(nlh, NFTA_MATCH_NAME, mt->name); if (e->flags & (1 << NFTNL_EXPR_MT_REV)) mnl_attr_put_u32(nlh, NFTA_MATCH_REV, htonl(mt->rev)); if (e->flags & (1 << NFTNL_EXPR_MT_INFO)) mnl_attr_put(nlh, NFTA_MATCH_INFO, mt->data_len, mt->data); }
static void nftnl_expr_payload_build(struct nlmsghdr *nlh, struct nftnl_expr *e) { struct nftnl_expr_payload *payload = nftnl_expr_data(e); if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_DREG)) mnl_attr_put_u32(nlh, NFTA_PAYLOAD_DREG, htonl(payload->dreg)); if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_BASE)) mnl_attr_put_u32(nlh, NFTA_PAYLOAD_BASE, htonl(payload->base)); if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_OFFSET)) mnl_attr_put_u32(nlh, NFTA_PAYLOAD_OFFSET, htonl(payload->offset)); if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_LEN)) mnl_attr_put_u32(nlh, NFTA_PAYLOAD_LEN, htonl(payload->len)); }
static int nftnl_expr_queue_export(char *buf, size_t size, struct nftnl_expr *e, int type) { struct nftnl_expr_queue *queue = nftnl_expr_data(e); NFTNL_BUF_INIT(b, buf, size); if (e->flags & (1 << NFTNL_EXPR_QUEUE_NUM)) nftnl_buf_u32(&b, type, queue->queuenum, NUM); if (e->flags & (1 << NFTNL_EXPR_QUEUE_TOTAL)) nftnl_buf_u32(&b, type, queue->queues_total, TOTAL); if (e->flags & (1 << NFTNL_EXPR_QUEUE_FLAGS)) nftnl_buf_u32(&b, type, queue->flags, FLAGS); return nftnl_buf_done(&b); }
static void nftnl_expr_lookup_build(struct nlmsghdr *nlh, struct nftnl_expr *e) { struct nftnl_expr_lookup *lookup = nftnl_expr_data(e); if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SREG)) mnl_attr_put_u32(nlh, NFTA_LOOKUP_SREG, htonl(lookup->sreg)); if (e->flags & (1 << NFTNL_EXPR_LOOKUP_DREG)) mnl_attr_put_u32(nlh, NFTA_LOOKUP_DREG, htonl(lookup->dreg)); if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SET)) mnl_attr_put_strz(nlh, NFTA_LOOKUP_SET, lookup->set_name); if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SET_ID)) { mnl_attr_put_u32(nlh, NFTA_LOOKUP_SET_ID, htonl(lookup->set_id)); } }
static int nftnl_expr_lookup_export(char *buf, size_t size, struct nftnl_expr *e, int type) { struct nftnl_expr_lookup *l = nftnl_expr_data(e); NFTNL_BUF_INIT(b, buf, size); if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SET)) nftnl_buf_str(&b, type, l->set_name, SET); if (e->flags & (1 << NFTNL_EXPR_LOOKUP_SREG)) nftnl_buf_u32(&b, type, l->sreg, SREG); if (e->flags & (1 << NFTNL_EXPR_LOOKUP_DREG)) nftnl_buf_u32(&b, type, l->dreg, DREG); return nftnl_buf_done(&b); }
static int nftnl_expr_payload_export(char *buf, size_t size, uint32_t flags, struct nftnl_expr *e, int type) { struct nftnl_expr_payload *payload = nftnl_expr_data(e); NFTNL_BUF_INIT(b, buf, size); if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_DREG)) nftnl_buf_u32(&b, type, payload->dreg, DREG); if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_OFFSET)) nftnl_buf_u32(&b, type, payload->offset, OFFSET); if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_LEN)) nftnl_buf_u32(&b, type, payload->len, LEN); if (e->flags & (1 << NFTNL_EXPR_PAYLOAD_BASE)) nftnl_buf_str(&b, type, base2str(payload->base), BASE); return nftnl_buf_done(&b); }
static int nftnl_expr_target_snprintf(char *buf, size_t len, uint32_t type, uint32_t flags, const struct nftnl_expr *e) { struct nftnl_expr_target *target = nftnl_expr_data(e); switch (type) { case NFTNL_OUTPUT_DEFAULT: return snprintf(buf, len, "name %s rev %u ", target->name, target->rev); case NFTNL_OUTPUT_XML: case NFTNL_OUTPUT_JSON: return nftnl_rule_exp_target_export(buf, len, e, type); default: break; } return -1; }
static int nftnl_expr_lookup_snprintf_default(char *buf, size_t size, struct nftnl_expr *e) { int len = size, offset = 0, ret; struct nftnl_expr_lookup *l = nftnl_expr_data(e); ret = snprintf(buf, len, "reg %u set %s ", l->sreg, l->set_name); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); if (e->flags & (1 << NFTNL_EXPR_LOOKUP_DREG)) { ret = snprintf(buf+offset, len, "dreg %u ", l->dreg); SNPRINTF_BUFFER_SIZE(ret, size, len, offset); } return offset; }
static int nftnl_expr_match_snprintf(char *buf, size_t len, uint32_t type, uint32_t flags, struct nftnl_expr *e) { struct nftnl_expr_match *match = nftnl_expr_data(e); switch (type) { case NFTNL_OUTPUT_DEFAULT: return snprintf(buf, len, "name %s rev %u ", match->name, match->rev); case NFTNL_OUTPUT_XML: case NFTNL_OUTPUT_JSON: return nftnl_expr_match_export(buf, len, e, type); default: break; } return -1; }
static void nftnl_expr_log_build(struct nlmsghdr *nlh, struct nftnl_expr *e) { struct nftnl_expr_log *log = nftnl_expr_data(e); if (e->flags & (1 << NFTNL_EXPR_LOG_PREFIX)) mnl_attr_put_strz(nlh, NFTA_LOG_PREFIX, log->prefix); if (e->flags & (1 << NFTNL_EXPR_LOG_GROUP)) mnl_attr_put_u16(nlh, NFTA_LOG_GROUP, htons(log->group)); if (e->flags & (1 << NFTNL_EXPR_LOG_SNAPLEN)) mnl_attr_put_u32(nlh, NFTA_LOG_SNAPLEN, htonl(log->snaplen)); if (e->flags & (1 << NFTNL_EXPR_LOG_QTHRESHOLD)) mnl_attr_put_u16(nlh, NFTA_LOG_QTHRESHOLD, htons(log->qthreshold)); if (e->flags & (1 << NFTNL_EXPR_LOG_LEVEL)) mnl_attr_put_u32(nlh, NFTA_LOG_LEVEL, htonl(log->level)); if (e->flags & (1 << NFTNL_EXPR_LOG_FLAGS)) mnl_attr_put_u32(nlh, NFTA_LOG_FLAGS, htonl(log->flags)); }
static const void * nftnl_expr_match_get(const struct nftnl_expr *e, uint16_t type, uint32_t *data_len) { struct nftnl_expr_match *mt = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_MT_NAME: *data_len = sizeof(mt->name); return mt->name; case NFTNL_EXPR_MT_REV: *data_len = sizeof(mt->rev); return &mt->rev; case NFTNL_EXPR_MT_INFO: *data_len = mt->data_len; return mt->data; } return NULL; }
static const void * nftnl_expr_queue_get(const struct nftnl_expr *e, uint16_t type, uint32_t *data_len) { struct nftnl_expr_queue *queue = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_QUEUE_NUM: *data_len = sizeof(queue->queuenum); return &queue->queuenum; case NFTNL_EXPR_QUEUE_TOTAL: *data_len = sizeof(queue->queues_total); return &queue->queues_total; case NFTNL_EXPR_QUEUE_FLAGS: *data_len = sizeof(queue->flags); return &queue->flags; } return NULL; }
static const void * nftnl_expr_target_get(const struct nftnl_expr *e, uint16_t type, uint32_t *data_len) { struct nftnl_expr_target *tg = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_TG_NAME: *data_len = sizeof(tg->name); return tg->name; case NFTNL_EXPR_TG_REV: *data_len = sizeof(tg->rev); return &tg->rev; case NFTNL_EXPR_TG_INFO: *data_len = tg->data_len; return tg->data; } return NULL; }
static int nftnl_expr_target_parse(struct nftnl_expr *e, struct nlattr *attr) { struct nftnl_expr_target *target = nftnl_expr_data(e); struct nlattr *tb[NFTA_TARGET_MAX+1] = {}; if (mnl_attr_parse_nested(attr, nftnl_expr_target_cb, tb) < 0) return -1; if (tb[NFTA_TARGET_NAME]) { snprintf(target->name, XT_EXTENSION_MAXNAMELEN, "%s", mnl_attr_get_str(tb[NFTA_TARGET_NAME])); target->name[XT_EXTENSION_MAXNAMELEN-1] = '\0'; e->flags |= (1 << NFTNL_EXPR_TG_NAME); } if (tb[NFTA_TARGET_REV]) { target->rev = ntohl(mnl_attr_get_u32(tb[NFTA_TARGET_REV])); e->flags |= (1 << NFTNL_EXPR_TG_REV); } if (tb[NFTA_TARGET_INFO]) { uint32_t len = mnl_attr_get_payload_len(tb[NFTA_TARGET_INFO]); void *target_data; if (target->data) xfree(target->data); target_data = calloc(1, len); if (target_data == NULL) return -1; memcpy(target_data, mnl_attr_get_payload(tb[NFTA_TARGET_INFO]), len); target->data = target_data; target->data_len = len; e->flags |= (1 << NFTNL_EXPR_TG_INFO); } return 0; }
static int nftnl_expr_queue_set(struct nftnl_expr *e, uint16_t type, const void *data, uint32_t data_len) { struct nftnl_expr_queue *queue = nftnl_expr_data(e); switch(type) { case NFTNL_EXPR_QUEUE_NUM: queue->queuenum = *((uint16_t *)data); break; case NFTNL_EXPR_QUEUE_TOTAL: queue->queues_total = *((uint16_t *)data); break; case NFTNL_EXPR_QUEUE_FLAGS: queue->flags = *((uint16_t *)data); break; default: return -1; } return 0; }