You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

bsd_base64.c 7.3KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185
  1. /* $OpenBSD: base64.c,v 1.3 1997/11/08 20:46:55 deraadt Exp $ */
  2. /*
  3. * Copyright (c) 1996 by Internet Software Consortium.
  4. *
  5. * Permission to use, copy, modify, and distribute this software for any
  6. * purpose with or without fee is hereby granted, provided that the above
  7. * copyright notice and this permission notice appear in all copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
  10. * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
  11. * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
  12. * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  15. * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  16. * SOFTWARE.
  17. */
  18. /*
  19. * Portions Copyright (c) 1995 by International Business Machines, Inc.
  20. *
  21. * International Business Machines, Inc. (hereinafter called IBM) grants
  22. * permission under its copyrights to use, copy, modify, and distribute this
  23. * Software with or without fee, provided that the above copyright notice and
  24. * all paragraphs of this notice appear in all copies, and that the name of IBM
  25. * not be used in connection with the marketing of any product incorporating
  26. * the Software or modifications thereof, without specific, written prior
  27. * permission.
  28. *
  29. * To the extent it has a right to do so, IBM grants an immunity from suit
  30. * under its patents, if any, for the use, sale or manufacture of products to
  31. * the extent that such products are used for performing Domain Name System
  32. * dynamic updates in TCP/IP networks by means of the Software. No immunity is
  33. * granted for any product per se or for any other function of any product.
  34. *
  35. * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
  36. * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  37. * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
  38. * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
  39. * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
  40. * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
  41. */
  42. #include "gpsd_config.h" /* must be before all includes */
  43. #include <stdlib.h>
  44. #include <sys/types.h>
  45. #include <ctype.h>
  46. #include <stdio.h>
  47. #include <stdlib.h>
  48. #include <string.h>
  49. #include <assert.h>
  50. #include "gpsd.h" /* we only need the prototype */
  51. static const char Base64[] =
  52. "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  53. static const char Pad64 = '=';
  54. /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
  55. The following encoding technique is taken from RFC 1521 by Borenstein
  56. and Freed. It is reproduced here in a slightly edited form for
  57. convenience.
  58. A 65-character subset of US-ASCII is used, enabling 6 bits to be
  59. represented per printable character. (The extra 65th character, "=",
  60. is used to signify a special processing function.)
  61. The encoding process represents 24-bit groups of input bits as output
  62. strings of 4 encoded characters. Proceeding from left to right, a
  63. 24-bit input group is formed by concatenating 3 8-bit input groups.
  64. These 24 bits are then treated as 4 concatenated 6-bit groups, each
  65. of which is translated into a single digit in the base64 alphabet.
  66. Each 6-bit group is used as an index into an array of 64 printable
  67. characters. The character referenced by the index is placed in the
  68. output string.
  69. Table 1: The Base64 Alphabet
  70. Value Encoding Value Encoding Value Encoding Value Encoding
  71. 0 A 17 R 34 i 51 z
  72. 1 B 18 S 35 j 52 0
  73. 2 C 19 T 36 k 53 1
  74. 3 D 20 U 37 l 54 2
  75. 4 E 21 V 38 m 55 3
  76. 5 F 22 W 39 n 56 4
  77. 6 G 23 X 40 o 57 5
  78. 7 H 24 Y 41 p 58 6
  79. 8 I 25 Z 42 q 59 7
  80. 9 J 26 a 43 r 60 8
  81. 10 K 27 b 44 s 61 9
  82. 11 L 28 c 45 t 62 +
  83. 12 M 29 d 46 u 63 /
  84. 13 N 30 e 47 v
  85. 14 O 31 f 48 w (pad) =
  86. 15 P 32 g 49 x
  87. 16 Q 33 h 50 y
  88. Special processing is performed if fewer than 24 bits are available
  89. at the end of the data being encoded. A full encoding quantum is
  90. always completed at the end of a quantity. When fewer than 24 input
  91. bits are available in an input group, zero bits are added (on the
  92. right) to form an integral number of 6-bit groups. Padding at the
  93. end of the data is performed using the '=' character.
  94. Since all base64 input is an integral number of octets, only the
  95. -------------------------------------------------
  96. following cases can arise:
  97. (1) the final quantum of encoding input is an integral
  98. multiple of 24 bits; here, the final unit of encoded
  99. output will be an integral multiple of 4 characters
  100. with no "=" padding,
  101. (2) the final quantum of encoding input is exactly 8 bits;
  102. here, the final unit of encoded output will be two
  103. characters followed by two "=" padding characters, or
  104. (3) the final quantum of encoding input is exactly 16 bits;
  105. here, the final unit of encoded output will be three
  106. characters followed by one "=" padding character.
  107. */
  108. int
  109. b64_ntop(unsigned char const *src, size_t srclength, char *target,
  110. size_t targsize)
  111. {
  112. size_t datalength = 0;
  113. unsigned char input[3];
  114. unsigned char output[4];
  115. while (2 < srclength) {
  116. input[0] = *src++;
  117. input[1] = *src++;
  118. input[2] = *src++;
  119. srclength -= 3;
  120. output[0] = input[0] >> 2;
  121. output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
  122. output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
  123. output[3] = input[2] & 0x3f;
  124. assert(output[0] < 64);
  125. assert(output[1] < 64);
  126. assert(output[2] < 64);
  127. assert(output[3] < 64);
  128. if (datalength + 4 > targsize)
  129. return (-1);
  130. target[datalength++] = Base64[output[0]];
  131. target[datalength++] = Base64[output[1]];
  132. target[datalength++] = Base64[output[2]];
  133. target[datalength++] = Base64[output[3]];
  134. }
  135. /* Now we worry about padding. */
  136. if (0 != srclength) {
  137. size_t i;
  138. /* Get what's left. */
  139. input[0] = input[1] = input[2] = '\0';
  140. for (i = 0; i < srclength; i++)
  141. input[i] = *src++;
  142. output[0] = input[0] >> 2;
  143. output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
  144. output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
  145. assert(output[0] < 64);
  146. assert(output[1] < 64);
  147. assert(output[2] < 64);
  148. if (datalength + 4 > targsize)
  149. return (-1);
  150. target[datalength++] = Base64[output[0]];
  151. target[datalength++] = Base64[output[1]];
  152. if (srclength == 1)
  153. target[datalength++] = Pad64;
  154. else
  155. target[datalength++] = Base64[output[2]];
  156. target[datalength++] = Pad64;
  157. }
  158. if (datalength >= targsize)
  159. return (-1);
  160. target[datalength] = '\0'; /* Returned value doesn't count \0. */
  161. return (datalength);
  162. }
  163. /* end */