--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/sit/src/sit.cpp Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,202 @@
+/*
+* Copyright (c) 2006 Nokia Corporation 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 Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Socket Interaction Thread implementation.
+*
+*/
+
+
+
+#include <e32math.h>
+#include "sit.h"
+#include "sitdeathobserver.h"
+#include "taskarrivalobserver.h"
+#include "taskhandlercreator.h"
+#include "log.h"
+
+// Exports
+
+EXPORT_C CSit::CSit(MSitDeathListener* aSitDeathListener)
+ : iTaskThread(NULL), iSitDeathListener(aSitDeathListener)
+ {
+ LOG(Log::Printf(_L("CSit::CSit\n")));
+ }
+
+EXPORT_C CSit::~CSit()
+ {
+ LOG(Log::Printf(_L("CSit::~CSit\n")));
+ delete iSitDeathObserver;
+
+ if (iTaskThread != NULL)
+ {
+ LOG(Log::Printf(_L("CSit::~CSit - closing task thread\n")));
+ iTaskThread->Close();
+ }
+ delete iTaskThread;
+ }
+
+EXPORT_C void CSit::StartL()
+ {
+ LOG(Log::Printf(_L("CSit::StartL\n")));
+
+ // Only start the thread if it is not already running
+ if (!iTaskThread)
+ {
+ LOG(Log::Printf(_L("CSit::StartL - thread not running, starting it\n")));
+ StartThreadL();
+ }
+ }
+
+EXPORT_C TThreadId CSit::ThreadId()
+ {
+ if (iTaskThread)
+ {
+ return iTaskThread->Id();
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+EXPORT_C TBool CSit::EventRequiresSit(TEventType aEventType)
+ {
+ return TaskHandlerCreator::EventRequiresSit(aEventType);
+ }
+
+EXPORT_C TEventType CSit::FindTaskRequestEventType(TEventType aCancelEventType)
+ {
+ return TaskHandlerCreator::FindTaskRequestEventType(aCancelEventType);
+ }
+
+EXPORT_C TEventType CSit::FindCancelEventType(TEventType aTaskRequestEventType)
+ {
+ return TaskHandlerCreator::FindCancelEventType(aTaskRequestEventType);
+ }
+
+EXPORT_C TBool CSit::IsTaskCancellationObservationRequest(TEventType aEventType)
+ {
+ return TaskHandlerCreator::IsTaskCancellationObservationRequest(aEventType);
+ }
+
+// Internals
+
+
+void CSit::StartThreadL()
+ {
+ LOG(Log::Printf(_L("CSit::StartThreadL\n")));
+ TName threadName(KSitName);
+
+ iTaskThread = new (ELeave) RThread;
+
+ TInt ret = iTaskThread->Create(threadName,
+ ThreadFunction,
+ KDefaultStackSize,
+ KMinHeapSize,
+ KSitMaxHeapSize,
+ this,
+ EOwnerProcess);
+
+ LOG(Log::Printf(_L("CSit::StartThreadL - iTaskThread->Create returned %d\n"), ret));
+ User::LeaveIfError(ret);
+
+ iSitDeathObserver = new (ELeave) CSitDeathObserver(iTaskThread->Id(), this);
+ iSitDeathObserver->StartObservingL();
+
+ iTaskThread->Resume();
+ }
+
+TInt CSit::ThreadFunction(TAny* aParameters)
+ {
+ LOG(Log::Printf(_L("CSit::ThreadFunction - begin\n")));
+ __UHEAP_MARK;
+
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+
+ TInt ret = KErrNoMemory;
+
+ if (cleanup)
+ {
+ CSit* const sit = STATIC_CAST(CSit*, aParameters);
+ TRAP(ret, sit->StartWorkingL());
+ delete cleanup;
+ }
+
+ __UHEAP_MARKEND;
+
+ LOG(Log::Printf(_L("CSit::ThreadFunction - end\n")));
+ return ret;
+ }
+
+void CSit::StartWorkingL()
+ {
+ LOG(Log::Printf(_L("CSit::StartWorkingL - begin\n")));
+ // Create and install the active scheduler we need
+ CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
+ CleanupStack::PushL(scheduler);
+ CActiveScheduler::Install(scheduler);
+
+ // Create the task arrival observer active object
+ CTaskArrivalObserver* taskArrivalObserver = CTaskArrivalObserver::NewL();
+ CleanupStack::PushL(taskArrivalObserver);
+
+ // Start observing task arrivals
+ taskArrivalObserver->Start();
+
+ // Start running active objects
+ CActiveScheduler::Start();
+
+ // Cleanup the task handler and scheduler
+ CleanupStack::PopAndDestroy(2); // taskArrivalObserver, scheduler
+
+ LOG(Log::Printf(_L("CSit::StartWorkingL - end\n")));
+ }
+
+void CSit::SitDied()
+ {
+ LOG(Log::Printf(_L("CSit::SitDied\n")));
+
+ if (iTaskThread != NULL)
+ {
+ iTaskThread->Close();
+ delete iTaskThread;
+ iTaskThread = NULL;
+
+ iSitDeathListener->SitDied();
+
+ // We must delete the observer object as well.
+ // With this, the StartThreadL method works
+ // correctly as it creates a new observer.
+ delete iSitDeathObserver;
+ iSitDeathObserver = NULL;
+ }
+ }
+
+HBufC16* CSit::To16BitL(const TDesC8& aDes)
+ {
+ HBufC16* desCopy;
+
+ TInt desLength = aDes.Length();
+
+ if (desLength > 0)
+ {
+ desCopy = HBufC16::NewL(desLength);
+ desCopy->Des().Copy(aDes);
+ }
+ else
+ {
+ desCopy = HBufC16::NewL(1);
+ }
+
+ return desCopy;
+ }