Source-Changes archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
Re: base64 routines [was: Re: CVS commit: src/usr.bin]
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
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);
+}
Home |
Main Index |
Thread Index |
Old Index