diff -Naur sipcalc-1.1.5.orig/include/sub.h sipcalc-1.1.5/include/sub.h

--- sipcalc-1.1.5.orig/include/sub.h	2005-11-02 10:27:04.000000000 +0100

+++ sipcalc-1.1.5/include/sub.h	2012-01-24 18:42:05.979999552 +0100

@@ -75,6 +75,12 @@

 #define V6ADDR_VAL "0123456789ABCDEFabcdef:"

 #define NETMASK_VAL "0123456789"

+#define TERMINATE(x) (x[sizeof(x)-1]='\0')

+#define safe_strncpy(dest,src) strncpy(dest,src,sizeof(dest)-1+TERMINATE(dest)*0)

+#define safe_strncat(dest,src) strncat(dest,src,sizeof(dest)-1+TERMINATE(dest)*0)

+#define safe_snprintf(dest,whatever...) snprintf(dest,sizeof(dest),## whatever)

+#define safe_bzero(dest) bzero((char *)dest,sizeof(dest))

+

 /*

  * Easier to define this ourselves then to use all the different

  * versions from different platforms.

diff -Naur sipcalc-1.1.5.orig/src/interface.c sipcalc-1.1.5/src/interface.c

--- sipcalc-1.1.5.orig/src/interface.c	2003-03-19 13:28:15.000000000 +0100

+++ sipcalc-1.1.5/src/interface.c	2012-01-24 19:05:01.453000525 +0100

@@ -60,10 +60,10 @@

 	n_if = ifarg_cur->next;

 	n_if->next = NULL;

 	bzero ((char *) n_if->name, IFNAMSIZ + 1);

-	bzero ((char *) n_if->p_v4addr, 19);

-	bzero ((char *) n_if->p_v4nmask, 16);

-	bzero ((char *) n_if->errorstr, 64);

-	bzero ((char *) n_if->cmdstr, 128);

+	safe_bzero (n_if->p_v4addr);

+	safe_bzero (n_if->p_v4nmask);

+	safe_bzero (n_if->errorstr);

+	safe_bzero (n_if->cmdstr);

 	n_if->type = 0;

 	return n_if;

diff -Naur sipcalc-1.1.5.orig/src/sub.c sipcalc-1.1.5/src/sub.c

--- sipcalc-1.1.5.orig/src/sub.c	2009-07-20 22:33:18.000000000 +0200

+++ sipcalc-1.1.5/src/sub.c	2012-01-24 19:09:15.453000027 +0100

@@ -194,26 +194,26 @@

 	char buf[2], sbuf[128], dbuf[128], *arg1, *arg2;

 	int x, y, z, argmax;

-	bzero ((char *) buf, 2);

+	safe_bzero (buf);

 	argmax = (IFNAMSIZ + 1 > 19) ? IFNAMSIZ + 1 : 19;

 	arg1 = (char *) malloc (argmax);

 	arg2 = (char *) malloc (16);

 	bzero ((char *) arg1, argmax);

 	bzero ((char *) arg2, 16);

-	bzero ((char *) sbuf, 128);

-	bzero ((char *) dbuf, 128);

+	safe_bzero (sbuf);

+	safe_bzero (dbuf);

 	while (!sbuf[0]) {

 		x = 0;

 		y = 0;

-		bzero ((char *) sbuf, 128);

+		safe_bzero (sbuf);

 		do {

 			x = read (0, buf, 1);

 			if (x == 1)

 				sbuf[y] = buf[0];

 			y++;

-		} while (x > 0 && buf[0] != '\n' && y < 127);

+		} while (x > 0 && buf[0] != '\n' && y < (sizeof(sbuf)-1));

 		if (x < 0) {

 			free (arg1);

 			free (arg2);

@@ -272,7 +272,7 @@

 {

 	abox->next = (struct argbox *) malloc (sizeof (struct argbox));

 	abox = abox->next;

-	bzero ((char *) abox, 128);

+	safe_bzero (abox->str);

 	abox->type = 0;

 	abox->resolv = 0;

 	abox->next = NULL;

@@ -313,14 +313,13 @@

 	 * We use goto's here *gasp*.

 	 */

 	while (argv[argcount]) {

-		bzero ((char *) expaddr, 128);

-

-		strncpy (expaddr, argv[argcount], 127);

+		safe_bzero (expaddr);

+		safe_strncpy (expaddr, argv[argcount]);

 		/*

 		 * Baaad argument.

 		 */

-		if (strlen (argv[argcount]) > 127) {

+		if (strlen (argv[argcount]) > sizeof(expaddr)-1) {

 			printf ("-[ERR : INVALID ARG - %s]\n", expaddr);

 			error = 1;

 			goto complete;

@@ -331,7 +330,7 @@

 		 */

 		x = validate_v6addr (expaddr);

 		if (x) {

-			strncpy (abox_cur->str, expaddr, 127);

+			safe_strncpy (abox_cur->str, expaddr);

 			abox_cur->type = AT_V6;

 			abox_cur->resolv = 0;

 			abox_cur = new_arg (abox_cur);

@@ -347,7 +346,7 @@

 		 */

 		x = validate_netmask (expaddr);

 		if (x == 2) {

-			strncpy (abox_cur->str, expaddr, 127);

+			safe_strncpy (abox_cur->str, expaddr);

 			abox_cur->type = AT_V4;

 			abox_cur->resolv = 0;

 			abox_cur = new_arg (abox_cur);

@@ -386,17 +385,17 @@

 		if (argcount + 1 < argc)

 			y = validate_netmask (argv[argcount + 1]);

 		if (y == 1 || y == 3) {

-			snprintf (abox_cur->str, 127, "%s %s", expaddr, argv[argcount + 1]);

+			safe_snprintf (abox_cur->str, "%s %s", expaddr, argv[argcount + 1]);

 			argcount++;

 		}

 		else

-			strncpy (abox_cur->str, expaddr, 127);

+			safe_strncpy (abox_cur->str, expaddr);

 		abox_cur->type = AT_UNKWN;

 		abox_cur->resolv = 1;

 		abox_cur = new_arg (abox_cur);

 complete:

-		bzero ((char *) expaddr, 128);

+		safe_bzero (expaddr);

 		argcount++;

 	}

@@ -428,8 +427,8 @@

 	    (struct if_info *) malloc (sizeof (struct if_info));

 	ifarg_cur->next = NULL;

 	bzero ((char *) ifarg_cur->name, IFNAMSIZ);

-	bzero ((char *) ifarg_cur->p_v4addr, 19);

-	bzero ((char *) ifarg_cur->p_v4nmask, 16);

+	safe_bzero (ifarg_cur->p_v4addr);

+	safe_bzero (ifarg_cur->p_v4nmask);

 	while (abox) {

 		if (abox->type == AT_V4 && !abox->resolv) {

@@ -449,19 +448,19 @@

 				x++;

 			}

 			ifarg_cur->type = IFT_V4;

-			strncpy (ifarg_cur->cmdstr, abox->str, 127);

+			safe_strncpy (ifarg_cur->cmdstr, abox->str);

 		}

 		if (abox->type == AT_V4 && abox->resolv) {

 			d_resp_start = d_resp_cur = (struct dnsresp *) malloc (sizeof (struct dnsresp));

 			d_resp_start->next = NULL;

-			bzero((char *) d_resp_start->str, 128);

+			safe_bzero(d_resp_start->str);

 			d_resp_start->type = 0;

 			tmpstr = resolve_addr (abox->str, PF_INET, d_resp_cur);

 			if (tmpstr) {

 				d_resp_cur = d_resp_start;

 				while (d_resp_cur) {

-					strncpy (ifarg_cur->cmdstr, abox->str, 127);

+					safe_strncpy (ifarg_cur->cmdstr, abox->str);

 					tmpstr = strstr (d_resp_cur->str, " ");

 					if (tmpstr != NULL && (strlen (tmpstr) > 0)) {

 						tmpstr++;

@@ -484,8 +483,8 @@

 				}

 			}

 			else {

-				strncpy (ifarg_cur->p_v4addr, abox->str, 18);

-				strncpy (ifarg_cur->cmdstr, abox->str, 127);

+				safe_strncpy (ifarg_cur->p_v4addr, abox->str);

+				safe_strncpy (ifarg_cur->cmdstr, abox->str);

 				ifarg_cur->type = IFT_V4;

 			}

@@ -493,8 +492,8 @@

 		}

 		if (abox->type == AT_V6 && !abox->resolv) {

-			strncpy (ifarg_cur->p_v6addr, abox->str, 43);

-			strncpy (ifarg_cur->cmdstr, abox->str, 127);

+			safe_strncpy (ifarg_cur->p_v6addr, abox->str);

+			safe_strncpy (ifarg_cur->cmdstr, abox->str);

 			mk_ipv6addr (&ifarg_cur->v6ad, ifarg_cur->p_v6addr);

 			ifarg_cur->type = IFT_V6;

@@ -503,14 +502,14 @@

 		if (abox->type == AT_V6 && abox->resolv) {

 			d_resp_start = d_resp_cur = (struct dnsresp *) malloc (sizeof (struct dnsresp));

 			d_resp_start->next = NULL;

-			bzero((char *) d_resp_start->str, 128);

+			safe_bzero(d_resp_start->str);

 			d_resp_start->type = 0;

 			tmpstr = resolve_addr (abox->str, PF_INET6, d_resp_cur);

 			if (tmpstr) {

 				d_resp_cur = d_resp_start;

 				while (d_resp_cur) {

-					strncpy (ifarg_cur->cmdstr, abox->str, 127);

-					strncpy (ifarg_cur->p_v6addr, d_resp_cur->str, 43);

+					safe_strncpy (ifarg_cur->cmdstr, abox->str);

+					safe_strncpy (ifarg_cur->p_v6addr, d_resp_cur->str);

 					ifarg_cur->type = IFT_V6;

 					mk_ipv6addr (&ifarg_cur->v6ad, ifarg_cur->p_v6addr);

@@ -521,8 +520,8 @@

 				}

 			}

 			else {

-				strncpy (ifarg_cur->cmdstr, abox->str, 127);

-				strncpy (ifarg_cur->p_v6addr, abox->str, 43);

+				safe_strncpy (ifarg_cur->cmdstr, abox->str);

+				safe_strncpy (ifarg_cur->p_v6addr, abox->str);

 				ifarg_cur->type = IFT_V6;

 				mk_ipv6addr (&ifarg_cur->v6ad, ifarg_cur->p_v6addr);

@@ -542,15 +541,15 @@

 					}

 					memcpy ((struct if_info *) ifarg_cur, (struct if_info *) if_cur, sizeof (struct if_info));

 					ifarg_cur->type = IFT_INTV4;

-					strncpy (ifarg_cur->cmdstr, abox->str, 127);

+					safe_strncpy (ifarg_cur->cmdstr, abox->str);

 					if_found = 1;

 				}

 				if_cur = if_cur->next;

 			}

 			if (!if_found) {

 				strncpy (ifarg_cur->name, abox->str, IFNAMSIZ);

-				strncpy (ifarg_cur->cmdstr, abox->str, 127);

-				snprintf(ifarg_cur->errorstr, sizeof(ifarg_cur->errorstr), "Unable to retrieve interface information");

+				safe_strncpy (ifarg_cur->cmdstr, abox->str);

+				safe_snprintf(ifarg_cur->errorstr, "Unable to retrieve interface information");

 				ifarg_cur->type = IFT_INTV4;

 			}

 		}

@@ -566,15 +565,15 @@

 					}

 					memcpy ((struct if_info *) ifarg_cur, (struct if_info *) if_cur, sizeof (struct if_info));

 					ifarg_cur->type = IFT_INTV4;

-					strncpy (ifarg_cur->cmdstr, abox->str, 127);

+					safe_strncpy (ifarg_cur->cmdstr, abox->str);

 					if_found = 1;

 				}

 				if_cur = if_cur->next;

 			}

 			if (!if_found) {

 				strncpy (ifarg_cur->name, abox->str, IFNAMSIZ);

-				strncpy (ifarg_cur->cmdstr, abox->str, 127);

-				snprintf(ifarg_cur->errorstr, sizeof(ifarg_cur->errorstr), "Unable to retrieve interface information");

+				safe_strncpy (ifarg_cur->cmdstr, abox->str);

+				safe_snprintf(ifarg_cur->errorstr, "Unable to retrieve interface information");

 				ifarg_cur->type = IFT_INTV4;

 			}

 		}

