if (len < sizeof(struct tcphdr))
return ULOGD_IRET_OK;
- ret[KEY_TCP_SPORT].u.value.ui16 = ntohs(tcph->source);
- ret[KEY_TCP_SPORT].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_DPORT].u.value.ui16 = ntohs(tcph->dest);
- ret[KEY_TCP_DPORT].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_SEQ].u.value.ui32 = ntohl(tcph->seq);
- ret[KEY_TCP_SEQ].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_ACKSEQ].u.value.ui32 = ntohl(tcph->ack_seq);
- ret[KEY_TCP_ACKSEQ].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_OFFSET].u.value.ui8 = ntohs(tcph->doff);
- ret[KEY_TCP_OFFSET].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_RESERVED].u.value.ui8 = ntohs(tcph->res1);
- ret[KEY_TCP_RESERVED].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_WINDOW].u.value.ui16 = ntohs(tcph->window);
- ret[KEY_TCP_WINDOW].flags |= ULOGD_RETF_VALID;
-
- ret[KEY_TCP_URG].u.value.b = tcph->urg;
- ret[KEY_TCP_URG].flags |= ULOGD_RETF_VALID;
- if (tcph->urg) {
- ret[KEY_TCP_URGP].u.value.ui16 = ntohs(tcph->urg_ptr);
- ret[KEY_TCP_URGP].flags |= ULOGD_RETF_VALID;
- }
- ret[KEY_TCP_ACK].u.value.b = tcph->ack;
- ret[KEY_TCP_ACK].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_PSH].u.value.b = tcph->psh;
- ret[KEY_TCP_PSH].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_RST].u.value.b = tcph->rst;
- ret[KEY_TCP_RST].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_SYN].u.value.b = tcph->syn;
- ret[KEY_TCP_SYN].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_FIN].u.value.b = tcph->fin;
- ret[KEY_TCP_FIN].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_RES1].u.value.b = tcph->res1;
- ret[KEY_TCP_RES1].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_RES2].u.value.b = tcph->res2;
- ret[KEY_TCP_RES2].flags |= ULOGD_RETF_VALID;
- ret[KEY_TCP_CSUM].u.value.ui16 = ntohs(tcph->check);
- ret[KEY_TCP_CSUM].u.value.ui16 = ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_TCP_SPORT], ntohs(tcph->source));
+ okey_set_u16(&ret[KEY_TCP_DPORT], ntohs(tcph->dest));
+ okey_set_u32(&ret[KEY_TCP_SEQ], ntohl(tcph->seq));
+ okey_set_u32(&ret[KEY_TCP_ACKSEQ], ntohl(tcph->ack_seq));
+ okey_set_u8(&ret[KEY_TCP_OFFSET], ntohs(tcph->doff));
+ okey_set_u8(&ret[KEY_TCP_RESERVED], ntohs(tcph->res1));
+ okey_set_u16(&ret[KEY_TCP_WINDOW], ntohs(tcph->window));
+
+ okey_set_b(&ret[KEY_TCP_URG], tcph->urg);
+ if (tcph->urg)
+ okey_set_u16(&ret[KEY_TCP_URGP], ntohs(tcph->urg_ptr));
+ okey_set_b(&ret[KEY_TCP_ACK], tcph->ack);
+ okey_set_b(&ret[KEY_TCP_PSH], tcph->psh);
+ okey_set_b(&ret[KEY_TCP_RST], tcph->rst);
+ okey_set_b(&ret[KEY_TCP_SYN], tcph->syn);
+ okey_set_b(&ret[KEY_TCP_FIN], tcph->fin);
+ okey_set_b(&ret[KEY_TCP_RES1], tcph->res1);
+ okey_set_b(&ret[KEY_TCP_RES2], tcph->res2);
+ okey_set_u16(&ret[KEY_TCP_CSUM], ntohs(tcph->check));
return ULOGD_IRET_OK;
}
if (len < sizeof(struct udphdr))
return ULOGD_IRET_OK;
- ret[KEY_UDP_SPORT].u.value.ui16 = ntohs(udph->source);
- ret[KEY_UDP_SPORT].flags |= ULOGD_RETF_VALID;
- ret[KEY_UDP_DPORT].u.value.ui16 = ntohs(udph->dest);
- ret[KEY_UDP_DPORT].flags |= ULOGD_RETF_VALID;
- ret[KEY_UDP_LEN].u.value.ui16 = ntohs(udph->len);
- ret[KEY_UDP_LEN].flags |= ULOGD_RETF_VALID;
- ret[KEY_UDP_CSUM].u.value.ui16 = ntohs(udph->check);
- ret[KEY_UDP_CSUM].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_UDP_SPORT], ntohs(udph->source));
+ okey_set_u16(&ret[KEY_UDP_DPORT], ntohs(udph->dest));
+ okey_set_u16(&ret[KEY_UDP_LEN], ntohs(udph->len));
+ okey_set_u16(&ret[KEY_UDP_CSUM], ntohs(udph->check));
return ULOGD_IRET_OK;
}
if (len < sizeof(struct icmphdr))
return ULOGD_IRET_OK;
- ret[KEY_ICMP_TYPE].u.value.ui8 = icmph->type;
- ret[KEY_ICMP_TYPE].flags |= ULOGD_RETF_VALID;
- ret[KEY_ICMP_CODE].u.value.ui8 = icmph->code;
- ret[KEY_ICMP_CODE].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[KEY_ICMP_TYPE], icmph->type);
+ okey_set_u8(&ret[KEY_ICMP_CODE], icmph->code);
switch (icmph->type) {
case ICMP_ECHO:
case ICMP_ECHOREPLY:
- ret[KEY_ICMP_ECHOID].u.value.ui16 = ntohs(icmph->un.echo.id);
- ret[KEY_ICMP_ECHOID].flags |= ULOGD_RETF_VALID;
- ret[KEY_ICMP_ECHOSEQ].u.value.ui16 = ntohs(icmph->un.echo.sequence);
- ret[KEY_ICMP_ECHOSEQ].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_ICMP_ECHOID], ntohs(icmph->un.echo.id));
+ okey_set_u16(&ret[KEY_ICMP_ECHOSEQ],
+ ntohs(icmph->un.echo.sequence));
break;
case ICMP_REDIRECT:
case ICMP_PARAMETERPROB:
- ret[KEY_ICMP_GATEWAY].u.value.ui32 = ntohl(icmph->un.gateway);
- ret[KEY_ICMP_GATEWAY].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[KEY_ICMP_GATEWAY], ntohl(icmph->un.gateway));
break;
case ICMP_DEST_UNREACH:
if (icmph->code == ICMP_FRAG_NEEDED) {
- ret[KEY_ICMP_FRAGMTU].u.value.ui16 = ntohs(icmph->un.frag.mtu);
- ret[KEY_ICMP_FRAGMTU].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_ICMP_FRAGMTU],
+ ntohs(icmph->un.frag.mtu));
}
break;
}
- ret[KEY_ICMP_CSUM].u.value.ui16 = icmph->checksum;
- ret[KEY_ICMP_CSUM].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_ICMP_CSUM], icmph->checksum);
return ULOGD_IRET_OK;
}
if (len < sizeof(struct icmp6_hdr))
return ULOGD_IRET_OK;
- ret[KEY_ICMPV6_TYPE].u.value.ui8 = icmph->icmp6_type;
- ret[KEY_ICMPV6_TYPE].flags |= ULOGD_RETF_VALID;
- ret[KEY_ICMPV6_CODE].u.value.ui8 = icmph->icmp6_code;
- ret[KEY_ICMPV6_CODE].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[KEY_ICMPV6_TYPE], icmph->icmp6_type);
+ okey_set_u8(&ret[KEY_ICMPV6_CODE], icmph->icmp6_code);
switch (icmph->icmp6_type) {
case ICMP6_ECHO_REQUEST:
case ICMP6_ECHO_REPLY:
- ret[KEY_ICMPV6_ECHOID].u.value.ui16 = ntohs(icmph->icmp6_id);
- ret[KEY_ICMPV6_ECHOID].flags |= ULOGD_RETF_VALID;
- ret[KEY_ICMPV6_ECHOSEQ].u.value.ui16 = ntohs(icmph->icmp6_seq);
- ret[KEY_ICMPV6_ECHOSEQ].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_ICMPV6_ECHOID], ntohs(icmph->icmp6_id));
+ okey_set_u16(&ret[KEY_ICMPV6_ECHOSEQ],
+ ntohs(icmph->icmp6_seq));
break;
}
- ret[KEY_ICMPV6_CSUM].u.value.ui16 = icmph->icmp6_cksum;
- ret[KEY_ICMPV6_CSUM].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_ICMPV6_CSUM], icmph->icmp6_cksum);
return ULOGD_IRET_OK;
}
{
struct ulogd_key *ret = pi->output.keys;
struct iphdr *iph =
- GET_VALUE(pi->input.keys, INKEY_RAW_PCKT).ptr;
+ ikey_get_ptr(&pi->input.keys[INKEY_RAW_PCKT]);
void *nexthdr = (u_int32_t *)iph + iph->ihl;
if (len < sizeof(struct iphdr) || len <= (u_int32_t)(iph->ihl * 4))
return ULOGD_IRET_OK;
len -= iph->ihl * 4;
- ret[KEY_IP_SADDR].u.value.ui32 = iph->saddr;
- ret[KEY_IP_SADDR].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_DADDR].u.value.ui32 = iph->daddr;
- ret[KEY_IP_DADDR].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_PROTOCOL].u.value.ui8 = iph->protocol;
- ret[KEY_IP_PROTOCOL].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_TOS].u.value.ui8 = iph->tos;
- ret[KEY_IP_TOS].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_TTL].u.value.ui8 = iph->ttl;
- ret[KEY_IP_TTL].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_TOTLEN].u.value.ui16 = ntohs(iph->tot_len);
- ret[KEY_IP_TOTLEN].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_IHL].u.value.ui8 = iph->ihl;
- ret[KEY_IP_IHL].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_CSUM].u.value.ui16 = ntohs(iph->check);
- ret[KEY_IP_CSUM].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_ID].u.value.ui16 = ntohs(iph->id);
- ret[KEY_IP_ID].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP_FRAGOFF].u.value.ui16 = ntohs(iph->frag_off);
- ret[KEY_IP_FRAGOFF].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[KEY_IP_SADDR], iph->saddr);
+ okey_set_u32(&ret[KEY_IP_DADDR], iph->daddr);
+ okey_set_u8(&ret[KEY_IP_PROTOCOL], iph->protocol);
+ okey_set_u8(&ret[KEY_IP_TOS], iph->tos);
+ okey_set_u8(&ret[KEY_IP_TTL], iph->ttl);
+ okey_set_u16(&ret[KEY_IP_TOTLEN], ntohs(iph->tot_len));
+ okey_set_u8(&ret[KEY_IP_IHL], iph->ihl);
+ okey_set_u16(&ret[KEY_IP_CSUM], ntohs(iph->check));
+ okey_set_u16(&ret[KEY_IP_ID], ntohs(iph->id));
+ okey_set_u16(&ret[KEY_IP_FRAGOFF], ntohs(iph->frag_off));
switch (iph->protocol) {
case IPPROTO_TCP:
static int _interp_ipv6hdr(struct ulogd_pluginstance *pi, u_int32_t len)
{
struct ulogd_key *ret = pi->output.keys;
- struct ip6_hdr *ipv6h =
- GET_VALUE(pi->input.keys, INKEY_RAW_PCKT).ptr;
+ struct ip6_hdr *ipv6h = ikey_get_ptr(&pi->input.keys[INKEY_RAW_PCKT]);
unsigned int ptr, hdrlen = 0;
u_int8_t curhdr;
int fragment = 0;
if (len < sizeof(struct ip6_hdr))
return ULOGD_IRET_OK;
- memcpy(ret[KEY_IP_SADDR].u.value.ui128, &ipv6h->ip6_src,
- sizeof(ipv6h->ip6_src));
- ret[KEY_IP_SADDR].flags |= ULOGD_RETF_VALID;
- memcpy(ret[KEY_IP_DADDR].u.value.ui128, &ipv6h->ip6_dst,
- sizeof(ipv6h->ip6_dst));
- ret[KEY_IP_DADDR].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP6_PAYLOAD_LEN].u.value.ui16 = ntohs(ipv6h->ip6_plen);
- ret[KEY_IP6_PAYLOAD_LEN].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP6_PRIORITY].u.value.ui8 = ntohl(ipv6h->ip6_flow & 0x0ff00000) >> 20;
- ret[KEY_IP6_PRIORITY].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP6_FLOWLABEL].u.value.ui32 = ntohl(ipv6h->ip6_flow & 0x000fffff);
- ret[KEY_IP6_FLOWLABEL].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP6_HOPLIMIT].u.value.ui8 = ipv6h->ip6_hlim;
- ret[KEY_IP6_HOPLIMIT].flags |= ULOGD_RETF_VALID;
+ okey_set_u128(&ret[KEY_IP_SADDR], &ipv6h->ip6_src);
+ okey_set_u128(&ret[KEY_IP_DADDR], &ipv6h->ip6_dst);
+ okey_set_u16(&ret[KEY_IP6_PAYLOAD_LEN], ntohs(ipv6h->ip6_plen));
+ okey_set_u8(&ret[KEY_IP6_PRIORITY],
+ ntohl(ipv6h->ip6_flow & 0x0ff00000) >> 20);
+ okey_set_u32(&ret[KEY_IP6_FLOWLABEL],
+ ntohl(ipv6h->ip6_flow & 0x000fffff));
+ okey_set_u8(&ret[KEY_IP6_HOPLIMIT], ipv6h->ip6_hlim);
curhdr = ipv6h->ip6_nxt;
ptr = sizeof(struct ip6_hdr);
return ULOGD_IRET_OK;
len -= hdrlen;
- ret[KEY_IP6_FRAG_OFF].u.value.ui16 = ntohs(fh->ip6f_offlg & IP6F_OFF_MASK);
- ret[KEY_IP6_FRAG_OFF].flags |= ULOGD_RETF_VALID;
- ret[KEY_IP6_FRAG_ID].u.value.ui32 = ntohl(fh->ip6f_ident);
- ret[KEY_IP6_FRAG_ID].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_IP6_FRAG_OFF],
+ ntohs(fh->ip6f_offlg & IP6F_OFF_MASK));
+ okey_set_u32(&ret[KEY_IP6_FRAG_ID],
+ ntohl(fh->ip6f_ident));
if (ntohs(fh->ip6f_offlg & IP6F_OFF_MASK))
fragment = 1;
goto out;
- ret[KEY_IP_PROTOCOL].u.value.ui8 = curhdr;
- ret[KEY_IP_PROTOCOL].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[KEY_IP_PROTOCOL], curhdr);
switch (curhdr) {
case IPPROTO_TCP:
}
out:
- ret[KEY_IP6_NEXTHDR].u.value.ui8 = curhdr;
- ret[KEY_IP6_NEXTHDR].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[KEY_IP6_NEXTHDR], curhdr);
return ULOGD_IRET_OK;
}
{
struct ulogd_key *ret = pi->output.keys;
const struct ether_arp *arph =
- GET_VALUE(pi->input.keys, INKEY_RAW_PCKT).ptr;
+ ikey_get_ptr(&pi->input.keys[INKEY_RAW_PCKT]);
if (len < sizeof(struct ether_arp))
return ULOGD_IRET_OK;
- ret[KEY_ARP_HTYPE].u.value.ui16 = ntohs(arph->arp_hrd);
- SET_VALID(ret[KEY_ARP_HTYPE]);
- ret[KEY_ARP_PTYPE].u.value.ui16 = ntohs(arph->arp_pro);
- SET_VALID(ret[KEY_ARP_PTYPE]);
- ret[KEY_ARP_OPCODE].u.value.ui16 = ntohs(arph->arp_op);
- SET_VALID(ret[KEY_ARP_OPCODE]);
-
- ret[KEY_ARP_SHA].u.value.ptr = &arph->arp_sha;
- SET_VALID(ret[KEY_ARP_SHA]);
-
- memcpy(&ret[KEY_ARP_SPA].u.value.ui32, &arph->arp_spa,
- sizeof(u_int32_t));
- SET_VALID(ret[KEY_ARP_SPA]);
-
- ret[KEY_ARP_THA].u.value.ptr = &arph->arp_tha;
- SET_VALID(ret[KEY_ARP_THA]);
+ okey_set_u16(&ret[KEY_ARP_HTYPE], ntohs(arph->arp_hrd));
+ okey_set_u16(&ret[KEY_ARP_PTYPE], ntohs(arph->arp_pro));
+ okey_set_u16(&ret[KEY_ARP_OPCODE], ntohs(arph->arp_op));
- memcpy(&ret[KEY_ARP_TPA].u.value.ui32, &arph->arp_tpa,
- sizeof(u_int32_t));
- SET_VALID(ret[KEY_ARP_TPA]);
+ okey_set_ptr(&ret[KEY_ARP_SHA], &arph->arp_sha);
+ okey_set_ptr(&ret[KEY_ARP_SPA], &arph->arp_spa),
+ okey_set_ptr(&ret[KEY_ARP_THA], &arph->arp_tha);
+ okey_set_ptr(&ret[KEY_ARP_TPA], &arph->arp_tpa);
return ULOGD_IRET_OK;
}
static int _interp_bridge(struct ulogd_pluginstance *pi, u_int32_t len)
{
const u_int16_t proto =
- GET_VALUE(pi->input.keys, INKEY_OOB_PROTOCOL).ui16;
+ ikey_get_u16(&pi->input.keys[INKEY_OOB_PROTOCOL]);
switch (proto) {
case ETH_P_IP:
static int _interp_pkt(struct ulogd_pluginstance *pi)
{
- u_int32_t len = GET_VALUE(pi->input.keys, INKEY_RAW_PCKTLEN).ui32;
- u_int8_t family = GET_VALUE(pi->input.keys, INKEY_OOB_FAMILY).ui8;
+ u_int32_t len = ikey_get_u32(&pi->input.keys[INKEY_RAW_PCKTLEN]);
+ u_int8_t family = ikey_get_u8(&pi->input.keys[INKEY_OOB_FAMILY]);
struct ulogd_key *ret = pi->output.keys;
- ret[KEY_OOB_PROTOCOL].u.value.ui16 =
- GET_VALUE(pi->input.keys, INKEY_OOB_PROTOCOL).ui16;
- SET_VALID(ret[KEY_OOB_PROTOCOL]);
+ okey_set_u16(&ret[KEY_OOB_PROTOCOL],
+ ikey_get_u16(&pi->input.keys[INKEY_OOB_PROTOCOL]));
switch (family) {
case AF_INET:
gettimeofday(&tv, NULL);
/* put date */
- ret[0].value.ui32 = (unsigned long) tv.tv_sec;
- ret[0].flags |= ULOGD_RETF_VALID;
-
- ret[1].value.ptr = hostname;
- ret[1].flags |= ULOGD_RETF_VALID;
+ okey_set_ui32(&ret[0], (unsigned long) tv.tv_sec);
+ okey_set_ptr(&ret[1], hostname);
return ret;
}
* ulogd interpreter plugin for HWMAC
*
* (C) 2008 by Eric Leblond <eric@inl.fr>
+ * (C) 2008 by Pablo Neira Ayuso <pablo@netfilter.org>
*
* Based on ulogd_filter_IFINDEX.c Harald Welte <laforge@gnumonks.org>
*
buf_cur += sprintf(buf_cur, "%02x%c", mac[i],
i == len - 1 ? 0 : ':');
- ret[okey].u.value.ptr = mac_str;
- ret[okey].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[okey], mac_str);
return ULOGD_IRET_OK;
}
+static void *hwhdr_get_saddr(struct ulogd_key *inp)
+{
+ return ikey_get_ptr(&inp[KEY_RAW_MAC]) + ETH_ALEN;
+}
+
+static void *hwhdr_get_daddr(struct ulogd_key *inp)
+{
+ return ikey_get_ptr(&inp[KEY_RAW_MAC]);
+}
+
+static u_int16_t hwhdr_get_len(struct ulogd_key *inp)
+{
+ void *len = ikey_get_ptr(&inp[KEY_RAW_MAC]) + 2 * ETH_ALEN;
+ return ntohs(*(u_int16_t *) len);
+}
static int parse_ethernet(struct ulogd_key *ret, struct ulogd_key *inp)
{
int fret;
if (!pp_is_valid(inp, KEY_RAW_MAC_SADDR)) {
- fret = parse_mac2str(ret,
- GET_VALUE(inp, KEY_RAW_MAC).ptr
- + ETH_ALEN,
+ fret = parse_mac2str(ret, hwhdr_get_saddr(inp),
KEY_MAC_SADDR, ETH_ALEN);
if (fret != ULOGD_IRET_OK)
return fret;
}
- fret = parse_mac2str(ret, GET_VALUE(inp, KEY_RAW_MAC).ptr,
+ fret = parse_mac2str(ret, hwhdr_get_daddr(inp),
KEY_MAC_DADDR, ETH_ALEN);
if (fret != ULOGD_IRET_OK)
return fret;
- ret[KEY_MAC_PROTOCOL].u.value.ui16 =
- ntohs(*(u_int16_t *) (GET_VALUE(inp, KEY_RAW_MAC).ptr
- + 2 * ETH_ALEN));
- ret[KEY_MAC_PROTOCOL].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[KEY_MAC_PROTOCOL], hwhdr_get_len(inp));
return ULOGD_IRET_OK;
}
struct ulogd_key *inp = pi->input.keys;
u_int16_t type = 0;
- if (pp_is_valid(inp, KEY_OOB_PROTOCOL)) {
- ret[KEY_MAC_PROTOCOL].u.value.ui16 =
- GET_VALUE(inp, KEY_OOB_PROTOCOL).ui16;
- ret[KEY_MAC_PROTOCOL].flags |= ULOGD_RETF_VALID;
- }
+ if (pp_is_valid(inp, KEY_OOB_PROTOCOL))
+ okey_set_u16(&ret[KEY_MAC_PROTOCOL],
+ ikey_get_u16(&inp[KEY_OOB_PROTOCOL]));
if (pp_is_valid(inp, KEY_RAW_MAC_SADDR)) {
int fret;
fret = parse_mac2str(ret,
- GET_VALUE(inp, KEY_RAW_MAC_SADDR).ptr,
+ ikey_get_ptr(&inp[KEY_RAW_MAC_SADDR]),
KEY_MAC_SADDR,
- GET_VALUE(inp, KEY_RAW_MAC_ADDRLEN).ui16);
+ ikey_get_u16(&inp[KEY_RAW_MAC_ADDRLEN]));
if (fret != ULOGD_IRET_OK)
return fret;
}
if (pp_is_valid(inp, KEY_RAW_MAC)) {
- if (GET_VALUE(inp, KEY_RAW_MAC_ADDRLEN).ui16 == ETH_ALEN) {
- ret[KEY_MAC_TYPE].u.value.ui16 = ARPHRD_ETHER;
- ret[KEY_MAC_TYPE].flags |= ULOGD_RETF_VALID;
- } else {
- ret[KEY_MAC_TYPE].u.value.ui16 = ARPHRD_VOID;
- ret[KEY_MAC_TYPE].flags |= ULOGD_RETF_VALID;
- }
+ if (ikey_get_u16(&inp[KEY_RAW_MAC_ADDRLEN]) == ETH_ALEN)
+ okey_set_u16(&ret[KEY_MAC_TYPE], ARPHRD_ETHER);
+ else
+ okey_set_u16(&ret[KEY_MAC_TYPE], ARPHRD_VOID);
+
return ULOGD_IRET_OK;
}
if (pp_is_valid(inp, KEY_RAW_TYPE)) {
/* NFLOG with Linux >= 2.6.27 case */
- ret[KEY_MAC_TYPE].u.value.ui16 = type =
- GET_VALUE(inp, KEY_RAW_TYPE).ui16;
- ret[KEY_MAC_TYPE].flags |= ULOGD_RETF_VALID;
+ type = ikey_get_u16(&inp[KEY_RAW_TYPE]);
+ okey_set_u16(&ret[KEY_MAC_TYPE], type);
} else {
/* ULOG case, treat ethernet encapsulation */
- if (GET_VALUE(inp, KEY_RAW_MACLEN).ui16 == ETH_HLEN) {
- ret[KEY_MAC_TYPE].u.value.ui16 = type = ARPHRD_ETHER;
- ret[KEY_MAC_TYPE].flags |= ULOGD_RETF_VALID;
+ if (ikey_get_u16(&inp[KEY_RAW_MACLEN]) == ETH_HLEN) {
+ type = ARPHRD_ETHER;
+ okey_set_u16(&ret[KEY_MAC_TYPE], type);
} else {
- ret[KEY_MAC_TYPE].u.value.ui16 = type = ARPHRD_VOID;
- ret[KEY_MAC_TYPE].flags |= ULOGD_RETF_VALID;
+ type = ARPHRD_VOID;
+ okey_set_u16(&ret[KEY_MAC_TYPE], type);
}
}
default:
/* convert raw header to string */
return parse_mac2str(ret,
- GET_VALUE(inp, KEY_RAW_MAC).ptr,
- KEY_MAC_ADDR,
- GET_VALUE(inp,
- KEY_RAW_MACLEN).ui16);
+ ikey_get_ptr(&inp[KEY_RAW_MAC]),
+ KEY_MAC_ADDR,
+ ikey_get_u16(&inp[KEY_RAW_MACLEN]));
}
return ULOGD_IRET_OK;
}
* ulogd interpreter plugin for ifindex to ifname conversion
*
* (C) 2005 by Harald Welte <laforge@gnumonks.org>
+ * (C) 2008 by Pablo Neira Ayuso <pablo@netfilter.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
{
struct ulogd_key *ret = pi->output.keys;
struct ulogd_key *inp = pi->input.keys;
+ void *ptr;
- ret[0].u.value.ptr = calloc(IFNAMSIZ, sizeof(char));
- nlif_index2name(nlif_inst, inp[0].u.source->u.value.ui32,
- ret[0].u.value.ptr);
- if (((char *)ret[0].u.value.ptr)[0] == '*')
- ((char *)(ret[0].u.value.ptr))[0] = 0;
- ret[0].flags |= ULOGD_RETF_VALID;
-
- ret[1].u.value.ptr = calloc(IFNAMSIZ, sizeof(char));
- nlif_index2name(nlif_inst, inp[1].u.source->u.value.ui32,
- ret[1].u.value.ptr);
- if (((char *)ret[1].u.value.ptr)[0] == '*')
- ((char *)(ret[1].u.value.ptr))[0] = 0;
- ret[1].flags |= ULOGD_RETF_VALID;
+ ptr = calloc(IFNAMSIZ, sizeof(char));
+ if (!ptr)
+ return ULOGD_IRET_ERR;
+
+ nlif_index2name(nlif_inst, ikey_get_u32(&inp[0]), ptr);
+ if (((char *)ptr)[0] == '*')
+ ((char *)(ptr))[0] = 0;
+ okey_set_ptr(&ret[0], ptr);
+
+ ptr = calloc(IFNAMSIZ, sizeof(char));
+ if (!ptr)
+ return ULOGD_IRET_ERR;
+
+ nlif_index2name(nlif_inst, ikey_get_u32(&inp[1]), ptr);
+ if (((char *)ptr)[0] == '*')
+ ((char *)(ptr))[0] = 0;
+ okey_set_ptr(&ret[1], ptr);
return ULOGD_IRET_OK;
}
switch (family) {
case AF_INET6:
- addr = (struct in6_addr *) GET_VALUE(inp, index).ui128;
+ addr = (struct in6_addr *)ikey_get_u128(&inp[index]);
break;
case AF_INET:
/* Convert IPv4 to IPv4 in IPv6 */
addr = &ip4_addr;
- uint32_to_ipv6(GET_VALUE(inp, index).ui32, addr);
+ uint32_to_ipv6(ikey_get_u32(&inp[index]), addr);
break;
default:
/* TODO handle error */
struct ulogd_key *ret = pi->output.keys;
struct ulogd_key *inp = pi->input.keys;
int i;
- int oob_family = GET_VALUE(inp, KEY_OOB_FAMILY).ui8;
+ int oob_family = ikey_get_u8(&inp[KEY_OOB_FAMILY]);
/* Iter on all addr fields */
for(i = START_KEY; i < MAX_KEY; i++) {
if (pp_is_valid(inp, i)) {
- ret[i-1].u.value.ptr = ip2bin(inp, i, oob_family);
- ret[i-1].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[i-1], ip2bin(inp, i, oob_family));
}
}
static char *ip2str(struct ulogd_key *inp, int index)
{
char tmp[IPADDR_LENGTH];
- char family = GET_VALUE(inp, KEY_OOB_FAMILY).ui8;
+ char family = ikey_get_u8(&inp[KEY_OOB_FAMILY]);
char convfamily = family;
if (family == AF_BRIDGE) {
"No protocol inside AF_BRIDGE packet\n");
return NULL;
}
- switch (GET_VALUE(inp, KEY_OOB_PROTOCOL).ui16) {
+ switch (ikey_get_u16(&inp[KEY_OOB_PROTOCOL])) {
case ETH_P_IPV6:
convfamily = AF_INET6;
break;
}
switch (convfamily) {
+ u_int32_t ip;
case AF_INET6:
inet_ntop(AF_INET6,
- GET_VALUE(inp, index).ui128,
+ ikey_get_u128(&inp[index]),
tmp, sizeof(tmp));
break;
case AF_INET:
- inet_ntop(AF_INET,
- &GET_VALUE(inp, index).ui32,
- tmp, sizeof(tmp));
+ ip = ikey_get_u32(&inp[index]);
+ inet_ntop(AF_INET, &ip, tmp, sizeof(tmp));
break;
default:
/* TODO error handling */
/* Iter on all addr fields */
for (i = START_KEY; i <= MAX_KEY; i++) {
if (pp_is_valid(inp, i)) {
- ret[i-START_KEY].u.value.ptr = ip2str(inp, i);
- ret[i-START_KEY].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[i-START_KEY], ip2str(inp, i));
}
}
{
struct ulogd_key *inp = pi->input.keys;
if (pp_is_valid(inp, KEY_CT_MARK)) {
- if ((GET_VALUE(inp, KEY_CT_MARK).ui32 &
+ if ((ikey_get_u32(&inp[KEY_CT_MARK]) &
pi->config_kset->ces[MARK_MASK].u.value) !=
(u_int32_t) pi->config_kset->ces[MARK_MARK].u.value
) {
return ULOGD_IRET_STOP;
}
} else if (pp_is_valid(inp, KEY_OOB_MARK)) {
- if ((GET_VALUE(inp, KEY_OOB_MARK).ui32 &
+ if ((ikey_get_u32(&inp[KEY_OOB_MARK]) &
pi->config_kset->ces[MARK_MASK].u.value) !=
(u_int32_t) pi->config_kset->ces[MARK_MARK].u.value
) {
static char buf[4096];
printflow_print(inp, buf);
- ret[0].u.value.ptr = buf;
- ret[0].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[0], buf);
return ULOGD_IRET_OK;
}
static char buf[4096];
printpkt_print(inp, buf);
- ret[0].u.value.ptr = buf;
- ret[0].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[0], buf);
return ULOGD_IRET_OK;
}
}
if (len) {
- ret[0].u.value.ptr = (char *) malloc(len+1);
- ret[0].flags |= ULOGD_RETF_VALID;
- if (!ret[0].u.value.ptr) {
- ulogd_log(ULOGD_ERROR, "OOM (size=%u)\n", len);
+ char *ptr;
+ ptr = (char *) malloc(len+1);
+ if (!ptr)
return ULOGD_IRET_ERR;
- }
- strncpy((char *) ret[0].u.value.ptr, (char *)begp, len);
- *((char *)ret[0].u.value.ptr + len) = '\0';
+ strncpy(ptr, (char *)begp, len);
+ ptr[len] = '\0';
+ okey_set_ptr(&ret[0], ptr);
}
if (pw_len) {
- ret[1].u.value.ptr = (char *) malloc(pw_len+1);
- ret[1].flags |= ULOGD_RETF_VALID;
- if (!ret[1].u.value.ptr){
- ulogd_log(ULOGD_ERROR, "OOM (size=%u)\n", pw_len);
+ char *ptr;
+ ptr = (char *) malloc(pw_len+1);
+ if (!ptr)
return ULOGD_IRET_ERR;
- }
- strncpy((char *)ret[1].u.value.ptr, (char *)pw_begp, pw_len);
- *((char *)ret[1].u.value.ptr + pw_len) = '\0';
-
+ strncpy(ptr, (char *)pw_begp, pw_len);
+ ptr[pw_len] = '\0';
+ okey_set_ptr(&ret[1], ptr);
}
return ULOGD_IRET_OK;
}
#include <stdio.h>
#include <signal.h> /* need this because of extension-sighandler */
#include <sys/types.h>
+#include <string.h>
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
unsigned int type;
};
+static inline void okey_set_b(struct ulogd_key *key, u_int8_t value)
+{
+ key->u.value.b = value;
+ key->flags |= ULOGD_RETF_VALID;
+}
+
+static inline void okey_set_u8(struct ulogd_key *key, u_int8_t value)
+{
+ key->u.value.ui8 = value;
+ key->flags |= ULOGD_RETF_VALID;
+}
+
+static inline void okey_set_u16(struct ulogd_key *key, u_int16_t value)
+{
+ key->u.value.ui16 = value;
+ key->flags |= ULOGD_RETF_VALID;
+}
+
+static inline void okey_set_u32(struct ulogd_key *key, u_int32_t value)
+{
+ key->u.value.ui32 = value;
+ key->flags |= ULOGD_RETF_VALID;
+}
+
+static inline void okey_set_u128(struct ulogd_key *key, const void *value)
+{
+ memcpy(key->u.value.ui128, value, 16);
+ key->flags |= ULOGD_RETF_VALID;
+}
+
+static inline void okey_set_ptr(struct ulogd_key *key, void *value)
+{
+ key->u.value.ptr = value;
+ key->flags |= ULOGD_RETF_VALID;
+}
+
+static inline u_int8_t ikey_get_u8(struct ulogd_key *key)
+{
+ return key->u.source->u.value.ui8;
+}
+
+static inline u_int16_t ikey_get_u16(struct ulogd_key *key)
+{
+ return key->u.source->u.value.ui16;
+}
+
+static inline u_int32_t ikey_get_u32(struct ulogd_key *key)
+{
+ return key->u.source->u.value.ui32;
+}
+
+#define ikey_get_u128 ikey_get_ptr
+
+static inline void *ikey_get_ptr(struct ulogd_key *key)
+{
+ return key->u.source->u.value.ptr;
+}
+
struct ulogd_pluginstance_stack;
struct ulogd_pluginstance;
struct ulogd_plugin {
#define IS_NEEDED(x) (x.flags & ULOGD_RETF_NEEDED)
#define SET_NEEDED(x) (x.flags |= ULOGD_RETF_NEEDED)
-#define GET_VALUE(res, x) (res[x].u.source->u.value)
#define GET_FLAGS(res, x) (res[x].u.source->flags)
#define pp_is_valid(res, x) \
(res[x].u.source && (GET_FLAGS(res, x) & ULOGD_RETF_VALID))
{
struct ulogd_key *ret = upi->output.keys;
- ret[NFCT_CT_EVENT].u.value.ui32 = type;
- ret[NFCT_CT_EVENT].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_OOB_FAMILY].u.value.ui8 = nfct_get_attr_u8(ct, ATTR_L3PROTO);
- ret[NFCT_OOB_FAMILY].flags |= ULOGD_RETF_VALID;
- /* FIXME */
- ret[NFCT_OOB_PROTOCOL].u.value.ui8 = 0;
- ret[NFCT_OOB_PROTOCOL].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[NFCT_CT_EVENT], type);
+ okey_set_u8(&ret[NFCT_OOB_FAMILY], nfct_get_attr_u8(ct, ATTR_L3PROTO));
+ okey_set_u8(&ret[NFCT_OOB_PROTOCOL], 0); /* FIXME */
switch (nfct_get_attr_u8(ct, ATTR_L3PROTO)) {
case AF_INET:
- ret[NFCT_ORIG_IP_SADDR].u.value.ui32 =
- nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_SRC);
- ret[NFCT_ORIG_IP_SADDR].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_ORIG_IP_DADDR].u.value.ui32 =
- nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_DST);
- ret[NFCT_ORIG_IP_DADDR].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_REPLY_IP_SADDR].u.value.ui32 =
- nfct_get_attr_u32(ct, ATTR_REPL_IPV4_SRC);
- ret[NFCT_REPLY_IP_SADDR].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_REPLY_IP_DADDR].u.value.ui32 =
- nfct_get_attr_u32(ct, ATTR_REPL_IPV4_DST);
- ret[NFCT_REPLY_IP_DADDR].flags |= ULOGD_RETF_VALID;
-
+ okey_set_u32(&ret[NFCT_ORIG_IP_SADDR],
+ nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_SRC));
+ okey_set_u32(&ret[NFCT_ORIG_IP_DADDR],
+ nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_DST));
+ okey_set_u32(&ret[NFCT_REPLY_IP_SADDR],
+ nfct_get_attr_u32(ct, ATTR_REPL_IPV4_SRC));
+ okey_set_u32(&ret[NFCT_REPLY_IP_DADDR],
+ nfct_get_attr_u32(ct, ATTR_REPL_IPV4_DST));
break;
case AF_INET6:
- memcpy(ret[NFCT_ORIG_IP_SADDR].u.value.ui128,
- nfct_get_attr(ct, ATTR_ORIG_IPV6_SRC),
- sizeof(int32_t) * 4);
- ret[NFCT_ORIG_IP_SADDR].flags |= ULOGD_RETF_VALID;
-
- memcpy(ret[NFCT_ORIG_IP_DADDR].u.value.ui128,
- nfct_get_attr(ct, ATTR_ORIG_IPV6_DST),
- sizeof(int32_t) * 4);
- ret[NFCT_ORIG_IP_DADDR].flags |= ULOGD_RETF_VALID;
-
- memcpy(ret[NFCT_REPLY_IP_SADDR].u.value.ui128,
- nfct_get_attr(ct, ATTR_REPL_IPV6_SRC),
- sizeof(int32_t) * 4);
- ret[NFCT_REPLY_IP_SADDR].flags |= ULOGD_RETF_VALID;
-
- memcpy(ret[NFCT_REPLY_IP_DADDR].u.value.ui128,
- nfct_get_attr(ct, ATTR_REPL_IPV6_DST),
- sizeof(int32_t) * 4);
- ret[NFCT_REPLY_IP_DADDR].flags |= ULOGD_RETF_VALID;
-
+ okey_set_u128(&ret[NFCT_ORIG_IP_SADDR],
+ nfct_get_attr(ct, ATTR_ORIG_IPV6_SRC));
+ okey_set_u128(&ret[NFCT_ORIG_IP_DADDR],
+ nfct_get_attr(ct, ATTR_ORIG_IPV6_DST));
+ okey_set_u128(&ret[NFCT_REPLY_IP_SADDR],
+ nfct_get_attr(ct, ATTR_REPL_IPV6_SRC));
+ okey_set_u128(&ret[NFCT_REPLY_IP_DADDR],
+ nfct_get_attr(ct, ATTR_REPL_IPV6_DST));
break;
default:
ulogd_log(ULOGD_NOTICE, "Unknown protocol family (%d)\n",
nfct_get_attr_u8(ct, ATTR_L3PROTO));
}
- ret[NFCT_ORIG_IP_PROTOCOL].u.value.ui8 =
- nfct_get_attr_u8(ct, ATTR_ORIG_L4PROTO);
- ret[NFCT_ORIG_IP_PROTOCOL].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_REPLY_IP_PROTOCOL].u.value.ui8 =
- nfct_get_attr_u8(ct, ATTR_REPL_L4PROTO);
- ret[NFCT_REPLY_IP_PROTOCOL].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[NFCT_ORIG_IP_PROTOCOL],
+ nfct_get_attr_u8(ct, ATTR_ORIG_L4PROTO));
+ okey_set_u8(&ret[NFCT_REPLY_IP_PROTOCOL],
+ nfct_get_attr_u8(ct, ATTR_REPL_L4PROTO));
switch (nfct_get_attr_u8(ct, ATTR_ORIG_L4PROTO)) {
case IPPROTO_TCP:
case IPPROTO_UDPLITE:
case IPPROTO_SCTP:
case IPPROTO_DCCP:
- ret[NFCT_ORIG_L4_SPORT].u.value.ui16 =
- htons(nfct_get_attr_u16(ct, ATTR_ORIG_PORT_SRC));
- ret[NFCT_ORIG_L4_SPORT].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_ORIG_L4_DPORT].u.value.ui16 =
- htons(nfct_get_attr_u16(ct, ATTR_ORIG_PORT_DST));
- ret[NFCT_ORIG_L4_DPORT].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[NFCT_ORIG_L4_SPORT],
+ htons(nfct_get_attr_u16(ct, ATTR_ORIG_PORT_SRC)));
+ okey_set_u16(&ret[NFCT_ORIG_L4_DPORT],
+ htons(nfct_get_attr_u16(ct, ATTR_ORIG_PORT_DST)));
break;
case IPPROTO_ICMP:
- ret[NFCT_ICMP_CODE].u.value.ui8 =
- nfct_get_attr_u8(ct, ATTR_ICMP_CODE);
- ret[NFCT_ICMP_CODE].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_ICMP_TYPE].u.value.ui8 =
- nfct_get_attr_u8(ct, ATTR_ICMP_TYPE);
- ret[NFCT_ICMP_TYPE].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[NFCT_ICMP_CODE],
+ nfct_get_attr_u8(ct, ATTR_ICMP_CODE));
+ okey_set_u16(&ret[NFCT_ICMP_TYPE],
+ nfct_get_attr_u8(ct, ATTR_ICMP_TYPE));
break;
}
case IPPROTO_UDPLITE:
case IPPROTO_SCTP:
case IPPROTO_DCCP:
- ret[NFCT_REPLY_L4_SPORT].u.value.ui16 =
- htons(nfct_get_attr_u16(ct, ATTR_REPL_PORT_SRC));
- ret[NFCT_REPLY_L4_SPORT].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_REPLY_L4_DPORT].u.value.ui16 =
- htons(nfct_get_attr_u16(ct, ATTR_REPL_PORT_DST));
- ret[NFCT_REPLY_L4_DPORT].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[NFCT_REPLY_L4_SPORT],
+ htons(nfct_get_attr_u16(ct, ATTR_REPL_PORT_SRC)));
+ okey_set_u16(&ret[NFCT_REPLY_L4_DPORT],
+ htons(nfct_get_attr_u16(ct, ATTR_REPL_PORT_DST)));
}
- ret[NFCT_ORIG_RAW_PKTLEN].u.value.ui32 =
- nfct_get_attr_u32(ct, ATTR_ORIG_COUNTER_BYTES);
- ret[NFCT_ORIG_RAW_PKTLEN].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_ORIG_RAW_PKTCOUNT].u.value.ui32 =
- nfct_get_attr_u32(ct, ATTR_ORIG_COUNTER_PACKETS);
- ret[NFCT_ORIG_RAW_PKTCOUNT].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_REPLY_RAW_PKTLEN].u.value.ui32 =
- nfct_get_attr_u32(ct, ATTR_REPL_COUNTER_BYTES);;
- ret[NFCT_REPLY_RAW_PKTLEN].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[NFCT_ORIG_RAW_PKTLEN],
+ nfct_get_attr_u32(ct, ATTR_ORIG_COUNTER_BYTES));
+ okey_set_u32(&ret[NFCT_ORIG_RAW_PKTCOUNT],
+ nfct_get_attr_u32(ct, ATTR_ORIG_COUNTER_PACKETS));
+ okey_set_u32(&ret[NFCT_REPLY_RAW_PKTLEN],
+ nfct_get_attr_u32(ct, ATTR_REPL_COUNTER_BYTES));
+ okey_set_u32(&ret[NFCT_REPLY_RAW_PKTCOUNT],
+ nfct_get_attr_u32(ct, ATTR_REPL_COUNTER_PACKETS));
- ret[NFCT_REPLY_RAW_PKTCOUNT].u.value.ui32 =
- nfct_get_attr_u32(ct, ATTR_REPL_COUNTER_PACKETS);
- ret[NFCT_REPLY_RAW_PKTCOUNT].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_CT_MARK].u.value.ui32 = nfct_get_attr_u32(ct, ATTR_MARK);
- ret[NFCT_CT_MARK].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_CT_ID].u.value.ui32 = nfct_get_attr_u32(ct, ATTR_ID);
- ret[NFCT_CT_ID].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[NFCT_CT_MARK], nfct_get_attr_u32(ct, ATTR_MARK));
+ okey_set_u32(&ret[NFCT_CT_ID], nfct_get_attr_u32(ct, ATTR_ID));
if (ts) {
if (ts->time[START].tv_sec) {
- ret[NFCT_FLOW_START_SEC].u.value.ui32 =
- ts->time[START].tv_sec;
- ret[NFCT_FLOW_START_SEC].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_FLOW_START_USEC].u.value.ui32 =
- ts->time[START].tv_usec;
- ret[NFCT_FLOW_START_USEC].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[NFCT_FLOW_START_SEC],
+ ts->time[START].tv_sec);
+ okey_set_u32(&ret[NFCT_FLOW_START_USEC],
+ ts->time[START].tv_usec);
}
if (ts->time[STOP].tv_sec) {
- ret[NFCT_FLOW_END_SEC].u.value.ui32 =
- ts->time[STOP].tv_sec;
- ret[NFCT_FLOW_END_SEC].flags |= ULOGD_RETF_VALID;
-
- ret[NFCT_FLOW_END_USEC].u.value.ui32 =
- ts->time[STOP].tv_usec;
- ret[NFCT_FLOW_END_USEC].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[NFCT_FLOW_END_SEC],
+ ts->time[STOP].tv_sec);
+ okey_set_u32(&ret[NFCT_FLOW_END_USEC],
+ ts->time[STOP].tv_usec);
}
}
u_int32_t uid;
u_int32_t gid;
- ret[NFLOG_KEY_OOB_FAMILY].u.value.ui8 = af_ce(upi->config_kset).u.value;
- ret[NFLOG_KEY_OOB_FAMILY].flags |= ULOGD_RETF_VALID;
-
- ret[NFLOG_KEY_RAW_LABEL].u.value.ui8 =
- label_ce(upi->config_kset).u.value;
- ret[NFLOG_KEY_RAW_LABEL].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[NFLOG_KEY_OOB_FAMILY],
+ af_ce(upi->config_kset).u.value);
+ okey_set_u8(&ret[NFLOG_KEY_RAW_LABEL],
+ label_ce(upi->config_kset).u.value);
if (ph) {
/* FIXME */
- ret[NFLOG_KEY_OOB_HOOK].u.value.ui8 = ph->hook;
- ret[NFLOG_KEY_OOB_HOOK].flags |= ULOGD_RETF_VALID;
- ret[NFLOG_KEY_OOB_PROTOCOL].u.value.ui16 =
- ntohs(ph->hw_protocol);
- ret[NFLOG_KEY_OOB_PROTOCOL].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[NFLOG_KEY_OOB_HOOK], ph->hook);
+ okey_set_u16(&ret[NFLOG_KEY_OOB_PROTOCOL],
+ ntohs(ph->hw_protocol));
}
if (nflog_get_msg_packet_hwhdrlen(ldata)) {
- ret[NFLOG_KEY_RAW_MAC].u.value.ptr =
- nflog_get_msg_packet_hwhdr(ldata);
- ret[NFLOG_KEY_RAW_MAC].flags |= ULOGD_RETF_VALID;
- ret[NFLOG_KEY_RAW_MAC_LEN].u.value.ui16 =
- nflog_get_msg_packet_hwhdrlen(ldata);
- ret[NFLOG_KEY_RAW_MAC_LEN].flags |= ULOGD_RETF_VALID;
- ret[NFLOG_KEY_RAW_TYPE].u.value.ui16 =
- nflog_get_hwtype(ldata);
- ret[NFLOG_KEY_RAW_TYPE].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[NFLOG_KEY_RAW_MAC],
+ nflog_get_msg_packet_hwhdr(ldata));
+ okey_set_u16(&ret[NFLOG_KEY_RAW_MAC_LEN],
+ nflog_get_msg_packet_hwhdrlen(ldata));
+ okey_set_u16(&ret[NFLOG_KEY_RAW_TYPE], nflog_get_hwtype(ldata));
}
if (hw) {
- ret[NFLOG_KEY_RAW_MAC_SADDR].u.value.ptr = hw->hw_addr;
- ret[NFLOG_KEY_RAW_MAC_SADDR].flags |= ULOGD_RETF_VALID;
- ret[NFLOG_KEY_RAW_MAC_ADDRLEN].u.value.ui16 =
- ntohs(hw->hw_addrlen);
- ret[NFLOG_KEY_RAW_MAC_ADDRLEN].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[NFLOG_KEY_RAW_MAC_SADDR], hw->hw_addr);
+ okey_set_u16(&ret[NFLOG_KEY_RAW_MAC_ADDRLEN],
+ ntohs(hw->hw_addrlen));
}
if (payload_len >= 0) {
/* include pointer to raw packet */
- ret[NFLOG_KEY_RAW_PCKT].u.value.ptr = payload;
- ret[NFLOG_KEY_RAW_PCKT].flags |= ULOGD_RETF_VALID;
-
- ret[NFLOG_KEY_RAW_PCKTLEN].u.value.ui32 = payload_len;
- ret[NFLOG_KEY_RAW_PCKTLEN].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[NFLOG_KEY_RAW_PCKT], payload);
+ okey_set_u32(&ret[NFLOG_KEY_RAW_PCKTLEN], payload_len);
}
/* number of packets */
- ret[NFLOG_KEY_RAW_PCKTCOUNT].u.value.ui32 = 1;
- ret[NFLOG_KEY_RAW_PCKTCOUNT].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[NFLOG_KEY_RAW_PCKTCOUNT], 1);
- if (prefix) {
- ret[NFLOG_KEY_OOB_PREFIX].u.value.ptr = prefix;
- ret[NFLOG_KEY_OOB_PREFIX].flags |= ULOGD_RETF_VALID;
- }
+ if (prefix)
+ okey_set_ptr(&ret[NFLOG_KEY_OOB_PREFIX], prefix);
/* god knows why timestamp_usec contains crap if timestamp_sec
* == 0 if (pkt->timestamp_sec || pkt->timestamp_usec) { */
gettimeofday(&ts, NULL);
/* FIXME: convert endianness */
- ret[NFLOG_KEY_OOB_TIME_SEC].u.value.ui32 = ts.tv_sec & 0xffffffff;
- ret[NFLOG_KEY_OOB_TIME_SEC].flags |= ULOGD_RETF_VALID;
- ret[NFLOG_KEY_OOB_TIME_USEC].u.value.ui32 = ts.tv_usec & 0xffffffff;
- ret[NFLOG_KEY_OOB_TIME_USEC].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[NFLOG_KEY_OOB_TIME_SEC], ts.tv_sec & 0xffffffff);
+ okey_set_u32(&ret[NFLOG_KEY_OOB_TIME_USEC], ts.tv_usec & 0xffffffff);
- ret[NFLOG_KEY_OOB_MARK].u.value.ui32 = mark;
- ret[NFLOG_KEY_OOB_MARK].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[NFLOG_KEY_OOB_MARK], mark);
- if (indev > 0) {
- ret[NFLOG_KEY_OOB_IFINDEX_IN].u.value.ui32 = indev;
- ret[NFLOG_KEY_OOB_IFINDEX_IN].flags |= ULOGD_RETF_VALID;
- }
+ if (indev > 0)
+ okey_set_u32(&ret[NFLOG_KEY_OOB_IFINDEX_IN], indev);
- if (outdev > 0) {
- ret[NFLOG_KEY_OOB_IFINDEX_OUT].u.value.ui32 = outdev;
- ret[NFLOG_KEY_OOB_IFINDEX_OUT].flags |= ULOGD_RETF_VALID;
- }
+ if (outdev > 0)
+ okey_set_u32(&ret[NFLOG_KEY_OOB_IFINDEX_OUT], outdev);
- if (nflog_get_uid(ldata, &uid) == 0) {
- ret[NFLOG_KEY_OOB_UID].u.value.ui32 = uid;
- ret[NFLOG_KEY_OOB_UID].flags |= ULOGD_RETF_VALID;
- }
- if (nflog_get_gid(ldata, &gid) == 0) {
- ret[NFLOG_KEY_OOB_GID].u.value.ui32 = gid;
- ret[NFLOG_KEY_OOB_GID].flags |= ULOGD_RETF_VALID;
- }
+ if (nflog_get_uid(ldata, &uid) == 0)
+ okey_set_u32(&ret[NFLOG_KEY_OOB_UID], uid);
+ if (nflog_get_gid(ldata, &gid) == 0)
+ okey_set_u32(&ret[NFLOG_KEY_OOB_GID], gid);
+ if (nflog_get_seq(ldata, &seq) == 0)
+ okey_set_u32(&ret[NFLOG_KEY_OOB_SEQ_LOCAL], seq);
+ if (nflog_get_seq_global(ldata, &seq) == 0)
+ okey_set_u32(&ret[NFLOG_KEY_OOB_SEQ_GLOBAL], seq);
- if (nflog_get_seq(ldata, &seq) == 0) {
- ret[NFLOG_KEY_OOB_SEQ_LOCAL].u.value.ui32 = seq;
- ret[NFLOG_KEY_OOB_SEQ_LOCAL].flags |= ULOGD_RETF_VALID;
- }
- if (nflog_get_seq_global(ldata, &seq) == 0) {
- ret[NFLOG_KEY_OOB_SEQ_GLOBAL].u.value.ui32 = seq;
- ret[NFLOG_KEY_OOB_SEQ_GLOBAL].flags |= ULOGD_RETF_VALID;
- }
ulogd_propagate_results(upi);
return 0;
}
struct ulogd_key *ret = ip->output.keys;
if (pkt->mac_len) {
- ret[ULOG_KEY_RAW_MAC].u.value.ptr = pkt->mac;
- ret[ULOG_KEY_RAW_MAC].flags |= ULOGD_RETF_VALID;
- ret[ULOG_KEY_RAW_MAC_LEN].u.value.ui16 = pkt->mac_len;
- ret[ULOG_KEY_RAW_MAC_LEN].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[ULOG_KEY_RAW_MAC], pkt->mac);
+ okey_set_u16(&ret[ULOG_KEY_RAW_MAC_LEN], pkt->mac_len);
}
- ret[ULOG_KEY_RAW_LABEL].u.value.ui8 = ip->config_kset->ces[3].u.value;
- ret[ULOG_KEY_RAW_LABEL].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[ULOG_KEY_RAW_LABEL], ip->config_kset->ces[3].u.value);
/* include pointer to raw ipv4 packet */
- ret[ULOG_KEY_RAW_PCKT].u.value.ptr = pkt->payload;
- ret[ULOG_KEY_RAW_PCKT].flags |= ULOGD_RETF_VALID;
- ret[ULOG_KEY_RAW_PCKTLEN].u.value.ui32 = pkt->data_len;
- ret[ULOG_KEY_RAW_PCKTLEN].flags |= ULOGD_RETF_VALID;
- ret[ULOG_KEY_RAW_PCKTCOUNT].u.value.ui32 = 1;
- ret[ULOG_KEY_RAW_PCKTCOUNT].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[ULOG_KEY_RAW_PCKT], pkt->payload);
+ okey_set_u32(&ret[ULOG_KEY_RAW_PCKTLEN], pkt->data_len);
+ okey_set_u32(&ret[ULOG_KEY_RAW_PCKTCOUNT], 1);
- ret[ULOG_KEY_OOB_PREFIX].u.value.ptr = pkt->prefix;
- ret[ULOG_KEY_OOB_PREFIX].flags |= ULOGD_RETF_VALID;
+ okey_set_ptr(&ret[ULOG_KEY_OOB_PREFIX], pkt->prefix);
/* god knows why timestamp_usec contains crap if timestamp_sec == 0
* if (pkt->timestamp_sec || pkt->timestamp_usec) { */
if (pkt->timestamp_sec) {
- ret[ULOG_KEY_OOB_TIME_SEC].u.value.ui32 = pkt->timestamp_sec;
- ret[ULOG_KEY_OOB_TIME_SEC].flags |= ULOGD_RETF_VALID;
- ret[ULOG_KEY_OOB_TIME_USEC].u.value.ui32 = pkt->timestamp_usec;
- ret[ULOG_KEY_OOB_TIME_USEC].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[ULOG_KEY_OOB_TIME_SEC], pkt->timestamp_sec);
+ okey_set_u32(&ret[ULOG_KEY_OOB_TIME_USEC], pkt->timestamp_usec);
} else {
ret[ULOG_KEY_OOB_TIME_SEC].flags &= ~ULOGD_RETF_VALID;
ret[ULOG_KEY_OOB_TIME_USEC].flags &= ~ULOGD_RETF_VALID;
}
- ret[ULOG_KEY_OOB_MARK].u.value.ui32 = pkt->mark;
- ret[ULOG_KEY_OOB_MARK].flags |= ULOGD_RETF_VALID;
- ret[ULOG_KEY_OOB_IN].u.value.ptr = pkt->indev_name;
- ret[ULOG_KEY_OOB_IN].flags |= ULOGD_RETF_VALID;
- ret[ULOG_KEY_OOB_OUT].u.value.ptr = pkt->outdev_name;
- ret[ULOG_KEY_OOB_OUT].flags |= ULOGD_RETF_VALID;
+ okey_set_u32(&ret[ULOG_KEY_OOB_MARK], pkt->mark);
+ okey_set_ptr(&ret[ULOG_KEY_OOB_IN], pkt->indev_name);
+ okey_set_ptr(&ret[ULOG_KEY_OOB_OUT], pkt->outdev_name);
- ret[ULOG_KEY_OOB_HOOK].u.value.ui8 = pkt->hook;
- ret[ULOG_KEY_OOB_HOOK].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[ULOG_KEY_OOB_HOOK], pkt->hook);
/* ULOG is IPv4 only */
- ret[ULOG_KEY_OOB_FAMILY].u.value.ui8 = AF_INET;
- ret[ULOG_KEY_OOB_FAMILY].flags |= ULOGD_RETF_VALID;
+ okey_set_u8(&ret[ULOG_KEY_OOB_FAMILY], AF_INET);
/* Undef in ULOG but necessary */
- ret[ULOG_KEY_OOB_PROTOCOL].u.value.ui16 = 0;
- ret[ULOG_KEY_OOB_PROTOCOL].flags |= ULOGD_RETF_VALID;
+ okey_set_u16(&ret[ULOG_KEY_OOB_PROTOCOL], 0);
ulogd_propagate_results(ip);
return 0;
{ .name = "oob.time.usec" },
};
-#define GET_VALUE(res, x) (res[x].u.source->u.value)
#define GET_FLAGS(res, x) (res[x].u.source->flags)
static int interp_pcap(struct ulogd_pluginstance *upi)
struct ulogd_key *res = upi->input.keys;
struct pcap_sf_pkthdr pchdr;
- pchdr.caplen = GET_VALUE(res, 2).ui32;
- pchdr.len = GET_VALUE(res, 2).ui32;
+ pchdr.caplen = ikey_get_u32(&res[2]);
+ pchdr.len = ikey_get_u32(&res[2]);
if (GET_FLAGS(res, 3) & ULOGD_RETF_VALID
&& GET_FLAGS(res, 4) & ULOGD_RETF_VALID) {
- pchdr.ts.tv_sec = GET_VALUE(res, 3).ui32;
- pchdr.ts.tv_usec = GET_VALUE(res, 4).ui32;
+ pchdr.ts.tv_sec = ikey_get_u32(&res[3]);
+ pchdr.ts.tv_usec = ikey_get_u32(&res[4]);
} else {
/* use current system time */
struct timeval tv;
strerror(errno));
return ULOGD_IRET_ERR;
}
- if (fwrite(GET_VALUE(res, 0).ptr, pchdr.caplen, 1, pi->of) != 1) {
+ if (fwrite(ikey_get_ptr(&res[0]), pchdr.caplen, 1, pi->of) != 1) {
ulogd_log(ULOGD_ERROR, "Error during write: %s\n",
strerror(errno));
return ULOGD_IRET_ERR;
/* try to be as close to nacct as possible. Instead of nacct's
'timestamp' value use 'flow.end.sec' */
- if (GET_VALUE(inp, KEY_IP_PROTO).ui8 == IPPROTO_ICMP) {
+ if (ikey_get_u8(&inp[KEY_IP_PROTO]) == IPPROTO_ICMP) {
snprintf(buf, sizeof(buf),
"%u\t%u\t%s\t%u\t%s\t%u\t%u\t%u",
- GET_VALUE(inp, KEY_FLOW_END).ui32,
- GET_VALUE(inp, KEY_IP_PROTO).ui8,
- (char *) GET_VALUE(inp, KEY_IP_SADDR).ptr,
- GET_VALUE(inp, KEY_ICMP_TYPE).ui8,
- (char *) GET_VALUE(inp, KEY_IP_DADDR).ptr,
- GET_VALUE(inp, KEY_ICMP_CODE).ui8,
- GET_VALUE(inp, KEY_RAW_PKTCNT).ui32,
- GET_VALUE(inp, KEY_RAW_PKTLEN).ui32);
+ ikey_get_u32(&inp[KEY_FLOW_END]),
+ ikey_get_u8(&inp[KEY_IP_PROTO]),
+ (char *) ikey_get_ptr(&inp[KEY_IP_SADDR]),
+ ikey_get_u8(&inp[KEY_ICMP_TYPE]),
+ (char *) ikey_get_ptr(&inp[KEY_IP_DADDR]),
+ ikey_get_u8(&inp[KEY_ICMP_CODE]),
+ ikey_get_u32(&inp[KEY_RAW_PKTCNT]),
+ ikey_get_u32(&inp[KEY_RAW_PKTLEN]));
} else {
snprintf(buf, sizeof(buf),
"%u\t%u\t%s\t%u\t%s\t%u\t%u\t%u",
- GET_VALUE(inp, KEY_FLOW_END).ui32,
- GET_VALUE(inp, KEY_IP_PROTO).ui8,
- (char *) GET_VALUE(inp, KEY_IP_SADDR).ptr,
- GET_VALUE(inp, KEY_L4_SPORT).ui16,
- (char *) GET_VALUE(inp, KEY_IP_DADDR).ptr,
- GET_VALUE(inp, KEY_L4_DPORT).ui16,
- GET_VALUE(inp, KEY_RAW_PKTCNT).ui32,
- GET_VALUE(inp, KEY_RAW_PKTLEN).ui32);
+ ikey_get_u32(&inp[KEY_FLOW_END]),
+ ikey_get_u8(&inp[KEY_IP_PROTO]),
+ (char *) ikey_get_ptr(&inp[KEY_IP_SADDR]),
+ ikey_get_u16(&inp[KEY_L4_SPORT]),
+ (char *) ikey_get_ptr(&inp[KEY_IP_DADDR]),
+ ikey_get_u16(&inp[KEY_L4_DPORT]),
+ ikey_get_u32(&inp[KEY_RAW_PKTCNT]),
+ ikey_get_u32(&inp[KEY_RAW_PKTLEN]));
}
fprintf(priv->of, "%s\n", buf);
#define pp_print(buf_cur, label, res, x, type) \
if (pp_is_valid(res, x)) \
- buf_cur += sprintf(buf_cur, label"=%u ", GET_VALUE(res, x).type);
+ buf_cur += sprintf(buf_cur, label"=%u ", ikey_get_##type(&res[x]));
int printflow_print(struct ulogd_key *res, char *buf)
{
char *buf_cur = buf;
if (pp_is_valid(res, PRINTFLOW_EVENT_TYPE)) {
- switch (GET_VALUE(res, PRINTFLOW_EVENT_TYPE).ui32) {
+ switch (ikey_get_u32(&res[PRINTFLOW_EVENT_TYPE])) {
case 1:
buf_cur += sprintf(buf_cur, "[NEW] ");
break;
if (pp_is_valid(res, PRINTFLOW_ORIG_IP_SADDR))
buf_cur += sprintf(buf_cur,
"SRC=%s ",
- (char *) GET_VALUE(res, PRINTFLOW_ORIG_IP_SADDR).ptr);
+ (char *) ikey_get_ptr(&res[PRINTFLOW_ORIG_IP_SADDR]));
if (pp_is_valid(res, PRINTFLOW_ORIG_IP_DADDR))
buf_cur += sprintf(buf_cur,
"DST=%s ",
- (char *) GET_VALUE(res, PRINTFLOW_ORIG_IP_DADDR).ptr);
+ (char *) ikey_get_ptr(&res[PRINTFLOW_ORIG_IP_DADDR]));
if (!pp_is_valid(res, PRINTFLOW_ORIG_IP_PROTOCOL))
goto orig_out;
- switch (GET_VALUE(res, PRINTFLOW_ORIG_IP_PROTOCOL).ui8) {
+ switch (ikey_get_u8(&res[PRINTFLOW_ORIG_IP_PROTOCOL])) {
case IPPROTO_TCP:
buf_cur += sprintf(buf_cur, "PROTO=TCP ");
- pp_print(buf_cur, "SPT", res, PRINTFLOW_ORIG_L4_SPORT, ui16);
- pp_print(buf_cur, "DPT", res, PRINTFLOW_ORIG_L4_DPORT, ui16);
+ pp_print(buf_cur, "SPT", res, PRINTFLOW_ORIG_L4_SPORT, u16);
+ pp_print(buf_cur, "DPT", res, PRINTFLOW_ORIG_L4_DPORT, u16);
break;
case IPPROTO_UDP:
buf_cur += sprintf(buf_cur, "PROTO=UDP ");
- pp_print(buf_cur, "SPT", res, PRINTFLOW_ORIG_L4_SPORT, ui16);
- pp_print(buf_cur, "DPT", res, PRINTFLOW_ORIG_L4_DPORT, ui16);
+ pp_print(buf_cur, "SPT", res, PRINTFLOW_ORIG_L4_SPORT, u16);
+ pp_print(buf_cur, "DPT", res, PRINTFLOW_ORIG_L4_DPORT, u16);
break;
case IPPROTO_ICMP:
buf_cur += sprintf(buf_cur, "PROTO=ICMP ");
- pp_print(buf_cur, "TYPE", res, PRINTFLOW_ICMP_CODE, ui8);
- pp_print(buf_cur, "CODE", res, PRINTFLOW_ICMP_TYPE, ui8);
+ pp_print(buf_cur, "TYPE", res, PRINTFLOW_ICMP_CODE, u8);
+ pp_print(buf_cur, "CODE", res, PRINTFLOW_ICMP_TYPE, u8);
break;
case IPPROTO_ESP:
break;
default:
- pp_print(buf_cur, "PROTO", res, PRINTFLOW_ORIG_IP_PROTOCOL, ui8);
+ pp_print(buf_cur, "PROTO", res, PRINTFLOW_ORIG_IP_PROTOCOL, u8);
break;
}
orig_out:
- pp_print(buf_cur, "PKTS", res, PRINTFLOW_ORIG_RAW_PKTCOUNT, ui32);
- pp_print(buf_cur, "BYTES", res, PRINTFLOW_ORIG_RAW_PKTLEN, ui32);
+ pp_print(buf_cur, "PKTS", res, PRINTFLOW_ORIG_RAW_PKTCOUNT, u32);
+ pp_print(buf_cur, "BYTES", res, PRINTFLOW_ORIG_RAW_PKTLEN, u32);
buf_cur += sprintf(buf_cur, ", REPLY: ");
if (pp_is_valid(res, PRINTFLOW_REPLY_IP_SADDR))
buf_cur += sprintf(buf_cur,
"SRC=%s ",
- (char *) GET_VALUE(res,PRINTFLOW_REPLY_IP_SADDR).ptr);
+ (char *) ikey_get_ptr(&res[PRINTFLOW_REPLY_IP_SADDR]));
if (pp_is_valid(res, PRINTFLOW_REPLY_IP_DADDR))
buf_cur += sprintf(buf_cur,
"DST=%s ",
- (char *) GET_VALUE(res,PRINTFLOW_REPLY_IP_DADDR).ptr);
+ (char *) ikey_get_ptr(&res[PRINTFLOW_REPLY_IP_DADDR]));
if (!pp_is_valid(res, PRINTFLOW_REPLY_IP_PROTOCOL))
goto reply_out;
- switch (GET_VALUE(res, PRINTFLOW_REPLY_IP_PROTOCOL).ui8) {
+ switch (ikey_get_u8(&res[PRINTFLOW_REPLY_IP_PROTOCOL])) {
case IPPROTO_TCP:
buf_cur += sprintf(buf_cur, "PROTO=TCP ");
- pp_print(buf_cur, "SPT", res, PRINTFLOW_REPLY_L4_SPORT, ui16);
- pp_print(buf_cur, "DPT", res, PRINTFLOW_REPLY_L4_DPORT, ui16);
+ pp_print(buf_cur, "SPT", res, PRINTFLOW_REPLY_L4_SPORT, u16);
+ pp_print(buf_cur, "DPT", res, PRINTFLOW_REPLY_L4_DPORT, u16);
break;
case IPPROTO_UDP:
buf_cur += sprintf(buf_cur, "PROTO=UDP ");
- pp_print(buf_cur, "SPT", res, PRINTFLOW_REPLY_L4_SPORT, ui16);
- pp_print(buf_cur, "DPT", res, PRINTFLOW_REPLY_L4_DPORT, ui16);
+ pp_print(buf_cur, "SPT", res, PRINTFLOW_REPLY_L4_SPORT, u16);
+ pp_print(buf_cur, "DPT", res, PRINTFLOW_REPLY_L4_DPORT, u16);
break;
case IPPROTO_ICMP:
buf_cur += sprintf(buf_cur, "PROTO=ICMP ");
- pp_print(buf_cur, "TYPE", res, PRINTFLOW_ICMP_CODE, ui8);
- pp_print(buf_cur, "CODE", res, PRINTFLOW_ICMP_TYPE, ui8);
+ pp_print(buf_cur, "TYPE", res, PRINTFLOW_ICMP_CODE, u8);
+ pp_print(buf_cur, "CODE", res, PRINTFLOW_ICMP_TYPE, u8);
break;
case IPPROTO_ESP:
break;
default:
- pp_print(buf_cur, "PROTO", res, PRINTFLOW_REPLY_IP_PROTOCOL, ui8);
+ pp_print(buf_cur, "PROTO", res, PRINTFLOW_REPLY_IP_PROTOCOL, u8);
break;
}
reply_out:
- pp_print(buf_cur, "PKTS", res, PRINTFLOW_REPLY_RAW_PKTCOUNT, ui32);
- pp_print(buf_cur, "BYTES", res, PRINTFLOW_REPLY_RAW_PKTLEN, ui32);
+ pp_print(buf_cur, "PKTS", res, PRINTFLOW_REPLY_RAW_PKTCOUNT, u32);
+ pp_print(buf_cur, "BYTES", res, PRINTFLOW_REPLY_RAW_PKTLEN, u32);
strcat(buf_cur, "\n");
return 0;
}
buf_cur += sprintf(buf_cur, "SPT=%u DPT=%u ",
- GET_VALUE(res, KEY_TCP_SPORT).ui16,
- GET_VALUE(res, KEY_TCP_DPORT).ui16);
+ ikey_get_u16(&res[KEY_TCP_SPORT]),
+ ikey_get_u16(&res[KEY_TCP_DPORT]));
/* FIXME: config */
- buf_cur += sprintf(buf_cur, "SEQ=%u ACK=%u ",
- GET_VALUE(res, KEY_TCP_SEQ).ui32,
- GET_VALUE(res, KEY_TCP_ACKSEQ).ui32);
+ buf_cur += sprintf(buf_cur, "SEQ=%u ACK=%u ",
+ ikey_get_u32(&res[KEY_TCP_SEQ]),
+ ikey_get_u32(&res[KEY_TCP_ACKSEQ]));
buf_cur += sprintf(buf_cur, "WINDOW=%u ",
- GET_VALUE(res, KEY_TCP_WINDOW).ui16);
+ ikey_get_u16(&res[KEY_TCP_WINDOW]));
// buf_cur += sprintf(buf_cur, "RES=0x%02x ",
- if (GET_VALUE(res, KEY_TCP_URG).b)
+ if (ikey_get_u8(&res[KEY_TCP_URG]))
buf_cur += sprintf(buf_cur, "URG ");
- if (GET_VALUE(res, KEY_TCP_ACK).b)
+ if (ikey_get_u8(&res[KEY_TCP_ACK]))
buf_cur += sprintf(buf_cur, "ACK ");
- if (GET_VALUE(res, KEY_TCP_PSH).b)
+ if (ikey_get_u8(&res[KEY_TCP_PSH]))
buf_cur += sprintf(buf_cur, "PSH ");
- if (GET_VALUE(res, KEY_TCP_RST).b)
+ if (ikey_get_u8(&res[KEY_TCP_RST]))
buf_cur += sprintf(buf_cur, "RST ");
- if (GET_VALUE(res, KEY_TCP_SYN).b)
+ if (ikey_get_u8(&res[KEY_TCP_SYN]))
buf_cur += sprintf(buf_cur, "SYN ");
- if (GET_VALUE(res, KEY_TCP_FIN).b)
+ if (ikey_get_u8(&res[KEY_TCP_FIN]))
buf_cur += sprintf(buf_cur, "FIN ");
buf_cur += sprintf(buf_cur, "URGP=%u ",
- GET_VALUE(res, KEY_TCP_URGP).ui16);
+ ikey_get_u16(&res[KEY_TCP_URGP]));
break;
}
buf_cur += sprintf(buf_cur, "SPT=%u DPT=%u LEN=%u ",
- GET_VALUE(res, KEY_UDP_SPORT).ui16,
- GET_VALUE(res, KEY_UDP_DPORT).ui16,
- GET_VALUE(res, KEY_UDP_LEN).ui16);
+ ikey_get_u16(&res[KEY_UDP_SPORT]),
+ ikey_get_u16(&res[KEY_UDP_DPORT]),
+ ikey_get_u16(&res[KEY_UDP_LEN]));
break;
case IPPROTO_ESP:
case IPPROTO_AH:
buf_cur += sprintf(buf_cur, "PROTO=%s ",
- GET_VALUE(res, KEY_IP_PROTOCOL).ui8 == IPPROTO_ESP ? "ESP" : "AH");
+ ikey_get_u8(&res[KEY_IP_PROTOCOL]) == IPPROTO_ESP ? "ESP" : "AH");
if (!pp_is_valid(res, KEY_AHESP_SPI)) {
buf_cur += sprintf(buf_cur, "INCOMPLETE");
}
buf_cur += sprintf(buf_cur, "SPI=0x%x ",
- GET_VALUE(res, KEY_AHESP_SPI).ui32);
+ ikey_get_u32(&res[KEY_AHESP_SPI]));
break;
}
{
char *buf_cur = buf;
char tmp[INET_ADDRSTRLEN];
+ u_int32_t paddr;
if (pp_is_valid(res, KEY_IP_SADDR))
buf_cur += sprintf(buf_cur, "SRC=%s ",
- (char *) GET_VALUE(res, KEY_IP_SADDR).ptr);
+ (char *) ikey_get_ptr(&res[KEY_IP_SADDR]));
if (pp_is_valid(res, KEY_IP_DADDR))
buf_cur += sprintf(buf_cur, "DST=%s ",
- (char *) GET_VALUE(res, KEY_IP_DADDR).ptr);
+ (char *) ikey_get_ptr(&res[KEY_IP_DADDR]));
/* FIXME: add pp_is_valid calls to remainder of file */
buf_cur += sprintf(buf_cur,"LEN=%u TOS=%02X PREC=0x%02X TTL=%u ID=%u ",
- GET_VALUE(res, KEY_IP_TOTLEN).ui16,
- GET_VALUE(res, KEY_IP_TOS).ui8 & IPTOS_TOS_MASK,
- GET_VALUE(res, KEY_IP_TOS).ui8 & IPTOS_PREC_MASK,
- GET_VALUE(res, KEY_IP_TTL).ui8,
- GET_VALUE(res, KEY_IP_ID).ui16);
+ ikey_get_u16(&res[KEY_IP_TOTLEN]),
+ ikey_get_u8(&res[KEY_IP_TOS]) & IPTOS_TOS_MASK,
+ ikey_get_u8(&res[KEY_IP_TOS]) & IPTOS_PREC_MASK,
+ ikey_get_u8(&res[KEY_IP_TTL]),
+ ikey_get_u16(&res[KEY_IP_ID]));
- if (GET_VALUE(res, KEY_IP_FRAGOFF).ui16 & IP_RF)
+ if (ikey_get_u16(&res[KEY_IP_FRAGOFF]) & IP_RF)
buf_cur += sprintf(buf_cur, "CE ");
- if (GET_VALUE(res, KEY_IP_FRAGOFF).ui16 & IP_DF)
+ if (ikey_get_u16(&res[KEY_IP_FRAGOFF]) & IP_DF)
buf_cur += sprintf(buf_cur, "DF ");
- if (GET_VALUE(res, KEY_IP_FRAGOFF).ui16 & IP_MF)
+ if (ikey_get_u16(&res[KEY_IP_FRAGOFF]) & IP_MF)
buf_cur += sprintf(buf_cur, "MF ");
- if (GET_VALUE(res, KEY_IP_FRAGOFF).ui16 & IP_OFFMASK)
+ if (ikey_get_u16(&res[KEY_IP_FRAGOFF]) & IP_OFFMASK)
buf_cur += sprintf(buf_cur, "FRAG:%u ",
- GET_VALUE(res, KEY_IP_FRAGOFF).ui16 & IP_OFFMASK);
+ ikey_get_u16(&res[KEY_IP_FRAGOFF]) & IP_OFFMASK);
- switch (GET_VALUE(res, KEY_IP_PROTOCOL).ui8) {
+ switch (ikey_get_u8(&res[KEY_IP_PROTOCOL])) {
case IPPROTO_TCP:
case IPPROTO_UDP:
case IPPROTO_ESP:
case IPPROTO_AH:
buf_cur += printpkt_proto(res, buf_cur,
- GET_VALUE(res, KEY_IP_PROTOCOL).ui8);
+ ikey_get_u8(&res[KEY_IP_PROTOCOL]));
break;
case IPPROTO_ICMP:
}
buf_cur += sprintf(buf_cur, "TYPE=%u CODE=%u ",
- GET_VALUE(res, KEY_ICMP_TYPE).ui8,
- GET_VALUE(res, KEY_ICMP_CODE).ui8);
+ ikey_get_u8(&res[KEY_ICMP_TYPE]),
+ ikey_get_u8(&res[KEY_ICMP_CODE]));
- switch (GET_VALUE(res, KEY_ICMP_TYPE).ui8) {
+ switch (ikey_get_u8(&res[KEY_ICMP_CODE])) {
case ICMP_ECHO:
case ICMP_ECHOREPLY:
buf_cur += sprintf(buf_cur, "ID=%u SEQ=%u ",
- GET_VALUE(res, KEY_ICMP_ECHOID).ui16,
- GET_VALUE(res, KEY_ICMP_ECHOSEQ).ui16);
+ ikey_get_u16(&res[KEY_ICMP_ECHOID]),
+ ikey_get_u16(&res[KEY_ICMP_ECHOSEQ]));
break;
case ICMP_PARAMETERPROB:
buf_cur += sprintf(buf_cur, "PARAMETER=%u ",
- GET_VALUE(res, KEY_ICMP_GATEWAY).ui32 >> 24);
+ ikey_get_u32(&res[KEY_ICMP_GATEWAY]) >> 24);
break;
case ICMP_REDIRECT:
+ paddr = ikey_get_u32(&res[KEY_ICMP_GATEWAY]),
buf_cur += sprintf(buf_cur, "GATEWAY=%s ",
inet_ntop(AF_INET,
- &GET_VALUE(res, KEY_ICMP_GATEWAY).ui32,
+ &paddr,
tmp, sizeof(tmp)));
break;
case ICMP_DEST_UNREACH:
- if (GET_VALUE(res, KEY_ICMP_CODE).ui8 == ICMP_FRAG_NEEDED)
+ if (ikey_get_u8(&res[KEY_ICMP_CODE]) == ICMP_FRAG_NEEDED)
buf_cur += sprintf(buf_cur, "MTU=%u ",
- GET_VALUE(res, KEY_ICMP_FRAGMTU).ui16);
+ ikey_get_u16(&res[KEY_ICMP_FRAGMTU]));
break;
}
break;
default:
buf_cur += sprintf(buf_cur, "PROTO=%u ",
- GET_VALUE(res, KEY_IP_PROTOCOL).ui8);
+ ikey_get_u8(&res[KEY_IP_PROTOCOL]));
}
return buf_cur - buf;
if (pp_is_valid(res, KEY_IP_SADDR))
buf_cur += sprintf(buf_cur, "SRC=%s ",
- (char *) GET_VALUE(res, KEY_IP_SADDR).ptr);
+ (char *) ikey_get_ptr(&res[KEY_IP_SADDR]));
if (pp_is_valid(res, KEY_IP_DADDR))
buf_cur += sprintf(buf_cur, "DST=%s ",
- (char *) GET_VALUE(res, KEY_IP_DADDR).ptr);
+ (char *) ikey_get_ptr(&res[KEY_IP_DADDR]));
if (pp_is_valid(res, KEY_IP6_PAYLOAD_LEN))
buf_cur += sprintf(buf_cur, "LEN=%Zu ",
- GET_VALUE(res, KEY_IP6_PAYLOAD_LEN).ui16 +
+ ikey_get_u16(&res[KEY_IP6_PAYLOAD_LEN]) +
sizeof(struct ip6_hdr));
if (pp_is_valid(res, KEY_IP6_PRIORITY))
buf_cur += sprintf(buf_cur, "TC=%u ",
- GET_VALUE(res, KEY_IP6_PRIORITY).ui8);
+ ikey_get_u8(&res[KEY_IP6_PRIORITY]));
if (pp_is_valid(res, KEY_IP6_HOPLIMIT))
buf_cur += sprintf(buf_cur, "HOPLIMIT=%u ",
- GET_VALUE(res, KEY_IP6_HOPLIMIT).ui8);
+ ikey_get_u8(&res[KEY_IP6_HOPLIMIT]));
if (pp_is_valid(res, KEY_IP6_FLOWLABEL))
buf_cur += sprintf(buf_cur, "FLOWLBL=%u ",
- GET_VALUE(res, KEY_IP6_FLOWLABEL).ui32);
+ ikey_get_u32(&res[KEY_IP6_FLOWLABEL]));
if (pp_is_valid(res, KEY_IP6_FRAG_OFF) && pp_is_valid(res, KEY_IP6_FRAG_ID))
buf_cur += sprintf(buf_cur, "FRAG: %u ID: %08x ",
- GET_VALUE(res, KEY_IP6_FRAG_OFF).ui16,
- GET_VALUE(res, KEY_IP6_FRAG_ID).ui32);
+ ikey_get_u16(&res[KEY_IP6_FRAG_OFF]),
+ ikey_get_u32(&res[KEY_IP6_FRAG_ID]));
- switch (GET_VALUE(res, KEY_IP6_NEXTHDR).ui8) {
+ switch (ikey_get_u8(&res[KEY_IP6_NEXTHDR])) {
case IPPROTO_TCP:
case IPPROTO_UDP:
case IPPROTO_ESP:
case IPPROTO_AH:
buf_cur += printpkt_proto(res, buf_cur,
- GET_VALUE(res, KEY_IP6_NEXTHDR).ui8);
+ ikey_get_u8(&res[KEY_IP6_NEXTHDR]));
break;
case IPPROTO_ICMPV6:
buf_cur += sprintf(buf_cur, "PROTO=ICMPv6 ");
}
buf_cur += sprintf(buf_cur, "TYPE=%u CODE=%u ",
- GET_VALUE(res, KEY_ICMPV6_TYPE).ui8,
- GET_VALUE(res, KEY_ICMPV6_CODE).ui8);
+ ikey_get_u8(&res[KEY_ICMPV6_TYPE]),
+ ikey_get_u8(&res[KEY_ICMPV6_CODE]));
- switch (GET_VALUE(res, KEY_ICMPV6_TYPE).ui8) {
+ switch (ikey_get_u8(&res[KEY_ICMPV6_TYPE])) {
case ICMP6_ECHO_REQUEST:
case ICMP6_ECHO_REPLY:
buf_cur += sprintf(buf_cur, "ID=%u SEQ=%u ",
- GET_VALUE(res, KEY_ICMPV6_ECHOID).ui16,
- GET_VALUE(res, KEY_ICMPV6_ECHOSEQ).ui16);
+ ikey_get_u16(&res[KEY_ICMPV6_ECHOID]),
+ ikey_get_u16(&res[KEY_ICMPV6_ECHOSEQ]));
break;
}
break;
if (pp_is_valid(res, KEY_ARP_SPA))
buf_cur += sprintf(buf_cur, "SRC=%s ",
- (char *) GET_VALUE(res, KEY_ARP_SPA).ptr);
+ (char *) ikey_get_ptr(&res[KEY_ARP_SPA]));
if (pp_is_valid(res, KEY_ARP_TPA))
buf_cur += sprintf(buf_cur, "DST=%s ",
- (char *) GET_VALUE(res, KEY_ARP_TPA).ptr);
+ (char *) ikey_get_ptr(&res[KEY_ARP_TPA]));
buf_cur += sprintf(buf_cur, "PROTO=ARP ");
if (pp_is_valid(res, KEY_ARP_OPCODE)) {
- code = GET_VALUE(res, KEY_ARP_OPCODE).ui16;
+ code = ikey_get_u16(&res[KEY_ARP_OPCODE]);
switch (code) {
case ARPOP_REQUEST:
buf_cur += sprintf(buf_cur, "REQUEST ");
}
if (pp_is_valid(res, KEY_ARP_SHA) && (code == ARPOP_REPLY)) {
- mac = GET_VALUE(res, KEY_ARP_SHA).ptr;
+ mac = ikey_get_ptr(&res[KEY_ARP_SHA]);
buf_cur += sprintf(buf_cur, "REPLY_MAC="
"%02x:%02x:%02x:%02x:%02x:%02x ",
mac[0], mac[1], mac[2],
{
char *buf_cur = buf;
- switch (GET_VALUE(res, KEY_OOB_PROTOCOL).ui16) {
+ switch (ikey_get_u16(&res[KEY_OOB_PROTOCOL])) {
case ETH_P_IP:
buf_cur += printpkt_ipv4(res, buf_cur);
break;
break;
default:
buf_cur += sprintf(buf_cur, "PROTO=%u ",
- GET_VALUE(res, KEY_OOB_PROTOCOL).ui16);
+ ikey_get_u16(&res[KEY_OOB_PROTOCOL]));
}
return buf_cur - buf;
if (pp_is_valid(res, KEY_OOB_PREFIX))
buf_cur += sprintf(buf_cur, "%s ",
- (char *) GET_VALUE(res, KEY_OOB_PREFIX).ptr);
+ (char *) ikey_get_ptr(&res[KEY_OOB_PREFIX]));
if (pp_is_valid(res, KEY_OOB_IN) && pp_is_valid(res, KEY_OOB_OUT))
buf_cur += sprintf(buf_cur, "IN=%s OUT=%s ",
- (char *) GET_VALUE(res, KEY_OOB_IN).ptr,
- (char *) GET_VALUE(res, KEY_OOB_OUT).ptr);
+ (char *) ikey_get_ptr(&res[KEY_OOB_IN]),
+ (char *) ikey_get_ptr(&res[KEY_OOB_OUT]));
/* FIXME: configurable */
if (pp_is_valid(res, KEY_RAW_MAC)) {
- unsigned char *mac = (unsigned char *) GET_VALUE(res, KEY_RAW_MAC).ptr;
- int i, len = GET_VALUE(res, KEY_RAW_MACLEN).ui16;
+ unsigned char *mac = (unsigned char *) ikey_get_ptr(&res[KEY_RAW_MAC]);
+ int i, len = ikey_get_u16(&res[KEY_RAW_MACLEN]);
buf_cur += sprintf(buf_cur, "MAC=");
for (i = 0; i < len; i++)
} else
buf_cur += sprintf(buf_cur, "MAC= ");
- switch (GET_VALUE(res, KEY_OOB_FAMILY).ui8) {
+ switch (ikey_get_u8(&res[KEY_OOB_FAMILY])) {
case AF_INET:
buf_cur += printpkt_ipv4(res, buf_cur);
break;
if (pp_is_valid(res, KEY_OOB_UID))
buf_cur += sprintf(buf_cur, "UID=%u ",
- GET_VALUE(res, KEY_OOB_UID).ui32);
+ ikey_get_u32(&res[KEY_OOB_UID]));
if (pp_is_valid(res, KEY_OOB_GID))
buf_cur += sprintf(buf_cur, "GID=%u ",
- GET_VALUE(res, KEY_OOB_GID).ui32);
+ ikey_get_u32(&res[KEY_OOB_GID]));
if (pp_is_valid(res, KEY_OOB_MARK))
buf_cur += sprintf(buf_cur, "MARK=%x ",
- GET_VALUE(res, KEY_OOB_MARK).ui32);
+ ikey_get_u32(&res[KEY_OOB_MARK]));
strcat(buf_cur, "\n");
projects / thirdparty / ulogd2.git / commitdiff
