src/fw-plugins/common-public/vobject-tizen/src/cals-ical-codec.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <glib.h>
  19 #include <glib/gprintf.h>
  20 #include <ctype.h>
  21 #include <assert.h>
  22 #include <time.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25
  26 #include "cals-typedef.h"
  27 #include "cals-ical.h"
  28 #include "cals-ical-codec.h"
  29 #include "cals-internal.h"
  30 #include "cals-utils.h"
  31
  32 #include "utility/sync_util.h"
  33
  34 #ifndef SYNC_AGENT_LOG
  35 #undef LOG_TAG
  36 #define LOG_TAG "VOBJECT_TIZEN"
  37 #endif
  38
  39 /****************************************************************************************************/
  40 /*                                                GLOBAL VARIABLE DECLARATION AND INITIALIZATION                                                        */
  41 /****************************************************************************************************/
  42
  43 /* Type */
  44 const char *pszCalTypeList[] = {
  45         "AALARM",
  46         "ACTION",
  47         "ATTACH",
  48         "ATTENDEE",
  49         "BEGIN",
  50         "CALSCALE",
  51         "CATEGORIES",
  52         "CLASS",
  53         "COMMENT",
  54         "COMPLETED",
  55         "CONTACT",
  56         "CREATED",
  57         "DALARM",
  58         "DAYLIGHT",
  59         "DCREATED",
  60         "DESCRIPTION",
  61         "DTEND",
  62         "DTSTAMP",
  63         "DTSTART",
  64         "DUE",
  65         "DURATION",
  66         "END",
  67         "EXDATE",
  68         "EXRULE",
  69         "FREEBUSY",
  70         "GEO",
  71         "LAST-MODIFIED",
  72         "LOCATION",
  73         "MALARM",
  74         "METHOD",
  75         "ORGANIZER",
  76         "PALARM",
  77         "PERCENT-COMPLETE",
  78         "PRIORITY",
  79         "PRODID",
  80         "RDATE",
  81         "RECURRENCE-ID",
  82         "RELATED-TO",
  83         "REPEAT",
  84         "REQUEST-STATUS",
  85         "RESOURCES",
  86         "RNUM",
  87         "RRULE",
  88         "SEQUENCE",
  89         "STANDARD",
  90         "STATUS",
  91         "SUMMARY",
  92         "TRANSP",
  93         "TRIGGER",
  94         "TZ",
  95         "TZID",
  96         "TZNAME",
  97         "TZOFFSETFROM",
  98         "TZOFFSETTO",
  99         "TZURL",
 100         "URL",
 101         "UID",
 102         "VALARM",
 103         "VCALENDAR",
 104         "VERSION",
 105         "VEVENT",
 106         "VFREEBUSY",
 107         "VJOURNAL",
 108         "VTIMEZONE",
 109         "VTODO",
 110         "X-FUNAMBOL-ALLDAY"
 111 };
 112
 113 /* Parameter */
 114 static const char *pszCalParamList[] = {
 115         "ALTREP",
 116         "CHARSET",
 117         "CN",
 118         "CONTEXT",
 119         "CUTYPE",
 120         "DELEGATED-FROM",
 121         "DELEGATED-TO",
 122         "DIR",
 123         "ENCODING",
 124         "EXPECT",
 125         "FBTYPE",
 126         "FMTYPE",
 127         "LANGUAGE",
 128         "MEMBER",
 129         "PARTSTAT",
 130         "RANGE",
 131         "RELATED",
 132         "RELTYPE",
 133         "ROLE",
 134         "RSVP",
 135         "SENT_BY",
 136         "STATUS",
 137         "TYPE",
 138         "TZID",
 139         "VALUE"
 140 };
 141
 142 /* Cu type value */
 143 static const ValueObj pCalCutypeValList[] = {
 144         {"GROUP", 0x00000001},
 145         {"INDIVIDUAL", 0x00000002},
 146         {"RESOURCE", 0x00000004},
 147         {"ROOM", 0x00000008},
 148         {"UNKNOWN", 0x00000010}
 149 };
 150
 151 /* Character set value */
 152 static const ValueObj pCalCharsetValList[] = {
 153         {"UTF-8", 0x00000001},
 154         {"UTF-16", 0x00000002}
 155 };
 156
 157 /* Encoding value */
 158 static const ValueObj pCalEncValList[] = {
 159         {"B", 0x00000001},
 160         {"BASE64", 0x00000002},
 161         {"QUOTED-PRINTABLE", 0x00000004},
 162         {"7BIT", 0x00000008},
 163         {"8BIT", 0x00000010}
 164 };
 165
 166 /* Fb type value */
 167 static const ValueObj pCalFbtypeValList[] = {
 168         {"BUSY", 0x00000001},
 169         {"BUSY_TENTATIVE", 0x00000002},
 170         {"BUSY_UNAVAILABLE", 0x00000004},
 171         {"FREE", 0x00000008}
 172 };
 173
 174 /* Partstat value */
 175 static const ValueObj pCalPartstatValList[] = {
 176         {"ACCEPTED", 0x00000001},
 177         {"COMPLETED", 0x00000002},
 178         {"DELEGATED", 0x00000004},
 179         {"DECLINED", 0x00000008},
 180         {"IN_PROCESS", 0x00000010},
 181         {"NEED_ACTION", 0x00000020},
 182         {"TENTATIVE", 0x00000040}
 183 };
 184
 185 /* Range value */
 186 static const ValueObj pCalRangeValList[] = {
 187         {"THISANDFUTURE", 0x00000001},
 188         {"THISANDPRIOR", 0x00000002}
 189 };
 190
 191 /* Related value */
 192 static const ValueObj pCalRelatedValList[] = {
 193         {"END", 0x00000001},
 194         {"START", 0x00000002}
 195 };
 196
 197 /* Rel type value */
 198 static const ValueObj pCalReltypeValList[] = {
 199         {"CHILD", 0x00000001},
 200         {"PARENT", 0x00000002},
 201         {"SIBLING", 0x00000004}
 202 };
 203
 204 /* Value value */
 205 static const ValueObj pCalValValList[] = {
 206         {"BINARY", 0x00000001},
 207         {"BOOLEAN", 0x00000002},
 208         {"CAL-ADDRESS", 0x00000004},
 209         {"CID", 0x00000008},
 210         {"CONTENT-ID", 0x00000010},
 211         {"DATE", 0x00000020},
 212         {"DATE-TIME", 0x00000040},
 213         {"DURATION", 0x00000080},
 214         {"FLOAT", 0x00000100},
 215         {"INTEGER", 0x00000200},
 216         {"PERIOD", 0x00000400},
 217         {"PHONE-NUMBER", 0x00000800},
 218         {"RECUR", 0X00001000},
 219         {"TEXT", 0x00002000},
 220         {"TIME", 0x00004000},
 221         {"URI", 0x00008000},
 222         {"URL", 0x00010000},
 223         {"UTC-OFFSET", 0x00020000},
 224         {"VCALENDAR", 0x00040000},
 225         {"VEVENT", 0x00080000},
 226         {"VTODO", 0x00100000}
 227 };
 228
 229 /* Type value */
 230 static const ValueObj pCalTypeValList[] = {
 231         {"AIFF", 0x00000001},
 232         {"BBS", 0x00000002},
 233         {"CAR", 0x00000004},
 234         {"CELL", 0x00000008},
 235         {"DOM", 0x00000010},
 236         {"FAX", 0x00000020},
 237         {"GIF", 0x00000040},
 238         {"HOME", 0x00000080},
 239         {"INTL", 0x00000100},
 240         {"INTERNET", 0x00000200},
 241         {"ISDN", 0x00000400},
 242         {"JPEG", 0x00000800},
 243         {"MODEM", 0x00001000},
 244         {"MSG", 0x00002000},
 245         {"PAGER", 0x00004000},
 246         {"PARCEL", 0x00008000},
 247         {"PCM", 0x00010000},
 248         {"PCS", 0x00020000},
 249         {"PNG", 0x00040000},
 250         {"POSTAL", 0x00080000},
 251         {"PREF", 0x00100000},
 252         {"VCARD", 0x00200000},
 253         {"VIDEO", 0x00400000},
 254         {"VOICE", 0x00800000},
 255         {"WAVE", 0x01000000},
 256         {"WBMP", 0x02000000},
 257         {"WORK", 0x04000000},
 258         {"X400", 0x08000000}
 259 };
 260
 261 /* Expect value */
 262 static const ValueObj pCalExpectValList[] = {
 263         {"FYI", 0x00000001},
 264         {"IMMEDIATE", 0x00000002},
 265         {"REQUEST", 0x00000004},
 266         {"REQUIRE", 0x00000008}
 267 };
 268
 269 /* Role value */
 270 static const ValueObj pCalRoleValList[] = {
 271         {"ATTENDEE", 0x00000001},
 272         {"CHAIR", 0x00000002},
 273         {"DELEGATE", 0x00000004},
 274         {"NON_PARTICIPANT", 0x00000008},
 275         {"OPT_PARTICIPANT", 0x00000010},
 276         {"ORGANIZER", 0x00000020},
 277         {"OWNER", 0x00000040},
 278         {"REQ_PARTICIPANT", 0x00000080}
 279 };
 280
 281 /* RSVP value */
 282 static const ValueObj pCalRSVPValList[] = {
 283         {"false", 0x00000001},
 284         {"NO", 0x00000002},
 285         {"true", 0x00000004},
 286         {"YES", 0x00000008}
 287 };
 288
 289 /* Status value */
 290 static const ValueObj pCalStatusValList[] = {
 291         {"ACCEPTED", 0x00000001},
 292         {"COMPLETED", 0x00000002},
 293         {"CONFIRMED", 0x00000004},
 294         {"DECLINED", 0x00000008},
 295         {"DELEGATED", 0x00000010},
 296         {"NEEDS ACTION", 0x00000020},
 297         {"SENT", 0x00000040},
 298         {"TENTATIVE", 0x00000080},
 299 };
 300
 301 static char *__VCalParamEncode(VObject *, int *);
 302
 303 void _gbase64Encode(char *Dest, char *Src, int len)
 304 {
 305         _INNER_FUNC_ENTER;
 306
 307         gchar *buf = g_base64_encode((guchar *) Src, strlen(Src));
 308         int dest_len = 0;
 309         dest_len = g_strlcpy(Dest, buf, len);
 310         if (dest_len >= len) {
 311                 _DEBUG_ERROR("Dest buffer overflow !!");
 312                 /* todo : exception handling */
 313         }
 314         _DEBUG_TRACE("_gbase64Decode before:\n%s \n", Src);
 315         _DEBUG_TRACE("_gbase64Decode after:\n%s \n", Dest);
 316         g_free(buf);
 317
 318         _INNER_FUNC_EXIT;
 319 }
 320
 321 /*
 322  * vcal_free_vtree_memory() frees memory used for decoding.
 323  *
 324  * @param       pTree            VTree structure to be freed.
 325  * @return      If succeeds, return true, else false.
 326  */
 327 bool vcal_free_vtree_memory(VTree * pTree)
 328 {
 329         _EXTERN_FUNC_ENTER;
 330
 331         VObject *pCurObj = NULL;
 332         VObject *pNextObj = NULL;
 333         VTree *pCurTree = NULL;
 334         VTree *pNextTree = NULL;
 335
 336         _DEBUG_INFO("vcal_free_vtree_memory() entered.\n");
 337         //SysRequireEx( pTree != NULL, false );
 338         retvm_if(NULL == pTree, NULL, "[ERROR]vcal_free_vtree_memory:Invalid parameter(pTree)!\n");
 339
 340         if ((pTree->treeType == VCALENDAR) || ((pTree->treeType >= VEVENT) && (pTree->treeType <= DAYLIGHT))) {
 341                 //continue
 342                 ;
 343         } else {
 344                 return false;
 345         }
 346
 347         pCurTree = pTree;
 348
 349         while (pCurTree) {
 350                 pNextTree = pCurTree->pNext;
 351                 pCurObj = pCurTree->pTop;
 352
 353                 while (pCurObj) {
 354                         int count;
 355                         int i;
 356
 357                         pNextObj = pCurObj->pSibling;
 358
 359                         count = pCurObj->valueCount;
 360
 361                         for (i = 0; i < count; i++) {
 362                                 if (pCurObj->pszValue[i] != NULL) {
 363                                         free(pCurObj->pszValue[i]);
 364                                         pCurObj->pszValue[i] = NULL;
 365                                 }
 366                         }
 367
 368 #ifdef VDATA_GROUPNAME_SUPPORTED
 369                         if (pCurObj->pszGroupName != NULL) {
 370                                 free(pCurObj->pszGroupName);
 371                                 pCurObj->pszGroupName = NULL;
 372                         }
 373 #endif                          // VDATA_GROUPNAME_SUPPORTED
 374
 375                         if (pCurObj->pParam != NULL) {
 376                                 VParam *pCurParam = NULL;
 377                                 VParam *pNextParam = NULL;
 378
 379                                 pCurParam = pCurObj->pParam;
 380
 381                                 while (pCurParam) {
 382                                         pNextParam = pCurParam->pNext;
 383
 384                                         free(pCurParam);
 385                                         pCurParam = NULL;
 386
 387                                         pCurParam = pNextParam;
 388                                 }
 389                         }
 390
 391                         free(pCurObj);
 392                         pCurObj = NULL;
 393
 394                         pCurObj = pNextObj;
 395                 }
 396
 397                 free(pCurTree);
 398                 pCurTree = NULL;
 399
 400                 pCurTree = pNextTree;
 401         }
 402
 403         _DEBUG_INFO("\n---------------------------exit vcal_free_vtree_memory--------- -------------\n");
 404
 405         _EXTERN_FUNC_EXIT;
 406
 407         return true;
 408 }
 409
 410 /*
 411  * vCaLTypeEncoder() compares the string and VCal type, parameter value.
 412  *
 413  * @param               typeObj                         Data which will be encoded
 414  * @param               type                            Name of the type
 415  * @return      char *              Encoded result
 416  */
 417 static char *__VCalTypeEncode(VObject * pTypeObj, const char *pType)
 418 {
 419         _INNER_FUNC_ENTER;
 420
 421         int len;
 422         char *pTemp = NULL;
 423         char *szTypeValue = NULL;
 424         int i;
 425         int enc = 0;
 426         char *pEncode = NULL;
 427         char *pRes = NULL;
 428         int total = 0;
 429         int biLen = 0;
 430         char *tempszTypeValue = NULL;
 431         int temp_len = 0;
 432
 433         _DEBUG_VERBOSE("__VCalTypeEncode() enter..\n");
 434
 435         len = strlen(pType);
 436         biLen = pTypeObj->numOfBiData;
 437
 438         if ((szTypeValue = (char *)malloc(total += (len + 1 + 10))) == NULL) {
 439                 _DEBUG_ERROR("VCalTypeEncode():malloc failed\n");
 440                 return NULL;
 441         }
 442
 443         memset(szTypeValue, '\0', (len + 1 + 10));
 444         memcpy(szTypeValue, pType, len);
 445
 446         pTemp = __VCalParamEncode(pTypeObj, &enc);
 447         if (pTemp != NULL) {
 448                 len = strlen(pTemp);
 449                 tempszTypeValue = szTypeValue;
 450                 if ((szTypeValue = (char *)realloc(szTypeValue, (total += len + 10))) == NULL) {
 451                         _DEBUG_ERROR("__VCalTypeEncode():realloc failed\n");
 452                         if (pTemp != NULL) {
 453                                 free(pTemp);
 454                                 pTemp = NULL;
 455                         }
 456
 457                         if (tempszTypeValue != NULL) {
 458                                 free(tempszTypeValue);
 459                                 tempszTypeValue = NULL;
 460                         }
 461                         return NULL;
 462                 }
 463                 temp_len = g_strlcat(szTypeValue, pTemp, total);
 464                 if (temp_len >= total) {
 465                         _DEBUG_ERROR("szTypeValue buffer overflow !!");
 466                         /* todo : exception handling */
 467                 }
 468                 free(pTemp);
 469         }
 470
 471         tempszTypeValue = szTypeValue;
 472         if ((szTypeValue = (char *)realloc(szTypeValue, (total += 2 + 10))) == NULL) {
 473
 474                 _DEBUG_ERROR("__VCalTypeEncode():realloc failed\n");
 475                 if (tempszTypeValue != NULL) {
 476                         free(tempszTypeValue);
 477                         tempszTypeValue = NULL;
 478                 }
 479                 return NULL;
 480         }
 481         temp_len = 0;
 482         temp_len = g_strlcat(szTypeValue, ":\0", total);
 483         if (temp_len >= total) {
 484                 _DEBUG_ERROR("szTypeValue buffer overflow !!");
 485                 /* todo : exception handling */
 486         }
 487
 488         len = 0;
 489         for (i = 0; i < pTypeObj->valueCount; i++) {
 490                 if ((pTypeObj->pszValue[i] == NULL)) {
 491                         free(szTypeValue);
 492                         return NULL;
 493                 }
 494
 495                 len += strlen(pTypeObj->pszValue[i]);
 496         }
 497
 498         int buf_len = 0;
 499         char *buf = NULL;
 500         if ((pEncode = (char *)calloc(1, (len + 30) * 2 + 31)) == NULL) {
 501                 free(szTypeValue);
 502                 _DEBUG_ERROR("__VCalTypeEncode():malloc failed\n");
 503                 return NULL;
 504         }
 505         for (i = 0; i < pTypeObj->valueCount; i++) {
 506                 int len_i = strlen(pTypeObj->pszValue[i]);
 507                 if (buf_len < len_i) {
 508                         free(buf);
 509                         buf_len = len_i;
 510                         if ((buf = (char *)calloc(1, buf_len * 2 + 1)) == NULL) {
 511                                 free(szTypeValue);
 512                                 _DEBUG_ERROR("__VCalTypeEncode():malloc failed\n");
 513                                 free(pEncode);
 514                                 return NULL;
 515                         }
 516                 } else {
 517                         if (buf != NULL)
 518                                 bzero(buf, buf_len);
 519                 }
 520
 521                 if (buf != NULL) {
 522                         strncpy(buf, pTypeObj->pszValue[i], len_i);
 523                         _VEscape(buf);
 524
 525                         if (i) {
 526                                 temp_len = 0;
 527                                 temp_len = g_strlcat(pEncode, ";", ((len + 30) * 2 + 31));
 528                                 if (temp_len >= ((len + 30) * 2 + 31)) {
 529                                         _DEBUG_ERROR("pEncode buffer overflow !!");
 530                                         /* todo : exception handling */
 531                                 }
 532                         }
 533                         temp_len = 0;
 534                         temp_len = g_strlcat(pEncode, buf, ((len + 30) * 2 + 31));
 535                         if (temp_len >= ((len + 30) * 2 + 31)) {
 536                                 _DEBUG_ERROR("pEncode buffer overflow !!");
 537                                 /* todo : exception handling */
 538                         }
 539                 }
 540         }
 541         free(buf);
 542
 543         temp_len = 0;
 544         temp_len = g_strlcat(pEncode, "\0\0", ((len + 30) * 2 + 31));
 545         if (temp_len >= ((len + 30) * 2 + 31)) {
 546                 _DEBUG_ERROR("pEncode buffer overflow !!");
 547                 /* todo : exception handling */
 548         }
 549         //      _VEscape( pEncode );
 550         len = strlen(pEncode);
 551
 552         if (enc & pCalEncValList[2].flag) {
 553
 554                 //if ( ( pRes = ( char * )malloc( len+40 ) ) == NULL )
 555                 //if ( ( pRes = ( char * )malloc( len+40+10 ) ) == NULL )
 556                 // Task description?? enter?? ??? ??? memory ?????. len * 4 + 30 -> len * 6 + 30???? ???? 2004.3.12
 557                 if ((pRes = (char *)malloc(len * 6 + 30)) == NULL) {
 558                         _DEBUG_ERROR("__VCalTypeEncode():malloc failed\n");
 559
 560                         free(pEncode);
 561                         free(szTypeValue);
 562
 563                         return NULL;
 564                 }
 565                 _VQPEncode(pRes, pEncode);
 566                 free(pEncode);
 567                 pEncode = NULL;
 568         } else if (enc & pCalEncValList[1].flag) {
 569
 570                 //if ( ( pRes = ( char * )malloc( ( len * 8 / 6 ) + 4 ) ) == NULL )
 571                 if ((pRes = (char *)malloc((len * 8 / 6) + 4 + 10)) == NULL) {
 572                         _DEBUG_ERROR("__VCalTypeEncode():malloc failed\n");
 573                         free(pEncode);
 574                         free(szTypeValue);
 575
 576                         return NULL;
 577                 }
 578                 //memset( pRes, '\0', ( ( len * 8 / 6 ) + 4 ) );
 579                 memset(pRes, '\0', ((len * 8 / 6) + 4 + 10));
 580 //              _gbase64Encode( pRes, pEncode, biLen );
 581                 _gbase64Encode(pRes, pEncode, ((len * 8 / 6) + 4 + 10));
 582
 583                 free(pEncode);
 584                 pEncode = NULL;
 585         } else {
 586
 587                 //if ( ( pRes = ( char * )malloc( len+2 ) ) == NULL )
 588                 if ((pRes = (char *)malloc(len + 2 + 10)) == NULL) {
 589                         _DEBUG_ERROR("__VCalTypeEncode():malloc failed\n");
 590
 591                         free(pEncode);
 592                         free(szTypeValue);
 593
 594                         return NULL;
 595                 }
 596                 //memset( pRes, '\0', ( len + 2 ) );
 597                 memset(pRes, '\0', (len + 2 + 10));
 598                 memcpy(pRes, pEncode, len);
 599                 free(pEncode);
 600                 pEncode = NULL;
 601         }
 602
 603         temp_len = 0;
 604         temp_len = g_strlcat(pRes, "\r\n", (len + 2 + 10));
 605         if (temp_len >= (len + 2 + 10)) {
 606                 _DEBUG_ERROR("pRes buffer overflow !!");
 607                 /* todo : exception handling */
 608         }
 609
 610         len = strlen(pRes);
 611         //if ( ( szTypeValue = ( char * )realloc( szTypeValue, ( total += ( len+3 ) ) ) ) == NULL )
 612         tempszTypeValue = szTypeValue;
 613         if ((szTypeValue = (char *)malloc((total += (len * 4 + 3 + 10)))) == NULL) {
 614                 _DEBUG_ERROR("__VCalTypeEncode():realloc failed\n");
 615                 if (pRes != NULL) {
 616                         free(pRes);
 617                         pRes = NULL;
 618                 }
 619                 if (tempszTypeValue != NULL) {
 620                         free(tempszTypeValue);
 621                         tempszTypeValue = NULL;
 622                 }
 623
 624                 return NULL;
 625         }
 626
 627         memset(szTypeValue, 0x00, total);
 628         strncpy(szTypeValue, tempszTypeValue, total);
 629         temp_len = 0;
 630         temp_len = g_strlcat(szTypeValue, pRes, total);
 631         if (temp_len >= (total + 1)) {
 632                 _DEBUG_ERROR("szTypeValue buffer overflow !!");
 633                 /* todo : exception handling */
 634         }
 635         _VRLSpace(szTypeValue);
 636         _VRTSpace(szTypeValue);
 637
 638         free(tempszTypeValue);
 639         free(pRes);
 640         if (strlen(szTypeValue) >= 75) {
 641                 if ((pEncode = (char *)malloc(sizeof(char) * (strlen(szTypeValue) * 4 + (strlen(szTypeValue) / 75) * 2 + 10 + 10))) == NULL) {
 642                         _DEBUG_ERROR("__VCalTypeEncode():malloc failed\n");
 643                         free(szTypeValue);
 644                         return NULL;
 645                 }
 646
 647                 _VFolding(pEncode, szTypeValue);
 648                 free(szTypeValue);
 649
 650                 return pEncode;
 651         }
 652
 653         _DEBUG_VERBOSE("__VCalTypeEncode() end..\n");
 654
 655         _INNER_FUNC_EXIT;
 656
 657         return szTypeValue;
 658 }
 659
 660 /*
 661  * vcal_encode() compares the string and VCal type, parameter value.
 662  *
 663  * @param       pVCalRaw            Data which will be encoded
 664  * @return      char *              Encoded result
 665  */
 666 char *vcal_encode(VTree * pVCalRaw)
 667 {
 668         _EXTERN_FUNC_ENTER;
 669
 670         char *pCalRes = NULL;
 671         char *pTemp = NULL;
 672         int len;
 673         int total = 0;
 674         VTree *pTmpTree = NULL;
 675         VObject *pTmpObj = NULL;
 676         int temp_len = 0;
 677
 678         _DEBUG_INFO("vcal_encode() enter..\n");
 679         //SysRequireEx( pVCalRaw != NULL, NULL );
 680         if (pVCalRaw == NULL)
 681                 return NULL;
 682
 683         if ((pVCalRaw->treeType == VCALENDAR) || ((pVCalRaw->treeType >= VEVENT) && (pVCalRaw->treeType <= DAYLIGHT))) {
 684                 //continue
 685                 ;
 686         } else {
 687                 return NULL;
 688         }
 689
 690         if ((pCalRes = (char *)malloc(total += 2)) == NULL) {
 691                 _DEBUG_INFO("vcal_encode():malloc failed\n");
 692                 return NULL;
 693         }
 694         memset(pCalRes, '\0', 1);
 695
 696         pTmpTree = pVCalRaw;
 697         pTmpObj = pTmpTree->pTop;
 698
 699         /*
 700            if( (pTmpObj == NULL) || (pTmpObj->property < 0) || (pTmpObj->valueCount < 0) )
 701            {
 702            if(pTmpObj !=NULL)
 703            _DEBUG_INFO(  "pTmpObj = %d, pTmpObj->property = %d,pTmpObj->valueCount=%d \n",pTmpObj,pTmpObj->property,pTmpObj->valueCount);
 704            else
 705            _DEBUG_INFO("pTmpObj is NULL");
 706            return NULL;
 707            } */
 708
 709         while (true) {
 710                 switch (pTmpTree->treeType) {
 711                 case VCALENDAR:
 712
 713                         // wyj add PRODID field,set PRODID length is 100
 714                         if ((pCalRes = (char *)realloc(pCalRes, (total += 18 + 100 + 15))) == NULL) {
 715
 716                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 717                                 return NULL;
 718                         }
 719
 720                         temp_len = g_strlcat(pCalRes, "BEGIN:VCALENDAR\r\n", total);
 721                         temp_len = g_strlcat(pCalRes, "PRODID:-//Samsung Electronics //Calendar //EN\r\n", total);
 722                         temp_len = g_strlcat(pCalRes, "VERSION:1.0\r\n", total);
 723                         if (temp_len >= (total + 1)) {
 724                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 725                                 /* todo : exception handling */
 726                         }
 727                         break;
 728                 case VEVENT:
 729                         if ((pCalRes = (char *)realloc(pCalRes, (total += 15))) == NULL) {
 730
 731                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 732                                 return NULL;
 733                         }
 734                         temp_len = 0;
 735                         temp_len = g_strlcat(pCalRes, "BEGIN:VEVENT\r\n", total);
 736                         if (temp_len >= (total + 1)) {
 737                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 738                                 /* todo : exception handling */
 739                         }
 740                         break;
 741                 case VTODO:
 742                         if ((pCalRes = (char *)realloc(pCalRes, (total += 14))) == NULL) {
 743
 744                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 745                                 return NULL;
 746                         }
 747                         temp_len = 0;
 748                         temp_len = g_strlcat(pCalRes, "BEGIN:VTODO\r\n", total);
 749                         if (temp_len >= (total + 1)) {
 750                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 751                                 /* todo : exception handling */
 752                         }
 753                         break;
 754                 case VJOURNAL:
 755                         if ((pCalRes = (char *)realloc(pCalRes, (total += 17))) == NULL) {
 756
 757                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 758                                 return NULL;
 759                         }
 760                         temp_len = 0;
 761                         temp_len = g_strlcat(pCalRes, "BEGIN:VJOURNAL\r\n", total);
 762                         if (temp_len >= (total + 1)) {
 763                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 764                                 /* todo : exception handling */
 765                         }
 766                         break;
 767                 case VFREEBUSY:
 768                         if ((pCalRes = (char *)realloc(pCalRes, (total += 18))) == NULL) {
 769
 770                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 771                                 return NULL;
 772                         }
 773                         temp_len = 0;
 774                         temp_len = g_strlcat(pCalRes, "BEGIN:VFREEBUSY\r\n", total);
 775                         if (temp_len >= (total + 1)) {
 776                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 777                                 /* todo : exception handling */
 778                         }
 779                         break;
 780                 case VTIMEZONE:
 781                         if ((pCalRes = (char *)realloc(pCalRes, (total += 19))) == NULL) {
 782
 783                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 784                                 return NULL;
 785                         }
 786                         temp_len = 0;
 787                         temp_len = g_strlcat(pCalRes, "BEGIN:VTIMEZONE\r\n", total);
 788                         if (temp_len >= (total + 1)) {
 789                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 790                                 /* todo : exception handling */
 791                         }
 792                         break;
 793                 case VALARM:
 794                         if ((pCalRes = (char *)realloc(pCalRes, (total += 15))) == NULL) {
 795
 796                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 797                                 return NULL;
 798                         }
 799                         temp_len = 0;
 800                         temp_len = g_strlcat(pCalRes, "BEGIN:VALARM\r\n", total);
 801                         if (temp_len >= (total + 1)) {
 802                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 803                                 /* todo : exception handling */
 804                         }
 805                         break;
 806                 case STANDARD:
 807                         if ((pCalRes = (char *)realloc(pCalRes, (total += 17))) == NULL) {
 808
 809                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 810                                 return NULL;
 811                         }
 812                         temp_len = 0;
 813                         temp_len = g_strlcat(pCalRes, "BEGIN:STANDARD\r\n", total);
 814                         if (temp_len >= (total + 1)) {
 815                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 816                                 /* todo : exception handling */
 817                         }
 818                         break;
 819                 case DAYLIGHT:
 820                         if ((pCalRes = (char *)realloc(pCalRes, (total += 17))) == NULL) {
 821
 822                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 823                                 return NULL;
 824                         }
 825                         temp_len = 0;
 826                         temp_len = g_strlcat(pCalRes, "BEGIN:DAYLIGHT\r\n", total);
 827                         if (temp_len >= (total + 1)) {
 828                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 829                                 /* todo : exception handling */
 830                         }
 831                         break;
 832                 }
 833
 834                 while (true) {
 835                         if (pTmpObj != NULL) {
 836                                 if (pTmpObj->property < 0 || pTmpObj->property >= VCAL_TYPE_NUM) {
 837                                         if (pCalRes != NULL)
 838                                                 free(pCalRes);
 839                                         return NULL;
 840                                 }
 841                                 if ((pTemp = __VCalTypeEncode(pTmpObj, pszCalTypeList[pTmpObj->property])) != NULL) {
 842                                         len = strlen(pTemp);
 843                                         if ((pCalRes = (char *)realloc(pCalRes, (total += (len + 10)))) == NULL) {
 844                                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 845                                                 free(pTemp);
 846                                                 pTemp = NULL;
 847                                                 return NULL;
 848                                         }
 849                                         temp_len = 0;
 850                                         temp_len = g_strlcat(pCalRes, pTemp, total);
 851                                         if (temp_len >= (total + 1)) {
 852                                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 853                                                 /* todo : exception handling */
 854                                         }
 855                                         free(pTemp);
 856                                 }
 857
 858                                 if (pTmpObj->pSibling != NULL)
 859                                         pTmpObj = pTmpObj->pSibling;
 860                                 else
 861                                         break;
 862                         } else
 863                                 break;
 864                 }
 865
 866                 switch (pTmpTree->treeType) {
 867                         /*      case VCALENDAR:
 868                            if ( ( pCalRes = ( char * )realloc( pCalRes, ( total += 15 ) ) ) == NULL )
 869                            {
 870                            _DEBUG_INFO(  "vcal_encode():realloc failed\n");
 871                            return NULL;
 872                            }
 873                            memcpy( pCalRes, "END:VCALENDAR\r\n", 17 );
 874                            break; */
 875                 case VEVENT:
 876                         if ((pCalRes = (char *)realloc(pCalRes, (total += 13))) == NULL) {
 877
 878                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 879                                 return NULL;
 880                         }
 881                         temp_len = 0;
 882                         temp_len = g_strlcat(pCalRes, "END:VEVENT\r\n", total);
 883                         if (temp_len >= (total + 1)) {
 884                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 885                                 /* todo : exception handling */
 886                         }
 887                         break;
 888                 case VTODO:
 889                         if ((pCalRes = (char *)realloc(pCalRes, (total += 12))) == NULL) {
 890
 891                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 892                                 return NULL;
 893                         }
 894                         temp_len = 0;
 895                         temp_len = g_strlcat(pCalRes, "END:VTODO\r\n", total);
 896                         if (temp_len >= (total + 1)) {
 897                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 898                                 /* todo : exception handling */
 899                         }
 900                         break;
 901                 case VJOURNAL:
 902                         if ((pCalRes = (char *)realloc(pCalRes, (total += 15))) == NULL) {
 903
 904                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 905                                 return NULL;
 906                         }
 907                         temp_len = 0;
 908                         temp_len = g_strlcat(pCalRes, "END:VJOURNALO\r\n", total);
 909                         if (temp_len >= (total + 1)) {
 910                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 911                                 /* todo : exception handling */
 912                         }
 913                         break;
 914                 case VFREEBUSY:
 915                         if ((pCalRes = (char *)realloc(pCalRes, (total += 16))) == NULL) {
 916
 917                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 918                                 return NULL;
 919                         }
 920                         temp_len = 0;
 921                         temp_len = g_strlcat(pCalRes, "END:VFREEBUSY\r\n", total);
 922                         if (temp_len >= (total + 1)) {
 923                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 924                                 /* todo : exception handling */
 925                         }
 926                         break;
 927                 case VTIMEZONE:
 928                         if ((pCalRes = (char *)realloc(pCalRes, (total += 16))) == NULL) {
 929
 930                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 931                                 return NULL;
 932                         }
 933                         temp_len = 0;
 934                         temp_len = g_strlcat(pCalRes, "END:VTIMEZONE\r\n", total);
 935                         if (temp_len >= (total + 1)) {
 936                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 937                                 /* todo : exception handling */
 938                         }
 939                         break;
 940                 case VALARM:
 941                         if ((pCalRes = (char *)realloc(pCalRes, (total += 13))) == NULL) {
 942
 943                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 944                                 return NULL;
 945                         }
 946                         temp_len = 0;
 947                         temp_len = g_strlcat(pCalRes, "END:VALARM\r\n", total);
 948                         if (temp_len >= (total + 1)) {
 949                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 950                                 /* todo : exception handling */
 951                         }
 952                         break;
 953                 case STANDARD:
 954                         if ((pCalRes = (char *)realloc(pCalRes, (total += 15))) == NULL) {
 955
 956                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 957                                 return NULL;
 958                         }
 959                         temp_len = 0;
 960                         temp_len = g_strlcat(pCalRes, "END:STANDARD\r\n", total);
 961                         if (temp_len >= (total + 1)) {
 962                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 963                                 /* todo : exception handling */
 964                         }
 965                         break;
 966                 case DAYLIGHT:
 967                         if ((pCalRes = (char *)realloc(pCalRes, (total += 15))) == NULL) {
 968                                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 969                                 return NULL;
 970                         }
 971                         temp_len = 0;
 972                         temp_len = g_strlcat(pCalRes, "END:DAYLIGHT\r\n", total);
 973                         if (temp_len >= (total + 1)) {
 974                                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 975                                 /* todo : exception handling */
 976                         }
 977                         break;
 978                 }
 979
 980                 if (pTmpTree->pNext != NULL)
 981                         pTmpTree = pTmpTree->pNext;
 982                 else
 983                         break;
 984                 pTmpObj = pTmpTree->pTop;
 985         }
 986
 987         if ((pCalRes = (char *)realloc(pCalRes, (total += 16))) == NULL) {
 988
 989                 _DEBUG_INFO("vcal_encode():realloc failed\n");
 990                 return NULL;
 991         }
 992         temp_len = 0;
 993         temp_len = g_strlcat(pCalRes, "END:VCALENDAR\r\n", total);
 994         if (temp_len >= (total + 1)) {
 995                 _DEBUG_ERROR("pCalRes buffer overflow !!");
 996                 /* todo : exception handling */
 997         }
 998
 999         _DEBUG_INFO("vcal_encode() end..\n");
1000
1001         _EXTERN_FUNC_EXIT;
1002
1003         return pCalRes;
1004 }
1005
1006 /*
1007  * vCalParamEncoder() compares the string and VCal type, parameter value.
1008  *
1009  * @param               typeObj                         Data which will be encoded
1010  * @param               type                            Name of the type
1011  */
1012 static char *__VCalParamEncode(VObject * pTypeObj, int *pEnc)
1013 {
1014         _INNER_FUNC_ENTER;
1015
1016         char *szParam = NULL;
1017         VParam *pTemp = NULL;
1018         int i;
1019         const ValueObj *pList;
1020         bool bSupported;
1021         int sNum;
1022         int shift;
1023         int len = 0;
1024         int temp_len = 0;
1025
1026         _DEBUG_VERBOSE("__VCalParamEncode() enter..\n");
1027         retvm_if(NULL == pTypeObj, NULL, "[ERROR]__VCalParamEncode:Invalid parameter(pTypeObj)!\n");
1028
1029         pTemp = pTypeObj->pParam;
1030         if (pTemp != NULL) {
1031                 if ((szParam = (char *)malloc(len += 2)) == NULL) {
1032                         _DEBUG_ERROR("__VCalParamEncode():malloc failed\n");
1033                         return NULL;
1034                 }
1035                 memcpy(szParam, "\0\0", 2);
1036         }
1037
1038         while (pTemp != NULL) {
1039                 bSupported = false;
1040
1041                 if ((szParam = (char *)realloc(szParam, (len += 15))) == NULL) {
1042
1043                         _DEBUG_ERROR("__VCalParamEncode():realloc failed\n");
1044                         return NULL;
1045                 }
1046
1047                 temp_len = g_strlcat(szParam, ";", len);
1048                 temp_len = g_strlcat(szParam, pszCalParamList[pTemp->parameter], len);
1049                 temp_len = g_strlcat(szParam, "=", len);
1050                 if (temp_len >= (len + 1)) {
1051                         _DEBUG_ERROR("szParam buffer overflow !!");
1052                         /* todo : exception handling */
1053                 }
1054
1055                 switch (pTemp->parameter) {
1056                 case VCAL_PARAM_ENCODING:
1057                         *pEnc = pTemp->paramValue;
1058                         shift = VCAL_ENCODE_PARAM_NUM;
1059                         pList = pCalEncValList;
1060                         bSupported = true;
1061                         break;
1062                 case VCAL_PARAM_CHARSET:
1063                         shift = VCAL_CHARSET_PARAM_NUM;
1064                         pList = pCalCharsetValList;
1065                         bSupported = true;
1066                         break;
1067                 case VCAL_PARAM_TYPE:
1068                         shift = VCAL_TYPE_PARAM_NUM;
1069                         pList = pCalTypeValList;
1070                         bSupported = true;
1071                         break;
1072                 case VCAL_PARAM_VALUE:
1073                         shift = VCAL_VALUE_PARAM_NUM;
1074                         pList = pCalValValList;
1075                         bSupported = true;
1076                         break;
1077                 case VCAL_PARAM_EXPECT:
1078                         shift = VCAL_EXPECT_PARAM_NUM;
1079                         pList = pCalExpectValList;
1080                         bSupported = true;
1081                         break;
1082                 case VCAL_PARAM_ROLE:
1083                         shift = VCAL_ROLE_PARAM_NUM;
1084                         pList = pCalRoleValList;
1085                         bSupported = true;
1086                         break;
1087                 case VCAL_PARAM_RSVP:
1088                         shift = VCAL_RSVP_PARAM_NUM;
1089                         pList = pCalRSVPValList;
1090                         bSupported = true;
1091                         break;
1092                 case VCAL_PARAM_STATUS:
1093                         shift = VCAL_STATUS_PARAM_NUM;
1094                         pList = pCalStatusValList;
1095                         bSupported = true;
1096                         break;
1097                 case VCAL_PARAM_CUTYPE:
1098                         shift = VCAL_CUTYPE_PARAM_NUM;
1099                         pList = pCalCutypeValList;
1100                         bSupported = true;
1101                         break;
1102                 case VCAL_PARAM_FBTYPE:
1103                         shift = VCAL_FBTYPE_PARAM_NUM;
1104                         pList = pCalFbtypeValList;
1105                         bSupported = true;
1106                         break;
1107                 case VCAL_PARAM_PARTSTAT:
1108                         shift = VCAL_PARTSTAT_PARAM_NUM;
1109                         pList = pCalPartstatValList;
1110                         bSupported = true;
1111                         break;
1112                 case VCAL_PARAM_RANGE:
1113                         shift = VCAL_RANGE_PARAM_NUM;
1114                         pList = pCalRangeValList;
1115                         bSupported = true;
1116                         break;
1117                 case VCAL_PARAM_RELATED:
1118                         shift = VCAL_RELATED_PARAM_NUM;
1119                         pList = pCalRelatedValList;
1120                         bSupported = true;
1121                         break;
1122                 case VCAL_PARAM_RELTYPE:
1123                         shift = VCAL_RELTYPE_PARAM_NUM;
1124                         pList = pCalReltypeValList;
1125                         bSupported = true;
1126                         break;
1127                 default:
1128
1129                         if ((szParam = (char *)realloc(szParam, 5)) == NULL) {
1130                                 _DEBUG_ERROR("__VCalParamEncode():realloc failed\n");
1131                                 return NULL;
1132                         }
1133                         temp_len = 0;
1134                         temp_len = g_strlcat(szParam, "NONE", 5);
1135                         if (temp_len >= 5) {
1136                                 _DEBUG_ERROR("szParam buffer overflow !!");
1137                                 /* todo : exception handling */
1138                         }
1139                         break;
1140                 }
1141
1142                 if (bSupported == true) {
1143                         for (i = 0, sNum = 0x00000001; i < shift; i++) {
1144                                 if (pTemp->paramValue & sNum) {
1145                                         if ((szParam = (char *)realloc(szParam, (len += (strlen(pList[i].szName) + 2)))) == NULL) {
1146
1147                                                 _DEBUG_ERROR("__VCalParamEncode():realloc failed\n");
1148                                                 return NULL;
1149                                         }
1150
1151                                         temp_len = 0;
1152                                         temp_len = g_strlcat(szParam, pList[i].szName, len);
1153                                         temp_len = g_strlcat(szParam, ", \0", len);
1154                                         if (temp_len >= (len + 1)) {
1155                                                 _DEBUG_ERROR("szParam buffer overflow !!");
1156                                                 /* todo : exception handling */
1157                                         }
1158                                 }
1159                                 sNum <<= 1;
1160                         }
1161                 }
1162
1163                 for (i = strlen(szParam); i > 0; i--) {
1164                         if (szParam[i] == ' ' && szParam[i - 1] == ',') {
1165                                 szParam[i - 1] = '\0';
1166                                 break;
1167                         }
1168                 }
1169
1170                 if (pTemp->pNext != NULL)
1171                         pTemp = pTemp->pNext;
1172                 else
1173                         break;
1174         }
1175
1176         _DEBUG_VERBOSE("\n ------end __VCalParamEncode ---------..\n");
1177
1178         _INNER_FUNC_EXIT;
1179
1180         return szParam;
1181 }
1182
1183 bool __cal_vcalendar_get_week_day_string(struct tm * start_time, char *s2)
1184 {
1185         _INNER_FUNC_ENTER;
1186
1187         char *date_string[7] = { "SU", "MO", "TU", "WE", "TH", "FR", "SA" };
1188
1189         struct tm temp;
1190         time_t t = timegm(start_time);
1191         gmtime_r(&t, &temp);
1192
1193         if (temp.tm_wday < 0 || temp.tm_wday > 6) {
1194                 return false;
1195         } else {
1196                 snprintf(s2, 3, "%s", date_string[temp.tm_wday]);
1197         }
1198
1199         _INNER_FUNC_EXIT;
1200
1201         return true;
1202 }
1203
1204 struct tm *__cal_vcalendar_compute_pre_time(struct tm *start_tm, struct tm *alarm_tm, const int remind_tick, const cal_sch_remind_tick_unit_t unit, struct tm *ret_tm)
1205 {
1206         _INNER_FUNC_ENTER;
1207
1208         start_tm->tm_sec = 0;
1209         alarm_tm->tm_sec = 0;
1210         //      time_t gap_time = cals_mktime(alarm_tm) - cals_mktime(start_tm);
1211         time_t timep = timegm(alarm_tm);
1212         time_t t = 0;
1213
1214         // Fix for prevent - B.
1215         switch (unit) {
1216         case CAL_SCH_TIME_UNIT_MIN:
1217                 t = timep - 60 * remind_tick;
1218                 break;
1219
1220         case CAL_SCH_TIME_UNIT_HOUR:
1221                 t = timep - 60 * 60 * remind_tick;
1222                 break;
1223
1224         case CAL_SCH_TIME_UNIT_DAY:
1225                 t = timep - 24 * 60 * 60 * remind_tick;
1226                 break;
1227         case CAL_SCH_TIME_UNIT_WEEK:
1228                 t = timep - 7 * 24 * 60 * 60 * remind_tick;
1229                 break;
1230
1231         case CAL_SCH_TIME_UNIT_MONTH:
1232                 t = timep - 30 * 24 * 60 * 60 * remind_tick;
1233                 break;
1234
1235         default:
1236                 break;
1237
1238         }
1239
1240         _INNER_FUNC_EXIT;
1241
1242         return gmtime_r(&t, ret_tm);
1243 }
1244
1245 bool __cal_vcalendar_sch_vtree_add_object(VTree * tree, const cal_sch_full_t * sch, vCalType obj_type)
1246 {
1247         _INNER_FUNC_ENTER;
1248
1249 #if 1
1250
1251         VObject *object;
1252         int str_len = 0;
1253         int buf_len = 0;
1254
1255         assert((tree != NULL) && (sch != NULL));
1256
1257         object = (VObject *) malloc(sizeof(VObject));
1258         if (object == NULL) {
1259                 vcal_free_vtree_memory(tree);
1260                 return false;
1261         }
1262
1263         memset(object, 0, sizeof(VObject));
1264
1265         switch (obj_type) {
1266         case VCAL_TYPE_CATEGORIES:
1267                 {
1268                         if (sch->cal_type == CALS_SCH_TYPE_TODO) {
1269                                 break;
1270                         }
1271
1272                         object->property = VCAL_TYPE_CATEGORIES;
1273
1274                         object->pszValue[0] = (char *)malloc(20);
1275                         if ((object->pszValue[0]) == NULL) {
1276                                 vcal_free_vtree_memory(tree);
1277                                 CAL_FREE(object);
1278
1279                                 return false;
1280                         }
1281
1282                         memset(object->pszValue[0], 0, 20);
1283
1284                         object->valueCount = 1;
1285                 }
1286                 break;
1287
1288         case VCAL_TYPE_SUMMARY:
1289                 {
1290                         if (NULL != sch->summary && strlen(sch->summary) != 0) {
1291                                 object->property = VCAL_TYPE_SUMMARY;
1292                                 str_len = strlen(sch->summary);
1293                                 //str_len = (str_len>500)?500:str_len;
1294                                 _DEBUG_INFO("-------------------__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_SUMMARY(%d) -------------", str_len);
1295                                 object->pParam = (VParam *) malloc(sizeof(VParam));
1296                                 if (object->pParam == NULL) {
1297                                         vcal_free_vtree_memory(tree);
1298                                         CAL_FREE(object);
1299
1300                                         return false;
1301                                 }
1302                                 memset(object->pParam, 0, sizeof(VParam));
1303
1304                                 object->pParam->parameter = VCAL_PARAM_CHARSET;
1305                                 object->pParam->paramValue = 0x01 << VCAL_CHARSET_PARAM_UTF_8;
1306                                 object->pParam->pNext = NULL;
1307
1308                                 object->pParam->pNext = (VParam *) malloc(sizeof(VParam));
1309                                 if (object->pParam->pNext == NULL) {
1310                                         vcal_free_vtree_memory(tree);
1311                                         CAL_FREE(object);
1312
1313                                         return false;
1314                                 }
1315                                 memset(object->pParam->pNext, 0, sizeof(VParam));
1316
1317                                 object->pParam->pNext->parameter = VCAL_PARAM_ENCODING;
1318                                 object->pParam->pNext->paramValue = 0x01 << VCAL_ENC_PARAM_BASE64;
1319
1320                                 object->pszValue[0] = (char *)malloc(str_len * 2 + 1);
1321                                 if ((object->pszValue[0]) == NULL) {
1322                                         vcal_free_vtree_memory(tree);
1323                                         CAL_FREE(object);
1324
1325                                         return false;
1326                                 }
1327
1328                                 if (NULL != sch->summary) {
1329                                         memset(object->pszValue[0], 0, str_len + 1);
1330                                         memcpy(object->pszValue[0], sch->summary, str_len);
1331                                 }
1332                                 _DEBUG_INFO("sch->summary = %s,%s\n", sch->summary, object->pszValue[0]);
1333
1334                                 object->valueCount = 1;
1335                         } else {
1336                                 CAL_FREE(object);
1337                                 _INNER_FUNC_EXIT;
1338                                 return true;
1339                         }
1340                 }
1341                 break;
1342
1343         case VCAL_TYPE_DESCRIPTION:
1344                 {
1345                         _DEBUG_INFO("---__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_DESCRIPTION/ -------------\n");
1346
1347                         if (NULL != sch->description && strlen(sch->description) != 0) {
1348                                 object->property = VCAL_TYPE_DESCRIPTION;
1349                                 str_len = strlen(sch->description);
1350                                 //str_len = (str_len>500)?500:str_len;
1351
1352                                 object->pParam = (VParam *) malloc(sizeof(VParam));
1353                                 if (object->pParam == NULL) {
1354                                         vcal_free_vtree_memory(tree);
1355                                         CAL_FREE(object);
1356
1357                                         return false;
1358                                 }
1359                                 memset(object->pParam, 0, sizeof(VParam));
1360
1361                                 object->pParam->parameter = VCAL_PARAM_CHARSET;
1362                                 object->pParam->paramValue = 0x01 << VCAL_CHARSET_PARAM_UTF_8;
1363                                 object->pParam->pNext = NULL;
1364
1365                                 object->pParam->pNext = (VParam *) malloc(sizeof(VParam));
1366                                 if (object->pParam->pNext == NULL) {
1367                                         vcal_free_vtree_memory(tree);
1368                                         CAL_FREE(object);
1369
1370                                         return false;
1371                                 }
1372                                 memset(object->pParam->pNext, 0, sizeof(VParam));
1373
1374                                 object->pParam->pNext->parameter = VCAL_PARAM_ENCODING;
1375                                 object->pParam->pNext->paramValue = 0x01 << VCAL_ENC_PARAM_BASE64;
1376
1377                                 object->pszValue[0] = (char *)malloc(str_len + 1);
1378                                 if ((object->pszValue[0]) == NULL) {
1379                                         vcal_free_vtree_memory(tree);
1380                                         CAL_FREE(object);
1381
1382                                         return false;
1383                                 }
1384
1385                                 if (sch->description != NULL) {
1386                                         memset(object->pszValue[0], 0, str_len + 1);
1387                                         memcpy(object->pszValue[0], sch->description, str_len);
1388                                 }
1389                                 object->valueCount = 1;
1390
1391                                 _DEBUG_INFO("description = %s", object->pszValue[0]);
1392
1393                         } else {
1394                                 CAL_FREE(object);
1395                                 _INNER_FUNC_EXIT;
1396                                 return true;
1397                         }
1398
1399                 }
1400                 break;
1401         case VCAL_TYPE_LOCATION:
1402                 {
1403                         _DEBUG_INFO("-------------------__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_LOCATION -------------\n");
1404
1405                         if (NULL != sch->location && strlen(sch->location) != 0) {
1406                                 object->property = VCAL_TYPE_LOCATION;
1407                                 str_len = strlen(sch->location);
1408                                 object->pParam = (VParam *) malloc(sizeof(VParam));
1409                                 if (object->pParam == NULL) {
1410                                         vcal_free_vtree_memory(tree);
1411                                         CAL_FREE(object);
1412
1413                                         return false;
1414                                 }
1415                                 memset(object->pParam, 0, sizeof(VParam));
1416
1417                                 object->pParam->parameter = VCAL_PARAM_CHARSET;
1418                                 object->pParam->paramValue = 0x01 << VCAL_CHARSET_PARAM_UTF_8;
1419                                 object->pParam->pNext = NULL;
1420
1421                                 object->pParam->pNext = (VParam *) malloc(sizeof(VParam));
1422                                 if (object->pParam->pNext == NULL) {
1423                                         vcal_free_vtree_memory(tree);
1424                                         CAL_FREE(object);
1425
1426                                         return false;
1427                                 }
1428                                 memset(object->pParam->pNext, 0, sizeof(VParam));
1429
1430                                 object->pParam->pNext->parameter = VCAL_PARAM_ENCODING;
1431                                 object->pParam->pNext->paramValue = 0x01;
1432
1433                                 object->pszValue[0] = (char *)malloc(str_len + 1);
1434                                 if ((object->pszValue[0]) == NULL) {
1435                                         vcal_free_vtree_memory(tree);
1436                                         CAL_FREE(object);
1437
1438                                         return false;
1439                                 }
1440
1441                                 if (sch->location != NULL) {
1442                                         memset(object->pszValue[0], 0, str_len + 1);
1443                                         memcpy(object->pszValue[0], sch->location, str_len);
1444                                 }
1445                                 object->valueCount = 1;
1446                         } else {
1447                                 CAL_FREE(object);
1448                                 _INNER_FUNC_EXIT;
1449                                 return true;
1450                         }
1451
1452                 }
1453                 break;
1454         case VCAL_TYPE_DTSTART:
1455                 {
1456                         _DEBUG_INFO("-------------------__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_DTSTART -------------\n");
1457
1458                         object->property = VCAL_TYPE_DTSTART;
1459
1460                         object->pszValue[0] = (char *)malloc(VCALENDAR_TIME_STR_LEN + 1);
1461                         if ((object->pszValue[0]) == NULL) {
1462                                 vcal_free_vtree_memory(tree);
1463                                 CAL_FREE(object);
1464
1465                                 return false;
1466                         }
1467
1468                         cal_vcalendar_convert_tm_to_vdata_str(&sch->start_date_time, object->pszValue[0]);
1469
1470                         object->valueCount = 1;
1471                 }
1472                 break;
1473
1474         case VCAL_TYPE_DTEND:
1475                 {
1476                         _DEBUG_INFO("-------------------__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_DTEND -------------\n");
1477
1478                         if (sch->cal_type == CALS_SCH_TYPE_TODO) {
1479                                 break;
1480                         }
1481
1482                         object->property = VCAL_TYPE_DTEND;
1483
1484                         object->pszValue[0] = (char *)malloc(VCALENDAR_TIME_STR_LEN + 1);
1485                         if ((object->pszValue[0]) == NULL) {
1486                                 vcal_free_vtree_memory(tree);
1487                                 CAL_FREE(object);
1488
1489                                 return false;
1490                         }
1491
1492                         cal_vcalendar_convert_tm_to_vdata_str(&sch->end_date_time, object->pszValue[0]);
1493
1494                         object->valueCount = 1;
1495                 }
1496                 break;
1497
1498                 // in Calendar sch data structure, there is no due data field
1499                 // end_date_time is assigned to due date
1500         case VCAL_TYPE_DUE:
1501                 {
1502                         _DEBUG_INFO("-------------------__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_DUE -------------\n");
1503
1504                         if (sch->cal_type != CALS_SCH_TYPE_TODO) {
1505                                 break;
1506                         }
1507
1508                         object->property = VCAL_TYPE_DUE;
1509
1510                         object->pszValue[0] = (char *)malloc(VCALENDAR_TIME_STR_LEN + 1);
1511                         if ((object->pszValue[0]) == NULL) {
1512                                 vcal_free_vtree_memory(tree);
1513                                 CAL_FREE(object);
1514
1515                                 return false;
1516                         }
1517                         cal_vcalendar_convert_tm_to_vdata_str(&sch->end_date_time, object->pszValue[0]);
1518
1519                         object->valueCount = 1;
1520                 }
1521                 break;
1522
1523         case VCAL_TYPE_LAST_MODIFIED:
1524                 {
1525                         _DEBUG_INFO("-------------------__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_LAST_MODIFIED -------------\n");
1526
1527                         object->property = obj_type;
1528                         object->pszValue[0] = (char *)malloc(VCALENDAR_TIME_STR_LEN + 1);
1529                         if ((object->pszValue[0]) == NULL) {
1530                                 vcal_free_vtree_memory(tree);
1531                                 CAL_FREE(object);
1532
1533                                 return false;
1534                         }
1535                         // get current time
1536                         struct tm now;
1537
1538                         now.tm_year = 105;
1539                         now.tm_mon = 2;
1540                         now.tm_mday = 4;
1541                         now.tm_hour = 10;
1542                         now.tm_min = 12;
1543                         now.tm_sec = 34;
1544
1545                         cal_vcalendar_convert_tm_to_vdata_str(&now, object->pszValue[0]);
1546
1547                         object->valueCount = 1;
1548                 }
1549                 break;
1550
1551         case VCAL_TYPE_AALARM:
1552                 {
1553                         _DEBUG_INFO("\n-------------------__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_AALARM -------------\n");
1554
1555                         if (sch->alarm_list != NULL) {
1556                                 object->property = VCAL_TYPE_AALARM;
1557                                 cal_alarm_info_t *tmp_alarm = ((cal_value *) sch->alarm_list->data)->user_data;
1558
1559                                 object->pszValue[0] = (char *)malloc(VCALENDAR_TIME_STR_LEN + 1);
1560                                 if ((object->pszValue[0]) == NULL) {
1561                                         vcal_free_vtree_memory(tree);
1562                                         if (object != NULL) {
1563                                                 free(object);
1564                                                 object = NULL;
1565                                         }
1566                                         return false;
1567                                 }
1568                                 struct tm ttm;
1569
1570                                 // TODO: handle alarms(this is one alarm)
1571                                 struct tm *tm = __cal_vcalendar_compute_pre_time((struct tm *)&sch->start_date_time,
1572                                                                                  &tmp_alarm->alarm_time, tmp_alarm->remind_tick, tmp_alarm->remind_tick_unit, &ttm);
1573                                 cal_vcalendar_convert_tm_to_vdata_str(tm, object->pszValue[0]);
1574
1575                                 object->valueCount = 1;
1576                         } else {
1577                                 CAL_FREE(object);
1578                                 _INNER_FUNC_EXIT;
1579                                 return true;
1580                         }
1581                 }
1582                 break;
1583
1584         case VCAL_TYPE_RRULE:
1585                 {
1586                         _DEBUG_INFO("\n-------------------__cal_vcalendar_sch_vtree_add_object /VCAL_TYPE_RRULE -------------\n");
1587
1588                         if (sch->repeat_term != CAL_REPEAT_NONE) {
1589                                 _DEBUG_INFO(" ------------------------ begine to create RRULE-------------------------- ");
1590
1591                                 object->property = VCAL_TYPE_RRULE;
1592
1593                                 char repeat_end_date[VCALENDAR_TIME_STR_LEN + 1] = { 0 };
1594                                 char week_day_string[VCALENDAR_TIME_STR_LEN + 1] = { 0 };
1595                                 cal_vcalendar_convert_tm_to_vdata_str(&sch->repeat_end_date, repeat_end_date);
1596
1597                                 _DEBUG_INFO(" repeat_end_date = %s ", repeat_end_date);
1598
1599                                 char str[100];
1600                                 memset(str, 0, 100);
1601
1602                                 switch (sch->repeat_term) {
1603                                 case CAL_REPEAT_EVERY_DAY:
1604                                         snprintf(str, sizeof(str), "D%d %s", sch->repeat_interval, repeat_end_date);
1605                                         break;
1606
1607                                 case CAL_REPEAT_EVERY_WEEK:
1608                                 case CAL_REPEAT_EVERY_WEEKDAYS:
1609                                         __cal_vcalendar_get_week_day_string((struct tm *)&(sch->start_date_time), week_day_string);
1610                                         snprintf(str, sizeof(str), "W%d %s %s", sch->repeat_interval, week_day_string, repeat_end_date);
1611                                         break;
1612
1613                                 case CAL_REPEAT_EVERY_MONTH:
1614                                 case CAL_REPEAT_EVERY_MONTH_DAY:
1615                                         snprintf(str, sizeof(str), "MD%d %s", sch->repeat_interval, repeat_end_date);
1616                                         break;
1617
1618                                 case CAL_REPEAT_EVERY_YEAR:
1619                                 case CAL_REPEAT_EVERY_YEAR_DAY:
1620                                         snprintf(str, sizeof(str), "YM%d %s", sch->repeat_interval, repeat_end_date);
1621                                         break;
1622
1623                                 default:
1624                                         break;
1625                                 }
1626                                 object->valueCount = 1;
1627
1628                                 object->pszValue[0] = (char *)malloc(strlen(str) + 1);
1629                                 if ((object->pszValue[0]) == NULL) {
1630                                         vcal_free_vtree_memory(tree);
1631                                         CAL_FREE(object);
1632
1633                                         return false;
1634                                 }
1635                                 memset(object->pszValue[0], 0, (strlen(str) + 1));
1636                                 buf_len = 0;
1637                                 buf_len = g_strlcpy(object->pszValue[0], str, (strlen(str) + 1));
1638                                 if (buf_len >= (strlen(str) + 1)) {
1639                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1640                                         vcal_free_vtree_memory(tree);
1641                                         CAL_FREE(object);
1642
1643                                         return false;
1644                                 }
1645
1646                                 _DEBUG_INFO("RRULE = %s", object->pszValue[0]);
1647
1648                         } else {
1649                                 CAL_FREE(object);
1650                                 _INNER_FUNC_EXIT;
1651                                 return true;
1652                         }
1653                 }
1654                 break;
1655
1656         case VCAL_TYPE_PRIORITY:
1657                 {
1658                         _DEBUG_INFO("\n-------------------__cal_vcalendar_todo_vtree_add_object /VCAL_TYPE_PRIORITY -------------\n");
1659
1660                         object->property = VCAL_TYPE_PRIORITY;
1661
1662                         char str[3];
1663                         memset(str, 0, 3);
1664
1665                         snprintf(str, sizeof(str), "%d", sch->priority);
1666
1667                         object->pszValue[0] = (char *)malloc(3);
1668                         if ((object->pszValue[0]) == NULL) {
1669                                 vcal_free_vtree_memory(tree);
1670                                 CAL_FREE(object);
1671
1672                                 return false;
1673                         }
1674
1675                         memset(object->pszValue[0], 0, 3);
1676                         buf_len = 0;
1677                         buf_len = g_strlcpy(object->pszValue[0], str, 3);
1678                         if (buf_len >= 3) {
1679                                 _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1680                                 vcal_free_vtree_memory(tree);
1681                                 CAL_FREE(object);
1682
1683                                 return false;
1684                         }
1685
1686                         object->valueCount = 1;
1687                 }
1688                 break;
1689
1690         case VCAL_TYPE_STATUS:
1691                 {
1692                         _DEBUG_INFO("\n-------------------__cal_vcalendar_todo_vtree_add_object /VCAL_TYPE_STATUS -------------\n");
1693
1694                         if (sch->cal_type != CALS_SCH_TYPE_TODO) {
1695                                 break;
1696                         }
1697
1698                         object->property = VCAL_TYPE_STATUS;
1699
1700                         object->pszValue[0] = (char *)malloc(20);
1701                         if ((object->pszValue[0]) == NULL) {
1702                                 vcal_free_vtree_memory(tree);
1703                                 CAL_FREE(object);
1704
1705                                 return false;
1706                         }
1707
1708                         memset(object->pszValue[0], 0, 20);
1709
1710                         switch (sch->task_status) {
1711                         case CALS_EVENT_STATUS_TENTATIVE:
1712                                 buf_len = 0;
1713                                 buf_len = g_strlcpy(object->pszValue[0], "TENTATIVE", 20);
1714                                 if (buf_len >= 20) {
1715                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1716                                         vcal_free_vtree_memory(tree);
1717                                         CAL_FREE(object);
1718
1719                                         return false;
1720                                 }
1721                                 break;
1722                         case CALS_EVENT_STATUS_CONFIRMED:
1723                                 buf_len = 0;
1724                                 buf_len = g_strlcpy(object->pszValue[0], "CONFIRMED", 20);
1725                                 if (buf_len >= 20) {
1726                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1727                                         vcal_free_vtree_memory(tree);
1728                                         CAL_FREE(object);
1729
1730                                         return false;
1731                                 }
1732                                 break;
1733                         case CALS_EVENT_STATUS_CANCELLED:
1734                                 buf_len = 0;
1735                                 buf_len = g_strlcpy(object->pszValue[0], "CANCELLED", 20);
1736                                 if (buf_len >= 20) {
1737                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1738                                         vcal_free_vtree_memory(tree);
1739                                         CAL_FREE(object);
1740
1741                                         return false;
1742                                 }
1743                                 break;
1744                         case CALS_TODO_STATUS_NEEDS_ACTION:
1745                                 buf_len = 0;
1746                                 buf_len = g_strlcpy(object->pszValue[0], "NEEDS-ACTION", 20);
1747                                 if (buf_len >= 20) {
1748                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1749                                         vcal_free_vtree_memory(tree);
1750                                         CAL_FREE(object);
1751
1752                                         return false;
1753                                 }
1754                                 break;
1755                         case CALS_TODO_STATUS_COMPLETED:
1756                                 buf_len = 0;
1757                                 buf_len = g_strlcpy(object->pszValue[0], "COMPLETED", 20);
1758                                 if (buf_len >= 20) {
1759                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1760                                         vcal_free_vtree_memory(tree);
1761                                         CAL_FREE(object);
1762
1763                                         return false;
1764                                 }
1765                                 break;
1766                         case CALS_TODO_STATUS_IN_PROCESS:
1767                                 buf_len = 0;
1768                                 buf_len = g_strlcpy(object->pszValue[0], "IN-PROCESS", 20);
1769                                 if (buf_len >= 20) {
1770                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1771                                         vcal_free_vtree_memory(tree);
1772                                         CAL_FREE(object);
1773
1774                                         return false;
1775                                 }
1776                                 break;
1777                         case CALS_TODO_STATUS_CANCELLED:
1778                                 buf_len = 0;
1779                                 buf_len = g_strlcpy(object->pszValue[0], "CANCELLED", 20);
1780                                 if (buf_len >= 20) {
1781                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1782                                         vcal_free_vtree_memory(tree);
1783                                         CAL_FREE(object);
1784
1785                                         return false;
1786                                 }
1787                                 break;
1788                         default:
1789                                 buf_len = 0;
1790                                 buf_len = g_strlcpy(object->pszValue[0], "NEEDS-ACTION", 20);
1791                                 if (buf_len >= 20) {
1792                                         _DEBUG_ERROR("object->pszValue[0] buffer overflow !!");
1793                                         vcal_free_vtree_memory(tree);
1794                                         CAL_FREE(object);
1795
1796                                         return false;
1797                                 }
1798                                 break;
1799                         }
1800
1801                         object->valueCount = 1;
1802                         break;
1803                 }
1804
1805         default:
1806                 break;
1807
1808         }
1809
1810         // if current is the header of the list
1811         if (tree->pTop == NULL) {
1812                 _DEBUG_INFO("\n--------tree->pTop = object--------------\n");
1813                 tree->pTop = object;
1814         } else {
1815                 tree->pCur->pSibling = object;
1816         }
1817
1818         // the object is the current object
1819         tree->pCur = object;
1820
1821 #endif
1822         _INNER_FUNC_EXIT;
1823         return true;
1824 }
1825
1826 bool _cal_convert_sch_to_vcalendar(const cal_sch_full_t * sch_array, const int sch_count, char **vcal, cal_vCal_ver_t version)
1827 {
1828         _INNER_FUNC_ENTER;
1829
1830 #if 1
1831         int i;
1832         int j;
1833
1834         VTree *cal_tree = NULL;
1835         VTree *tmp_tree = NULL;
1836
1837         vCalType obj_type[] = {
1838                 VCAL_TYPE_SUMMARY,
1839                 VCAL_TYPE_DESCRIPTION,
1840                 VCAL_TYPE_LOCATION,
1841                 VCAL_TYPE_DTSTART,
1842                 VCAL_TYPE_DTEND,
1843                 VCAL_TYPE_LAST_MODIFIED,
1844                 VCAL_TYPE_ATTACH,
1845                 VCAL_TYPE_CATEGORIES,
1846                 VCAL_TYPE_PRIORITY,
1847                 VCAL_TYPE_STATUS,
1848                 VCAL_TYPE_AALARM,
1849                 VCAL_TYPE_RRULE,
1850                 0
1851         };
1852
1853         assert((sch_array != NULL) && (vcal != NULL));
1854
1855         cal_tree = (VTree *) malloc(sizeof(VTree));
1856         if (cal_tree == NULL)
1857                 return false;
1858
1859         memset(cal_tree, 0, sizeof(VTree));
1860
1861         cal_tree->treeType = VCALENDAR;
1862         cal_tree->pTop = NULL;
1863         cal_tree->pCur = NULL;
1864         cal_tree->pNext = NULL;
1865
1866         VTree *tree = cal_tree;
1867
1868         for (i = 0; i < sch_count; i++) {
1869                 tmp_tree = (VTree *) malloc(sizeof(VTree));
1870                 if (tmp_tree == NULL) {
1871                         vcal_free_vtree_memory(cal_tree);
1872                         return false;
1873                 }
1874
1875                 memset(tmp_tree, 0, sizeof(VTree));
1876
1877                 if ((sch_array + i)->cal_type == CALS_SCH_TYPE_TODO) {
1878                         tmp_tree->treeType = VTODO;
1879                         obj_type[4] = VCAL_TYPE_DUE;
1880                 } else {
1881                         tmp_tree->treeType = VEVENT;
1882                 }
1883
1884                 tmp_tree->pTop = NULL;
1885                 tmp_tree->pCur = NULL;
1886                 tmp_tree->pNext = NULL;
1887
1888                 j = 0;
1889                 while (obj_type[j]) {
1890                         if (!__cal_vcalendar_sch_vtree_add_object(tmp_tree, sch_array + i, obj_type[j])) {
1891                                 vcal_free_vtree_memory(cal_tree);
1892                                 return false;
1893                         }
1894                         j++;
1895                 }
1896
1897                 tree->pNext = tmp_tree;
1898                 tree = tmp_tree;
1899
1900         }
1901
1902         tree->pNext = NULL;
1903
1904         *vcal = vcal_encode(cal_tree);
1905         if (*vcal == NULL) {
1906                 _DEBUG_ERROR("vcal_encode Failed");
1907                 vcal_free_vtree_memory(cal_tree);
1908                 return false;
1909         }
1910
1911         vcal_free_vtree_memory(cal_tree);
1912         _DEBUG_TRACE("\n---------------------------exit _cal_convert_sch_to_vcalendar--------- -------------\n");
1913 #endif
1914         _INNER_FUNC_EXIT;
1915         return true;
1916 }