calendarengines/caldav/src/caldavengine.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Tue, 14 Sep 2010 21:17:03 +0300
branchRCL_3
changeset 31 97232defd20e
permissions -rw-r--r--
Revision: 201033 Kit: 201035

/*
 * Copyright (c) 2010 Sun Microsystems, Inc. and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributor:
 * Maximilian Odendahl
 *
 * Contributors:
 * 
 * Description:  main Caldav class, all magic happens here 
 *				one engine for each configured Caldav calendar
 */
#include "caldavengine.h"
#include <f32file.h> 
#include <S32FILE.H>
#include <S32MEM.H> 
#include <avkon.rsg>
#include <UTF.H>
#include <agnexportobserver.h>
#include <calsession.h>
#include <caliterator.h>
#include <calentry.h>
#include <calentryview.h>
#include <caltime.h>
#include <calalarm.h>
#include <calcategory.h>
#include <caluser.h>
#include <calrrule.h>
#include <calinstance.h>
#include <calinstanceview.h>
#include <caleninterimutils2.h> 
#include <calenexporter.h>
#include <calenimporter.h>
#include <calcalendarinfo.h>
#include "calenglobaldata.h"
#include <xmlengdocument.h>
#include <xmlengnode.h>
#include <xmlengelement.h>
#include <xmlengnodelist.h>
#include <xmlengtext.h>
#include "httpclient.h"
#include <e32math.h>	// divmod
#define MULTIGETSPLIT 			100
#define ARRAYEXPAND				4
#define	URLMAX					500
#define EXPANDSIZE_SMALL		512
#define EXPANDSIZE_BIG			1024
_LIT(KFormatString,"\"%F%Y%M%DT000000Z\"");

/**
 * SyncTickL
 * timer for basic sync interval
 */
TInt SyncTickL(TAny *aObject)
	{
	CCalDavEngine* engine = ((CCalDavEngine*) aObject);
	CPeriodic* timer = engine->Timer();
	if (engine && timer)
		{
		timer->Cancel();
		TRAP_IGNORE(engine->SyncL());
		TInt ticktime = engine->SyncInterval().Int() == 0 ? 1
				: engine->SyncInterval().Int();
		const TUint64 tickInterval = 1000000 * 60 * ticktime;
		timer->Start(tickInterval, tickInterval, TCallBack(SyncTickL, engine));
		}
	return 0;
	}

#ifdef _DEBUG
void ExportToFileNameL(const TDesC8& aDes, const TDesC &aFilename)
	{
	RFs fsSession;
	User::LeaveIfError(fsSession.Connect());
	CleanupClosePushL(fsSession);

	TInt err = fsSession.MkDirAll(aFilename);

	RFile file;
	User::LeaveIfError(file.Replace(fsSession, aFilename, EFileWrite));
	CleanupClosePushL(file);

	RFileWriteStream writeStream2;
	writeStream2.Attach(file);
	CleanupClosePushL(writeStream2);

	writeStream2 << aDes;
	writeStream2.CommitL();
	CleanupStack::PopAndDestroy(&writeStream2);
	CleanupStack::PopAndDestroy(&file);
	CleanupStack::PopAndDestroy(&fsSession);
	}

void ExportToFileL(CCalEntry* aEntry, CCalenExporter *iCalExporter)
	{
	if (aEntry)
		{
		_LIT(KFileName, "C:\\logs\\caldav\\testing_export.txt");

		RFs fsSession;
		User::LeaveIfError(fsSession.Connect());
		CleanupClosePushL(fsSession);

		TInt err = fsSession.MkDirAll(KFileName);

		RFile file;
		User::LeaveIfError(file.Replace(fsSession, KFileName, EFileWrite));
		CleanupClosePushL(file);

		RFileWriteStream writeStream2;
		writeStream2.Attach(file);
		CleanupClosePushL(writeStream2);

		iCalExporter->ExportICalL(*aEntry, writeStream2);
		writeStream2.CommitL();
		CleanupStack::PopAndDestroy(&writeStream2);
		CleanupStack::PopAndDestroy(&file);
		CleanupStack::PopAndDestroy(&fsSession);
		}
	}
#endif

/**
 * SearchL
 * search inside xml tree for a specific node
 */
void SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,
		const TDesC8 &aNamespace, TXmlEngNode & aReturnNode)
	{
	RXmlEngNodeList<TXmlEngNode> List;
	aTopNode.GetChildNodes(List);
	while (List.HasNext() && aReturnNode.IsNull())
		{
		TXmlEngNode Node = List.Next();
		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();
		if (Type == TXmlEngNode::EElement)
			{
			//todo: compare namespace ?
			if (Node.Name() == aName)
				{
				aReturnNode = Node.CopyL();
				return;
				}
			else
				{
				SearchL(Node, aName, aNamespace, aReturnNode);
				if (!aReturnNode.IsNull())
					return;
				}
			}
		}
	}

/**
 * SearchL
 * search inside xml tree for a specific node
 */
void SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,
		const TDesC8 &aNamespace, RBuf8 &aBuf)
	{
	RXmlEngNodeList<TXmlEngNode> List;
	aTopNode.GetChildNodes(List);
	while (List.HasNext())
		{
		TXmlEngNode Node = List.Next();
		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();
		if (Type == TXmlEngNode::EElement)
			{
			//todo: compare namespace ?
			if (Node.Name() == aName)
				{
				if (Node.IsSimpleTextContents())
					aBuf.Create(Node.Value());
				else
					Node.WholeTextContentsCopyL(aBuf);
				return;
				}
			else
				{
				SearchL(Node, aName, aNamespace, aBuf);
				if (aBuf.Length())
					return;
				}
			}
		}
	}

/**
 * SearchL
 * search inside xml tree for a specific node
 */
TPtrC8 SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,
		const TDesC8 &aNamespace)
	{
	RXmlEngNodeList<TXmlEngNode> List;
	aTopNode.GetChildNodes(List);
	while (List.HasNext())
		{
		TXmlEngNode Node = List.Next();
		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();
		if (Type == TXmlEngNode::EElement)
			{
			//todo: compare namespace ?
			if (Node.Name() == aName)
				return Node.Value();
			else
				{
				TPtrC8 Return = SearchL(Node, aName, aNamespace);
				if (Return != KNullDesC8)
					return Return;
				}
			}
		}
	return KNullDesC8();
	}

/**
 * GetBoolFromPropertiesL
 * get a boolean value from CCalCalendarInfo
 */
TBool GetBoolFromPropertiesL(CCalCalendarInfo* info, const TDesC8 &aKey)
	{
	TBool boolean;
	TPckgC<TBool> pckgboolean(boolean);
	pckgboolean.Set(info->PropertyValueL(aKey));
	return pckgboolean();
	}

/**
 * GetTimeFromPropertiesL
 * get a time value from CCalCalendarInfo
 */
TCalTime GetTimeFromPropertiesL(CCalCalendarInfo* info, const TDesC8 &aKey)
	{
	TCalTime time;
	TPckgC<TCalTime> pckgtime(time);
	pckgtime.Set(info->PropertyValueL(aKey));
	return pckgtime();
	}

/**
 * PropertyExists
 * finds a property from an array
 */
TBool PropertyExists(CDesC8Array* aArray, const TDesC8 &aKey)
	{
	TInt pos = 0;
	return aArray->Find(aKey, pos, ECmpNormal) == KErrNone;
	}

/**
 * CCalDavEngine::SetCalendarInfoL
 * set key and value pair at calendar session info
 */
void CCalDavEngine::SetCalendarInfoL(const TDesC8 &aKey, const TDesC8 &aValue)
	{
	TBool createdelete = !iCalSession;
	if (createdelete)
		{
		iCalSession = CCalSession::NewL();
		TRAP_IGNORE(iCalSession->OpenL(*iCalendar));
		}
	CCalCalendarInfo* calendarInfo = iCalSession->CalendarInfoL();
	CleanupStack::PushL(calendarInfo);
	TPckgC<TBool> enabled(iEnabled);
	calendarInfo->SetPropertyL(KCaldavEnabled, enabled);
	if (aValue != KNullDesC8)
		calendarInfo->SetPropertyL(aKey, aValue);
	iCalSession->SetCalendarInfoL(*calendarInfo);
	CleanupStack::PopAndDestroy(calendarInfo);

	if (createdelete)
		{
		delete iCalSession;
		iCalSession = NULL;
		}
	}

/**
 * CCalDavEngine::CCalDavEngine
 * default constructor
 */
CCalDavEngine::CCalDavEngine() :
	iCalSession(0), iCalIter(0), iCalEntryView(0), iCalExporter(0),
			iCalImporter(0), iCalIntermimUtils2(0), iCalendar(0), iUrl(0),
			iBaseUrl(0), iHome(0), iHttp(0), iSynctoken(0), iCTag(0),
			iSyncInterval(DEFAULT_SYNC_MINUTES), iPastDays(DEFAULT_PAST_DAYS),
			iImmediateSync(DEFAULT_IMMEDIATE_SYNC), iKeepServerEntry(
					DEFAULT_KEEP_SERVER_ENTRY), iEnabled(EFalse), iTimer(0)
	{
	}

/**
 * CCalDavEngine::~CCalDavEngine
 * default destructor
 */
CCalDavEngine::~CCalDavEngine()
	{
	iLocalUidArray.Close();
	iGlobalUidArray.Close();
	iDeletedEntries.Close();

	iDomParser.Close();
	iDomImpl.Close();

	if (iCalendar)
		delete iCalendar;

	if (iUrl)
		delete iUrl;

	if (iBaseUrl)
		delete iBaseUrl;

	if (iHttp)
		delete iHttp;

	DeleteCalObjects();

	if (iCalIntermimUtils2)
		delete iCalIntermimUtils2;

	if (iSynctoken)
		delete iSynctoken;

	if (iCTag)
		delete iCTag;

	if (iHome)
		delete iHome;

	if (iTimer)
		delete iTimer;
	}

/**
 * CCalDavEngine::NewLC
 * first phase construction
 */
