} else {
        /*
          <Put>
            <CmdID>2</CmdID>
            <Meta><Type xmlns='syncml:metinf'>application/vnd.syncml-devinf+xml</Type></Meta>
            <Item>
              <Source><LocURI>./devinf11</LocURI></Source>
              <Data>
                <DevInf xmlns='syncml:devinf'>...</DevInf>
              </Data>
            </Item>
          </Put>
        */

        res = new Put(&commandID,
                      FALSE,
                      NULL,
                      NULL,
                      &meta,
                      &items);
    }
    safeDelete(&msgRefStr);
    return res;
}


Alert* SyncMLBuilder::prepareAlert(SyncSource& s, int code) {

    ++cmdID;

    char* cmdid = itow(cmdID);
    CmdID* commandID     = new CmdID(cmdid);
    delete [] cmdid; cmdid = NULL;
    Target* tar          = new Target(s.getConfig().getURI());
    Source* sou          = new Source(_wcc(s.getName()));
    Item* item           = new Item(tar, sou, NULL, NULL, FALSE);

    ArrayList* list      = new ArrayList();
    list->add(*item);
    Alert* alert         = new Alert(commandID, false, NULL, code, list);

    deleteTarget(&tar);
    deleteSource(&sou);
    deleteItem(&item);
    deleteCmdID(&commandID);
    deleteArrayList(&list);

    return alert;
}

Alert* SyncMLBuilder::prepareInitAlert(SyncSource& s, unsigned long maxObjSize) {

    ++cmdID;

    char* cmdid = itow(cmdID);
    CmdID* commandID     = new CmdID(cmdid);
    delete [] cmdid; cmdid = NULL;
    int data             = s.getPreferredSyncMode();
    Target* tar          = new Target(s.getConfig().getURI());
    Source* sou          = new Source(_wcc(s.getName()));

    //
    // Read the clause filter from the source and translate
    // it into a Filter. This must be assigned to the Target
    //
    SourceFilter* sourceFilter = s.getFilter();
    if (sourceFilter) {
        Filter* filter = ClauseUtil::toFilter(*sourceFilter);
        tar->setFilter(filter);
        delete filter; filter = NULL;
    }


    Anchor*    anchor    = new Anchor(s.getLastAnchor(), s.getNextAnchor());
    MetInf* metInf       = new MetInf(NULL, NULL, NULL, NULL,
                            anchor, NULL, NULL, NULL, maxObjSize > 0 ? maxObjSize : NULL,  NULL, NULL);
    Meta* meta           = new Meta();
    meta->setMetInf(metInf);
    Item* item           = new Item(tar, sou, meta, NULL, FALSE);

    ArrayList* list      = new ArrayList();
    list->add(*item);
    Alert* alert         = new Alert(commandID, false, NULL, data, list);

    deleteCmdID(&commandID);
    deleteTarget(&tar);
    if(sou)
        delete sou;
    deleteAnchor(&anchor);
    deleteMetInf(&metInf);
    deleteMeta(&meta);
    deleteItem(&item);
    deleteArrayList(&list);

    return alert;
}

Alert* SyncMLBuilder::prepareAddrChangeAlert(SyncSource& s) {

    SyncItem *syncItem;
    ArrayList list;
    for(syncItem = s.getFirstItem(); syncItem; syncItem = s.getNextItem()) {
        int size = syncItem->getDataSize();

        if( syncItem && size ) {  // only valid items

            char* syncData = new char[size + 1];
            memset(syncData, 0, size + 1);
            memcpy (syncData, (char*)syncItem->getData(), size);

            ComplexData addr( syncData );
            Target target( "" );
            Source source(_wcc(syncItem->getKey()));
            // Build Item
            Item item(&target, &source, NULL, &addr, FALSE);
            // Add it to the list
            list.add(item);

            delete [] syncData;
        }
    }
    /*
    for(syncItem = s.getFirstItem(); syncItem; syncItem = s.getNextItem()) {
        int size = syncItem->getDataSize()/sizeof(char);
        char *syncData = (char *)syncItem->getData();

        if( syncItem && size ) {  // only valid items

            // Add the syncItem data as zero terminated string
            StringBuffer itemData(syncData, size);
            ComplexData addr( itemData.c_str() );
            Target target( "" );
            Source source(syncItem->getKey());
            // Build Item
            Item item(&target, &source, NULL, &addr, FALSE);
            // Add it to the list
            list.add(item);
        }
    }
    */
    // If no valid items were provided by the syncsource
    // return null alert
    if(list.isEmpty())
        return NULL;

    // Ok, prepare the message
    cmdID++;

    char* cmdid = itow(cmdID);
    CmdID commandID(cmdid);
    delete [] cmdid; cmdid = NULL;
    int data = s.getPreferredSyncMode();

    Alert* alert = new Alert(&commandID, false, NULL, data, &list);

    return alert;
}

