Max Kellermann <max@duempel.org>:

use C99 integers (uint32_t instead of u_int32_t)

22 files changed, 110 insertions, 100 deletions

diff --git a/ChangeLog b/ChangeLog
index d6bfbf9..6425e32 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -51,6 +51,7 @@ Max Kellermann <max@duempel.org>:
 o fix shadow warnings by renaming variables or making them local
 o remove "-g" from Makefile.am, this should be specified by the user
 o enable C99 mode
+o use C99 integers (uint32_t instead of u_int32_t)
 
 = conntrackd =
 o resolve global variable "alarm" conflict with alarm() function in unistd.h.
diff --git a/include/cache.h b/include/cache.h
index e4fb945..0743d3f 100644
--- a/include/cache.h
+++ b/include/cache.h
@@ -1,7 +1,8 @@
 #ifndef _CACHE_H_
 #define _CACHE_H_
 
-#include <sys/types.h>
+#include <stdint.h>
+#include <stddef.h>
 #include <time.h>
 
 /* cache features */
@@ -75,7 +76,7 @@ struct cache_extra {
 
 struct nf_conntrack;
 
-struct cache *cache_create(const char *name, unsigned int features, u_int8_t proto, struct cache_extra *extra);
+struct cache *cache_create(const char *name, unsigned int features, uint8_t proto, struct cache_extra *extra);
 void cache_destroy(struct cache *e);
 
 struct us_conntrack *cache_add(struct cache *c, struct nf_conntrack *ct);
diff --git a/include/conntrack.h b/include/conntrack.h
index 8f2b6a2..d6b6150 100644
--- a/include/conntrack.h
+++ b/include/conntrack.h
@@ -3,6 +3,7 @@
 
 #include "linux_list.h"
 #include <getopt.h>
+#include <stdint.h>
 #include <libnetfilter_conntrack/libnetfilter_conntrack.h>
 
 #define PROGNAME "conntrack"
@@ -149,7 +150,7 @@ struct ctproto_handler {
 	struct list_head 	head;
 
 	const char		*name;
-	u_int16_t 		protonum;
+	uint16_t 		protonum;
 	const char		*version;
 
 	enum ctattr_protoinfo	protoinfo_attr;
diff --git a/include/conntrackd.h b/include/conntrackd.h
index d3f66ba..418f4b7 100644
--- a/include/conntrackd.h
+++ b/include/conntrackd.h
@@ -4,6 +4,7 @@
 #include "mcast.h"
 #include "local.h"
 
+#include <stdint.h>
 #include <stdio.h>
 #include <libnetfilter_conntrack/libnetfilter_conntrack.h> 
 #include "cache.h"
@@ -63,9 +64,9 @@ enum {
 #endif
 
 union inet_address {
-	u_int32_t ipv4;
-	u_int32_t ipv6[4];
-	u_int32_t all[4];
+	uint32_t ipv4;
+	uint32_t ipv6[4];
+	uint32_t all[4];
 };
 
 #define CONFIG(x) conf.x
@@ -112,9 +113,9 @@ struct ct_general_state {
 	struct nfct_handle		*dump;		/* dump handler */
 
 	/* statistics */
-	u_int64_t			malformed;
-	u_int64_t 			bytes[NFCT_DIR_MAX];
-	u_int64_t 			packets[NFCT_DIR_MAX];
+	uint64_t			malformed;
+	uint64_t 			bytes[NFCT_DIR_MAX];
+	uint64_t 			packets[NFCT_DIR_MAX];
 };
 
 #define STATE_SYNC(x) state.sync->x
@@ -128,10 +129,10 @@ struct ct_sync_state {
 
 	struct sync_mode *sync;		/* sync mode */
 
-	u_int32_t last_seq_sent;	/* last sequence number sent */
-	u_int32_t last_seq_recv;	/* last sequence number recv */
-	u_int64_t packets_replayed;	/* number of replayed packets */
-	u_int64_t packets_lost;         /* lost packets: sequence tracking */
+	uint32_t last_seq_sent;	/* last sequence number sent */
+	uint32_t last_seq_recv;	/* last sequence number recv */
+	uint64_t packets_replayed;	/* number of replayed packets */
+	uint64_t packets_lost;         /* lost packets: sequence tracking */
 };
 
 #define STATE_STATS(x) state.stats->x
diff --git a/include/hash.h b/include/hash.h
index c9460fa..caad412 100644
--- a/include/hash.h
+++ b/include/hash.h
@@ -2,21 +2,22 @@
 #define _NF_SET_HASH_H_
 
 #include <unistd.h>
-#include <sys/types.h>
 #include "slist.h"
 #include "linux_list.h"
 
+#include <stdint.h>
+
 struct hashtable;
 struct hashtable_node;
 
 struct hashtable {
-	u_int32_t hashsize;
-	u_int32_t limit;
-	u_int32_t count;
-	u_int32_t initval;
-	u_int32_t datasize;
+	uint32_t hashsize;
+	uint32_t limit;
+	uint32_t count;
+	uint32_t initval;
+	uint32_t datasize;
 	
-	u_int32_t	(*hash)(const void *data, struct hashtable *table);
+	uint32_t	(*hash)(const void *data, struct hashtable *table);
 	int		(*compare)(const void *data1, const void *data2);
 
 	struct slist_head 	members[0];
@@ -32,7 +33,7 @@ void hashtable_destroy_node(struct hashtable_node *h);
 
 struct hashtable *
 hashtable_create(int hashsize, int limit, int datasize,
-		 u_int32_t (*hash)(const void *data, struct hashtable *table),
+		 uint32_t (*hash)(const void *data, struct hashtable *table),
 		 int (*compare)(const void *data1, const void *data2));
 void hashtable_destroy(struct hashtable *h);
 
diff --git a/include/ignore.h b/include/ignore.h
index 96deb93..f1c2846 100644
--- a/include/ignore.h
+++ b/include/ignore.h
@@ -1,11 +1,13 @@
 #ifndef _IGNORE_H_
 #define _IGNORE_H_
 
+#include <stdint.h>
+
 struct ignore_pool {
 	struct hashtable *h;
 };
 
-struct ignore_pool *ignore_pool_create(u_int8_t family);
+struct ignore_pool *ignore_pool_create(uint8_t family);
 void ignore_pool_destroy(struct ignore_pool *ip);
 int ignore_pool_add(struct ignore_pool *ip, void *data);
 int ignore_pool_test(struct ignore_pool *ip, struct nf_conntrack *ct);
diff --git a/include/mcast.h b/include/mcast.h
index d4fd335..e3cdb38 100644
--- a/include/mcast.h
+++ b/include/mcast.h
@@ -1,6 +1,7 @@
 #ifndef _MCAST_H_
 #define _MCAST_H_
 
+#include <stdint.h>
 #include <netinet/in.h>
 #include <net/if.h>
 
@@ -22,9 +23,9 @@ struct mcast_conf {
 };
 
 struct mcast_stats {
-	u_int64_t bytes;
-	u_int64_t messages;
-	u_int64_t error;
+	uint64_t bytes;
+	uint64_t messages;
+	uint64_t error;
 };
 
 struct mcast_sock {
diff --git a/include/network.h b/include/network.h
index d0b639b..f9976dd 100644
--- a/include/network.h
+++ b/include/network.h
@@ -1,12 +1,12 @@
 #ifndef _NETWORK_H_
 #define _NETWORK_H_
 
-#include <sys/types.h>
+#include <stdint.h>
 
 struct nethdr {
-	u_int16_t flags;
-	u_int16_t len;
-	u_int32_t seq;
+	uint16_t flags;
+	uint16_t len;
+	uint32_t seq;
 };
 #define NETHDR_SIZ sizeof(struct nethdr)
 
@@ -14,11 +14,11 @@ struct nethdr {
 	(struct netpld *)(((char *)x) + sizeof(struct nethdr))
 
 struct nethdr_ack {
-	u_int16_t flags; 
-	u_int16_t len;
-	u_int32_t seq;
-	u_int32_t from;
-	u_int32_t to;
+	uint16_t flags; 
+	uint16_t len;
+	uint32_t seq;
+	uint32_t from;
+	uint32_t to;
 };
 #define NETHDR_ACK_SIZ sizeof(struct nethdr_ack)
 
@@ -55,7 +55,7 @@ int prepare_send_netmsg(struct mcast_sock *m, void *data);
 int mcast_send_netmsg(struct mcast_sock *m, void *data);
 int mcast_recv_netmsg(struct mcast_sock *m, void *data, int len);
 int handle_netmsg(struct nethdr *net);
-int mcast_track_seq(u_int32_t seq, u_int32_t *exp_seq);
+int mcast_track_seq(uint32_t seq, uint32_t *exp_seq);
 
 struct mcast_conf;
 
@@ -103,21 +103,21 @@ int mcast_buffered_pending_netmsg(struct mcast_sock *m);
  * and worry about wraparound (automatic with unsigned arithmetic).
  */
 
-static inline int before(__u32 seq1, __u32 seq2)
+static inline int before(uint32_t seq1, uint32_t seq2)
 {
-	return (__s32)(seq1-seq2) < 0;
+	return (int32_t)(seq1-seq2) < 0;
 }
 #define after(seq2, seq1)       before(seq1, seq2)
 
 /* is s2<=s1<=s3 ? */
-static inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
+static inline int between(uint32_t seq1, uint32_t seq2, uint32_t seq3)
 {
 	return seq3 - seq2 >= seq1 - seq2;
 }
 
 struct netpld {
-	u_int16_t       len;
-	u_int16_t       query;
+	uint16_t       len;
+	uint16_t       query;
 };
 #define NETPLD_SIZ		sizeof(struct netpld)
 
@@ -134,8 +134,8 @@ struct netpld {
 })
 
 struct netattr {
-	u_int16_t nta_len;
-	u_int16_t nta_attr;
+	uint16_t nta_len;
+	uint16_t nta_attr;
 };
 
 #define ATTR_NETWORK2HOST(x)						 \
diff --git a/include/state_helper.h b/include/state_helper.h
index 1ed0b79..0015890 100644
--- a/include/state_helper.h
+++ b/include/state_helper.h
@@ -1,13 +1,15 @@
 #ifndef _STATE_HELPER_H_
 #define _STATE_HELPER_H_
 
+#include <stdint.h>
+
 enum {
 	ST_H_SKIP,
 	ST_H_REPLICATE
 };
 
 struct state_replication_helper {
-	u_int8_t 		proto;
+	uint8_t 		proto;
 	unsigned int		state;
 
 	int (*verdict)(const struct state_replication_helper *h,
diff --git a/src/build.c b/src/build.c
index 5fdc83f..c99990b 100644
--- a/src/build.c
+++ b/src/build.c
@@ -36,38 +36,38 @@ static void __build_u8(const struct nf_conntrack *ct,
 		       struct netpld *pld,
 		       int attr)
 {
-	u_int8_t data = nfct_get_attr_u8(ct, attr);
-	addattr(pld, attr, &data, sizeof(u_int8_t));
+	uint8_t data = nfct_get_attr_u8(ct, attr);
+	addattr(pld, attr, &data, sizeof(uint8_t));
 }
 
 static void __build_u16(const struct nf_conntrack *ct,
 			struct netpld *pld,
 			int attr)
 {
-	u_int16_t data = nfct_get_attr_u16(ct, attr);
+	uint16_t data = nfct_get_attr_u16(ct, attr);
 	data = htons(data);
-	addattr(pld, attr, &data, sizeof(u_int16_t));
+	addattr(pld, attr, &data, sizeof(uint16_t));
 }
 
 static void __build_u32(const struct nf_conntrack *ct, 
 			struct netpld *pld,
 			int attr)
 {
-	u_int32_t data = nfct_get_attr_u32(ct, attr);
+	uint32_t data = nfct_get_attr_u32(ct, attr);
 	data = htonl(data);
-	addattr(pld, attr, &data, sizeof(u_int32_t));
+	addattr(pld, attr, &data, sizeof(uint32_t));
 }
 
-static void __nat_build_u32(u_int32_t data, struct netpld *pld, int attr)
+static void __nat_build_u32(uint32_t data, struct netpld *pld, int attr)
 {
 	data = htonl(data);
-	addattr(pld, attr, &data, sizeof(u_int32_t));
+	addattr(pld, attr, &data, sizeof(uint32_t));
 }
 
-static void __nat_build_u16(u_int16_t data, struct netpld *pld, int attr)
+static void __nat_build_u16(uint16_t data, struct netpld *pld, int attr)
 {
 	data = htons(data);
-	addattr(pld, attr, &data, sizeof(u_int16_t));
+	addattr(pld, attr, &data, sizeof(uint16_t));
 }
 
 /* XXX: IPv6 and ICMP not supported */
@@ -84,7 +84,7 @@ void build_netpld(struct nf_conntrack *ct, struct netpld *pld, int query)
 	if (nfct_attr_is_set(ct, ATTR_PORT_DST))
 		__build_u16(ct, pld, ATTR_PORT_DST);
 	if (nfct_attr_is_set(ct, ATTR_L4PROTO)) {
-		u_int8_t proto;
+		uint8_t proto;
 
 		__build_u8(ct, pld, ATTR_L4PROTO);
 		proto = nfct_get_attr_u8(ct, ATTR_L4PROTO);
@@ -118,19 +118,19 @@ void build_netpld(struct nf_conntrack *ct, struct netpld *pld, int query)
 
 	/*  NAT */
 	if (nfct_getobjopt(ct, NFCT_GOPT_IS_SNAT)) {
-		u_int32_t data = nfct_get_attr_u32(ct, ATTR_REPL_IPV4_DST);
+		uint32_t data = nfct_get_attr_u32(ct, ATTR_REPL_IPV4_DST);
 		__nat_build_u32(data, pld, ATTR_SNAT_IPV4);
 	}
 	if (nfct_getobjopt(ct, NFCT_GOPT_IS_DNAT)) {
-		u_int32_t data = nfct_get_attr_u32(ct, ATTR_REPL_IPV4_SRC);
+		uint32_t data = nfct_get_attr_u32(ct, ATTR_REPL_IPV4_SRC);
 		__nat_build_u32(data, pld, ATTR_DNAT_IPV4);
 	}
 	if (nfct_getobjopt(ct, NFCT_GOPT_IS_SPAT)) {
-		u_int16_t data = nfct_get_attr_u16(ct, ATTR_REPL_PORT_DST);
+		uint16_t data = nfct_get_attr_u16(ct, ATTR_REPL_PORT_DST);
 		__nat_build_u16(data, pld, ATTR_SNAT_PORT);
 	}
 	if (nfct_getobjopt(ct, NFCT_GOPT_IS_DPAT)) {
-		u_int16_t data = nfct_get_attr_u16(ct, ATTR_REPL_PORT_SRC);
+		uint16_t data = nfct_get_attr_u16(ct, ATTR_REPL_PORT_SRC);
 		__nat_build_u16(data, pld, ATTR_DNAT_PORT);
 	}
 
diff --git a/src/cache.c b/src/cache.c
index c5afb00..dcb0123 100644
--- a/src/cache.c
+++ b/src/cache.c
@@ -25,17 +25,17 @@
 #include "cache.h"
 #include <stdlib.h>
 
-static u_int32_t hash(const void *data, struct hashtable *table)
+static uint32_t hash(const void *data, struct hashtable *table)
 {
 	unsigned int a, b;
 	const struct us_conntrack *u = data;
 	struct nf_conntrack *ct = u->ct;
 
-	a = jhash(nfct_get_attr(ct, ATTR_ORIG_IPV4_SRC), sizeof(u_int32_t),
+	a = jhash(nfct_get_attr(ct, ATTR_ORIG_IPV4_SRC), sizeof(uint32_t),
 		  ((nfct_get_attr_u8(ct, ATTR_ORIG_L3PROTO) << 16) |
 		   (nfct_get_attr_u8(ct, ATTR_ORIG_L4PROTO))));
 
-	b = jhash(nfct_get_attr(ct, ATTR_ORIG_IPV4_DST), sizeof(u_int32_t),
+	b = jhash(nfct_get_attr(ct, ATTR_ORIG_IPV4_DST), sizeof(uint32_t),
 		  ((nfct_get_attr_u16(ct, ATTR_ORIG_PORT_SRC) << 16) |
 		   (nfct_get_attr_u16(ct, ATTR_ORIG_PORT_DST))));
 
@@ -46,24 +46,24 @@ static u_int32_t hash(const void *data, struct hashtable *table)
 	 * but using a multiply, less expensive than a divide. See:
 	 * http://www.mail-archive.com/netdev@vger.kernel.org/msg56623.html
 	 */
-	return ((u_int64_t)jhash_2words(a, b, 0) * table->hashsize) >> 32;
+	return ((uint64_t)jhash_2words(a, b, 0) * table->hashsize) >> 32;
 }
 
-static u_int32_t hash6(const void *data, struct hashtable *table)
+static uint32_t hash6(const void *data, struct hashtable *table)
 {
 	unsigned int a, b;
 	const struct us_conntrack *u = data;
 	struct nf_conntrack *ct = u->ct;
 
-	a = jhash(nfct_get_attr(ct, ATTR_ORIG_IPV6_SRC), sizeof(u_int32_t)*4,
+	a = jhash(nfct_get_attr(ct, ATTR_ORIG_IPV6_SRC), sizeof(uint32_t)*4,
 		  ((nfct_get_attr_u8(ct, ATTR_ORIG_L3PROTO) << 16) |
 		   (nfct_get_attr_u8(ct, ATTR_ORIG_L4PROTO))));
 
-	b = jhash(nfct_get_attr(ct, ATTR_ORIG_IPV6_DST), sizeof(u_int32_t)*4,
+	b = jhash(nfct_get_attr(ct, ATTR_ORIG_IPV6_DST), sizeof(uint32_t)*4,
 		  ((nfct_get_attr_u16(ct, ATTR_ORIG_PORT_SRC) << 16) |
 		   (nfct_get_attr_u16(ct, ATTR_ORIG_PORT_DST))));
 
-	return ((u_int64_t)jhash_2words(a, b, 0) * table->hashsize) >> 32;
+	return ((uint64_t)jhash_2words(a, b, 0) * table->hashsize) >> 32;
 }
 
 static int __compare(const struct nf_conntrack *ct1, 
@@ -123,7 +123,7 @@ struct cache_feature *cache_feature[CACHE_MAX_FEATURE] = {
 
 struct cache *cache_create(const char *name, 
 			   unsigned int features, 
-			   u_int8_t proto,
+			   uint8_t proto,
 			   struct cache_extra *extra)
 {
 	size_t size = sizeof(struct us_conntrack);
diff --git a/src/conntrack.c b/src/conntrack.c
index 9d268c5..b8843d4 100644
--- a/src/conntrack.c
+++ b/src/conntrack.c
@@ -444,8 +444,8 @@ parse_inetaddr(const char *cp, struct addr_parse *parse)
 }
 
 union ct_address {
-	u_int32_t v4;
-	u_int32_t v6[4];
+	uint32_t v4;
+	uint32_t v6[4];
 };
 
 static int
@@ -472,7 +472,7 @@ nat_parse(char *arg, int portok, struct nf_conntrack *obj, int type)
 	colon = strchr(arg, ':');
 
 	if (colon) {
-		u_int16_t port;
+		uint16_t port;
 
 		if (!portok)
 			exit_error(PARAMETER_PROBLEM,
diff --git a/src/hash.c b/src/hash.c
index 553dd1d..d7724c8 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -48,7 +48,7 @@ void hashtable_destroy_node(struct hashtable_node *h)
 
 struct hashtable *
 hashtable_create(int hashsize, int limit, int datasize,
-		 u_int32_t (*hash)(const void *data, struct hashtable *table),
+		 uint32_t (*hash)(const void *data, struct hashtable *table),
 		 int (*compare)(const void *data1, const void *data2))
 {
 	int i;
@@ -85,7 +85,7 @@ void *hashtable_add(struct hashtable *table, void *data)
 {
 	struct slist_head *e;
 	struct hashtable_node *n;
-	u_int32_t id;
+	uint32_t id;
 
 	/* hash table is full */
 	if (table->count >= table->limit) {
@@ -118,7 +118,7 @@ void *hashtable_add(struct hashtable *table, void *data)
 void *hashtable_test(struct hashtable *table, const void *data)
 {
 	struct slist_head *e;
-	u_int32_t id;
+	uint32_t id;
 	struct hashtable_node *n;
 
 	id = table->hash(data, table);
@@ -136,7 +136,7 @@ void *hashtable_test(struct hashtable *table, const void *data)
 int hashtable_del(struct hashtable *table, void *data)
 {
 	struct slist_head *e, *next, *prev;
-	u_int32_t id;
+	uint32_t id;
 	struct hashtable_node *n;
 
 	id = table->hash(data, table);
@@ -156,7 +156,7 @@ int hashtable_del(struct hashtable *table, void *data)
 
 int hashtable_flush(struct hashtable *table)
 {
-	u_int32_t i;
+	uint32_t i;
 	struct slist_head *e, *next, *prev;
 	struct hashtable_node *n;
 
@@ -175,7 +175,7 @@ int hashtable_flush(struct hashtable *table)
 int hashtable_iterate(struct hashtable *table, void *data,
 		      int (*iterate)(void *data1, void *data2))
 {
-	u_int32_t i;
+	uint32_t i;
 	struct slist_head *e, *next, *prev;
 	struct hashtable_node *n;
 
diff --git a/src/ignore_pool.c b/src/ignore_pool.c
index 82afa93..5889398 100644
--- a/src/ignore_pool.c
+++ b/src/ignore_pool.c
@@ -29,32 +29,32 @@
 #define IGNORE_POOL_SIZE 128
 #define IGNORE_POOL_LIMIT INT_MAX
 
-static u_int32_t hash(const void *data, struct hashtable *table)
+static uint32_t hash(const void *data, struct hashtable *table)
 {
-	const u_int32_t *ip = data;
+	const uint32_t *ip = data;
 
 	return jhash_1word(*ip, 0) % table->hashsize;
 }
 
-static u_int32_t hash6(const void *data, struct hashtable *table)
+static uint32_t hash6(const void *data, struct hashtable *table)
 {
-	return jhash(data, sizeof(u_int32_t)*4, 0) % table->hashsize;
+	return jhash(data, sizeof(uint32_t)*4, 0) % table->hashsize;
 }
 
 static int compare(const void *data1, const void *data2)
 {
-	const u_int32_t *ip1 = data1;
-	const u_int32_t *ip2 = data2;
+	const uint32_t *ip1 = data1;
+	const uint32_t *ip2 = data2;
 
 	return *ip1 == *ip2;
 }
 
 static int compare6(const void *data1, const void *data2)
 {
-	return memcmp(data1, data2, sizeof(u_int32_t)*4) == 0;
+	return memcmp(data1, data2, sizeof(uint32_t)*4) == 0;
 }
 
-struct ignore_pool *ignore_pool_create(u_int8_t proto)
+struct ignore_pool *ignore_pool_create(uint8_t proto)
 {
 	struct ignore_pool *ip;
 
@@ -67,14 +67,14 @@ struct ignore_pool *ignore_pool_create(u_int8_t proto)
 	case AF_INET:
 		ip->h = hashtable_create(IGNORE_POOL_SIZE,
 					 IGNORE_POOL_LIMIT,
-					 sizeof(u_int32_t),
+					 sizeof(uint32_t),
 					 hash,
 					 compare);
 		break;
 	case AF_INET6:
 		ip->h = hashtable_create(IGNORE_POOL_SIZE,
 					 IGNORE_POOL_LIMIT,
-					 sizeof(u_int32_t)*4,
+					 sizeof(uint32_t)*4,
 					 hash6,
 					 compare6);
 		break;
diff --git a/src/mcast.c b/src/mcast.c
index cf03593..185a7e2 100644
--- a/src/mcast.c
+++ b/src/mcast.c
@@ -57,9 +57,9 @@ struct mcast_sock *mcast_server_create(struct mcast_conf *conf)
 
 	case AF_INET6:
 		memcpy(&mreq.ipv6.ipv6mr_multiaddr, &conf->in.inet_addr6,
-		       sizeof(u_int32_t) * 4);
+		       sizeof(uint32_t) * 4);
 		memcpy(&mreq.ipv6.ipv6mr_interface, &conf->ifa.interface_addr6,
-		       sizeof(u_int32_t) * 4);
+		       sizeof(uint32_t) * 4);
 
 		m->addr.ipv6.sin6_family = AF_INET6;
 		m->addr.ipv6.sin6_port = htons(conf->port);
diff --git a/src/netlink.c b/src/netlink.c
index 7800b10..388407a 100644
--- a/src/netlink.c
+++ b/src/netlink.c
@@ -202,11 +202,11 @@ int nl_dump_conntrack_table(void)
 /* This function modifies the conntrack passed as argument! */
 int nl_create_conntrack(struct nf_conntrack *ct)
 {
-	u_int8_t flags;
+	uint8_t flags;
 
 	/* XXX: related connections */
 	if (nfct_attr_is_set(ct, ATTR_STATUS)) {
-		u_int32_t status = nfct_get_attr_u32(ct, ATTR_STATUS);
+		uint32_t status = nfct_get_attr_u32(ct, ATTR_STATUS);
 		status &= ~IPS_EXPECTED;
 		nfct_set_attr_u32(ct, ATTR_STATUS, status);
 	}
diff --git a/src/network.c b/src/network.c
index 9d6e6e1..939e94b 100644
--- a/src/network.c
+++ b/src/network.c
@@ -197,7 +197,7 @@ int handle_netmsg(struct nethdr *net)
 	return 0;
 }
 
-int mcast_track_seq(u_int32_t seq, u_int32_t *exp_seq)
+int mcast_track_seq(uint32_t seq, uint32_t *exp_seq)
 {
 	static int local_seq_set = 0;
 	int ret = 1;
diff --git a/src/parse.c b/src/parse.c
index c8a9704..a248b47 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -22,19 +22,19 @@
 
 static void parse_u8(struct nf_conntrack *ct, int attr, void *data)
 {
-	u_int8_t *value = (u_int8_t *) data;
+	uint8_t *value = (uint8_t *) data;
 	nfct_set_attr_u8(ct, attr, *value);
 }
 
 static void parse_u16(struct nf_conntrack *ct, int attr, void *data)
 {
-	u_int16_t *value = (u_int16_t *) data;
+	uint16_t *value = (uint16_t *) data;
 	nfct_set_attr_u16(ct, attr, ntohs(*value));
 }
 
 static void parse_u32(struct nf_conntrack *ct, int attr, void *data)
 {
-	u_int32_t *value = (u_int32_t *) data;
+	uint32_t *value = (uint32_t *) data;
 	nfct_set_attr_u32(ct, attr, ntohl(*value));
 }
 
diff --git a/src/state_helper.c b/src/state_helper.c
index de4cf48..9034864 100644
--- a/src/state_helper.c
+++ b/src/state_helper.c
@@ -23,7 +23,7 @@ static struct state_replication_helper *helper[IPPROTO_MAX];
 
 int state_helper_verdict(int type, struct nf_conntrack *ct) 
 {
-	u_int8_t l4proto;
+	uint8_t l4proto;
 
         if (type == NFCT_Q_DESTROY)
 		return ST_H_REPLICATE;
diff --git a/src/state_helper_tcp.c b/src/state_helper_tcp.c
index e0a51ee..88af35e 100644
--- a/src/state_helper_tcp.c
+++ b/src/state_helper_tcp.c
@@ -22,7 +22,7 @@
 static int tcp_verdict(const struct state_replication_helper *h,
 		       const struct nf_conntrack *ct)
 {
-	u_int8_t t_state = nfct_get_attr_u8(ct, ATTR_TCP_STATE);
+	uint8_t t_state = nfct_get_attr_u8(ct, ATTR_TCP_STATE);
 	if (h->state & (1 << t_state))
 		return ST_H_REPLICATE;
 
diff --git a/src/sync-ftfw.c b/src/sync-ftfw.c
index 0943e68..f0b3262 100644
--- a/src/sync-ftfw.c
+++ b/src/sync-ftfw.c
@@ -44,7 +44,7 @@ static struct queue *tx_queue;
 struct cache_ftfw {
 	struct list_head 	rs_list;
 	struct list_head	tx_list;
-	u_int32_t 		seq;
+	uint32_t 		seq;
 };
 
 static void cache_ftfw_add(struct us_conntrack *u, void *data)
@@ -73,7 +73,7 @@ static struct cache_extra cache_ftfw_extra = {
 	.destroy	= cache_ftfw_del
 };
 
-static void tx_queue_add_ctlmsg(u_int32_t flags, u_int32_t from, u_int32_t to)
+static void tx_queue_add_ctlmsg(uint32_t flags, uint32_t from, uint32_t to)
 {
 	struct nethdr_ack ack = {
 		.flags = flags,
diff --git a/src/traffic_stats.c b/src/traffic_stats.c
index b6fa030..93511ce 100644
--- a/src/traffic_stats.c
+++ b/src/traffic_stats.c
@@ -42,9 +42,9 @@ void dump_traffic_stats(int fd)
 {
 	char buf[512];
 	int size;
-	u_int64_t bytes = STATE(bytes)[NFCT_DIR_ORIGINAL] +
+	uint64_t bytes = STATE(bytes)[NFCT_DIR_ORIGINAL] +
 			  STATE(bytes)[NFCT_DIR_REPLY];
-	u_int64_t packets = STATE(packets)[NFCT_DIR_ORIGINAL] +
+	uint64_t packets = STATE(packets)[NFCT_DIR_ORIGINAL] +
 			    STATE(packets)[NFCT_DIR_REPLY];
 
 	size = sprintf(buf, "traffic processed:\n");