This is a multi-part message in MIME format.

--Boundary_(ID_Obmlpx3ktzR0AnJj04kJUw)
Content-type: text/plain; charset=ISO-8859-1
Content-transfer-encoding: 7BIT

FWIW, attached diff can be used to have uuencode/uudecode-internal
versions of the base64 routines to remove the dependency on the resolver
lib.

-e.

-- 
Elad Efrat

--Boundary_(ID_Obmlpx3ktzR0AnJj04kJUw)
Content-type: text/plain; name=uu.diff
Content-transfer-encoding: 7BIT
Content-disposition: inline; filename=uu.diff

Index: uuencode/uuencode.c
===================================================================
RCS file: /cvsroot/src/usr.bin/uuencode/uuencode.c,v
retrieving revision 1.12
diff -u -p -r1.12 uuencode.c
--- uuencode/uuencode.c	24 Sep 2006 15:32:48 -0000	1.12
+++ uuencode/uuencode.c	24 Sep 2006 19:25:50 -0000
@@ -50,11 +50,9 @@ __RCSID("$NetBSD: uuencode.c,v 1.12 2006
  */
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <netinet/in.h>
 #include <err.h>
 #include <errno.h>
 #include <locale.h>
-#include <resolv.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -64,6 +62,11 @@ int main(int, char *[]);
 static void encode(void);
 static void base64_encode(void);
 static void usage(void);
+int base64_ntop(u_char const *, size_t, char *, size_t);
+
+static const char Base64[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char Pad64 = '=';
 
 int
 main(int argc, char *argv[])
@@ -142,9 +145,9 @@ base64_encode(void)
 
 	while ((n = fread(buf, 1, sizeof(buf), stdin))) {
 		++sequence;
-		rv = b64_ntop(buf, n, buf2, (sizeof(buf2) / sizeof(buf2[0])));
+		rv = base64_ntop(buf, n, buf2, (sizeof(buf2) / sizeof(buf2[0])));
 		if (rv == -1)
-			errx(1, "b64_ntop: error encoding base64");
+			errx(1, "base64_ntop: error encoding base64");
 		printf("%s%s", buf2, (sequence % GROUPS) ? "" : "\n");
 	}
 	if (sequence % GROUPS)
@@ -200,3 +203,64 @@ usage(void)
 		      getprogname());
 	exit(1);
 }
+
+int
+base64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize)
+{
+	size_t datalength = 0;
+	u_char input[3];
+	u_char output[4];
+	size_t i;
+
+	while (2U < srclength) {
+		input[0] = *src++;
+		input[1] = *src++;
+		input[2] = *src++;
+		srclength -= 3;
+
+		output[0] = input[0] >> 2;
+		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+		output[3] = input[2] & 0x3f;
+
+		if (output[0] >= 64 || output[1] >= 64 ||
+		    output[2] >= 64 || output[3] >= 64)
+			return (-1);
+
+		if (datalength + 4 > targsize)
+			return (-1);
+		target[datalength++] = Base64[output[0]];
+		target[datalength++] = Base64[output[1]];
+		target[datalength++] = Base64[output[2]];
+		target[datalength++] = Base64[output[3]];
+	}
+    
+	/* Now we worry about padding. */
+	if (0U != srclength) {
+		/* Get what's left. */
+		input[0] = input[1] = input[2] = '\0';
+		for (i = 0; i < srclength; i++)
+			input[i] = *src++;
+	
+		output[0] = input[0] >> 2;
+		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+
+		if (output[0] >= 64 || output[1] >= 64 || output[2] >= 64)
+			return (-1);
+
+		if (datalength + 4 > targsize)
+			return (-1);
+		target[datalength++] = Base64[output[0]];
+		target[datalength++] = Base64[output[1]];
+		if (srclength == 1U)
+			target[datalength++] = Pad64;
+		else
+			target[datalength++] = Base64[output[2]];
+		target[datalength++] = Pad64;
+	}
+	if (datalength >= targsize)
+		return (-1);
+	target[datalength] = '\0';	/* Returned value doesn't count \0. */
+	return (datalength);
+}
Index: uudecode/uudecode.c
===================================================================
RCS file: /cvsroot/src/usr.bin/uudecode/uudecode.c,v
retrieving revision 1.21
diff -u -p -r1.21 uudecode.c
--- uudecode/uudecode.c	24 Sep 2006 15:32:48 -0000	1.21
+++ uudecode/uudecode.c	24 Sep 2006 19:25:50 -0000
@@ -51,13 +51,11 @@ __RCSID("$NetBSD: uudecode.c,v 1.21 2006
  */
 #include <sys/param.h>
 #include <sys/stat.h>
-#include <netinet/in.h>
 #include <ctype.h>
 #include <err.h>
 #include <errno.h>
 #include <limits.h>
 #include <locale.h>
-#include <resolv.h>
 #include <pwd.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -69,6 +67,11 @@ static void usage(void);
 static int checkend(const char *, const char *, const char *);
 static int base64_decode(void);
 int main(int, char *[]);
+int base64_pton(char const *, u_char *, size_t);
+
+static const char Base64[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char Pad64 = '=';
 
 int base64, pflag;
 char *filename;
@@ -268,7 +271,7 @@ base64_decode(void)
 			warnx("%s: short file.", filename);
 			return (1);
 		}
-		n = b64_pton(inbuf, outbuf, sizeof(outbuf));
+		n = base64_pton(inbuf, outbuf, sizeof(outbuf));
 		if (n < 0)
 			break;
 		fwrite(outbuf, 1, n, stdout);
@@ -284,3 +287,122 @@ usage()
 		      getprogname());
 	exit(1);
 }
