src: Use stdint types everywhere

Signed-off-by: Felix Janda <felix.janda@posteo.de>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

1 files changed, 41 insertions, 41 deletions

diff --git a/src/conntrack/parse.c b/src/conntrack/parse.c
index c003744..3eb8b81 100644
--- a/src/conntrack/parse.c
+++ b/src/conntrack/parse.c
@@ -14,14 +14,14 @@
 static void __parse_ip(const struct nfattr *attr,
 		       struct __nfct_tuple *tuple,
 		       const int dir,
-		       u_int32_t *set)
+		       uint32_t *set)
 {
 	struct nfattr *tb[CTA_IP_MAX];
 
         nfnl_parse_nested(tb, CTA_IP_MAX, attr);
 
 	if (tb[CTA_IP_V4_SRC-1]) {
-		tuple->src.v4 = *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_SRC-1]);
+		tuple->src.v4 = *(uint32_t *)NFA_DATA(tb[CTA_IP_V4_SRC-1]);
 		switch(dir) {
 		case __DIR_ORIG:
 			set_bit(ATTR_ORIG_IPV4_SRC, set);
@@ -36,7 +36,7 @@ static void __parse_ip(const struct nfattr *attr,
 	}
 
 	if (tb[CTA_IP_V4_DST-1]) {
-		tuple->dst.v4 = *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_DST-1]);
+		tuple->dst.v4 = *(uint32_t *)NFA_DATA(tb[CTA_IP_V4_DST-1]);
 		switch(dir) {
 		case __DIR_ORIG:
 			set_bit(ATTR_ORIG_IPV4_DST, set);
@@ -86,14 +86,14 @@ static void __parse_ip(const struct nfattr *attr,
 static void __parse_proto(const struct nfattr *attr,
 			  struct __nfct_tuple *tuple,
 		   const int dir,
-		   u_int32_t *set)
+		   uint32_t *set)
 {
 	struct nfattr *tb[CTA_PROTO_MAX];
 
 	nfnl_parse_nested(tb, CTA_PROTO_MAX, attr);
 
 	if (tb[CTA_PROTO_NUM-1]) {
-		tuple->protonum = *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_NUM-1]);
+		tuple->protonum = *(uint8_t *)NFA_DATA(tb[CTA_PROTO_NUM-1]);
 		switch(dir) {
 		case __DIR_ORIG:
 			set_bit(ATTR_ORIG_L4PROTO, set);
@@ -109,7 +109,7 @@ static void __parse_proto(const struct nfattr *attr,
 
 	if (tb[CTA_PROTO_SRC_PORT-1]) {
 		tuple->l4src.tcp.port =
-			*(u_int16_t *)NFA_DATA(tb[CTA_PROTO_SRC_PORT-1]);
+			*(uint16_t *)NFA_DATA(tb[CTA_PROTO_SRC_PORT-1]);
 		switch(dir) {
 		case __DIR_ORIG:
 			set_bit(ATTR_ORIG_PORT_SRC, set);
@@ -125,7 +125,7 @@ static void __parse_proto(const struct nfattr *attr,
 	
 	if (tb[CTA_PROTO_DST_PORT-1]) {
 		tuple->l4dst.tcp.port =
-			*(u_int16_t *)NFA_DATA(tb[CTA_PROTO_DST_PORT-1]);
+			*(uint16_t *)NFA_DATA(tb[CTA_PROTO_DST_PORT-1]);
 		switch(dir) {
 		case __DIR_ORIG:
 			set_bit(ATTR_ORIG_PORT_DST, set);
@@ -141,37 +141,37 @@ static void __parse_proto(const struct nfattr *attr,
 	
 	if (tb[CTA_PROTO_ICMP_TYPE-1]) {
 		tuple->l4dst.icmp.type =
-			*(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_TYPE-1]);
+			*(uint8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_TYPE-1]);
 		set_bit(ATTR_ICMP_TYPE, set);
 	}
 	
 	if (tb[CTA_PROTO_ICMP_CODE-1]) {
 		tuple->l4dst.icmp.code =
-			*(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_CODE-1]);
+			*(uint8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_CODE-1]);
 		set_bit(ATTR_ICMP_CODE, set);
 	}
 	
 	if (tb[CTA_PROTO_ICMP_ID-1]) {
 		tuple->l4src.icmp.id =
-			*(u_int16_t *)NFA_DATA(tb[CTA_PROTO_ICMP_ID-1]);
+			*(uint16_t *)NFA_DATA(tb[CTA_PROTO_ICMP_ID-1]);
 		set_bit(ATTR_ICMP_ID, set);
 	}
 
 	if (tb[CTA_PROTO_ICMPV6_TYPE-1]) {
 		tuple->l4dst.icmp.type =
-			*(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_TYPE-1]);
+			*(uint8_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_TYPE-1]);
 		set_bit(ATTR_ICMP_TYPE, set);
 	}
 	
 	if (tb[CTA_PROTO_ICMPV6_CODE-1]) {
 		tuple->l4dst.icmp.code =
-			*(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_CODE-1]);
+			*(uint8_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_CODE-1]);
 		set_bit(ATTR_ICMP_CODE, set);
 	}
 	
 	if (tb[CTA_PROTO_ICMPV6_ID-1]) {
 		tuple->l4src.icmp.id =
-			*(u_int16_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_ID-1]);
+			*(uint16_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_ID-1]);
 		set_bit(ATTR_ICMP_ID, set);
 	}
 }
