src/plugins/ds-public/vcard/include/encoding_util.h

   1 /*
   2  * oma-ds-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #ifndef ENCODING_UTIL_H_
  19 #define ENCODING_UTIL_H_
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #define QP_SIZE                 76
  26 #define BASE64_SIZE                     76
  27
  28 typedef enum {
  29         EN_TYPE_NONE = 0,
  30         EN_TYPE_QUOTED_PRINTABLE,
  31         EN_TYPE_BASE64
  32 } encoding_type_e;
  33
  34 /*              Quoted-Printable
  35 *
  36 *       @example code
  37 int main()
  38 {
  39 char *src = "hello";
  40 char *encode_src;
  41 int encode_src_len = 0;
  42 char *decode_src;
  43 int decode_src_len = 0;
  44
  45 int res = encode_qp(src, strlen(src), &encode_src, &encode_src_len);
  46 if (res != 0)
  47 fprintf(stdout, "encode src : %s ( %d ) \n", encode_src, encode_src_len);
  48 else
  49 fprintf(stdout, "%s\n", "encode error !!");
  50
  51 res = decode_qp(encode_src, encode_src_len, &decode_src, &decode_src_len);
  52 if (res != 0)
  53 fprintf(stdout, "decode src : %s ( %d ) \n", decode_src, decode_src_len);
  54 else
  55 fprintf(stdout, "%s\n", "decode error !!");
  56
  57 return 0;
  58 }
  59
  60 */
  61
  62 /*
  63 * @brief                        encode original source ( encoding type : quoted-printable )
  64 *       @param[in]      src                             original source
  65 *       @param[in]      src_len                 length of original source
  66 *       @param[out]     en_src                  encoded source
  67 *       @param[out]     en_src_len              length of encoded source
  68 *       @return                 operation result
  69 *       @retval                 1                                       success
  70 *       @retval                 0                                       fail
  71 */
  72 int encode_qp(char *src, int src_len, char **en_src, int *en_src_len);
  73
  74 /*
  75 * @brief                        decode encoded source ( decoding type : quoted-printable )
  76 * @param[in]    src                             encoded source
  77 * @param[in]    src_len                 length of encoded source
  78 * @param[out]   de_src                  decoded source ( original source )
  79 * @param[out]   de_src_len              length of decoded source
  80 * @return                       operation result
  81 * @retval                       1                                       success
  82 * @retval                       0                                       fail
  83 */
  84 int decode_qp(char *src, int src_len, char **de_src, int *de_src_len);
  85
  86 /*              Base64
  87 *
  88 *       @example code
  89
  90 int main()
  91 {
  92 char *src = "hello";
  93 char *encode_src;
  94 int encode_src_len = 0;
  95 char *decode_src;
  96 int decode_src_len = 0;
  97
  98 int res = encode_base64(src, strlen(src), &encode_src, &encode_src_len);
  99 if (res != 0)
 100 fprintf(stdout, "encode src : %s ( %d ) \n", encode_src, encode_src_len);
 101 else
 102 fprintf(stdout, "%s\n", "encode error !!");
 103
 104 res = decode_base64(encode_src, encode_src_len, &decode_src, &decode_src_len);
 105 if (res != 0)
 106 fprintf(stdout, "decode src : %s ( %d ) \n", decode_src, decode_src_len);
 107 else
 108 fprintf(stdout, "%s\n", "decode error !!");
 109
 110 return 0;
 111 }
 112
 113 */
 114
 115 /*
 116 * @brief                        encode original source ( encoding type : base64 )
 117 *       @param[in]      src                             original source
 118 *       @param[in]      src_len                 length of original source
 119 *       @param[out]     en_src                  encoded source
 120 *       @param[out]     en_src_len              length of encoded source
 121 *       @return                 operation result
 122 *       @retval                 1                                       success
 123 *       @retval                 0                                       fail
 124 */
 125 int encode_base64(char *src, int src_len, char **en_src, int *en_src_len);
 126
 127 /*
 128 * @brief                        decode encoded source ( decoding type : base64 )
 129 * @param[in]    src                             encoded source
 130 * @param[in]    src_len                 length of encoded source
 131 * @param[out]   de_src                  decoded source ( original source )
 132 * @param[out]   de_src_len              length of decoded source
 133 * @return                       operation result
 134 * @retval                       1                                       success
 135 * @retval                       0                                       fail
 136 */
 137 int decode_base64(char *src, int src_len, char **de_src, int *de_src_len);
 138
 139 /*
 140 * @brief                        make the decoding process
 141 * @param[in]    src                             encoded source
 142 * @param[in]    src_len                 length of encoded source
 143 * @param[out]   de_src                  decoded source ( original source )
 144 * @param[out]   de_src_len              length of decoded source
 145 * @return                       operation result
 146 * @retval                       1                                       success
 147 * @retval                       0                                       fail
 148 *
 149 * @example code
 150
 151 int main()
 152 {
 153 char *src = "...";                      // decoded data
 154 int src_len = strlen(src);
 155 char *decode_src;
 156 int decode_src_len = 0;
 157
 158 int res = proc_decoding(src, src_len, &decode_src, &decode_src_len);
 159
 160 if (res != 0)
 161 fprintf(stdout, "decode src : \n%s\n", decode_src);
 162 else
 163 fprintf(stdout, "%s\n", "decode error !!");
 164
 165 if (decode_src != NULL)
 166 free(decode_src);
 167
 168 return 0;
 169 }
 170 */
 171 int proc_decoding(const char *src, int src_len, char **de_src, int *de_src_len);
 172
 173 /*
 174 * @brief                        encoded value is changed to the decoded value
 175 * @param[in]    type                                    encoding type
 176 * @param[in]    value                                   encoded value (end of string must be '\0' !!)
 177 *                                                                                       ex) =EA=B9=80;=EC=B2=A0=EC=88=98;;;\0
 178 * @param[in]    value_size                      length of encoded value
 179 * @param[out]   decode_str                      decoded string
 180 * @param[out]   decode_str_len  length of decoded string
 181 * @return                       operation result
 182 * @ratval                       1                                               success
 183 * @retval                       0                                               fail
 184 *
 185 * @example code
 186
 187 int main()
 188 {
 189 char *data = "...";                                             // ex) ENCODING=QUOTED-PRINTABLE;CHARSET=UTF-8
 190 encoding_type_e type = find_encoding_type((const char *)data);
 191
 192 char *value = "...";                                    // ex) =EA=B9=80;=EC=B2=A0=EC=88=98;;;\0
 193 int value_size = strlen(value);
 194
 195 int decode_str_len = 0;
 196 char *decode_str = (char*)malloc(sizeof(char)*BUF_SIZE);                        // BUF_SIZE : user define
 197 if (decode_str == NULL) {
 198 // error process
 199 }
 200 memset(decode_str, 0x00, sizeof(char)*BUF_SIZE);
 201
 202 int res = decode_value(type, value, data_size, &decode_str, &decode_str_len);
 203
 204 if (res == 1) {
 205 // success process
 206 if (decode_str != NULL)
 207 free(decode_str);
 208 } else {
 209 // error process
 210 if (decode_str != NULL)
 211 free(decode_str);
 212 }
 213
 214 return 0;
 215 }
 216 */
 217 int decode_value(encoding_type_e type, const char *value, int value_size, char **decode_str, int *decode_str_len);
 218
 219 /*
 220 * @brief                        get encoding type for data
 221 * @param[in]    data                                    vobject data
 222 * @return                       encoding type
 223 * @ratval                       >= 1                                    success
 224 * @retval                       0                                               fail
 225 */
 226 encoding_type_e find_encoding_type(const char *data);
 227
 228 /*
 229 * @brief                        check whether to exist this string, "ENCODING=" in the data
 230 * @param[in]    data                            vobject data
 231 * @return                       operation result
 232 * @retval                       1                                       exist
 233 * @retval                       0                                       not exist
 234 */
 235 int check_encoding_data(const char *data);
 236
 237 #endif                          /* ENCODING_UTIL_H_ */