CCalDavEngine* CCalDavEngine::NewLC(const TDesC& aCalendar)
	{
	CCalDavEngine* self = new (ELeave) CCalDavEngine();
	CleanupStack::PushL(self);
	self->ConstructL(aCalendar);
	return self;
	}

/**
 * CCalDavEngine::NewL
 * first phase construction
 */
CCalDavEngine* CCalDavEngine::NewL(const TDesC& aCalendar)
	{
	CCalDavEngine* self = CCalDavEngine::NewLC(aCalendar);
	CleanupStack::Pop(self); // self;
	return self;
	}

/**
 * CCalDavEngine::
 * second phase construction
 */
void CCalDavEngine::ConstructL(const TDesC& aCalendar)
	{
	iManualSync = EFalse;
	iFirstInit = ETrue;
	iCalendar = aCalendar.AllocL();

	iHttp = CHttpClient::NewL();

	iDomImpl.OpenL();
	TInt err = iDomParser.Open(iDomImpl);
	if (KErrNone != err)
		User::Leave(err);

	iTimer = CPeriodic::NewL(EPriorityNormal);
	iCalIntermimUtils2 = CCalenInterimUtils2::NewL();
	iCalSession = CCalSession::NewL();
	TRAP_IGNORE(iCalSession->OpenL(aCalendar));
	CalendarInfoL();
	// we can't close the file, so delete it completly
	delete iCalSession;
	iCalSession = NULL;
	}

/**
 * CCalDavEngine::Progress
 * Progress callback
 */
void CCalDavEngine::Progress(TInt /*aPercentageCompleted*/)
	{
	}

/**
 * CCalDavEngine::RegisterL
 * register all neccessary notification callback
 */
void CCalDavEngine::RegisterL()
	{
	TDateTime Start;
	TDateTime End;
	End.SetYear(2200);

	TCalTime StartCal;
	TCalTime EndCal;
	StartCal.SetTimeLocalL(Start);
	EndCal.SetTimeLocalL(End);
	CalCommon::TCalTimeRange Range(StartCal, EndCal);
	CCalChangeNotificationFilter *Filter = CCalChangeNotificationFilter::NewL(
			MCalChangeCallBack2::EChangeEntryAll, true, Range);
	iCalSession->StartChangeNotification(*this, *Filter);
	iCalSession->StartFileChangeNotificationL(*this);
	delete Filter;
	}

/**
 * CCalDavEngine::CalendarInfoL
 * load all properties from CalendarInfo
 */
void CCalDavEngine::CalendarInfoL()
	{
	CCalCalendarInfo* calendarInfo = iCalSession->CalendarInfoL();
	if (calendarInfo->IsValid())
		{
		CleanupStack::PushL(calendarInfo);
		CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();
		CleanupStack::PushL(propertyKeys);
		TInt pos = 0;
		if (propertyKeys->Find(KCaldavEnabled, pos, ECmpNormal) == KErrNone)
			{
			iEnabled = GetBoolFromPropertiesL(calendarInfo, KCaldavEnabled);
			if (PropertyExists(propertyKeys, KCaldavFirstInit))
				iFirstInit = GetBoolFromPropertiesL(calendarInfo,
						KCaldavFirstInit);
			if (PropertyExists(propertyKeys, KCaldavSynctoken))
				iSynctoken
						= calendarInfo->PropertyValueL(KCaldavSynctoken).AllocL();
			if (PropertyExists(propertyKeys, KCaldavCtag))
				iCTag = calendarInfo->PropertyValueL(KCaldavCtag).AllocL();
			if (PropertyExists(propertyKeys, KCaldavManualSync))
				iManualSync = GetBoolFromPropertiesL(calendarInfo,
						KCaldavManualSync);
			if (PropertyExists(propertyKeys, KCaldavTime))
				iLastSyncTime = GetTimeFromPropertiesL(calendarInfo,
						KCaldavTime);
			if (PropertyExists(propertyKeys, KCaldavUrl))
				iUrl = calendarInfo->PropertyValueL(KCaldavUrl).AllocL();
			if (PropertyExists(propertyKeys, KCaldavUser))
				iHttp->SetUserL(calendarInfo->PropertyValueL(KCaldavUser));
			if (PropertyExists(propertyKeys, KCaldavPassword))
				iHttp->SetPasswordL(calendarInfo->PropertyValueL(
						KCaldavPassword));
			if (PropertyExists(propertyKeys, KCaldavKeepServer))
				iKeepServerEntry = GetBoolFromPropertiesL(calendarInfo,
						KCaldavKeepServer);
			if (PropertyExists(propertyKeys, KCaldavImmediateSync))
				iImmediateSync = GetBoolFromPropertiesL(calendarInfo,
						KCaldavImmediateSync);
			if (PropertyExists(propertyKeys, KCaldavPastDays))
				{
				TPckgC<TTimeIntervalDays> pastdays(iPastDays);
				pastdays.Set(calendarInfo->PropertyValueL(KCaldavPastDays));
				iPastDays = pastdays();
				}
			if (PropertyExists(propertyKeys, KCaldavSyncInterval))
				{
				TPckgC<TTimeIntervalMinutes> syncinterval(iSyncInterval);
				syncinterval.Set(calendarInfo->PropertyValueL(
						KCaldavSyncInterval));
				iSyncInterval = syncinterval();
				}
			// access point	    
			}

		CleanupStack::PopAndDestroy(propertyKeys);
		CleanupStack::Pop(calendarInfo);
		}
	delete calendarInfo;
	}

/**
 * CCalDavEngine::InitL
 * check for correct url
 * load most Caldav url properties
 * do inital sync
 */
TInt CCalDavEngine::InitL()
	{
	// this is only needed to find a GlobalUID from a LocalUID, used after an event was deleted
	// also used now for uploading of local events when only GlobalUID is know 
	LocalLoopL(ELoopActionFillArray);

	if (iFirstInit)
		{
		TInt err = GetCalendarUrlsL(NULL);
		if (err == KErrArgument)
			return KErrArgument;
		GetOptionsL();
		SetLastSyncTimeL();

		TBool success;
		// get all server items
		if (iOptions.sync_collection)
			success = WebDavSyncL();
		else
			success = ListL() == KErrNone;

		if (!success)
			return KErrGeneral;

		// upload all local entries of this calendar to server
		LocalLoopL(ELoopActionUpload);

		if (iOptions.sync_collection)
			SetSyncTokenL(GetSyncTokenL());
		else
			SetCTagL(GetCTagL());

		iFirstInit = EFalse;
		iEnabled = ETrue;
		TPckgC<TBool> firstInit(iFirstInit);
		SetCalendarInfoL(KCaldavFirstInit, firstInit); // this will set iEnabled as well
		}
	else
		{
		TInt err = GetCalendarUrlsL(NULL);
		if (err == KErrArgument)
			return KErrArgument;
		GetOptionsL();
		SetLastSyncTimeL();
		iEnabled = ETrue;
		SetCalendarInfoL(KCaldavEnabled, KNullDesC8);
		SyncL();
		}

	return KErrNone;
	}

/**
 * CCalDavEngine::Completed
 * Completed callback
 */
void CCalDavEngine::Completed(TInt aError)
	{
	if (aError == KErrNone)
		{
		CActiveScheduler::Stop();
		}
	else
		iManualSync = true;
	}

/**
 * CCalDavEngine::NotifyProgress
 * NotifyProgress callback
 */
TBool CCalDavEngine::NotifyProgress()
	{
	return EFalse;
	}

/**
 * CCalDavEngine::CalChangeNotification
 * change item callback, sync to server
 */
void CCalDavEngine::CalChangeNotification(RArray<TCalChangeEntry> &aChangeItems)
	{
	for (TInt i = 0; i < aChangeItems.Count(); i++)
		{
		TRAP_IGNORE(HandleChangeL(aChangeItems[i].iChangeType, aChangeItems[i].iEntryType, aChangeItems[i].iEntryId));
		}
	}

/**
 * CCalDavEngine::CalendarInfoChangeNotificationL
 * change callback, sync changed color or name to server
 */
void CCalDavEngine::CalendarInfoChangeNotificationL(RPointerArray<
		CCalFileChangeInfo>& aCalendarInfoChangeEntries)
	{
	for (TInt i = 0; i < aCalendarInfoChangeEntries.Count(); i++)
		{
		if ((aCalendarInfoChangeEntries[i]->FileNameL() == *iCalendar)
				&& (aCalendarInfoChangeEntries[i]->ChangeType()
						== MCalFileChangeObserver::ECalendarInfoUpdated))
			{
			TRAP_IGNORE(HandleCalendarInfoChangeL());
			}
		}
	}

/**
 * CCalDavEngine::HandleCalendarInfoChangeL
 * sync changed color or name to server
 */
void CCalDavEngine::HandleCalendarInfoChangeL()
	{
	if (iHttp)
		{
		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);
		CCalCalendarInfo* info = iCalSession->CalendarInfoL();
		CleanupStack::PushL(info);

		HBufC8* name =
				CnvUtfConverter::ConvertFromUnicodeToUtf8L(info->NameL());
		CleanupStack::PushL(name);

		TRgb color = info->Color();
		_LIT8(KColorformat,"#%02x%02x%02xFF");
		TBuf8<9> colorbuf;
		colorbuf.Format(KColorformat, color.Red(), color.Green(), color.Blue());

		HBufC8* patch = HBufC8::NewLC(KColorDisplayStart().Length()
				+ colorbuf.Length() + KColorDisplayMiddle().Length()
				+ name->Length() + KColorDisplayEnd().Length());
		patch->Des().Append(KColorDisplayStart);
		patch->Des().Append(colorbuf);
		patch->Des().Append(KColorDisplayMiddle);
		patch->Des().Append(*name);
		patch->Des().Append(KColorDisplayEnd);
		iHttp->ProppatchL(*iUrl, *patch, response);
		CleanupStack::PopAndDestroy(4); // response, info, name, patch
		}
	}

/**
 * CCalDavEngine::HandleChangeL
 * change item callback, sync to server
 */