+
+int
+base64_pton(char const *src, u_char *target, size_t targsize)
+{
+	int tarindex, state, ch;
+	char *pos;
+
+	state = 0;
+	tarindex = 0;
+
+	while ((ch = *src++) != '\0') {
+		if (isspace(ch))	/* Skip whitespace anywhere. */
+			continue;
+
+		if (ch == Pad64)
+			break;
+
+		pos = strchr(Base64, ch);
+		if (pos == 0) 		/* A non-base64 character. */
+			return (-1);
+
+		switch (state) {
+		case 0:
+			if (target) {
+				if ((size_t)tarindex >= targsize)
+					return (-1);
+				target[tarindex] = (pos - Base64) << 2;
+			}
+			state = 1;
+			break;
+		case 1:
+			if (target) {
+				if ((size_t)tarindex + 1 >= targsize)
+					return (-1);
+				target[tarindex]   |=  (pos - Base64) >> 4;
+				target[tarindex+1]  = ((pos - Base64) & 0x0f)
+							<< 4 ;
+			}
+			tarindex++;
+			state = 2;
+			break;
+		case 2:
+			if (target) {
+				if ((size_t)tarindex + 1 >= targsize)
+					return (-1);
+				target[tarindex]   |=  (pos - Base64) >> 2;
+				target[tarindex+1]  = ((pos - Base64) & 0x03)
+							<< 6;
+			}
+			tarindex++;
+			state = 3;
+			break;
+		case 3:
+			if (target) {
+				if ((size_t)tarindex >= targsize)
+					return (-1);
+				target[tarindex] |= (pos - Base64);
+			}
+			tarindex++;
+			state = 0;
+			break;
+		default:
+			abort();
+		}
+	}
+
+	/*
+	 * We are done decoding Base-64 chars.  Let's see if we ended
+	 * on a byte boundary, and/or with erroneous trailing characters.
+	 */
+
+	if (ch == Pad64) {		/* We got a pad char. */
+		ch = *src++;		/* Skip it, get next. */
+		switch (state) {
+		case 0:		/* Invalid = in first position */
+		case 1:		/* Invalid = in second position */
+			return (-1);
+
+		case 2:		/* Valid, means one byte of info */
+			/* Skip any number of spaces. */
+			for ((void)NULL; ch != '\0'; ch = *src++)
+				if (!isspace(ch))
+					break;
+			/* Make sure there is another trailing = sign. */
+			if (ch != Pad64)
+				return (-1);
+			ch = *src++;		/* Skip the = */
+			/* Fall through to "single trailing =" case. */
+			/* FALLTHROUGH */
+
+		case 3:		/* Valid, means two bytes of info */
+			/*
+			 * We know this char is an =.  Is there anything but
+			 * whitespace after it?
+			 */
+			for ((void)NULL; ch != '\0'; ch = *src++)
+				if (!isspace(ch))
+					return (-1);
+
+			/*
+			 * Now make sure for cases 2 and 3 that the "extra"
+			 * bits that slopped past the last full byte were
+			 * zeros.  If we don't check them, they become a
+			 * subliminal channel.
+			 */
+			if (target && target[tarindex] != 0)
+				return (-1);
+		}
+	} else {
+		/*
+		 * We ended by seeing the end of the string.  Make sure we
+		 * have no partial bytes lying around.
+		 */
+		if (state != 0)
+			return (-1);
+	}
+
+	return (tarindex);
+}

--Boundary_(ID_Obmlpx3ktzR0AnJj04kJUw)--