1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <mtp/cmtpobjectmetadata.h>

    17 #include <mtp/mtpprotocolconstants.h>

    18 

    19 #include "cmtpconnection.h"

    20 #include "cmtpdataprovider.h"

    21 #include "cmtpdataprovidercontroller.h"

    22 #include "cmtpframeworkconfig.h"

    23 #include "cmtpobjectmgr.h"

    24 #include "cmtpparserrouter.h"

    25 #include "cmtpsession.h"

    26 #include "cmtpstoragemgr.h"

    27 #include "tmtptypeobjecthandle.h"

    28 #include "cmtpservicemgr.h"

    29 

    30 // Class constants.

    31 __FLOG_STMT(_LIT8(KComponent,"ParserRouter");)

    32 

    33 /**

    34 Provides the byte size of the specified array.

    35 */

    36 #define _ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))

    37 

    38 

    39 /**

    40 CMTPParserRouter panic codes.

    41 */

    42 _LIT(KMTPPanicCategory, "CMTPParserRouter");

    43 enum TMTPPanicReasons

    44     {

    45     EMTPPanicRoutingConflict = 0

    46     };

    47     

    48 /**

    49 Produces a "CMTPParserRouter" category panic.

    50 @param aReason The panic code.

    51 */

    52 LOCAL_C void Panic(TInt aReason)

    53     {

    54     User::Panic(KMTPPanicCategory, aReason);

    55     }

    56     

    57 /**

    58 Constructor.

    59 */

    60 EXPORT_C CMTPParserRouter::TRoutingParameters::TRoutingParameters(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) :

    61     iConnection(aConnection),

    62     iRequest(aRequest),

    63     iParameters(iParameterData, ENumTypes)

    64     {

    65     Reset();

    66     }

    67         

    68     

    69 /**

    70 Copy constructor.

    71 */

    72 CMTPParserRouter::TRoutingParameters::TRoutingParameters(const TRoutingParameters& aParams) :

    73     iConnection(aParams.iConnection),

    74     iRequest(aParams.iRequest),

    75     iParameters(iParameterData, ENumTypes)

    76     {

    77     iParameters.Copy(aParams.iParameters.Begin(), aParams.iParameters.Count());

    78     }

    79 

    80 /**

    81 Provides the handle of the MTP connection on associated with the operation.

    82 @return The MTP connection handle.

    83 */    

    84 EXPORT_C MMTPConnection& CMTPParserRouter::TRoutingParameters::Connection() const

    85     {

    86     return iConnection;

    87     }

    88     

    89 /**

    90 Provides the value of the specified parameter.

    91 @param aId The parameter identifier.

    92 @return The parameter value.

    93 */

    94 EXPORT_C TUint CMTPParserRouter::TRoutingParameters::Param(CMTPParserRouter::TRoutingParameters::TParameterType aId) const

    95     {

    96     return iParameters[aId];

    97     }

    98     

    99 /**

   100 Resets all parameter values to zero.

   101 */

   102 EXPORT_C void CMTPParserRouter::TRoutingParameters::Reset()

   103     {

   104     iParameters.Reset();

   105     }

   106     

   107 /**

   108 Provides the operation dataset associated with the operation.

   109 @return The operation dataset.

   110 */

   111 EXPORT_C const TMTPTypeRequest& CMTPParserRouter::TRoutingParameters::Request() const

   112     {

   113     return iRequest;

   114     }

   115     

   116 /**

   117 Sets the value of the specified parameter.

   118 @param aId The parameter identifier.

   119 @param aVal The new parameter value.

   120 */

   121 EXPORT_C void CMTPParserRouter::TRoutingParameters::SetParam(CMTPParserRouter::TRoutingParameters::TParameterType aId, TUint aVal)

   122     {

   123     iParameters[aId] = aVal;

   124     }

   125 

   126 /**

   127 CMTPParserRouter factory method.

   128 @return A pointer to a new CMTPDataProvider instance. Ownership IS transfered.

   129 @leave One of the system wide error codes if a processing failure occurs.

   130  */

   131 CMTPParserRouter* CMTPParserRouter::NewL()

   132     {

   133     CMTPParserRouter* self = new (ELeave) CMTPParserRouter();

   134     CleanupStack::PushL(self);

   135     self->ConstructL();

   136     CleanupStack::Pop(self);

   137     return self;

   138     }

   139 

   140 /**

   141 Destructor

   142 */

   143 CMTPParserRouter::~CMTPParserRouter()

   144     {

   145     __FLOG(_L8("~CMTPParserRouter, Entry"));

   146     iMaps.ResetAndDestroy();

   147     iSingletons.Close();

   148     __FLOG(_L8("~CMTPParserRouter, Exit"));

   149     __FLOG_CLOSE;

   150     }

   151 

   152 /**

   153 Configures the parser/router. This processing primarily involves retrieving 

   154 each data provider's set of supported category codes and using them to build

   155 up the operation parameter lookup routing sub-type tables.

   156 @leave One of the system wide error codes, if a processing failure occurs.

   157 */

   158 EXPORT_C void CMTPParserRouter::ConfigureL()

   159     {

   160     __FLOG(_L8("ConfigureL, Entry"));    

   161     const TUint KMapIds[] = 

   162         {

   163         ESubTypeDevicePropCode,

   164         ESubTypeObjectPropCode,

   165         ESubTypeOperationCode,

   166         ESubTypeStorageType,

   167         ESubTypeFormatCodeFormatSubcode,

   168         ESubTypeFormatCodeOperationCode,

   169         ESubTypeStorageTypeOperationCode,

   170         ESubTypeFormatCodeFormatSubcodeStorageType,

   171         ESubTypeServiceIDOperationCode

   172         };

   173         

   174     iMaps.ResetAndDestroy();

   175     for (TUint i(0); (i < _ARRAY_SIZE(KMapIds)); i++)

   176         {

   177         const TUint KSubType(KMapIds[i]);

   178         CMap* map(CMap::NewLC(KSubType));

   179         iMaps.AppendL(map);

   180         CleanupStack::Pop(map);

   181         

   182         RArray<TUint> p1Codes;

   183         RArray<TUint> p2Codes;

   184         RArray<TUint> p3Codes;

   185         CleanupClosePushL(p1Codes);

   186         CleanupClosePushL(p2Codes);

   187         CleanupClosePushL(p3Codes);

   188         

   189         GetMapParameterIdsL(KSubType, p1Codes, p2Codes, p3Codes);

   190         

   191         const TUint KParams(KSubType & ESubTypeParamsMask);

   192         switch (KParams)

   193             {

   194         case ESubTypeParams1:

   195             Configure1ParameterMapL(KSubType, p1Codes);

   196             break;

   197             

   198         case ESubTypeParams2:

   199             Configure2ParameterMapL(KSubType, p1Codes, p2Codes);

   200             break;

   201             

   202         case ESubTypeParams3:

   203             Configure3ParameterMapL(KSubType, p1Codes, p2Codes, p3Codes);

   204             break;

   205 

   206         default:

   207             __DEBUG_ONLY(User::Invariant());

   208             break;

   209             }

   210             

   211         CleanupStack::PopAndDestroy(&p3Codes);

   212         CleanupStack::PopAndDestroy(&p2Codes);

   213         CleanupStack::PopAndDestroy(&p1Codes);

   214         }

   215         

   216     __FLOG_STMT(FLOGMapsL());

   217     __FLOG(_L8("ConfigureL, Exit"));

   218     }

   219     

   220 /**

   221 Indicates if the specified MTP operation code is supported by any of the set 

   222 of loaded data providers.

   223 @param aOperation The MTP operation code.

   224 @leave One of the system wide error codes, if a processing failure occurs.

   225 */    

   226 EXPORT_C TBool CMTPParserRouter::OperationSupportedL(TUint16 aOperation) const

   227     {

   228     __FLOG(_L8("OperationSupported, Entry"));

   229     RArray<TUint> from;

   230     RArray<TUint> to;

   231     CleanupClosePushL(from);

   232     CleanupClosePushL(to);

   233     

   234     from.AppendL(aOperation);

   235     iMaps[Index(ESubTypeOperationCode)]->GetToL(from, to);

   236     TBool ret(to.Count() > 0);

   237 

   238     CleanupStack::PopAndDestroy(&to);

   239     CleanupStack::PopAndDestroy(&from);

   240     __FLOG(_L8("OperationSupported, Exit"));

   241     return (ret);

   242     }

   243 

   244 /**

   245 Parses the operation dataset supplied in the specified routing parameters 

   246 object which encapsulates all information required to route the operation. 

   247 The parsing process involves:

   248 

   249     1.  Extracting all relevant routing information from the received operation 

   250         dataset. Note that not all parameter data is extracted, only that which 

   251         is required to route the operation.

   252     2.  Coarse grain validating the parsed data. Specifically this involves 

   253         validating that any MTP StorageID or Object Handle parameter data refers 

   254         to valid entities that exist on the device.

   255     3.    Extracting additional meta-data related to specific data objects and/or 

   256         storages referred to in the operation dataset and which is required to 

   257         route the operation.

   258         

   259 @param aParams The routing parameters object. On entry this contains the 

   260 operation dataset to be parsed and the handle of the MTP connection on which it

   261 was received. On exit this contains all information required to route the 

   262 operation. 

   263 @leave One of the system wide error codes if a processing failure occurs,

   264 */

   265 EXPORT_C void CMTPParserRouter::ParseOperationRequestL(TRoutingParameters& aParams) const

   266     {

   267     __FLOG(_L8("ParseOperationRequestL, Entry"));

   268     const TUint16 KOpCode(aParams.Request().Uint16(TMTPTypeRequest::ERequestOperationCode));

   269     __FLOG_VA((_L8("Operation Code = 0x%04X"), KOpCode));

   270     switch (KOpCode)

   271         {

   272     case EMTPOpCodeGetStorageInfo:

   273         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);

   274         break;

   275       

   276     case EMTPOpCodeGetObjectInfo:

   277     case EMTPOpCodeGetObject:

   278     case EMTPOpCodeGetThumb:

   279     case EMTPOpCodeSetObjectProtection:

   280     case EMTPOpCodeMoveObject:

   281     case EMTPOpCodeCopyObject:        

   282     case EMTPOpCodeGetPartialObject:

   283     case EMTPOpCodeGetObjectReferences:

   284     case EMTPOpCodeSetObjectReferences:

   285     case EMTPOpCodeUpdateObjectPropList :

   286     case EMTPOpCodeDeleteObjectPropList :

   287         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectHandle, aParams);

   288         break; 

   289         

   290     case EMTPOpCodeGetObjectPropValue:

   291     case EMTPOpCodeSetObjectPropValue:

   292         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectHandle, aParams);

   293         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamObjectPropCode, aParams);

   294         break; 

   295 

   296     case EMTPOpCodeDeleteObject:              

   297         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectHandle, aParams);

   298         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamFormatCode, aParams); 

   299         break;

   300         

   301     case EMTPOpCodeSendObjectInfo:

   302         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);

   303         break;

   304 

   305     case EMTPOpCodeInitiateCapture: 

   306     case EMTPOpCodeInitiateOpenCapture:

   307         {   

   308         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);

   309         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamFormatCode, aParams); 

   310         TUint format(aParams.Request().Uint32(TMTPTypeRequest::ERequestParameter2));

   311         if (format == KMTPNotSpecified32)

   312             {

   313             iSingletons.FrameworkConfig().GetValueL(MMTPFrameworkConfig::EDefaultObjectFormatCode, format);

   314             if (format == KMTPNotSpecified32)

   315                 {

   316                 format = EMTPFormatCodeUndefined;

   317                 }

   318             aParams.SetParam(TRoutingParameters::EParamFormatCode, format);

   319             }

   320         }

   321         break; 

   322  

   323     case EMTPOpCodeSendObjectPropList:

   324         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamStorageId, aParams);

   325         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter3, TRoutingParameters::EParamFormatCode, aParams); 

   326         break;  

   327         

   328     case EMTPOpCodeGetDevicePropDesc:

   329     case EMTPOpCodeGetDevicePropValue:

   330     case EMTPOpCodeSetDevicePropValue:

   331     case EMTPOpCodeResetDevicePropValue:

   332         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamDevicePropCode, aParams);

   333         break;

   334         

   335     case EMTPOpCodeGetObjectPropsSupported:

   336     case EMTPOpCodeGetInterdependentPropDesc:

   337     case EMTPOpCodeGetFormatCapabilities:

   338         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamFormatCode, aParams); 

   339         break;

   340 

   341     case EMTPOpCodeGetObjectPropDesc:

   342         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectPropCode, aParams); 

   343         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamFormatCode, aParams);

   344         break;

   345 

   346     case EMTPOpCodeGetObjectPropList:              

   347         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter2, TRoutingParameters::EParamFormatCode, aParams);

   348         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamObjectHandle, aParams);

   349         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter3, TRoutingParameters::EParamObjectPropCode, aParams);

   350         break;

   351         

   352     case EMTPOpCodeGetServiceInfo :

   353     case EMTPOpCodeGetServiceCapabilities :

   354     case EMTPOpCodeGetServicePropDesc :

   355     case EMTPOpCodeGetServicePropList :

   356     case EMTPOpCodeSetServicePropList:

   357     case EMTPOpCodeDeleteServicePropList :

   358         {

   359         ParseOperationRequestParameterL(TMTPTypeRequest::ERequestParameter1, TRoutingParameters::EParamServiceId, aParams);

   360         }

   361         break;

   362                 

   363     case EMTPOpCodeGetDeviceInfo:

   364     case EMTPOpCodeOpenSession:

   365     case EMTPOpCodeCloseSession:

   366     case EMTPOpCodeGetStorageIDs:

   367     case EMTPOpCodeGetNumObjects:

   368     case EMTPOpCodeGetObjectHandles:

   369     case EMTPOpCodeSendObject:

   370     case EMTPOpCodeFormatStore:

   371     case EMTPOpCodeResetDevice:

   372     case EMTPOpCodeSelfTest:

   373     case EMTPOpCodePowerDown:

   374     case EMTPOpCodeSetObjectPropList:

   375     case EMTPOpCodeSkip:

   376     case EMTPOpCodeGetServiceIDs:

   377         default:

   378         break;

   379         }

   380     __FLOG(_L8("ParseOperationRequestL, Exit"));

   381     }

   382 

   383 /**

   384 Routes an MTP operation using the specified routing parameters. By default 

   385 only operation parameter routing is performed.

   386 @param aParams The routing parameters.

   387 @param aTargets One exit, the set of data provider targets to which the 

   388 operation should be dispatched.

   389 @leave One of the system wide error codes if a processing failure occurs,

   390 */

   391 EXPORT_C void CMTPParserRouter::RouteOperationRequestL(const TRoutingParameters& aParams, RArray<TUint>& aTargets) const

   392     {

   393     __FLOG(_L8("RouteOperationRequestL, Entry"));

   394     aTargets.Reset();

   395     

   396     // By default ETypeOperationParameter routing is always enabled.

   397     if (!(aParams.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeOperationParameter))

   398         {

   399         const_cast<TRoutingParameters&>(aParams).SetParam(TRoutingParameters::EFlagRoutingTypes, ETypeOperationParameter);

   400         }

   401     

   402     // Get the routing and validation sub-types.

   403     RArray<TUint> routing;

   404     CleanupClosePushL(routing);

   405     RArray<TUint> validation;

   406     CleanupClosePushL(validation);

   407     RArray<TRoutingParameters> params;

   408     CleanupClosePushL(params);

   409     params.AppendL(TRoutingParameters(aParams));

   410     TRoutingParameters& param1(params[0]);

   411     GetRoutingSubTypesL(params, routing, validation);

   412     

   413     // Execute the routing sub-types.

   414     const TUint KCountParams(params.Count());

   415     for (TUint p(0); ((p < KCountParams) && (aTargets.Count() == 0)); p++)

   416         {

   417         const TRoutingParameters& KParam(params[p]);

   418         const TUint KCountRouting(routing.Count());

   419         for (TUint r(0); (r < KCountRouting); r++)

   420             {

   421             const TUint KRouting(routing[r]);

   422             if ((KRouting & ESubTypeParamsMask) == ESubTypeParams0)

   423                 {

   424                 RouteOperationRequest0ParametersL(KRouting, KParam, aTargets);

   425                 }

   426             else

   427                 {

   428                 RouteOperationRequestNParametersL(KRouting, KParam, aTargets);

   429                 }

   430             }

   431         }

   432      

   433     // Execute the validation sub-types.

   434     ValidateTargetsL(param1, validation, aTargets);

   435     const TUint KCountTargets(aTargets.Count());

   436     if ((KCountTargets == 0) && (param1.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeFramework))

   437         {

   438         SelectTargetL(iSingletons.DpController().DeviceDpId(), aTargets);

   439         }

   440     else if (KCountTargets > 1)

   441         {

   442         if (param1.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeFlagSingleTarget)

   443             {

   444             TUint target(KCountTargets);

   445             while (target-- > 1)

   446                 {

   447                 aTargets.Remove(target);

   448                 }

   449             }

   450         else if (param1.Param(TRoutingParameters::EFlagRoutingTypes) & ETypeFramework)

   451             {

   452             aTargets.Reset();

   453             SelectTargetL(iSingletons.DpController().ProxyDpId(), aTargets);

   454             }

   455         }    

   456     CleanupStack::PopAndDestroy(&params);

   457     CleanupStack::PopAndDestroy(&validation);

   458     CleanupStack::PopAndDestroy(&routing);

   459     __FLOG(_L8("RouteOperationRequestL, Exit"));

   460     }

   461 

   462 /**

   463 Indicates if a routing request with the specified MTP operation code is 

   464 registered on the specified session.

   465 @param aRequest The MTP operation requesty dataset specifying MTP operation 

   466 code and session.

   467 @param aConnection The handle of the MTP connection on which the operation

   468 request is expected to be received.

   469 @return ETrue if a routing request with the specified MTP operation code is 

   470 registered on the session, otherwise EFalse.

   471 @leave One of the system wide error codes, if a processing failure occurs.

   472 */

   473 EXPORT_C TBool CMTPParserRouter::RouteRequestRegisteredL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const

   474     {

   475     __FLOG(_L8("RouteRequestRegistered, Entry"));

   476     TBool ret(EFalse);

   477     const TUint32 KSessionId(aRequest.Uint32(TMTPTypeRequest::ERequestSessionID));

   478     if ((KSessionId != KMTPSessionAll) && (aConnection.SessionWithMTPIdExists(KSessionId)))

   479         {

   480         CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(KSessionId)));

   481         ret = session.RouteRequestRegistered(aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode));

   482         }

   483     __FLOG(_L8("RouteRequestRegistered, Exit"));

   484     return ret;

   485     }

   486    

   487 /**

   488 Routes and dispatches the specified MTP event dataset. The only valid event 

   489 that is accepted is CancelTransaction, all other event types are discarded. 

   490 Events are routed to the same target to which the currently active operation 

   491 was dispatched. If there is no active transaction in progress then the event 

   492 will be discarded.

   493 @param aEvent The MTP event dataset.

   494 @param aConnection The MTP connection on which the event was received.

   495 @leave One of the system wide error codes, if a processing failure occurs.

   496 */

   497 void CMTPParserRouter::ProcessEventL(const TMTPTypeEvent& aEvent, CMTPConnection& aConnection) const

   498     {

   499     __FLOG(_L8("ProcessEventL, Entry"));

   500     if ((aEvent.Uint16(TMTPTypeEvent::EEventCode) == EMTPEventCodeCancelTransaction) &&

   501         (aConnection.SessionWithMTPIdExists(aEvent.Uint32(TMTPTypeEvent::EEventSessionID))))

   502         {

   503         CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(aEvent.Uint32(TMTPTypeEvent::EEventSessionID))));

   504         if (session.TransactionPhase() != EIdlePhase)

   505             {    

   506             iSingletons.DpController().DataProviderL(RoutingTargetL(session.ActiveRequestL(), aConnection)).ExecuteEventL(aEvent, aConnection);

   507             }

   508         }

   509     __FLOG(_L8("ProcessEventL, Exit"));

   510     }

   511    

   512 /**

   513 Routes and dispatches the specified MTP operation (request) dataset.

   514 @param aRequest The MTP operation (request) dataset.

   515 @param aConnection The MTP connection on which the event was received.

   516 @leave One of the system wide error codes, if a processing failure occurs.

   517 */

   518 void CMTPParserRouter::ProcessRequestL(const TMTPTypeRequest& aRequest, CMTPConnection& aConnection) const

   519     {

   520     __FLOG(_L8("ProcessRequestL, Entry")); 

   521     iSingletons.DpController().DataProviderL(RoutingTargetL(aRequest, aConnection)).ExecuteRequestL(aRequest, aConnection);

   522     __FLOG(_L8("ProcessRequestL, Exit"));

   523     }

   524 

   525 /**

   526 Registers the calling data provider to receive one or more occurrences of 

   527 the specified request dataset that are received on the specified connection.

   528 @param aRequest The operation request dataset being registered.

   529 @param aConnection The handle of the MTP connection on which the operation

   530 request is expected to be received.

   531 @param aId The data provider identifier.

   532 @leave One of the system wide error codes, if a processing failure occurs.

   533 @see MMTPDataProviderFramework::RouteRequestRegisterL

   534 */

   535 void CMTPParserRouter::RouteRequestRegisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection, TInt aId)

   536     {

   537     __FLOG(_L8("RouteRequestRegisterL, Entry"));

   538     const TUint32 KSessionId(aRequest.Uint32(TMTPTypeRequest::ERequestSessionID));

   539     if (KSessionId == KMTPSessionAll)

   540         {

   541         // Register the request on all sessions.

   542         const TUint KNumSessions(aConnection.SessionCount());

   543         TUint count(0);

   544         TUint sessionId(1);

   545         while (count < KNumSessions)

   546             {

   547             // Insert the correct session id into a copy of the request and register this copy with the session

   548             if (aConnection.SessionWithMTPIdExists(sessionId))

   549                 {

   550                 // Session exists

   551                 count++;

   552                 TMTPTypeRequest req(aRequest);

   553                 req.SetUint32(TMTPTypeRequest::ERequestSessionID, sessionId);

   554                 CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(sessionId)));

   555                 session.RouteRequestRegisterL(req, aId);

   556                 }

   557             sessionId++;

   558             }

   559         }

   560     else

   561         {

   562         CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(KSessionId)));

   563         session.RouteRequestRegisterL(aRequest, aId);

   564         }

   565     __FLOG(_L8("RouteRequestRegisterL, Exit"));

   566     }

   567 

   568 /**

   569 Cancels a pending RouteRequestRegisterL registration.

   570 @param aRequest The registered operation request dataset.

   571 @param aConnection The handle of the MTP connection for which the operation

   572 request was registered.

   573 @leave One of the system wide error codes, if a general processing error

   574 occurs.

   575 @see MMTPDataProviderFramework::RouteRequestUnregisterL

   576 */

   577 void CMTPParserRouter::RouteRequestUnregisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)

   578     {

   579     __FLOG(_L8("RouteRequestUnregisterL, Entry"));

   580     CMTPSession& session(static_cast<CMTPSession&>(aConnection.SessionWithMTPIdL(aRequest.Uint32(TMTPTypeRequest::ERequestSessionID))));

   581     session.RouteRequestUnregister(aRequest);

   582     __FLOG(_L8("RouteRequestUnregisterL, Exit"));

   583     }

   584 

   585 /**

   586 Constructor.

   587 @param aFrom The map source parameter.

   588 */

   589 CMTPParserRouter::TMap::TMap(TUint aFrom) :

   590     iFrom(aFrom),

   591     iSubType(0),

   592     iTo(0)

   593     {

   594 

   595     }

   596 

   597 /**

   598 Constructor.

   599 @param aFrom The map source parameter.

   600 @param aTo The map target.

   601 @param aSubType The map routing sub-type code (@see CMTPParserRouter::TRoutingSubType).

   602 */

   603 CMTPParserRouter::TMap::TMap(TUint aFrom, TUint aTo, TUint aSubType) :

   604     iFrom(aFrom),

   605     iSubType(aSubType),

   606     iTo(aTo)

   607     {

   608 

   609     }

   610 

   611 /**

   612 CMTPParserRouter::CMap factory method.

   613 @param aSubType The map routing sub-type code (@see CMTPParserRouter::TRoutingSubType).

   614 @leave One of the system wide error codes, if a general processing error 

   615 occurs.

   616 */

   617 CMTPParserRouter::CMap* CMTPParserRouter::CMap::NewLC(TUint aSubType)

   618     {

   619     return NewLC(0, aSubType);

   620     }

   621 

   622 /**

   623 Destructor.

   624 */

   625 CMTPParserRouter::CMap::~CMap()

   626     {

   627     if (Params(iSubType) == ESubTypeParams1)

   628         {

   629         iToNodes.Reset();

   630         }

   631     else

   632         {

   633         iToBranches.ResetAndDestroy();

   634         }

   635     __FLOG_CLOSE;

   636     }

   637     

   638 /**

   639 Provides the map source parameter.

   640 @return The map source parameter.

   641 */

   642 TUint CMTPParserRouter::CMap::From() const

   643     {

   644     return iFrom;

   645     }

   646     

   647 /**

   648 Initialises a map source parameter set array.

   649 @param aFrom On exit, the initialised map source parameter set array.

   650 @leave One of the system wide error codes, if a general processing error 

   651 occurs.

   652 

   653 */

   654 void CMTPParserRouter::CMap::InitParamsL(RArray<TUint>& aFrom) const

   655     {

   656     aFrom.Reset();

   657     TUint KCount(ParamsCount(iSubType));

   658     for (TUint i(0); (i < KCount); i++)

   659         {

   660         aFrom.AppendL(0);

   661         }

   662     }

   663 

   664 /**

   665 Inserts an entry into the map table with the specified source and target 

   666 parameters.

   667 @param aFrom The map source parameter set array.

   668 @param aFrom The map target parameter.

   669 @leave One of the system wide error codes, if a general processing error 

   670 occurs.

   671 */

   672 void CMTPParserRouter::CMap::InsertL(const RArray<TUint>& aFrom, TUint aTo)

   673     {

   674     const TUint KFrom(Param(aFrom));

   675     if (Params(iSubType) == ESubTypeParams1)

   676         {

   677         // Node.

   678         __FLOG_STMT(FLOGMapEntryL(aFrom, aTo));

   679         const TUint KSubType(CMTPParserRouter::SubType(Index(iSubType), Flags(iSubType), (ParamsCount(iSubType) - 1)));

   680         const TMap KNode(KFrom, aTo, KSubType);

   681         NodeInsertL(KNode);

   682         }

   683     else

   684         {

   685         // Branch.

   686         TInt idx(BranchFind(KFrom));

   687         if (idx == KErrNotFound)

   688             {

   689             idx = BranchInsertL(KFrom);

   690             __ASSERT_DEBUG((idx != KErrNotFound), User::Invariant());

   691             }

   692         iToBranches[idx]->InsertL(aFrom, aTo);

   693         }

   694     }

   695 

   696 /**

   697 Provides the set of targets which map from the specified source parameters.

   698 @param aFrom The map source parameters.

   699 @param aTo The map target parameter set.

   700 @leave One of the system wide error codes, if a general processing error 

   701 occurs.

   702 */

   703 void CMTPParserRouter::CMap::GetToL(const RArray<TUint>& aFrom, RArray<TUint>& aTo) const

   704     {

   705     __FLOG(_L8("CMap::GetToL - entry"));

   706     const TUint KFrom(Param(aFrom));

   707     if (KFrom == KMTPNotSpecified32)

   708         {

   709         // Null (zero) parameter acts as a wildcard.

   710         SelectTargetAllL(aFrom, aTo);

   711         }

   712     else if (Flags(iSubType) & ESubTypeFlagEnableDuplicates)

   713         {

   714         // Select 0 .. n matching targets.

   715         SelectTargetMatchingL(aFrom, aTo);

   716         }

   717     else

   718         {

   719         // Select 0 .. 1 matching targets.

   720         SelectTargetSingleL(aFrom, aTo);

   721         }

   722 	__FLOG(_L8("CMap::GetToL - Exit"));        

   723     }

   724     

   725 /**

   726 Provides the map subtype code.

   727 @return The map subtype code.

   728 */

   729 TUint CMTPParserRouter::CMap::SubType() const

   730     {

   731     return iSubType;

   732     }

   733 

   734 #ifdef __FLOG_ACTIVE

   735 /**

   736 Logs the map table entries (source and target) which match the specified source 

   737 parameters.

   738 @param aFrom The map source parameters.

   739 @leave One of the system wide error codes, if a general processing error 

   740 occurs.

   741 */  

   742 void CMTPParserRouter::CMap::FLOGMapL(RArray<TUint>& aFrom) const

   743     {

   744     if (Params(iSubType) == ESubTypeParams1)

   745         {

   746         // Node.

   747         const TUint KCount(iToNodes.Count());

   748         for (TUint i(0); (i < KCount); i++)

   749             {

   750             aFrom[ParamIdx(aFrom)] = iToNodes[i].iFrom;

   751             FLOGMapEntryL(aFrom, iToNodes[i].iTo);

   752             }

   753         }

   754     else 

   755         {

   756         // Branch.

   757         const TUint KCount(iToBranches.Count());

   758         for (TUint i(0); (i < KCount); i++)

   759             {

   760             const CMap& KBranch(*iToBranches[i]);

   761             aFrom[ParamIdx(aFrom)] = KBranch.iFrom;

   762             KBranch.FLOGMapL(aFrom);

   763             }

   764         }

   765     }

   766     

   767 /**

   768 Logs the specified source and target map table entry parameters.

   769 @param aFrom The map source parameters.

   770 @param aTo The map target parameter.

   771 @leave One of the system wide error codes, if a general processing error 

   772 occurs.

   773 */

   774 void CMTPParserRouter::CMap::FLOGMapEntryL(const RArray<TUint>& aFrom, TUint aTo) const

   775     {

   776     __ASSERT_DEBUG((aFrom.Count() >= ParamsCount(iSubType)), User::Invariant());

   777     RBuf log;

   778     log.CleanupClosePushL();

   779     const TUint KParamsCount(aFrom.Count());

   780     const TUint KWidthFrom(8);

   781     const TUint KWidthTo(2);

   782     const TUint KLength((KParamsCount * 11) + 7);

   783     log.CreateL(KLength);

   784     for (TUint i(0); (i < KParamsCount); i++)

   785         {

   786         log.Append(_L("0x"));

   787         log.AppendNumFixedWidthUC(aFrom[i], EHex, KWidthFrom);

   788         log.Append(_L(" "));

   789         }

   790     log.Append(_L("-> 0x"));

   791     log.AppendNumFixedWidthUC(aTo, EHex, KWidthTo);

   792     __FLOG(log);

   793     CleanupStack::PopAndDestroy(&log);

   794     }

   795 #endif

   796 

   797 /**

   798 CMTPParserRouter::CMap factory method.

   799 @param aFrom The map source parameter.

   800 @param aTo The map target parameter.

   801 @leave One of the system wide error codes, if a general processing error 

   802 occurs.

   803 */

   804 CMTPParserRouter::CMap* CMTPParserRouter::CMap::NewLC(TUint aFrom, TUint aSubType)

   805     {

   806     CMap* self(new(ELeave) CMap(aFrom, aSubType));

   807     CleanupStack::PushL(self);

   808     self->ConstructL();

   809     return self;

   810     }

   811     

   812 /**

   813 Constructor.

   814 @param aFrom The map source parameter.

   815 @param aTo The map target parameter.

   816 */

   817 CMTPParserRouter::CMap::CMap(TUint aFrom, TUint aSubType) :

   818     iFrom(aFrom),

   819     iSubType(aSubType)

   820     {

   821 

   822     }

   823     

   824 /**

   825 Second-phase constructor.

   826 */

   827 void CMTPParserRouter::CMap::ConstructL()

   828     {

   829     __FLOG_OPEN(KMTPSubsystem, KComponent);

   830     }

   831     

   832 /**

   833 Locates the map branch table index of the first map table entry matching the 

   834 specified source parameter, using a binary search algorithm.

   835 @param aFrom The map source parameter,

   836 @return The map node table index of the first matching entry, or KErrNotFound 

   837 if no matching entry is found.

   838 */

   839 TInt CMTPParserRouter::CMap::BranchFind(TUint aFrom) const

   840     {

   841     return (iToBranches.FindInOrder(aFrom, ((Flags(iSubType) & ESubTypeFlagOrderDescending) ? BranchOrderFromKeyDescending : BranchOrderFromKeyAscending)));

   842     }

   843     

   844 /**

   845 Inserts a new map branch table with the specified source parameter.

   846 @param aFrom The map source paramete.

   847 @return The map branch table index of the new entry.

   848 @leave One of the system wide error codes, if a general processing error 

   849 occurs.

   850 */

   851 TUint CMTPParserRouter::CMap::BranchInsertL(TUint aFrom)

   852     {

   853     CMap* branch(CMap::NewLC(aFrom, CMTPParserRouter::SubType(Index(iSubType), Flags(iSubType), (ParamsCount(iSubType) - 1))));

   854     TLinearOrder<CMap> KOrder((iSubType & ESubTypeFlagOrderDescending) ? BranchOrderFromDescending : BranchOrderFromAscending);

   855     iToBranches.InsertInOrderL(branch, KOrder);

   856     CleanupStack::Pop(branch);

   857     return iToBranches.FindInOrder(branch, KOrder);

   858     }

   859     

   860 /**

   861 Locates the map node table index of the first map table entry matching the 

   862 specified source parameter, using a binary search algorithm.

   863 @param aFrom The source parameter,

   864 @return The map node table index of the first matching entry, or KErrNotFound 

   865 if no matching entry is found.

   866 */

   867 TInt CMTPParserRouter::CMap::NodeFind(TUint aFrom) const

   868     {

   869     return (iToNodes.FindInOrder(aFrom, ((Flags(iSubType) & ESubTypeFlagOrderDescending) ? NodeOrderFromKeyDescending : NodeOrderFromKeyAscending)));

   870     }

   871     

   872 /**

   873 Locates the map node table index of the  map table entry matching the specified

   874 node, using a binary search algorithm.

   875 @param aFrom The map node table entry.

   876 @return The map node table index, or KErrNotFound if no matching entry is 

   877 found.

   878 */

   879 TInt CMTPParserRouter::CMap::NodeFind(const TMap& aNode) const

   880     {

   881     return iToNodes.FindInOrder(aNode, ((Flags(iSubType) & ESubTypeFlagOrderDescending) ? NodeOrderFromToDescending : NodeOrderFromToAscending));

   882     }

   883     

   884 /**

   885 Inserts the specified map node into the map node table.

   886 @param aFrom The map node table entry.

   887 @return The map node table index of the new entry.

   888 @leave One of the system wide error codes, if a general processing error 

   889 occurs.

   890 */

   891 TUint CMTPParserRouter::CMap::NodeInsertL(const TMap& aMap)

   892     {   

   893     TLinearOrder<TMap> KOrder((iSubType & ESubTypeFlagOrderDescending) ? NodeOrderFromToDescending : NodeOrderFromToAscending);

   894     if (Flags(iSubType) & ESubTypeFlagEnableDuplicates)

   895         {

   896         // Duplicates allowed, but discard completely duplicated routes.

   897         if (NodeFind(aMap) == KErrNotFound) 

   898             {

   899             iToNodes.InsertInOrderL(aMap, KOrder);

   900             }

   901         }

   902     else

   903         {

   904         TInt err(iToNodes.InsertInOrder(aMap, KOrder));

   905         if (err == KErrAlreadyExists)

   906             {

   907             Panic(EMTPPanicRoutingConflict);

   908             }

   909         else

   910             {

   911             User::LeaveIfError(err);

   912             }

   913         }

   914     const TInt KIdx(NodeFind(aMap));

   915     __ASSERT_DEBUG((KIdx != KErrNotFound), User::Invariant());

   916     return KIdx;

   917     }

   918     

   919 /**

   920 Provides the source parameter value from the specified source parameter set 

   921 appropriate to the parameter level of the map.

   922 @param aFrom The map source parameter set.

   923 @return The parameter value.

   924 */

   925 TUint CMTPParserRouter::CMap::Param(const RArray<TUint>& aFrom) const

   926     {

   927     return (aFrom[ParamIdx(aFrom)]);

   928     }

   929     

   930 /**

   931 Provides the source parameter set index of the source parameter corresponding to the 

   932 parameter level of the map.

   933 @param aFrom The map source parameter set.

   934 @return The parameter set index.

   935 */

   936 TUint CMTPParserRouter::CMap::ParamIdx(const RArray<TUint>& aFrom) const

   937     {

   938     return (aFrom.Count() - ParamsCount(iSubType));

   939     }

   940 

   941 /**

   942 Selects all map targets at the parameter level of the map.

   943 @param aFrom The map source parameter set.

   944 @param aTo The matching target parameters.

   945 @leave One of the system wide error codes, if a general processing error 

   946 occurs.

   947 */

   948 void CMTPParserRouter::CMap::SelectTargetAllL(const RArray<TUint>& aFrom, RArray<TUint>& aTo) const

   949     {

   950     if (Params(iSubType) == ESubTypeParams1)

   951         {

   952         // Node.

   953         const TUint KCount(iToNodes.Count());

   954         for (TUint idx(0); (idx < KCount); idx++)

   955             {

   956             SelectTargetL(iToNodes[idx].iTo, aTo);

   957             }

   958         }

   959     else

   960         {

   961         // Branch.

   962         const TUint KCount(iToBranches.Count());

   963         for (TUint idx(0); (idx < KCount); idx++)

   964             {

   965             iToBranches[idx]->GetToL(aFrom, aTo);

   966             }

   967         }

   968     }

   969 

   970 /**

   971 Selects all map targets which match the specified source parameters.

   972 @param aFrom The map source parameter set.

   973 @param aTo The matching target parameters.

   974 @leave One of the system wide error codes, if a general processing error 

   975 occurs.

   976 */

   977 void CMTPParserRouter::CMap::SelectTargetMatchingL(const RArray<TUint>& aFrom, RArray<TUint>& aTo) const

   978     {

   979     __FLOG(_L8("CMap::SelectTargetMatchingL - entry"));

   980     const TUint KFrom(Param(aFrom));

   981     TInt idx(KErrNotFound);

   982     if (Params(iSubType) == ESubTypeParams1)

   983         {

   984         idx = iToNodes.SpecificFindInOrder(TMap(KFrom), ((iSubType & ESubTypeFlagOrderDescending) ? NodeOrderFromDescending : NodeOrderFromAscending), EArrayFindMode_First);                

   985         if (idx != KErrNotFound)

   986             {

   987             const TUint KCount(iToNodes.Count());

   988             while ((idx < KCount) && (iToNodes[idx].iFrom == KFrom))

   989                 {

   990                 SelectTargetL(iToNodes[idx++].iTo, aTo);

   991                 }

   992             }

   993         }

   994     else

   995         {

   996         CMap* from(CMap::NewLC(KFrom, iSubType));

   997         idx = iToBranches.SpecificFindInOrder(from, ((iSubType & ESubTypeFlagOrderDescending) ? BranchOrderFromDescending : BranchOrderFromAscending), EArrayFindMode_First);

   998         CleanupStack::PopAndDestroy(from);

   999         const TUint KCount(iToBranches.Count());

  1000         while ((idx < KCount) && (iToBranches[idx]->From() == KFrom))

  1001             {

  1002             iToBranches[idx++]->GetToL(aFrom, aTo);

  1003             }

  1004         }

  1005 	__FLOG(_L8("CMap::SelectTargetMatchingL - exit"));        

  1006     }

  1007 

  1008 /**

  1009 Selects the first map target which matches the specified source parameters.

  1010 @param aFrom The map source parameter set.

  1011 @param aTo The matching target parameters.

  1012 @leave One of the system wide error codes, if a general processing error 

  1013 occurs.

  1014 */

  1015 void CMTPParserRouter::CMap::SelectTargetSingleL(const RArray<TUint>& aFrom, RArray<TUint>& aTo) const

  1016     {

  1017     const TUint KFrom(Param(aFrom));

  1018     TInt idx(KErrNotFound);

  1019     if (Params(iSubType) == ESubTypeParams1)

  1020         {

  1021         idx = NodeFind(KFrom);

  1022         if (idx != KErrNotFound)

  1023             {

  1024             SelectTargetL(iToNodes[idx].iTo, aTo);

  1025             }

  1026         }

  1027     else

  1028         {

  1029         idx = BranchFind(KFrom);

  1030         if (idx != KErrNotFound)

  1031             {

  1032             iToBranches[idx]->GetToL(aFrom, aTo);

  1033             }

  1034         }

  1035     }

  1036     

  1037 /**

  1038 Implements an @see TLinearOrder relation for @see CMTPParserRouter::CMap 

  1039 branch map objects based on ascending map source parameter order.

  1040 @param aL The first object instance.

  1041 @param aR The second object instance.

  1042 @return Zero, if the two objects are equal; A negative value, if the first 

  1043 object is less than the second, or; A positive value, if the first object is 

  1044 greater than the second.

  1045 */

  1046 TInt CMTPParserRouter::CMap::BranchOrderFromAscending(const CMap& aL, const CMap& aR)

  1047     {

  1048     return (aL.iFrom - aR.iFrom);

  1049     }

  1050     

  1051 /**

  1052 Implements an @see TLinearOrder relation for @see CMTPParserRouter::CMap 

  1053 branch map objects based on descending map source parameter order.

  1054 @param aL The first object instance.

  1055 @param aR The second object instance.

  1056 @return Zero, if the two objects are equal; A positive value, if the first 

  1057 object is less than the second, or; A negative value, if the first object is 

  1058 greater than the second.

  1059 */

  1060 TInt CMTPParserRouter::CMap::BranchOrderFromDescending(const CMap& aL, const CMap& aR)

  1061     {

  1062     return (aR.iFrom - aL.iFrom);

  1063     }

  1064     

  1065 /**

  1066 Implements a map source parameter key identity relation for 

  1067 @see CMTPParserRouter::CMap branch map objects based on ascending key order.

  1068 @param aL The first object instance.

  1069 @param aR The second object instance.

  1070 @return Zero, if the two objects are equal; A negative value, if the first 

  1071 object is less than the second, or; A positive value, if the first object is 

  1072 greater than the second.

  1073 */

  1074 TInt CMTPParserRouter::CMap::BranchOrderFromKeyAscending(const TUint* aL, const CMap& aR)

  1075     {

  1076     return (*aL - aR.iFrom);

  1077     }

  1078     

  1079 /**

  1080 Implements a map source parameter key identity relation for 

  1081 @see CMTPParserRouter::CMap branch map objects based on descending key order.

  1082 @param aL The first object instance.

  1083 @param aR The second object instance.

  1084 @return Zero, if the two objects are equal; A positive value, if the first 

  1085 object is less than the second, or; A negative value, if the first object is 

  1086 greater than the second.

  1087 */

  1088 TInt CMTPParserRouter::CMap::BranchOrderFromKeyDescending(const TUint* aL, const CMap& aR)

  1089     {

  1090     return (aR.iFrom - *aL);

  1091     }

  1092     

  1093 /**

  1094 Implements an @see TLinearOrder relation for @see CMTPParserRouter::TMap 

  1095 node map objects based on ascending map source parameter order.

  1096 @param aL The first object instance.

  1097 @param aR The second object instance.

  1098 @return Zero, if the two objects are equal; A negative value, if the first 

  1099 object is less than the second, or; A positive value, if the first object is 

  1100 greater than the second.

  1101 */

  1102 TInt CMTPParserRouter::CMap::NodeOrderFromAscending(const TMap& aL, const TMap& aR)

  1103     {

  1104     return (aL.iFrom - aR.iFrom);

  1105     }

  1106     

  1107 /**

  1108 Implements an @see TLinearOrder relation for @see CMTPParserRouter::TMap 

  1109 node map objects based on descending map source parameter order.

  1110 @param aL The first object instance.

  1111 @param aR The second object instance.

  1112 @return Zero, if the two objects are equal; A positive value, if the first 

  1113 object is less than the second, or; A negative value, if the first object is 

  1114 greater than the second.

  1115 */

  1116 TInt CMTPParserRouter::CMap::NodeOrderFromDescending(const TMap& aL, const TMap& aR)

  1117     {

  1118     return (aR.iFrom - aL.iFrom);

  1119     }

  1120     

  1121 /**

  1122 Implements a map source parameter key identity relation for 

  1123 @see CMTPParserRouter::TMap node map objects based on ascending key order.

  1124 @param aL The first object instance.

  1125 @param aR The second object instance.

  1126 @return Zero, if the two objects are equal; A negative value, if the first 

  1127 object is less than the second, or; A positive value, if the first object is 

  1128 greater than the second.

  1129 */

  1130 TInt CMTPParserRouter::CMap::NodeOrderFromKeyAscending(const TUint* aL, const TMap& aR)

  1131     {

  1132     return (*aL - aR.iFrom);

  1133     }

  1134