void CCalDavEngine::HandleChangeL(
		MCalChangeCallBack2::TChangeType &aChangeType,
		MCalChangeCallBack2::TChangeEntryType &aEntryType, TCalLocalUid &aUid)
	{
	switch (aChangeType)
		{
		case MCalChangeCallBack2::EChangeAdd:
		case MCalChangeCallBack2::EChangeModify:
			{
			if (iImmediateSync)
				UploadEntryL(aUid, aChangeType, aEntryType);
			else
				// enable manual sync for the next sync interval
				SyncFailedL();
			break;
			}
		case MCalChangeCallBack2::EChangeDelete:
			{
			if (iImmediateSync)
				DeleteEntryL(aUid);
			else
				{
				iDeletedEntries.Append(aUid);
				SyncFailedL();
				}
			break;
			}
		case MCalChangeCallBack2::EChangeUndefined:
			{
			// upload new and modified entries to server
			UploadModifiedSinceDateL();

			// Find locally deleted ones and delete on server
			DeleteRemovedEntriesOnServerL();

			break;
			}
		}
	}

/**
 * CCalDavEngine::EnableL
 * enable Caldav sync
 */
TInt CCalDavEngine::EnableL()
	{
	if (!iCalEntryView) //do not use iEnabled here,might be set already in ConstructL()
		{
		TInt aErr = CreateCalObjectsL();
		if ((aErr == KErrNone) && (InitL() == KErrNone))
			{
			iTimer->Cancel();
			TInt ticktime = iSyncInterval.Int() == 0 ? 1 : iSyncInterval.Int();
			const TUint64 tickInterval = 1000000 * 60 * ticktime;
			iTimer->Start(tickInterval, tickInterval,
					TCallBack(SyncTickL, this));
			// register change notification
			RegisterL();
			return KErrNone;
			}
		else
			{
			iEnabled = EFalse;
			SetCalendarInfoL(KCaldavEnabled, KNullDesC8);
			DeleteCalObjects();
			return KErrArgument;
			}
		}
	return KErrNone;
	}

/**
 * CCalDavEngine::DeleteCalObjects
 * delete all calendar objects
 */
void CCalDavEngine::DeleteCalObjects()
	{
	delete iCalIter;
	iCalIter = NULL;
	delete iCalEntryView;
	iCalEntryView = NULL;
	delete iCalImporter;
	iCalImporter = NULL;
	delete iCalExporter;
	iCalExporter = NULL;
	if (iCalSession)
		{
		iCalSession->StopChangeNotification();
		iCalSession->StopFileChangeNotification();
		delete iCalSession;
		}
	iCalSession = NULL;
	}

/**
 * CCalDavEngine::CreateCalObjectsL
 * create all calendar objects
 */
TInt CCalDavEngine::CreateCalObjectsL()
	{
	iCalSession = CCalSession::NewL();
	TRAPD(aErr,iCalSession->OpenL(*iCalendar));
	iCalExporter = CCalenExporter::NewL(*iCalSession);
	iCalImporter = CCalenImporter::NewL(*iCalSession);
	iCalEntryView = CCalEntryView::NewL(*iCalSession);
	iCalIter = CCalIter::NewL(*iCalSession);
	return aErr;
	}

/**
 * CCalDavEngine::DisableL
 * disable sync
 */
void CCalDavEngine::DisableL()
	{
	if (iEnabled)
		{
		iTimer->Cancel();
		iEnabled = EFalse;
		SetCalendarInfoL(KCaldavEnabled, KNullDesC8);
		DeleteCalObjects();
		}
	}

/**
 * CCalDavEngine::EnabledSync
 * check for enabled sync
 */
TBool CCalDavEngine::EnabledSync()
	{
	return iEnabled;
	}

/**
 * CCalDavEngine::TimeReportL
 * do a CalDav time report
 */
TInt CCalDavEngine::TimeReportL(TBool VEVENT, const TDesC8 &aStart,
		TBool aDelete)
	{
	CBufFlat* body = CBufFlat::NewL(EXPANDSIZE_BIG);
	CleanupStack::PushL(body);

	body->InsertL(body->Size(), VEVENT ? KTimeStartEVENT() : KTimeStartTODO());
	body->InsertL(body->Size(), aStart); // "20090509T220000Z"/>
	body->InsertL(body->Size(), KTimeEnd);

	CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_BIG);
	CleanupStack::PushL(response);
	TInt ret = iHttp->ReportL(*iUrl, body->Ptr(0), response);

	if (ret == MULTISTATUS)
		ret = aDelete ? ParseResponsesDeleteL(response->Ptr(0))
				: ParseResponsesL(response->Ptr(0));
	else
		ret = KErrGeneral;

	CleanupStack::PopAndDestroy(response);
	CleanupStack::PopAndDestroy(body);
	return ret;
	}

/**
 * CCalDavEngine::ListL
 * get events either using time report or basic propfind
 */
TInt CCalDavEngine::ListL()
	{
	if (iOptions.calendar_access)
		{
		TTime syncstart;
		syncstart.HomeTime();
		syncstart = syncstart - iPastDays;
		TBuf<100> nowStr;
		syncstart.FormatL(nowStr, KFormatString);
		TBuf8<100> nowStrAdd;
		nowStrAdd.Append(nowStr);

		TInt eventreturn = KErrNone;
		if (iOptions.VEVENT)
			eventreturn = TimeReportL(ETrue, nowStrAdd);

		TInt todoreturn = KErrNone;
		if (iOptions.VTODO)
			todoreturn = TimeReportL(EFalse, nowStrAdd);

		return (eventreturn == KErrNone) && (todoreturn == KErrNone) ? KErrNone
				: KErrGeneral;
		}
	else
		{
		// use PROPFIND report
		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);
		TInt ret = iHttp->PropfindL(*iUrl, KPropList, response, EFalse);
		if (ret == MULTISTATUS)
			ret = ParseResponsesL(response->Ptr(0));
		else
			ret = KErrGeneral;
		CleanupStack::PopAndDestroy(response);
		return ret;
		}
	}

/**
 * CCalDavEngine::SyncL
 * sync a calendar
 */
TInt CCalDavEngine::SyncL()
	{
	if (iUrl)
		{
		if (iOptions.sync_collection)
			return WebDavSyncL();
		else
			return ManualSyncL();
		}
	return KErrGeneral;
	}

/**
 * CCalDavEngine::ManualSyncL
 * if sync failed previously, try again manually
 */
TBool CCalDavEngine::ManualSyncL()
	{
	TBool client = ClientChangesL();
	if (iOptions.sync_ctag)
		{
		HBufC8 *newCTag = GetCTagL();
		TBool server = ETrue;
		if ((CTag() != *newCTag) && (*newCTag != KNullDesC8))
			{
			server = ServerChangesL();
			if (server)
				SetCTagL(newCTag);
			else
				delete newCTag;
			}
		else
			delete newCTag;

		return client || server;
		}
	else
		{
		TBool server = ServerChangesL();
		return client || server;
		}
	}

/**
 * CCalDavEngine::ServerChangesL
 * sync server changes
 */
TBool CCalDavEngine::ServerChangesL()
	{
	// loop over all server items to find new and modified entries
	// uses either propfind or calendar-query
	TInt ret = ListL();

	// loop over all local items to find deleted ones on the server
	LocalLoopL(ELoopActionDeleteLocal);

	return ret == KErrNone;
	}

/**
 * CCalDavEngine::LocalLoopL
 * loop over local calendar store
 */
TInt CCalDavEngine::LocalLoopL(TLocalLoopAction aAction)
	{
	TBuf8<URLMAX> iter = iCalIter->FirstL();
	TBuf8<URLMAX> url;
	while (iter != KNullDesC8)
		{
		url.Append(*iUrl);
		url.Append(iter);
		url.Append(KIcs);
		switch (aAction)
			{
			case ELoopActionDeleteLocal:
				{
				if (HeadL(iter) == NOTFOUND)
					DeleteLocalEntryL(url);
				break;
				}
			case ELoopActionFillArray:
				{
				RPointerArray<CCalEntry> entryArray;
				CleanupClosePushL(entryArray);
				iCalEntryView->FetchL(iter, entryArray);
				if (entryArray.Count())
					{
					iLocalUidArray.Append(entryArray[0]->LocalUidL());
					iGlobalUidArray.Append(entryArray[0]->UidL());
					}
				entryArray.ResetAndDestroy();
				CleanupStack::PopAndDestroy(&entryArray);

				break;
				}
			case ELoopActionUpload:
				{
				TInt pos = iGlobalUidArray.Find(iter);
				if ((pos != KErrNotFound) && (iLocalUidArray.Count() > pos))
					UploadEntryL(iLocalUidArray[pos],
							MCalChangeCallBack2::EChangeAdd,
							MCalChangeCallBack2::EChangeEntryAll);
				break;
				}
			}
		url.Delete(0, url.Length());
		iter = iCalIter->NextL();
		}
	return KErrNone;
	}

/**
 * CCalDavEngine::ParseResponsesDeleteL
 * process a recieved multistatus response
 */
TInt CCalDavEngine::ParseResponsesDeleteL(const TDesC8 &aDocument)
	{
	TInt ret = KErrNone;
	RXmlEngDocument document = iDomParser.ParseL(aDocument);
	CleanupClosePushL(document);
	if (document.NotNull())
		{
		// this method works for response as well as sync-response
		// do not use GetElementsByTagNameL for one specific responses directly	
		TXmlEngElement ResponseListTop;
		SearchL(document, KMultistatus, KNullDesC8, ResponseListTop);

		RXmlEngNodeList<TXmlEngNode> ResponseList;
		CleanupClosePushL(ResponseList);
		ResponseListTop.GetChildNodes(ResponseList);

		while (ResponseList.HasNext())
			{
			TXmlEngNode node = ResponseList.Next();
			if (node.NodeType() == TXmlEngNode::EElement)
				{
				TPtrC8 href = SearchL(node, KHref, KNullDesC8);
				// don't do anything with home itself
				if ((href.Right(KIcs().Length()) == KIcs))
					{
					if (!DoesEntryExistL(href))
						DeleteEntryL(href);
					}
				}
			}
		CleanupStack::PopAndDestroy(&ResponseList);

		}
	else
		ret = KErrArgument;
	CleanupStack::PopAndDestroy(&document);
	return ret;
	}

