SDL_Android/SmartDeviceLinkProxyAndroid/src/com/smartdevicelink/util/Mime.java

   1 package com.smartdevicelink.util;\r
   2 \r
   3 public class Mime {\r
   4         \r
   5         private static String m_base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";\r
   6         \r
   7         public static Boolean isSafeASCII(String check) {\r
   8                 if (check.contains("&") || check.contains("<") || check.contains("]]") || check.contains("}") )\r
   9                         return false;  // these things aren't reliably CDATA encodable\r
  10                 \r
  11                 return true;\r
  12         }\r
  13         \r
  14         public static String base64Encode(String toEncode) {\r
  15                 \r
  16                 byte[] bytesToEncode = new byte[toEncode.length()];   \r
  17                 for (int i=0; i< toEncode.length(); i++) \r
  18                         bytesToEncode[i] = (byte)toEncode.charAt(i);      \r
  19                 \r
  20                 StringBuilder sb = new StringBuilder();\r
  21 \r
  22                 int             idxin = 0;\r
  23                 int             b64idx = 0;\r
  24 \r
  25                 for (idxin=0;idxin < bytesToEncode.length;idxin++) {\r
  26                         switch (idxin % 3) {\r
  27                                 case 0:\r
  28                                         b64idx = (bytesToEncode[idxin] >> 2) & 0x3f;\r
  29                                         break;\r
  30                                 case 1:\r
  31                                         b64idx = (bytesToEncode[idxin] >> 4) & 0x0f;\r
  32                                         b64idx |= ((bytesToEncode[idxin-1] << 4)& 0x30);\r
  33                                         break;\r
  34                                 case 2:\r
  35                                         b64idx = (bytesToEncode[idxin] >> 6) & 0x03;\r
  36                                         b64idx |= ((bytesToEncode[idxin-1] << 2)& 0x3c);\r
  37                                         sb.append(m_base64Chars.charAt(b64idx));\r
  38                                         b64idx = bytesToEncode[idxin] & 0x3f;\r
  39                                         break;\r
  40                         } // end-switch\r
  41                         sb.append(m_base64Chars.charAt(b64idx));\r
  42                 } // end-for\r
  43 \r
  44                 switch (idxin % 3) {\r
  45                         case 0:\r
  46                                 break;\r
  47                         case 1:\r
  48                                 b64idx = (bytesToEncode[idxin-1] << 4) & 0x30;\r
  49                                 sb.append(m_base64Chars.charAt(b64idx));\r
  50                                 sb.append("==");\r
  51                                 break;\r
  52                         case 2:\r
  53                                 b64idx = ((bytesToEncode[idxin-1] << 2)& 0x3c);\r
  54                                 sb.append(m_base64Chars.charAt(b64idx));\r
  55                                 sb.append('=');\r
  56                                 break;\r
  57                 } // end-switch\r
  58                 \r
  59                 return sb.toString();\r
  60         } // end-method\r
  61         \r
  62         \r
  63         private byte[] base64Decode(String base64String) {\r
  64                 byte[] outBytes = null;\r
  65                 byte[] base64ASCIIString = null;\r
  66                 final String ASCII_Encoding = "US-ASCII";\r
  67                 \r
  68                 // Convert b64 string to raw bytes\r
  69                 try {\r
  70                         base64ASCIIString = base64String.getBytes(ASCII_Encoding);\r
  71                 } catch (Exception ex){\r
  72                         // TODO\r
  73                         //publishStatus("Failure converting b64string to ASCII string: " + ex.toString());\r
  74                         return null;\r
  75                 }\r
  76                 \r
  77                 if (!m_decodeInitComplete) {\r
  78                         m_decodeInitComplete = true;\r
  79                         initForDecode();\r
  80                 } // end-if\r
  81 \r
  82                 int     numInChars = base64ASCIIString.length;\r
  83 \r
  84                 if ((numInChars % 4) > 0) {\r
  85                         return null;\r
  86                 } // end-if\r
  87 \r
  88                 int numOutBytes = base64ASCIIString.length / 4;\r
  89                 numOutBytes *= 3;\r
  90                 int     eqpos = base64String.indexOf("=");\r
  91                 if (eqpos >= 0) {\r
  92                         numOutBytes--;\r
  93                         if (base64String.substring(eqpos).indexOf("==") >= 0) {\r
  94                                 numOutBytes--;\r
  95                         } // end-if\r
  96                 } // end-if\r
  97                 outBytes = new byte[numOutBytes];\r
  98 \r
  99                 byte    b64idxbits = 0x00;\r
 100                 int             iidx = 0, oidx = 0;\r
 101                 byte    writeByte = 0x00;\r
 102                 byte    b64ASCIIChar = 0x00;\r
 103                 for (iidx=0, oidx=0;iidx < numInChars;iidx++) {\r
 104                         b64ASCIIChar = base64ASCIIString[iidx];\r
 105                         if (b64ASCIIChar == 0x3d /*'='*/) {\r
 106                                 return outBytes;\r
 107                         } // end-if\r
 108 \r
 109                         if (!isb64char(b64ASCIIChar)) {\r
 110                                 return null;\r
 111                         } // end-if\r
 112 \r
 113                         switch (iidx % 4) {\r
 114                                 case 0:\r
 115                                         break;\r
 116                                 case 1:\r
 117                                         b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
 118                                         writeByte = (byte)((b64idxbits << 2) | ((b64decode[b64ASCIIChar] >> 4) & 0x03));\r
 119                                         outBytes[oidx++] = writeByte;\r
 120                                         break;\r
 121                                 case 2:\r
 122                                         b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
 123                                         writeByte = (byte)(((b64idxbits << 4) & 0xf0) | ((b64decode[b64ASCIIChar] >> 2) & 0x0f));\r
 124                                         outBytes[oidx++] = writeByte;\r
 125                                         break;\r
 126                                 case 3:\r
 127                                         b64idxbits = b64decode[base64ASCIIString[iidx-1]];\r
 128                                         writeByte = (byte)(((b64idxbits << 6) & 0xc0) | ((b64decode[b64ASCIIChar]) & 0x3f));\r
 129                                         outBytes[oidx++] = writeByte;\r
 130                                         break;\r
 131                         } // end-switch\r
 132                 } // end-for\r
 133 \r
 134                 return outBytes;\r
 135 \r
 136         } // end-method\r
 137 \r
 138 \r
 139         private static  byte[]  b64decode = new byte[256];\r
 140         // A-Z is 0x41-0x5a\r
 141         // a-z is 0x61-0x7a\r
 142         // 0-9 is 0x30-0x39\r
 143         // + is 0x2b\r
 144         // / is 0x2f\r
 145 \r
 146         private static  boolean m_decodeInitComplete = false;\r
 147 \r
 148         private void initForDecode() {\r
 149                 int aidx = 0;\r
 150                 int lidx = 0;\r
 151                 // Set A-Z\r
 152                 for (aidx=0x41, lidx=0;aidx <= 0x5a;aidx++, lidx++) {\r
 153                         b64decode[aidx] = (byte)lidx;\r
 154                 } // end-for\r
 155                 // Set a-z\r
 156                 for (aidx=0x61;aidx <= 0x7a;aidx++, lidx++) {\r
 157                         b64decode[aidx] = (byte)lidx;\r
 158                 } // end-for\r
 159                 // Set 0-9\r
 160                 for (aidx=0x30;aidx <= 0x39;aidx++, lidx++) {\r
 161                         b64decode[aidx] = (byte)lidx;\r
 162                 } // end-for\r
 163                 // Set '+'\r
 164                 b64decode[0x2b] = (byte)lidx++;\r
 165                 // Set '/'\r
 166                 b64decode[0x2f] = (byte)lidx++;\r
 167         } // end-method\r
 168 \r
 169         private boolean isb64char(byte b) {\r
 170                 // A-Z is 0x41-0x5a\r
 171                 // a-z is 0x61-0x7a\r
 172                 // 0-9 is 0x30-0x39\r
 173                 // + is 0x2b\r
 174                 // / is 0x2f\r
 175                 return (   (b >= 0x41 && b <= 0x5a)\r
 176                         || (b >= 0x61 && b <= 0x7a)\r
 177                         || (b >= 0x30 && b <= 0x39)\r
 178                         || (b == 0x2b)\r
 179                         || (b == 0x2f)\r
 180                         );\r
 181         } // end-method\r
 182 }\r