TB10.1 Example Applications: examples/Base/IPC/ClientServer/Simple/SimpleServer.cpp Source File

00001 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
-00002 // All rights reserved.
-00003 // This component and the accompanying materials are made available
-00004 // under the terms of "Eclipse Public License v1.0"
-00005 // which accompanies this distribution, and is available
-00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
-00007 //
-00008 // Initial Contributors:
-00009 // Nokia Corporation - initial contribution.
-00010 //
-00011 // Contributors:
-00012 //
-00013 // Description:
-00014 // The implementation of our simple server that increments and decrements a simple counter value.
-00015 // **NOTE**: The example does not demonstrate any security features - its purpose is simply
-00016 // to demonstrate the basic principles of client/server interaction.
-00017 //
-00018 
-00019 
-00020 #include "ClientServer.h"
-00021 #include "SimpleServer.h"
-00022 #include <e32svr.h>
-00023 #include <e32uid.h>
-00024 
-00025 
-00026 //**********************************
-00027 //CCountServServer - implementations
-00028 //**********************************
-00029 
-00040 CCountServServer::CCountServServer(CActive::TPriority aActiveObjectPriority)
-00041         : CServer2(aActiveObjectPriority)
-00042         {
-00043         }
-00044 
-00045 
-00049 CSession2* CCountServServer::NewSessionL(const TVersion& aVersion,const RMessage2& /*aMessage*/) const
-00050     {
-00051       // Check that the version is OK
-00052     TVersion v(KCountServMajorVersionNumber,KCountServMinorVersionNumber,KCountServBuildVersionNumber);
-00053         if (!User::QueryVersionSupported(v,aVersion))
-00054                 User::Leave(KErrNotSupported);  
-00055         
-00056         // CAN USE THE aMessage argument to check client's security and identity
-00057         // can make use of this later but for now ignore. AH 4/5/05
-00058         // the connect message is delivered via the RMessage2 object passed. 
-00059         
-00060         // do something with this later (and move it to the start of the function?)
-00061         
-00062           // Create the session.
-00063         return new (ELeave) CCountServSession;
-00064         }
-00065 
-00066 
-00070 void CCountServServer::PanicServer(TCountServPanic aPanic)
-00071         {
-00072         _LIT(KTxtServerPanic,"Count server panic");
-00073         User::Panic(KTxtServerPanic,aPanic);
-00074         }
-00075 
-00076 
-00077 //***********************************
-00078 //CCountServSession - implementations
-00079 //***********************************
-00080 
-00081 
-00085 CCountServSession::CCountServSession()
-00086         {
-00087     }
-00088 
-00092 void CCountServSession::ServiceL(const RMessage2& aMessage)
-00093         {
-00094         TRAPD(err,DispatchMessageL(aMessage));
-00095         aMessage.Complete(err);
-00096         }
-00097 
-00104 void CCountServSession::DispatchMessageL(const RMessage2& aMessage)
-00105         {
-00106         switch (aMessage.Function())
-00107         {
-00108         case ECountServSetFromString:
-00109                 SetFromStringL(aMessage);
-00110                 return;
-00111         case ECountServIncrease:
-00112                 Increase();
-00113                 return;
-00114         case ECountServIncreaseBy:
-00115                 IncreaseBy(aMessage);
-00116                 return;
-00117         case ECountServDecrease:
-00118                 Decrease();
-00119                 return;
-00120         case ECountServDecreaseBy:
-00121                 DecreaseBy(aMessage);
-00122                 return;
-00123         case ECountServReset:
-00124                 Reset();
-00125                 return;
-00126         case ECountServValue:
-00127                 CounterValueL(aMessage);
-00128                 return;
-00129           
-00130           // This is an example of a request that we know about, but don't support.
-00131           // We cause KErrNotSupported to be returned to the client.
-00132         case ECountServUnsupportedRequest:
-00133                 User::Leave(KErrNotSupported);
-00134                 
-00135          //  Requests that we don't understand at all are a different matter.
-00136          //  This is considered a client programming error, so we panic the 
-00137          //  client - this also completes the message.
-00138         default:
-00139                 PanicClient(aMessage,EBadRequest);
-00140                 return;
-00141         }
-00142         }
-00143 
-00149 void CCountServSession::SetFromStringL(const RMessage2& aMessage)
-00150         {
-00151         
-00152           // length of passed descriptor (1st parameter passed from client)
-00153         TInt deslen = aMessage.GetDesLength(0);
-00154         
-00155           // Passed data will be saved in this descriptor.
-00156     RBuf buffer;
-00157       
-00158       // Max length set to the value of "deslen", but current length is zero
-00159     buffer.CreateL(deslen);
-00160       
-00161       // Do the right cleanup if anything subsequently goes wrong
-00162     buffer.CleanupClosePushL();
-00163     
-00164       // Copy the client's descriptor data into our buffer.
-00165     aMessage.ReadL(0,buffer,0);
-00166     
-00167       // Now do a validation to make sure that the string only has digits
-00168     if (buffer.Length() == 0)
-00169         {
-00170         User::Leave(ENonNumericString);
-00171         }
-00172     
-00173     TLex16 lexer;
-00174     
-00175     lexer.Assign(buffer);
-00176     while (!lexer.Eos())
-00177         {
-00178         TChar thechar;
-00179         
-00180         thechar = lexer.Peek();
-00181         if (!thechar.IsDigit())
-00182             {
-00183                 User::Leave(ENonNumericString);
-00184             }
-00185         lexer.Inc();
-00186         }
-00187        
-00188       // Convert to a simple TInt value. 
-00189     lexer.Assign(buffer);           
-00190     if (lexer.Val(iCount))
-00191         {
-00192         User::Leave(ENonNumericString);
-00193         }
-00194         
-00195           // Clean up the memory acquired by the RBuf variable "buffer"
-00196         CleanupStack::PopAndDestroy();
-00197         }
-00198 
-00199 
-00203 void CCountServSession::Increase()
-00204         {
-00205         iCount++;
-00206         }
-00207 
-00208 
-00212 void CCountServSession::IncreaseBy(const RMessage2& aMessage)
-00213         {
-00214         iCount = iCount + aMessage.Int0();
-00215         }
-00216 
-00220 void CCountServSession::Decrease()
-00221         {
-00222         iCount--;
-00223         }
-00224 
-00225 
-00229 void CCountServSession::DecreaseBy(const RMessage2& aMessage)
-00230         {
-00231         iCount = iCount - aMessage.Int0();      
-00232         }
-00233 
-00234 
-00238 void CCountServSession::Reset()
-00239         {
-00240         iCount=0;
-00241         }
-00242 
-00243 
-00248 void CCountServSession::CounterValueL(const RMessage2& aMessage)
-00249         {
-00250         TPckgBuf<TInt> p(iCount);
-00251         aMessage.WriteL(0,p);
-00252         }
-00253 
-00254 
-00258 void CCountServSession::PanicClient(const RMessage2& aMessage,TInt aPanic) const
-00259         {
-00260         _LIT(KTxtServer,"CountServ server");
-00261         aMessage.Panic(KTxtServer,aPanic);
-00262         }
-00263 
-00264 
-00265 
-00266 //**********************************
-00267 //Global functions
-00268 //**********************************
-00269 
-00270 // The count server thread function that initialises the server.
-00271 GLDEF_C TInt CCountServServer::ThreadFunction(TAny* )
-00272         {
-00273           // get clean-up stack
-00274         CTrapCleanup* cleanup=CTrapCleanup::New();
-00275         if (cleanup == NULL)
-00276             {
-00277                 CCountServServer::PanicServer(ECreateTrapCleanup);
-00278             }
-00279         
-00280           // create an active scheduler and server
-00281         CActiveScheduler *pA=new CActiveScheduler;
-00282         __ASSERT_ALWAYS(pA!=NULL,CCountServServer::PanicServer(EMainSchedulerError));
-00283         CCountServServer *pS=new CCountServServer(EPriorityStandard);
-00284         __ASSERT_ALWAYS(pS!=NULL,CCountServServer::PanicServer(ESvrCreateServer));
-00285                 
-00286           //Install the active scheduler
-00287         CActiveScheduler::Install(pA);
-00288           
-00289           // Start the server
-00290         TInt err = pS->Start(KCountServerName);
-00291         if (err != KErrNone)
-00292             {
-00293                 CCountServServer::PanicServer(ESvrStartServer);
-00294             }
-00295         
-00296       // Let everyone know that we are ready to
-00297       // deal with requests.
-00298     RThread::Rendezvous(KErrNone);
-00299         
-00300           // And start fielding requests from client(s).
-00301         CActiveScheduler::Start();
-00302 
-00303       // Tidy up...     
-00304     delete pS;
-00305     delete pA;
-00306     delete cleanup; 
-00307     
-00308           // ...although we should never get here!
-00309         return(KErrNone);
-00310         }
-00311 
-00312 
-00320 EXPORT_C TInt StartThread(RThread& aServerThread)
-00321     {
-00322         TInt res=KErrNone;
-00323         
-00324           // Create the server, if one with this name does not already exist.
-00325         TFindServer findCountServer(KCountServerName);
-00326         TFullName   name;
-00327         
-00328           // Need to check that the server exists.
-00329         if (findCountServer.Next(name)!=KErrNone)
-00330                 {
-00331                   // Create the thread for the server.
-00332                 res=aServerThread.Create(KCountServerName,
-00333                         CCountServServer::ThreadFunction,
-00334                         KDefaultStackSize,
-00335                         KDefaultHeapSize,
-00336                         KDefaultHeapSize,
-00337                         NULL
-00338                         );
-00339                         
-00340           // The thread has been created OK so get it started - however
-00341           // we need to make sure that it has started before we continue.
-00342                 if (res==KErrNone)
-00343                         {
-00344                         TRequestStatus rendezvousStatus;
-00345                         
-00346                         aServerThread.SetPriority(EPriorityNormal);
-00347                         aServerThread.Rendezvous(rendezvousStatus);
-00348                         aServerThread.Resume();
-00349                         User::WaitForRequest(rendezvousStatus);
-00350                         }
-00351                         
-00352                   // The thread has not been created - clearly there's been a problem.
-00353                 else
-00354                         {
-00355                         aServerThread.Close();
-00356                         }
-00357                 }
-00358     return res;
-00359     }
-