Suppressing warning about cast in inet & list

Warning : some cast can be wrong between uintptr_t to u_int* (long unsigned
int to unsigned int)

src/andna.c

 		 * ip and discard the rest of the snsd records
 		 */
 		snsd_add_mainip(&snsd_unpacked, &snsd_counter,
-						SNSD_MAX_QUEUE_RECORDS, rfrom.data);
+						SNSD_MAX_QUEUE_RECORDS,
+						(uintptr_t*)rfrom.data);
 	} else {
 		/*
 		 * Register the snsd records
 
 			/* Add the mainip and update its IP */
 			snd = snsd_add_mainip(&snsd_unpacked, &snsd_counter,
-								  SNSD_MAX_RECORDS, rfrom.data);
-			inet_copy_ipdata_raw(snd->record, &rfrom);
+								SNSD_MAX_RECORDS,
+								(uintptr_t*)rfrom.data);
+			inet_copy_ipdata_raw((u_int*)snd->record, &rfrom);
 
 			/**
 			 * Set the mainip flag only to the real mainip record,
 		if (service == SNSD_ALL_SERVICE ||
 			service == SNSD_DEFAULT_SERVICE || !ret)
 			snsd_add_mainip(&ret, &fake_counter,
-							SNSD_MAX_RECORDS, me.cur_ip.data);
+							SNSD_MAX_RECORDS,
+							(uintptr_t*)me.cur_ip.data);
 		return ret;
 	}
 

src/andna_cache.c

 
 			if (rhc_counter >= ANDNA_MAX_HOSTNAMES) {
 				/* Delete the oldest struct in cache */