/**
 * CCalDavEngine::ParseResponsesL
 * process a recieved multistatus response
 */
TInt CCalDavEngine::ParseResponsesL(RXmlEngDocument &aDocument, TBool aMultiget)
	{
	TInt ret = KErrNone;
	if (aDocument.NotNull())
		{
		CDesC8ArrayFlat *multiget = NULL;
		if (iOptions.MULTIGET)
			{
			multiget = new (ELeave) CDesC8ArrayFlat(ARRAYEXPAND);
			CleanupStack::PushL(multiget);
			}

		// this method works for response as well as sync-response
		// do not use GetElementsByTagNameL for one specific responses directly	
		TXmlEngElement ResponseListTop;
		SearchL(aDocument, KMultistatus, KNullDesC8, ResponseListTop);

		RXmlEngNodeList<TXmlEngNode> ResponseList;
		CleanupClosePushL(ResponseList);
		ResponseListTop.GetChildNodes(ResponseList);

		while (ResponseList.HasNext())
			{
			TXmlEngNode node = ResponseList.Next();
			if (node.NodeType() == TXmlEngNode::EElement)
				{
				TPtrC8 href = SearchL(node, KHref, KNullDesC8);
				//do not use Search, only looking for first childs,
				//as D:propstat has D:status as well
				RXmlEngNodeList<TXmlEngElement> statuslist;
				CleanupClosePushL(statuslist);
				node.AsElement().GetElementsByTagNameL(statuslist, KStatus,
						KDav);
				//only one or zero item
				HBufC8* status =
						statuslist.Count() ? statuslist.Next().Value().AllocL()
								: KNullDesC8().AllocL();
				CleanupStack::PopAndDestroy(&statuslist);
				CleanupStack::PushL(status);
				status->Des().LowerCase();
				TPtrC8 etag = SearchL(node, KEtag, KNullDesC8);
				RBuf8 calendardata;
				SearchL(node, KCalendarData, KNullDesC8, calendardata);
				calendardata.CleanupClosePushL();

				// don't do anything with home itself
				if (href.Right(KIcs().Length()) == KIcs)
					{
					if ((*status == KHTTP200) || (*status == KHTTP201) || (*status == KNullDesC8))
						{
						if ((calendardata == KNullDesC8))
							{
							if (aMultiget)
								{
								// ATTENTION: an empty response to a multiget should never happen
								// data wrapped inside CDATA, e.g. bedework ??
								}
							else
								//TOOD: if this is a webdav sync response, we should skip the etag check
								AddModifyLocalEntryL(href, etag, multiget);
							}
						else
							{
							// response to a multiget or time-range report, we now already have everything we need
							StoreEntryL(calendardata, etag);
							}
						}
					else if (*status == KHTTP404)
						{
						if (iOptions.sync_collection)
							{
							// if this is an initial sync without token, 
							// this should be ignored, Sun Server bug!!!
							if (SyncToken() != KNullDesC8)
								DeleteLocalEntryL(href);
							}
						else
							{
							//multiget answer, but deleted in the meantime, should delete locally as well
							DeleteLocalEntryL(href);
							}
						}
					}
				CleanupStack::PopAndDestroy(&calendardata);
				CleanupStack::PopAndDestroy(status);
				}
			}
		CleanupStack::PopAndDestroy(&ResponseList);

		if (iOptions.MULTIGET)
			{
			if (multiget->Count())
				{
				DownloadEntryL(multiget);
				multiget->Reset();
				}
			CleanupStack::PopAndDestroy(multiget);
			}
		}
	else
		ret = KErrArgument;

	return ret;
	}

/**
 * CCalDavEngine::ParseResponsesL
 * process a recieved multistatus response
 */
TInt CCalDavEngine::ParseResponsesL(const TDesC8 &aDocument, TBool aMultiget)
	{
#ifdef _DEBUG
	_LIT(KFilename,"c:\\logs\\caldav\\parseresonseslatest.txt");
	ExportToFileNameL(aDocument, KFilename);
#endif

	RXmlEngDocument document = iDomParser.ParseL(aDocument);
	CleanupClosePushL(document);
	TInt ret = ParseResponsesL(document, aMultiget);
	CleanupStack::PopAndDestroy(&document);
	return ret;
	}

/**
 * CCalDavEngine::StoreEntryL
 * store event in local store
 */
#ifdef ETAG
TInt CCalDavEngine::StoreEntryL(const TDesC8 &aBuf, const TDesC8 &aEtag)
#else
TInt CCalDavEngine::StoreEntryL(const TDesC8 &aBuf, const TDesC8 &/*aEtag*/)
#endif
	{
#ifdef _DEBUG
	_LIT(KFileName2, "C:\\logs\\caldav\\testing_import.txt");
	ExportToFileNameL(aBuf, KFileName2);
#endif

	HBufC8* buffer = HBufC8::NewL(aBuf.Length() + 500);
	buffer->Des().Append(aBuf);
	TPtr8 ptr = buffer->Des();
	CalDavUtils::FixImportIssues(ptr);

	RPointerArray<CCalEntry> Array;
	CleanupClosePushL(Array);
	RDesReadStream ReadStream;
	ReadStream.Open(ptr);
	CleanupClosePushL(ReadStream);
#ifdef _DEBUG
	_LIT(KFileName, "C:\\logs\\caldav\\testing_import_fixed.txt");
	ExportToFileNameL(ptr, KFileName);
#endif
	TRAPD(error, iCalImporter->ImportICalendarL(ReadStream,Array));
	CleanupStack::PopAndDestroy(&ReadStream); // calls close on rSteam												
	if ((error == KErrNone) && (Array.Count()))
		{
		iCalIntermimUtils2->StoreL(*iCalEntryView, *Array[0], ETrue); // or should last one be EFalse??
		TInt pos = iLocalUidArray.Find(Array[0]->LocalUidL());
		if (pos == KErrNotFound)
			{
			iLocalUidArray.Append(Array[0]->LocalUidL());
			iGlobalUidArray.Append(Array[0]->UidL());
			}
#ifdef ETAG
		Array[0]->SetETag(aEtag);
#endif
		}
	Array.ResetAndDestroy();
	CleanupStack::PopAndDestroy(&Array);

	delete buffer;
	return error;
	}

/**
 * CCalDavEngine::WebDavSyncReportL
 * webdav sync report
 * http://tools.ietf.org/html/draft-daboo-webdav-sync-02
 */
TInt CCalDavEngine::WebDavSyncReportL(TBool aSynctoken)
	{
	HBufC8 *Buf = HBufC8::NewL(KSync().Length() + SyncToken().Length());
	TPtrC8 token = SyncToken();
	if (aSynctoken)
		Buf->Des().Format(KSync, &token);
	else
		Buf->Des().Format(KSync, &KNullDesC8());
	CleanupStack::PushL(Buf);

	CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_BIG);
	CleanupStack::PushL(response);
	TInt ret = iHttp->ReportL(*iUrl, *Buf, response);

	if (ret == MULTISTATUS)
		{
		RXmlEngDocument document = iDomParser.ParseL(response->Ptr(0));
		CleanupClosePushL(document);
		if (document.NotNull())
			{
			TPtrC8 Token = SearchL(document, KSynctoken, KNullDesC8);
			if ((Token != KNullDesC8) && (Token != SyncToken()))
				{
				ret = ParseResponsesL(document);
				//store newest token
				if (ret == KErrNone)
					SetSyncTokenL(Token.AllocL());
				}
			else
				ret = KErrNone;
			}
		else
			ret = KErrGeneral;
		CleanupStack::PopAndDestroy(&document);
		}
	CleanupStack::PopAndDestroy(response);
	CleanupStack::PopAndDestroy(Buf);
	return ret;
	}

/**
 * CCalDavEngine::WebDavSyncL
 * sync using webdav sync
 * http://tools.ietf.org/html/draft-daboo-webdav-sync-02
 */
TBool CCalDavEngine::WebDavSyncL()
	{
	if (iHttp)
		{
		// commit any left over client changes
		TBool RetClient = ClientChangesL();
		// get all changes from server
		TInt ret = WebDavSyncReportL(ETrue);
		if (ret == CONFLICT)
			ret = WebDavSyncReportL(EFalse);
		return (ret == KErrNone) && RetClient;
		}
	return EFalse;
	}

/**
 * CCalDavEngine::GetUIDByUrl
 * parse url to find UID
 */
TPtrC8 CCalDavEngine::GetUIDByUrl(const TDesC8 &aUrl)
	{
	TPtrC8 UID;
	TInt Pos = aUrl.LocateReverse('/');
	TInt Pos2 = aUrl.Find(KIcs);

	if ((Pos != KErrNotFound) && (Pos2 != KErrNotFound))
		UID.Set(aUrl.Mid(Pos + 1, Pos2 - Pos - 1));
	else
		{
		if (Pos != KErrNotFound)
			UID.Set(aUrl.Mid(Pos + 1, aUrl.Length() - Pos - 1));
		else if (Pos2 != KErrNotFound)
			UID.Set(aUrl.Left(aUrl.Length() - KIcs().Length()));
		else
			UID.Set(aUrl);
		}

	return UID;
	}

/**
 * CCalDavEngine::DoesEntryExistL
 * check if entry exists in local store
 */
unsigned long CCalDavEngine::DoesEntryExistL(const TDesC8 &aUrl)
	{
	// check if we already have it locally by uid
	RPointerArray<CCalEntry> entryArray;
	CleanupClosePushL(entryArray);
	iCalEntryView->FetchL(GetUIDByUrl(aUrl), entryArray);
	// get parent 
	CCalEntry *entry = entryArray.Count() ? entryArray[0] : NULL;
	TInt ret = entry ? entry->LocalUidL() : 0;
	entryArray.ResetAndDestroy();
	CleanupStack::PopAndDestroy(&entryArray);
	return ret;
	}

/**
 * CCalDavEngine::ETagMatchL
 * checks for equal ETag
 */