SyncHdr* SyncMLBuilder::prepareSyncHdr(Cred* cred, unsigned long maxMsgSize, unsigned long maxObjSize) {

    ++msgID;

    VerDTD*    verDTD    = new VerDTD("1.1");
    VerProto*  verProto  = new VerProto("SyncML/1.1");
    char* sid = ltow(sessionID);
    SessionID* sessID    = new SessionID(sid);
    delete [] sid;   sid = NULL;
    char*   messageID = itow(msgID);
    Target*    tar       = new Target(target);
    Source*    sou       = NULL;
    Meta* meta           = NULL;

    if (cred && strcmp(cred->getType(), AUTH_TYPE_MD5) == 0)
        sou = new Source(device, cred->getUsername());
    else
        sou = new Source(device);


    if (maxMsgSize > 0 || maxObjSize > 0) {
        MetInf* metInf = new MetInf(NULL, NULL, NULL, NULL,
                                    NULL, NULL, NULL, maxMsgSize,
                                    maxObjSize, NULL, NULL);
        meta = new Meta();
        meta->setMetInf(metInf);
        deleteMetInf(&metInf);
    }
    SyncHdr* syncHdr = new SyncHdr(verDTD, verProto, sessID, messageID,
                                   tar, sou, NULL, false, cred, meta); //respUri e Meta are null

    deleteVerDTD(&verDTD);
    deleteVerProto(&verProto);
    deleteSessionID(&sessID);
    deleteSource(&sou);
    deleteTarget(&tar);
    safeDel(&messageID);

    return syncHdr;
}

SyncML* SyncMLBuilder::prepareInitObject(Cred* cred, ArrayList* alerts, ArrayList* commands, unsigned long maxMsgSize, unsigned long maxObjSize) {

    SyncHdr* syncHdr     = prepareSyncHdr(cred, maxMsgSize, maxObjSize);
    SyncML*  syncml      = NULL;
    ArrayList* list      = NULL;
    SyncBody* syncBody   = NULL;

    // Clone commands, even if empty. The result is a list anyway.
    list = commands->clone();

    if (alerts && alerts->size() > 0) {
        for (int k = 0; k < alerts->size(); k++)
            list->add(*(Alert*)alerts->get(k));
    }

    syncBody   = new SyncBody(list, TRUE);
    deleteArrayList(&list);
    syncml       = new SyncML(syncHdr, syncBody);

    deleteSyncHdr(&syncHdr);
    deleteSyncBody(&syncBody);

    return syncml;
}

char* SyncMLBuilder::prepareMsg(SyncML* syncml) {
    StringBuffer *s = Formatter::getSyncML(syncml);
    char* str = stringdup(s->c_str());
    delete s;
    return str;
}


SyncML* SyncMLBuilder::prepareSyncML(ArrayList* commands, BOOL final) {

    SyncHdr* syncHdr = prepareSyncHdr(NULL);
    SyncBody* syncBody   = new SyncBody(commands, final);
    SyncML* syncml = new SyncML(syncHdr, syncBody);
    deleteSyncHdr(&syncHdr);
    deleteSyncBody(&syncBody);

    return syncml;
}

ComplexData* SyncMLBuilder::getComplexData(SyncItem* syncItem,
                                           long &syncItemOffset, long maxBytes, long &sentBytes) {

        char* t   = NULL;
        ComplexData* data = NULL;

        sentBytes = syncItem->getDataSize() - syncItemOffset;
        if (sentBytes && sentBytes > maxBytes) {
            sentBytes = maxBytes;
            if (sentBytes < 1) {
                // ensure that at least one byte is sent even if maxBytes is 0 or negative,
                // otherwise no progress is made
                sentBytes = 1;
            }
        }

        t = new char[sentBytes + 1];
        memset(t, 0, sentBytes + 1);
        memcpy(t, (char *)syncItem->getData() + syncItemOffset, sentBytes);
        syncItemOffset += sentBytes;

        data = new ComplexData(t);

        if (t)
            {delete [] t; t = NULL; }

        return data;
}


ArrayList* SyncMLBuilder::prepareItem(SyncItem* syncItem,
                                      long &syncItemOffset, long maxBytes, long &sentBytes,
                                      const char* type, char* COMMAND) {
    ArrayList* list = new ArrayList();

    Source* sou = new Source(_wcc(syncItem->getKey()));
    ComplexData* data = NULL;
    Meta m;
    BOOL hasMoreData = FALSE;
    BOOL isFirstChunk = !syncItemOffset;
    if (strcmp(DELETE_COMMAND_NAME, COMMAND) != 0) {
        if (syncItem->getDataEncoding()) {
            m.setFormat(syncItem->getDataEncoding());
        }
        data = getComplexData(syncItem, syncItemOffset, maxBytes, sentBytes);
        hasMoreData = syncItemOffset < syncItem->getDataSize();
        if (isFirstChunk && hasMoreData) {
            // must send size, but only in first chunk of this item
            m.setSize(syncItem->getDataSize());
        }
    } else {
        // skip all item data for deleted items
        syncItemOffset = syncItem->getDataSize();
        sentBytes = 0;
    }

    char *tparent = toMultibyte(syncItem->getTargetParent());
    char *sparent = toMultibyte(syncItem->getSourceParent());

    Item* item = new Item(NULL, sou, tparent, sparent, &m, data, hasMoreData);
    list->add(*item);

    delete [] tparent;
    delete [] sparent;

    deleteSource(&sou);
    deleteComplexData(&data);
    deleteItem(&item);

    return list;
}