-				rhc = list_last(andna_rhc);
+				rhc = (rh_cache *)list_last(andna_rhc);
 				clist_del(&andna_rhc, &rhc_counter, rhc);
 			}
 		}
 			 * snsd record 
 			 */
 			if (str_to_inet(records[1], &ip) >= 0) {
-				inet_copy_ipdata_raw(snsd_node.record, &ip);
+				inet_copy_ipdata_raw((u_int*)snsd_node.record, &ip);
 				snsd_node.flags = SNSD_NODE_IP;
 			} else {
 				hash_md5((u_char *) records[1], strlen(records[1]),

src/andns_snsd.c

 		return iplen + 2;
 	} else if (recursion) {
 		snsd_node snt;
-		res = snsd_main_ip(sn->record, &snt);
+		res = snsd_main_ip((u_int*)sn->record, &snt);
 		if (!res) {				/* I love recursion */
 			res = snsd_node_to_data(buf, &snt, prio, iplen, -1);
 			return res;
 					inet_htonl((u_int *) buf, family);
 					buf += iplen;
 				} else {
-					if (recursion && !snsd_main_ip(sn->record, &snt)) {
+					if (recursion && !snsd_main_ip((u_int*)sn->record, &snt)) {
 						memcpy(buf, snt.record, iplen);
 						*(buf - 4) |= 0x40;
 						family = (iplen == 4) ? AF_INET : AF_INET6;
 	int res;
 
 	if (!(sn->flags & SNSD_NODE_HNAME)) {
-		if (!(res = snsd_main_ip(sn->record, &snt)))
+		if (!(res = snsd_main_ip((u_int*)sn->record, &snt)))
 			return -1;
 		s = &snt;
 	} else

src/igs.c

 #include "qspn.h"
 #include "radar.h"
 #include "andns.h"
+#include "andna_cache.h"
 #include "netsukuku.h"
 #include "route.h"
 #include "krnl_rule.h"

src/inet.c

         }
 	return err;
 }
-#endif*/
+#endif*/

src/inet.h

 	u_char family;				/* AF_INET or AF_INET6 */
 	u_short len;				/* IP length: 4 or 16 (bytes) */
 	u_char bits;				/* Number of used bits of the IP */
-	u_int data[MAX_IP_INT];		/* The address is kept in host long format, 
-								   word ORDER 1 (most significant word first) */
+	/* TODO : check if data should be uintptr_t instead of u_int
+	   note: expected ‘uintptr_t * {aka long unsigned int *}’ but argument is of type ‘u_int * {aka unsigned int *}’
+	   But explicit cast has been added to suppress warnings
+	*/
+	u_int data[MAX_IP_INT];			/* The address is kept in host long format, 
+						   word ORDER 1 (most significant word first) */
 } inet_prefix;
 
 /* int_info struct used for packing the inet_prefix struct.

src/llist.c

 ({									\
 	 l_list *_il=(l_list *)(list);					\
 	 for(; _il && _il->next; _il=(l_list *)_il->next);		\
- 	 (typeof((list)))_il;						\
+	 _il;								\
 })
 
 /*

src/radar.c

 
 	rq = radar_q;
 	list_for(rq)
-		if (rq->node && ((int) rq->node != RADQ_EXT_RNODE)) {
+		if (rq->node && ((uintptr_t) rq->node != RADQ_EXT_RNODE)) {
 		xfree(rq->node);
 		rq->node = 0;
 	}
 			inet_copy(&to, &rq->ip);
 
 		} else {
-			rnodetoip((u_int) me.int_map, (u_int) node,
+			rnodetoip((uintptr_t) me.int_map, (uintptr_t) node,
 					  me.cur_quadg.ipstart[1], &to);
 		}
 
 		 * We need to know if it is a node which is not in the gnode
 		 * where we are (external_rnode).
 		 */
-		if ((int) rq->node == RADQ_EXT_RNODE) {
+		if ((uintptr_t) rq->node == RADQ_EXT_RNODE) {
 			external_node = 1;
 			total_levels = rq->quadg.levels;
 		} else {
 			  QUADG_GID | QUADG_GNODE | QUADG_IPSTART);
 
 	if (!(me.cur_node->flags & MAP_HNODE)) {
-		iptomap((u_int) me.int_map, pkt.from, me.cur_quadg.ipstart[1],
+		iptomap((uintptr_t) me.int_map, pkt.from, me.cur_quadg.ipstart[1],
 				&rnode);
 		ret = quadg_gids_cmp(me.cur_quadg, quadg, 1);
 	}
 
 	rq = radar_q;
 	list_for(rq) {
-		ret = iptomap((u_int) me.int_map, rq->ip, me.cur_quadg.ipstart[1],
+		ret = iptomap((uintptr_t) me.int_map, rq->ip, me.cur_quadg.ipstart[1],
 					  &rnode);
 		if (ret)
 			rq->node = (map_node *) RADQ_EXT_RNODE;

src/route.c

 			e_rnode = (ext_rnode *) gw_node[i];
 			inet_copy(&gw_ip[e], &e_rnode->quadg.ipstart[gw_level]);
 		} else
-			maptoip((u_int) int_map, (u_int) gw_node[i],
+			maptoip((uintptr_t) int_map, (uintptr_t) gw_node[i],
 					cur_quadg->ipstart[1], &gw_ip[e]);
 
 		if (gw_nodes)
 		for (i = 0, n = 0; i < node->links; i++) {
 			tmp_node = (map_node *) node->r_node[i].r_node;
 
-			maptoip((u_int) me.int_map, (u_int) tmp_node,
+			maptoip((uintptr_t) me.int_map, (uintptr_t) tmp_node,
 					me.cur_quadg.ipstart[1], &nh[n].gw);
 			inet_htonl(nh[n].gw.data, nh[n].gw.family);
 
 		e_rnode = (ext_rnode *) gw_node;
 		inet_copy(&nh[0].gw, &e_rnode->quadg.ipstart[0]);
 	} else
-		maptoip((u_int) me.int_map, (u_int) gw_node,
+		maptoip((uintptr_t) me.int_map, (uintptr_t) gw_node,
 				me.cur_quadg.ipstart[1], &nh[0].gw);
 	inet_htonl(nh[0].gw.data, nh[0].gw.family);
 	nh[0].dev = oifs[0]->dev_name;
 		gnodetoip(dst_quadg, node_pos, level, &to);
 	} else {
 		node_pos = pos_from_node(node, me.int_map);
-		maptoip((u_int) me.int_map, (u_int) node, me.cur_quadg.ipstart[1],
-				&to);
+		maptoip((uintptr_t) me.int_map, (uintptr_t) node,
+				me.cur_quadg.ipstart[1], &to);
 	}
 #ifdef DEBUG
 	to_ip = xstrdup(inet_to_str(to));

src/snsd_cache.c

 }
 
 snsd_node *
-snsd_find_node_by_record(snsd_node * snd, u_int record[MAX_IP_INT])
+snsd_find_node_by_record(snsd_node * snd, uintptr_t record[MAX_IP_INT])
 {
 	list_for(snd)
 		if (!memcmp(snd->record, record, MAX_IP_SZ))
  */
 snsd_node *
 snsd_add_node(snsd_node ** head, u_short * counter,
-			  u_short max_records, u_int record[MAX_IP_INT])
+			  u_short max_records, uintptr_t record[MAX_IP_INT])
 {
 	snsd_node *snd;
 
  */
 snsd_node *
 snsd_add_first_node(snsd_node ** head, u_short * counter,
-					u_short max_records, u_int record[MAX_IP_INT])
+					u_short max_records, uintptr_t record[MAX_IP_INT])
 {
 	if (!(*head) || !(*counter))
 		return snsd_add_node(head, counter, max_records, record);
  */
 snsd_node *
 snsd_add_mainip(snsd_service ** head, u_short * counter,
-				u_short max_records, u_int record[MAX_IP_INT])
+				u_short max_records, uintptr_t record[MAX_IP_INT])
 {
 	snsd_service *sns;
 	snsd_prio *snp;
 	buf += sizeof(char);
 
 	if (snd->flags & SNSD_NODE_IP)
-		inet_ntohl(snd->record, net_family);
+		inet_ntohl((u_int*)snd->record, net_family);
 
 	return snd;
 }

src/snsd_cache.h

 struct snsd_node {
 	LLIST_HDR(struct snsd_node);
 
-	u_int record[MAX_IP_INT];	/* It can be the IP or the md5
+	uintptr_t record[MAX_IP_INT];	/* It can be the IP or the md5
 								   hash of the hname of the 
 								   SNSD node */
 	RSA *pubkey;				/* pubkey of the snsd_node */
 snsd_prio *snsd_find_prio(snsd_prio * snp, u_char prio);
 snsd_prio *snsd_add_prio(snsd_prio ** head, u_char prio);
 snsd_node *snsd_find_node_by_record(snsd_node * snd,
-									u_int record[MAX_IP_INT]);
+									uintptr_t record[MAX_IP_INT]);
 snsd_node *snsd_add_node(snsd_node ** head, u_short * counter,
-						 u_short max_records, u_int record[MAX_IP_INT]);
+						 u_short max_records, uintptr_t record[MAX_IP_INT]);
 snsd_node *snsd_add_mainip(snsd_service ** head, u_short * counter,
-						   u_short max_records, u_int record[MAX_IP_INT]);
+						   u_short max_records, uintptr_t record[MAX_IP_INT]);
 void snsd_service_llist_del(snsd_service ** head);
 void snsd_record_del_selected(snsd_service ** head, u_short * snd_counter,
 							  snsd_service * selected);

src/tracer.c

 		external_node = 1;
 
 	if (!external_node) {
-		iptomap((u_int) me.int_map, rip, me.cur_quadg.ipstart[1], &from);
+		iptomap((uintptr_t) me.int_map, rip, me.cur_quadg.ipstart[1], &from);
 		ret = rnode_find(me.cur_node, from);
 	} else {
 		erc = e_rnode_find(me.cur_erc, quadg, 0);
 	 */
 
 	if (!level) {
-		iptomap((u_int) me.int_map, rip, me.cur_quadg.ipstart[1],
+		iptomap((uintptr_t) me.int_map, rip, me.cur_quadg.ipstart[1],
 				&real_from);
 		from = node_from_pos(tracer[hops - 1].node, me.int_map);
 	} else {