TBool CCalDavEngine::ETagMatchL(const TDesC8& /*aUrl*/, const TDesC8& /*aETag*/)
	{
#ifdef ETAG
	// check if we already have it locally by uid
	RPointerArray<CCalEntry> entryArray;
	CleanupClosePushL(entryArray);
	iCalEntryView->FetchL(GetUIDByUrl(aUrl), entryArray);
	// get parent 
	CCalEntry *entry = entryArray.Count() ? entryArray[0] : NULL;
	TBool ret = entry ? entry->ETag() == aETag : EFalse;
	entryArray.ResetAndDestroy();
	CleanupStack::PopAndDestroy(&entryArray);
	return ret;
#else
	return EFalse;
#endif
	}

/**
 * CCalDavEngine::AddModifyLocalEntryL
 * add or modify existing event
 */
TInt CCalDavEngine::AddModifyLocalEntryL(const TDesC8 &aUrl,
		const TDesC8 &aETag, CDesC8ArrayFlat* aArray)
	{
	// check if we have the entry locally
	// check for etag if we have the latest version, if not, download and import or add to multiget request
	if (!ETagMatchL(aUrl, aETag))
		{
		if (aArray)
			aArray->AppendL(aUrl);
		else
			DownloadEntryL(aUrl);
		}
	return KErrNone;
	}

/**
 * CCalDavEngine::DownloadEntryL
 * download entries using multiget from server
 */
TInt CCalDavEngine::DownloadEntryL(CDesC8Array* aArray)
	{
	TInt ret = KErrNone;
	TInt64 remainder;
	TInt64 result = Math::DivMod64(aArray->Count(), MULTIGETSPLIT, remainder);

	// split large multigets request into several smaller ones
	for (TInt64 l = 0; l <= result; l++)
		{
		// do the multiget request and pass it to parserepsonses again to read in the data
		CBufFlat* body = CBufFlat::NewL(EXPANDSIZE_BIG);
		CleanupStack::PushL(body);

		body->InsertL(body->Size(), KMultistart);
		for (TInt64 i = 0; i <= ((l == result) ? remainder - 1 : MULTIGETSPLIT
				- 1); i++)
			{
			body->InsertL(body->Size(), KHrefstart);
			body->InsertL(body->Size(), (*aArray)[MULTIGETSPLIT * l + i]);
			body->InsertL(body->Size(), KHrefend);
			}
		body->InsertL(body->Size(), KMultiend);

		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_BIG);
		CleanupStack::PushL(response);
		TInt Return = iHttp->ReportL(*iUrl, body->Ptr(0), response);

		if (Return == MULTISTATUS)
			{
			TInt parsereturn = ParseResponsesL(response->Ptr(0), ETrue);
			// if it failed before, we do not want to override this error
			ret = (ret == KErrNone) ? parsereturn : ret;
			}
		else
			ret = KErrGeneral;
		CleanupStack::PopAndDestroy(response);
		CleanupStack::PopAndDestroy(body);

		}
	return ret;
	}

/**
 * CCalDavEngine::DownloadEntryL
 * download entry from server
 */
TInt CCalDavEngine::DownloadEntryL(const TDesC8 &aUrl)
	{
	TBuf8<URLMAX> url;
	url.Append(*iUrl);
	url.Append(GetUIDByUrl(aUrl));
	url.Append(KIcs);

	CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
	CleanupStack::PushL(response);
	TInt ret = iHttp->GetL(url, response);
	if (ret == OK)
		ret = StoreEntryL(response->Ptr(0), iHttp->ETag());
	else
		ret = KErrGeneral;
	CleanupStack::PopAndDestroy(response);
	return ret;
	}

/**
 * CCalDavEngine::DeleteLocalEntryL
 * delete an event from local store
 */
TInt CCalDavEngine::DeleteLocalEntryL(const TDesC8 &aUID)
	{
	CDesC8ArrayFlat * Array = new (ELeave) CDesC8ArrayFlat(ARRAYEXPAND);
	CleanupStack::PushL(Array);
	Array->AppendL(GetUIDByUrl(aUID));
	// we could have delete it ourselves, so it is already gone
	TRAPD(error, iCalEntryView->DeleteL(*Array));
	Array->Reset();
	CleanupStack::PopAndDestroy(Array);
	return error;
	}

/**
 * CCalDavEngine::DeleteRemovedEntriesOnServerL
 * check for removed entries on server
 */
TInt CCalDavEngine::DeleteRemovedEntriesOnServerL()
	{
	if (iOptions.calendar_access)
		{
		TTime syncstart;
		syncstart.HomeTime();
		syncstart = syncstart - iPastDays;
		TBuf<100> nowStr;
		syncstart.FormatL(nowStr, KFormatString);
		TBuf8<100> nowStrAdd;
		nowStrAdd.Append(nowStr);

		TInt eventreturn = KErrNone;
		if (iOptions.VEVENT)
			eventreturn = TimeReportL(ETrue, nowStrAdd, ETrue);

		TInt todoreturn = KErrNone;
		if (iOptions.VTODO)
			todoreturn = TimeReportL(EFalse, nowStrAdd, ETrue);

		return (eventreturn == KErrNone) && (todoreturn == KErrNone) ? KErrNone
				: KErrGeneral;
		}
	else
		{
		// use PROPFIND report
		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);
		TInt ret = iHttp->PropfindL(*iUrl, KPropList, response, EFalse);
		if (ret == MULTISTATUS)
			ret = ParseResponsesDeleteL(response->Ptr(0));
		else
			ret = KErrGeneral;
		CleanupStack::PopAndDestroy(response);
		return ret;
		}

	}

/**
 * CCalDavEngine::UploadModifiedSinceDateL
 * check for any modified data after last sync time
 */
TBool CCalDavEngine::UploadModifiedSinceDateL()
	{
	TBool manualsync = EFalse;
	// upload modified and newly create ones 
	RArray<TCalLocalUid> *Ids = new (ELeave) RArray<TCalLocalUid> (ARRAYEXPAND);
	iCalEntryView->GetIdsModifiedSinceDateL(iLastSyncTime, *Ids);
	for (TInt i = 0; i < Ids->Count(); i++)
		{
		TCalLocalUid id = (*Ids)[i];
		TInt ret = UploadEntryL(id, MCalChangeCallBack2::EChangeUndefined,
				MCalChangeCallBack2::EChangeEntryAll);
		// TOOD: if it fails during upload, ignore
		// if it fails due to internet connection, try again
		if (ret != KErrNone)
			manualsync = ETrue;
		}
	Ids->Reset();
	delete Ids;
	return manualsync;
	}

/**
 * CCalDavEngine::ClientChangesL
 * check for left over local client changes
 */
TBool CCalDavEngine::ClientChangesL()
	{
	if (iCalEntryView && iManualSync)
		{
		iManualSync = EFalse;

		// upload modified and newly create ones 
		iManualSync = UploadModifiedSinceDateL();

		// delete locally deleted entries on server 
		for (TInt i = iDeletedEntries.Count() - 1; i >= 0; --i)
			{
			TInt ret = DeleteEntryL(iDeletedEntries[i]);
			if (ret == KErrNone)
				iDeletedEntries.Remove(i);

			}

		iManualSync = iDeletedEntries.Count() ? ETrue : EFalse;

		TPckgC<TBool> manualSync(iManualSync);
		SetCalendarInfoL(KCaldavManualSync, manualSync);
		}

	return ETrue;
	}

/**
 * CCalDavEngine::MkcalendarL
 * create a new calendar on the server
 */
TInt CCalDavEngine::MkcalendarL(const TDesC8 &aName)
	{
	if (iOptions.MKCALENDAR)
		{
		TBuf8<URLMAX> url;
		url.Append(*iHome);
		url.Append(aName);
		url.Append(KSlash);

		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);

		// TOOD: initialize with name, body etc.
		TInt ret = iHttp->MkCalendarL(url, KNullDesC8, response);

		if ((ret == CREATED) || (ret == OK))
			ret = KErrNone;
		else if ((ret == NOTALLOWED) || (ret == FORBIDDEN))
			ret = KErrArgument;
		else
			ret = KErrGeneral;
		CleanupStack::PopAndDestroy(response);
		return ret;
		}
	else
		return KErrNotSupported;
	}

/**
 * CCalDavEngine::DeleteCalendarL
 * delete a calendar on the server
 */
TInt CCalDavEngine::DeleteCalendarL(const TDesC8 &aName)
	{
	if (iOptions.MKCALENDAR)
		{
		TBuf8<URLMAX> url;
		url.Append(*iHome);
		url.Append(aName);
		url.Append(KSlash);

		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);
		TInt ret = iHttp->DeleteL(url);
		if ((ret == NOCONTENT) || (ret == OK))
			ret = KErrNone;
		else
			ret = KErrGeneral;
		CleanupStack::PopAndDestroy(response);
		return ret;
		}
	else
		return KErrNotSupported;
	}

/**
 * CCalDavEngine::HeadL
 * check for existence of an entry on server
 */
TInt CCalDavEngine::HeadL(const TDesC8 &aUID)
	{
	// special handing for yahoo neccessary
	// after deleting an event, it is still there and findable with HEAD
	_LIT8(KYahoo,"yahoo");
	_LIT8(KTrash,"trash");

	TBuf8<URLMAX> url;
	url.Append(*iUrl);
	url.Append(aUID);
	url.Append(KIcs);
	if (iUrl->Find(KYahoo) == KErrNotFound)
		{
		TInt head = iHttp->HeadL(url);
		return (head == NOCONTENT) || (head == OK) ? OK : head;
		}
	else
		{
		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);
		TInt ret = iHttp->PropfindL(url, KNullDesC8, response);

		if (ret == MULTISTATUS)
			{
			RXmlEngDocument document = iDomParser.ParseL(response->Ptr(0));
			CleanupClosePushL(document);
			if (document.NotNull())
				{
				HBufC8* href = SearchL(document, KHref, KNullDesC8).AllocL();
				href->Des().LowerCase();
				ret = href->Find(KTrash) == KErrNotFound ? OK : NOTFOUND;
				delete href;
				}
			CleanupStack::PopAndDestroy(&document);
			CleanupStack::PopAndDestroy(response);
			return ret;
			}
		else
			{
			CleanupStack::PopAndDestroy(response);
			return NOTFOUND;
			}
		}
	}

/**
 * CCalDavEngine::DeleteEntryL
 * delete entry on server
 */