@@ -179,7 +179,7 @@ static void __parse_proto(const struct nfattr *attr,
 void __parse_tuple(const struct nfattr *attr,
 		   struct __nfct_tuple *tuple, 
 		   int dir,
-		   u_int32_t *set)
+		   uint32_t *set)
 {
 	struct nfattr *tb[CTA_TUPLE_MAX];
 
@@ -200,21 +200,21 @@ static void __parse_protoinfo_tcp(const struct nfattr *attr,
 
 	if (tb[CTA_PROTOINFO_TCP_STATE-1]) {
                 ct->protoinfo.tcp.state =
-                        *(u_int8_t *)NFA_DATA(tb[CTA_PROTOINFO_TCP_STATE-1]);
+                        *(uint8_t *)NFA_DATA(tb[CTA_PROTOINFO_TCP_STATE-1]);
 		set_bit(ATTR_TCP_STATE, ct->head.set);
 	}
 
 	if (tb[CTA_PROTOINFO_TCP_WSCALE_ORIGINAL-1]) {
 		memcpy(&ct->protoinfo.tcp.wscale[__DIR_ORIG],
 		       NFA_DATA(tb[CTA_PROTOINFO_TCP_WSCALE_ORIGINAL-1]),
-		       sizeof(u_int8_t));
+		       sizeof(uint8_t));
 		set_bit(ATTR_TCP_WSCALE_ORIG, ct->head.set);
 	}
 
 	if (tb[CTA_PROTOINFO_TCP_WSCALE_REPLY-1]) {
 		memcpy(&ct->protoinfo.tcp.wscale[__DIR_REPL],
 		       NFA_DATA(tb[CTA_PROTOINFO_TCP_WSCALE_REPLY-1]),
-		       sizeof(u_int8_t));
+		       sizeof(uint8_t));
 		set_bit(ATTR_TCP_WSCALE_REPL, ct->head.set);
 	}
 
