plugin/mms_plugin/MmsPluginCodecCommon.cpp

   1 /*
   2 * Copyright 2012-2013  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *    http://floralicense.org
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <ctype.h>
  18 #include "MmsPluginDebug.h"
  19 #include "MmsPluginCodecCommon.h"
  20 #include "MmsPluginMIME.h"
  21 #include "MmsPluginUtil.h"
  22 #include "MmsPluginTextConvert.h"
  23
  24 #define MMS_MAX_FIELD_VALUE_COUNT       74
  25 #define MMS_MAX_FIELD_TYPE_COUNT        21
  26
  27 typedef struct {
  28         const char *szText;
  29         UINT16 binary;
  30 } MmsField;
  31
  32 /* Reference : MMS-209-Encapsulation & WAP-203-WSP-20000504.pdf Table 39 */
  33 const MmsField gMmsField[MMS_MAX_FIELD_TYPE_COUNT][MMS_MAX_FIELD_VALUE_COUNT] =
  34 {
  35         /* MMS Specific (MsgMmsMsg.h / MsgMmsUA.h) -----------------------*/
  36
  37         /* MmsCodeFieldCode */
  38         {
  39                 {"Bcc", 0x01},                                                          //0
  40                 {"Cc", 0x02},
  41                 {"X-Mms-Content-Location", 0x03},
  42                 {"Content-Type", 0x04},
  43                 {"Date", 0x05},
  44                 {"X-Mms-Delivery-Report", 0x06},
  45                 {"X-Mms-Delivery-Time", 0x07},
  46                 {"X-Mms-Expiry", 0x08},
  47                 {"From", 0x09},
  48                 {"X-Mms-Message-Class", 0x0A},
  49                 {"Message-ID", 0x0B},                                           // 10
  50                 {"X-Mms-Message-Type", 0x0C},
  51                 {"X-Mms-MMS-Version", 0x0D},
  52                 {"X-Mms-Message-Size", 0x0E},
  53                 {"X-Mms-Priority", 0x0F},
  54                 {"X-Mms-Read-Reply", 0x10},
  55                 {"X-Mms-Report-Allowed", 0x11},
  56                 {"X-Mms-Response-Status", 0x12},
  57                 {"X-Mms-Retrieve-Status", 0x19},                        /* Add by MMSENC v1.1 */
  58                 {"X-Mms-Response-Text", 0x13},
  59                 {"X-Mms-Retrieve-Text", 0x1A},                          // 20   /* Add by MMSENC v1.1 */
  60                 {"X-Mms-Sender-Visibility", 0x14},
  61                 {"X-Mms-Status", 0x15},
  62                 {"Subject", 0x16},
  63                 {"To", 0x17},
  64                 {"X-Mms-Transaction-ID", 0x18},
  65
  66                 /* Add by MMSENC v1.1 */
  67                 {"X-Mms-Read-Status", 0x1B},
  68                 {"X-Mms-Reply-Charging", 0x1C},
  69                 {"X-Mms-Reply-Charging-Deadline", 0x1D},        // 30
  70                 {"X-Mms-Reply-Charging-ID", 0x1E},
  71                 {"X-Mms-Reply-Charging-Size", 0x1F},
  72                 {"X-Mms-Previously-Sent-By", 0x20},
  73                 {"X-Mms-Previously-Sent-Date", 0x21},
  74         },
  75
  76         /* MmsCodeParameterCode ( By WSP Table 38. Wellknown parameter Assignments ) */
  77         {
  78                 {"Charset", 0x01},              // v1.1 base
  79                 {"Name", 0x05},                 // v1.1 base. 0x17 at v1.4
  80                 {"FileName", 0x06},             // v1.1 base. ox18 at v1.4
  81                 {"Type", 0x09},                 // v1.2 base
  82                 {"Start", 0x0A},                // v1.2 base. 0x19 at v1.4
  83                 {"Start-Info", 0x0B},   // v1.2 base. 0x1A at v1.4
  84                 {"boundary", 0xFF},             //laconic_javaParamFix
  85                 {"report-type", 0xFF},        // only used as parameter of Content-Type: multipart/report; report-type=delivery-status;
  86 #ifdef FEATURE_JAVA_MMS
  87                 {"Application-ID", 0xFF},
  88                 {"Reply-To-Application-ID", 0xFF},
  89 #endif
  90         },
  91
  92         /* MmsCodeMsgBodyHeaderCode ( By WSP Table 39. Header Field Name Assignments ) */
  93         {
  94                 {"Content-Transfer-Encoding", 0xFFFF},  // only text encoding, no binary number
  95                 {"Content-Disposition", 0x2E},                  // v1.1 base. 0x45 at v1.4
  96                 {"Content-ID", 0x40},                                   // v1.3 base
  97                 {"Content-Location", 0x0E},                             // v1.3 base
  98                 {"X-Oma-Drm-Separate-Delivery", 0xFF }, // DRM RO WAITING
  99         },
 100
 101         /* MmsCodeMsgType */
 102         {
 103                 {"m-send-req", 0x00},
 104                 {"m-send-conf", 0x01},
 105                 {"m-notification-ind", 0x02},
 106                 {"m-notifyresp-ind", 0x03},
 107                 {"m-retrieve-conf", 0x04},
 108                 {"m-acknowledge-ind", 0x05},
 109                 {"m-delivery-ind", 0x06},
 110
 111                 /* Add by MMSENC v1.1 */
 112                 {"m-read-rec-ind", 0x07},
 113                 {"m-read-orig-ind", 0x08},
 114                 {"m-forward-req", 0x09},
 115                 {"m-forward-conf", 0x0A}
 116         },
 117
 118         /* MmsCodeDeliveryReport */
 119         {
 120                 { "Yes", 0x00 }, { "No", 0x01 }
 121         },
 122
 123         /* MmsCodeTimeType */
 124         {
 125                 { "relative", 0x01 }, { "absolute", 0x00 }
 126         },
 127
 128         /* MmsCodeMsgClass */
 129         {
 130                 {"Personal", 0x00},
 131                 {"Advertisement", 0x01},
 132                 {"Informational", 0x02},
 133                 {"Auto", 0x03}
 134         },
 135
 136         /* MmsCodePriority */
 137         {
 138                 { "Low", 0x00 }, { "Normal", 0x01 }, { "High", 0x02 }
 139         },
 140
 141         /* MmsCodeResponseStatus */
 142         {
 143                 {"Ok", 0x00},
 144                 {"Error-unspecified", 0x01},
 145                 {"Error-service-denied", 0x02},
 146                 {"Error-message-format-corrupt", 0x03},
 147                 {"Error-sending-address-unresolved", 0x04},
 148                 {"Error-message-not-found", 0x05},
 149                 {"Error-network-problem", 0x06},
 150                 {"Error-content-not-accepted", 0x07},
 151                 {"Error-unsupported-message", 0x08},
 152
 153                 {"Error-transient-failure", 0x40},
 154                 {"Error-transient-sending-address-unresolved", 0x41},
 155                 {"Error-transient-message-not-found", 0x42},
 156                 {"Error-transient-network-problem", 0x43},
 157
 158                 {"Error-transient-failure", 0x44}, //reserved for future
 159                 {"Error-transient-failure", 0x45},
 160                 {"Error-transient-failure", 0x46},
 161                 {"Error-transient-failure", 0x47},
 162                 {"Error-transient-failure", 0x48},
 163                 {"Error-transient-failure", 0x49},
 164                 {"Error-transient-failure", 0x4A},
 165                 {"Error-transient-failure", 0x4B},
 166                 {"Error-transient-failure", 0x4C},
 167                 {"Error-transient-failure", 0x4D},
 168                 {"Error-transient-failure", 0x4E},
 169                 {"Error-transient-failure", 0x4F},
 170                 {"Error-transient-failure", 0x50},
 171                 {"Error-transient-failure", 0x51},
 172                 {"Error-transient-failure", 0x52},
 173                 {"Error-transient-failure", 0x53},
 174                 {"Error-transient-failure", 0x54},
 175                 {"Error-transient-failure", 0x55},
 176                 {"Error-transient-failure", 0x56},
 177                 {"Error-transient-failure", 0x57},
 178                 {"Error-transient-failure", 0x58},
 179                 {"Error-transient-failure", 0x59},
 180                 {"Error-transient-failure", 0x5A},
 181                 {"Error-transient-failure", 0x5B},
 182                 {"Error-transient-failure", 0x5C},
 183                 {"Error-transient-failure", 0x5D},
 184                 {"Error-transient-failure", 0x5E},
 185                 {"Error-transient-failure", 0x5F},
 186
 187                 {"Error-permanent-failure", 0x60},
 188                 {"Error-permanent-service-denied", 0x61},
 189                 {"Error-permanent-message-format-corrupt", 0x62},
 190                 {"Error-permanent-sending-address-unresolved", 0x63},
 191                 {"Error-permanent-message-not-found", 0x64},
 192                 {"Error-permanent-content-not-accepted", 0x65},
 193                 {"Error-permanent-reply-charging-limitations-not-met", 0x66},
 194                 {"Error-permanent-reply-charging-request-not-accepted", 0x67},
 195                 {"Error-permanent-reply-charging-forwarding-denied", 0x68},
 196                 {"Error-permanent-reply-charging-not-supported", 0x69},
 197
 198                 {"Error-permanent-failure", 0x6A}, //reserved for future
 199                 {"Error-permanent-failure", 0x6B},
 200                 {"Error-permanent-failure", 0x6C},
 201                 {"Error-permanent-failure", 0x6D},
 202                 {"Error-permanent-failure", 0x6E},
 203                 {"Error-permanent-failure", 0x6F},
 204                 {"Error-permanent-failure", 0x70},
 205                 {"Error-permanent-failure", 0x71},
 206                 {"Error-permanent-failure", 0x72},
 207                 {"Error-permanent-failure", 0x73},
 208                 {"Error-permanent-failure", 0x74},
 209                 {"Error-permanent-failure", 0x75},
 210                 {"Error-permanent-failure", 0x76},
 211                 {"Error-permanent-failure", 0x77},
 212                 {"Error-permanent-failure", 0x78},
 213                 {"Error-permanent-failure", 0x79},
 214                 {"Error-permanent-failure", 0x7A},
 215                 {"Error-permanent-failure", 0x7B},
 216                 {"Error-permanent-failure", 0x7C},
 217                 {"Error-permanent-failure", 0x7D},
 218                 {"Error-permanent-failure", 0x7E},
 219                 {"Error-permanent-failure", 0x7F}
 220
 221
 222         },
 223
 224         /* MmsCodeRetrieveStatus */
 225         {
 226                 {"Ok", 0x00},
 227                 {"Error-transient-failure", 0x40},
 228                 {"Error-transient-message-not-found", 0x41},
 229                 {"Error-transient-network-problem", 0x42},
 230
 231                 {"Error-transient-failure", 0x43}, //reserved for future
 232                 {"Error-transient-failure", 0x44},
 233                 {"Error-transient-failure", 0x45},
 234                 {"Error-transient-failure", 0x46},
 235                 {"Error-transient-failure", 0x47},
 236                 {"Error-transient-failure", 0x48},
 237                 {"Error-transient-failure", 0x49},
 238                 {"Error-transient-failure", 0x4A},
 239                 {"Error-transient-failure", 0x4B},
 240                 {"Error-transient-failure", 0x4C},
 241                 {"Error-transient-failure", 0x4D},
 242                 {"Error-transient-failure", 0x4E},
 243                 {"Error-transient-failure", 0x4F},
 244                 {"Error-transient-failure", 0x50},
 245                 {"Error-transient-failure", 0x51},
 246                 {"Error-transient-failure", 0x52},
 247                 {"Error-transient-failure", 0x53},
 248                 {"Error-transient-failure", 0x54},
 249                 {"Error-transient-failure", 0x55},
 250                 {"Error-transient-failure", 0x56},
 251                 {"Error-transient-failure", 0x57},
 252                 {"Error-transient-failure", 0x58},
 253                 {"Error-transient-failure", 0x59},
 254                 {"Error-transient-failure", 0x5A},
 255                 {"Error-transient-failure", 0x5B},
 256                 {"Error-transient-failure", 0x5C},
 257                 {"Error-transient-failure", 0x5D},
 258                 {"Error-transient-failure", 0x5E},
 259                 {"Error-transient-failure", 0x5F},
 260
 261                 {"Error-permanent-failure", 0x60},
 262                 {"Error-permanent-service-denied", 0x61},
 263                 {"Error-permanent-message-not-found", 0x62},
 264                 {"Error-permanent-content-unsupported", 0x63},
 265
 266                 {"Error-permanent-failure", 0x64}, //reserved for future
 267                 {"Error-permanent-failure", 0x65},
 268                 {"Error-permanent-failure", 0x66},
 269                 {"Error-permanent-failure", 0x67},
 270                 {"Error-permanent-failure", 0x68},
 271                 {"Error-permanent-failure", 0x69},
 272                 {"Error-permanent-failure", 0x6A},
 273                 {"Error-permanent-failure", 0x6B},
 274                 {"Error-permanent-failure", 0x6C},
 275                 {"Error-permanent-failure", 0x6D},
 276                 {"Error-permanent-failure", 0x6E},
 277                 {"Error-permanent-failure", 0x6F},
 278                 {"Error-permanent-failure", 0x70},
 279                 {"Error-permanent-failure", 0x71},
 280                 {"Error-permanent-failure", 0x72},
 281                 {"Error-permanent-failure", 0x73},
 282                 {"Error-permanent-failure", 0x74},
 283                 {"Error-permanent-failure", 0x75},
 284                 {"Error-permanent-failure", 0x76},
 285                 {"Error-permanent-failure", 0x77},
 286                 {"Error-permanent-failure", 0x78},
 287                 {"Error-permanent-failure", 0x79},
 288                 {"Error-permanent-failure", 0x7A},
 289                 {"Error-permanent-failure", 0x7B},
 290                 {"Error-permanent-failure", 0x7C},
 291                 {"Error-permanent-failure", 0x7D},
 292                 {"Error-permanent-failure", 0x7E},
 293                 {"Error-permanent-failure", 0x7F}
 294
 295         },
 296
 297         /* MmsCodeReadReply */
 298         {
 299                 { "Yes", 0x00 }, { "No", 0x01 }
 300         },
 301
 302         /* MmsCodeReportAllowed */
 303         {
 304                 { "Yes", 0x00 }, { "No", 0x01 }
 305         },
 306
 307         /* MmsCodeSenderVisibility */
 308         {
 309                 { "Show", 0x01 }, { "Hide", 0x00 }
 310         },
 311
 312         /* MmsCodeMsgStatus */
 313         {
 314                 {"Expired", 0x00},
 315                 {"Retrieved", 0x01},
 316                 {"Rejected", 0x02},
 317                 {"Deferred", 0x03},
 318                 {"Unrecognised", 0x04},
 319
 320                 /* Add by MMSENC v1.1 */
 321                 {"Indeterminate ", 0x05},
 322                 {"Forwarded", 0x06},
 323
 324                 /* Add by MMSENC v1.2 */
 325                 {"Unreachable", 0x07 }
 326
 327         },
 328
 329         /* MmsCodeReadStatus */
 330         {
 331                 {"Read", 0x00}, {"Deleted", 0x01}
 332         },
 333
 334         /* MmsCodeAddressType */
 335         {
 336                 {"present", 0x00}, {"insert", 0x01}
 337         },
 338
 339
 340         /* MSG Specific (MsgMIMEExtern.h) -----------------------*/
 341
 342         /* MmsCodeCharSet */
 343         {
 344                 {"us-ascii", 0x03},
 345                 {"UTF-16", 0x03F7},
 346                 {"ISO-10646-UCS-2", 0x03E8},
 347                 {"UTF-8", 0x6A},
 348
 349                 {"ISO-2022-KR", 0x25},
 350                 {"KS_C_5601-1987", 0x24},
 351                 {"EUC-KR", 0x26},
 352                 {"ISO-2022-JP", 0x27},
 353                 {"ISO-2022-JP-2", 0x28},
 354
 355                 {"ISO_8859-1", 0x04},
 356                 {"ISO_8859-2", 0x05},
 357                 {"ISO-8859-3", 0x06},
 358                 {"ISO-8859-4", 0x07},
 359                 {"ISO-8859-5", 0x08},
 360                 {"ISO-8859-6", 0x09},
 361                 {"ISO-8859-6-E", 0x51},
 362                 {"ISO-8859-6-I", 0x52},
 363                 {"ISO-8859-7", 0x0a},
 364                 {"ISO-8859-8", 0x0b},
 365                 {"ISO-8859-8-I", 0x85},
 366                 {"ISO-8859-9", 0x0c},
 367                 {"ISO-8859-10", 0x0d},
 368                 {"ISO-8859-15", 0x6F},
 369
 370                 {"Shift_JIS", 0x11},
 371                 {"EUC-JP", 0x13},
 372                 {"GB2312", 0x07E9},
 373                 {"BIG5", 0x0d},
 374                 {"WIN1251", 0xFF},
 375                 {"WINDOW-1251", 0xFF},
 376                 {"WINDOWS-1251", 0xFF},
 377                 {"KOI8-R", 0x0824},
 378                 {"KOI8-U", 0x0828},
 379         },
 380
 381         /* MmsCodeReplyCharging, */
 382         {
 383                 { "Requested", 0x00 },
 384                 { "Requested text only", 0x01 },
 385                 { "Accepted", 0x02 },
 386                 { "Accepted text only", 0x03 }
 387         },
 388
 389
 390         /* MSG Specific (MsgMIMEExtern.h) -----------------------*/
 391
 392         /* Content-Type (http://www.wapforum.org/wina/wsp-content-type.htm) */
 393         /* this group(Content-Type) will be replaced by utyMime */
 394         {
 395                 // {"Text/txt", 0x01},
 396                 {"Text/html", 0x02},
 397                 {"Text/plain", 0x03},
 398                 {"Text/vnd.wap.wml", 0x08},
 399                 {"Text/x-vCalendar", 0x06},
 400                 {"Text/x-vCard", 0x07},
 401
 402                 {"Application/vnd.wap.multipart.*", 0x22},
 403                 {"Application/vnd.wap.multipart.mixed", 0x23},
 404                 {"Application/vnd.wap.multipart.related", 0x33},
 405                 {"Application/vnd.wap.multipart.alternative", 0x26},
 406
 407                 {"application/vnd.oma.drm.message", 0x48},                      // 10
 408                 {"application/vnd.oma.drm.content", 0x49},
 409                 {"application/vnd.oma.drm.rights+xml", 0x4A},
 410                 {"application/vnd.oma.drm.rights+wbxml", 0x4B},
 411
 412                 {"application/smil", 0xFFFF},
 413                 {"Multipart/mixed", 0x0c},
 414                 {"Multipart/related", 0x0B},
 415                 {"Multipart/alternative", 0x0F},
 416
 417                 {"multipart/report", 0xffff},
 418                 {"Message/rfc822", 0xffff},
 419
 420         //   T E X T
 421                 {"Image/gif", 0x1D},                    // 20
 422                 {"Image/jpeg", 0x1E},
 423                 {"Image/jpg", 0xFFFF},
 424                 {"image/tiff", 0x1f},
 425                 {"Image/png", 0x20},
 426
 427
 428                 {"Image/vnd.wap.wbmp", 0x21},
 429
 430                 {"Image/wbmp", 0xFFFF},
 431                 {"Image/pjpeg", 0xFFFF},
 432
 433                 {"Image/bmp", 0xFFFF},
 434
 435         // A U D I O
 436                 {"Audio/basic", 0xFFFF},
 437                 {"Audio/mpeg", 0xFFFF},                 // 30
 438                 {"Audio/x-mpeg", 0xFFFF},
 439                 {"Audio/mp3", 0xFFFF},
 440                 {"audio/x-mp3", 0xFFFF},
 441                 {"audio/mpeg3", 0xFFFF},
 442                 {"audio/x-mpeg3", 0xFFFF},
 443                 {"audio/mpg", 0xFFFF},
 444                 {"audio/x-mpg", 0xFFFF},
 445                 {"audio/x-mpegaudio", 0xFFFF},
 446                 {"Audio/aac", 0xFFFF},                  // 39
 447                 {"Audio/g72", 0xFFFF},
 448                 {"Audio/amr", 0xFFFF},
 449                 {"audio/x-amr", 0xFFFF},
 450                 {"audio/x-mmf", 0xFFFF},
 451                 {"application/vnd.smaf",  0xffff},
 452                 {"application/x-smaf", 0xFFFF},
 453                 {"audio/mmf", 0xFFFF},
 454
 455                 {"text/x-iMelody", 0xffff},
 456                 {"audio/x-iMelody", 0xffff},
 457                 {"audio/iMelody", 0xffff},              // 49
 458                 {"audio/mid",0xffff},
 459                 {"audio/midi", 0xffff},
 460                 {"audio/x-midi", 0xffff},
 461                 {"audio/sp-midi", 0xffff},
 462                 {"audio/wave", 0xffff},
 463                 {"audio/3gpp", 0xffff},
 464                 {"audio/vnd.rn-realaudio", 0xffff},
 465                 {"audio/x-pn-realaudio", 0xffff},
 466                 {"audio/mp4",  0xffff},
 467
 468         // V I D E O
 469                 {"video/mpeg4", 0xFFFF},
 470                 {"video/mp4", 0xffff},
 471                 {"video/x-mp4", 0xFFFF},
 472                 {"video/x-vp-mp4", 0xffff},
 473                 {"Video/h263", 0xFFFF},
 474
 475                 {"video/3gpp", 0xffff},
 476                 {"video/3gp", 0xffff},
 477                 {"Video/avi", 0xFFFF},
 478
 479                 {"video/sdp", 0xffff},                  // 70
 480                 {"application/vnd.rn-realmedia", 0xffff},
 481                 {"video/vnd.rn-realvideo", 0xffff},
 482
 483                 {"application/octet-stream", 0xFFFF }
 484         },
 485
 486         /* MmsCodeMsgDisposition : Wsp Header (By Wsp 8.4.2.53) */
 487         {
 488                 {"form-data", 0x00},
 489                 {"attachment", 0x01},
 490                 {"inline", 0x02}
 491         },
 492
 493         /* Content-transfer-encoding : HTTP Header(Binary Value is not assigned) */
 494         {
 495                 {"7bit", 0x00},
 496                 {"8bit", 0x00},
 497                 {"binary", 0x00},
 498                 {"base64", 0x00},
 499                 {"quoted-printable", 0x00}
 500         }
 501 };
 502
 503 const char *MmsGetTextValue(MmsCode i, int j)
 504 {
 505         if (i == MmsCodeContentType) {
 506                 //apply UtyMime
 507                 return MimeGetMimeStringFromMimeInt(j);
 508         }
 509
 510         return (const char *)gMmsField[i][j].szText;
 511 }
 512
 513 const char *MmsGetTextValuebyField(int field, int value)
 514 {
 515         const char *szValue = NULL;
 516
 517         switch (field) {
 518         case MMS_CODE_MSGTYPE:
 519                 szValue = MmsGetTextValue(MmsCodeMsgType, value);
 520                 break;
 521
 522         case MMS_CODE_MSGCLASS:
 523                 szValue = MmsGetTextValue(MmsCodeMsgClass, value);
 524                 break;
 525
 526         case MMS_CODE_PRIORITY:
 527                 szValue = MmsGetTextValue(MmsCodePriority, value);
 528                 break;
 529
 530         case MMS_CODE_SENDERVISIBILLITY:
 531                 szValue = MmsGetTextValue(MmsCodeSenderVisibility, value);
 532                 break;
 533
 534         case MMS_CODE_DELIVERYREPORT:
 535                 szValue = MmsGetTextValue(MmsCodeDeliveryReport, value);
 536                 break;
 537
 538         case MMS_CODE_READREPLY:
 539                 szValue = MmsGetTextValue(MmsCodeReadReply, value);
 540                 break;
 541
 542         case MMS_CODE_MSGSTATUS:
 543                 szValue = MmsGetTextValue(MmsCodeMsgStatus, value);
 544                 break;
 545
 546         case MMS_CODE_REPORTALLOWED:
 547                 szValue = MmsGetTextValue(MmsCodeReportAllowed, value);
 548                 break;
 549
 550         case MMS_CODE_RESPONSESTATUS:
 551                 szValue = MmsGetTextValue(MmsCodeResponseStatus, value);
 552                 break;
 553
 554         /* Add by MMSENC v1.1 */
 555         case MMS_CODE_READSTATUS:
 556                 szValue = MmsGetTextValue(MmsCodeReadStatus, value);
 557                 break;
 558
 559         default:
 560                 szValue = NULL;
 561                 break;
 562         }
 563
 564         return szValue;
 565 }
 566
 567 UINT16 MmsGetBinaryValue(MmsCode i, int j)
 568 {
 569         if (i == MmsCodeContentType) {
 570                 return MimeGetBinaryValueFromMimeInt((MimeType)j);
 571         }
 572
 573         return gMmsField[i][j].binary;
 574 }
 575
 576 // getting mime type (int) by binary type
 577 int MmsGetBinaryType(MmsCode i, UINT16 value)
 578 {
 579         MSG_BEGIN();
 580
 581         if (i == MmsCodeContentType) {
 582                 //apply UtyMime
 583                 return MimeGetMimeIntFromBi(value);
 584         }
 585
 586         for (int j = 0; j < MMS_MAX_FIELD_VALUE_COUNT; j++) {
 587                 if (gMmsField[i][j].binary == value) {
 588                         return j;
 589                 }
 590         }
 591
 592         MSG_END();
 593
 594         return MIME_UNKNOWN;
 595 }
 596
 597 int MmsGetTextType(MmsCode i, char *pValue)
 598 {
 599         int j = 0;
 600
 601         if (i == MmsCodeContentType) {
 602                 /*apply UtyMime */
 603                 return MimeGetMimeIntFromMimeString( pValue );
 604         }
 605
 606         for (j = 0; j < MMS_MAX_FIELD_VALUE_COUNT; j++) {
 607                 if (gMmsField[i][j].szText != NULL) {
 608                         if (strcasecmp( gMmsField[i][j].szText, pValue ) == 0) {
 609                                 return j;
 610                         }
 611                 }
 612         }
 613
 614         return -1;
 615 }
 616
 617 const char *MmsGetTextByCode(MmsCode i, UINT16 code)
 618 {
 619         for (int j = 0; j < MMS_MAX_FIELD_VALUE_COUNT; j++) {
 620                 if (gMmsField[i][j].binary == code) {
 621                         return gMmsField[i][j].szText;
 622                 }
 623         }
 624         return NULL;
 625 }
 626
 627
 628
 629 /* ==================================================================
 630  *      Decode/Encode inline base64 string
 631  *
 632  * base64 : 3*8bit -> 4*6bit & convert the value into A~Z, a~z, 0~9, +, or /
 633  * pad(=) is needed when the end of the string is < 24bit.
 634  *
 635  *     Value Encoding  Value Encoding  Value Encoding  Value Encoding
 636  *         0 A            17 R            34 i            51 z
 637  *         1 B            18 S            35 j            52 '0'
 638  *         2 C            19 T            36 k            53 1
 639  *         3 D            20 U            37 l            54 2
 640  *         4 E            21 V            38 m            55 3
 641  *         5 F            22 W            39 n            56 4
 642  *         6 G            23 X            40 o            57 5
 643  *         7 H            24 Y            41 p            58 6
 644  *         8 I            25 Z            42 q            59 7
 645  *         9 J            26 a            43 r            60 8
 646  *        10 K            27 b            44 s            61 9
 647  *        11 L            28 c            45 t            62 +
 648  *        12 M            29 d            46 u            63 /
 649  *        13 N            30 e            47 v
 650  *        14 O            31 f            48 w         (pad) =
 651  *        15 P            32 g            49 x
 652  *        16 Q            33 h            50 y
 653  *
 654  * (1) the final quantum = 24 bits : no "=" padding,
 655  * (2) the final quantum = 8 bits : two "=" + two characters
 656  * (3) the final quantum = 16 bits : one "=" + three characters
 657  * ================================================================== */
 658
 659 void *MsgDecodeBase64(unsigned char *pSrc, unsigned long srcLen, unsigned long *len)
 660 {
 661         char c;
 662         void *ret = NULL;
 663         char *d = NULL;
 664         short e = 0;
 665
 666         ret = malloc((size_t)(*len = 4 + ((srcLen * 3) / 4)));
 667         d = (char *)ret;
 668
 669         if (ret == NULL) {
 670                 MSG_DEBUG("_MsgDecodeBase64: ret malloc Fail \n");
 671                 return NULL;
 672         }
 673
 674         memset(ret, 0, (size_t)*len);
 675         *len = 0;
 676
 677         while (srcLen-- > 0) {
 678                 c = *pSrc++;
 679
 680                 /* Convert base64 character into original value */
 681
 682                 if (isupper(c))
 683                         c -= 'A';
 684                 else if (islower(c))
 685                         c -= 'a' - 26;
 686                 else if (isdigit(c))
 687                         c -= '0' - 52;
 688                 else if (c == '+')
 689                         c = 62;
 690                 else if (c == '/')
 691                         c = 63;
 692                 else if (c == '=') {
 693                         switch (e++) {
 694                         case 2:
 695                                 if (*pSrc != '=') {
 696                                         *len = d - (char *)ret;
 697                                         return ret;
 698                                 }
 699                                 break;
 700                         case 3:
 701                                 e = 0;
 702                                 break;
 703                         default:
 704                                 *len = d - (char *)ret;
 705                                 return ret;
 706                         }
 707                         continue;
 708                 } else
 709                         continue;                                       // Actually, never get here
 710
 711                 /* Pad 4*6bit character into 3*8bit character */
 712
 713                 switch (e++) {
 714                 case 0:
 715                         *d = c << 2;                    // byte 1: high 6 bits
 716                         break;
 717
 718                 case 1:
 719                         *d++ |= c >> 4;                 // byte 1: low 2 bits
 720                         *d = c << 4;                    // byte 2: high 4 bits
 721                         break;
 722
 723                 case 2:
 724                         *d++ |= c >> 2;                 // byte 2: low 4 bits
 725                         *d = c << 6;                    // byte 3: high 2 bits
 726                         break;
 727
 728                 case 3:
 729                         *d++ |= c;                              // byte 3: low 6 bits
 730                         e = 0;                                  // Calculate next unit.
 731                         break;
 732
 733                 default:
 734                         MSG_DEBUG("_MsgDecodeBase64: Unknown paremeter\n");
 735                         break;
 736                 }
 737         }
 738
 739         *len = d - (char *)ret;                 // Calculate the size of decoded string.
 740
 741         return ret;
 742 }
 743
 744
 745
 746 /* ==========================================
 747  *      Decode/Encode inline base64 string
 748  *
 749  * quoted-printable := ([*(ptext / SPACE / TAB) ptext] ["="] CRLF)
 750  *       ; Maximum line length of 76 characters excluding CRLF
 751  *
 752  * ptext := octet /<any ASCII character except "=", SPACE, or TAB>
 753  *       ; characters not listed as "mail-safe" in Appendix B
 754  *       ; are also not recommended.
 755  *
 756  * octet := "=" 2(DIGIT / "A" / "B" / "C" / "D" / "E" / "F")
 757  *       ; octet must be used for characters > 127, =, SPACE, or TAB.
 758  *
 759  * ==========================================*/
 760
 761
 762 unsigned char *MsgDecodeQuotePrintable(unsigned char *pSrc, unsigned long srcLen, unsigned long *len)
 763 {
 764         unsigned char *ret = NULL;
 765         unsigned char *d = NULL;
 766         unsigned char *s = NULL;                                        /* last non-blank */
 767         unsigned char c;
 768         unsigned char e;
 769
 770         d = s = ret = (unsigned char *)malloc((size_t)srcLen + 1);
 771         if (ret == NULL) {
 772                 MSG_DEBUG("_MsgDecodeQuotePrintable: ret malloc Fail \n");
 773                 return NULL;
 774         }
 775
 776         *len = 0;
 777         pSrc[srcLen] = '\0';
 778
 779         while ((c = *pSrc++)!= '\0') {
 780                 switch (c) {
 781                 case '=':                                                       /* octet characters (> 127, =, SPACE, or TAB) */
 782                         switch (c = *pSrc++) {
 783                         case '\0':                                      /* end of string -> postpone to while */
 784                                 break;
 785
 786                         case '\015':                            /* CRLF */
 787                                 if (*pSrc == '\012')
 788                                         pSrc++;
 789                                 break;
 790
 791                         default:                                        /* two hexes */
 792                                 if (!isxdigit(c)) {
 793                                         *d = '\0';
 794                                         *len = d - ret;
 795                                         return ret;
 796                                 }
 797
 798                                 if (isdigit(c))
 799                                         e = c - '0';
 800                                 else
 801                                         e = c - (isupper(c) ? 'A' - 10 : 'a' - 10);
 802
 803                                 c = *pSrc++;
 804                                 if (!isxdigit(c)) {
 805                                         *d = '\0';
 806                                         *len = d - ret;
 807                                         return ret;
 808                                 }
 809
 810                                 if (isdigit(c))
 811                                         c -= '0';
 812                                 else
 813                                         c -= (isupper(c) ? 'A' - 10 : 'a' - 10);
 814
 815                                 *d++ = c + (e << 4);
 816                                 s = d;
 817                                 break;
 818                         }
 819                         break;
 820
 821                 case ' ':                                                       /* skip the blank */
 822                         *d++ = c;
 823                         break;
 824
 825                 case '\015':                                            /* Line Feedback : to last non-blank character */
 826                         d = s;
 827                         break;
 828
 829                 default:
 830                         *d++ = c;                                               /* ASCII character */
 831                         s = d;
 832                         break;
 833                 }
 834         }
 835
 836         *d = '\0';
 837         *len = d - ret;
 838
 839         return ret;
 840 }
 841
 842
 843 /* ========================================
 844  * Decode/Encode inline base64 string
 845  * Inline base64 has no "\r\n" in it,
 846  * and has charset and encoding sign in it
 847  * ======================================== */
 848 bool MsgEncode2Base64(void *pSrc, unsigned long srcLen, unsigned long *len, unsigned char *ret)
 849 {
 850         unsigned char *d = NULL;
 851         unsigned char *s = (unsigned char *)pSrc;
 852         char *v = (char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 853         unsigned long i = ((srcLen + 2) / 3) * 4;
 854
 855         i += 2 * ((i / 60) + 1);
 856         *len = i;
 857
 858         if (ret == NULL) {
 859                 MSG_DEBUG("_MsgEncode2Base64: ret Memory Alloc Fail \n");
 860                 return false;
 861         }
 862         memset(ret, 0, i);
 863
 864         d = ret;
 865
 866         /* Convert 3*8bit into 4*6bit */
 867         for (i = 0; srcLen > 0; s += 3) {
 868                 *d++ = v[s[0] >> 2];                                                                                                                    // byte 1: high 6 bits of character-1
 869                 *d++ = v[((s[0] << 4) + (--srcLen ? (s[1] >> 4) : 0)) & 0x3f];                                  // byte 2: low 2 bits of character-1 and high 4 bits of character-2
 870                 *d++ = srcLen ? v[((s[1] << 2) + (--srcLen ? (s[2] >> 6) : 0)) & 0x3f] : '=';   // byte 3: low 4 bits of charcter-2 and high 2 bits of character-3
 871                 *d++ = srcLen ? v[s[2] & 0x3f] : '=';                                                                                   // byte 4: low 6 bits of character-3
 872
 873                 if (srcLen)
 874                         srcLen--;
 875         }
 876
 877         *d = '\0';
 878
 879         if (((unsigned long)(d - ret)) != *len) {
 880                 *len = d - ret;
 881                 MSG_DEBUG("base64 encoding length = %d \n", *len);
 882         }
 883
 884         return true;
 885 }
 886
 887
 888 char *MsgDecodeText(char *pOri)
 889 {
 890         MSG_BEGIN();
 891
 892         int size = 0;
 893         int cnt = 0;
 894         char *pSrc = NULL;
 895         char *pTemp = NULL;
 896         char *pRe = NULL;
 897         char *pStrEnd = NULL;
 898         char *pDecStart = NULL;
 899         char *pDecEnd = NULL;
 900         char *pDecQ = NULL;
 901         char *pDecQ2 = NULL;
 902         bool bEncoding = false;
 903         int     nCharset = MSG_CHARSET_UTF8;
 904         int     nTemp = 0;
 905         char *pReturnStr = NULL;
 906
 907         char szTempBuf[MSG_LOCAL_TEMP_BUF_SIZE] = {0};
 908
 909         // copy original string
 910         if (strlen(pOri) >= MSG_LOCAL_TEMP_BUF_SIZE) {
 911                 pSrc = MsgStrCopy( pOri );
 912         } else {
 913                 memset(szTempBuf, 0, MSG_LOCAL_TEMP_BUF_SIZE);
 914                 strcpy(szTempBuf, pOri);
 915
 916                 pSrc = szTempBuf;
 917         }
 918
 919         // it can be one or more encoding methods in a line
 920         while (1) {
 921                 cnt++;
 922
 923                 bEncoding = false;
 924
 925                 /*
 926                   (ex) "=?euc-kr?B?Y2NqMjEyMw==?="
 927
 928                   pDecStart: charset                    (=?euc-kr?B?Y2NqMjEyMw==?=)
 929                   pDecQ : Encoding type         (B?Y2NqMjEyMw==?=)
 930                   pDecQ2        : Encoded text          (Y2NqMjEyMw==?=)
 931                   pDecEnd       : Encoded of text       (?=)
 932                  */
 933                 if (pSrc == NULL)
 934                         goto __CATCH;
 935
 936                 if (((pDecStart = strstr(pSrc, MSG_STR_DEC_START)) != NULL)     //"=?"
 937                      && ((pDecQ = strchr(pDecStart + 2, MSG_CH_QUESTION)) != NULL)      // '?'
 938                      && ((pDecQ2 = strchr(pDecQ + 1, MSG_CH_QUESTION))!= NULL)          // '?'
 939                      && ((pDecEnd = strstr(pDecQ2 + 1, MSG_STR_DEC_END))!= NULL)) {     //"=?"
 940                         bEncoding = true;
 941
 942                         /* fixme: charset problem
 943                          * pDecStart ~ pDecQ : charSet & MSG_CHARSET_USC2 ~ MSG_CHARSET_UTF8 & LATIN
 944                          */
 945
 946                         *pDecQ = '\0';
 947                         nCharset = _MsgGetCode(MSG_CHARSET, pDecStart + 2);
 948                         if(nCharset < 0)
 949                                 goto __CATCH;
 950                         *pDecQ = MSG_CH_QUESTION;
 951                 }
 952
 953                 // End of encoding
 954                 if (!bEncoding)
 955                         goto __RETURN;
 956
 957                 // find end of string
 958                 pStrEnd = pSrc + strlen(pSrc);
 959
 960                 // Decoding
 961                 if ((*(pDecQ2 - 1) == MSG_CH_BASE64_UPPER) ||
 962                         (*(pDecQ2 - 1) == MSG_CH_BASE64_LOWER) ||
 963                         (*(pDecQ + 1) == MSG_CH_BASE64_UPPER) ||
 964                         (*(pDecQ + 1) == MSG_CH_BASE64_LOWER)) {
 965                         pTemp = (char *)MsgDecodeBase64((UCHAR *)(pDecQ2 + 1), (ULONG)(pDecEnd - pDecQ2 - 1), (ULONG *)&size);
 966
 967                         if (pTemp != NULL) {
 968                                 pTemp[size] = MSG_CH_NULL;
 969
 970                                 if(pRe) {
 971                                         free(pRe);
 972                                         pRe = NULL;
 973                                 }
 974
 975                                 pRe = (char *)malloc((pDecStart-pSrc) + size + (pStrEnd - (pDecEnd + 2)) + 1);
 976                                 if (pRe == NULL) {
 977                                         MSG_DEBUG("_MsgDecodeText: pRemalloc fail \n");
 978                                         free(pTemp);
 979                                         pTemp = NULL;
 980
 981                                         goto __RETURN;
 982                                 }
 983
 984                                 memcpy(pRe, pSrc, pDecStart - pSrc);
 985                                 memcpy(&pRe[pDecStart-pSrc], pTemp, size);
 986                                 memcpy(&pRe[(pDecStart - pSrc) + size], pDecEnd + 2, pStrEnd - (pDecEnd + 2));
 987                                 pRe[(pDecStart - pSrc) + size + (pStrEnd - (pDecEnd + 2))] = MSG_CH_NULL;
 988
 989                                 free(pTemp);
 990                                 pTemp = NULL;
 991
 992                                 if (pSrc != NULL && pSrc != szTempBuf) {
 993                                         free(pSrc);
 994                                         pSrc = NULL;
 995                                 }
 996                         }
 997                 } else if ((*(pDecQ2-1) == MSG_CH_QPRINT_UPPER) ||
 998                                 (*(pDecQ2-1) == MSG_CH_QPRINT_LOWER) ||
 999                                 (*(pDecQ+1) == MSG_CH_QPRINT_UPPER) ||
1000                                 (*(pDecQ+1) == MSG_CH_QPRINT_LOWER)) {
1001
1002                         pTemp = (char *)MsgDecodeQuotePrintable((UCHAR *)( pDecQ2 + 1 ), (ULONG)(pDecEnd - pDecQ2 - 1), (ULONG *)&size);
1003
1004                         if (pTemp != NULL) {
1005                                 int i;
1006                                 pTemp[size] = MSG_CH_NULL;
1007
1008                                 for (i = 0; i < size; i++) {
1009                                         if (pTemp[i] == MSG_CH_UNDERLINE) {
1010                                                 pTemp[i] = MSG_CH_SP;                         // change '_' to ' '
1011                                         }
1012                                 }
1013
1014                                 if(pRe) {
1015                                         free(pRe);
1016                                         pRe = NULL;
1017                                 }
1018
1019                                 pRe = (char *)malloc((pDecStart - pSrc) + size + (pStrEnd - (pDecEnd + 2)) + 1);
1020                                 if (pRe == NULL) {
1021                                         MSG_DEBUG("_MsgDecodeText: pRemalloc fail \n");
1022                                         free(pTemp);
1023                                         pTemp = NULL;
1024
1025                                         goto __RETURN;
1026                                 }
1027
1028                                 memcpy(pRe, pSrc, pDecStart - pSrc);
1029                                 memcpy(&pRe[pDecStart - pSrc], pTemp, size);
1030                                 memcpy(&pRe[(pDecStart - pSrc) + size], pDecEnd + 2, pStrEnd - (pDecEnd + 2));
1031                                 pRe[(pDecStart - pSrc) + size + (pStrEnd - (pDecEnd + 2))] = MSG_CH_NULL;
1032
1033                                 if (pTemp) {
1034                                         free(pTemp);
1035                                         pTemp = NULL;
1036                                 }
1037
1038                                 if (pSrc != NULL && pSrc != szTempBuf) {
1039                                         free(pSrc);
1040                                         pSrc = NULL;
1041                                 }
1042                         }
1043                 } else {
1044                         goto __RETURN;
1045                 }
1046         }
1047
1048
1049
1050 __RETURN:
1051
1052         pTemp = strdup(pSrc);
1053         nTemp = strlen(pSrc);
1054
1055         {//temp brace;
1056                 const char *pToCharSet = "UTF-8";
1057
1058                 UINT16 charset_code =  MmsGetBinaryValue(MmsCodeCharSet, nCharset);
1059
1060                 const char *pFromCharSet = MmsPluginTextConvertGetCharSet(charset_code);
1061
1062                 if (pFromCharSet != NULL && strcmp(pFromCharSet, pToCharSet) != 0) {//Not UTF-8
1063                         char *pDest = NULL;
1064                         int destLen = 0;
1065
1066                         if (MmsPluginTextConvert(pToCharSet, pFromCharSet, pTemp, nTemp, &pDest, &destLen) == false) {
1067                                 MSG_DEBUG("MmsPluginTextConvert Fail");
1068                         }
1069
1070                         if (pDest) {
1071                                 free(pTemp);
1072                                 pTemp = strdup(pDest);
1073                                 nTemp = destLen;
1074                                 free(pDest);
1075                         }
1076                 }
1077
1078         }
1079
1080         pReturnStr = (char *)malloc(nTemp + 1);
1081
1082         if (pReturnStr == NULL) {
1083                 goto __CATCH;
1084         }
1085
1086         memset(pReturnStr, 0, nTemp + 1);
1087
1088         if (pTemp) {
1089                 memcpy(pReturnStr, pTemp, nTemp);
1090                 free(pTemp);
1091                 pTemp = NULL;
1092         }
1093
1094         if(pRe) {
1095                 free(pRe);
1096                 pRe = NULL;
1097         }
1098
1099         if (pSrc != NULL && pSrc != szTempBuf) {
1100                 free(pSrc);
1101                 pSrc = NULL;
1102         }
1103
1104         return pReturnStr;
1105
1106 __CATCH:
1107
1108         if(pRe) {
1109                 free(pRe);
1110                 pRe = NULL;
1111         }
1112
1113         if (pSrc != NULL && pSrc != szTempBuf) {
1114                 free(pSrc);
1115                 pSrc = NULL;
1116         }
1117
1118         if (pTemp) {
1119                 free(pTemp);
1120                 pTemp = NULL;
1121         }
1122
1123         return NULL;
1124 }
1125
1126
1127 static char gszDebugStringBuf[50];
1128
1129 static char *MmsDebugPrintUnknownValue(int value)
1130 {
1131         snprintf(gszDebugStringBuf, sizeof(gszDebugStringBuf), "unknown value(%d)", value);
1132         return gszDebugStringBuf;
1133 }
1134
1135
1136 const char *MmsDebugGetMimeType(MimeType mimeType)
1137 {
1138         switch (mimeType) {
1139         case MIME_APPLICATION_XML:
1140                 return "MIME_APPLICATION_XML";
1141         case MIME_APPLICATION_WML_XML:
1142                 return "MIME_APPLICATION_WML_XML";
1143         case MIME_APPLICATION_XHTML_XML:
1144                 return "MIME_APPLICATION_XHTML_XML";
1145         case MIME_APPLICATION_JAVA_VM:
1146                 return "MIME_APPLICATION_JAVA_VM";
1147         case MIME_APPLICATION_SMIL:
1148                 return "MIME_APPLICATION_SMIL";
1149         case MIME_APPLICATION_JAVA_ARCHIVE:
1150                 return "MIME_APPLICATION_JAVA_ARCHIVE";
1151         case MIME_APPLICATION_JAVA:
1152                 return "MIME_APPLICATION_JAVA";
1153         case MIME_APPLICATION_OCTET_STREAM:
1154                 return "MIME_APPLICATION_OCTET_STREAM";
1155         case MIME_APPLICATION_STUDIOM:
1156                 return "MIME_APPLICATION_STUDIOM";
1157         case MIME_APPLICATION_FUNMEDIA:
1158                 return "MIME_APPLICATION_FUNMEDIA";
1159         case MIME_APPLICATION_MSWORD:
1160                 return "MIME_APPLICATION_MSWORD";
1161         case MIME_APPLICATION_PDF:
1162                 return "MIME_APPLICATION_PDF";
1163         case MIME_APPLICATION_ASTERIC:
1164                 return "MIME_APPLICATION_ASTERIC";
1165         case MIME_APPLICATION_VND_WAP_XHTMLXML:
1166                 return "MIME_APPLICATION_VND_WAP_XHTMLXML";
1167         case MIME_APPLICATION_VND_WAP_WMLC:
1168                 return "MIME_APPLICATION_VND_WAP_WMLC";
1169         case MIME_APPLICATION_VND_WAP_WMLSCRIPTC:
1170                 return "MIME_APPLICATION_VND_WAP_WMLSCRIPTC";
1171         case MIME_APPLICATION_VND_WAP_WTA_EVENTC:
1172                 return "MIME_APPLICATION_VND_WAP_WTA_EVENTC";
1173         case MIME_APPLICATION_VND_WAP_UAPROF:
1174                 return "MIME_APPLICATION_VND_WAP_UAPROF";
1175         case MIME_APPLICATION_VND_WAP_SIC:
1176                 return "MIME_APPLICATION_VND_WAP_SIC";
1177         case MIME_APPLICATION_VND_WAP_SLC:
1178                 return "MIME_APPLICATION_VND_WAP_SLC";
1179         case MIME_APPLICATION_VND_WAP_COC:
1180                 return "MIME_APPLICATION_VND_WAP_COC";
1181         case MIME_APPLICATION_VND_WAP_SIA:
1182                 return "MIME_APPLICATION_VND_WAP_SIA";
1183         case MIME_APPLICATION_VND_WAP_CONNECTIVITY_WBXML:
1184                 return "MIME_APPLICATION_VND_WAP_CONNECTIVITY_WBXML";
1185         case MIME_APPLICATION_VND_WAP_MULTIPART_FORM_DATA:
1186                 return "MIME_APPLICATION_VND_WAP_MULTIPART_FORM_DATA";
1187         case MIME_APPLICATION_VND_WAP_MULTIPART_BYTERANGES:
1188                 return "MIME_APPLICATION_VND_WAP_MULTIPART_BYTERANGES";
1189         case MIME_APPLICATION_VND_WAP_MULTIPART_MIXED:
1190                 return "MIME_APPLICATION_VND_WAP_MULTIPART_MIXED";
1191         case MIME_APPLICATION_VND_WAP_MULTIPART_RELATED:
1192                 return "MIME_APPLICATION_VND_WAP_MULTIPART_RELATED";
1193         case MIME_APPLICATION_VND_WAP_MULTIPART_ALTERNATIVE:
1194                 return "MIME_APPLICATION_VND_WAP_MULTIPART_ALTERNATIVE";
1195         case MIME_APPLICATION_VND_WAP_MULTIPART_ASTERIC:
1196                 return "MIME_APPLICATION_VND_WAP_MULTIPART_ASTERIC";
1197         case MIME_APPLICATION_VND_OMA_DD_XML:
1198                 return "MIME_APPLICATION_VND_OMA_DD_XML";
1199         case MIME_APPLICATION_VND_OMA_DRM_MESSAGE:
1200                 return "MIME_APPLICATION_VND_OMA_DRM_MESSAGE";
1201         case MIME_APPLICATION_VND_OMA_DRM_CONTENT:
1202                 return "MIME_APPLICATION_VND_OMA_DRM_CONTENT";
1203         case MIME_APPLICATION_VND_OMA_DRM_RIGHTS_XML:
1204                 return "MIME_APPLICATION_VND_OMA_DRM_RIGHTS_XML";
1205         case MIME_APPLICATION_VND_OMA_DRM_RIGHTS_WBXML:
1206                 return "MIME_APPLICATION_VND_OMA_DRM_RIGHTS_WBXML";
1207         case MIME_APPLICATION_VND_SMAF:
1208                 return "MIME_APPLICATION_VND_SMAF";
1209         case MIME_APPLICATION_VND_RN_REALMEDIA:
1210                 return "MIME_APPLICATION_VND_RN_REALMEDIA";
1211         case MIME_APPLICATION_VND_SUN_J2ME_JAVA_ARCHIVE:
1212                 return "MIME_APPLICATION_VND_SUN_J2ME_JAVA_ARCHIVE";
1213         case MIME_APPLICATION_VND_SAMSUNG_THEME:
1214                 return "MIME_APPLICATION_VND_SAMSUNG_THEME";
1215         case MIME_APPLICATION_VND_EXCEL:
1216                 return "MIME_APPLICATION_VND_EXCEL";
1217         case MIME_APPLICATION_X_HDMLC:
1218                 return "MIME_APPLICATION_X_HDMLC";
1219         case MIME_APPLICATION_X_X968_USERCERT:
1220                 return "MIME_APPLICATION_X_X968_USERCERT";
1221         case MIME_APPLICATION_X_WWW_FORM_URLENCODED:
1222                 return "MIME_APPLICATION_X_WWW_FORM_URLENCODED";
1223         case MIME_APPLICATION_X_SMAF:
1224                 return "MIME_APPLICATION_X_SMAF";
1225         case MIME_APPLICATION_X_FLASH:
1226                 return "MIME_APPLICATION_X_FLASH";
1227         case MIME_APPLICATION_X_EXCEL:
1228                 return "MIME_APPLICATION_X_EXCEL";
1229         case MIME_APPLICATION_X_POWERPOINT:
1230                 return "MIME_APPLICATION_X_POWERPOINT";
1231
1232         case MIME_AUDIO_BASIC:
1233                 return "MIME_AUDIO_BASIC";
1234         case MIME_AUDIO_MPEG:
1235                 return "MIME_AUDIO_MPEG";
1236         case MIME_AUDIO_MP3:
1237                 return "MIME_AUDIO_MP3";
1238         case MIME_AUDIO_MPG3:
1239                 return "MIME_AUDIO_MPG3";
1240         case MIME_AUDIO_MPEG3:
1241                 return "MIME_AUDIO_MPEG3";
1242         case MIME_AUDIO_MPG:
1243                 return "MIME_AUDIO_MPG";
1244         case MIME_AUDIO_AAC:
1245                 return "MIME_AUDIO_AAC";
1246         case MIME_AUDIO_G72:
1247                 return "MIME_AUDIO_G72";
1248         case MIME_AUDIO_AMR:
1249                 return "MIME_AUDIO_AMR";
1250         case MIME_AUDIO_AMR_WB:
1251                 return "MIME_AUDIO_AMR_WB";
1252         case MIME_AUDIO_MMF:
1253                 return "MIME_AUDIO_MMF";
1254         case MIME_AUDIO_SMAF:
1255                 return "MIME_AUDIO_SMAF";
1256         case MIME_AUDIO_IMELODY:
1257                 return "MIME_AUDIO_IMELODY";
1258         case MIME_AUDIO_MELODY:
1259                 return "MIME_AUDIO_MELODY";
1260         case MIME_AUDIO_MID:
1261                 return "MIME_AUDIO_MID";
1262         case MIME_AUDIO_MIDI:
1263                 return "MIME_AUDIO_MIDI";
1264         case MIME_AUDIO_X_MID:
1265                 return "MIME_AUDIO_X_MID";
1266         case MIME_AUDIO_SP_MIDI:
1267                 return "MIME_AUDIO_SP_MIDI";
1268         case MIME_AUDIO_WAVE:
1269                 return "MIME_AUDIO_WAVE";
1270         case MIME_AUDIO_3GPP:
1271                 return "MIME_AUDIO_3GPP";
1272         case MIME_AUDIO_MP4:
1273                 return "MIME_AUDIO_MP4";
1274         case MIME_AUDIO_MP4A_LATM:
1275                 return "MIME_AUDIO_MP4A_LATM";
1276         case MIME_AUDIO_VND_RN_REALAUDIO:
1277                 return "MIME_AUDIO_VND_RN_REALAUDIO";
1278         case MIME_AUDIO_X_MPEG:
1279                 return "MIME_AUDIO_X_MPEG";
1280         case MIME_AUDIO_X_MP3:
1281                 return "MIME_AUDIO_X_MP3";
1282         case MIME_AUDIO_X_MPEG3:
1283                 return "MIME_AUDIO_X_MPEG3";
1284         case MIME_AUDIO_X_MPG:
1285                 return "MIME_AUDIO_X_MPG";
1286         case MIME_AUDIO_X_AMR:
1287                 return "MIME_AUDIO_X_AMR";
1288         case MIME_AUDIO_X_MMF:
1289                 return "MIME_AUDIO_X_MMF";
1290         case MIME_AUDIO_X_SMAF:
1291                 return "MIME_AUDIO_X_SMAF";
1292         case MIME_AUDIO_X_IMELODY:
1293                 return "MIME_AUDIO_X_IMELODY";
1294         case MIME_AUDIO_X_MIDI:
1295                 return "MIME_AUDIO_X_MIDI";
1296         case MIME_AUDIO_X_MPEGAUDIO:
1297                 return "MIME_AUDIO_X_MPEGAUDIO";
1298         case MIME_AUDIO_X_PN_REALAUDIO:
1299                 return "MIME_AUDIO_X_PN_REALAUDIO";
1300         case MIME_AUDIO_X_PN_MULTIRATE_REALAUDIO:
1301                 return "MIME_AUDIO_X_PN_MULTIRATE_REALAUDIO";
1302         case MIME_AUDIO_X_PN_MULTIRATE_REALAUDIO_LIVE:
1303                 return "MIME_AUDIO_X_PN_MULTIRATE_REALAUDIO_LIVE";
1304         case MIME_AUDIO_X_WAV:
1305                 return "MIME_AUDIO_X_WAV";
1306
1307         case MIME_IMAGE_GIF:
1308                 return "MIME_IMAGE_GIF";
1309         case MIME_IMAGE_JPEG:
1310                 return "MIME_IMAGE_JPEG";
1311         case MIME_IMAGE_JPG:
1312                 return "MIME_IMAGE_JPG";
1313         case MIME_IMAGE_TIFF:
1314                 return "MIME_IMAGE_TIFF";
1315         case MIME_IMAGE_TIF:
1316                 return "MIME_IMAGE_TIF";
1317         case MIME_IMAGE_PNG:
1318                 return "MIME_IMAGE_PNG";
1319         case MIME_IMAGE_WBMP:
1320                 return "MIME_IMAGE_WBMP";
1321         case MIME_IMAGE_PJPEG:
1322                 return "MIME_IMAGE_PJPEG";
1323         case MIME_IMAGE_BMP:
1324                 return "MIME_IMAGE_BMP";
1325         case MIME_IMAGE_SVG:
1326                 return "MIME_IMAGE_SVG";
1327         case MIME_IMAGE_SVG1:
1328                 return "MIME_IMAGE_SVG1";
1329         case MIME_IMAGE_VND_WAP_WBMP:
1330                 return "MIME_IMAGE_VND_WAP_WBMP";
1331
1332         case MIME_IMAGE_X_BMP:
1333                 return "MIME_IMAGE_X_BMP";
1334
1335         case MIME_MESSAGE_RFC822:
1336                 return "MIME_MESSAGE_RFC822";
1337
1338         case MIME_MULTIPART_MIXED:
1339                 return "MIME_MULTIPART_MIXED";
1340         case MIME_MULTIPART_RELATED:
1341                 return "MIME_MULTIPART_RELATED";
1342         case MIME_MULTIPART_ALTERNATIVE:
1343                 return "MIME_MULTIPART_ALTERNATIVE";
1344         case MIME_MULTIPART_FORM_DATA:
1345                 return "MIME_MULTIPART_FORM_DATA";
1346         case MIME_MULTIPART_BYTERANGE:
1347                 return "MIME_MULTIPART_BYTERANGE";
1348         case MIME_MULTIPART_REPORT:
1349                 return "MIME_MULTIPART_REPORT";
1350
1351         case MIME_TEXT_TXT:
1352                 return "MIME_TEXT_TXT";
1353         case MIME_TEXT_HTML:
1354                 return "MIME_TEXT_HTML";
1355         case MIME_TEXT_PLAIN:
1356                 return "MIME_TEXT_PLAIN";
1357         case MIME_TEXT_CSS:
1358                 return "MIME_TEXT_CSS";
1359         case MIME_TEXT_XML:
1360                 return "MIME_TEXT_XML";
1361         case MIME_TEXT_IMELODY:
1362                 return "MIME_TEXT_IMELODY";
1363         case MIME_TEXT_VND_WAP_WMLSCRIPT:
1364                 return "MIME_TEXT_VND_WAP_WMLSCRIPT";
1365         case MIME_TEXT_VND_WAP_WML:
1366                 return "MIME_TEXT_VND_WAP_WML";
1367         case MIME_TEXT_VND_WAP_WTA_EVENT:
1368                 return "MIME_TEXT_VND_WAP_WTA_EVENT";
1369         case MIME_TEXT_VND_WAP_CONNECTIVITY_XML:
1370                 return "MIME_TEXT_VND_WAP_CONNECTIVITY_XML";
1371         case MIME_TEXT_VND_WAP_SI:
1372                 return "MIME_TEXT_VND_WAP_SI";
1373         case MIME_TEXT_VND_WAP_SL:
1374                 return "MIME_TEXT_VND_WAP_SL";
1375         case MIME_TEXT_VND_WAP_CO:
1376                 return "MIME_TEXT_VND_WAP_CO";
1377         case MIME_TEXT_VND_SUN_J2ME_APP_DESCRIPTOR:
1378                 return "MIME_TEXT_VND_SUN_J2ME_APP_DESCRIPTOR";
1379         case MIME_TEXT_X_HDML:
1380                 return "MIME_TEXT_X_HDML";
1381         case MIME_TEXT_X_VCALENDAR:
1382                 return "MIME_TEXT_X_VCALENDAR";
1383         case MIME_TEXT_X_VCARD:
1384                 return "MIME_TEXT_X_VCARD";
1385         case MIME_TEXT_X_IMELODY:
1386                 return "MIME_TEXT_X_IMELODY";
1387
1388         case MIME_VIDEO_MPEG4:
1389                 return "MIME_VIDEO_MPEG4";
1390         case MIME_VIDEO_MP4:
1391                 return "MIME_VIDEO_MP4";
1392         case MIME_VIDEO_H263:
1393                 return "MIME_VIDEO_H263";
1394         case MIME_VIDEO_3GPP:
1395                 return "MIME_VIDEO_3GPP";
1396         case MIME_VIDEO_3GP:
1397                 return "MIME_VIDEO_3GP";
1398         case MIME_VIDEO_AVI:
1399                 return "MIME_VIDEO_AVI";
1400         case MIME_VIDEO_SDP:
1401                 return "MIME_VIDEO_SDP";
1402         case MIME_VIDEO_VND_RN_REALVIDEO:
1403                 return "MIME_VIDEO_VND_RN_REALVIDEO";
1404         case MIME_VIDEO_X_MP4:
1405                 return "MIME_VIDEO_X_MP4";
1406         case MIME_VIDEO_X_PV_MP4:
1407                 return "MIME_VIDEO_X_PV_MP4";
1408         case MIME_VIDEO_X_PN_REALVIDEO:
1409                 return "MIME_VIDEO_X_PN_REALVIDEO";
1410         case MIME_VIDEO_X_PN_MULTIRATE_REALVIDEO:
1411                 return "MIME_VIDEO_X_PN_MULTIRATE_REALVIDEO";
1412         default:
1413                 return MmsDebugPrintUnknownValue(mimeType);
1414         }
1415 }
1416
1417
1418 /* MsgMmsMsg.h */
1419 const char *MmsDebugGetMmsReport(MmsReport report)
1420 {
1421         switch (report) {
1422         case MMS_REPORT_ERROR:
1423                 return "MMS_REPORT_ERROR";
1424         case MMS_REPORT_YES:
1425                 return "MMS_REPORT_YES";
1426         case MMS_REPORT_NO:
1427                 return "MMS_REPORT_NO";
1428         }
1429
1430         return MmsDebugPrintUnknownValue(report);
1431 }
1432
1433
1434 const char *MmsDebugGetMmsReportAllowed(MmsReportAllowed reportAllowed)
1435 {
1436         switch (reportAllowed) {
1437         case MMS_REPORTALLOWED_ERROR:
1438                 return "MMS_REPORTALLOWED_ERROR";
1439         case MMS_REPORTALLOWED_YES:
1440                 return "MMS_REPORTALLOWED_YES";
1441         case MMS_REPORTALLOWED_NO:
1442                 return "MMS_REPORTALLOWED_NO";
1443         }
1444
1445         return MmsDebugPrintUnknownValue(reportAllowed);
1446 }
1447
1448
1449 const char *MmsDebugGetMmsReadStatus(msg_read_report_status_t readStatus)
1450 {
1451         _MSG_READ_REPORT_STATUS_E readReport = (_MSG_READ_REPORT_STATUS_E)readStatus;
1452
1453         switch (readReport) {
1454         case MSG_READ_REPORT_NONE:
1455                 return "MMS_READSTATUS_NONE";
1456         case MSG_READ_REPORT_IS_READ:
1457                 return "MMS_IS_READ";
1458         case MSG_READ_REPORT_IS_DELETED:
1459                 return "MMS_IS_DELETED";
1460         }
1461
1462         return MmsDebugPrintUnknownValue(readStatus);
1463 }
1464
1465 const char *MmsDebugGetMsgType(MmsMsgType msgType)
1466 {
1467         switch (msgType) {
1468         case MMS_MSGTYPE_ERROR:
1469                 return "error";
1470         case MMS_MSGTYPE_SEND_REQ:
1471                 return "send.req";
1472         case MMS_MSGTYPE_SEND_CONF:
1473                 return "send.conf";
1474         case MMS_MSGTYPE_NOTIFICATION_IND:
1475                 return "notification.ind";
1476         case MMS_MSGTYPE_NOTIFYRESP_IND:
1477                 return "notifyResp.ind";
1478         case MMS_MSGTYPE_RETRIEVE_CONF:
1479                 return "retrieve conf";
1480         case MMS_MSGTYPE_ACKNOWLEDGE_IND:
1481                 return "acknowledge ind";
1482         case MMS_MSGTYPE_DELIVERY_IND:
1483                 return "delivery ind";
1484         case MMS_MSGTYPE_READREC_IND:
1485                 return "read rec ind";
1486         case MMS_MSGTYPE_READORG_IND:
1487                 return "read org ind";
1488         case MMS_MSGTYPE_FORWARD_REQ:
1489                 return "forward req";
1490         case MMS_MSGTYPE_FORWARD_CONF:
1491                 return "forward conf";
1492         case MMS_MSGTYPE_READ_REPLY:
1493                 return "read reply";
1494         default:
1495                 return MmsDebugPrintUnknownValue(msgType);
1496         }
1497 }
1498
1499 const char *MmsDebugGetResponseStatus(MmsResponseStatus responseStatus)
1500 {
1501         switch (responseStatus) {
1502         case MMS_RESPSTATUS_ERROR:
1503                 return "error";
1504         case MMS_RESPSTATUS_OK:
1505                 return "ok";
1506         case MMS_RESPSTAUTS_ERROR_UNSPECIFIED:
1507                 return "unspecified";
1508         case MMS_RESPSTAUTS_ERROR_SERVICEDENIED:
1509                 return "service denied";
1510         case MMS_RESPSTAUTS_ERROR_MESSAGEFORMATCORRUPT:
1511                 return "message format corrupt";
1512         case MMS_RESPSTAUTS_ERROR_SENDINGADDRESSUNRESOLVED:
1513                 return "sending address unresolved";
1514         case MMS_RESPSTAUTS_ERROR_MESSAGENOTFOUND:
1515                 return "message not found";
1516         case MMS_RESPSTAUTS_ERROR_NETWORKPROBLEM:
1517                 return "network problem";
1518         case MMS_RESPSTAUTS_ERROR_CONTENTNOTACCEPTED:
1519                 return "content not accepted";
1520         case MMS_RESPSTAUTS_ERROR_UNSUPPORTEDMESSAGE:
1521                 return "unsupported message";
1522         case MMS_RESPSTAUTS_ERROR_TRANSIENT_FAILURE:
1523                 return "transient failure";
1524         case MMS_RESPSTAUTS_ERROR_TRANSIENT_SENDING_ADDRESS_UNRESOLVED:
1525                 return "transient sending address unresolved";
1526         case MMS_RESPSTAUTS_ERROR_TRANSIENT_MESSAGE_NOT_FOUND:
1527                 return "transient message not found";
1528         case MMS_RESPSTAUTS_ERROR_TRANSIENT_NETWORK_PROBLEM:
1529                 return "transient network problem";
1530         case MMS_RESPSTAUTS_ERROR_PERMANENT_FAILURE:
1531                 return "permanent failure";
1532         case MMS_RESPSTAUTS_ERROR_PERMANENT_SERVICE_DENIED:
1533                 return "permanent service denied";
1534         case MMS_RESPSTAUTS_ERROR_PERMANENT_MESSAGE_FORMAT_CORRUPT:
1535                 return "permanent message format corrupt";
1536         case MMS_RESPSTAUTS_ERROR_PERMANENT_SENDING_ADDRESS_UNRESOLVED:
1537                 return "permanent sending address unresolved";
1538         case MMS_RESPSTAUTS_ERROR_PERMANENT_MESSAGE_NOT_FOUND:
1539                 return "permanent message not found";
1540         case MMS_RESPSTAUTS_ERROR_PERMANENT_CONTENT_NOT_ACCEPTED:
1541                 return "permanent content not accepted";
1542         case MMS_RESPSTAUTS_ERROR_PERMANENT_REPLY_CHARGING_LIMITATIONS_NOT_MET:
1543                 return "permanent reply charging limitations not met";
1544         case MMS_RESPSTAUTS_ERROR_PERMANENT_REPLY_CHARGING_REQUEST_NOT_ACCEPTED:
1545                 return "permanent reply charging request not accepted";
1546         case MMS_RESPSTAUTS_ERROR_PERMANENT_REPLY_CHARGING_FORWARDING_DENIED:
1547                 return "permanent reply charging forwarding denied";
1548         case MMS_RESPSTAUTS_ERROR_PERMANENT_REPLY_CHARGING_NOT_SUPPORTED:
1549                 return "permanent reply charging not supported";
1550         }
1551
1552         return MmsDebugPrintUnknownValue(responseStatus);
1553 }
1554
1555
1556 const char *MmsDebugGetRetrieveStatus(MmsRetrieveStatus retrieveStatus)
1557 {
1558         switch (retrieveStatus) {
1559         case MMS_RETRSTATUS_ERROR:
1560                 return "error";
1561         case MMS_RETRSTATUS_OK:
1562                 return "ok";
1563         case MMS_RETRSTATUS_TRANSIENT_FAILURE:
1564                 return "transient failure";
1565         case MMS_RETRSTATUS_TRANSIENT_MESSAGE_NOT_FOUND:
1566                 return "transient message not found";
1567         case MMS_RETRSTATUS_TRANSIENT_NETWORK_PROBLEM:
1568                 return "transient network problem";
1569         case MMS_RETRSTATUS_PERMANENT_FAILURE:
1570                 return "permanent failure";
1571         case MMS_RETRSTATUS_PERMANENT_SERVICE_DENIED:
1572                 return "permanent service denied";
1573         case MMS_RETRSTATUS_PERMANENT_MESSAGE_NOT_FOUND:
1574                 return "permanent message not found";
1575         case MMS_RETRSTATUS_PERMANENT_CONTENT_UNSUPPORT:
1576                 return "permanent content unsupport";
1577         }
1578
1579         return MmsDebugPrintUnknownValue(retrieveStatus);
1580 }
1581
1582
1583 const char *MmsDebugGetMsgStatus(msg_delivery_report_status_t msgStatus)
1584 {
1585         switch (msgStatus) {
1586         case MSG_DELIVERY_REPORT_ERROR:
1587                 return "error";
1588         case MSG_DELIVERY_REPORT_EXPIRED:
1589                 return "expired";
1590         case MSG_DELIVERY_REPORT_SUCCESS:
1591                 return "retrieved";
1592         case MSG_DELIVERY_REPORT_REJECTED:
1593                 return "rejected";
1594         case MSG_DELIVERY_REPORT_DEFERRED:
1595                 return "deferred";
1596         case MSG_DELIVERY_REPORT_UNRECOGNISED:
1597                 return "unrecognised";
1598         case MSG_DELIVERY_REPORT_INDETERMINATE:
1599                 return "indeterminate";
1600         case MSG_DELIVERY_REPORT_FORWARDED:
1601                 return "forwarded";
1602         case MSG_DELIVERY_REPORT_UNREACHABLE:
1603                 return "unreachable";
1604         }
1605
1606         return MmsDebugPrintUnknownValue(msgStatus);
1607 }
1608
1609
1610 const char *MmsDebugGetMsgClass(MmsMsgClass msgClass)
1611 {
1612         switch (msgClass) {
1613         case MMS_MSGCLASS_ERROR:
1614                 return "error";
1615         case MMS_MSGCLASS_PERSONAL:
1616                 return "personal";
1617         case MMS_MSGCLASS_ADVERTISEMENT:
1618                 return "advertisement";
1619         case MMS_MSGCLASS_INFORMATIONAL:
1620                 return "information";
1621         case MMS_MSGCLASS_AUTO:
1622                 return "auto";
1623         }
1624
1625         return MmsDebugPrintUnknownValue(msgClass);
1626 }
1627
1628
1629 const char *MmsDebugGetDataType(MmsDataType dataType)
1630 {
1631         switch (dataType) {
1632         case MMS_DATATYPE_NONE:
1633                 return "MMS_DATATYPE_NONE";
1634         case MMS_DATATYPE_READ:
1635                 return "MMS_DATATYPE_READ";
1636         case MMS_DATATYPE_SENT:
1637                 return "MMS_DATATYPE_SENT";
1638         case MMS_DATATYPE_NOTIFY:
1639                 return "MMS_DATATYPE_NOTIFY";
1640         case MMS_DATATYPE_UNSENT:
1641                 return "MMS_DATATYPE_UNSENT";
1642         case MMS_DATATYPE_DRAFT:
1643                 return "MMS_DATATYPE_DRAFT";
1644         case MMS_DATATYPE_SENDING:
1645                 return "MMS_DATATYPE_SENDING";
1646         case MMS_DATATYPE_DRM_RO_WAITING:
1647                 return "MMS_DATATYPE_DRM_RO_WAITING";
1648         case MMS_DATATYPE_RETRIEVING:
1649                 return "MMS_DATATYPE_RETRIEVING";
1650         case MMS_DATATYPE_UNRETV:
1651                 return "MMS_DATATYPE_UNRETV";
1652         default:
1653                 return MmsDebugPrintUnknownValue(dataType);
1654         }
1655 }
1656
1657 bool MmsInitMsgType(MsgType *pMsgType)
1658 {
1659         MSG_DEBUG("MmsInitMsgType");
1660         pMsgType->offset = 0;
1661         pMsgType->size = 0;
1662         pMsgType->contentSize = 0;
1663         pMsgType->disposition = -1;
1664         pMsgType->encoding = -1;
1665         pMsgType->type = MIME_UNKNOWN;
1666         pMsgType->section = -1;
1667
1668         pMsgType->szOrgFilePath[0] = '\0';
1669         pMsgType->szContentID[0] = '\0';
1670         pMsgType->szContentLocation[0] = '\0';
1671
1672         pMsgType->szContentRepPos[0] = '\0';
1673         pMsgType->szContentRepSize[0] = '\0';
1674         pMsgType->szContentRepIndex[0] = '\0';
1675
1676         MmsInitMsgContentParam(&pMsgType->param);
1677 #ifdef __SUPPORT_DRM__
1678         MmsInitMsgDRMInfo(&pMsgType->drmInfo);
1679 #endif
1680
1681         return true;
1682 }
1683
1684 bool MmsInitMsgBody(MsgBody *pMsgBody)
1685 {
1686         MSG_DEBUG("MmsInitMsgBody");
1687         pMsgBody->offset = 0;
1688         pMsgBody->size = 0;
1689         pMsgBody->body.pText = NULL;
1690
1691         MmsInitMsgType(&pMsgBody->presentationType);
1692         pMsgBody->pPresentationBody = NULL;
1693
1694         memset(pMsgBody->szOrgFilePath, 0, MSG_FILEPATH_LEN_MAX);
1695
1696         return true;
1697 }
1698
1699 bool MmsInitMsgContentParam(MsgContentParam *pMsgContentParam)
1700 {
1701         MSG_DEBUG("MmsInitMsgContentParam");
1702         pMsgContentParam->charset = MSG_CHARSET_UNKNOWN;
1703         pMsgContentParam->type = MIME_UNKNOWN;
1704         pMsgContentParam->szBoundary[0] = '\0';
1705         pMsgContentParam->szFileName[0] = '\0';
1706         pMsgContentParam->szName[0] = '\0';
1707         pMsgContentParam->szStart[0] = '\0';
1708         pMsgContentParam->szStartInfo[0] = '\0';
1709         pMsgContentParam->pPresentation = NULL;
1710         pMsgContentParam->reportType = MSG_PARAM_REPORT_TYPE_UNKNOWN; // only used as parameter of Content-Type: multipart/report; report-type
1711 #ifdef FEATURE_JAVA_MMS
1712         pMsgContentParam->szApplicationID = NULL;
1713         pMsgContentParam->szReplyToApplicationID = NULL;
1714 #endif
1715         return true;
1716 }
1717
1718 bool MmsInitMsgAttrib(MmsAttrib *pAttrib)
1719 {
1720         MSG_DEBUG("MmsInitMsgAttrib");
1721
1722         pAttrib->bAskDeliveryReport = false;
1723
1724         pAttrib->bAskReadReply = false;
1725         pAttrib->bRead = false;
1726         pAttrib->bReportAllowed = false;
1727         pAttrib->readReportAllowedType = MMS_RECEIVE_READ_REPORT_ALLOWED;
1728         pAttrib->readReportSendStatus = MMS_RECEIVE_READ_REPORT_NO_SEND;
1729         pAttrib->bReadReportSent = false;
1730
1731         pAttrib->bHideAddress = false;
1732         pAttrib->date = 0;
1733         pAttrib->bUseDeliveryCustomTime = false;
1734         pAttrib->deliveryTime.type = MMS_TIMETYPE_RELATIVE;
1735         pAttrib->deliveryTime.time = 0;
1736         pAttrib->bUseExpiryCustomTime = false;
1737         pAttrib->expiryTime.type = MMS_TIMETYPE_RELATIVE;
1738         pAttrib->expiryTime.time = 0;
1739         memset(&pAttrib->expiryTime, 0, sizeof(MmsTimeStruct));
1740         pAttrib->msgClass = MMS_MSGCLASS_PERSONAL;
1741         pAttrib->msgStatus = MSG_DELIVERY_REPORT_NONE;
1742         pAttrib->priority = MMS_PRIORITY_NORMAL;
1743         pAttrib->responseStatus = MMS_RESPSTATUS_ERROR;
1744         pAttrib->retrieveStatus = MMS_RETRSTATUS_ERROR;
1745         pAttrib->contentType = MIME_UNKNOWN;
1746         pAttrib->msgSize = 0;
1747         pAttrib->bLeaveCopy = true;
1748
1749         pAttrib->specialMsgType = MMS_SPECIAL_MSG_TYPE_NONE;
1750 #ifdef __SUPPORT_DRM__
1751         pAttrib->drmType = MSG_DRM_TYPE_NONE;
1752         pAttrib->roWaitingTimerMax = 0;
1753         pAttrib->pszDrmData = NULL;
1754 #endif
1755         pAttrib->version = MMS_VERSION;
1756
1757         memset(pAttrib->szFrom, 0, MSG_LOCALE_ADDR_LEN + 10);
1758         memset(pAttrib->szResponseText, 0, MMS_LOCALE_RESP_TEXT_LEN + 1);
1759         memset(pAttrib->szRetrieveText, 0, MMS_LOCALE_RESP_TEXT_LEN + 1);
1760         memset(pAttrib->szSubject, 0, MSG_LOCALE_SUBJ_LEN + 1);
1761         pAttrib->szTo = NULL;
1762         pAttrib->szCc = NULL;
1763         pAttrib->szBcc = NULL;
1764
1765         pAttrib->pMultiStatus = NULL;
1766
1767         pAttrib->replyCharge.chargeType = MMS_REPLY_NONE;
1768         memset(&pAttrib->replyCharge.deadLine , 0, sizeof(MmsTimeStruct));
1769         pAttrib->replyCharge.chargeSize = 0;
1770         memset(pAttrib->replyCharge.szChargeID, 0, MMS_MSG_ID_LEN);
1771
1772         return true;
1773 }
1774
1775 #ifdef __SUPPORT_DRM__
1776 bool MmsInitMsgDRMInfo(MsgDRMInfo *pMsgDrmInfo)
1777 {
1778         pMsgDrmInfo->contentType = MIME_UNKNOWN;
1779         pMsgDrmInfo->drmType = MSG_DRM_TYPE_NONE;
1780
1781         pMsgDrmInfo->szContentName = NULL;
1782         pMsgDrmInfo->szContentURI = NULL;
1783         pMsgDrmInfo->szContentDescription = NULL;
1784         pMsgDrmInfo->szContentVendor = NULL;
1785         pMsgDrmInfo->szRightIssuer = NULL;
1786         pMsgDrmInfo->szDrm2FullPath = NULL;
1787         pMsgDrmInfo->roWaitingTimerMax = 0;
1788         pMsgDrmInfo->bFwdLock = false;
1789         pMsgDrmInfo->bNoScreen = false;
1790         pMsgDrmInfo->bNoRingTone = false;
1791         pMsgDrmInfo->pszContentType = NULL;
1792
1793         return true;
1794 }
1795
1796 void MmsReleaseMsgDRMInfo(MsgDRMInfo *pDrmInfo)
1797 {
1798         MSG_DEBUG("_MsgFreeDRMInfo: S T A R T  !!! \n");
1799
1800         if (pDrmInfo == NULL) {
1801                 MSG_DEBUG("pDrmInfo is NULL");
1802                 return;
1803         }
1804
1805         if (pDrmInfo->szContentDescription) {
1806                 free(pDrmInfo->szContentDescription);
1807                 pDrmInfo->szContentDescription = NULL;
1808         }
1809
1810         if (pDrmInfo->szContentVendor) {
1811                 free(pDrmInfo->szContentVendor);
1812                 pDrmInfo->szContentVendor = NULL;
1813         }
1814
1815         if (pDrmInfo->szContentName) {
1816                 free(pDrmInfo->szContentName);
1817                 pDrmInfo->szContentName = NULL;
1818         }
1819
1820         if (pDrmInfo->szContentURI) {
1821                 free(pDrmInfo->szContentURI);
1822                 pDrmInfo->szContentURI = NULL;
1823         }
1824
1825         if (pDrmInfo->szRightIssuer) {
1826                 free(pDrmInfo->szRightIssuer);
1827                 pDrmInfo->szRightIssuer = NULL;
1828         }
1829
1830         if (pDrmInfo->szDrm2FullPath) {
1831                 free(pDrmInfo->szDrm2FullPath);
1832                 pDrmInfo->szDrm2FullPath = NULL;
1833         }
1834
1835         pDrmInfo->contentType = MIME_UNKNOWN;
1836         pDrmInfo->drmType = MSG_DRM_TYPE_NONE;
1837 }
1838
1839 #endif
1840
1841 bool MmsReleaseMmsAttrib(MmsAttrib *pAttrib)
1842 {
1843         MSG_BEGIN();
1844
1845         if (pAttrib == NULL) {
1846                 MSG_DEBUG("pAttrib is NULL");
1847                 return false;
1848         }
1849
1850         if (pAttrib->szTo) {
1851                 free(pAttrib->szTo);
1852                 pAttrib->szTo = NULL;
1853         }
1854
1855         if (pAttrib->szCc) {
1856                 free(pAttrib->szCc);
1857                 pAttrib->szCc = NULL;
1858         }
1859
1860         if (pAttrib->szBcc) {
1861                 free(pAttrib->szBcc);
1862                 pAttrib->szBcc = NULL;
1863         }
1864
1865         //check if pMultiStatus should be freed or not, because pMultiStatus is not allocated
1866         if (pAttrib->pMultiStatus) {
1867                 MmsMsgMultiStatus *pMultiStatus = pAttrib->pMultiStatus;
1868                 MmsMsgMultiStatus *pCurStatus = NULL;
1869
1870                 while (pMultiStatus != NULL ) {
1871                         pCurStatus = pMultiStatus;
1872                         pMultiStatus = pMultiStatus->pNext;
1873
1874                         if (pCurStatus) {
1875                                 free(pCurStatus);
1876                                 pCurStatus = NULL;
1877                         }
1878                 }
1879
1880                 pAttrib->pMultiStatus = NULL;
1881         }
1882
1883
1884         MSG_END();
1885
1886         return true;
1887 }
1888
1889 bool MmsReleaseMsgBody(MsgBody *pBody, int type)
1890 {
1891         MSG_BEGIN();
1892
1893         if (pBody == NULL) {
1894                 MSG_DEBUG("pBody == NULL \n" );
1895                 MSG_END();
1896
1897                 return false;
1898         }
1899
1900         switch (type) {
1901         case MIME_MULTIPART_REPORT:
1902         case MIME_APPLICATION_VND_OMA_DRM_MESSAGE:
1903         case MIME_APPLICATION_VND_WAP_MULTIPART_MIXED:
1904         case MIME_APPLICATION_VND_WAP_MULTIPART_RELATED:
1905         case MIME_APPLICATION_VND_WAP_MULTIPART_ASTERIC:
1906         case MIME_MULTIPART_MIXED:
1907         case MIME_MULTIPART_RELATED:
1908         case MIME_MULTIPART_ALTERNATIVE:
1909         case MIME_APPLICATION_VND_WAP_MULTIPART_ALTERNATIVE:
1910                 {
1911                         MsgMultipart *pMulti = pBody->body.pMultipart;
1912                         MsgMultipart *pCurrPart = NULL;
1913                         MsgBody *pPresentation = pBody->pPresentationBody;
1914                         while (pMulti != NULL) {
1915                                 pCurrPart = pMulti;
1916
1917                                 pMulti = pMulti->pNext;
1918
1919                                 if (pCurrPart) {
1920 #ifdef __SUPPORT_DRM__
1921                                         MmsReleaseMsgDRMInfo(&pCurrPart->type.drmInfo);
1922 #endif
1923
1924                                         if (pCurrPart->pBody) {
1925                                                 if (pCurrPart->pBody->body.pBinary) {
1926                                                         free(pCurrPart->pBody->body.pBinary);
1927                                                         pCurrPart->pBody->body.pBinary = NULL;
1928                                                 }
1929                                                 free(pCurrPart->pBody);
1930                                                 pCurrPart->pBody = NULL;
1931                                         }
1932                                         free(pCurrPart);
1933                                         pCurrPart = NULL;
1934                                 }
1935                         }
1936
1937                         pBody->body.pMultipart = NULL;
1938
1939                         if (pPresentation) {
1940                                 if (pPresentation->body.pText) {
1941                                         free(pPresentation->body.pText);
1942                                         pPresentation->body.pText = NULL;
1943                                 }
1944                                 free(pPresentation);
1945                                 pBody->pPresentationBody = NULL;
1946                         }
1947
1948                         MmsInitMsgType(&pBody->presentationType);
1949
1950                         break;
1951                 }
1952
1953         default:
1954                 /* Any single part */
1955                 if (pBody->body.pBinary) {
1956                         free(pBody->body.pBinary);
1957                         pBody->body.pBinary = NULL;
1958                 }
1959
1960                 break;
1961         }
1962
1963         MSG_END();
1964         return true;
1965 }
1966
1967 void MmsReleaseMmsMsg(MmsMsg *pMmsMsg)
1968 {
1969         if (pMmsMsg) {
1970                 MmsReleaseMsgBody(&pMmsMsg->msgBody, pMmsMsg->msgType.type);
1971                 MmsReleaseMmsAttrib(&pMmsMsg->mmsAttrib);
1972                 bzero(pMmsMsg, sizeof(MmsMsg));
1973         }
1974 }