1 /*

     2 * Copyright (c) 2007-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:   Logging code fot the dmadpki

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #if defined(_DEBUG)

    22 

    23 

    24 _LIT(KTraceOutOfMemory, "TRACE out of memory");

    25 

    26 _LIT(KInMark, ">");

    27 _LIT(KOutMark, "<");

    28 _LIT(KDepthMark, "-");

    29 _LIT(KSeparator, " ");

    30 _LIT(KLeaveFrom, "LEAVE FROM: ");

    31 

    32 

    33 

    34 void TTraceItem::TraceCleanupOperation(TAny* aItem)

    35     {           

    36     

    37     TTraceItem* traceCleanupItem = static_cast<TTraceItem*>(aItem);

    38     CVpnDebugLogger* logger = CVpnDebugLogger::VpnDebugLogger();

    39     logger->iCallDepth--;

    40         

    41     logger->iDebugString.Zero();                

    42     

    43     CVpnDebugLogger::TimeStamp(logger->iDebugString);

    44     logger->iDebugString.Append(KLeaveFrom);

    45     logger->iDebugString.Append(*(traceCleanupItem->iTraceName));  

    46     logger->WriteLogRaw(logger->iDebugString);

    47     

    48     delete traceCleanupItem->iTraceName;

    49     

    50     traceCleanupItem->iMethodHasLeft = ETrue;

    51     }

    52 

    53 

    54 TTraceItem::TTraceItem(const TDesC& aTraceName)

    55     {

    56     iMethodHasLeft = EFalse;

    57     

    58     CVpnDebugLogger* logger = CVpnDebugLogger::VpnDebugLogger();

    59     

    60     iTraceName = aTraceName.Alloc();

    61     if (iTraceName != NULL)

    62         {                

    63         if (logger != NULL)

    64             {            

    65             logger->iCallDepth++;        

    66             

    67             logger->iDebugString.Zero();

    68             CVpnDebugLogger::TimeStamp(logger->iDebugString);

    69             

    70             for (TInt i = 0; i < logger->iCallDepth; ++i)

    71                 {

    72                 logger->iDebugString.Append(KDepthMark);

    73                 }            

    74                     

    75             logger->iDebugString.Append(KInMark);

    76             logger->iDebugString.Append(KSeparator);        

    77             logger->iDebugString.Append(*iTraceName);        

    78             logger->WriteLogRaw(logger->iDebugString);

    79             }

    80         CleanupStack::PushL(TCleanupItem(TTraceItem::TraceCleanupOperation, this));

    81         }

    82     else

    83         {

    84         if (logger != NULL)

    85             {            

    86             logger->WriteLogRaw(KTraceOutOfMemory);

    87             }

    88         }

    89     }

    90 

    91 

    92 TTraceItem::~TTraceItem()

    93     {

    94     CVpnDebugLogger* logger = CVpnDebugLogger::VpnDebugLogger();

    95     

    96     

    97     if (!iMethodHasLeft)

    98         {        

    99         if (iTraceName != NULL)

   100             {       

   101             if (logger != NULL)

   102                 {                

   103                 logger->iDebugString.Zero();

   104                 CVpnDebugLogger::TimeStamp(logger->iDebugString);

   105                 logger->iDebugString.Append(KOutMark);

   106                 for (TInt i = 0; i < logger->iCallDepth; ++i)

   107                     {

   108                     logger->iDebugString.Append(KDepthMark);

   109                     }                

   110 

   111                 logger->iDebugString.Append(KSeparator);

   112                 logger->iDebugString.Append(*iTraceName);        

   113                 logger->WriteLogRaw(logger->iDebugString);

   114                 

   115                 logger->iCallDepth--;                

   116                 }

   117             delete iTraceName;        

   118             CleanupStack::Pop(this);                

   119             

   120             }

   121         else

   122             {

   123             if (logger != NULL)

   124                 {                

   125                 logger->WriteLogRaw(KTraceOutOfMemory);

   126                 }

   127             }

   128         }

   129     }

   130     

   131     

   132 

   133 void CVpnDebugLogger::InitializeDebugLoggerL(const TDesC& aFolder, const TDesC& aFileName)

   134     {

   135     

   136     CVpnDebugLogger* self = static_cast<CVpnDebugLogger*>(Dll::Tls());

   137     if (self == NULL)

   138         {            

   139         self = new (ELeave) CVpnDebugLogger;

   140         CleanupStack::PushL(self);

   141         self->ConstructL(aFolder, aFileName);

   142         User::LeaveIfError(Dll::SetTls(self));

   143         CleanupStack::Pop(self);    

   144         }

   145     self->iReferenceCount++;

   146     }

   147 

   148 

   149 void CVpnDebugLogger::ConstructL(const TDesC& aFolder, const TDesC& aFileName)

   150     {            

   151     User::LeaveIfError(iFileLogger.Connect());

   152     iFileLogger.SetDateAndTime(EFalse, EFalse);

   153     iFileLogger.CreateLog(aFolder, aFileName, EFileLoggingModeAppend);	

   154     }

   155     

   156     

   157 CVpnDebugLogger::~CVpnDebugLogger()

   158     {

   159     if ( iFileLogger.Handle() != 0 )

   160         {    

   161         iFileLogger.Write(_L("Logger delete"));        

   162         iFileLogger.CloseLog();

   163         }

   164     

   165     iFileLogger.Close();

   166     }

   167 

   168 

   169 void CVpnDebugLogger::FinalizeDebugLogger()

   170     {

   171     CVpnDebugLogger* self = static_cast<CVpnDebugLogger*>(Dll::Tls());

   172     __ASSERT_ALWAYS(self != NULL, User::Invariant());

   173     

   174     self->iReferenceCount--;

   175     

   176     if (self->iReferenceCount == 0)

   177         {        

   178         Dll::SetTls(NULL);    

   179         delete self;

   180         }

   181     }

   182 

   183 

   184 CVpnDebugLogger* CVpnDebugLogger::VpnDebugLogger()

   185     {

   186     return static_cast<CVpnDebugLogger*>(Dll::Tls());

   187     }

   188     

   189 

   190 void CVpnDebugLogger::WriteLogRaw(const TDesC& aLogMessage)

   191     {

   192     iFileLogger.Write(aLogMessage);

   193     }

   194     

   195     

   196 void CVpnDebugLogger::LogWrite(const TDesC& aText)

   197     {

   198     CVpnDebugLogger* logger = VpnDebugLogger();

   199     logger->iDebugString.Zero();

   200     CVpnDebugLogger::TimeStamp(logger->iDebugString);

   201     

   202     if (logger->iCallDepth > 0)

   203         {        

   204         for (TUint i = 0; i < logger->iCallDepth; ++i)

   205             {

   206             logger->iDebugString.Append(_L(" "));

   207             }

   208         logger->iDebugString.Append(_L("  "));

   209         }

   210         

   211     logger->iDebugString.Append(aText);

   212     logger->WriteLogRaw(logger->iDebugString);

   213     }

   214 

   215 

   216 void CVpnDebugLogger::LogWrite(const TDesC8& aText)

   217     {

   218     CVpnDebugLogger* logger = VpnDebugLogger();

   219     logger->iDebugString.Zero();

   220     CVpnDebugLogger::TimeStamp(logger->iDebugString);

   221     

   222     if (logger->iCallDepth > 0)

   223         {        

   224         for (TUint i = 0; i < logger->iCallDepth; ++i)

   225             {

   226             logger->iDebugString.Append(_L(" "));

   227             }

   228         logger->iDebugString.Append(_L("  "));

   229         }

   230                 

   231     TInt stringLength = logger->iDebugString.Length(); 

   232     TUint spaceLeft = logger->iDebugString.MaxLength() - stringLength;

   233        

   234     TUint16* ptr = const_cast<TUint16*>(logger->iDebugString.Ptr() + stringLength);      

   235     TPtr buffer(ptr, spaceLeft);       

   236     buffer.Copy(aText);

   237         

   238     logger->iDebugString.SetLength(stringLength + buffer.Length());

   239     logger->WriteLogRaw(logger->iDebugString);    

   240     }

   241 

   242 

   243 void CVpnDebugLogger::LogWriteF(TRefByValue<const TDesC> aFmt, ...)

   244     {

   245     VA_LIST list;

   246     VA_START(list,aFmt);

   247 

   248 

   249     CVpnDebugLogger* logger = VpnDebugLogger();

   250     logger->iDebugString.Zero();

   251     CVpnDebugLogger::TimeStamp(logger->iDebugString);

   252 

   253     if (logger->iCallDepth > 0)

   254         {        

   255         for (TUint i = 0; i < logger->iCallDepth; ++i)

   256             {

   257             logger->iDebugString.Append(_L(" "));

   258             }

   259         logger->iDebugString.Append(_L("  "));

   260         }

   261         

   262         

   263     const TDesC& format = aFmt;    

   264     

   265     logger->iDebugString.AppendFormatList(format, list);

   266 	logger->WriteLogRaw(logger->iDebugString);

   267     }

   268 

   269 

   270 

   271 void CVpnDebugLogger::LogWriteF(TRefByValue<const TDesC8> aFmt, ...)

   272     {

   273     TBuf8<512> buf;

   274 

   275     VA_LIST list;

   276     VA_START(list,aFmt);

   277     

   278     const TDesC8& format = aFmt;

   279     buf.FormatList(format, list);

   280     

   281     LogWrite(buf);    

   282     }

   283 

   284 

   285 void CVpnDebugLogger::HexWrite(const TDesC8& aData)

   286     {

   287     const TUint KRowLength = 16; //16 bytes in one row

   288     

   289     TBuf<128> row;    

   290     

   291     TUint rowCount = aData.Length() / KRowLength;

   292     if (aData.Length() % KRowLength != 0)

   293         {

   294         rowCount++;

   295         }

   296     

   297     for (TInt i = 0; i < rowCount; ++i)

   298         {

   299         _LIT(KRowStartFormat, "%04x: ");

   300         TPtrC8 rowData(aData.Mid(KRowLength*i));

   301         

   302         row.Zero();        

   303         row.Format(KRowStartFormat, i*KRowLength);  

   304         TInt j;      

   305         for (j = 0; j < KRowLength; ++j)

   306             {                                    

   307             if ( j < rowData.Length())

   308                 {

   309                 _LIT(KDataByteFormat, "%02x ");

   310                 TUint8 byte = rowData[j];

   311                 row.AppendFormat(KDataByteFormat, byte);

   312                 }

   313             else

   314                 {

   315                 row.Append(_L("   "));

   316                 }

   317             }                

   318 

   319         for (j = 0; j < KRowLength && j < rowData.Length(); ++j)

   320             {

   321             TUint8 byte = rowData[j];

   322             if (byte >= ' ' && byte <= '~')

   323                 {

   324                 row.Append(byte);

   325                 }

   326             else

   327                 {

   328                 row.Append(_L("."));

   329                 }

   330             }                

   331 

   332         

   333         LogWrite(row);

   334         }           

   335     }

   336 

   337     

   338 void CVpnDebugLogger::TimeStamp(TDes& aBuffer)

   339     {

   340     TTime time;

   341     time.HomeTime();

   342     TDateTime dateTime = time.DateTime();

   343     

   344     

   345     _LIT(KFormatTxt,"%02d/%02d/%d    %02d:%02d:%02d.%03d    ");

   346     aBuffer.Format(KFormatTxt,

   347                    dateTime.Day()+1, 

   348                    TInt(dateTime.Month()+1), 

   349                    dateTime.Year(),

   350                    

   351                    dateTime.Hour(), dateTime.Minute(), dateTime.Second(),

   352                    dateTime.MicroSecond()

   353                   );

   354 

   355     

   356     }

   357 

   358 

   359 #endif //defined(_DEBUG)