CVS gsasl/lib/gl

[gsasl-commit]

Update of /home/cvs/gsasl/lib/gl
In directory dopio:/tmp/cvs-serv2989/gl

Modified Files:
        base64.c 
Log Message:
Update.

--- /home/cvs/gsasl/lib/gl/base64.c     2004/11/28 04:50:38     1.6
+++ /home/cvs/gsasl/lib/gl/base64.c     2004/11/28 05:32:19     1.7
@@ -27,15 +27,13 @@
  * int ok = base64_decode_alloc (in, inlen, &out, &outlen);
  * if (!ok)
  *   FAIL: input was not valid base64
- * if (outlen == SIZE_MAX)
- *   FAIL: integer overflow (too large input)
  * if (out == NULL)
  *   FAIL: memory allocation error
  * OK: data in OUT/OUTLEN
  *
  * size_t outlen = base64_encode_alloc (in, inlen, &out);
  * if (outlen == SIZE_MAX)
- *   FAIL: integer overflow
+ *   FAIL: integer overflow (too large input)
  * if (out == NULL)
  *   FAIL: memory allocation error
  * OK: data in OUT/LEN.
@@ -131,8 +129,9 @@
   return outlen - 1;
 }
 
-/* With this approach, instead of hard coding the values, this file
-   work independent of the charset used (think EBCDIC). */
+/* With this approach this file work independent of the charset used
+   (think EBCDIC).  However, it does assume that the characters in the
+   Base64 alphabet (A-Za-z0-9+/) are encoded in 0..255. */
 #define B64(x)                                 \
   ((x) == 'A' ? 0                              \
    : (x) == 'B' ? 1                            \
@@ -200,9 +199,87 @@
    : (x) == '/' ? 63                           \
    : -1)
 
+static const signed char b64[0x100] = {
+  B64 (0), B64 (1), B64 (2), B64 (3),
+  B64 (4), B64 (5), B64 (6), B64 (7),
+  B64 (8), B64 (9), B64 (10), B64 (11),
+  B64 (12), B64 (13), B64 (14), B64 (15),
+  B64 (16), B64 (17), B64 (18), B64 (19),
+  B64 (20), B64 (21), B64 (22), B64 (23),
+  B64 (24), B64 (25), B64 (26), B64 (27),
+  B64 (28), B64 (29), B64 (30), B64 (31),
+  B64 (32), B64 (33), B64 (34), B64 (35),
+  B64 (36), B64 (37), B64 (38), B64 (39),
+  B64 (40), B64 (41), B64 (42), B64 (43),
+  B64 (44), B64 (45), B64 (46), B64 (47),
+  B64 (48), B64 (49), B64 (50), B64 (51),
+  B64 (52), B64 (53), B64 (54), B64 (55),
+  B64 (56), B64 (57), B64 (58), B64 (59),
+  B64 (60), B64 (61), B64 (62), B64 (63),
+  B64 (64), B64 (65), B64 (66), B64 (67),
+  B64 (68), B64 (69), B64 (70), B64 (71),
+  B64 (72), B64 (73), B64 (74), B64 (75),
+  B64 (76), B64 (77), B64 (78), B64 (79),
+  B64 (80), B64 (81), B64 (82), B64 (83),
+  B64 (84), B64 (85), B64 (86), B64 (87),
+  B64 (88), B64 (89), B64 (90), B64 (91),
+  B64 (92), B64 (93), B64 (94), B64 (95),
+  B64 (96), B64 (97), B64 (98), B64 (99),
+  B64 (100), B64 (101), B64 (102), B64 (103),
+  B64 (104), B64 (105), B64 (106), B64 (107),
+  B64 (108), B64 (109), B64 (110), B64 (111),
+  B64 (112), B64 (113), B64 (114), B64 (115),
+  B64 (116), B64 (117), B64 (118), B64 (119),
+  B64 (120), B64 (121), B64 (122), B64 (123),
+  B64 (124), B64 (125), B64 (126), B64 (127),
+  B64 (128), B64 (129), B64 (130), B64 (131),
+  B64 (132), B64 (133), B64 (134), B64 (135),
+  B64 (136), B64 (137), B64 (138), B64 (139),
+  B64 (140), B64 (141), B64 (142), B64 (143),
+  B64 (144), B64 (145), B64 (146), B64 (147),
+  B64 (148), B64 (149), B64 (150), B64 (151),
+  B64 (152), B64 (153), B64 (154), B64 (155),
+  B64 (156), B64 (157), B64 (158), B64 (159),
+  B64 (160), B64 (161), B64 (162), B64 (163),
+  B64 (164), B64 (165), B64 (166), B64 (167),
+  B64 (168), B64 (169), B64 (170), B64 (171),
+  B64 (172), B64 (173), B64 (174), B64 (175),
+  B64 (176), B64 (177), B64 (178), B64 (179),
+  B64 (180), B64 (181), B64 (182), B64 (183),
+  B64 (184), B64 (185), B64 (186), B64 (187),
+  B64 (188), B64 (189), B64 (190), B64 (191),
+  B64 (192), B64 (193), B64 (194), B64 (195),
+  B64 (196), B64 (197), B64 (198), B64 (199),
+  B64 (200), B64 (201), B64 (202), B64 (203),
+  B64 (204), B64 (205), B64 (206), B64 (207),
+  B64 (208), B64 (209), B64 (210), B64 (211),
+  B64 (212), B64 (213), B64 (214), B64 (215),
+  B64 (216), B64 (217), B64 (218), B64 (219),
+  B64 (220), B64 (221), B64 (222), B64 (223),
+  B64 (224), B64 (225), B64 (226), B64 (227),
+  B64 (228), B64 (229), B64 (230), B64 (231),
+  B64 (232), B64 (233), B64 (234), B64 (235),
+  B64 (236), B64 (237), B64 (238), B64 (239),
+  B64 (240), B64 (241), B64 (242), B64 (243),
+  B64 (244), B64 (245), B64 (246), B64 (247),
+  B64 (248), B64 (249), B64 (250), B64 (251),
+  B64 (252), B64 (253), B64 (254), B64 (255)
+};
+
 /* C89 compliant way to cast 'char *' to 'unsigned char *'. */
 static inline unsigned char *to_ucharp (char *ch) { return ch; }
 