@@ -582,15 +581,15 @@

 		if (abox->type == AT_UNKWN && abox->resolv) {

 			d_resp_start = d_resp_cur = (struct dnsresp *) malloc (sizeof (struct dnsresp));

 			d_resp_start->next = NULL;

-			bzero((char *) d_resp_start->str, 128);

+			safe_bzero(d_resp_start->str);

 			d_resp_start->type = 0;

 			tmpstr = resolve_addr (abox->str, PF_UNSPEC, d_resp_cur);

 			if (tmpstr) {

 				d_resp_cur = d_resp_start;

 				while (d_resp_cur) {

-					strncpy (ifarg_cur->cmdstr, abox->str, 127);

+					safe_strncpy (ifarg_cur->cmdstr, abox->str);

 					if (d_resp_cur->type == AF_INET6) {

-						strncpy (ifarg_cur->p_v6addr, d_resp_cur->str, 43);

+						safe_strncpy (ifarg_cur->p_v6addr, d_resp_cur->str);

 						ifarg_cur->type = IFT_V6;

 						mk_ipv6addr (&ifarg_cur->v6ad, ifarg_cur->p_v6addr);

@@ -631,14 +630,14 @@

 						}

 						memcpy ((struct if_info *) ifarg_cur, (struct if_info *) if_cur, sizeof (struct if_info));

 						ifarg_cur->type = IFT_INTV4;

-						strncpy (ifarg_cur->cmdstr, abox->str, 127);

+						safe_strncpy (ifarg_cur->cmdstr, abox->str);

 						if_found = 1;

 					}

 					if_cur = if_cur->next;

 				}

 				if (!if_found) {

-					strncpy (ifarg_cur->cmdstr, abox->str, 127);

-					snprintf(ifarg_cur->errorstr, sizeof(ifarg_cur->errorstr), "Unparsable argument.");

+					safe_strncpy (ifarg_cur->cmdstr, abox->str);

+					safe_snprintf(ifarg_cur->errorstr, "Unparsable argument.");

 					ifarg_cur->type = IFT_UNKWN;

 				}

@@ -728,7 +727,7 @@

 	 * v[4,6]args.

 	 */

 	abox_start = abox_cur = (struct argbox *) malloc (sizeof (struct argbox));

-	bzero ((char *) abox_cur, 128);

+	safe_bzero (abox_cur->str);

 	abox_cur->type = 0;

 	abox_cur->resolv = 0;

 	abox_cur->next = NULL;

@@ -822,7 +821,7 @@

 			printf ("Try '%s -h' for more information.\n", NAME);

 			return 0;

 		case '4':

-			strncpy (abox_cur->str, optarg, 127);

+			safe_strncpy (abox_cur->str, optarg);

 			abox_cur->type = AT_V4;

 			abox_cur->resolv = 1;

 			if (validate_netmask (optarg) == 2)

@@ -833,7 +832,7 @@

 			break;

 		case '6':

-			strncpy (abox_cur->str, optarg, 127);

+			safe_strncpy (abox_cur->str, optarg);

 			abox_cur->type = AT_V6;

 			abox_cur->resolv = 1;

 			if (validate_v6addr (expaddr) == 1)

@@ -842,7 +841,7 @@

 			break;

 		case 'I':

-			strncpy (abox_cur->str, optarg, 127);

+			safe_strncpy (abox_cur->str, optarg);

 			abox_cur->type = AT_INT;

 			abox_cur->resolv = 0;

 			abox_cur = new_arg (abox_cur);

@@ -936,7 +935,7 @@

 	iffound = 0;

 	index = 0;

 	ifarg_cur = ifarg_start;

-	bzero ((char *) oldcmdstr, 128);

+	safe_bzero (oldcmdstr);

 	while (ifarg_cur && !parse_stdin) {

 		if (strlen (ifarg_cur->cmdstr) > 0) {

 			if (!strcmp (ifarg_cur->cmdstr, oldcmdstr))

@@ -948,7 +947,7 @@

 			index = 0;

 		}

 		iffound += out_cmdline (ifarg_cur, v4args, m_argv4, v6args, m_argv6, 0, index);

-		strcpy (oldcmdstr, ifarg_cur->cmdstr);

+		safe_strncpy (oldcmdstr, ifarg_cur->cmdstr);

 		ifarg_cur = ifarg_cur->next;

 	}

@@ -991,7 +990,7 @@

 				iffound = 0;

 				index = 0;

 				ifarg_cur = ifarg_start;

-				bzero ((char *) oldcmdstr, 128);

+				safe_bzero (oldcmdstr);

 				while (ifarg_cur) {

 					if (strlen (ifarg_cur->cmdstr) > 0) {

 						if (!strcmp (ifarg_cur->cmdstr, oldcmdstr))

@@ -1003,7 +1002,7 @@

 						index = 0;

 					}

 					iffound += out_cmdline (ifarg_cur, v4args, m_argv4, v6args, m_argv6, 0, index);

-					strcpy (oldcmdstr, ifarg_cur->cmdstr);

+					safe_strncpy (oldcmdstr, ifarg_cur->cmdstr);

 					ifarg_cur = ifarg_cur->next;

 				}

 			}

