From a8f06005be7e61f0562d8c36d953f688922edf01 Mon Sep 17 00:00:00 2001
From: "/C=EU/ST=EU/CN=Pablo Neira Ayuso/emailAddress=pablo@netfilter.org"
 </C=EU/ST=EU/CN=Pablo Neira Ayuso/emailAddress=pablo@netfilter.org>
Date: Thu, 17 Jan 2008 16:56:50 +0000
Subject: Max Kellermann <max@duempel.org>: use C99 integers (uint32_t instead
 of u_int32_t)

---
 src/build.c            | 30 +++++++++++++++---------------
 src/cache.c            | 18 +++++++++---------
 src/conntrack.c        |  6 +++---
 src/hash.c             | 12 ++++++------
 src/ignore_pool.c      | 20 ++++++++++----------
 src/mcast.c            |  4 ++--
 src/netlink.c          |  4 ++--
 src/network.c          |  2 +-
 src/parse.c            |  6 +++---
 src/state_helper.c     |  2 +-
 src/state_helper_tcp.c |  2 +-
 src/sync-ftfw.c        |  4 ++--
 src/traffic_stats.c    |  4 ++--
 13 files changed, 57 insertions(+), 57 deletions(-)

(limited to 'src')

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");
-- 
cgit v1.2.3