add ukey_* function for key assignation

This patch cleans up the current key assignation by introducing a
set of functions ukey_* to set the key value as Eric Leblond and
we discussed during the latest Netfilter Workshop. This patch is
based on an idea from Holger Eitzenberger.

Signed-off-by: Eric Leblond <eric@inl.fr>

3 files changed, 103 insertions, 202 deletions

diff --git a/input/flow/ulogd_inpflow_NFCT.c b/input/flow/ulogd_inpflow_NFCT.c
index 58bb0e2..a33ec35 100644
--- a/input/flow/ulogd_inpflow_NFCT.c
+++ b/input/flow/ulogd_inpflow_NFCT.c
@@ -443,67 +443,39 @@ static int propagate_ct(struct ulogd_pluginstance *upi,
 {
 	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:
@@ -511,22 +483,16 @@ static int propagate_ct(struct ulogd_pluginstance *upi,
 	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;
 	}
 
@@ -536,55 +502,36 @@ static int propagate_ct(struct ulogd_pluginstance *upi,
 	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);
 		}
 	}
 
diff --git a/input/packet/ulogd_inppkt_NFLOG.c b/input/packet/ulogd_inppkt_NFLOG.c
index 39f915a..5d25eec 100644
--- a/input/packet/ulogd_inppkt_NFLOG.c
+++ b/input/packet/ulogd_inppkt_NFLOG.c
@@ -310,59 +310,43 @@ interp_packet(struct ulogd_pluginstance *upi, struct nflog_data *ldata)
 	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) { */
@@ -370,41 +354,26 @@ interp_packet(struct ulogd_pluginstance *upi, struct nflog_data *ldata)
 		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;
 }
diff --git a/input/packet/ulogd_inppkt_ULOG.c b/input/packet/ulogd_inppkt_ULOG.c
index 3fdb42e..00975de 100644
--- a/input/packet/ulogd_inppkt_ULOG.c
+++ b/input/packet/ulogd_inppkt_ULOG.c
@@ -190,54 +190,39 @@ static int interp_packet(struct ulogd_pluginstance *ip, ulog_packet_msg_t *pkt)
 	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;