+static inline bool isb64 (unsigned char ch)
+{
+#if UCHAR_MAX > 255
+  if (ch > 255)
+    return false;
+#endif
+  if (b64[ch] < 0)
+    return false;
+  return true;
+}
+
 /* Decode base64 encoded input array IN of length INLEN to output
    array OUT that can hold *OUTLEN bytes.  Return true if decoding was
    successful, i.e. if the input was valid base64 data, false
@@ -213,72 +290,6 @@
 bool
 base64_decode (const char *in, size_t inlen, char *out, size_t * outlen)
 {
-  static const signed char b64[0x100] = {
-    B64 (0), B64 (1), B64 (2), B64 (3),
-    B64 (4), B64 (5), B64 (6), B64 (7),
-    B64 (8), B64 (9), B64 (10), B64 (11),
-    B64 (12), B64 (13), B64 (14), B64 (15),
-    B64 (16), B64 (17), B64 (18), B64 (19),
-    B64 (20), B64 (21), B64 (22), B64 (23),
-    B64 (24), B64 (25), B64 (26), B64 (27),
-    B64 (28), B64 (29), B64 (30), B64 (31),
-    B64 (32), B64 (33), B64 (34), B64 (35),
-    B64 (36), B64 (37), B64 (38), B64 (39),
-    B64 (40), B64 (41), B64 (42), B64 (43),
-    B64 (44), B64 (45), B64 (46), B64 (47),
-    B64 (48), B64 (49), B64 (50), B64 (51),
-    B64 (52), B64 (53), B64 (54), B64 (55),
-    B64 (56), B64 (57), B64 (58), B64 (59),
-    B64 (60), B64 (61), B64 (62), B64 (63),
-    B64 (64), B64 (65), B64 (66), B64 (67),
-    B64 (68), B64 (69), B64 (70), B64 (71),
-    B64 (72), B64 (73), B64 (74), B64 (75),
-    B64 (76), B64 (77), B64 (78), B64 (79),
-    B64 (80), B64 (81), B64 (82), B64 (83),
-    B64 (84), B64 (85), B64 (86), B64 (87),
-    B64 (88), B64 (89), B64 (90), B64 (91),
-    B64 (92), B64 (93), B64 (94), B64 (95),
-    B64 (96), B64 (97), B64 (98), B64 (99),
-    B64 (100), B64 (101), B64 (102), B64 (103),
-    B64 (104), B64 (105), B64 (106), B64 (107),
-    B64 (108), B64 (109), B64 (110), B64 (111),
-    B64 (112), B64 (113), B64 (114), B64 (115),
-    B64 (116), B64 (117), B64 (118), B64 (119),
-    B64 (120), B64 (121), B64 (122), B64 (123),
-    B64 (124), B64 (125), B64 (126), B64 (127),
-    B64 (128), B64 (129), B64 (130), B64 (131),
-    B64 (132), B64 (133), B64 (134), B64 (135),
-    B64 (136), B64 (137), B64 (138), B64 (139),
-    B64 (140), B64 (141), B64 (142), B64 (143),
-    B64 (144), B64 (145), B64 (146), B64 (147),
-    B64 (148), B64 (149), B64 (150), B64 (151),
-    B64 (152), B64 (153), B64 (154), B64 (155),
-    B64 (156), B64 (157), B64 (158), B64 (159),
-    B64 (160), B64 (161), B64 (162), B64 (163),
-    B64 (164), B64 (165), B64 (166), B64 (167),
-    B64 (168), B64 (169), B64 (170), B64 (171),
-    B64 (172), B64 (173), B64 (174), B64 (175),
-    B64 (176), B64 (177), B64 (178), B64 (179),
-    B64 (180), B64 (181), B64 (182), B64 (183),
-    B64 (184), B64 (185), B64 (186), B64 (187),
-    B64 (188), B64 (189), B64 (190), B64 (191),
-    B64 (192), B64 (193), B64 (194), B64 (195),
-    B64 (196), B64 (197), B64 (198), B64 (199),
-    B64 (200), B64 (201), B64 (202), B64 (203),
-    B64 (204), B64 (205), B64 (206), B64 (207),
-    B64 (208), B64 (209), B64 (210), B64 (211),
-    B64 (212), B64 (213), B64 (214), B64 (215),
-    B64 (216), B64 (217), B64 (218), B64 (219),
-    B64 (220), B64 (221), B64 (222), B64 (223),
-    B64 (224), B64 (225), B64 (226), B64 (227),
-    B64 (228), B64 (229), B64 (230), B64 (231),
-    B64 (232), B64 (233), B64 (234), B64 (235),
-    B64 (236), B64 (237), B64 (238), B64 (239),
-    B64 (240), B64 (241), B64 (242), B64 (243),
-    B64 (244), B64 (245), B64 (246), B64 (247),
-    B64 (248), B64 (249), B64 (250), B64 (251),
-    B64 (252), B64 (253), B64 (254), B64 (255)
-  };
   const unsigned char *iptr = to_cucharp (in);
   unsigned char *optr = to_ucharp (out);
   size_t outleft = *outlen;
@@ -288,7 +299,7 @@
 
   while (inlen >= 4)
     {
-      if (b64[iptr[0]] < 0 || b64[iptr[1]] < 0)
+      if (!isb64 (iptr[0]) || !isb64 (iptr[1]))
        return false;
 
       if (outleft)
@@ -309,7 +320,7 @@
        }
       else
        {
-         if (b64[iptr[2]] < 0)
+         if (!isb64 (iptr[2]))
            return false;
 
          if (outleft)
@@ -327,7 +338,7 @@
            }
          else
            {
-             if (b64[iptr[3]] < 0)
+             if (!isb64 (iptr[3]))
                return false;
 
              if (outleft)
@@ -355,30 +366,28 @@
    size of the decoded data is stored in *OUTLEN.  OUTLEN may be NULL,
    if the caller is not interested in the decoded length.  *OUT may be
    NULL to indicate an out of memory error, in which case *OUTLEN
-   contain the size of the memory block needed.  *OUTLEN may be
-   SIZE_MAX if INLEN is too large, in which case *OUT is also NULL.
-   The function return true on successful decoding, memory errors and
-   overflow errors.  (Use the *OUT and *OUTLEN parameters to
-   differentiate between successful decoding and memory/overflow
-   errors.)  The function return false if the input was invalid, in
-   which case *OUT is NULL and *OUTLEN is undefined. */
+   contain the size of the memory block needed.  The function return
+   true on successful decoding and memory allocation errors.  (Use the
+   *OUT and *OUTLEN parameters to differentiate between successful
+   decoding and memory error.)  The function return false if the input
+   was invalid, in which case *OUT is NULL and *OUTLEN is
+   undefined. */
 bool
 base64_decode_alloc (const char *in, size_t inlen, char **out,
                     size_t * outlen)
 {
   size_t needlen;
 
-  if (inlen >= SIZE_MAX / 3)
-    {
-      *out = NULL;
-      if (outlen)
-       *outlen = SIZE_MAX;
-      return true;
-    }
+  /* We want to compute 3 * inlen / 4, but to avoid overflow checking,
+     we compute 3 * (inlen / 4) and re-add the truncated values.
 
-  needlen = 3 * inlen / 4; /* FIXME: Rewrite to avoid overflowing.
-                             FIXME: May allocate one 1 or 2 bytes too
-                             much, depending on input. */
+     FIXME? 3*inlen/4 may allocate one 1 or 2 bytes too much,
+     depending on input (i.e., need 2 bytes less if input ends with
+     '==' and 1 byte less if input end with '=').  The value returned
+     in *OUTLEN will be correct, though. */
+  needlen = 3 * (inlen / 4)
+    + ((inlen % 4 == 2) ? 1 : 0)
+    + ((inlen % 4 == 3) ? 2 : 0);
 
   *out = malloc (needlen);
   if (!*out)