long SyncMLBuilder::addItem(ModificationCommand* &modificationCommand,
                            long &syncItemOffset, long maxBytes,
                            char* COMMAND, SyncItem* syncItem, const char* defaultType) {
    if (syncItem == NULL) {
         return 0;
    }

    // The item should determine its type itself.
    // Only fallback to the default type configured for its
    // source if (broken?) SyncSources do not set a in their
    // items.
    const char *type = _wcc(syncItem->getDataType());
    if (!type || !type[0]) {
        type = defaultType;
    }

    if (!modificationCommand) {
        ++cmdID;
        char* cmdid = itow(cmdID);
        CmdID commandID(cmdid);
        delete [] cmdid; cmdid = NULL;
        ModificationCommand* ret = NULL;
        MetInf metInf(NULL, (char*)type, NULL, NULL,
                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
        Meta meta;

        meta.setMetInf(&metInf);

        if (strcmp(ADD_COMMAND_NAME, COMMAND) == 0)
            modificationCommand = new Add(&commandID, FALSE, NULL, &meta, NULL);
        else if (strcmp(REPLACE_COMMAND_NAME, COMMAND) == 0){
            modificationCommand = new Replace(&commandID, FALSE, NULL, &meta, NULL);
        } else if (strcmp(DELETE_COMMAND_NAME, COMMAND) == 0) {
            modificationCommand = new Delete(&commandID, FALSE, FALSE, FALSE, NULL, &meta, NULL);
        }
    }

    ArrayList* list = modificationCommand->getItems();
    /* size is effectively undefined for deleted items, don't check it */
    assert(!strcmp(DELETE_COMMAND_NAME, COMMAND) || syncItemOffset >= 0);
    assert(!strcmp(DELETE_COMMAND_NAME, COMMAND) || syncItemOffset <= syncItem->getDataSize());
    long sentBytes = 0;
    ArrayList* tmpList = prepareItem(syncItem, syncItemOffset, maxBytes, sentBytes, type, COMMAND);
    assert(!strcmp(DELETE_COMMAND_NAME, COMMAND) || syncItemOffset >= 0);
    assert(!strcmp(DELETE_COMMAND_NAME, COMMAND) || syncItemOffset <= syncItem->getDataSize());
    list->add(tmpList);
    deleteArrayList(&tmpList);

    return sentBytes;
}

Sync* SyncMLBuilder::prepareSyncCommand(SyncSource& source) {

    ++cmdID;

    char* cmdid = itow(cmdID);
    CmdID* commandID     = new CmdID(cmdid);
    delete [] cmdid; cmdid = NULL;
    Target* tar          = new Target(source.getConfig().getURI());
    Source* sou          = new Source(_wcc(source.getName()));
    ArrayList* list      = new ArrayList();
    Sync* sync           = NULL;

    sync = new Sync(commandID, FALSE, NULL, tar, sou, NULL, 0,  list);

    deleteCmdID(&commandID);
    deleteTarget(&tar);
    deleteSource(&sou);
    deleteArrayList(&list);

    return sync;

}


Map* SyncMLBuilder::prepareMapCommand(SyncSource& s) {
    /*
    CmdID* cmdID,
    Target* target,
    Source* source,
    Cred* cred,
    Meta* meta,
    ArrayList* mapItems);
    */
    ++cmdID;
    char* cmdid = itow(cmdID);
    CmdID* commandID     = new CmdID(cmdid);
    delete [] cmdid; cmdid = NULL;
    Target* tar          = new Target(s.getConfig().getURI());
    Source* sou          = new Source(_wcc(s.getName()));
    ArrayList* mapItems  = new ArrayList();
    Map* map = new Map(commandID, tar, sou, NULL, NULL, mapItems);

    deleteCmdID(&commandID);
    deleteTarget(&tar);
    deleteSource(&sou);
    deleteArrayList(&mapItems);

    return map;

}

MapItem* SyncMLBuilder::prepareMapItem(SyncMap* syncMap) {

    Target* tar          = new Target(syncMap->getGUID());
    Source* sou          = new Source(syncMap->getLUID());
    MapItem* m = new MapItem(tar, sou);
    deleteTarget(&tar);
    deleteSource(&sou);

    return m;
}

void SyncMLBuilder::addMapItem(Map* map, MapItem* mapItem){
    if (mapItem == NULL || map == NULL)
        return;
    ArrayList* list = map->getMapItems();
    list->add(*mapItem);

}

void SyncMLBuilder::resetMessageID() {
    msgID = 0;
}