src/cencode.c

   1 /*
   2 cencoder.c - c source to a base64 encoding algorithm implementation
   3
   4 This is part of the libb64 project, and has been placed in the public domain.
   5 For details, see http://sourceforge.net/projects/libb64
   6 */
   7
   8 #include "cencode.h"
   9 #include "utils.h"
  10
  11 const int CHARS_PER_LINE = 72;
  12
  13 _hidden void base64_init_encodestate(base64_encodestate* state_in)
  14 {
  15         state_in->step = step_A;
  16         state_in->result = 0;
  17         state_in->stepcount = 0;
  18 }
  19
  20 _hidden char base64_encode_value(char value_in)
  21 {
  22         static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  23         if (value_in > 63) return '=';
  24         return encoding[(int)value_in];
  25 }
  26
  27 _hidden int base64_encode_block(const char* plaintext_in, int length_in,
  28         char* code_out, base64_encodestate* state_in)
  29 {
  30         const char* plainchar = plaintext_in;
  31         const char* const plaintextend = plaintext_in + length_in;
  32         char* codechar = code_out;
  33         char result;
  34         char fragment;
  35
  36         result = state_in->result;
  37
  38         switch (state_in->step)
  39         {
  40                 while (1)
  41                 {
  42         case step_A:
  43                         if (plainchar == plaintextend)
  44                         {
  45                                 state_in->result = result;
  46                                 state_in->step = step_A;
  47                                 return codechar - code_out;
  48                         }
  49                         fragment = *plainchar++;
  50                         result = (fragment & 0x0fc) >> 2;
  51                         *codechar++ = base64_encode_value(result);
  52                         result = (fragment & 0x003) << 4;
  53         case step_B:
  54                         if (plainchar == plaintextend)
  55                         {
  56                                 state_in->result = result;
  57                                 state_in->step = step_B;
  58                                 return codechar - code_out;
  59                         }
  60                         fragment = *plainchar++;
  61                         result |= (fragment & 0x0f0) >> 4;
  62                         *codechar++ = base64_encode_value(result);
  63                         result = (fragment & 0x00f) << 2;
  64         case step_C:
  65                         if (plainchar == plaintextend)
  66                         {
  67                                 state_in->result = result;
  68                                 state_in->step = step_C;
  69                                 return codechar - code_out;
  70                         }
  71                         fragment = *plainchar++;
  72                         result |= (fragment & 0x0c0) >> 6;
  73                         *codechar++ = base64_encode_value(result);
  74                         result  = (fragment & 0x03f) >> 0;
  75                         *codechar++ = base64_encode_value(result);
  76
  77                         ++(state_in->stepcount);
  78                         if (state_in->stepcount == CHARS_PER_LINE/4)
  79                         {
  80                                 *codechar++ = '\n';
  81                                 state_in->stepcount = 0;
  82                         }
  83                 }
  84         }
  85         /* control should not reach here */
  86         return codechar - code_out;
  87 }
  88
  89 _hidden int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
  90 {
  91         char* codechar = code_out;
  92
  93         switch (state_in->step)
  94         {
  95         case step_B:
  96                 *codechar++ = base64_encode_value(state_in->result);
  97                 *codechar++ = '=';
  98                 *codechar++ = '=';
  99                 break;
 100         case step_C:
 101                 *codechar++ = base64_encode_value(state_in->result);
 102                 *codechar++ = '=';
 103                 break;
 104         case step_A:
 105                 break;
 106         }
 107         *codechar++ = '\n';
 108
 109         return codechar - code_out;
 110 }