TInt CCalDavEngine::DeleteEntryL(const TDesC8 &aUid)
	{
	TBuf8<URLMAX> url;
	url.Append(*iBaseUrl);
	url.Append(aUid);
	return iHttp->DeleteL(url);
	}

/**
 * CCalDavEngine::DeleteEntryL
 * delete entry on server
 */
TInt CCalDavEngine::DeleteEntryL(const TCalLocalUid &aUid)
	{
	TInt Ret = KErrNone;
	// find the filename for a given local UID
	TInt aPos = iLocalUidArray.Find(aUid);
	if (aPos != KErrNotFound)
		{
		TBuf8<URLMAX> url;
		url.Append(*iUrl);
		url.Append(iGlobalUidArray[aPos]);
		url.Append(KIcs);

#ifdef ETAG
		CCalEntry* entry = iCalEntryView->FetchL(aUid);
		CleanupStack::PushL(entry);
		TInt Return = entry ? iHttp->DeleteL(url, entry->ETag())
		: iHttp->DeleteL(url);
		CleanupStack::PopAndDestroy(entry);
#else
		TInt Return = iHttp->DeleteL(url);
#endif

		if ((Return == NOCONTENT) || (Return == OK))
			{
			SetLastSyncTimeL();
			}
		else if (Return == PRECONDFAILED)
			{
			// someone modified this in the meantime
			// ask user if he wants the new event or still delete it
			TBool modify = EFalse;
			if (modify)
				DownloadEntryL(url);
			else
				iHttp->DeleteL(url);
			}
		else if (Return == NOTFOUND)
			{
			// someone deleted this already
			Ret = KErrGeneral;
			}
		else if (Return == FORBIDDEN)
			{
			// event read-only
			Ret = KErrGeneral;
			}
		else
			{
			Ret = KErrGeneral;
			SyncFailedL();
			TInt pos = iDeletedEntries.Find(aUid);
			if (pos == KErrNotFound)
				iDeletedEntries.Append(aUid);
			}
		}
	else
		Ret = KErrGeneral;
	return Ret;
	}

/**
 * CCalDavEngine::UploadEntryL
 * upload entry to server
 */
TInt CCalDavEngine::UploadEntryL(CCalEntry* aEntry,
		MCalChangeCallBack2::TChangeType aChangeType,
		MCalChangeCallBack2::TChangeEntryType aEntryType)
	{
	if (aEntry)
		{
		TInt ret = KErrNone;
		TBool upload = EFalse;
		switch (aEntryType)
			{
			case MCalChangeCallBack2::EChangeEntryEvent:
			case MCalChangeCallBack2::EChangeEntryTodo:
				{
				upload = aEntry && ((MCalChangeCallBack2::EChangeEntryEvent
						&& iOptions.VEVENT)
						|| (MCalChangeCallBack2::EChangeEntryTodo
								&& iOptions.VTODO));
				break;
				}
			case MCalChangeCallBack2::EChangeEntryAll:
				{
				if (aEntry)
					{
					switch (aEntry->EntryTypeL())
						{
						case CCalEntry::EAppt:
						case CCalEntry::EAnniv:
						case CCalEntry::EEvent:
						case CCalEntry::EReminder:
							{
							upload = iOptions.VEVENT;
							break;
							}
						case CCalEntry::ETodo:
							{
							upload = iOptions.VTODO;
							break;
							}
						}
					}

				}
			}
		if (upload)
			{
			CBufFlat* BufFlat = CBufFlat::NewL(EXPANDSIZE_SMALL);
			CleanupStack::PushL(BufFlat);
			RBufWriteStream writeStream(*BufFlat);
			CleanupClosePushL(writeStream);
			iCalExporter->ExportICalL(*aEntry, writeStream);
			writeStream.CommitL();
			CleanupStack::PopAndDestroy(&writeStream);

			HBufC8* buffer = BufFlat->Ptr(0).AllocL();
			CleanupStack::PopAndDestroy(BufFlat);
			CleanupStack::PushL(buffer);
			TPtr8 ptr = buffer->Des();
			CalDavUtils::FixExportIssues(ptr);

#ifdef _DEBUG
			ExportToFileL(aEntry, iCalExporter);
			_LIT(KFileName, "C:\\logs\\caldav\\testing_export_fixed.txt");
			ExportToFileNameL(ptr, KFileName);
#endif

			TBuf8<URLMAX> url;
			url.Append(*iUrl);
			url.Append(aEntry->UidL());
			url.Append(KIcs);

			CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
			CleanupStack::PushL(response);

#ifdef ETAG
			TPtrC8 etag = aEntry->GetETag();
			TBool newentry = (aChangeType == MCalChangeCallBack2::EChangeAdd)
			|| ((aChangeType == MCalChangeCallBack2::EChangeUndefined)
					&& (etag == KNullDesC8));
			TInt Ret = newentry ? iHttp->PutL(url, *buffer, response)
			: iHttp->PutL(url, *buffer, response, etag);
#else
			TBool newentry = (aChangeType == MCalChangeCallBack2::EChangeAdd)
					|| (aChangeType == MCalChangeCallBack2::EChangeUndefined);
			TInt Ret = newentry ? iHttp->PutL(url, *buffer, response)
					: iHttp->PutL(url, *buffer, response, _L8("ETAG"));
#endif
			if ((Ret == CREATED) || (Ret == NOCONTENT) || (Ret == OK))
				{
				if (newentry)
					{
					iLocalUidArray.Append(aEntry->LocalUidL());
					iGlobalUidArray.Append(aEntry->UidL());
					}
#ifdef ETAG
				aEntry->SetETag(iHttp->ETag());
#endif
				SetLastSyncTimeL();
				}
			else if (Ret == PRECONDFAILED)
				{
				if (newentry)// same filename already exists, use a different one and upload again
					{
					TBuf8<URLMAX> nextUrl;
					nextUrl.Append(*iUrl);
					nextUrl.Append(aEntry->UidL());
					TTime time;
					time.HomeTime();
					_LIT(KTimeFormat,"%H%T%S");
					TBuf<20> StringTime;
					time.FormatL(StringTime, KTimeFormat);
					nextUrl.Append(StringTime);
					nextUrl.Append(_L8(".ics"));
					response->Reset();
					TInt Ret = iHttp->PutL(nextUrl, *buffer, response);
					if ((Ret == CREATED) || (Ret == OK))
						{
						iLocalUidArray.Append(aEntry->LocalUidL());
						iGlobalUidArray.Append(aEntry->UidL());
#ifdef ETAG
						aEntry->SetETag(iHttp->ETag());
#endif
						SetLastSyncTimeL();
						}
					else
						{
						SyncFailedL();
						ret = KErrAbort;
						}
					}
				else
					{
					if (!iKeepServerEntry)
						{
						response->Reset();
						// upload again without ETAG to overwrite server entry
						TInt Ret = iHttp->PutL(url, *buffer, response);
						if ((Ret == CREATED) || (Ret == OK))
							{
#ifdef ETAG
							aEntry->SetETag(iHttp->ETag());
#endif
							SetLastSyncTimeL();
							}
						else
							{
							SyncFailedL();
							ret = KErrAbort;
							}
						}
					else
						{
						// download the server event and update local store
						ret = DownloadEntryL(url);
						if (ret == KErrNone)
							SetLastSyncTimeL();
						else
							{
							SyncFailedL();
							ret = KErrAbort;
							}
						}
					}
				}
			else
				{
				SyncFailedL();
				ret = KErrAbort;
				}
			CleanupStack::PopAndDestroy(response);
			CleanupStack::PopAndDestroy(buffer);
			}
		return ret;
		}
	return KErrArgument;
	}

/**
 * CCalDavEngine::UploadEntryL
 * upload entry to server
 */
TInt CCalDavEngine::UploadEntryL(const TCalLocalUid &aUid,
		MCalChangeCallBack2::TChangeType aChangeType,
		MCalChangeCallBack2::TChangeEntryType aEntryType)
	{
	CCalEntry * aEntry = iCalEntryView->FetchL(aUid);
	CleanupStack::PushL(aEntry);
	TInt ret = UploadEntryL(aEntry, aChangeType, aEntryType);
	CleanupStack::PopAndDestroy(aEntry);
	return ret;
	}

/**
 * CCalDavEngine::GetSyncTokenL
 * get latest Webdav Sync token
 */
HBufC8* CCalDavEngine::GetSyncTokenL()
	{
	HBufC8 *aBuf = HBufC8::NewL(KSync().Length());
	aBuf->Des().Format(KSync, &KNullDesC8());
	CleanupStack::PushL(aBuf);

	CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
	CleanupStack::PushL(response);
	TInt RetServer = iHttp->ReportL(*iUrl, *aBuf, response);

	if (RetServer)
		{
		RXmlEngDocument document = iDomParser.ParseL(response->Ptr(0));
		CleanupClosePushL(document);
		if (document.NotNull())
			{
			HBufC8* ret = SearchL(document, KSynctoken, KNullDesC8).AllocL();
			CleanupStack::PopAndDestroy(&document);
			CleanupStack::PopAndDestroy(response);
			CleanupStack::PopAndDestroy(aBuf);
			return ret;
			}
		CleanupStack::PopAndDestroy(&document);
		}
	CleanupStack::PopAndDestroy(response);
	CleanupStack::PopAndDestroy(aBuf);
	return KNullDesC8().AllocL();
	}

/**
 * CCalDavEngine::CheckCalendarInfoL
 * check for new calendar displayname and color
 */