@@ -1012,7 +1011,7 @@

 			free_if (ifarg_start);

 			free_boxargs (abox_start);

 			abox_start = abox_cur = (struct argbox *) malloc (sizeof (struct argbox));

-			bzero ((char *) abox_cur, 128);

+			safe_bzero (abox_cur->str);

 			abox_cur->type = 0;

 			abox_cur->resolv = 0;

 			abox_cur->next = NULL;

diff -Naur sipcalc-1.1.5.orig/src/sub-func.c sipcalc-1.1.5/src/sub-func.c

--- sipcalc-1.1.5.orig/src/sub-func.c	2006-11-10 10:46:45.000000000 +0100

+++ sipcalc-1.1.5/src/sub-func.c	2012-01-24 19:02:51.245000309 +0100

@@ -115,7 +115,7 @@

 	y = 0;

 	for (x = 0; x < 4; x++) {

 		z = 0;

-		bzero ((char *) buf, 16);

+		safe_bzero (buf);

 		while (addr[y] != '.' && y < strlen (addr)) {

 			buf[z] = addr[y];

 			y++;

@@ -177,7 +177,7 @@

 	if (x == 1)

 		return 3;

-	bzero ((char *) addr, 16);

+	safe_bzero (addr);

 	if (strstr (in_addr, "/")) {

 		x = 0;

 		while (in_addr[x] != '/' && x < 15) {

@@ -185,7 +185,7 @@

 			x++;

 		}

 	} else {

-		strncpy (addr, in_addr, 16);

+		safe_strncpy (addr, in_addr);

 	}

 	/*

@@ -311,7 +311,7 @@

 	if (!validate_v4addr (quad))

 		return -1;

-	bzero ((char *) buf, 128);

+	safe_bzero (buf);

 	x = 0;

 	while (quad[x] != '.') {

 		buf[x] = quad[x];

@@ -324,7 +324,7 @@

 		if (z > 255 || z < 0)

 			return -1;

 		*num = *num | (z << (8 * (3 - y)));

-		bzero ((char *) buf, 128);

+		safe_bzero (buf);

 		z = 0;

 		while (quad[x] != '.' && quad[x] != '\0' && x < strlen (quad)) {

 			buf[z] = quad[x];

@@ -345,8 +345,8 @@

 	for (x = 0; x < 4; x++)

 		a[x] = num >> (8 * (3 - x)) & 0xff;

-	bzero ((char *) quad, 17);

-	snprintf (quad, 16, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);

+	safe_bzero (quad);

+	safe_snprintf (quad, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);

 	return quad;

 }

@@ -357,7 +357,7 @@

 	static char bitmap[36];

 	int x, y, z;

-	bzero ((char *) bitmap, 36);

+	safe_bzero (bitmap);

 	y = 1;

 	z = 0;

 	for (x = 0; x < 32; x++) {

@@ -384,8 +384,8 @@

 	char *s_find;

 	int x, y, z;

-	bzero ((char *) buf, 128);

-	bzero ((char *) buf2, 128);

+	safe_bzero (buf);

+	safe_bzero (buf2);

 	ifi->v4ad.n_nmaskbits = 0;

 	/*

@@ -509,7 +509,7 @@

 	/*

 	 * network class, class remark and classfull netmask

 	 */

-	bzero ((char *) ifi->v4ad.class_remark, 64);

+	safe_bzero (ifi->v4ad.class_remark);

 	x = ifi->v4ad.n_haddr >> 24;

 	ifi->v4ad.n_cnaddr = 0;

 	if (!(x & 0x80)) {

@@ -526,18 +526,18 @@

 	}

 	if ((x & 0xf0) == 0xe0) {

 		ifi->v4ad.class = 'D';

-		snprintf (ifi->v4ad.class_remark, 64, " (multicast network)");

+		safe_snprintf (ifi->v4ad.class_remark, " (multicast network)");

 		ifi->v4ad.n_cnmask = ifi->v4ad.n_nmask;

 	}

 	if ((x & 0xf8) == 0xf0) {

 		ifi->v4ad.class = 'E';

-		snprintf (ifi->v4ad.class_remark, 64,

+		safe_snprintf (ifi->v4ad.class_remark,

 			  " (reserved for future use)");

 		ifi->v4ad.n_cnmask = ifi->v4ad.n_nmask;

 	}

 	if (ifi->v4ad.class == '\0') {

 		ifi->v4ad.n_cnmask = ifi->v4ad.n_nmask;

-		snprintf (ifi->v4ad.class_remark, 64, "Nonexistant");

+		safe_snprintf (ifi->v4ad.class_remark, "Nonexistant");

 	}

 	/*

@@ -583,7 +583,7 @@

 	if (split && (count (addr, '/') == 1)) {

 		if (strlen (split) > 1 && strlen (split) < 5) {

 			split++;

-			strncpy (spstr->nmask, split, 3);

+			safe_strncpy (spstr->nmask, split);

 		}

 	}

@@ -776,7 +776,7 @@

 			y++;

 		}

-		bzero ((char *) str, 5);

+		safe_bzero (str);

 		x = 0;

 		while (y < strlen (addr) && addr[y] != ':') {

 			str[x] = addr[y];

@@ -786,7 +786,7 @@

 	}

 	if (compressed) {

-		bzero ((char *) str, 5);

+		safe_bzero (str);

 		if (pos <= cstart) {

 			x = 0;

 			y = 0;

@@ -824,7 +824,7 @@

 				y++;

 			}

-			bzero ((char *) str, 5);

+			safe_bzero (str);

 			x = 0;

 			while (y < strlen (addr) && addr[y] != ':') {

 				str[x] = addr[y];

@@ -865,7 +865,7 @@

 	}

 	if (type == V6TYPE_V4INV6) {

-		bzero ((char *) buf, 128);

+		safe_bzero (buf);

 		x = 0;

 		while (spstr.ipv4addr[x] != '.') {

 			buf[x] = spstr.ipv4addr[x];

@@ -883,7 +883,7 @@

 			}

 			n = atoi (buf);

-			bzero ((char *) buf, 128);

+			safe_bzero (buf);

 			z = 0;

 			while (spstr.ipv4addr[x] != '.'

 			       && spstr.ipv4addr[x] != '\0'

@@ -937,9 +937,9 @@

 	int x;

 	struct ipv6_split spstr;

-	bzero ((char *) spstr.ipv6addr, 40);

-	bzero ((char *) spstr.ipv4addr, 16);

-	bzero ((char *) spstr.nmask, 4);

+	safe_bzero (spstr.ipv6addr);

+	safe_bzero (spstr.ipv4addr);

+	safe_bzero (spstr.nmask);

 	split_ipv6addr (addr, &spstr);

@@ -1011,29 +1011,29 @@

 	a = in6_addr->haddr.sip6_addr16[0];

 	if (a == 0)

-		snprintf (in6_addr->class_remark, 63, "Reserved");

+		safe_snprintf (in6_addr->class_remark, "Reserved");

 	if (a == 2 || a == 3)

-		snprintf (in6_addr->class_remark, 63,

+		safe_snprintf (in6_addr->class_remark,

 			  "Reserved for NSAP Allocation");

 	if (a == 4 || a == 5)

-		snprintf (in6_addr->class_remark, 63,

+		safe_snprintf (in6_addr->class_remark,

 			  "Reserved for IPX Allocation");

 	if ((a & 0xe000) == 0x2000)

-		snprintf (in6_addr->class_remark, 63,

+		safe_snprintf (in6_addr->class_remark,

 			  "Aggregatable Global Unicast Addresses");

 	if ((a | 0x00ff) == 0x00ff)

-		snprintf (in6_addr->class_remark, 63, "Reserved");

+		safe_snprintf (in6_addr->class_remark, "Reserved");

 	if ((a & 0xff00) == 0xff00)

-		snprintf (in6_addr->class_remark, 63, "Multicast Addresses");

+		safe_snprintf (in6_addr->class_remark, "Multicast Addresses");

 	if ((a & 0xff80) == 0xfe80)

-		snprintf (in6_addr->class_remark, 63,

+		safe_snprintf (in6_addr->class_remark,

 			  "Link-Local Unicast Addresses");

 	if ((a & 0xffc0) == 0xfec0)

-		snprintf (in6_addr->class_remark, 63,

+		safe_snprintf (in6_addr->class_remark,

 			  "Site-Local Unicast Addresses");

 	if (in6_addr->class_remark[0] == '\0')

-		snprintf (in6_addr->class_remark, 63, "Unassigned");

+		safe_snprintf (in6_addr->class_remark, "Unassigned");

 	return;

 }

@@ -1049,7 +1049,7 @@

 			y = 1;

 	}

 	if (!y)

-		snprintf (in6_addr->comment, 63, "Unspecified");

+		safe_snprintf (in6_addr->comment, "Unspecified");

 	y = 0;

 	for (x = 0; x < 7; x++) {

@@ -1058,7 +1058,7 @@

 	}

 	if (!y)

 		if (in6_addr->haddr.sip6_addr16[7] == 1)

-			snprintf (in6_addr->comment, 63, "Loopback");

+			safe_snprintf (in6_addr->comment, "Loopback");

 	return;

 }

@@ -1092,7 +1092,7 @@

 	int x, y, z;

 	int start, num;

-	bzero ((char *) outad, 44);

+	safe_bzero (outad);

 	start = -1;

 	num = 0;

@@ -1121,15 +1121,15 @@

 	for (x = 0; x < 8; x++) {

 		if (x == start) {

 			if (!x)

-				strcat (outad, ":");

-			strcat (outad, ":");

+				safe_strncat (outad, ":");

+			safe_strncat (outad, ":");

 			x += num - 1;

 		} else {

-			bzero ((char *) tmpad, 5);

-			sprintf (tmpad, "%x", addr.sip6_addr16[x]);

-			strcat (outad, tmpad);

+			safe_bzero (tmpad);

+			safe_snprintf (tmpad, "%x", addr.sip6_addr16[x]);

+			safe_strncat (outad, tmpad);

 			if (x != 7)

-				strcat (outad, ":");

+				safe_strncat (outad, ":");

 		}

 	}

@@ -1142,9 +1142,9 @@

 	int x, y, z;

 	struct ipv6_split spstr;

-	bzero ((char *) spstr.ipv6addr, 40);

-	bzero ((char *) spstr.ipv4addr, 16);

-	bzero ((char *) spstr.nmask, 4);

+	safe_bzero (spstr.ipv6addr);

+	safe_bzero (spstr.ipv4addr);

+	safe_bzero (spstr.nmask);

 	split_ipv6addr (addr, &spstr);

@@ -1195,9 +1195,9 @@

 	v6addrtobroadcast (in6_addr);

 	in6_addr->real_v4 = v6verifyv4 (in6_addr->haddr);

-	bzero ((char *) in6_addr->class_remark, 64);

+	safe_bzero (in6_addr->class_remark);

 	v6_type (in6_addr);

-	bzero ((char *) in6_addr->comment, 64);

+	safe_bzero (in6_addr->comment);

 	v6_comment (in6_addr);

 	return 0;

@@ -1209,7 +1209,7 @@

 	d_resp->next = (struct dnsresp *) malloc (sizeof (struct dnsresp));

 	d_resp = d_resp->next;

 	d_resp->next = NULL;

-	bzero((char *) d_resp->str, 128);

+	safe_bzero(d_resp->str);

 	d_resp->type = 0;

 	return d_resp;

@@ -1235,17 +1235,17 @@

 	static char retaddr[1024];

 	int x;

-	bzero ((char *) retaddr, 1024);

+	safe_bzero (retaddr);

 	he = gethostbyname (raddr);

 	if (!he)

 		return NULL;

 	if (he->h_addrtype == AF_INET) {

-		snprintf (retaddr, 1023, "%s%s", inet_ntoa (*(struct in_addr *) he->h_addr_list[0]), extra);

+		safe_snprintf (retaddr, "%s%s", inet_ntoa (*(struct in_addr *) he->h_addr_list[0]), extra);

 		x = 0;

 		while (he->h_addr_list[x]) {

-			snprintf (d_resp->str, 127, "%s%s", inet_ntoa (*(struct in_addr *) he->h_addr_list[x]), extra);

+			safe_snprintf (d_resp->str, "%s%s", inet_ntoa (*(struct in_addr *) he->h_addr_list[x]), extra);

 			d_resp->type = AF_INET;

 			x++;

 			if (he->h_addr_list[x])

@@ -1275,18 +1275,18 @@

 	char ip6addr[128];

 	int x;

-	bzero ((char *) retaddr, 1024);

+	safe_bzero (retaddr);

 	he = gethostbyname2 (raddr, AF_INET6);

 	if (!he)

 		return NULL;

 	if (he->h_addrtype == AF_INET6) {

-		bzero ((char *) ip6addr, 128);

-		snprintf (retaddr, 1023, "%s%s", inet_ntop (AF_INET6, he->h_addr_list[0], ip6addr, 128), extra);

+		safe_bzero (ip6addr);

+		safe_snprintf (retaddr, "%s%s", inet_ntop (AF_INET6, he->h_addr_list[0], ip6addr, 128), extra);

 		x = 0;

 		while (he->h_addr_list[x]) {

-			snprintf (d_resp->str, 127, "%s%s", inet_ntop (AF_INET6, he->h_addr_list[x], ip6addr, 128), extra);

+			safe_snprintf (d_resp->str, "%s%s", inet_ntop (AF_INET6, he->h_addr_list[x], ip6addr, 128), extra);

 			d_resp->type = AF_INET6;

 			x++;

 			if (he->h_addr_list[x])

@@ -1331,11 +1331,11 @@

 	res_orig = res;

 	while (res) {

-		bzero ((char *) ip6addr, 128);

+		safe_bzero (ip6addr);

 		if (res->ai_family == PF_INET6) {

 			sin6 = (struct sockaddr_in6 *) res->ai_addr;

-			snprintf (retaddr, 1023, "%s%s", inet_ntop (AF_INET6, &sin6->sin6_addr, ip6addr, 128), extra);

-			snprintf (d_resp->str, 127, "%s%s", inet_ntop (AF_INET6, &sin6->sin6_addr, ip6addr, 128), extra);

+			safe_snprintf (retaddr, "%s%s", inet_ntop (AF_INET6, &sin6->sin6_addr, ip6addr, 128), extra);

+			safe_snprintf (d_resp->str, "%s%s", inet_ntop (AF_INET6, &sin6->sin6_addr, ip6addr, 128), extra);

 			d_resp->type = AF_INET6;

 		}

 		if (res->ai_next && (res->ai_family == PF_INET || res->ai_family == PF_INET6))

@@ -1384,17 +1384,17 @@

 	res_orig = res;

 	while (res) {

-		bzero ((char *) ip6addr, 128);

+		safe_bzero (ip6addr);

 		if (res->ai_family == PF_INET) {

 			sin = (struct sockaddr_in *) res->ai_addr;

-			snprintf (retaddr, 1023, "%s%s", inet_ntoa (sin->sin_addr), extra);

-			snprintf(d_resp->str, 127, "%s%s", inet_ntoa (sin->sin_addr), extra);

+			safe_snprintf (retaddr, "%s%s", inet_ntoa (sin->sin_addr), extra);

+			safe_snprintf(d_resp->str, "%s%s", inet_ntoa (sin->sin_addr), extra);

 			d_resp->type = AF_INET;

 		}

 		if (res->ai_family == PF_INET6) {

 			sin6 = (struct sockaddr_in6 *) res->ai_addr;

-			snprintf (retaddr, 1023, "%s%s", inet_ntop (AF_INET6, &sin6->sin6_addr, ip6addr, 128), extra);

-			snprintf (d_resp->str, 127, "%s%s", inet_ntop (AF_INET6, &sin6->sin6_addr, ip6addr, 128), extra);

+			safe_snprintf (retaddr, "%s%s", inet_ntop (AF_INET6, &sin6->sin6_addr, ip6addr, 128), extra);

+			safe_snprintf (d_resp->str, "%s%s", inet_ntop (AF_INET6, &sin6->sin6_addr, ip6addr, 128), extra);

 			d_resp->type = AF_INET6;

 		}

 		if (res->ai_next && (res->ai_family == PF_INET || res->ai_family == PF_INET6))

@@ -1479,30 +1479,30 @@

 	if (family == PF_UNSPEC && !ipv6_cap)

 		family = PF_INET;

-	bzero ((char *) extra, 32);

-	bzero ((char *) raddr, 1024);

+	safe_bzero (extra);

+	safe_bzero (raddr);

 	tmpstr = strstr (addr, "/");

 	if (tmpstr) {

-		strncpy (extra, tmpstr, 31);

+		safe_strncpy (extra, tmpstr);

 		strncpy (raddr, addr, strlen (addr) - strlen (tmpstr));

 	}

 	else {

 		tmpstr = strstr (addr, " ");

 		if (tmpstr) {

-			strncpy (extra, tmpstr, 31);

+			safe_strncpy (extra, tmpstr);

 			strncpy (raddr, addr, strlen (addr) - strlen (tmpstr));

 		}

 		else

-			strncpy (raddr, addr, 1023);

+			safe_strncpy (raddr, addr);

 	}

-	bzero ((char *) retaddr, 1024);

+	safe_bzero (retaddr);

 	if (family == PF_INET) {

 		tmpstr = _resolv_v4_ghbn (raddr, d_resp, extra);

 		if (!tmpstr)

 			return NULL;

-		strncpy (retaddr, tmpstr, 1024);

+		safe_strncpy (retaddr, tmpstr);

 		return retaddr;

 	}

@@ -1511,7 +1511,7 @@

 			tmpstr = _resolv_v6_gai (raddr, d_resp, extra);

 			if (!tmpstr)

 				return NULL;

-			strncpy (retaddr, tmpstr, 1024);

+			safe_strncpy (retaddr, tmpstr);

 			return retaddr;

 		}

@@ -1519,7 +1519,7 @@

 			tmpstr = _resolv_v6_ghbn2 (raddr, d_resp, extra);

 			if (!tmpstr)

 				return NULL;

-			strncpy (retaddr, tmpstr, 1024);

+			safe_strncpy (retaddr, tmpstr);

 			return retaddr;

 		}

 	}

@@ -1529,13 +1529,13 @@

 			tmpstr = _resolv_unspec_gai (raddr, d_resp, extra);

 			if (!tmpstr)

 				return NULL;

-			strncpy (retaddr, tmpstr, 1024);

+			safe_strncpy (retaddr, tmpstr);

 			return retaddr;

 		}

 		if (f_gethostbyname && f_gethostbyname2) {

 			tmpstr = _resolv_v4_ghbn (raddr, d_resp, extra);

 			if (tmpstr) {

-				strncpy (retaddr, tmpstr, 1024);

+				safe_strncpy (retaddr, tmpstr);

 				d_resp_tmp = d_resp;

 				d_resp = new_dnsresp (d_resp);

 			}

diff -Naur sipcalc-1.1.5.orig/src/sub-output.c sipcalc-1.1.5/src/sub-output.c

--- sipcalc-1.1.5.orig/src/sub-output.c	2009-07-20 22:31:59.000000000 +0200

+++ sipcalc-1.1.5/src/sub-output.c	2012-01-24 18:44:29.468999531 +0100

@@ -135,11 +135,11 @@

 			printf ("%s\n", numtoquad (end));

 		}

 		if ((v4args & V4VERBSPLIT) == V4VERBSPLIT) {

-			bzero ((char *) ifi_tmp.p_v4addr, 19);

-			bzero ((char *) ifi_tmp.p_v4nmask, 16);

-			bzero ((char *) ifi_tmp.p_v6addr, 44);

-			snprintf (ifi_tmp.p_v4addr, 19, "%s", numtoquad (start));

-			snprintf (ifi_tmp.p_v4nmask, 16, "%s", numtoquad (splitmask));

+			safe_bzero (ifi_tmp.p_v4addr);

+			safe_bzero (ifi_tmp.p_v4nmask);

+			safe_bzero (ifi_tmp.p_v6addr);

+			safe_snprintf (ifi_tmp.p_v4addr, "%s", numtoquad (start));

+			safe_snprintf (ifi_tmp.p_v4nmask, "%s", numtoquad (splitmask));

 		}

 		start += diff;

 		if (end == 0xffffffff || end >= ifi->v4ad.n_broadcast)

@@ -447,11 +447,11 @@

 	char inbuf[40], outbuf[256];

 	int x, y;

-	bzero ((char *) inbuf, 40);

-	bzero ((char *) outbuf, 256);

+	safe_bzero (inbuf);

+	safe_bzero (outbuf);

-	snprintf

-	(inbuf, 39, "%04x%04x%04x%04x%04x%04x%04x%04x",

+	safe_snprintf

+	(inbuf, "%04x%04x%04x%04x%04x%04x%04x%04x",

 	 addr.sip6_addr16[0],

 	 addr.sip6_addr16[1],

 	 addr.sip6_addr16[2],

@@ -467,7 +467,7 @@

 		y += 2;

 	}

-	strcat (outbuf, "ip6.arpa.");

+	safe_strncat (outbuf, "ip6.arpa.");

 	printf("%s", outbuf);

 }

@@ -642,10 +642,10 @@

 		}