src/plugins/ds-public/xcalllog/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
 218 int decode_value(encoding_type_e type, const char *value, int value_size, char **decode_str, int *decode_str_len);
 219
 220 /*
 221  * @brief                       get encoding type for data
 222  * @param[in]   data                                    vobject data
 223  * @return                      encoding type
 224  * @ratval                      >= 1                                    success
 225  * @retval                      0                                               fail
 226  */
 227 encoding_type_e find_encoding_type(const char *data);
 228
 229 /*
 230  * @brief                       check whether to exist this string, "ENCODING=" in the data
 231  * @param[in]   data                            vobject data
 232  * @return                      operation result
 233  * @retval                      1                                       exist
 234  * @retval                      0                                       not exist
 235  */
 236 int check_encoding_data(const char *data);
 237
 238 #endif                          /* ENCODING_UTIL_H_ */