plugin/mms_plugin/MmsPluginDebug.cpp

   1 /*
   2 *
   3 * Copyright (c) 2000-2012 Samsung Electronics Co., Ltd. All Rights Reserved.
   4 *
   5 * This file is part of msg-service.
   6 *
   7 * Contact: Jaeyun Jeong <jyjeong@samsung.com>
   8 *          Sangkoo Kim <sangkoo.kim@samsung.com>
   9 *          Seunghwan Lee <sh.cat.lee@samsung.com>
  10 *          SoonMin Jung <sm0415.jung@samsung.com>
  11 *          Jae-Young Lee <jy4710.lee@samsung.com>
  12 *          KeeBum Kim <keebum.kim@samsung.com>
  13 *
  14 * PROPRIETARY/CONFIDENTIAL
  15 *
  16 * This software is the confidential and proprietary information of
  17 * SAMSUNG ELECTRONICS ("Confidential Information"). You shall not
  18 * disclose such Confidential Information and shall use it only in
  19 * accordance with the terms of the license agreement you entered
  20 * into with SAMSUNG ELECTRONICS.
  21 *
  22 * SAMSUNG make no representations or warranties about the suitability
  23 * of the software, either express or implied, including but not limited
  24 * to the implied warranties of merchantability, fitness for a particular
  25 * purpose, or non-infringement. SAMSUNG shall not be liable for any
  26 * damages suffered by licensee as a result of using, modifying or
  27 * distributing this software or its derivatives.
  28 *
  29 */
  30
  31 #include <stdio.h>
  32 #include "MmsPluginMIME.h"
  33 #include "MmsPluginMessage.h"
  34
  35 static char gszDebugStringBuf[50];
  36
  37 static char *MmsDebugPrintUnknownValue(int value)
  38 {
  39         printf(gszDebugStringBuf, "unknown value(%d)", value);
  40         return gszDebugStringBuf;
  41 }
  42
  43
  44 const char *MmsDebugGetMimeType(MimeType mimeType)
  45 {
  46         switch (mimeType) {
  47         case MIME_APPLICATION_XML:
  48                 return "MIME_APPLICATION_XML";
  49         case MIME_APPLICATION_WML_XML:
  50                 return "MIME_APPLICATION_WML_XML";
  51         case MIME_APPLICATION_XHTML_XML:
  52                 return "MIME_APPLICATION_XHTML_XML";
  53         case MIME_APPLICATION_JAVA_VM:
  54                 return "MIME_APPLICATION_JAVA_VM";
  55         case MIME_APPLICATION_SMIL:
  56                 return "MIME_APPLICATION_SMIL";
  57         case MIME_APPLICATION_JAVA_ARCHIVE:
  58                 return "MIME_APPLICATION_JAVA_ARCHIVE";
  59         case MIME_APPLICATION_JAVA:
  60                 return "MIME_APPLICATION_JAVA";
  61         case MIME_APPLICATION_OCTET_STREAM:
  62                 return "MIME_APPLICATION_OCTET_STREAM";
  63         case MIME_APPLICATION_STUDIOM:
  64                 return "MIME_APPLICATION_STUDIOM";
  65         case MIME_APPLICATION_FUNMEDIA:
  66                 return "MIME_APPLICATION_FUNMEDIA";
  67         case MIME_APPLICATION_MSWORD:
  68                 return "MIME_APPLICATION_MSWORD";
  69         case MIME_APPLICATION_PDF:
  70                 return "MIME_APPLICATION_PDF";
  71         case MIME_APPLICATION_ASTERIC:
  72                 return "MIME_APPLICATION_ASTERIC";
  73         case MIME_APPLICATION_VND_WAP_XHTMLXML:
  74                 return "MIME_APPLICATION_VND_WAP_XHTMLXML";
  75         case MIME_APPLICATION_VND_WAP_WMLC:
  76                 return "MIME_APPLICATION_VND_WAP_WMLC";
  77         case MIME_APPLICATION_VND_WAP_WMLSCRIPTC:
  78                 return "MIME_APPLICATION_VND_WAP_WMLSCRIPTC";
  79         case MIME_APPLICATION_VND_WAP_WTA_EVENTC:
  80                 return "MIME_APPLICATION_VND_WAP_WTA_EVENTC";
  81         case MIME_APPLICATION_VND_WAP_UAPROF:
  82                 return "MIME_APPLICATION_VND_WAP_UAPROF";
  83         case MIME_APPLICATION_VND_WAP_SIC:
  84                 return "MIME_APPLICATION_VND_WAP_SIC";
  85         case MIME_APPLICATION_VND_WAP_SLC:
  86                 return "MIME_APPLICATION_VND_WAP_SLC";
  87         case MIME_APPLICATION_VND_WAP_COC:
  88                 return "MIME_APPLICATION_VND_WAP_COC";
  89         case MIME_APPLICATION_VND_WAP_SIA:
  90                 return "MIME_APPLICATION_VND_WAP_SIA";
  91         case MIME_APPLICATION_VND_WAP_CONNECTIVITY_WBXML:
  92                 return "MIME_APPLICATION_VND_WAP_CONNECTIVITY_WBXML";
  93         case MIME_APPLICATION_VND_WAP_MULTIPART_FORM_DATA:
  94                 return "MIME_APPLICATION_VND_WAP_MULTIPART_FORM_DATA";
  95         case MIME_APPLICATION_VND_WAP_MULTIPART_BYTERANGES:
  96                 return "MIME_APPLICATION_VND_WAP_MULTIPART_BYTERANGES";
  97         case MIME_APPLICATION_VND_WAP_MULTIPART_MIXED:
  98                 return "MIME_APPLICATION_VND_WAP_MULTIPART_MIXED";
  99         case MIME_APPLICATION_VND_WAP_MULTIPART_RELATED:
 100                 return "MIME_APPLICATION_VND_WAP_MULTIPART_RELATED";
 101         case MIME_APPLICATION_VND_WAP_MULTIPART_ALTERNATIVE:
 102                 return "MIME_APPLICATION_VND_WAP_MULTIPART_ALTERNATIVE";
 103         case MIME_APPLICATION_VND_WAP_MULTIPART_ASTERIC:
 104                 return "MIME_APPLICATION_VND_WAP_MULTIPART_ASTERIC";
 105         case MIME_APPLICATION_VND_OMA_DD_XML:
 106                 return "MIME_APPLICATION_VND_OMA_DD_XML";
 107         case MIME_APPLICATION_VND_OMA_DRM_MESSAGE:
 108                 return "MIME_APPLICATION_VND_OMA_DRM_MESSAGE";
 109         case MIME_APPLICATION_VND_OMA_DRM_CONTENT:
 110                 return "MIME_APPLICATION_VND_OMA_DRM_CONTENT";
 111         case MIME_APPLICATION_VND_OMA_DRM_RIGHTS_XML:
 112                 return "MIME_APPLICATION_VND_OMA_DRM_RIGHTS_XML";
 113         case MIME_APPLICATION_VND_OMA_DRM_RIGHTS_WBXML:
 114                 return "MIME_APPLICATION_VND_OMA_DRM_RIGHTS_WBXML";
 115         case MIME_APPLICATION_VND_SMAF:
 116                 return "MIME_APPLICATION_VND_SMAF";
 117         case MIME_APPLICATION_VND_RN_REALMEDIA:
 118                 return "MIME_APPLICATION_VND_RN_REALMEDIA";
 119         case MIME_APPLICATION_VND_SUN_J2ME_JAVA_ARCHIVE:
 120                 return "MIME_APPLICATION_VND_SUN_J2ME_JAVA_ARCHIVE";
 121         case MIME_APPLICATION_VND_EXCEL:
 122                 return "MIME_APPLICATION_VND_EXCEL";
 123         case MIME_APPLICATION_X_HDMLC:
 124                 return "MIME_APPLICATION_X_HDMLC";
 125         case MIME_APPLICATION_X_X968_USERCERT:
 126                 return "MIME_APPLICATION_X_X968_USERCERT";
 127         case MIME_APPLICATION_X_WWW_FORM_URLENCODED:
 128                 return "MIME_APPLICATION_X_WWW_FORM_URLENCODED";
 129         case MIME_APPLICATION_X_SMAF:
 130                 return "MIME_APPLICATION_X_SMAF";
 131         case MIME_APPLICATION_X_FLASH:
 132                 return "MIME_APPLICATION_X_FLASH";
 133         case MIME_APPLICATION_X_EXCEL:
 134                 return "MIME_APPLICATION_X_EXCEL";
 135         case MIME_APPLICATION_X_POWERPOINT:
 136                 return "MIME_APPLICATION_X_POWERPOINT";
 137
 138         case MIME_AUDIO_BASIC:
 139                 return "MIME_AUDIO_BASIC";
 140         case MIME_AUDIO_MPEG:
 141                 return "MIME_AUDIO_MPEG";
 142         case MIME_AUDIO_MP3:
 143                 return "MIME_AUDIO_MP3";
 144         case MIME_AUDIO_MPG3:
 145                 return "MIME_AUDIO_MPG3";
 146         case MIME_AUDIO_MPEG3:
 147                 return "MIME_AUDIO_MPEG3";
 148         case MIME_AUDIO_MPG:
 149                 return "MIME_AUDIO_MPG";
 150         case MIME_AUDIO_AAC:
 151                 return "MIME_AUDIO_AAC";
 152         case MIME_AUDIO_G72:
 153                 return "MIME_AUDIO_G72";
 154         case MIME_AUDIO_AMR:
 155                 return "MIME_AUDIO_AMR";
 156         case MIME_AUDIO_AMR_WB:
 157                 return "MIME_AUDIO_AMR_WB";
 158         case MIME_AUDIO_MMF:
 159                 return "MIME_AUDIO_MMF";
 160         case MIME_AUDIO_SMAF:
 161                 return "MIME_AUDIO_SMAF";
 162         case MIME_AUDIO_IMELODY:
 163                 return "MIME_AUDIO_IMELODY";
 164         case MIME_AUDIO_MELODY:
 165                 return "MIME_AUDIO_MELODY";
 166         case MIME_AUDIO_MID:
 167                 return "MIME_AUDIO_MID";
 168         case MIME_AUDIO_MIDI:
 169                 return "MIME_AUDIO_MIDI";
 170         case MIME_AUDIO_X_MID:
 171                 return "MIME_AUDIO_X_MID";
 172         case MIME_AUDIO_SP_MIDI:
 173                 return "MIME_AUDIO_SP_MIDI";
 174         case MIME_AUDIO_WAVE:
 175                 return "MIME_AUDIO_WAVE";
 176         case MIME_AUDIO_3GPP:
 177                 return "MIME_AUDIO_3GPP";
 178         case MIME_AUDIO_MP4:
 179                 return "MIME_AUDIO_MP4";
 180         case MIME_AUDIO_MP4A_LATM:
 181                 return "MIME_AUDIO_MP4A_LATM";
 182         case MIME_AUDIO_VND_RN_REALAUDIO:
 183                 return "MIME_AUDIO_VND_RN_REALAUDIO";
 184         case MIME_AUDIO_X_MPEG:
 185                 return "MIME_AUDIO_X_MPEG";
 186         case MIME_AUDIO_X_MP3:
 187                 return "MIME_AUDIO_X_MP3";
 188         case MIME_AUDIO_X_MPEG3:
 189                 return "MIME_AUDIO_X_MPEG3";
 190         case MIME_AUDIO_X_MPG:
 191                 return "MIME_AUDIO_X_MPG";
 192         case MIME_AUDIO_X_AMR:
 193                 return "MIME_AUDIO_X_AMR";
 194         case MIME_AUDIO_X_MMF:
 195                 return "MIME_AUDIO_X_MMF";
 196         case MIME_AUDIO_X_SMAF:
 197                 return "MIME_AUDIO_X_SMAF";
 198         case MIME_AUDIO_X_IMELODY:
 199                 return "MIME_AUDIO_X_IMELODY";
 200         case MIME_AUDIO_X_MIDI:
 201                 return "MIME_AUDIO_X_MIDI";
 202         case MIME_AUDIO_X_MPEGAUDIO:
 203                 return "MIME_AUDIO_X_MPEGAUDIO";
 204         case MIME_AUDIO_X_PN_REALAUDIO:
 205                 return "MIME_AUDIO_X_PN_REALAUDIO";
 206         case MIME_AUDIO_X_PN_MULTIRATE_REALAUDIO:
 207                 return "MIME_AUDIO_X_PN_MULTIRATE_REALAUDIO";
 208         case MIME_AUDIO_X_PN_MULTIRATE_REALAUDIO_LIVE:
 209                 return "MIME_AUDIO_X_PN_MULTIRATE_REALAUDIO_LIVE";
 210         case MIME_AUDIO_X_WAV:
 211                 return "MIME_AUDIO_X_WAV";
 212
 213         case MIME_IMAGE_GIF:
 214                 return "MIME_IMAGE_GIF";
 215         case MIME_IMAGE_JPEG:
 216                 return "MIME_IMAGE_JPEG";
 217         case MIME_IMAGE_JPG:
 218                 return "MIME_IMAGE_JPG";
 219         case MIME_IMAGE_TIFF:
 220                 return "MIME_IMAGE_TIFF";
 221         case MIME_IMAGE_TIF:
 222                 return "MIME_IMAGE_TIF";
 223         case MIME_IMAGE_PNG:
 224                 return "MIME_IMAGE_PNG";
 225         case MIME_IMAGE_WBMP:
 226                 return "MIME_IMAGE_WBMP";
 227         case MIME_IMAGE_PJPEG:
 228                 return "MIME_IMAGE_PJPEG";
 229         case MIME_IMAGE_BMP:
 230                 return "MIME_IMAGE_BMP";
 231         case MIME_IMAGE_SVG:
 232                 return "MIME_IMAGE_SVG";
 233         case MIME_IMAGE_SVG1:
 234                 return "MIME_IMAGE_SVG1";
 235         case MIME_IMAGE_VND_WAP_WBMP:
 236                 return "MIME_IMAGE_VND_WAP_WBMP";
 237
 238         case MIME_IMAGE_X_BMP:
 239                 return "MIME_IMAGE_X_BMP";
 240
 241         case MIME_MESSAGE_RFC822:
 242                 return "MIME_MESSAGE_RFC822";
 243
 244         case MIME_MULTIPART_MIXED:
 245                 return "MIME_MULTIPART_MIXED";
 246         case MIME_MULTIPART_RELATED:
 247                 return "MIME_MULTIPART_RELATED";
 248         case MIME_MULTIPART_ALTERNATIVE:
 249                 return "MIME_MULTIPART_ALTERNATIVE";
 250         case MIME_MULTIPART_FORM_DATA:
 251                 return "MIME_MULTIPART_FORM_DATA";
 252         case MIME_MULTIPART_BYTERANGE:
 253                 return "MIME_MULTIPART_BYTERANGE";
 254         case MIME_MULTIPART_REPORT:
 255                 return "MIME_MULTIPART_REPORT";
 256
 257         case MIME_TEXT_TXT:
 258                 return "MIME_TEXT_TXT";
 259         case MIME_TEXT_HTML:
 260                 return "MIME_TEXT_HTML";
 261         case MIME_TEXT_PLAIN:
 262                 return "MIME_TEXT_PLAIN";
 263         case MIME_TEXT_CSS:
 264                 return "MIME_TEXT_CSS";
 265         case MIME_TEXT_XML:
 266                 return "MIME_TEXT_XML";
 267         case MIME_TEXT_IMELODY:
 268                 return "MIME_TEXT_IMELODY";
 269         case MIME_TEXT_VND_WAP_WMLSCRIPT:
 270                 return "MIME_TEXT_VND_WAP_WMLSCRIPT";
 271         case MIME_TEXT_VND_WAP_WML:
 272                 return "MIME_TEXT_VND_WAP_WML";
 273         case MIME_TEXT_VND_WAP_WTA_EVENT:
 274                 return "MIME_TEXT_VND_WAP_WTA_EVENT";
 275         case MIME_TEXT_VND_WAP_CONNECTIVITY_XML:
 276                 return "MIME_TEXT_VND_WAP_CONNECTIVITY_XML";
 277         case MIME_TEXT_VND_WAP_SI:
 278                 return "MIME_TEXT_VND_WAP_SI";
 279         case MIME_TEXT_VND_WAP_SL:
 280                 return "MIME_TEXT_VND_WAP_SL";
 281         case MIME_TEXT_VND_WAP_CO:
 282                 return "MIME_TEXT_VND_WAP_CO";
 283         case MIME_TEXT_VND_SUN_J2ME_APP_DESCRIPTOR:
 284                 return "MIME_TEXT_VND_SUN_J2ME_APP_DESCRIPTOR";
 285         case MIME_TEXT_X_HDML:
 286                 return "MIME_TEXT_X_HDML";
 287         case MIME_TEXT_X_VCALENDAR:
 288                 return "MIME_TEXT_X_VCALENDAR";
 289         case MIME_TEXT_X_VCARD:
 290                 return "MIME_TEXT_X_VCARD";
 291         case MIME_TEXT_X_IMELODY:
 292                 return "MIME_TEXT_X_IMELODY";
 293
 294         case MIME_VIDEO_MPEG4:
 295                 return "MIME_VIDEO_MPEG4";
 296         case MIME_VIDEO_MP4:
 297                 return "MIME_VIDEO_MP4";
 298         case MIME_VIDEO_H263:
 299                 return "MIME_VIDEO_H263";
 300         case MIME_VIDEO_3GPP:
 301                 return "MIME_VIDEO_3GPP";
 302         case MIME_VIDEO_3GP:
 303                 return "MIME_VIDEO_3GP";
 304         case MIME_VIDEO_AVI:
 305                 return "MIME_VIDEO_AVI";
 306         case MIME_VIDEO_SDP:
 307                 return "MIME_VIDEO_SDP";
 308         case MIME_VIDEO_VND_RN_REALVIDEO:
 309                 return "MIME_VIDEO_VND_RN_REALVIDEO";
 310         case MIME_VIDEO_X_MP4:
 311                 return "MIME_VIDEO_X_MP4";
 312         case MIME_VIDEO_X_PV_MP4:
 313                 return "MIME_VIDEO_X_PV_MP4";
 314         case MIME_VIDEO_X_PN_REALVIDEO:
 315                 return "MIME_VIDEO_X_PN_REALVIDEO";
 316         case MIME_VIDEO_X_PN_MULTIRATE_REALVIDEO:
 317                 return "MIME_VIDEO_X_PN_MULTIRATE_REALVIDEO";
 318         default:
 319                 return MmsDebugPrintUnknownValue(mimeType);
 320         }
 321 }
 322
 323
 324 /* MsgMmsMsg.h */
 325 const char *MmsDebugGetMmsReport(MmsReport report)
 326 {
 327         switch (report) {
 328         case MMS_REPORT_ERROR:
 329                 return "MMS_REPORT_ERROR";
 330         case MMS_REPORT_YES:
 331                 return "MMS_REPORT_YES";
 332         case MMS_REPORT_NO:
 333                 return "MMS_REPORT_NO";
 334         }
 335
 336         return MmsDebugPrintUnknownValue(report);
 337 }
 338
 339
 340 const char *MmsDebugGetMmsReportAllowed(MmsReportAllowed reportAllowed)
 341 {
 342         switch (reportAllowed) {
 343         case MMS_REPORTALLOWED_ERROR:
 344                 return "MMS_REPORTALLOWED_ERROR";
 345         case MMS_REPORTALLOWED_YES:
 346                 return "MMS_REPORTALLOWED_YES";
 347         case MMS_REPORTALLOWED_NO:
 348                 return "MMS_REPORTALLOWED_NO";
 349         }
 350
 351         return MmsDebugPrintUnknownValue(reportAllowed);
 352 }
 353
 354
 355 const char *MmsDebugGetMmsReadStatus(MSG_READ_REPORT_STATUS_T readStatus)
 356 {
 357         _MSG_READ_REPORT_STATUS_E readReport = (_MSG_READ_REPORT_STATUS_E)readStatus;
 358
 359         switch (readReport) {
 360         case MSG_READ_REPORT_NONE:
 361                 return "MMS_READSTATUS_NONE";
 362         case MSG_READ_REPORT_IS_READ:
 363                 return "MMS_IS_READ";
 364         case MSG_READ_REPORT_IS_DELETED:
 365                 return "MMS_IS_DELETED";
 366         }
 367
 368         return MmsDebugPrintUnknownValue(readStatus);
 369 }
 370
 371 const char *MmsDebugGetMsgType(MmsMsgType msgType)
 372 {
 373         switch (msgType) {
 374         case MMS_MSGTYPE_ERROR:
 375                 return "error";
 376         case MMS_MSGTYPE_SEND_REQ:
 377                 return "send.req";
 378         case MMS_MSGTYPE_SEND_CONF:
 379                 return "send.conf";
 380         case MMS_MSGTYPE_NOTIFICATION_IND:
 381                 return "notification.ind";
 382         case MMS_MSGTYPE_NOTIFYRESP_IND:
 383                 return "notifyResp.ind";
 384         case MMS_MSGTYPE_RETRIEVE_CONF:
 385                 return "retrieve conf";
 386         case MMS_MSGTYPE_ACKNOWLEDGE_IND:
 387                 return "acknowledge ind";
 388         case MMS_MSGTYPE_DELIVERY_IND:
 389                 return "delivery ind";
 390         case MMS_MSGTYPE_READREC_IND:
 391                 return "read rec ind";
 392         case MMS_MSGTYPE_READORG_IND:
 393                 return "read org ind";
 394         case MMS_MSGTYPE_FORWARD_REQ:
 395                 return "forward req";
 396         case MMS_MSGTYPE_FORWARD_CONF:
 397                 return "forward conf";
 398         case MMS_MSGTYPE_READ_REPLY:
 399                 return "read reply";
 400         default:
 401                 return MmsDebugPrintUnknownValue(msgType);
 402         }
 403 }
 404
 405 const char *MmsDebugGetResponseStatus(MmsResponseStatus responseStatus)
 406 {
 407         switch (responseStatus) {
 408         case MMS_RESPSTATUS_ERROR:
 409                 return "error";
 410         case MMS_RESPSTATUS_OK:
 411                 return "ok";
 412         case MMS_RESPSTAUTS_ERROR_UNSPECIFIED:
 413                 return "unspecified";
 414         case MMS_RESPSTAUTS_ERROR_SERVICEDENIED:
 415                 return "service denied";
 416         case MMS_RESPSTAUTS_ERROR_MESSAGEFORMATCORRUPT:
 417                 return "message format corrupt";
 418         case MMS_RESPSTAUTS_ERROR_SENDINGADDRESSUNRESOLVED:
 419                 return "sending address unresolved";
 420         case MMS_RESPSTAUTS_ERROR_MESSAGENOTFOUND:
 421                 return "message not found";
 422         case MMS_RESPSTAUTS_ERROR_NETWORKPROBLEM:
 423                 return "network problem";
 424         case MMS_RESPSTAUTS_ERROR_CONTENTNOTACCEPTED:
 425                 return "content not accepted";
 426         case MMS_RESPSTAUTS_ERROR_UNSUPPORTEDMESSAGE:
 427                 return "unsupported message";
 428         case MMS_RESPSTAUTS_ERROR_TRANSIENT_FAILURE:
 429                 return "transient failure";
 430         case MMS_RESPSTAUTS_ERROR_TRANSIENT_SENDING_ADDRESS_UNRESOLVED:
 431                 return "transient sending address unresolved";
 432         case MMS_RESPSTAUTS_ERROR_TRANSIENT_MESSAGE_NOT_FOUND:
 433                 return "transient message not found";
 434         case MMS_RESPSTAUTS_ERROR_TRANSIENT_NETWORK_PROBLEM:
 435                 return "transient network problem";
 436         case MMS_RESPSTAUTS_ERROR_PERMANENT_FAILURE:
 437                 return "permanent failure";
 438         case MMS_RESPSTAUTS_ERROR_PERMANENT_SERVICE_DENIED:
 439                 return "permanent service denied";
 440         case MMS_RESPSTAUTS_ERROR_PERMANENT_MESSAGE_FORMAT_CORRUPT:
 441                 return "permanent message format corrupt";
 442         case MMS_RESPSTAUTS_ERROR_PERMANENT_SENDING_ADDRESS_UNRESOLVED:
 443                 return "permanent sending address unresolved";
 444         case MMS_RESPSTAUTS_ERROR_PERMANENT_MESSAGE_NOT_FOUND:
 445                 return "permanent message not found";
 446         case MMS_RESPSTAUTS_ERROR_PERMANENT_CONTENT_NOT_ACCEPTED:
 447                 return "permanent content not accepted";
 448         case MMS_RESPSTAUTS_ERROR_PERMANENT_REPLY_CHARGING_LIMITATIONS_NOT_MET:
 449                 return "permanent reply charging limitations not met";
 450         case MMS_RESPSTAUTS_ERROR_PERMANENT_REPLY_CHARGING_REQUEST_NOT_ACCEPTED:
 451                 return "permanent reply charging request not accepted";
 452         case MMS_RESPSTAUTS_ERROR_PERMANENT_REPLY_CHARGING_FORWARDING_DENIED:
 453                 return "permanent reply charging forwarding denied";
 454         case MMS_RESPSTAUTS_ERROR_PERMANENT_REPLY_CHARGING_NOT_SUPPORTED:
 455                 return "permanent reply charging not supported";
 456         }
 457
 458         return MmsDebugPrintUnknownValue(responseStatus);
 459 }
 460
 461
 462 const char *MmsDebugGetRetrieveStatus(MmsRetrieveStatus retrieveStatus)
 463 {
 464         switch (retrieveStatus) {
 465         case MMS_RETRSTATUS_ERROR:
 466                 return "error";
 467         case MMS_RETRSTATUS_OK:
 468                 return "ok";
 469         case MMS_RETRSTATUS_TRANSIENT_FAILURE:
 470                 return "transient failure";
 471         case MMS_RETRSTATUS_TRANSIENT_MESSAGE_NOT_FOUND:
 472                 return "transient message not found";
 473         case MMS_RETRSTATUS_TRANSIENT_NETWORK_PROBLEM:
 474                 return "transient network problem";
 475         case MMS_RETRSTATUS_PERMANENT_FAILURE:
 476                 return "permanent failure";
 477         case MMS_RETRSTATUS_PERMANENT_SERVICE_DENIED:
 478                 return "permanent service denied";
 479         case MMS_RETRSTATUS_PERMANENT_MESSAGE_NOT_FOUND:
 480                 return "permanent message not found";
 481         case MMS_RETRSTATUS_PERMANENT_CONTENT_UNSUPPORT:
 482                 return "permanent content unsupport";
 483         }
 484
 485         return MmsDebugPrintUnknownValue(retrieveStatus);
 486 }
 487
 488
 489 const char *MmsDebugGetMsgStatus(MSG_DELIVERY_REPORT_STATUS_T msgStatus)
 490 {
 491         switch (msgStatus) {
 492         case MSG_DELIVERY_REPORT_ERROR:
 493                 return "error";
 494         case MSG_DELIVERY_REPORT_EXPIRED:
 495                 return "expired";
 496         case MSG_DELIVERY_REPORT_SUCCESS:
 497                 return "retrieved";
 498         case MSG_DELIVERY_REPORT_REJECTED:
 499                 return "rejected";
 500         case MSG_DELIVERY_REPORT_DEFERRED:
 501                 return "deferred";
 502         case MSG_DELIVERY_REPORT_UNRECOGNISED:
 503                 return "unrecognised";
 504         case MSG_DELIVERY_REPORT_INDETERMINATE:
 505                 return "indeterminate";
 506         case MSG_DELIVERY_REPORT_FORWARDED:
 507                 return "forwarded";
 508         case MSG_DELIVERY_REPORT_UNREACHABLE:
 509                 return "unreachable";
 510         }
 511
 512         return MmsDebugPrintUnknownValue(msgStatus);
 513 }
 514
 515
 516 const char *MmsDebugGetMsgClass(MmsMsgClass msgClass)
 517 {
 518         switch (msgClass) {
 519         case MMS_MSGCLASS_ERROR:
 520                 return "error";
 521         case MMS_MSGCLASS_PERSONAL:
 522                 return "personal";
 523         case MMS_MSGCLASS_ADVERTISEMENT:
 524                 return "advertisement";
 525         case MMS_MSGCLASS_INFORMATIONAL:
 526                 return "information";
 527         case MMS_MSGCLASS_AUTO:
 528                 return "auto";
 529         }
 530
 531         return MmsDebugPrintUnknownValue(msgClass);
 532 }
 533
 534
 535 const char *MmsDebugGetDataType(MmsDataType dataType)
 536 {
 537         switch (dataType) {
 538         case MMS_DATATYPE_NONE:
 539                 return "MMS_DATATYPE_NONE";
 540         case MMS_DATATYPE_READ:
 541                 return "MMS_DATATYPE_READ";
 542         case MMS_DATATYPE_SENT:
 543                 return "MMS_DATATYPE_SENT";
 544         case MMS_DATATYPE_NOTIFY:
 545                 return "MMS_DATATYPE_NOTIFY";
 546         case MMS_DATATYPE_UNSENT:
 547                 return "MMS_DATATYPE_UNSENT";
 548         case MMS_DATATYPE_DRAFT:
 549                 return "MMS_DATATYPE_DRAFT";
 550         case MMS_DATATYPE_SENDING:
 551                 return "MMS_DATATYPE_SENDING";
 552         case MMS_DATATYPE_DRM_RO_WAITING:
 553                 return "MMS_DATATYPE_DRM_RO_WAITING";
 554         case MMS_DATATYPE_RETRIEVING:
 555                 return "MMS_DATATYPE_RETRIEVING";
 556         case MMS_DATATYPE_UNRETV:
 557                 return "MMS_DATATYPE_UNRETV";
 558         default:
 559                 return MmsDebugPrintUnknownValue(dataType);
 560         }
 561 }
 562
 563 #ifdef MMS_PLUGIN_DEBUG_ENABLE
 564 bool
 565 MmsDebugPrintMsgAttributes(char *pszFunc, MmsAttrib *pAttrib, bool bAll)
 566 {
 567         SysRequireEx(pAttrib != NULL, false);
 568
 569         if (pszFunc)
 570                 SysDebug((MID_MMS|DBG_MMS_COMMON,"%s ========= \n", pszFunc));
 571
 572         SysDebug((MID_MMS|DBG_MMS_COMMON, "szSubject = %s \n", pAttrib->szSubject));
 573         SysDebug((MID_MMS|DBG_MMS_COMMON, "contentType=%s \n", MmsDebugGetMimeType(pAttrib->contentType)));
 574         SysDebug((MID_MMS|DBG_MMS_COMMON, "dataType=%s \n", MmsDebugGetDataType(pAttrib->dataType)));
 575
 576         if (pAttrib->specialMsgType != MMS_SPECIAL_MSG_TYPE_NONE)
 577                 SysDebug((MID_MMS|DBG_MMS_COMMON, "spcialMsgType = %lu \n", pAttrib->specialMsgType));
 578
 579         SysDebug((MID_MMS|DBG_MMS_COMMON, "date=%lu, msgSize=%lu, bRead=%lu\n", pAttrib->date, pAttrib->msgSize, pAttrib->bRead));
 580
 581         if (!bAll)
 582                 return true;
 583
 584         SysDebug((MID_MMS|DBG_MMS_COMMON, "msgClass=%s, priority=%lu \n", MmsDebugGetMsgClass(pAttrib->msgClass), pAttrib->priority ));
 585         SysDebug((MID_MMS|DBG_MMS_COMMON, "deliveryTime.type = %lu, time = %lu\n", pAttrib->deliveryTime.type, pAttrib->deliveryTime.time));
 586         SysDebug((MID_MMS|DBG_MMS_COMMON, "expiryTime.type = %lu, time = %lu\n", pAttrib->expiryTime.type, pAttrib->expiryTime.time));
 587
 588         if (pAttrib->szTo && pAttrib->szTo[0] != 0)
 589                 SysDebug((MID_MMS|DBG_MMS_COMMON, "szTo = %s \n", pAttrib->szTo));
 590         if (pAttrib->szCc && pAttrib->szCc[0] != 0)
 591                 SysDebug((MID_MMS|DBG_MMS_COMMON, "szCc = %s \n", pAttrib->szCc));
 592         if (pAttrib->szBcc && pAttrib->szBcc[0] != 0)
 593                 SysDebug((MID_MMS|DBG_MMS_COMMON, "szBcc = %s \n", pAttrib->szBcc));
 594
 595 #if defined(_MMS_SUPPORT_RECEIVING_OPTION_PROMPT)
 596         SysDebug((MID_MMS|DBG_MMS_COMMON, "readReportAllowedType = %lu \n", pAttrib->readReportAllowedType));
 597 #endif
 598         SysDebug((MID_MMS|DBG_MMS_COMMON, "bAskDeliveryReport=%lu, bReportAllowed=%lu, bAskReadReply=%lu, bLeaveCopy=%lu \n",
 599                         pAttrib->bAskDeliveryReport, pAttrib->bReportAllowed, pAttrib->bAskReadReply, pAttrib->bLeaveCopy));
 600
 601         if (pAttrib->bHideAddress)
 602                 SysDebug((MID_MMS|DBG_MMS_COMMON, "bHideAddress=true\n"));
 603
 604         SysDebug((MID_MMS|DBG_MMS_COMMON, "msgStatus = %s \n", MmsDebugGetMsgStatus(pAttrib->msgStatus)));
 605         SysDebug((MID_MMS|DBG_MMS_COMMON, "responseStatus = %s \n", MmsDebugGetResponseStatus(pAttrib->responseStatus)));
 606         SysDebug((MID_MMS|DBG_MMS_COMMON, "retrieveStatus = %s \n", MmsDebugGetRetrieveStatus(pAttrib->retrieveStatus)));
 607
 608         if (pAttrib->szResponseText && pAttrib->szResponseText[0] != 0)
 609                 SysDebug((MID_MMS|DBG_MMS_COMMON, "szResponseText = %s \n", pAttrib->szResponseText));
 610
 611         if (pAttrib->szRetrieveText && pAttrib->szRetrieveText[0] != 0)
 612                 SysDebug((MID_MMS|DBG_MMS_COMMON, "szRetrieveText = %s \n", pAttrib->szRetrieveText));
 613
 614         return true;
 615 }
 616
 617 char *MmsDebugGetMsgDrmType(MsgDrmType drmType)
 618 {
 619         switch (drmType) {
 620         case MSG_DRM_TYPE_NONE:
 621                 return "MSG_DRM_TYPE_NONE";
 622         case MSG_DRM_TYPE_FL:
 623                 return "MSG_DRM_TYPE_FL";
 624         case MSG_DRM_TYPE_CD:
 625                 return "MSG_DRM_TYPE_CD";
 626         case MSG_DRM_TYPE_SD:
 627                 return "MSG_DRM_TYPE_SD";
 628         case MSG_DRM_TYPE_SSD:
 629                 return "MSG_DRM_TYPE_SSD";
 630         }
 631
 632         return MmsDebugPrintUnknownValue(drmType);
 633 }
 634
 635 char *MmsDebugGetDrmDeliveryMode(DrmDeliveryMode deliveryMode)
 636 {
 637         switch (deliveryMode) {
 638         case DRM_DELIVERYMODE_FORWARD_LOCK:
 639                 return "DRM_DELIVERYMODE_FORWARD_LOCK";
 640         case DRM_DELIVERYMODE_COMBINED_DELIVERY:
 641                 return "DRM_DELIVERYMODE_COMBINED_DELIVERY";
 642         case DRM_DELIVERYMODE_SEPARATE_DELIVERY:
 643                 return "DRM_DELIVERYMODE_SEPARATE_DELIVERY";
 644         case DRM_DELIVERYMODE_SPECIAL_SEPARATE:
 645                 return "DRM_DELIVERYMODE_SPECIAL_SEPARATE";
 646         }
 647
 648         return MmsDebugPrintUnknownValue(deliveryMode);
 649 }
 650
 651 char *MmsDebugGetDrmRightState(DrmRightState rightState)
 652 {
 653         switch (rightState) {
 654         case DRMRIGHT_STATE_NORIGHTS:
 655                 return "DRMRIGHT_STATE_NORIGHTS";
 656         case DRMRIGHT_STATE_INVALID_RIGHTS:
 657                 return "DRMRIGHT_STATE_INVALID_RIGHTS";
 658         case DRMRIGHT_STATE_VALID_RIGHTS:
 659                 return "DRMRIGHT_STATE_VALID_RIGHTS";
 660         case DRMRIGHT_STATE_EXPIRED_RIGHTS:
 661                 return "DRMRIGHT_STATE_EXPIRED_RIGHTS";
 662         }
 663
 664         return MmsDebugPrintUnknownValue(rightState);
 665 }
 666
 667
 668 bool MmsDebugPrintDrmRight(DrmRight *pDrmRight)
 669 {
 670         if (!pDrmRight)
 671                 return true;
 672
 673         if (pDrmRight->rightStatus == DRMRIGHT_STATE_NORIGHTS) {
 674                 SysDebug((MID_MMS|DBG_MMS_COMMON, "rightStatus = %s \n", MmsDebugGetDrmRightState(pDrmRight->rightStatus)));
 675                 return true;
 676         }
 677
 678         SysDebug((MID_MMS|DBG_MMS_COMMON, "iDeliveryType = %s \n", MmsDebugGetDrmDeliveryMode(pDrmRight->iDeliveryType)));
 679         SysDebug((MID_MMS|DBG_MMS_COMMON, "bestConstraint = %s \n", MmsDebugGetDrmConsumeMode(pDrmRight->bestConstraint)));
 680         SysDebug((MID_MMS|DBG_MMS_COMMON, "bFirstIntervalRender = %d \n", pDrmRight->bFirstIntervalRender));
 681         SysDebug((MID_MMS|DBG_MMS_COMMON, "rightStatus = %s \n", MmsDebugGetDrmRightState(pDrmRight->rightStatus)));
 682
 683         SysDebug((MID_MMS|DBG_MMS_COMMON, "bValidIssuer = %d \n", pDrmRight->bValidIssuer));
 684
 685         return true;
 686 }
 687
 688 char *MmsDebugPrintMsgDRMStatus(MsgDRMStatus status)
 689 {
 690         switch (status) {
 691         case MSG_DRM_STATUS_INVALID:
 692                 return "MSG_DRM_STATUS_INVALID";
 693         case MSG_DRM_STATUS_VALID:
 694                 return "MSG_DRM_STATUS_VALID";
 695         case MSG_DRM_STATUS_EXPIRED:
 696                 return "MSG_DRM_STATUS_EXPIRED";
 697         }
 698
 699         return MmsDebugPrintUnknownValue(status);
 700 }
 701
 702
 703 bool MmsDebugPrintMulitpartEntry(MsgMultipart *pMultipart, int index)
 704 {
 705         SysDebug((MID_MMS|DBG_MMS_COMMON, "------------------------------\n"));
 706         SysDebug((MID_MMS|DBG_MMS_COMMON, "%dth multipart info\n", index));
 707         SysDebug((MID_MMS|DBG_MMS_COMMON, "header size=%d\n", pMultipart->type.size));
 708         SysDebug((MID_MMS|DBG_MMS_COMMON, "body size=%d\n", pMultipart->type.contentSize));
 709         SysDebug((MID_MMS|DBG_MMS_COMMON, "content type=%s\n", MmsDebugGetMimeType(pMultipart->type.type)));
 710         SysDebug((MID_MMS|DBG_MMS_COMMON, "content ID=%s\n", pMultipart->type.szContentID));
 711         SysDebug((MID_MMS|DBG_MMS_COMMON, "content location=%s\n", pMultipart->type.szContentLocation));
 712
 713         if (pMultipart->type.type == MIME_TEXT_PLAIN) {
 714                 SysDebug((MID_MMS|DBG_MMS_COMMON, "text info\n"));
 715                 SysDebug((MID_MMS|DBG_MMS_COMMON, "charset=%d\n", pMultipart->type.param.charset));
 716                 SysDebug((MID_MMS|DBG_MMS_COMMON, "text file name=%s\n", pMultipart->type.param.szName));
 717         }
 718
 719         if (pMultipart->type.drmInfo.drmType != MSG_DRM_TYPE_NONE) {
 720                 SysDebug((MID_MMS|DBG_MMS_COMMON, "drm info\n"));
 721                 SysDebug((MID_MMS|DBG_MMS_COMMON, "drm type=%s\n", MmsDebugGetMsgDrmType(pMultipart->type.drmInfo.drmType)));
 722                 SysDebug((MID_MMS|DBG_MMS_COMMON, "drm content type=%s\n", MmsDebugGetMimeType(pMultipart->type.drmInfo.contentType)));
 723                 SysDebug((MID_MMS|DBG_MMS_COMMON, "drm content URI=%s\n", pMultipart->type.drmInfo.szContentURI));
 724         }
 725         SysDebug((MID_MMS|DBG_MMS_COMMON, "------------------------------\n"));
 726         return true;
 727 }
 728
 729
 730 bool MmsDebugPrintCurrentEventHandler(char *pszFunc, MmsDebugEvType evType)
 731 {
 732         HEventHandler hMmsEH;
 733         HEventHandler hSmsEH;
 734         HEventHandler hEmailEH;
 735         HEventHandler hCommonEH;
 736         HEventHandler hCurrentEH;
 737
 738         hMmsEH          = WmGetEventHandlerByName(EHN_MMS);
 739         hSmsEH          = WmGetEventHandlerByName(EHN_SMS);
 740         hEmailEH        = WmGetEventHandlerByName(EHN_EMAIL);
 741         hCommonEH       = WmGetEventHandlerByName(EHN_MESSENGER);
 742         hCurrentEH      = WmGetCurrentEventHandler();
 743
 744         switch (evType) {
 745         case MMS_DEBUG_EV_MMS:
 746                 SysRequireExf(hCurrentEH == hMmsEH, false, ("%s, hMmsEH=%d, hSmsEH=%d, hEmailEH=%d, hCommonEH=%d, hCurrentEH=%d\n",     \
 747                                                         pszFunc, hMmsEH, hSmsEH, hEmailEH, hCommonEH, hCurrentEH));
 748                 break;
 749
 750         case MMS_DEBUG_EV_SMS:
 751                 SysRequireExf(hCurrentEH == hSmsEH, false, ("%s, hMmsEH=%d, hSmsEH=%d, hEmailEH=%d, hCommonEH=%d, hCurrentEH=%d\n",     \
 752                                                         pszFunc, hMmsEH, hSmsEH, hEmailEH, hCommonEH, hCurrentEH));
 753                 break;
 754
 755         case MMS_DEBUG_EV_COMMON:
 756                 SysRequireExf(hCurrentEH == hCommonEH, false, ("%s, hMmsEH=%d, hSmsEH=%d, hEmailEH=%d, hCommonEH=%d, hCurrentEH=%d\n",  \
 757                                                         pszFunc, hMmsEH, hSmsEH, hEmailEH, hCommonEH, hCurrentEH));
 758                 break;
 759
 760         case MMS_DEBUG_EV_EMAIL:
 761                 SysRequireExf(hCurrentEH == hEmailEH, false, ("%s, hMmsEH=%d, hSmsEH=%d, hEmailEH=%d, hCommonEH=%d, hCurrentEH=%d\n",   \
 762                                                         pszFunc, hMmsEH, hSmsEH, hEmailEH, hCommonEH, hCurrentEH));
 763                 break;
 764
 765         case MMS_DEBUG_EV_NONE:
 766         default:
 767                 SysDebug((MID_MMS,"%s, hMmsEH=%d, hSmsEH=%d, hEmailEH=%d, hCommonEH=%d, hCurrentEH=%d\n",       \
 768                                                         pszFunc, hMmsEH, hSmsEH, hEmailEH, hCommonEH, hCurrentEH));
 769                 break;
 770         }
 771         return true;
 772 }
 773
 774
 775 char *DebugPrintGetRmResultInd(MmsRmResultInd indType)
 776 {
 777         switch (indType) {
 778         case RM_RESULTIND_NONE:
 779                 return "RM_RESULTIND_NONE";
 780
 781         case RM_RESULTIND_MANUAL_SEND:
 782                 return "RM_RESULTIND_MANUAL_SEND";
 783
 784         case RM_RESULTIND_AUTO_SEND:
 785                 return "RM_RESULTIND_AUTO_SEND";
 786
 787         case RM_RESULTIND_MANUAL_GET:
 788                 return "RM_RESULTIND_MANUAL_GET";
 789
 790         case RM_RESULTIND_AUTO_GET:
 791                 return "RM_RESULTIND_AUTO_GET";
 792
 793         case RM_RESULTIND_MANUAL_FORWARD:
 794                 return "RM_RESULTIND_MANUAL_FORWARD";
 795         }
 796
 797         return MmsDebugPrintUnknownValue(indType);
 798 }
 799
 800
 801 char *DebugPrintHttpStatusCode(int status)
 802 {
 803         switch (status) {
 804         case HTTP_STATUS_100:
 805                 return "HTTP_STATUS_100";
 806         case HTTP_STATUS_101:
 807                 return "HTTP_STATUS_101";
 808
 809         case HTTP_STATUS_200:
 810                 return "HTTP_STATUS_200";
 811         case HTTP_STATUS_201:
 812                 return "HTTP_STATUS_201";
 813         case HTTP_STATUS_202:
 814                 return "HTTP_STATUS_202";
 815         case HTTP_STATUS_203:
 816                 return "HTTP_STATUS_203";
 817         case HTTP_STATUS_204:
 818                 return "HTTP_STATUS_204";
 819         case HTTP_STATUS_205:
 820                 return "HTTP_STATUS_205";
 821         case HTTP_STATUS_206:
 822                 return "HTTP_STATUS_206";
 823
 824         case HTTP_STATUS_300:
 825                 return "HTTP_STATUS_300";
 826         case HTTP_STATUS_301:
 827                 return "HTTP_STATUS_301";
 828         case HTTP_STATUS_302:
 829                 return "HTTP_STATUS_302";
 830         case HTTP_STATUS_303:
 831                 return "HTTP_STATUS_303";
 832         case HTTP_STATUS_304:
 833                 return "HTTP_STATUS_304";
 834         case HTTP_STATUS_305:
 835                 return "HTTP_STATUS_305";
 836
 837         case HTTP_STATUS_400:
 838                 return "HTTP_STATUS_400";
 839         case HTTP_STATUS_401:
 840                 return "HTTP_STATUS_401";
 841         case HTTP_STATUS_402:
 842                 return "HTTP_STATUS_402";
 843         case HTTP_STATUS_403:
 844                 return "HTTP_STATUS_403";
 845         case HTTP_STATUS_404:
 846                 return "HTTP_STATUS_404";
 847         case HTTP_STATUS_405:
 848                 return "HTTP_STATUS_405";
 849         case HTTP_STATUS_406:
 850                 return "HTTP_STATUS_406";
 851         case HTTP_STATUS_407:
 852                 return "HTTP_STATUS_407";
 853         case HTTP_STATUS_408:
 854                 return "HTTP_STATUS_408";
 855         case HTTP_STATUS_409:
 856                 return "HTTP_STATUS_409";
 857         case HTTP_STATUS_410:
 858                 return "HTTP_STATUS_410";
 859         case HTTP_STATUS_411:
 860                 return "HTTP_STATUS_411";
 861         case HTTP_STATUS_412:
 862                 return "HTTP_STATUS_412";
 863         case HTTP_STATUS_413:
 864                 return "HTTP_STATUS_413";
 865         case HTTP_STATUS_414:
 866                 return "HTTP_STATUS_414";
 867         case HTTP_STATUS_415:
 868                 return "HTTP_STATUS_415";
 869
 870         case HTTP_STATUS_500:
 871                 return "HTTP_STATUS_500";
 872         case HTTP_STATUS_501:
 873                 return "HTTP_STATUS_501";
 874         case HTTP_STATUS_502:
 875                 return "HTTP_STATUS_502";
 876         case HTTP_STATUS_503:
 877                 return "HTTP_STATUS_503";
 878         case HTTP_STATUS_504:
 879                 return "HTTP_STATUS_504";
 880         case HTTP_STATUS_505:
 881                 return "HTTP_STATUS_505";
 882
 883         case REASON_WTP_UNKNOWN:
 884                 return "REASON_WTP_UNKNOWN";
 885         case REASON_WTP_PROTO_ERR:
 886                 return "REASON_WTP_PROTO_ERR";
 887         case REASON_WTP_INVALID_TID:
 888                 return "REASON_WTP_INVALID_TID";
 889         case REASON_WTP_NOT_IMPLEMENTED_CL2:
 890                 return "REASON_WTP_NOT_IMPLEMENTED_CL2";
 891         case REASON_WTP_NOT_IMPLEMENTED_SAR:
 892                 return "REASON_WTP_NOT_IMPLEMENTED_SAR";
 893         case REASON_WTP_NOT_IMPLEMENTEDU_ACK:
 894                 return "REASON_WTP_NOT_IMPLEMENTEDU_ACK";
 895         case REASON_WTP_VERSIONONE:
 896                 return "REASON_WTP_VERSIONONE";
 897         case REASON_WTP_CAPTEMP_EXCEED:
 898                 return "REASON_WTP_CAPTEMP_EXCEED";
 899         case REASON_WTP_NO_RESPONSE:
 900                 return "REASON_WTP_NO_RESPONSE";
 901         case REASON_WTP_MESSAGE_TOO_LARGE:
 902                 return "REASON_WTP_MESSAGE_TOO_LARGE";
 903
 904         case REASON_PROTOERR:
 905                 return "REASON_PROTOERR";       //  = 0xE0
 906         case REASON_DISCONNECT:
 907                 return "REASON_DISCONNECT";
 908         case REASON_SUSPEND:
 909                 return "REASON_SUSPEND";
 910         case REASON_RESUME:
 911                 return "REASON_RESUME";
 912         case REASON_CONGESTION:
 913                 return "REASON_CONGESTION";
 914         case REASON_CONNECTERR:
 915                 return "REASON_CONNECTERR";
 916         case REASON_MRUEXCEEDED:
 917                 return "REASON_MRUEXCEEDED";
 918         case REASON_MOREXCEEDED:
 919                 return "REASON_MOREXCEEDED";
 920         case REASON_PEERREQ:
 921                 return "REASON_PEERREQ";
 922         case REASON_NETERR:
 923                 return "REASON_NETERR";
 924         case REASON_USERREQ:
 925                 return "REASON_USERREQ";
 926         /* added for ver 1.2 */
 927         case REASON_USERRFS:
 928                 return "REASON_USERRFS";
 929         case REASON_PND:
 930                 return "REASON_PND";
 931         case REASON_USERDCR:
 932                 return "REASON_USERDCR";
 933         case REASON_USERDCU:
 934                 return "REASON_USERDCU";
 935         }
 936
 937         return MmsDebugPrintUnknownValue(status);
 938 }
 939
 940
 941 char *DebugPrintRmMethodType(MmsRmMethodType method)
 942 {
 943         switch (method) {
 944         case RM_METHOD_NONE:
 945                 return "RM_METHOD_NONE";
 946         case RM_METHOD_GET:
 947                 return "RM_METHOD_GET";
 948         case RM_METHOD_POST:
 949                 return "RM_METHOD_POST";
 950         }
 951
 952         return MmsDebugPrintUnknownValue(method);
 953 }
 954
 955
 956 char *DebugPrintGetMmsRmNetState(MmsRmNetState state)
 957 {
 958         switch (state) {
 959         case RM_PROTO_IDLE:
 960                 return "RM_PROTO_IDLE";
 961         case RM_PROTO_STARTING:
 962                 return "RM_PROTO_STARTING";
 963         case RM_PROTO_STARTED:
 964                 return "RM_PROTO_STARTED";
 965         case RM_PROTO_STOPPING:
 966                 return "RM_PROTO_STOPPING";
 967
 968         case RM_PROTO_WAITING:
 969                 return "RM_PROTO_WAITING";
 970         case RM_PROTO_DISCONNECTING_OTHER_APP:
 971                 return "RM_PROTO_DISCONNECTING_OTHER_APP";
 972         case RM_PROTO_DISCONNECTED_BY_OTHER_APP:
 973                 return "RM_PROTO_DISCONNECTED_BY_OTHER_APP";
 974
 975         case RM_PROTO_FAILED:
 976                 return "RM_PROTO_FAILED";
 977         }
 978
 979         return MmsDebugPrintUnknownValue(state);
 980 }
 981
 982
 983 char *DebugPrintGetMmsRmEntityState(MmsRmExEntityState stateEx)
 984 {
 985         switch (stateEx) {
 986         case RM_ENTITY_IDLE:
 987                 return "RM_ENTITY_IDLE";
 988         case RM_ENTITY_PROTO_STARTING:
 989                 return "RM_ENTITY_PROTO_STARTING";
 990
 991         case RM_ENTITY_CNXN_ESTABLISHING:
 992                 return "RM_ENTITY_CNXN_ESTABLISHING";
 993         case RM_ENTITY_CNXN_ESTABLISHED:
 994                 return "RM_ENTITY_CNXN_ESTABLISHED";
 995
 996         case RM_ENTITY_SENDING_REQUEST:
 997                 return "RM_ENTITY_SENDING_REQUEST";
 998         case RM_ENTITY_SENDING_REQ_N_NO_RESPONSE:
 999                 return "RM_ENTITY_SENDING_REQ_N_NO_RESPONSE";
1000
1001         case RM_ENTITY_SENDING_REQ_COMPLETED:
1002                 return "RM_ENTITY_SENDING_REQ_COMPLETED";
1003
1004         case RM_ENTITY_SENDING_REQ_FAILED:
1005                 return "RM_ENTITY_SENDING_REQ_FAILED";
1006         case RM_ENTITY_SENDING_REQ_CANCELLED_BY_USER_CONFIRMED:
1007                 return "RM_ENTITY_SENDING_REQ_CANCELLED_BY_USER_CONFIRMED";
1008         }
1009
1010         return MmsDebugPrintUnknownValue(stateEx);
1011 }
1012
1013
1014 char *MmsDebugPrintMmsRmResult(MmsRmResult result)
1015 {
1016         switch (result) {
1017         case MMS_RM_RESULT_SUCCESSED:
1018                 return "MMS_RM_RESULT_SUCCESSED";
1019         case MMS_RM_RESULT_FAIL:
1020                 return "MMS_RM_RESULT_FAIL";
1021         case MMS_RM_RESULT_FAIL_N_RETRY:
1022                 return "MMS_RM_RESULT_FAIL_N_RETRY";
1023
1024         case MMS_RM_RESULT_PROTO_STARTING_FAILED:
1025                 return "MMS_RM_RESULT_PROTO_STARTING_FAILED";
1026
1027         case MMS_RM_RESULT_DISCONNECT_MMS:
1028                 return "MMS_RM_RESULT_DISCONNECT_MMS";
1029         case MMS_RM_RESULT_CLOSING_OTHER_APP_FAILED:
1030                 return "MMS_RM_RESULT_CLOSING_OTHER_APP_FAILED";
1031
1032         case MMS_RM_RESULT_SENDING_REQ_FAILED:
1033                 return "MMS_RM_RESULT_SENDING_REQ_FAILED";
1034         case MMS_RM_RESULT_CANCELED_BY_USER:
1035                 return "MMS_RM_RESULT_CANCELED_BY_USER";
1036         case MMS_RM_RESULT_CANCELED_FROM_RETRY_POPUP:
1037                 return "MMS_RM_RESULT_CANCELED_FROM_RETRY_POPUP";
1038
1039         case MMS_RM_RESULT_PROTO_FAILED:
1040                 return "MMS_RM_RESULT_PROTO_FAILED";
1041         case MMS_RM_RESULT_DISCONNECTED_BY_OTHER:
1042                 return "MMS_RM_RESULT_DISCONNECTED_BY_OTHER";
1043
1044         case MMS_RM_RESULT_MEMORY_FULL:
1045                 return "MMS_RM_RESULT_MEMORY_FULL";
1046         }
1047
1048         return MmsDebugPrintUnknownValue(result);
1049 }
1050
1051 void MmsDebugPrintReqEntityInfo(MmsRmRequest *pEntity)
1052 {
1053         SysDebug((MID_MMS,"     - proto state=%s\n", DebugPrintGetMmsRmNetState(_MmsRmNetGetState())));
1054
1055         if (_MmsRmNetGetProtoType() == MMS_RM_WAP_CONNORIENTED || _MmsRmNetGetProtoType() == MMS_RM_WTLS) {
1056                 SysDebug((MID_MMS,"     - wap cnxn state=%s\n", DebugPrintWspState(MmsRmWspGetCnxnState())));
1057         }
1058
1059         if (!pEntity) {
1060                 SysDebug((MID_EXCEPTION, "MmsDebugPrintReqEntityInfo : pEntity is NULL. \n"));
1061                 return;
1062         }
1063
1064         SysDebug((MID_MMS,"     - entity state=%s\n", DebugPrintGetMmsRmEntityState(pEntity->stateEx)));
1065
1066         if (pEntity->cb.result.bSend) {
1067                 if (pEntity->pduType == MMS_RM_READ_REPORT_V10) {
1068                         SysDebug((MID_MMS,"     - sending read report v10\n"));
1069                 } else if (pEntity->pduType == MMS_RM_READ_REPORT_V11) {
1070                         SysDebug((MID_MMS,"     - sending read report v11\n"));
1071                 } else {
1072                         SysDebug((MID_MMS,"     - sending msg\n"));
1073                 }
1074         } else {        // then receiving..
1075                 if (pEntity->cb.result.bAutoRetrieving) {
1076                         SysDebug((MID_MMS,"     - retrieving(auto)\n"));
1077                 } else {
1078                         SysDebug((MID_MMS,"     - retrieving(manual)\n"));
1079                 }
1080         }
1081
1082         SysDebug((MID_MMS,"     - msgID=%d, trID=0x%x, pduType=%s\n", pEntity->msgID, pEntity->trId, MmsDebugPrintRmPduType(pEntity->pduType)));
1083
1084         if (pEntity->protoActvCount > 1) {
1085                 SysDebug((MID_MMS,"     - protoActvCount=%d\n", pEntity->protoActvCount));
1086         }
1087
1088         if (pEntity->reqCount > 1) {
1089                 SysDebug((MID_MMS,"     - reqCount=%d\n", pEntity->reqCount));
1090         }
1091
1092         if (pEntity->fullRetryCount > 1) {
1093                 SysDebug((MID_MMS,"     - fullRetryCount=%d\n", pEntity->fullRetryCount));
1094         }
1095 }
1096
1097 char *MmsDebugPrintHttpErrorCode(int errCode)
1098 {
1099         switch (errCode) {
1100         case HTTPERR_INVALID_PARAM:
1101                 return "HTTPERR_INVALID_PARAM";
1102         case HTTPERR_UNKNOWN:
1103                 return "HTTPERR_UNKNOWN";
1104         case HTTPERR_INVALID_PROXY:
1105                 return "HTTPERR_INVALID_PROXY";
1106         case HTTPERR_OUT_OF_MEMORY:
1107                 return "HTTPERR_OUT_OF_MEMORY";
1108         case HTTPERR_NO_RESPONSE:
1109                 return "HTTPERR_NO_RESPONSE";
1110         case HTTPERR_INIT:
1111                 return "HTTPERR_INIT";
1112         case HTTPERR_NETDOWN:
1113                 return "HTTPERR_NETDOWN";
1114         case HTTPERR_TIMEOUT:
1115                 return "HTTPERR_TIMEOUT";
1116         case HTTPERR_HOST_UNREACH:
1117                 return "HTTPERR_HOST_UNREACH";
1118         case HTTPERR_CONN_RESET:
1119                 return "HTTPERR_CONN_RESET";
1120         case HTTPERR_INTERNAL:
1121                 return "HTTPERR_INTERNAL";
1122         case HTTPERR_CHUNKEDTR:
1123                 return "HTTPERR_CHUNKEDTR";
1124         case HTTPERR_USER:
1125                 return "HTTPERR_USER";
1126         case HTTPERR_TOO_BIG:
1127                 return "HTTPERR_TOO_BIG";
1128         case HTTPERR_NOT_SUPPORTED_SVC:
1129                 return "HTTPERR_NOT_SUPPORTED_SVC";
1130         case HTTPERR_NO_CONTENT:
1131                 return "HTTPERR_NO_CONTENT";
1132         case HTTPERR_WRITEFAIL:
1133                 return "HTTPERR_WRITEFAIL";
1134         case HTTPERR_AUTHFAIL:
1135                 return "HTTPERR_AUTHFAIL";
1136
1137         case HTTPERR_DNSFAIL:
1138                 return "HTTPERR_DNSFAIL";
1139         case HTTPERR_UAGENT_NOT_ALLOWED:
1140                 return "HTTPERR_UAGENT_NOT_ALLOWED";
1141
1142         }
1143         return MmsDebugPrintUnknownValue(errCode);
1144 }
1145
1146 char *MmsDebugPrintProtoErrorCode(int errCode)
1147 {
1148         switch (errCode) {
1149         case PROTO_ERROR_NONE:
1150                 return "PROTO_ERROR_NONE";
1151         /* Wireless stack errors */
1152         case PROTO_ERROR_NO_SERVICE:
1153                 return "PROTO_ERROR_NO_SERVICE";
1154         case PROTO_ERROR_INVALID_PARAM:
1155                 return "PROTO_ERROR_INVALID_PARAM";
1156         case PROTO_ERROR_INVALID_APN:
1157                 return "PROTO_ERROR_INVALID_APN";
1158         case PROTO_ERROR_INVALID_OP_MODE:
1159                 return "PROTO_ERROR_INVALID_OP_MODE";
1160         case PROTO_ERROR_INVALID_PROTO_TYPE:
1161                 return "PROTO_ERROR_INVALID_PROTO_TYPE";
1162         case PROTO_ERROR_INVALID_SERVICE_DOMAIN:
1163                 return "PROTO_ERROR_INVALID_SERVICE_DOMAIN";
1164         case PROTO_ERROR_INVALID_PDP_DATA:
1165                 return "PROTO_ERROR_INVALID_PDP_DATA";
1166         case PROTO_ERROR_INVALID_QOS:
1167                 return "PROTO_ERROR_INVALID_QOS";
1168         case PROTO_ERROR_SESSION_DEACTIVATED:
1169                 return "PROTO_ERROR_SESSION_DEACTIVATED";
1170         case PROTO_ERROR_AUTHENTICATION_FAILED:
1171                 return "PROTO_ERROR_AUTHENTICATION_FAILED";
1172         case PROTO_ERROR_MOBILE_FAILURE:
1173                 return "PROTO_ERROR_MOBILE_FAILURE";
1174         case PROTO_ERROR_NETWORK_FAILURE:
1175                 return "PROTO_ERROR_NETWORK_FAILURE";
1176         case PROTO_ERROR_TIMEOUT:
1177                 return "PROTO_ERROR_TIMEOUT";
1178         case PROTO_ERROR_NO_RESOURCE:
1179                 return "PROTO_ERROR_NO_RESOURCE";
1180         case PROTO_ERROR_INVALID_CONTEXT_ID:
1181                 return "PROTO_ERROR_INVALID_CONTEXT_ID";
1182         case PROTO_ERROR_MODEM_IN_USE:
1183                 return "PROTO_ERROR_MODEM_IN_USE";
1184         case PROTO_ERROR_INVALID_SIM_STATE:
1185                 return "PROTO_ERROR_INVALID_SIM_STATE:";
1186         case PROTO_ERROR_SERVICE_NOT_SUBSCRIBED:
1187                 return "PROTO_ERROR_SERVICE_NOT_SUBSCRIBED";
1188         case PROTO_ERROR_SERVICE_NOT_IMPLEMENTED:
1189                 return "PROTO_ERROR_SERVICE_NOT_IMPLEMENTED";
1190         case PROTO_ERROR_FDN_NOT_ALLOWED:
1191                 return "PROTO_ERROR_FDN_NOT_ALLOWED";
1192         case PROTO_ERROR_CALL_INCOME:
1193                 return "PROTO_ERROR_CALL_INCOME";
1194         case PROTO_ERROR_NOT_SUPPORT_3GCSD:
1195                 return "PROTO_ERROR_NOT_SUPPORT_3GCSD";
1196         case PROTO_ERROR_UNKNOWN:
1197                 return "PROTO_ERROR_UNKNOWN";
1198         case PROTO_ERROR_SI_OFFLINE:
1199                 return "PROTO_ERROR_SI_OFFLINE";
1200         /* TCP/IP/PPP stack errors */
1201         case PROTO_ERROR_TCPIP_UP:
1202                 return "PROTO_ERROR_TCPIP_UP";
1203         case PROTO_ERROR_TCPIP_DOWN:
1204                 return "PROTO_ERROR_TCPIP_DOWN";
1205         case PROTO_ERROR_PPP_UP:
1206                 return "PROTO_ERROR_PPP_UP";
1207         case PROTO_ERROR_PPP_DOWN:
1208                 return "PROTO_ERROR_PPP_DOWN";
1209         case PROTO_ERROR_WDP_INIT:
1210                 return "PROTO_ERROR_WDP_INIT";
1211         /* ProtoMgr API call errors */
1212         case PROTO_ERROR_ACTIVE_CONNECTIONS:
1213                 return "PROTO_ERROR_ACTIVE_CONNECTIONS";
1214         case PROTO_ERROR_MAX_CONNECTIONS:
1215                 return "PROTO_ERROR_MAX_CONNECTIONS";
1216         case PROTO_ERROR_INVALID_HANDLE:
1217                 return "PROTO_ERROR_INVALID_HANDLE";
1218         case PROTO_ERROR_INVALID_CONTEXT:
1219                 return "PROTO_ERROR_INVALID_CONTEXT";
1220         case PROTO_ERROR_INVALID_CALLBACK:
1221                 return "PROTO_ERROR_INVALID_CALLBACK";
1222         case PROTO_ERROR_INVALID_EHN:
1223                 return "PROTO_ERROR_INVALID_EHN";
1224         case PROTO_ERROR_INVALID_EVENTCLASS:
1225                 return "PROTO_ERROR_INVALID_EVENTCLASS";
1226         case PROTO_ERROR_INVALID_REFTYPE:
1227                 return "PROTO_ERROR_INVALID_REFTYPE";
1228         case PROTO_ERROR_INVALID_TIMEOUT:
1229                 return "PROTO_ERROR_INVALID_TIMEOUT";
1230         case PROTO_ERROR_MAX_CLIENT:
1231                 return "PROTO_ERROR_MAX_CLIENT";
1232         case PROTO_ERROR_MAX_ACCOUNT:
1233                 return "PROTO_ERROR_MAX_ACCOUNT";
1234         case PROTO_ERROR_ACCESS_DENIED:
1235                 return "PROTO_ERROR_ACCESS_DENIED";
1236         case PROTO_ERROR_REGISTRY_LOAD:
1237                 return "PROTO_ERROR_REGISTRY_LOAD";
1238
1239         case PROTO_ERROR_PCBROWSING_ON:
1240                 return "PROTO_ERROR_PCBROWSING_ON";
1241         case PROTO_ERROR_REACTIVATION_REQ:
1242                 return "PROTO_ERROR_REACTIVATION_REQ";
1243         case PROTO_ERROR_NO_PDP_ACTIVATED:
1244                 return "PROTO_ERROR_NO_PDP_ACTIVATED";
1245
1246         case PROTO_ERROR_MAX:
1247                 return "PROTO_ERROR_MAX";
1248
1249         }
1250
1251         return MmsDebugPrintUnknownValue(errCode);
1252 }
1253
1254
1255 char *DebugPrintWspResult(WspResult wspResult)
1256 {
1257         switch (wspResult) {
1258         case WSP_RESULT_NO_ERROR:
1259                 return "WSP_RESULT_NO_ERROR";
1260         case WSP_RESULT_NO_SESSION:
1261                 return "WSP_RESULT_NO_SESSION";
1262         case WSP_RESULT_NOT_SUITABLE:
1263                 return "WSP_RESULT_NOT_SUITABLE";
1264
1265         case WSP_RESULT_NOT_RESPONDING:
1266                 return "WSP_RESULT_NOT_RESPONDING";
1267         case WSP_RESULT_MOP_EXCEED:
1268                 return "WSP_RESULT_MOP_EXCEED";
1269         case WSP_RESULT_MOM_EXCEED:
1270                 return "WSP_RESULT_MOM_EXCEED";
1271
1272         case WSP_RESULT_UNABLE:
1273                 return "WSP_RESULT_UNABLE";
1274         case WSP_RESULT_UNKNOWN:
1275                 return "WSP_RESULT_UNKNOWN";
1276         case WSP_RESULT_WRONG_PARAM:
1277                 return "WSP_RESULT_WRONG_PARAM";
1278
1279         case WSP_RESULT_NO_MEMORY:
1280                 return "WSP_RESULT_NO_MEMORY";
1281         case WSP_RESULT_NO_HANDLE:
1282                 return "WSP_RESULT_NO_HANDLE";
1283
1284         case WSP_RESULT_CAPABILITY_UNABLE:
1285                 return "WSP_RESULT_CAPABILITY_UNABLE";
1286         case WSP_RESULT_UAGENT_NOT_ALLOWED:
1287                 return "WSP_RESULT_UAGENT_NOT_ALLOWED";
1288         }
1289
1290         return MmsDebugPrintUnknownValue(wspResult);
1291 }
1292
1293
1294 char *DebugPrintWspState(MmsRmWapState wspState)
1295 {
1296         switch (wspState) {     //gMmsRmWapState
1297         case RM_WAP_IDLE:
1298                 return "RM_WAP_IDLE";
1299         case RM_WAP_CONNECTING:
1300                 return "RM_WAP_CONNECTING";
1301         case RM_WAP_CONNECTED:
1302                 return "RM_WAP_CONNECTED";
1303         case RM_WAP_DISCONNECTING:
1304                 return "RM_WAP_DISCONNECTING";
1305         case RM_WAP_SECURE_REDIRECT:
1306                 return "RM_WAP_SECURE_REDIRECT";
1307         case RM_WAP_FAILED:
1308                 return "RM_WAP_FAILED";
1309         case RM_WAP_WTLS_HANDSHAKING:
1310                 return "RM_WAP_WTLS_HANDSHAKING";
1311         case RM_WAP_WTLS_HANDSHAKE_COMPLETED:
1312                 return "RM_WAP_WTLS_HANDSHAKE_COMPLETED";
1313         }
1314
1315         return MmsDebugPrintUnknownValue(wspState);
1316 }
1317
1318
1319 char *MmsDebugPrintRmPduType(MmsRmPduType pduType)
1320 {
1321         switch (pduType) {
1322         case MMS_RM_PDU_TYPE:
1323                 return "MMS_RM_PDU_TYPE";
1324
1325         case MMS_RM_SEND_REQ:
1326                 return "MMS_RM_SEND_REQ";
1327         case MMS_RM_GET_REQ_AUTO:
1328                 return "MMS_RM_GET_REQ_AUTO";
1329         case MMS_RM_GET_REQ_MANUAL:
1330                 return "MMS_RM_GET_REQ_MANUAL";
1331         case MMS_RM_NOTIFY_RESP_IND:
1332                 return "MMS_RM_NOTIFY_RESP_IND";
1333         case MMS_RM_ACK_IND:
1334                 return "MMS_RM_ACK_IND";
1335
1336         case MMS_RM_NOTI_IND:
1337                 return "MMS_RM_NOTI_IND";
1338         case MMS_RM_RETRIEVE_CONF:
1339                 return "MMS_RM_RETRIEVE_CONF";
1340
1341         case MMS_RM_READ_REPORT_V10:
1342                 return "MMS_RM_READ_REPORT_V10";
1343         case MMS_RM_READ_REPORT_V11:
1344                 return "MMS_RM_READ_REPORT_V11";
1345         }
1346
1347         return MmsDebugPrintUnknownValue(pduType);
1348 }
1349
1350
1351 char *MmsDebugPrintMailboxType(MsgMailboxType mailboxType)
1352 {
1353         switch (mailboxType) {
1354         case MSG_MAILBOX_WRITE:
1355                 return "MSG_MAILBOX_WRITE";
1356         case MSG_MAILBOX_INBOX:
1357                 return "MSG_MAILBOX_INBOX";
1358         case MSG_MAILBOX_DRAFT:
1359                 return "MSG_MAILBOX_DRAFT";
1360         case MSG_MAILBOX_SENT:
1361                 return "MSG_MAILBOX_SENT";
1362         case MSG_MAILBOX_MAILBOX:
1363                 return "MSG_MAILBOX_MAILBOX";
1364         case MSG_MAILBOX_OUTBOX:
1365                 return "MSG_MAILBOX_OUTBOX";
1366         case MSG_MAILBOX_TEMPLATE:
1367                 return "MSG_MAILBOX_TEMPLATE";
1368         case MSG_MAILBOX_MYFOLDER:
1369                 return "MSG_MAILBOX_MYFOLDER";
1370         case MSG_MAILBOX_MYFOLDER_LIST:
1371                 return "MSG_MAILBOX_MYFOLDER_LIST";
1372         case MSG_MAILBOX_PRESET:
1373                 return "MSG_MAILBOX_PRESET";
1374         }
1375
1376         return MmsDebugPrintUnknownValue(mailboxType);
1377 }
1378 #endif
1379