1 /*

     2 * Copyright (c) 2009 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 

    24 #include "wspolicywriter.h"

    25 #include "wspolicyreader.h"

    26 

    27 #include "policyassertion.h"

    28 #include "andcompositeassertion.h"

    29 #include "xorcompositeassertion.h"

    30 #include "assertion.h"

    31 #include "primitiveassertion.h"

    32 #include "policyreferenceassertion.h"

    33 using namespace WSPolicy;

    34 using namespace PolicyWriter;    

    35 

    36 CWSPolicyWriter* CWSPolicyWriter::NewL()

    37 {

    38      CWSPolicyWriter* pSelf = CWSPolicyWriter::NewLC();

    39     CleanupStack::Pop(pSelf);

    40     return pSelf;

    41     

    42 }

    43 CWSPolicyWriter* CWSPolicyWriter::NewLC()

    44 {

    45        CWSPolicyWriter* pSelf = new (ELeave) CWSPolicyWriter();

    46     CleanupStack::PushL(pSelf);

    47     pSelf->ConstructL();

    48     return pSelf;

    49      

    50 }

    51 CWSPolicyWriter::~CWSPolicyWriter()

    52 {

    53     iNamespcaes.Reset();

    54 }

    55 CWSPolicyWriter::CWSPolicyWriter():iNamespcaes(ETrue,ETrue)

    56 {

    57 }

    58 void CWSPolicyWriter::ConstructL()

    59 {

    60 count = 0;    

    61 }

    62 

    63 TPtrC8 CWSPolicyWriter::WriteToBufL(CBufBase& aBuf, CPolicyAssertion* aEle)

    64     {

    65     RBufWriteStream bufWs(aBuf);

    66     CleanupClosePushL(bufWs);

    67     WritePolicyL(aEle, bufWs);

    68     CleanupStack::PopAndDestroy(); // bufWs.Close();

    69 //    TPtrC8 p = aBuf.Ptr(0);

    70 //    TInt size(p.Length());

    71     iNamespcaes.Reset();

    72     return aBuf.Ptr(0);

    73     }

    74 HBufC8* CWSPolicyWriter::WriteAllAsXMlL(CPolicyAssertion* aPolicy)

    75 {

    76    if(!aPolicy)

    77     return NULL;

    78    

    79     CBufFlat *pBuf = CBufFlat::NewL(128);

    80     CleanupStack::PushL(pBuf);

    81     TPtrC8 p = WriteToBufL(*pBuf, aPolicy);

    82 

    83     TInt size(p.Length());

    84     HBufC8* pRet = NULL; //p.AllocL();   

    85     

    86     if (size > 0)

    87     {

    88         pRet = HBufC8::NewLC(size);

    89         TPtr8 retP = pRet->Des();

    90         retP.Copy(p.Ptr(),size);

    91         CleanupStack::Pop(); //pRet

    92         WriteToFileAllL(retP);            

    93     }

    94     

    95     CleanupStack::PopAndDestroy(); // pBuf;

    96     iNamespcaes.Reset();    

    97     return pRet;    

    98 }

    99 HBufC8* CWSPolicyWriter::WriteAllAsXmlL(CSenElement* /*aXml*/)

   100 {

   101 return NULL;    

   102 }

   103          

   104 TInt CWSPolicyWriter::WritePolicyL(CPolicyAssertion* aEle, RWriteStream& aWriteStream)

   105 {

   106     aWriteStream.WriteL(KStartElement);

   107     aWriteStream.WriteL(KWspPolicyPrefix);

   108     TPtrC8 name(KSenXmlNsAttNamePlusColonWsp);

   109     if(IsNamespaceAdded(name) == KErrNotFound)

   110     {

   111         aWriteStream.WriteL(KSenXmlNsAttNamePlusColonWsp); //namespace

   112         aWriteStream.WriteL(KSenEqualsDblQuot);

   113         aWriteStream.WriteL(KWsPolicyNsUri); //namespace

   114         aWriteStream.WriteL(KSenDblQuot);

   115         TPtrC8 nameuri(KWsPolicyNsUri);

   116         AddNameSpaceL(name, nameuri);	//codescannerwarnings

   117     }

   118     

   119 /*

   120 		if (policy.getId() != null) {

   121 

   122 			writer.writeNamespace(PolicyConstants.WSU_NAMESPACE_PREFIX,

   123 					PolicyConstants.WSU_NAMESPACE_URI);

   124 			writer.setPrefix(PolicyConstants.WSU_NAMESPACE_PREFIX,

   125 					PolicyConstants.WSU_NAMESPACE_URI);

   126 

   127 			writer.writeAttribute("wsu", PolicyConstants.WSU_NAMESPACE_URI,

   128 					"Id", policy.getId());

   129 		}

   130 */

   131 		RPolicyTerms terms = aEle->GetTerms();

   132 		

   133 		if(terms.Count() > 0)

   134 		{

   135 		    aWriteStream.WriteL(KSenGreaterThan);		    

   136        		for (TInt i = 0; i< terms.Count(); i++) 

   137        		{

   138 			MAssertion* term = terms[i];

   139 			WriteAssertionL(term, aWriteStream);

   140 		    }

   141 		}

   142 		else

   143 		{

   144 		    aWriteStream.WriteL(KSenGreaterThan);

   145 		}

   146         

   147         

   148         aWriteStream.WriteL(KSenLessThanSlash);

   149         aWriteStream.WriteL(KWspPolicyPrefix);

   150 		aWriteStream.WriteL(KSenGreaterThan);

   151 

   152         return KErrNone;

   153 }

   154 TInt CWSPolicyWriter::WriteAndAssertionL(CAndCompositeAssertion* aEle, RWriteStream& aWriteStream)

   155 {

   156     aWriteStream.WriteL(KStartElement);

   157     aWriteStream.WriteL(KWspAndPrefix);

   158     aWriteStream.WriteL(KSenGreaterThan);

   159 	RPolicyTerms terms = aEle->GetTerms();

   160 	

   161 	if(terms.Count() > 0)

   162 	{

   163     	WriteTermsL(terms, aWriteStream);

   164 	}

   165 		

   166     aWriteStream.WriteL(KSenLessThanSlash);

   167     aWriteStream.WriteL(KWspAndPrefix);

   168     aWriteStream.WriteL(KSenGreaterThan);  

   169     

   170     return KErrNone; 

   171 }

   172 TInt CWSPolicyWriter::WriteXorAssertionL(CXorCompositeAssertion* aEle, RWriteStream& aWriteStream)

   173 {

   174     aWriteStream.WriteL(KStartElement);

   175     aWriteStream.WriteL(KWspXorPrefix);

   176     aWriteStream.WriteL(KSenGreaterThan);

   177 	RPolicyTerms terms = aEle->GetTerms();

   178 	

   179 	if(terms.Count() > 0)

   180 	{

   181     	WriteTermsL(terms, aWriteStream);

   182 	}

   183 

   184 		

   185     aWriteStream.WriteL(KSenLessThanSlash);

   186     aWriteStream.WriteL(KWspXorPrefix);

   187     aWriteStream.WriteL(KSenGreaterThan);  

   188     return KErrNone; 

   189 }

   190 TInt CWSPolicyWriter::WriteAssertionL(MAssertion* aEle, RWriteStream& aWriteStream)

   191 {

   192     if(!aEle)

   193         return KErrNone; 

   194     

   195 		if (aEle->Type() == EPrimitiveType)

   196 		{

   197 			WritePrimitiveAssertionL((CPrimitiveAssertion*) aEle, aWriteStream);

   198 

   199 		}

   200 		else if (aEle->Type() == ECompositeXorType)

   201 		{

   202 			WriteXorAssertionL((CXorCompositeAssertion*) aEle,	aWriteStream);

   203 		}

   204 		else if (aEle->Type()== EPolicyReferenceType ) 

   205 		{

   206 			WritePolicyReferenceL((CPolicyReferenceAssertion*)aEle, aWriteStream);

   207 		} 

   208 		else if (aEle->Type() == ECompositePolicyType)

   209 		{

   210 			WritePolicyL((CPolicyAssertion*) aEle, aWriteStream);

   211 		

   212 		}

   213 		else if (aEle->Type() == ECompositeAndType)

   214 		{

   215 			WriteAndAssertionL((CAndCompositeAssertion*) aEle,aWriteStream);

   216 

   217 		} 

   218 		else 

   219 		{

   220 		}

   221     

   222         return KErrNone;

   223 }

   224 TInt CWSPolicyWriter::WritePolicyReferenceL(CPolicyReferenceAssertion* aAssertion, RWriteStream& aWriteStream)

   225 {

   226 

   227     aWriteStream.WriteL(KStartElement);

   228     aWriteStream.WriteL(KWspPolicyReferencePrefix);

   229     aWriteStream.WriteL(KSenSpace);

   230     aWriteStream.WriteL(KWspPolicyReferenceUri);

   231 

   232     aWriteStream.WriteL(KSenEqualsDblQuot);

   233     aWriteStream.WriteL(aAssertion->PolicyUri());

   234     aWriteStream.WriteL(KSenDblQuot);

   235     aWriteStream.WriteL(KSenGreaterThan);

   236     

   237     

   238     aWriteStream.WriteL(KSenLessThanSlash);

   239     aWriteStream.WriteL(KWspPolicyReferencePrefix);

   240     aWriteStream.WriteL(KSenGreaterThan);  

   241 

   242     return KErrNone;

   243 }

   244 TInt CWSPolicyWriter::WritePrimitiveAssertionL(CPrimitiveAssertion* aAssertion, RWriteStream& aWriteStream)

   245 {

   246 	TPtrC8 qname = aAssertion->Name();

   247 	aWriteStream.WriteL(KStartElement);

   248     aWriteStream.WriteL(qname);

   249 

   250     TBuf8<200> name(KSenXmlNsAttNamePlusColon);

   251     name.Append(aAssertion->iQname->Prefix());

   252 //    if(IsNamespaceAdded(name) == KErrNotFound)

   253     {

   254         aWriteStream.WriteL(name); //namespace

   255         aWriteStream.WriteL(KSenEqualsDblQuot);

   256         aWriteStream.WriteL(aAssertion->iQname->Uri()); //namespace

   257         aWriteStream.WriteL(KSenDblQuot);

   258         TPtrC8 nameuri(aAssertion->iQname->Uri());

   259         AddNameSpaceL(name, nameuri);	//codescannerwarnings

   260     }

   261     

   262 	WriteAttributesL(aAssertion, aWriteStream);

   263     aWriteStream.WriteL(KSenGreaterThan);	

   264     

   265     TPtrC8 strValue = aAssertion->StrValue();    

   266 

   267 	if (strValue != KNullDesC8()) {

   268 	

   269 		aWriteStream.WriteL(strValue);

   270 	}

   271 

   272     

   273 	RPolicyTerms terms = aAssertion->GetTerms();

   274 	if(terms.Count() > 0)

   275 	{

   276 	    

   277     	WriteTermsL(terms, aWriteStream);

   278 	}

   279 

   280 	aWriteStream.WriteL(KSenLessThanSlash);

   281     aWriteStream.WriteL(qname);

   282     aWriteStream.WriteL(KSenGreaterThan);   

   283     return KErrNone; 

   284 }

   285 TInt CWSPolicyWriter::WriteTermsL(RPointerArray<MAssertion>& aTerms, RWriteStream& aWriteStream)

   286 {

   287 

   288     for (TInt i=0; i<aTerms.Count(); i++ )

   289     {

   290         CAssertion* obj = (CAssertion*)aTerms[i];

   291         if(obj)

   292         {

   293             WriteAssertionL(obj, aWriteStream);

   294         }

   295     }

   296     return KErrNone;

   297 }

   298 void WriteAttrToL(RWriteStream& aWriteStream, TDesC8& aName, TDesC8& aValue)

   299 {

   300     aWriteStream.WriteL(KSenSpace);

   301     aWriteStream.WriteL(aName);

   302     aWriteStream.WriteL(KSenEqualsDblQuot);

   303     aWriteStream.WriteL(aValue);

   304     aWriteStream.WriteL(KSenDblQuot);    

   305 }

   306 

   307 void CWSPolicyWriter::WriteAttributesL(CPrimitiveAssertion* aAssertion, RWriteStream& aWriteStream)

   308 {

   309 

   310 	RAttributeMap& attributes = aAssertion->Attributes();

   311 	

   312 	TInt attCount = attributes.Count();

   313 	

   314 	for (TInt i=0; i<attCount; i++ )

   315     {

   316         const TDesC8* nameptr= attributes.KeyAt(i);

   317         const TDesC8* valptr= attributes.ValueAt(i);

   318         HBufC8* tt = nameptr->AllocL();

   319         HBufC8* tt2 = valptr->AllocL();

   320         TPtrC8 name =  tt->Des();   

   321         TPtrC8 value =  tt2->Des();

   322         WriteAttrToL(aWriteStream, name, value);

   323         delete tt;

   324         delete tt2;

   325         

   326     }

   327 }

   328 

   329 TPtrC8 CWSPolicyWriter::GetAttrib(TPtrC8 /*aReference*/, CSenElement* /*aEle*/)

   330 {

   331     return KNullDesC8();

   332 }

   333 TBool CWSPolicyWriter::IsNamespaceAdded(TPtrC8 aName)

   334 {

   335     return iNamespcaes.Find(aName);

   336 }

   337 

   338 TInt CWSPolicyWriter::AddNameSpaceL(TPtrC8 aName, TPtrC8 aUri)	//codescannerwarnings

   339 {

   340     if(IsNamespaceAdded(aName) == KErrNotFound)

   341     {

   342         return iNamespcaes.Append(aName.AllocL(),aUri.AllocL());            

   343     }

   344     return KErrGeneral;

   345 }

   346 

   347 //#ifdef _SENDEBUG  

   348 void CWSPolicyWriter::WriteToFileAllL(CSenElement* aXml)

   349 {

   350   RFs fss;

   351   User::LeaveIfError(fss.Connect());

   352   CleanupClosePushL(fss);

   353     

   354   TBuf<255> file;

   355   _LIT( KFileName, "c:\\logs\\normalizer%d.xml");

   356   file.Format(KFileName, count);

   357   count++;

   358   TPtrC OutputFile(file);

   359     

   360    RFile  xmlFile;

   361    xmlFile.Replace(fss , OutputFile, EFileWrite );

   362    HBufC8* temp = aXml->AsXmlL();

   363    CleanupStack::PushL(temp);

   364    xmlFile.Write(temp->Des());

   365    xmlFile.Close();

   366    CleanupStack::PopAndDestroy(temp);

   367    CleanupStack::PopAndDestroy(1); // fss

   368 }

   369 void CWSPolicyWriter::WriteToFileAllL(TDesC8& aXml)

   370 {

   371   RFs fss;

   372   User::LeaveIfError(fss.Connect());

   373   CleanupClosePushL(fss);

   374     

   375   TBuf<255> file;

   376   _LIT( KFileName, "c:\\logs\\normalizer%d.xml");

   377   file.Format(KFileName, count);

   378   count++;

   379   TPtrC OutputFile(file);

   380     

   381    RFile  xmlFile;

   382    xmlFile.Replace(fss , OutputFile, EFileWrite );

   383    xmlFile.Write(aXml);

   384    xmlFile.Close();

   385    CleanupStack::PopAndDestroy(1); // fss

   386 }

   387 

   388 //#endif