1 /*

     2 * Copyright (c) 2003 - 2004 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 /**

    22  *

    23  * @file    XPFParser.cpp

    24  *

    25  * @internal

    26  *

    27  */

    28 

    29 #include "j2me/midp2/security/MPermission.h"

    30 #include "ConnectionFilterType.h"

    31 #include "FunctionGroup.h"

    32 #include "FunctionGroupBinding.h"

    33 #include "FileSystemAccessPolicy.h"

    34 #include "DriveAccessPolicy.h"

    35 #include "PathAccessPolicy.h"

    36 #include "ProtectionDomain.h"

    37 #include "SecurityPolicy.h"

    38 #include "XPFParser.h"

    39 #include "BlanketPermissionPolicy.h"

    40 #include "BlanketPermissionPolicyElement.h"

    41 #include <j2me/jdebug.h>

    42 

    43 #define MAX_LENGTH_DG_POLICY 40

    44 

    45 namespace MIDP

    46 {

    47 

    48 CXPFParser* CXPFParser::NewLC(RFile& aFile, CSecurityPolicy& aPolicy)

    49 {

    50     CXPFParser* xpfp = new(ELeave) CXPFParser(aFile, aPolicy);

    51 

    52     CleanupStack::PushL(xpfp);

    53     xpfp->ConstructL();

    54     return xpfp;

    55 }

    56 

    57 CXPFParser::CXPFParser(RFile& aFile, CSecurityPolicy& aPolicy):

    58         iFile(aFile),

    59         iPolicy(aPolicy)

    60 {

    61 }

    62 

    63 CXPFParser::~CXPFParser()

    64 {

    65     iFile.Close();

    66     iFunctionGroups.Close();

    67     delete iFileBuffer;

    68     delete iBuffer;

    69     delete iFunctionGroupName;

    70 }

    71 

    72 const TUint32 KFileBufferSize = 8192;

    73 

    74 const TUint32 KLineBufferSize = 256;

    75 

    76 void CXPFParser::ConstructL(void)

    77 {

    78     iFileBuffer = HBufC8::NewL(KFileBufferSize);

    79     iBuffer = HBufC::NewL(KLineBufferSize);

    80 }

    81 

    82 _LIT(KFormatVersion, "FormatVersion: 1.0");

    83 _LIT(KBlanket,  "Blanket");

    84 _LIT(KOneshot,  "Oneshot");

    85 _LIT(KSession,  "Session");

    86 _LIT(KNo,       "No");

    87 

    88 // Policy := Misc* FormatVersion Domains FunctionGroups Bindings Misc*

    89 

    90 void CXPFParser::ParseL(void)

    91 {

    92     MiscL();

    93     EnsureL(*iBuffer, KFormatVersion);

    94     DomainsL();

    95     FunctionGroupsL();

    96     BindingsL();

    97     while (ReadLineL() != -1)

    98     {

    99         if ((iLineLength > 0) && ((*iBuffer)[0] != '#'))

   100         {

   101             UnexpectedL(ECommentOrNewline, *iBuffer);

   102         }

   103     }

   104 }

   105 

   106 //

   107 // Domains := Misc* ^'Domains' NewLine (Misc* Domain NewLine+)+  ^'EndDomain' NewLine

   108 //

   109 

   110 _LIT(KDomains,    "Domains");

   111 _LIT(KEndDomains, "EndDomains");

   112 

   113 void CXPFParser::DomainsL(void)

   114 {

   115     MiscL();

   116     EnsureL(*iBuffer, KDomains);

   117     for (;;)

   118     {

   119         MiscL();

   120         DomainL();

   121         if (*iBuffer == KEndDomains)

   122         {

   123             break;

   124         }

   125         iNextLine = ETrue;

   126     }

   127 }

   128 

   129 //

   130 // Domain := WS* 'Domain:' WS+ DomainName (NewLine ConnectionFilters 'EndDomain')? NewLine

   131 //

   132 // ConnectionFilters := WS* 'ConnectionFilters' NewLine

   133 //                                (Misc* ConnectionFilter NewLine+)+

   134 //                      WS* 'EndConnectionFilters' NewLine

   135 //

   136 

   137 _LIT(KDomain,               "Domain:");

   138 _LIT(KEndDomain,            "EndDomain");

   139 _LIT(KUntrusted,            "[UNTRUSTED]");

   140 _LIT(KConnectionFilters,    "ConnectionFilters");

   141 _LIT(KEndConnectionFilters, "EndConnectionFilters");

   142 _LIT(KFileAccess,           "FileAccess");

   143 _LIT(KEndFileAccess,        "EndFileAccess");

   144 _LIT(KBlanketPermission,    "BlanketPermission");

   145 _LIT(KEndBlanketPermission, "EndBlanketPermission");

   146 

   147 void CXPFParser::DomainL(void)

   148 {

   149     EnsureTokenL(KDomain);

   150     switch (TokenL())

   151     {

   152     case EString:

   153 

   154         if (iPolicy.FindProtectionDomain(iToken) != NULL)

   155         {

   156             DuplicateDeclarationL(EDomain, iToken);

   157         }

   158         iCurrentDomain = iPolicy.AddProtectionDomainL(iToken);

   159         break;

   160 

   161     case ESymbol:

   162 

   163         if (iToken == KUntrusted)

   164         {

   165             if (iUntrustedDomain != NULL)

   166             {

   167                 DuplicateDeclarationL(EUntrustedDomain, iToken);

   168             }

   169             iUntrustedDomain = iPolicy.AddUntrustedProtectionDomainL();

   170             iCurrentDomain   = iUntrustedDomain;

   171             break;

   172         }

   173 

   174         // Fall-through

   175 

   176     default:

   177 

   178         UnexpectedL(EDomainName, iToken);

   179     }

   180     NewLinePlusL();

   181     TokenL();

   182 

   183     TBool endDomainExpected = EFalse;

   184 

   185     if (iToken == KConnectionFilters)

   186     {

   187         ConnectionFiltersL();

   188         endDomainExpected = ETrue;

   189         TokenL();

   190     }

   191 

   192     if (iToken == KFileAccess)

   193     {

   194         FileAccessL();

   195         endDomainExpected = ETrue;

   196         TokenL();

   197     }

   198 

   199     if (iToken == KBlanketPermission)

   200     {

   201         BlanketPermissionL();

   202         endDomainExpected = ETrue;

   203         TokenL();

   204     }

   205 

   206     if (endDomainExpected)

   207     {

   208         EnsureL(iToken, KEndDomain);

   209         NewLinePlusL();

   210     }

   211     else

   212     {

   213         iLineOffset = 0;

   214     }

   215 }

   216 

   217 void CXPFParser::ConnectionFiltersL(void)

   218 {

   219     NewLineL();

   220     for (;;)

   221     {

   222         MiscL();

   223         ConnectionFilterL();

   224         NewLinePlusL();

   225         TokenL();

   226         if (iToken == KEndConnectionFilters)

   227         {

   228             break;

   229         }

   230         iNextLine = ETrue;

   231         iLineOffset = 0;

   232     }

   233     NewLinePlusL();

   234 }

   235 

   236 _LIT(KNegativePortFilter,       "NegativePortFilter:");

   237 _LIT(KEndNegativePortFilter,    "EndNegativePortFilter");

   238 _LIT(KPort,                     "Port:");

   239 

   240 //

   241 // ConnectionFilter   := NegativePortFilter

   242 //

   243 // NegativePortFilter := 'NegativePortFilter' Ports 'EndNegativePortFilter' NewLine

   244 //

   245 // Ports              := (Misc* 'Port:' port NewLine+)+

   246 //

   247 

   248 _LIT(KNegativePortFilterTypeName, "NegativePortFilter");

   249 

   250 void CXPFParser::ConnectionFilterL(void)

   251 {

   252     EnsureTokenL(KNegativePortFilter);

   253 

   254     HBufC* scheme = StringLC();

   255 

   256     NewLineL();

   257     for (;;)

   258     {

   259         MiscL();

   260         EnsureTokenL(KPort);

   261 

   262         HBufC* port = StringLC();

   263 

   264         User::LeaveIfError(iArgs.Append(port));

   265         CleanupStack::Pop(port);

   266         NewLinePlusL();

   267         TokenL();

   268         if (iToken == KEndNegativePortFilter)

   269         {

   270             break;

   271         }

   272         iNextLine   = ETrue;

   273         iLineOffset = 0;

   274     }

   275     NewLineL();

   276     iCurrentDomain->AddConnectionFilterL(

   277         KNegativePortFilterTypeName,

   278         ENegativePortFilter,

   279         *scheme,

   280         iArgs);

   281     iArgs.ResetAndDestroy();

   282     CleanupStack::PopAndDestroy(scheme);

   283 }

   284 

   285 _LIT(KDriveList,        "DriveList:");

   286 _LIT(KEndDriveList,     "EndDriveList");

   287 

   288 void CXPFParser::FileAccessL(void)

   289 {

   290     CFileSystemAccessPolicy* fsap = CFileSystemAccessPolicy::NewL();

   291     iCurrentDomain->SetFileSystemAccessPolicy(fsap);

   292 

   293     for (;;)

   294     {

   295         NewLinePlusL();

   296         TokenL();

   297         if (iToken == KDriveList)

   298         {

   299             DriveListL(*fsap);

   300         }

   301         else if (iToken == KEndFileAccess)

   302         {

   303             break;

   304         }

   305     }

   306     NewLinePlusL();

   307 }

   308 

   309 

   310 _LIT(KMutualExclusionSet,       "MutualExclusionSet");

   311 _LIT(KEndMutualExclusionSet,    "EndMutualExclusionSet");

   312 _LIT(KRiskConfirmationSet,      "RiskConfirmationSet");

   313 _LIT(KEndRiskConfirmationSet,   "EndRiskConfirmationSet");

   314 

   315 void CXPFParser::BlanketPermissionL(void)

   316 {

   317     DEBUG("CXPFParser::BlanketPermissionL() - Enter");

   318     CBlanketPermissionPolicy* bpp = CBlanketPermissionPolicy::NewL();

   319     CleanupStack::PushL(bpp);

   320 

   321     for (;;)

   322     {

   323         NewLinePlusL();

   324         TokenL();

   325         if (iToken == KMutualExclusionSet || iToken == KRiskConfirmationSet)

   326         {

   327             ExclusionSetL(bpp);

   328         }

   329         else if (iToken == KEndBlanketPermission)

   330         {

   331             break;

   332         }

   333     }

   334     NewLinePlusL();

   335     CleanupStack::Pop(bpp);

   336     iCurrentDomain->SetBlanketPermissionPolicy(bpp);

   337     DEBUG("CXPFParser::BlanketPermissionL() - Exit");

   338 }

   339 

   340 

   341 void CXPFParser::ExclusionSetL(CBlanketPermissionPolicy* aBlanketPermissionPolicy)

   342 {

   343     //Parse mutually excusive blanket permission sets and the

   344     //downgrade policy for each such pair of sets

   345     DEBUG("CXPFParser::ExclusionSetL() - Enter");

   346     TBool endOfSetA= EFalse;

   347 

   348     CBlanketPermissionPolicyElement* pe = CBlanketPermissionPolicyElement::NewL();

   349     CleanupStack::PushL(pe);

   350 

   351     //Sets clash type in policy element to either KMutualExclusionSet or KRiskConfirmationSet

   352     pe->AppendDowngradeFunctionGroupListL(iToken.AllocL());

   353 

   354     NewLinePlusL();

   355     // Parse mutually excusive blanket permission sets

   356     for (;;)

   357     {

   358         TToken type = TokenL();

   359         if (type==EString)

   360         {

   361             if (!endOfSetA)

   362             {//Add token to set A

   363                 pe->AppendFunctionGroupAL(iToken.AllocL());

   364             }

   365             else

   366             {//Add token to set B

   367                 pe->AppendFunctionGroupBL(iToken.AllocL());

   368             }

   369 

   370         }

   371         else if ((type==ESymbol) && (iToken.Length() == 1))   // ':'

   372         {

   373             //create setB now

   374             endOfSetA=ETrue;

   375         }

   376         else if (iToken==KEndMutualExclusionSet || iToken==KEndRiskConfirmationSet)

   377             break;

   378 

   379         if (iToken.Length() == 0)

   380         {

   381             NewLinePlusL();

   382         }

   383 

   384     }

   385 

   386     //Add the sets and permission downgrade policy to the

   387     //CBlanketPermissionPolicy object for this domain

   388     CleanupStack::Pop(pe);

   389     aBlanketPermissionPolicy->Add(pe);

   390     DEBUG("CXPFParser::ExclusionSetL() - Exit");

   391 }

   392 

   393 

   394 _LIT(KPathAccess,       "PathAccess:");

   395 _LIT(KEndPathAccess,    "EndPathAccess");

   396 _LIT(KPathMapping,      "PathMapping:");

   397 _LIT(KEndPathMapping,   "EndPathMapping");

   398 

   399 //

   400 // DriveList := 'DriveList:' ( PathAccess | PathMapping )+ 'EndDriveList'

   401 //

   402 

   403 void CXPFParser::DriveListL(CFileSystemAccessPolicy& aFileSystemAccessPolicy)

   404 {

   405     CPathAccessPolicy* pap = CPathAccessPolicy::NewL();

   406     CleanupReleasePushL(*pap);

   407 

   408     // Parse drive letters

   409     for (;;)

   410     {

   411         TokenL();

   412 

   413         if (iToken.Length() == 1)

   414         {

   415             TDriveNumber drive = TDriveNumber(DriveTokenL());

   416             CDriveAccessPolicy& dap =

   417                 aFileSystemAccessPolicy.GetDriveAccessPolicyL(drive);

   418             dap.SetPathAccessPolicy(pap);

   419         }

   420         else

   421         {

   422             // Anything other that a single character moves on to the paths.

   423             break;

   424         }

   425     }

   426 

   427     if (iToken.Length() == 0)

   428     {

   429         NewLinePlusL();

   430         TokenL();

   431     }

   432 

   433     for (;;)

   434     {

   435         if (iToken == KPathAccess)

   436         {

   437             PathAccessL(*pap);

   438         }

   439         else if (iToken == KPathMapping)

   440         {

   441             PathMappingL(*pap);

   442         }

   443         else if (iToken == KEndDriveList)

   444         {

   445             break;

   446         }

   447         NewLinePlusL();

   448         TokenL();

   449     }

   450 

   451     CleanupStack::PopAndDestroy(pap);    // Only actually deleted if not used.

   452 }

   453 

   454 //

   455 // Drive := <Single character between A and Z inclusive>

   456 //

   457 

   458 _LIT(KDriveLetter, "drive letter");

   459 

   460 TInt CXPFParser::DriveTokenL()

   461 {

   462     TUint letter = iToken[0];

   463 

   464     if (letter >= 'A' && letter <= 'Z')

   465     {

   466         return (letter - 'A' + EDriveA);

   467     }

   468 

   469     if (letter >= 'a' && letter <= 'z')

   470     {

   471         return (letter - 'a' + EDriveA);

   472     }

   473 

   474     UnexpectedL(KDriveLetter, iToken);

   475     return -1;  // Keep compiler happy.

   476 }

   477 

   478 

   479 _LIT(KRead,             "Read");

   480 _LIT(KWrite,            "Write");

   481 

   482 //

   483 // PathAccess := ‘PathAccess:’ ( ‘Read’ | ‘Write’ )* Path+ ‘EndPathAccess’

   484 //

   485 // Path := <String containing one or more path elements>

   486 //

   487 

   488 void CXPFParser::PathAccessL(CPathAccessPolicy& aPathAccessPolicy)

   489 {

   490     TInt modeBits = 0;

   491 

   492     for (;;)

   493     {

   494         TokenL();

   495         if (iToken == KRead)

   496         {

   497             modeBits |= 1;

   498         }

   499         else if (iToken == KWrite)

   500         {

   501             modeBits |= 2;

   502         }

   503         else if (iToken.Length() == 0)

   504         {

   505             break;

   506         }

   507         else

   508         {

   509             UnexpectedL(EPathAccessMode, iToken);

   510         }

   511     }

   512 

   513     MDriveAccessPolicy::TAccessMode mode;

   514     switch (modeBits)

   515     {

   516     case 1:

   517         mode = MDriveAccessPolicy::ERead;

   518         break;

   519     case 2:

   520         mode = MDriveAccessPolicy::EWrite;

   521         break;

   522     case 3:

   523         mode = MDriveAccessPolicy::EReadWrite;

   524         break;

   525     default:

   526         mode = MDriveAccessPolicy::ENone;

   527     }

   528 

   529     // Now the paths, ending with 'EndPathAccess'

   530     for (;;)

   531     {

   532         NewLinePlusL();

   533         TokenL();

   534 

   535         if (iToken == KEndPathAccess)

   536         {

   537             break;

   538         }

   539 

   540         aPathAccessPolicy.AddPathAccessL(iToken, mode);

   541     }

   542 }

   543 

   544 

   545 //

   546 // PathMapping := 'PathMapping' ( From To )+ 'EndPathMapping'

   547 //

   548 // From := Dir

   549 //

   550 // Dir := <String containing a single directory name>

   551 //

   552 // To := Path | ( ‘MIDLET_HOME’ Path )

   553 //

   554 

   555 _LIT(KMidletHome,       "MIDLET_HOME");

   556 

   557 void CXPFParser::PathMappingL(CPathAccessPolicy& aPathAccessPolicy)

   558 {

   559     for (;;)

   560     {

   561         NewLinePlusL();

   562         TokenL();

   563 

   564         if (iToken == KEndPathMapping)

   565         {

   566             break;

   567         }

   568 

   569         TBuf<KMaxFileName> from = iToken;

   570         TBool inMidletHome = EFalse;

   571 

   572         if (TokenL() == ESymbol && iToken == KMidletHome)

   573         {

   574             inMidletHome = ETrue;

   575             TokenL();

   576         }

   577 

   578         aPathAccessPolicy.AddPathMappingL(from, iToken, inMidletHome);

   579     }

   580 }

   581 

   582 

   583 

   584 //

   585 // FunctionGroups := Misc*

   586 //                    'FunctionGroups' NewLine

   587 //                         (Misc* FunctionGroup NewLine+)+

   588 //                    'EndFunctionGroups' NewLine

   589 //

   590 

   591 _LIT(KFunctionGroups,       "FunctionGroups");

   592 _LIT(KEndFunctionGroups,    "EndFunctionGroups");

   593 

   594 void CXPFParser::FunctionGroupsL(void)

   595 {

   596     MiscL();

   597     EnsureL(*iBuffer, KFunctionGroups);

   598     for (;;)

   599     {

   600         MiscL();

   601         FunctionGroupL();

   602         NewLinePlusL();

   603         if (*iBuffer == KEndFunctionGroups)

   604         {

   605             break;

   606         }

   607         iNextLine = ETrue;

   608     }

   609 }

   610 

   611 //

   612 // FunctionGroup := 'FunctionGroup:' WS+ String NewLine

   613 //                       Permissions

   614 //                  'EndFunctionGroup' NewLine

   615 //

   616 // Permissions   := Misc*

   617 //                   WS* 'Permissions' NewLine

   618 //                        (PermissionName NewLine+)+

   619 //                   WS* 'EndPermisions' NewLine

   620 //

   621 

   622 _LIT(KFunctionGroup,    "FunctionGroup:");

   623 _LIT(KPermissions,      "Permissions");

   624 _LIT(KEndPermissions,   "EndPermissions");

   625 _LIT(KEndFunctionGroup, "EndFunctionGroup");

   626 

   627 

   628 void CXPFParser::FunctionGroupL(void)

   629 {

   630     EnsureTokenL(KFunctionGroup);

   631 

   632     HBufC* functionGroupName = StringLC();

   633 

   634     if (FindFunctionGroup(*functionGroupName) != NULL)

   635     {

   636         DuplicateDeclarationL(EFunctionGroup, *functionGroupName);

   637     }

   638 

   639     CFunctionGroup* functionGroup = iPolicy.AddFunctionGroupL(*functionGroupName);

   640 

   641     CleanupStack::PopAndDestroy(functionGroupName);

   642     User::LeaveIfError(iFunctionGroups.Append(functionGroup));

   643     MiscL();

   644     EnsureTokenL(KPermissions);

   645     NewLineL();

   646     for (;;)

   647     {

   648         MiscL();

   649         if (TokenL() != ESymbol)

   650         {

   651             UnexpectedL(EPermissionName, iToken);

   652         }

   653         iPolicy.AddPermissionL(*functionGroup, iToken);

   654         NewLinePlusL();

   655         TokenL();

   656         if (iToken == KEndPermissions)

   657         {

   658             break;

   659         }

   660         iNextLine = ETrue;

   661         iLineOffset = 0;

   662     }

   663     NewLinePlusL();

   664     EnsureTokenL(KEndFunctionGroup);

   665     NewLineL();

   666 

   667 }

   668 

   669 _LIT(KBindings,     "Bindings");

   670 _LIT(KEndBindings,  "EndBindings");

   671 

   672 //

   673 // Bindings := Misc* 'Bindings' NewLine (Misc* DomainBindings NewLine+)+ 'EndBindings' NewLine

   674 //

   675 

   676 void CXPFParser::BindingsL(void)

   677 {

   678     MiscL();

   679     EnsureL(*iBuffer, KBindings);

   680     for (;;)

   681     {

   682         MiscL();

   683         DomainBindingsL();

   684         NewLinePlusL();

   685         if (*iBuffer == KEndBindings)

   686         {

   687             break;

   688         }

   689         iNextLine = ETrue;

   690     }

   691 }

   692 

   693 _LIT(KDomainBindings,           "DomainBindings:");

   694 _LIT(KEndDomainBindings,        "EndDomainBindings");

   695 

   696 //

   697 // DomainBindings := 'DomainBindings:' WS+ DomainName NewLine

   698 //                         FunctionGroupBindings

   699 //                   'EndDomainBindings' NewLine

   700 //

   701 

   702 void CXPFParser::DomainBindingsL(void)

   703 {

   704     EnsureTokenL(KDomainBindings);

   705     switch (TokenL())

   706     {

   707     case EString:

   708 

   709         iCurrentDomain = iPolicy.FindProtectionDomain(iToken);

   710         if (iCurrentDomain == NULL)

   711         {

   712             UndeclaredL(EDomain, iToken);

   713         }

   714         break;

   715 

   716     case ESymbol:

   717 

   718         if (iToken == KUntrusted)

   719         {

   720             iCurrentDomain = iUntrustedDomain;

   721             if (iCurrentDomain == NULL)

   722             {

   723                 UndeclaredL(EUntrustedDomain, iToken);

   724             }

   725             break;

   726         }

   727         // Fall-through

   728 

   729     default:

   730 

   731         UnexpectedL(EDomainName, iToken);

   732     }

   733     for (;;)

   734     {

   735         MiscL();

   736 

   737         TBool wildcardBinding = FunctionGroupBindingL();

   738 

   739         NewLinePlusL();

   740         TokenL();

   741         if (iToken == KEndDomainBindings)

   742         {

   743             break;

   744         }

   745         if (wildcardBinding)

   746         {

   747             UnexpectedL(KEndDomainBindings, iToken);

   748         }

   749         iNextLine   = ETrue;

   750         iLineOffset = 0;

   751     }

   752     NewLineL();

   753     iFunctionGroupBindings.Reset();

   754 }

   755 

   756 _LIT(KFunctionGroupBinding,     "FunctionGroupBinding:");

   757 _LIT(KWildcard,                 "[*]");

   758 _LIT(KPermission,               "Permission:");

   759 _LIT(KAllowed,                  "Allowed");

   760 _LIT(KUser,                     "User");

   761 _LIT(KDefaultMode,              "DefaultMode:");

   762 _LIT(KMaximumMode,              "MaximumMode:");

   763 _LIT(KRules,                    "Rules");

   764 _LIT(KEndRules,                 "EndRules");

   765 _LIT(KEndFunctionGroupBinding,  "EndFunctionGroupBinding");

   766 

   767 _LIT(KFunctionGroupNameOrWildcard, "FunctionGroupName or Wildcard");

   768 

   769 #if !defined (NO_SYNTAX_EXTENSIONS)

   770 _LIT(KInteractionModes,     "InteractionModes");

   771 _LIT(KEndInteractionModes,  "EndInteractionModes");

   772 #endif

   773 

   774 TBool CXPFParser::FunctionGroupBindingL(void)

   775 {

   776     TBool wildcardBinding = EFalse;

   777 

   778     EnsureTokenL(KFunctionGroupBinding);

   779     switch (TokenL())

   780     {

   781     case EString:

   782         delete iFunctionGroupName;

   783         iFunctionGroupName = NULL;

   784         iFunctionGroupName = iToken.AllocL();

   785         if (FindFunctionGroup(*iFunctionGroupName) == NULL)

   786         {

   787             UndeclaredL(EFunctionGroup, *iFunctionGroupName);

   788         }

   789         if (FindFunctionGroupBinding(*iFunctionGroupName) != NULL)

   790         {

   791             DuplicateDeclarationL(EFunctionGroupBinding, *iFunctionGroupName);

   792         }

   793         break;

   794 

   795     case ESymbol:

   796 

   797         if (iToken == KWildcard)

   798         {

   799             wildcardBinding = ETrue;

   800             break;

   801         }

   802 

   803         // Fall-through;

   804 

   805     default:

   806 

   807         UnexpectedL(KFunctionGroupNameOrWildcard, iToken);

   808     }

   809     NewLinePlusL();

   810     EnsureTokenL(KPermission);

   811     TokenL();

   812 

   813     MPermission::TMode defaultMode = MPermission::EAllow;

   814     MPermission::TMode maximumMode = MPermission::EAllow;

   815 

   816     CFunctionGroupBinding* binding;

   817 

   818     if (iToken == KAllowed)

   819     {

   820         NewLinePlusL();

   821         if (!wildcardBinding)

   822         {

   823             binding = iCurrentDomain->AddFunctionGroupBindingL(

   824                           *iFunctionGroupName,

   825                           MPermission::EAllowed,

   826                           defaultMode,

   827                           maximumMode);

   828             User::LeaveIfError(iFunctionGroupBindings.Append(binding));

   829         }

   830         else

   831         {

   832             AddDefaultBindingsL(MPermission::EAllowed, defaultMode, maximumMode);

   833         }

   834     }

   835     else if (iToken == KUser)

   836     {

   837 #if defined (NO_SYNTAX_EXTENSIONS)

   838         NewLinePlusL();

   839         EnsureTokenL(KDefaultMode);

   840         defaultMode = InteractionModeL();

   841         NewLinePlusL();

   842         EnsureTokenL(KMaximumMode);

   843         maximumMode = InteractionModeL();

   844         NewLinePlusL();

   845         if (!wildcardBinding)

   846         {

   847             binding = iCurrentDomain->AddFunctionGroupBindingL(

   848                           *iFunctionGroupName,

   849                           MPermission::EUser,

   850                           defaultMode,

   851                           maximumMode);

   852             User::LeaveIfError(iFunctionGroupBindings.Append(binding));

   853             TokenL();

   854             if (iToken == KRules)

   855             {

   856                 for (;;)

   857                 {

   858                     MiscL();

   859                     RuleL(*binding);

   860                     NewLinePlusL();

   861                     TokenL();

   862                     if (iToken == KEndRules)

   863                     {

   864                         break;

   865                     }

   866                     iNextLine   = ETrue;

   867                     iLineOffset = 0;

   868                 }

   869                 NewLinePlusL();

   870             }

   871             else

   872             {

   873                 iLineOffset = 0;

   874             }

   875         }

   876         else

   877         {

   878             AddDefaultBindingsL(MPermission::EUser, defaultMode, maximumMode);

   879         }

   880 #else

   881         NewLinePlusL();

   882         EnsureTokenL(KDefaultMode);

   883         defaultMode = InteractionModeL();

   884         NewLinePlusL();

   885         TokenL();

   886         if (iToken == KMaximumMode)

   887         {

   888             maximumMode = InteractionModeL();

   889             NewLinePlusL();

   890             if (!wildcardBinding)

   891             {

   892                 binding = iCurrentDomain->AddFunctionGroupBindingL(

   893                               *iFunctionGroupName,

   894                               MPermission::EUser,

   895                               defaultMode,

   896                               maximumMode);

   897                 User::LeaveIfError(iFunctionGroupBindings.Append(binding));

   898                 TokenL();

   899                 if (iToken == KRules)

   900                 {

   901                     for (;;)

   902                     {

   903                         MiscL();

   904                         RuleL(*binding);

   905                         NewLinePlusL();

   906                         TokenL();

   907                         if (iToken == KEndRules)

   908                         {

   909                             break;

   910                         }

   911                         iNextLine   = ETrue;

   912                         iLineOffset = 0;

   913                     }

   914                     NewLinePlusL();

   915                 }

   916                 else

   917                 {

   918                     iLineOffset = 0;

   919                 }

   920             }

   921             else

   922             {

   923                 AddDefaultBindingsL(MPermission::EUser, defaultMode, maximumMode);

   924             }

   925         }

   926         else if (iToken == KInteractionModes)

   927         {

   928             TUint32 interactionModes = 0;

   929             TUint32 interactionMode  = 0;

   930 

   931             for (;;)

   932             {

   933                 NewLinePlusL();

   934                 TokenL();

   935                 if (iToken == KEndInteractionModes)

   936                 {

   937                     break;

   938                 }

   939                 else if (iToken == KNo)

   940                 {

   941                     interactionMode = 1 << MPermission::EDenied;

   942                 }

   943                 else if (iToken == KOneshot)

   944                 {

   945                     interactionMode = 1 << MPermission::EOneshot;

   946                 }

   947                 else if (iToken == KSession)

   948                 {

   949                     interactionMode = 1 << MPermission::ESession;

   950                 }

   951                 else if (iToken == KBlanket)

   952                 {

   953                     interactionMode = 1 << MPermission::EBlanket;

   954                 }

   955                 else

   956                 {

   957                     UnexpectedL(EInteractionMode, iToken);

   958                 }

   959                 if (interactionModes & interactionMode)

   960                 {

   961                     User::Leave(-1);

   962                 }

   963                 interactionModes |= interactionMode;

   964             }

   965             NewLinePlusL();

   966             if (!wildcardBinding)

   967             {

   968                 iCurrentDomain->AddFunctionGroupBindingL(

   969                     *iFunctionGroupName,

   970                     MPermission::EUser,

   971                     defaultMode,

   972                     interactionModes);

   973             }

   974             else

   975             {

   976                 AddDefaultBindingsL(MPermission::EAllowed, defaultMode, interactionModes);

   977             }

   978         }

   979         else

   980         {

   981             UnexpectedL(EPermissionType, iToken);

   982         }

   983 #endif

   984     }

   985     else

   986     {

   987         UnexpectedL(EPermissionType, iToken);

   988     }

   989     EnsureTokenL(KEndFunctionGroupBinding);

   990     NewLineL();

   991     return wildcardBinding;

   992 }

   993 

   994 _LIT(KSimpleMapping,        "SimpleMapping:");

   995 _LIT(KFunctionGroupMode,    "FunctionGroupMode:");

   996 _LIT(KPermissionMode,       "PermissionMode:");

   997 _LIT(KEndSimpleMapping,     "EndSimpleMapping");

   998 

   999 void CXPFParser::RuleL(CFunctionGroupBinding& aBinding)

  1000 {

  1001     EnsureTokenL(KSimpleMapping);

  1002     TokenL();

  1003 

  1004     HBufC* permission = iToken.AllocLC();

  1005 

  1006     NewLinePlusL();

  1007     for (;;)

  1008     {

  1009         EnsureTokenL(KFunctionGroupMode);

  1010         User::LeaveIfError(iMappings.Append(InteractionModeL()));

  1011         NewLinePlusL();

  1012         EnsureTokenL(KPermissionMode);

  1013         User::LeaveIfError(iMappings.Append(InteractionModeL()));

  1014         NewLinePlusL();

  1015         TokenL();

  1016         if (iToken == KEndSimpleMapping)

  1017         {

  1018             break;

  1019         }

  1020         //iNextLine = ETrue; "JCF commented out to allow grouped simplemappings to work"

  1021         iLineOffset = 0;

  1022     }

  1023     NewLineL();

  1024     aBinding.AddSimpleMappingL(*permission, iMappings);

  1025     CleanupStack::PopAndDestroy(permission);

  1026     iMappings.Reset();

  1027 }

  1028 

  1029 _LIT(KDenied,   "Denied");

  1030 

  1031 MPermission::TMode CXPFParser::InteractionModeL(void)

  1032 {

  1033     MPermission::TMode mode = MPermission::EInvalid;

  1034 

  1035     if (TokenL() != ESymbol)

  1036     {

  1037         UnexpectedL(ESymbol, iToken);

  1038     }

  1039     if (iToken == KBlanket)

  1040     {

  1041         mode = MPermission::EBlanket;

  1042     }

  1043     else if (iToken == KOneshot)

  1044     {

  1045         mode = MPermission::EOneshot;

  1046     }

  1047     else if (iToken == KSession)

  1048     {

  1049         mode = MPermission::ESession;

  1050     }

  1051     else if (iToken == KDenied)

  1052     {

  1053         mode = MPermission::EDenied;

  1054     }

  1055     else

  1056     {

  1057         UnexpectedL(EInteractionMode, iToken);

  1058     }

  1059     return mode;

  1060 }

  1061 

  1062 

  1063 void CXPFParser::MiscL(void)

  1064 {

  1065     for (;;)

  1066     {

  1067         if (ReadLineL() == -1)

  1068         {

  1069             //UnexpectedL(EEof, ????);

  1070         }

  1071         if ((iBuffer->Length() > 0) && ((*iBuffer)[0] != '#'))

  1072         {

  1073             break;

  1074         }

  1075     }

  1076 }

  1077 

  1078 void CXPFParser::NewLineL(void)

  1079 {

  1080     SkipWhitespace();

  1081     if (iLineOffset != iLineLength)

  1082     {

  1083         UnexpectedL(EEndOfLine, EAny);

  1084     }

  1085 }

  1086 

  1087 void CXPFParser::NewLinePlusL(void)

  1088 {

  1089     NewLineL();

  1090     for (;;)

  1091     {

  1092         if (ReadLineL() != 0)

  1093         {

  1094             break;

  1095         }

  1096     }

  1097 }

  1098 

  1099 void CXPFParser::SkipWhitespace(void)

  1100 {

  1101     while (iLineOffset < iLineLength)

  1102     {

  1103         TUint16 c = (*iBuffer)[iLineOffset];

  1104 

  1105         if ((c != 0x09) && (c != 0x20))

  1106         {

  1107             break;

  1108         }

  1109         ++iLineOffset;

  1110     }

  1111 }

  1112 

  1113 void CXPFParser::EnsureL(const TDesC& aActual, const TDesC& aExpected)

  1114 {

  1115     if (aActual != aExpected)

  1116     {

  1117         UnexpectedL(aExpected, aActual);

  1118     }

  1119 }

  1120 

  1121 void CXPFParser::EnsureTokenL(const TDesC& aExpectedToken)

  1122 {

  1123     TokenL();

  1124     EnsureL(iToken, aExpectedToken);

  1125 }

  1126 

  1127 CXPFParser::TToken CXPFParser::TokenL(TToken aExpected)

  1128 {

  1129     TPtrC   buffer = *iBuffer;

  1130     TToken  token  = ENoToken;

  1131 

  1132     while (iLineOffset < iLineLength)

  1133     {

  1134         TUint16 c = buffer[iLineOffset];