modules/plugin/tools/tester/common/pplib.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 /****************************************************/
  39 /*                                                  */
  40 /* Private profile library                          */
  41 /*                                                  */
  42 /* Attempt to write a cross-platform library for    */
  43 /* dealing with Windows style .INI profiles.        */
  44 /*                                                  */
  45 /* For API see pplib.h                              */
  46 /*                                                  */
  47 /* 11.26.97 - av started                            */
  48 /*                                                  */
  49 /* Current limitations:                             */
  50 /*   - profile must NOT contain space chars         */
  51 /*   - colon indicating comments must be in the     */
  52 /*     first position                               */
  53 /*                                                  */
  54 /****************************************************/
  55
  56 #include "xp.h"
  57
  58 static BOOL isCurrentLineCommentedOut(char * pBuf, char * pPosition)
  59 {
  60   for(;;)
  61   {
  62     if((*pPosition == ';') && ((pPosition - 1 < pBuf) || (*(pPosition - 1) == '\n') || (*(pPosition - 1) == '\r')))
  63       return TRUE;
  64     pPosition--;
  65     if(pPosition < pBuf)
  66       return FALSE;
  67     if((*pPosition == '\n') || (*pPosition == '\r'))
  68       return FALSE;
  69   }
  70 }
  71
  72 /*******************************************************************/
  73 /*                                                                 */
  74 /* Note: For a section header to be found, the [ must be the first */
  75 /* character on the line.  This prevents the [Options] string in   */
  76 /* the comments of the Sample.pts script from being found as the   */
  77 /* top of the Options section.          -pollmann                  */
  78 /*                                                                 */
  79 /*******************************************************************/
  80 static char * goToSectionBody(char * pBuf, char * szSection)
  81 {
  82   if((pBuf == NULL) || (szSection == NULL))
  83     return NULL;
  84   char szSectionString[256];
  85   strcpy(szSectionString, "\n");   /* Line feed before [ */
  86   strcat(szSectionString, "[");
  87   strcat(szSectionString, szSection);
  88   strcat(szSectionString, "]");
  89   char * p = strstr(pBuf, szSectionString);
  90   if(p == NULL) {
  91     szSectionString[0] = '\r';     /* Carriage return before [ */
  92     char * p = strstr(pBuf, szSectionString);
  93     if(p == NULL)
  94       return NULL;
  95   }
  96   p += strlen(szSectionString) + 1; // 1 is for new line character
  97   return p;
  98 }
  99
 100 static int getSectionLength(char * pBuf, char * szSection)
 101 {
 102   int iRet = 0;
 103
 104   char * pSectionStart = goToSectionBody(pBuf, szSection);
 105
 106   if(pSectionStart == NULL)
 107     return 0;
 108
 109   char * pNextSection = strstr(pSectionStart, "[");
 110
 111   if(pNextSection != NULL)
 112     iRet = (int)(pNextSection - pSectionStart);
 113   else
 114     iRet = (int)(pBuf + strlen(pBuf) - pSectionStart);
 115
 116   return iRet;
 117 }
 118
 119 static char * goToKeyBody(char * pSectionStart, int iSectionLength, char * szKey)
 120 {
 121   if((pSectionStart == NULL) || (szKey == NULL))
 122     return NULL;
 123   if((int)strlen(szKey) >= iSectionLength)
 124     return NULL;
 125   char szKeyString[256];
 126   strcpy(szKeyString, szKey);
 127   strcat(szKeyString, "=");
 128   char chBackup = pSectionStart[iSectionLength];
 129   pSectionStart[iSectionLength] = '\0';
 130   char * p = strstr(pSectionStart, szKeyString);
 131   if(p == NULL)
 132   {
 133     pSectionStart[iSectionLength] = chBackup;
 134     return NULL;
 135   }
 136   p = strstr(p, "=");
 137   if(p == NULL)
 138   {
 139     pSectionStart[iSectionLength] = chBackup;
 140     return NULL;
 141   }
 142   p++;
 143   pSectionStart[iSectionLength] = chBackup;
 144   if(isCurrentLineCommentedOut(pSectionStart, p))
 145     return NULL;
 146   else
 147     return p;
 148 }
 149
 150 static int getKeyLength(char * pSectionStart, int iSectionLength, char * szKey)
 151 {
 152   int iRet = 0;
 153
 154   char * pKeyStart = goToKeyBody(pSectionStart, iSectionLength, szKey);
 155
 156   if(pKeyStart == NULL)
 157     return 0;
 158
 159   char * pFirstCarriageReturn = strchr(pKeyStart, '\r');
 160   char * pFirstNewLine = strchr(pKeyStart, '\n');
 161
 162   if((pFirstCarriageReturn == NULL) && (pFirstNewLine == NULL))
 163     return iSectionLength;
 164
 165   char * p = NULL;
 166
 167   if((pFirstCarriageReturn != NULL) && (pFirstNewLine != NULL))
 168     p = (pFirstCarriageReturn < pFirstNewLine) ? pFirstCarriageReturn : pFirstNewLine;
 169   else
 170     p = (pFirstCarriageReturn != NULL) ? pFirstCarriageReturn : pFirstNewLine;
 171
 172   p--;
 173
 174   // cut off ending spaces and tabs
 175   while((*p == ' ') || (*p == '\t'))
 176     p--;
 177
 178   p++;
 179
 180   iRet = (int)(p - pKeyStart);
 181
 182   return iRet;
 183 }
 184
 185 static char * readFileToNewAllocatedZeroTerminatedBuffer(XP_HFILE hFile)
 186 {
 187   if(hFile == NULL)
 188     return NULL;
 189
 190   int iSize;
 191
 192 #ifdef XP_MAC
 193   iSize = 32000;  /* HACK for the MAC */
 194 #else
 195   #if defined(XP_UNIX) || defined(XP_OS2)
 196     struct stat buf;
 197     fstat(fileno(hFile), &buf);
 198     iSize = buf.st_size;
 199   #else
 200     iSize = (int)_filelength(/*_fileno*/(hFile));
 201   #endif
 202 #endif
 203
 204   if(iSize <= 0)
 205     return NULL;
 206
 207   char * pBuf = new char[iSize + 1];
 208   if(pBuf == NULL)
 209     return NULL;
 210
 211   fseek((FILE *)hFile, 0L, SEEK_SET);
 212   fread((void *)pBuf, iSize, 1, (FILE *)hFile);
 213
 214   // cut off strange stuff at the end and reallocate
 215   char * p = pBuf + iSize - 1;
 216   for(;;)
 217   {
 218     BOOL bNormalChar = ((int)*p > 0) && (isprint(*p) != 0);
 219     if(bNormalChar || (*p == '\n') || (*p == '\r') || (p < pBuf))
 220       break;
 221     p--;
 222   }
 223   p++;
 224   *p = '\0';
 225
 226   iSize = strlen(pBuf);
 227   char * pBufFinal = new char[iSize + 1];
 228   memcpy((void *)pBufFinal, (void *)pBuf, iSize);
 229   pBufFinal[iSize] = '\0';
 230   delete [] pBuf;
 231   return pBufFinal;
 232 }
 233
 234 DWORD PP_GetString(char * szSection, char * szKey, char * szDefault, char * szString, DWORD dwSize,  XP_HFILE hFile)
 235 {
 236   char * pBuf = NULL;
 237   char * pSectionStart = NULL;
 238   int iSectionLength = 0;
 239   int iSize = 0;
 240
 241   pBuf = readFileToNewAllocatedZeroTerminatedBuffer(hFile);
 242
 243   if(pBuf == NULL)
 244     goto ReturnDefault;
 245
 246   iSize = strlen(pBuf);
 247
 248   //
 249   // first consider two special cases: szSection = NULL and szKey = NULL
 250   //
 251   if(szSection == NULL) // find all sections and return
 252   {
 253     char * pNextSection = NULL;
 254     char * pSource = pBuf;
 255     char * pDest = szString;
 256     int iBytes = 0;
 257
 258     for(;;)
 259     {
 260       pSource = strstr(pSource, "[");
 261       if(pSource == NULL)
 262         break;
 263
 264       pNextSection = pSource + 1;
 265       char * pEnd = strstr(pSource, "]");
 266       int iLength = pEnd - pNextSection;
 267
 268       if(!isCurrentLineCommentedOut(pBuf, pSource))
 269       {
 270         if(iBytes + iLength + 2 < (int)dwSize)
 271           memcpy((void *)pDest, (void *)pNextSection, iLength);
 272         else
 273           break;
 274
 275         pDest += iLength;
 276         *pDest = '\0';
 277         pDest++;
 278         iBytes += iLength + 1;  // for '\0'
 279         if(iBytes >= iSize)
 280           break;
 281       }
 282       pSource += iLength + 2; // for "[" and "]"
 283     }
 284
 285     *pDest = '\0';
 286     iBytes++; // for this '\0'
 287     delete [] pBuf;
 288     return (DWORD)iBytes;
 289   }
 290
 291   pSectionStart = goToSectionBody(pBuf, szSection);
 292
 293   if(pSectionStart == NULL)
 294     goto ReturnDefault;
 295
 296   iSectionLength = getSectionLength(pBuf, szSection);
 297
 298   if(iSectionLength == 0)
 299     goto ReturnDefault;
 300
 301   if(szKey == NULL) // find all keys and return
 302   {
 303     int iBytes = 0;
 304     char * pSource = pSectionStart - 1; // point to previous new line char
 305     char * pDest = szString;
 306
 307     for(;;)
 308     {
 309       char * pEqualSign = strstr(pSource, "=");
 310
 311       if(pEqualSign > pSectionStart + iSectionLength)
 312         break;
 313
 314       *pEqualSign = '\0';
 315
 316       char * pLastCarriageReturn = strrchr(pSource, '\r');
 317       char * pLastNewLine = strrchr(pSource, '\n');
 318
 319       if((pLastCarriageReturn == NULL) && (pLastNewLine == NULL))
 320       {
 321         pSource = pEqualSign + 1;
 322         continue;
 323       }
 324
 325       char * pKey = (pLastCarriageReturn > pLastNewLine) ? pLastCarriageReturn : pLastNewLine;
 326       pKey++;
 327       int iLength = strlen(pKey);
 328
 329       if(!isCurrentLineCommentedOut(pBuf, pKey))
 330       {
 331         if(iBytes + iLength + 2 < (int)dwSize)
 332           memcpy((void *)pDest, (void *)pKey, iLength);
 333         else
 334           break;
 335
 336         pDest += iLength;
 337         *pDest = '\0';
 338         pDest++;
 339         iBytes += iLength + 1; // for '\0'
 340         if(iBytes >= iSize)
 341           break;
 342       }
 343       pSource = pEqualSign + 1;
 344     }
 345
 346     *pDest = '\0';
 347     iBytes++; // for this '\0'
 348     delete [] pBuf;
 349     return (DWORD)iBytes;
 350   }
 351
 352   //
 353   // Now the real thing
 354   //
 355   {
 356     char * pKeyStart = goToKeyBody(pSectionStart, iSectionLength, szKey);
 357     if(pKeyStart == NULL)
 358       goto ReturnDefault;
 359     int iKeyLength = getKeyLength(pSectionStart, iSectionLength, szKey);
 360     int iLength = (iKeyLength < (int)dwSize - 1) ? iKeyLength : (int)dwSize - 1;
 361     memcpy((void *)szString, (void *)pKeyStart, iLength);
 362     szString[iLength] = '\0';
 363     delete [] pBuf;
 364     return (DWORD)iLength;
 365   }
 366
 367 ReturnDefault:
 368
 369   if(pBuf != NULL)
 370     delete [] pBuf;
 371   if((szDefault != NULL) && (szString != NULL))
 372     strcpy(szString, szDefault);
 373   return (DWORD)strlen(szString);
 374 }
 375
 376 static BOOL replaceBytesInReallocatedBufferAfter(
 377                  char ** ppBuf,       // address of buffer pointer
 378                  char * szString,     // string to make a replacement with
 379                  int iPosition,       // byte after which to insert the string
 380                  int iBytesToReplace) // number of bytes to replace
 381 {
 382   if(ppBuf == NULL)
 383     return FALSE;
 384   char * pBuf = *ppBuf;
 385   if(pBuf == NULL)
 386     return FALSE;
 387
 388   int iNewLength = strlen(pBuf) - iBytesToReplace + strlen(szString);
 389   char * pBufNew = new char[iNewLength + 1]; // 1 - for zero termination
 390   if(pBufNew == NULL)
 391     return FALSE;
 392   if(iPosition > 0)
 393     memcpy((void *)pBufNew, (void *)pBuf, iPosition);
 394   char * p = pBufNew + iPosition;
 395   memcpy((void *)p, (void *)szString, strlen(szString));
 396   p += strlen(szString);
 397   memcpy((void *)p, (void *)(pBuf + iPosition + iBytesToReplace), strlen(pBuf) - iPosition - iBytesToReplace);
 398   p += strlen(pBuf) - iPosition - iBytesToReplace;
 399   *p = '\0';
 400   delete [] pBuf;
 401   *ppBuf = pBufNew;
 402   return TRUE;
 403 }
 404
 405 BOOL PP_WriteString(char * szSection, char * szKey, char * szString, XP_HFILE hFile)
 406 {
 407   if((szSection == NULL) || (szKey == NULL) || (szString == NULL) || (hFile == NULL))
 408     return FALSE;
 409
 410   char * pBuf = readFileToNewAllocatedZeroTerminatedBuffer(hFile);
 411
 412   if(pBuf == NULL)
 413     return FALSE;
 414
 415 #if !(defined XP_MAC || defined XP_UNIX || defined XP_OS2)
 416   long lOldSize = (long)strlen(pBuf);
 417 #endif
 418
 419   char * pSectionStart = goToSectionBody(pBuf, szSection);
 420
 421   // add section if not present
 422   if(pSectionStart == NULL)
 423   {
 424     char szNewSection[256];
 425     strcpy(szNewSection, "[");
 426     strcat(szNewSection, szSection);
 427     strcat(szNewSection, "]");
 428     strcat(szNewSection, "\n");
 429     strcat(szNewSection, "\n");
 430     if(!replaceBytesInReallocatedBufferAfter(&pBuf, szNewSection, 0, 0))
 431     {
 432       if(pBuf != NULL)
 433         delete [] pBuf;
 434       return FALSE;
 435     }
 436     pSectionStart = goToSectionBody(pBuf, szSection);
 437   }
 438
 439   if(pSectionStart == NULL)
 440     return FALSE;
 441
 442   int iSectionLength = getSectionLength(pBuf, szSection);
 443   char * pKeyStart = goToKeyBody(pSectionStart, iSectionLength, szKey);
 444
 445   // add key if not present
 446   if(pKeyStart == NULL)
 447   {
 448     char szNewKey[256];
 449     strcpy(szNewKey, szKey);
 450     strcat(szNewKey, "=");
 451     strcat(szNewKey, "\n");
 452     int iPos = pSectionStart - pBuf;
 453     if(!replaceBytesInReallocatedBufferAfter(&pBuf, szNewKey, iPos, 0))
 454     {
 455       if(pBuf != NULL)
 456         delete [] pBuf;
 457       return FALSE;
 458     }
 459     pSectionStart = goToSectionBody(pBuf, szSection);
 460     iSectionLength = getSectionLength(pBuf, szSection);
 461     pKeyStart = goToKeyBody(pSectionStart, iSectionLength, szKey);
 462   }
 463
 464   if(pKeyStart == NULL)
 465     return FALSE;
 466
 467   int iKeyLength = getKeyLength(pSectionStart, iSectionLength, szKey);
 468   int iPos = pKeyStart - pBuf;
 469   if(!replaceBytesInReallocatedBufferAfter(&pBuf, szString, iPos, iKeyLength))
 470   {
 471     if(pBuf != NULL)
 472       delete [] pBuf;
 473     return FALSE;
 474   }
 475
 476 #if (defined XP_MAC || defined XP_UNIX || defined XP_OS2)
 477         rewind(hFile);
 478 #else
 479   // change file size
 480   long lNewSize = (long)strlen(pBuf);
 481   long lSizeChange = lNewSize - lOldSize;
 482   if(lSizeChange != 0L)
 483   {
 484     long lOldFileSize = (long)_filelength(/*_fileno*/(hFile));
 485     long lNewFileSize = lOldFileSize + lSizeChange;
 486     _chsize(/*_fileno*/(hFile), lNewFileSize);
 487   }
 488
 489   fseek((FILE *)hFile, 0L, SEEK_SET);
 490 #endif
 491
 492   fwrite(pBuf, strlen(pBuf), 1, (FILE *)hFile);
 493
 494   delete [] pBuf;
 495
 496   return TRUE;
 497 }