void CCalDavEngine::CheckCalendarInfoL(RXmlEngDocument &aDocument)
	{
	TBool change = EFalse;
	CCalCalendarInfo* info = iCalSession->CalendarInfoL();
	CleanupStack::PushL(info);

	HBufC8* color = SearchL(aDocument, KCalendar_Color, KNullDesC8).AllocLC();
	if ((*color != KNullDesC8) && (color->Length() > 6))
		{
		TLex8 lexred(color->Des().Mid(1, 2));
		TInt red;
		lexred.Val(red);
		TLex8 lexgreen(color->Des().Mid(3, 2));
		TInt green;
		lexgreen.Val(green);
		TLex8 lexblue(color->Des().Mid(5, 2));
		TInt blue;
		lexblue.Val(blue);
		TRgb newcolor(red, green, blue);
		if (info->Color() != newcolor)
			{
			info->SetColor(newcolor);
			change = ETrue;
			}
		}
	CleanupStack::PopAndDestroy(color);

	HBufC8* displayname =
			SearchL(aDocument, KDisplayname, KNullDesC8).AllocLC();
	if (*displayname != KNullDesC8)
		{
		HBufC16* name =
				CnvUtfConverter::ConvertToUnicodeFromUtf8L(*displayname);
		CleanupStack::PushL(name);
		if (info->NameL() != *name)
			{
			info->SetNameL(*name);
			change = ETrue;
			}
		CleanupStack::PopAndDestroy(name);
		change = ETrue;
		}
	CleanupStack::PopAndDestroy(displayname);

	if (change)
		iCalSession->SetCalendarInfoL(*info);
	CleanupStack::PopAndDestroy(info);

	}

/**
 * CCalDavEngine::GetCTagL
 * get latest CTag
 * https://trac.calendarserver.org/browser/CalendarServer/trunk/doc/Extensions/caldav-ctag.txt
 */
HBufC8* CCalDavEngine::GetCTagL()
	{
	if (iHttp)
		{
		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);
		TInt ret = iHttp->PropfindL(*iUrl, KCtag, response);

		if (ret == MULTISTATUS)
			{
			RXmlEngDocument document = iDomParser.ParseL(response->Ptr(0));
			CleanupClosePushL(document);
			if (document.NotNull())
				{
				HBufC8* status =
						SearchL(document, KStatus, KNullDesC8).AllocLC();
				HBufC8* ctag =
						SearchL(document, KGetctag, KNullDesC8).AllocLC();
				status->Des().LowerCase();
				if ((*ctag != KNullDesC8) && (*status == KHTTP200))
					{
					CleanupStack::Pop(ctag);
					CleanupStack::PopAndDestroy(status);
					CleanupStack::PopAndDestroy(&document);
					CleanupStack::PopAndDestroy(response);
					return ctag;
					}
				else
					CleanupStack::PopAndDestroy(ctag);
				CleanupStack::PopAndDestroy(status);
				}
			CleanupStack::PopAndDestroy(&document);

			}
		CleanupStack::PopAndDestroy(response);
		}
	return KNullDesC8().AllocL();
	}

/**
 * CCalDavEngine::GetOptionsL
 * get OPTIONS from server
 */
TBool CCalDavEngine::GetOptionsL()
	{
	if (iHttp)
		{
		// check DAV and allow headers
		iHttp->GetServerOptionsL(*iUrl, iOptions);

		// check ctag extension
		HBufC8* ctag = GetCTagL();
		if (*ctag != KNullDesC8)
			iOptions.sync_ctag = true;
		delete ctag;

		// check supported elements
		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);
		TInt Ret = iHttp->PropfindL(*iUrl, KSupportedSet, response);

		if (Ret == MULTISTATUS)
			{
			RXmlEngDocument document = iDomParser.ParseL(response->Ptr(0));
			CleanupClosePushL(document);
			if (document.NotNull())
				{
				CheckCalendarInfoL(document);

				//<C:supported-calendar-component-set/>
				TXmlEngElement supportedelement;
				SearchL(document, KSupportedCalendarComponentSet, KNullDesC8,
						supportedelement);
				if (supportedelement.NotNull())
					{
					RXmlEngNodeList<TXmlEngElement> supportedelements;
					CleanupClosePushL(supportedelements);
					supportedelement.GetChildElements(supportedelements);
					while (supportedelements.HasNext())
						{
						TXmlEngElement element = supportedelements.Next();
						TPtrC8 value = element.AttributeValueL(KName);
						if (value == KNullDesC8)
							value.Set(element.AttributeValueL(KName, KCalDav));
						if (value == KVEVENT)
							iOptions.VEVENT = ETrue;
						else if (value == KVTODO)
							iOptions.VTODO = ETrue;
						else if (value == KVFREBUSY)
							iOptions.VFREEBUSY = ETrue;
						else if (value == KVJOURNAL)
							iOptions.VJOURNAL = ETrue;
						}
					CleanupStack::PopAndDestroy(&supportedelements);
					}
				}
			CleanupStack::PopAndDestroy(&document);
			}
		CleanupStack::PopAndDestroy(response);
		}
	return ETrue;
	}

/**
 * CCalDavEngine::SetSyncTokenL
 * set sync token
 */
void CCalDavEngine::SetSyncTokenL(HBufC8* aToken)
	{
	if (iSynctoken)
		{
		delete iSynctoken;
		iSynctoken = NULL;
		}
	iSynctoken = aToken;
	SetCalendarInfoL(KCaldavSynctoken, *iSynctoken);
	}

/**
 * CCalDavEngine::SyncToken
 * get synctoken
 */
TPtrC8 CCalDavEngine::SyncToken()
	{
	return iSynctoken ? *iSynctoken : KNullDesC8();
	}

/**
 * CCalDavEngine::SetCTagL
 * set ctag
 */
void CCalDavEngine::SetCTagL(HBufC8* aToken)
	{
	if (iCTag)
		{
		delete iCTag;
		iCTag = NULL;
		}
	iCTag = aToken;
	SetCalendarInfoL(KCaldavCtag, *iCTag);
	}

/**
 * CCalDavEngine::CTag
 * get ctag
 */
TPtrC8 CCalDavEngine::CTag()
	{
	return iCTag ? *iCTag : KNullDesC8();
	}

/**
 * CCalDavEngine::SetLastSyncTimeL
 * set last sync time
 */
void CCalDavEngine::SetLastSyncTimeL()
	{
	// only set a new last sync time, if we did not have a failed one before
	// otherwise, the old one would be lost
	if (!iManualSync)
		{
		TTime time;
		time.UniversalTime();
		iLastSyncTime.SetTimeUtcL(time);
		TPckgC<TCalTime> lasttime(iLastSyncTime);
		SetCalendarInfoL(KCaldavTime, lasttime);
		}
	}

/**
 * CCalDavEngine::SyncFailedL
 * sync failed, enable manual sync
 */
void CCalDavEngine::SyncFailedL()
	{
	if (!iManualSync)
		{
		iManualSync = ETrue;
		TPckgC<TBool> manualSync(iManualSync);
		SetCalendarInfoL(KCaldavManualSync, manualSync);
		}
	}

/**
 * CCalDavEngine::GetBaseUrl
 * get base domain url
 */
void CCalDavEngine::GetBaseUrl(const TDesC8 &aUrl)
	{
	_LIT8(http,"http://");
	_LIT8(https,"https://");

	if (iBaseUrl)
		{
		delete iBaseUrl;
		iBaseUrl = NULL;
		}

	if (aUrl.Length() > http().Length())
		{
		TInt length = aUrl.Find(https) != KErrNotFound ? https().Length()
				: http().Length();
		TInt pos = aUrl.Mid(length).Locate('/');
		iBaseUrl = aUrl.Left(pos + length).Alloc();
		}
	}

/**
 * CCalDavEngine::FindUrlsL
 * find home, inbox and outbox property
 */
void CCalDavEngine::FindUrlsL(const TDesC8 &aDes, HBufC8 *&home,
		HBufC8 *&inbox, HBufC8 *&outbox)
	{
	RXmlEngDocument document = iDomParser.ParseL(aDes);
	CleanupClosePushL(document);
	if (document.NotNull())
		{
		HBufC8* status = SearchL(document, KStatus, KNullDesC8).AllocLC();
		status->Des().LowerCase();
		if (*status == KHTTP200)
			{
			TXmlEngElement calendarhome, inboxhome, outboxhome;

			SearchL(document, KCalendarHomeSet, KNullDesC8, calendarhome);
			if (calendarhome.NotNull())
				{
				TPtrC8 homeend = SearchL(calendarhome, KHref, KNullDesC8);
				home = HBufC8::NewL(iBaseUrl->Length() + homeend.Length());
				home->Des().Append(*iBaseUrl);
				home->Des().Append(homeend);
				}

			SearchL(document, KInbox, KNullDesC8, inboxhome);
			if (inboxhome.NotNull())
				{
				TPtrC8 inboxend = SearchL(inboxhome, KHref, KNullDesC8);
				inbox = HBufC8::NewL(iBaseUrl->Length() + inboxend.Length());
				inbox->Des().Append(*iBaseUrl);
				inbox->Des().Append(inboxend);
				}

			SearchL(document, KOutbox, KNullDesC8, outboxhome);
			if (outboxhome.NotNull())
				{
				TPtrC8 outboxend = SearchL(outboxhome, KHref, KNullDesC8);
				outbox = HBufC8::NewL(iBaseUrl->Length() + outboxend.Length());
				outbox->Des().Append(*iBaseUrl);
				outbox->Des().Append(outboxend);
				}
			}
		CleanupStack::PopAndDestroy(status);
		}
	CleanupStack::PopAndDestroy(&document);
	}

/**
 * CCalDavEngine::FindCalendarCollectionL
 * find all calendar collections under home url
 */