@@ -244,19 +244,19 @@ static void __parse_protoinfo_sctp(const struct nfattr *attr,
 
 	if (tb[CTA_PROTOINFO_SCTP_STATE-1]) {
                 ct->protoinfo.sctp.state =
-                        *(u_int8_t *)NFA_DATA(tb[CTA_PROTOINFO_SCTP_STATE-1]);
+                        *(uint8_t *)NFA_DATA(tb[CTA_PROTOINFO_SCTP_STATE-1]);
 		set_bit(ATTR_SCTP_STATE, ct->head.set);
 	}
 
 	if (tb[CTA_PROTOINFO_SCTP_VTAG_ORIGINAL-1]) {
 		ct->protoinfo.sctp.vtag[__DIR_ORIG] = 
-			ntohl(*(u_int32_t *)NFA_DATA(tb[CTA_PROTOINFO_SCTP_VTAG_ORIGINAL-1]));
+			ntohl(*(uint32_t *)NFA_DATA(tb[CTA_PROTOINFO_SCTP_VTAG_ORIGINAL-1]));
 		set_bit(ATTR_SCTP_VTAG_ORIG, ct->head.set);
 	}
 
 	if (tb[CTA_PROTOINFO_SCTP_VTAG_REPLY-1]) {
 		ct->protoinfo.sctp.vtag[__DIR_REPL] = 
-			ntohl(*(u_int32_t *)NFA_DATA(tb[CTA_PROTOINFO_SCTP_VTAG_REPLY-1]));
+			ntohl(*(uint32_t *)NFA_DATA(tb[CTA_PROTOINFO_SCTP_VTAG_REPLY-1]));
 		set_bit(ATTR_SCTP_VTAG_REPL, ct->head.set);
 	}
 
@@ -271,16 +271,16 @@ static void __parse_protoinfo_dccp(const struct nfattr *attr,
 
 	if (tb[CTA_PROTOINFO_DCCP_STATE-1]) {
                 ct->protoinfo.dccp.state =
-                        *(u_int8_t *)NFA_DATA(tb[CTA_PROTOINFO_DCCP_STATE-1]);
+                        *(uint8_t *)NFA_DATA(tb[CTA_PROTOINFO_DCCP_STATE-1]);
 		set_bit(ATTR_DCCP_STATE, ct->head.set);
 	}
 	if (tb[CTA_PROTOINFO_DCCP_ROLE-1]) {
                 ct->protoinfo.dccp.role =
-                        *(u_int8_t *)NFA_DATA(tb[CTA_PROTOINFO_DCCP_ROLE-1]);
+                        *(uint8_t *)NFA_DATA(tb[CTA_PROTOINFO_DCCP_ROLE-1]);
 		set_bit(ATTR_DCCP_ROLE, ct->head.set);
 	}
 	if (tb[CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ-1]) {
-		u_int64_t tmp;
+		uint64_t tmp;
 		memcpy(&tmp,
 		       NFA_DATA(tb[CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ-1]),
 		       sizeof(tmp));
@@ -317,11 +317,11 @@ static void __parse_counters(const struct nfattr *attr,
 
 		if (tb[CTA_COUNTERS32_PACKETS-1])
 			ct->counters[dir].packets
-				= ntohl(*(u_int32_t *)
+				= ntohl(*(uint32_t *)
 					NFA_DATA(tb[CTA_COUNTERS32_PACKETS-1]));
 
 		if (tb[CTA_COUNTERS_PACKETS-1]) {
-			u_int64_t tmp;
+			uint64_t tmp;
 			memcpy(&tmp,
 			       NFA_DATA(tb[CTA_COUNTERS_PACKETS-1]),
 			       sizeof(tmp));
@@ -341,11 +341,11 @@ static void __parse_counters(const struct nfattr *attr,
 
 		if (tb[CTA_COUNTERS32_BYTES-1])
 			ct->counters[dir].bytes
-				= ntohl(*(u_int32_t *)
+				= ntohl(*(uint32_t *)
 					NFA_DATA(tb[CTA_COUNTERS32_BYTES-1]));
 
 		if (tb[CTA_COUNTERS_BYTES-1]) {
-			u_int64_t tmp;
+			uint64_t tmp;
 			memcpy(&tmp,
 			       NFA_DATA(tb[CTA_COUNTERS_BYTES-1]),
 			       sizeof(tmp));
@@ -372,7 +372,7 @@ __parse_nat_seq(const struct nfattr *attr, struct nf_conntrack *ct, int dir)
 
 	if (tb[CTA_NAT_SEQ_CORRECTION_POS-1]) {
 		ct->natseq[dir].correction_pos =
-			ntohl(*(u_int32_t *)NFA_DATA(tb[CTA_NAT_SEQ_CORRECTION_POS-1]));
+			ntohl(*(uint32_t *)NFA_DATA(tb[CTA_NAT_SEQ_CORRECTION_POS-1]));
 		switch(dir) {
 		case __DIR_ORIG:
 			set_bit(ATTR_ORIG_NAT_SEQ_CORRECTION_POS, ct->head.set);
@@ -385,7 +385,7 @@ __parse_nat_seq(const struct nfattr *attr, struct nf_conntrack *ct, int dir)
 					
 	if (tb[CTA_NAT_SEQ_OFFSET_BEFORE-1]) {
 		ct->natseq[dir].offset_before =
-		ntohl(*(u_int32_t *)NFA_DATA(tb[CTA_NAT_SEQ_OFFSET_BEFORE-1]));
+		ntohl(*(uint32_t *)NFA_DATA(tb[CTA_NAT_SEQ_OFFSET_BEFORE-1]));
 		switch(dir) {
 		case __DIR_ORIG:
 			set_bit(ATTR_ORIG_NAT_SEQ_OFFSET_BEFORE, ct->head.set);
@@ -398,7 +398,7 @@ __parse_nat_seq(const struct nfattr *attr, struct nf_conntrack *ct, int dir)
 
 	if (tb[CTA_NAT_SEQ_OFFSET_AFTER-1]) {
 		ct->natseq[dir].offset_after =
-		ntohl(*(u_int32_t *)NFA_DATA(tb[CTA_NAT_SEQ_OFFSET_AFTER-1]));
+		ntohl(*(uint32_t *)NFA_DATA(tb[CTA_NAT_SEQ_OFFSET_AFTER-1]));
 		switch(dir) {
 		case __DIR_ORIG:
 			set_bit(ATTR_ORIG_NAT_SEQ_OFFSET_AFTER, ct->head.set);
@@ -442,8 +442,8 @@ __parse_secctx(const struct nfattr *attr, struct nf_conntrack *ct)
 
 int __parse_message_type(const struct nlmsghdr *nlh)
 {
-	u_int16_t type = NFNL_MSG_TYPE(nlh->nlmsg_type);
-	u_int16_t flags = nlh->nlmsg_flags;
+	uint16_t type = NFNL_MSG_TYPE(nlh->nlmsg_type);
+	uint16_t flags = nlh->nlmsg_flags;
 	int ret = NFCT_T_UNKNOWN;
 
 	if (type == IPCTNL_MSG_CT_NEW) {
@@ -464,13 +464,13 @@ __parse_timestamp(const struct nfattr *attr, struct nf_conntrack *ct)
 
 	nfnl_parse_nested(tb, CTA_TIMESTAMP_MAX, attr);
 	if (tb[CTA_TIMESTAMP_START-1]) {
-		u_int64_t tmp;
+		uint64_t tmp;
 		memcpy(&tmp, NFA_DATA(tb[CTA_TIMESTAMP_START-1]), sizeof(tmp));
 		ct->timestamp.start = __be64_to_cpu(tmp);
 		set_bit(ATTR_TIMESTAMP_START, ct->head.set);
 	}
 	if (tb[CTA_TIMESTAMP_STOP-1]) {
-		u_int64_t tmp;
+		uint64_t tmp;
 		memcpy(&tmp, NFA_DATA(tb[CTA_TIMESTAMP_STOP-1]), sizeof(tmp));
 		ct->timestamp.stop = __be64_to_cpu(tmp);
 		set_bit(ATTR_TIMESTAMP_STOP, ct->head.set);
@@ -530,7 +530,7 @@ void __parse_conntrack(const struct nlmsghdr *nlh,
 		__parse_nat_seq(cda[CTA_NAT_SEQ_ADJ_REPLY-1], ct, __DIR_REPL);
 
 	if (cda[CTA_STATUS-1]) {
-		ct->status = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_STATUS-1]));
+		ct->status = ntohl(*(uint32_t *)NFA_DATA(cda[CTA_STATUS-1]));
 		set_bit(ATTR_STATUS, ct->head.set);
 	}
 
@@ -538,17 +538,17 @@ void __parse_conntrack(const struct nlmsghdr *nlh,
 		__parse_protoinfo(cda[CTA_PROTOINFO-1], ct);
 
 	if (cda[CTA_TIMEOUT-1]) {
-		ct->timeout = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_TIMEOUT-1]));
+		ct->timeout = ntohl(*(uint32_t *)NFA_DATA(cda[CTA_TIMEOUT-1]));
 		set_bit(ATTR_TIMEOUT, ct->head.set);
 	}
 	
 	if (cda[CTA_MARK-1]) {
-		ct->mark = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_MARK-1]));
+		ct->mark = ntohl(*(uint32_t *)NFA_DATA(cda[CTA_MARK-1]));
 		set_bit(ATTR_MARK, ct->head.set);
 	}
 
 	if (cda[CTA_SECMARK-1]) {
-		ct->secmark = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_SECMARK-1]));
+		ct->secmark = ntohl(*(uint32_t *)NFA_DATA(cda[CTA_SECMARK-1]));
 		set_bit(ATTR_SECMARK, ct->head.set);
 	}
 
@@ -559,12 +559,12 @@ void __parse_conntrack(const struct nlmsghdr *nlh,
 		__parse_counters(cda[CTA_COUNTERS_REPLY-1], ct, __DIR_REPL);
 
 	if (cda[CTA_USE-1]) {
-		ct->use = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_USE-1]));
+		ct->use = ntohl(*(uint32_t *)NFA_DATA(cda[CTA_USE-1]));
 		set_bit(ATTR_USE, ct->head.set);
 	}
 
 	if (cda[CTA_ID-1]) {
-		ct->id = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_ID-1]));
+		ct->id = ntohl(*(uint32_t *)NFA_DATA(cda[CTA_ID-1]));
 		set_bit(ATTR_ID, ct->head.set);
 	}
 
@@ -572,7 +572,7 @@ void __parse_conntrack(const struct nlmsghdr *nlh,
 		__parse_helper(cda[CTA_HELP-1], ct);
 
 	if (cda[CTA_ZONE-1]) {
-		ct->zone = ntohs(*(u_int16_t *)NFA_DATA(cda[CTA_ZONE-1]));
+		ct->zone = ntohs(*(uint16_t *)NFA_DATA(cda[CTA_ZONE-1]));
 		set_bit(ATTR_ZONE, ct->head.set);
 	}