HBufC8* CCalDavEngine::FindCalendarCollectionL(const TDesC8 &aUrl,
		CDesC8ArrayFlat *aArray)
	{
	HBufC8* homecalendar = 0;

	// do propfind depth:1 and find all calendar collections
	// right now, take the first one as default
	CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
	CleanupStack::PushL(response);
	TInt retcode = iHttp->PropfindL(aUrl, KCalendarurl, response, EFalse);
	if (retcode == MULTISTATUS)
		{
		RXmlEngDocument document = iDomParser.ParseL(response->Ptr(0));
		CleanupClosePushL(document);
		if (document.NotNull() && document.DocumentElement().NotNull())
			{
			RXmlEngNodeList<TXmlEngElement> ResponseList;
			CleanupClosePushL(ResponseList);
			document.DocumentElement().GetElementsByTagNameL(ResponseList,
					KResponse, KDav);
			TBool FirstOneDone = EFalse;
			while (ResponseList.HasNext())
				{
				TXmlEngElement node = ResponseList.Next();
				TPtrC8 href = SearchL(node, KHref, KNullDesC8);
				TPtrC8 status = SearchL(node, KStatus, KNullDesC8);

				TXmlEngElement calendar;
				TXmlEngElement vevent_collection;
				TXmlEngElement vtodo_collection;
				SearchL(node, KCalendar, KNullDesC8, calendar);
				SearchL(node, KVEventCollection, KNullDesC8, vevent_collection);
				SearchL(node, KVTodoCollection, KNullDesC8, vtodo_collection);

				if (calendar.NotNull() || vevent_collection.NotNull()
						|| vtodo_collection.NotNull())
					{
					if (!FirstOneDone)
						{
						homecalendar = HBufC8::NewL(iBaseUrl->Length()
								+ href.Length());
						homecalendar->Des().Append(*iBaseUrl);
						homecalendar->Des().Append(href);

						iOptions.VEVENT = vevent_collection.NotNull();
						iOptions.VTODO = vtodo_collection.NotNull();

						FirstOneDone = ETrue;
						}

					if (aArray)
						{
						TBuf8<URLMAX> url;
						url.Append(*iBaseUrl);
						url.Append(href);
						aArray->AppendL(url);
						}
					}
				}
			CleanupStack::PopAndDestroy(&ResponseList);
			}
		CleanupStack::PopAndDestroy(&document);
		}
	CleanupStack::PopAndDestroy(response);
	return homecalendar;
	}

/**
 * CCalDavEngine::GetCalendarUrlsL
 * find calendar url based on any url
 * could be principal url, home or direct calendar url
 */
TInt CCalDavEngine::GetCalendarUrlsL(CDesC8ArrayFlat *aArray)
	{
	if (iHttp && iUrl)
		{
		HBufC8 *principal = 0;
		HBufC8 *home = 0;
		HBufC8 *homecalendar = 0;
		HBufC8 *inbox = 0;
		HBufC8 *outbox = 0;

		GetBaseUrl(*iUrl);

		// TODO: does this really find groupdav collection?

		// find out if this is a caldav or groupdav calendar collection
		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);
		CleanupStack::PushL(response);
		TInt retcode = iHttp->PropfindL(*iUrl, KCalendarurl, response);
		if (retcode == MULTISTATUS)
			{
			RXmlEngDocument document = iDomParser.ParseL(response->Ptr(0));
			CleanupClosePushL(document);
			if (document.NotNull())
				{
				HBufC8* status =
						SearchL(document, KStatus, KNullDesC8).AllocLC();
				status->Des().LowerCase();
				TXmlEngElement calendar;
				SearchL(document, KCalendar, KNullDesC8, calendar);
				// it should be <owner><href>value</href></owner>
				// but oracle beehive server does <owner>value</owner>
				TXmlEngElement owner;
				SearchL(document, KOwner, KNullDesC8, owner);
				TPtrC8 ownerref1 = SearchL(owner, KHref, KNullDesC8);
				TPtrC8 ownerref2 = owner.Value();
				TPtrC8 ownerref;
				ownerref.Set(ownerref1 != KNullDesC8 ? ownerref1 : ownerref2);

				if (calendar.NotNull() && (ownerref != KNullDesC8) && (*status
						== KHTTP200))
					{
					// this is a calendar collection and we know the principal as well now
					homecalendar = iUrl->AllocL();
					_LIT8(KHTTP,"http");
					HBufC8* http = ownerref.Left(KHTTP().Length()).AllocLC();
					if (*http == KHTTP)
						{
						// sogo server does not return relative, but principal url
						principal = ownerref.AllocL();
						}
					else
						{
						principal = HBufC8::NewL(iBaseUrl->Length()
								+ ownerref.Length());
						principal->Des().Append(*iBaseUrl);
						principal->Des().Append(ownerref);
						}
					CleanupStack::PopAndDestroy(http);
					}
				CleanupStack::PopAndDestroy(status);
				}
			CleanupStack::PopAndDestroy(&document);
			}

		// if we have principal, ask for home, otherwise see if principal was given in the first place
		if (principal)
			{
			response->Reset();
			TInt retcode =
					iHttp->PropfindL(*principal, KPrincipalurl, response);
			if (retcode == MULTISTATUS)
				{
				FindUrlsL(response->Ptr(0), home, inbox, outbox);
				}
			}
		else
			{
			response->Reset();
			TInt retcode = iHttp->PropfindL(*iUrl, KPrincipalurl, response);
			if (retcode == MULTISTATUS)
				{
				FindUrlsL(response->Ptr(0), home, inbox, outbox);
				}
			}

		home = CalDavUtils::EnsureSlashL(home);
		inbox = CalDavUtils::EnsureSlashL(inbox);
		outbox = CalDavUtils::EnsureSlashL(outbox);

		// find out all calendar collections under home
		if (home)
			{
			// TODO: temporary? we already have homecalendar...
			if (!homecalendar)
				{
				homecalendar = FindCalendarCollectionL(*home, aArray);
				}
			}
		else
			{
			// have not found out home nor a groupdav collection, maybe we are home ourselves
			homecalendar = FindCalendarCollectionL(*iUrl, aArray);
			if (homecalendar)
				home = iUrl->AllocL();
			}

		CleanupStack::PopAndDestroy(response);
		delete principal;
		delete inbox;
		delete outbox;

		if (home)
			iHome = CalDavUtils::EnsureSlashL(home);
		if (homecalendar)
			{
			delete iUrl;
			iUrl = NULL;
			iUrl = CalDavUtils::EnsureSlashL(homecalendar);
			return KErrNone;
			}
		else
			return KErrArgument;
		}
	return KErrArgument;
	}

/**
 * CCalDavEngine::CalendarName
 * get calendar name
 */
TPtrC CCalDavEngine::CalendarName() const
	{
	return iCalendar ? *iCalendar : KNullDesC();
	}

/**
 * CCalDavEngine::Home
 * get home
 */
TPtrC8 CCalDavEngine::Home() const
	{
	return iHome ? *iHome : KNullDesC8();
	}

/**
 * CCalDavEngine::Url
 * get url
 */
TPtrC8 CCalDavEngine::Url() const
	{
	return iUrl ? *iUrl : KNullDesC8();
	}

/**
 * CCalDavEngine::SetUrlL
 * set url
 */
void CCalDavEngine::SetUrlL(const TDesC8 &aUrl)
	{
	if (iUrl ? *iUrl != aUrl : ETrue)
		{
		DisableL();

		if (iUrl)
			{
			delete iUrl;
			iUrl = NULL;
			}

		iUrl = CalDavUtils::EnsureSlashL(aUrl);
		SetCalendarInfoL(KCaldavUrl, *iUrl);
		}
	}

/**
 * CCalDavEngine::User
 * get user
 */
TPtrC8 CCalDavEngine::User() const
	{
	return iHttp->User();
	}

/**
 * CCalDavEngine::SetUserL
 * set user
 */
void CCalDavEngine::SetUserL(const TDesC8 &aUser)
	{
	if (iHttp->User() != aUser)
		{
		DisableL();
		SetCalendarInfoL(KCaldavUser, aUser);
		iHttp->SetUserL(aUser);
		}
	}

/**
 * CCalDavEngine::Password
 * get password
 */
TPtrC8 CCalDavEngine::Password() const
	{
	return iHttp->Password();
	}

/**
 * CCalDavEngine::SetPasswordL
 * set password
 */
void CCalDavEngine::SetPasswordL(const TDesC8 &aPassword)
	{
	if (iHttp->Password() != aPassword)
		{
		DisableL();
		iHttp->SetPasswordL(aPassword);
		SetCalendarInfoL(KCaldavPassword, aPassword);
		}
	}

/**
 * CCalDavEngine::SyncInterval
 * get SyncInterval
 */
TTimeIntervalMinutes CCalDavEngine::SyncInterval() const
	{
	return iSyncInterval;
	}

/**
 * CCalDavEngine::SetSyncIntervalL
 * set SetSyncIntervalL
 */
void CCalDavEngine::SetSyncIntervalL(TTimeIntervalMinutes aSyncInterval)
	{
	iSyncInterval = aSyncInterval;
	TPckgC<TTimeIntervalMinutes> minutes(iSyncInterval);
	SetCalendarInfoL(KCaldavSyncInterval, minutes);
	}

/**
 * CCalDavEngine::PastDays
 * get past days
 */
TTimeIntervalDays CCalDavEngine::PastDays() const
	{
	return iPastDays;
	}

/**
 * CCalDavEngine::SetPastDaysL
 * Set PastDaysL
 */
void CCalDavEngine::SetPastDaysL(TTimeIntervalDays aDays)
	{
	iPastDays = aDays;
	TPckgC<TTimeIntervalDays> days(iPastDays);
	SetCalendarInfoL(KCaldavPastDays, days);
	}

/**
 * CCalDavEngine::ImmediateSync
 * get ImmediateSyncL
 */
TBool CCalDavEngine::ImmediateSync() const
	{
	return iImmediateSync;
	}

/**
 * CCalDavEngine::SetImmediateSyncL
 * Set ImmediateSyncL
 */
void CCalDavEngine::SetImmediateSyncL(TBool aImmediateSyc)
	{
	iImmediateSync = aImmediateSyc;
	TPckgC<TBool> immediatesync(iImmediateSync);
	SetCalendarInfoL(KCaldavImmediateSync, immediatesync);
	}

/**
 * CCalDavEngine::KeepServerEntry
 * get KeepServerEntryL
 */
TBool CCalDavEngine::KeepServerEntry() const
	{
	return iKeepServerEntry;
	}

/**
 * CCalDavEngine::SetKeepServerEntryL
 * Set KeepServerEntryL
 */
void CCalDavEngine::SetKeepServerEntryL(TBool aKeepServerEntry)
	{
	iKeepServerEntry = aKeepServerEntry;
	TPckgC<TBool> keepserver(iKeepServerEntry);
	SetCalendarInfoL(KCaldavKeepServer, keepserver);
	}

/**
 * CCalDavEngine::Timer
 * get timer
 */
CPeriodic* CCalDavEngine::Timer()
	{
	return iTimer;
	}