modules/libreg/src/vr_stubs.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   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 /* this file contains stubs needed to build the registry routines
  39  * into a stand-alone library for use with our installers
  40  */
  41
  42 #ifdef STANDALONE_REGISTRY
  43
  44 #include <stdlib.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47
  48 #else
  49
  50 #include "prtypes.h"
  51 #include "plstr.h"
  52
  53 #endif /*STANDALONE_REGISTRY*/
  54
  55 #include "vr_stubs.h"
  56
  57 #ifdef XP_MACOSX
  58 #include <Carbon/Carbon.h>
  59 #include <stdlib.h>
  60 #endif
  61
  62 #ifdef XP_BEOS
  63 #include <FindDirectory.h>
  64 #endif
  65
  66 #ifdef XP_MACOSX
  67 /* So that we're not dependent on the size of chars in a wide string literal */
  68 static const UniChar kOSXRegParentName[] =
  69   { 'M', 'o', 'z', 'i', 'l', 'l', 'a' };
  70 static const UniChar kOSXRegName[] =
  71   { 'G', 'l', 'o', 'b', 'a', 'l', '.', 'r', 'e', 'g', 's' };
  72 static const UniChar kOSXVersRegName[] =
  73   { 'V', 'e', 'r', 's', 'i', 'o', 'n', 's', '.', 'r', 'e', 'g', 's' };
  74
  75 #define UNICHAR_ARRAY_LEN(s) (sizeof(s) / sizeof(UniChar))
  76 #endif
  77
  78 #define DEF_REG "/.mozilla/registry"
  79 #define WIN_REG "\\mozregistry.dat"
  80 #define MAC_REG "\pMozilla Registry"
  81 #define BEOS_REG "/mozilla/registry"
  82
  83 #define DEF_VERREG "/.mozilla/mozver.dat"
  84 #define WIN_VERREG "\\mozver.dat"
  85 #define MAC_VERREG "\pMozilla Versions"
  86 #define BEOS_VERREG "/mozilla/mozver.dat"
  87
  88
  89 /* ------------------------------------------------------------------
  90  *  OS/2 STUBS
  91  * ------------------------------------------------------------------
  92  */
  93 #ifdef XP_OS2
  94 #define INCL_DOS
  95 #include <os2.h>
  96
  97 #ifdef STANDALONE_REGISTRY
  98 extern XP_File vr_fileOpen (const char *name, const char * mode)
  99 {
 100     XP_File fh = NULL;
 101     struct stat st;
 102
 103     if ( name != NULL ) {
 104         if ( stat( name, &st ) == 0 )
 105             fh = fopen( name, XP_FILE_UPDATE_BIN );
 106         else
 107             fh = fopen( name, XP_FILE_TRUNCATE_BIN );
 108     }
 109
 110     return fh;
 111 }
 112 #endif /*STANDALONE_REGISTRY*/
 113
 114 extern void vr_findGlobalRegName ()
 115 {
 116     char    path[ CCHMAXPATH ];
 117     int     pathlen;
 118     XP_File fh = NULL;
 119     struct stat st;
 120
 121     XP_STRCPY(path, ".");
 122     pathlen = strlen(path);
 123
 124     if ( pathlen > 0 ) {
 125         XP_STRCPY( path+pathlen, WIN_REG );
 126         globalRegName = XP_STRDUP(path);
 127     }
 128 }
 129
 130 char* vr_findVerRegName()
 131 {
 132     /* need to find a global place for the version registry */
 133     if ( verRegName == NULL )
 134     {
 135         if ( globalRegName == NULL)
 136             vr_findGlobalRegName();
 137         verRegName = XP_STRDUP(globalRegName);
 138     }
 139
 140     return verRegName;
 141 }
 142
 143 #endif /* XP_OS2 */
 144
 145
 146 /* ------------------------------------------------------------------
 147  *  WINDOWS STUBS
 148  * ------------------------------------------------------------------
 149  */
 150 #if defined(XP_WIN)
 151 #include "windows.h"
 152 #define PATHLEN 260
 153
 154 #ifdef STANDALONE_REGISTRY
 155 extern XP_File vr_fileOpen (const char *name, const char * mode)
 156 {
 157     XP_File fh = NULL;
 158     struct stat st;
 159
 160     if ( name != NULL ) {
 161         if ( stat( name, &st ) == 0 )
 162             fh = fopen( name, XP_FILE_UPDATE_BIN );
 163         else
 164             fh = fopen( name, XP_FILE_TRUNCATE_BIN );
 165     }
 166
 167     return fh;
 168 }
 169 #endif /*STANDALONE_REGISTRY*/
 170
 171 extern void vr_findGlobalRegName ()
 172 {
 173     char    path[ PATHLEN ];
 174     int     pathlen;
 175
 176     pathlen = GetWindowsDirectory(path, PATHLEN);
 177     if ( pathlen > 0 ) {
 178         XP_FREEIF(globalRegName);
 179         XP_STRCPY( path+pathlen, WIN_REG );
 180         globalRegName = XP_STRDUP(path);
 181     }
 182 }
 183
 184 char* vr_findVerRegName()
 185 {
 186     char    path[ PATHLEN ];
 187     int     pathlen;
 188
 189     if ( verRegName == NULL )
 190     {
 191         pathlen = GetWindowsDirectory(path, PATHLEN);
 192         if ( pathlen > 0 ) {
 193             XP_STRCPY( path+pathlen, WIN_VERREG );
 194             verRegName = XP_STRDUP(path);
 195         }
 196     }
 197
 198     return verRegName;
 199 }
 200
 201 #if !defined(WIN32) && !defined(__BORLANDC__)
 202 int FAR PASCAL _export WEP(int);
 203
 204 int FAR PASCAL LibMain(HANDLE hInst, WORD wDataSeg, WORD wHeapSize, LPSTR lpszCmdLine)
 205 {
 206     if ( wHeapSize > 0 )
 207         UnlockData(0);
 208     return 1;
 209 }
 210
 211 int FAR PASCAL _export WEP(int nParam)
 212 {
 213     return 1;
 214 }
 215 #endif /* not WIN32 */
 216
 217 #endif /* XP_WIN */
 218
 219
 220 /* ------------------------------------------------------------------
 221  *  MACINTOSH STUBS
 222  * ------------------------------------------------------------------
 223  */
 224
 225 #if defined(XP_MAC) || defined(XP_MACOSX)
 226 #include <Files.h>
 227
 228 #ifdef STANDALONE_REGISTRY
 229 extern XP_File vr_fileOpen(const char *name, const char * mode)
 230 {
 231     XP_File fh = NULL;
 232     struct stat st;
 233
 234 #ifdef STANDALONE_REGISTRY
 235     errno = 0; /* reset errno (only if we're using stdio) */
 236 #endif
 237
 238     if ( name != NULL ) {
 239         if ( stat( name, &st ) == 0 )
 240             fh = fopen( name, XP_FILE_UPDATE_BIN );
 241         else
 242         {
 243             /* should never get here! */
 244             fh = fopen( name, XP_FILE_TRUNCATE_BIN );
 245         }
 246     }
 247     return fh;
 248 }
 249 #endif /*STANDALONE_REGISTRY*/
 250
 251 #if defined (XP_MACOSX)
 252 extern void vr_findGlobalRegName()
 253 {
 254     OSErr   err;
 255     FSRef   foundRef;
 256
 257     err = FSFindFolder(kLocalDomain, kDomainLibraryFolderType, kDontCreateFolder, &foundRef);
 258     if (err == noErr)
 259     {
 260         FSRef parentRef;
 261         err = FSMakeFSRefUnicode(&foundRef, UNICHAR_ARRAY_LEN(kOSXRegParentName), kOSXRegParentName,
 262                                  kTextEncodingUnknown, &parentRef);
 263         if (err == fnfErr)
 264         {
 265             err = FSCreateDirectoryUnicode(&foundRef, UNICHAR_ARRAY_LEN(kOSXRegParentName), kOSXRegParentName,
 266                                            kFSCatInfoNone, NULL, &parentRef, NULL, NULL);
 267         }
 268         if (err == noErr)
 269         {
 270             FSRef regRef;
 271             err = FSMakeFSRefUnicode(&parentRef, UNICHAR_ARRAY_LEN(kOSXRegName), kOSXRegName,
 272                                      kTextEncodingUnknown, &regRef);
 273             if (err == fnfErr)
 274             {
 275                 FSCatalogInfo catalogInfo;
 276                 FileInfo fileInfo = { 'REGS', 'MOSS', 0, { 0, 0 }, 0 };
 277                 BlockMoveData(&fileInfo, &(catalogInfo.finderInfo), sizeof(FileInfo));
 278                 err = FSCreateFileUnicode(&parentRef, UNICHAR_ARRAY_LEN(kOSXRegName), kOSXRegName,
 279                                                kFSCatInfoFinderInfo, &catalogInfo, &regRef, NULL);
 280             }
 281             if (err == noErr)
 282             {
 283                 UInt8 pathBuf[PATH_MAX];
 284                 err = FSRefMakePath(&regRef, pathBuf, sizeof(pathBuf));
 285                 if (err == noErr)
 286                     globalRegName = XP_STRDUP(pathBuf);
 287             }
 288         }
 289     }
 290 }
 291 #else
 292 extern void vr_findGlobalRegName()
 293 {
 294     FSSpec  regSpec;
 295     OSErr   err;
 296     short   foundVRefNum;
 297     long    foundDirID;
 298     int     bCreate = 0;
 299
 300     err = FindFolder(kOnSystemDisk,'pref', false, &foundVRefNum, &foundDirID);
 301
 302     if (err == noErr)
 303     {
 304         err = FSMakeFSSpec(foundVRefNum, foundDirID, MAC_REG, &regSpec);
 305
 306         if (err == -43) /* if file doesn't exist */
 307         {
 308             err = FSpCreate(&regSpec, 'MOSS', 'REGS', smSystemScript);
 309             bCreate = 1;
 310         }
 311
 312         if (err == noErr)
 313         {
 314             Handle thePath;
 315             short pathLen;
 316             err = FSpGetFullPath(&regSpec, &pathLen, &thePath);
 317             if (err == noErr && thePath)
 318             {
 319                 /* we have no idea if this moves memory, so better lock the handle */
 320             #if defined(STANDALONE_REGISTRY) || defined(USE_STDIO_MODES)
 321                 HLock(thePath);
 322                 globalRegName = (char *)XP_ALLOC(pathLen + 1);
 323                 XP_STRNCPY(globalRegName, *thePath, pathLen);
 324                 globalRegName[pathLen] = '\0';
 325             #else
 326                 /* Since we're now using NSPR, this HAS to be a unix path! */
 327                 const char* src;
 328                 char* dst;
 329                 HLock(thePath);
 330                 globalRegName = (char*)XP_ALLOC(pathLen + 2);
 331                 src = *(char**)thePath;
 332                 dst = globalRegName;
 333                 *dst++ = '/';
 334                 while (pathLen--)
 335                 {
 336                     char c = *src++;
 337                     *dst++ = (c == ':') ? '/' : c;
 338                 }
 339                 *dst = '\0';
 340             #endif
 341             }
 342             DisposeHandle(thePath);
 343         }
 344     }
 345 }
 346 #endif /* XP_MACOSX */
 347
 348 #ifdef XP_MACOSX
 349 extern char* vr_findVerRegName()
 350 {
 351     OSErr   err;
 352     FSRef   foundRef;
 353
 354     err = FSFindFolder(kLocalDomain, kDomainLibraryFolderType, kDontCreateFolder, &foundRef);
 355     if (err == noErr)
 356     {
 357         FSRef parentRef;
 358         err = FSMakeFSRefUnicode(&foundRef, UNICHAR_ARRAY_LEN(kOSXRegParentName), kOSXRegParentName,
 359                                  kTextEncodingUnknown, &parentRef);
 360         if (err == fnfErr)
 361         {
 362             err = FSCreateDirectoryUnicode(&foundRef, UNICHAR_ARRAY_LEN(kOSXRegParentName), kOSXRegParentName,
 363                                            kFSCatInfoNone, NULL, &parentRef, NULL, NULL);
 364         }
 365         if (err == noErr)
 366         {
 367             FSRef regRef;
 368             err = FSMakeFSRefUnicode(&parentRef, UNICHAR_ARRAY_LEN(kOSXVersRegName), kOSXVersRegName,
 369                                      kTextEncodingUnknown, &regRef);
 370             if (err == fnfErr)
 371             {
 372                 FSCatalogInfo catalogInfo;
 373                 FileInfo fileInfo = { 'REGS', 'MOSS', 0, { 0, 0 }, 0 };
 374                 BlockMoveData(&fileInfo, &(catalogInfo.finderInfo), sizeof(FileInfo));
 375                 err = FSCreateFileUnicode(&parentRef, UNICHAR_ARRAY_LEN(kOSXVersRegName), kOSXVersRegName,
 376                                                kFSCatInfoFinderInfo, &catalogInfo, &regRef, NULL);
 377             }
 378             if (err == noErr)
 379             {
 380                 UInt8 pathBuf[PATH_MAX];
 381                 err = FSRefMakePath(&regRef, pathBuf, sizeof(pathBuf));
 382                 if (err == noErr)
 383                     verRegName = XP_STRDUP(pathBuf);
 384             }
 385         }
 386     }
 387     return verRegName;
 388 }
 389 #else
 390 extern char* vr_findVerRegName()
 391 {
 392     FSSpec  regSpec;
 393     OSErr   err;
 394     short   foundVRefNum;
 395     long    foundDirID;
 396     int     bCreate = 0;
 397
 398     /* quick exit if we have the info */
 399     if ( verRegName != NULL )
 400         return verRegName;
 401
 402     err = FindFolder(kOnSystemDisk,'pref', false, &foundVRefNum, &foundDirID);
 403
 404     if (err == noErr)
 405     {
 406         err = FSMakeFSSpec(foundVRefNum, foundDirID, MAC_VERREG, &regSpec);
 407
 408         if (err == -43) /* if file doesn't exist */
 409         {
 410             err = FSpCreate(&regSpec, 'MOSS', 'REGS', smSystemScript);
 411             bCreate = 1;
 412         }
 413
 414         if (err == noErr)
 415         {
 416             Handle thePath;
 417             short pathLen;
 418             err = FSpGetFullPath(&regSpec, &pathLen, &thePath);
 419             if (err == noErr && thePath)
 420             {
 421                 /* we have no idea if this moves memory, so better lock the handle */
 422              #if defined(STANDALONE_REGISTRY) || defined(USE_STDIO_MODES)
 423                 HLock(thePath);
 424                 verRegName = (char *)XP_ALLOC(pathLen + 1);
 425                 XP_STRNCPY(verRegName, *thePath, pathLen);
 426                 verRegName[pathLen] = '\0';
 427             #else
 428                 /* Since we're now using NSPR, this HAS to be a unix path! */
 429                 const char* src;
 430                 char* dst;
 431                 HLock(thePath);
 432                 verRegName = (char*)XP_ALLOC(pathLen + 2);
 433                 src = *(char**)thePath;
 434                 dst = verRegName;
 435                 *dst++ = '/';
 436                 while (pathLen--)
 437                 {
 438                     char c = *src++;
 439                     *dst++ = (c == ':') ? '/' : c;
 440                 }
 441                 *dst = '\0';
 442             #endif
 443             }
 444             DisposeHandle(thePath);
 445         }
 446     }
 447
 448     return verRegName;
 449 }
 450 #endif /* OS_MACOSX */
 451
 452 /* Moves and renames a file or directory.
 453    Returns 0 on success, -1 on failure (errno contains mac error code).
 454  */
 455 #ifndef XP_MACOSX
 456 extern int nr_RenameFile(char *from, char *to)
 457 {
 458     OSErr           err = -1;
 459     FSSpec          fromSpec;
 460     FSSpec          toSpec;
 461     FSSpec          destDirSpec;
 462     FSSpec          beforeRenameSpec;
 463
 464 #ifdef STANDALONE_REGISTRY
 465     errno = 0; /* reset errno (only if we're using stdio) */
 466 #endif
 467
 468     if (from && to) {
 469         err = FSpLocationFromFullPath(XP_STRLEN(from), from, &fromSpec);
 470         if (err != noErr) goto exit;
 471
 472         err = FSpLocationFromFullPath(XP_STRLEN(to), to, &toSpec);
 473         if (err != noErr && err != fnfErr) goto exit;
 474
 475         /* make an FSSpec for the destination directory */
 476         err = FSMakeFSSpec(toSpec.vRefNum, toSpec.parID, nil, &destDirSpec);
 477         if (err != noErr) goto exit; /* parent directory must exist */
 478
 479         /* move it to the directory specified */
 480         err = FSpCatMove(&fromSpec, &destDirSpec);
 481         if (err != noErr) goto exit;
 482
 483         /* make a new FSSpec for the file or directory in its new location  */
 484         err = FSMakeFSSpec(toSpec.vRefNum, toSpec.parID, fromSpec.name, &beforeRenameSpec);
 485         if (err != noErr) goto exit;
 486
 487         /* rename the file or directory */
 488         err = FSpRename(&beforeRenameSpec, toSpec.name);
 489     }
 490
 491     exit:
 492 #ifdef STANDALONE_REGISTRY
 493     if (err != noErr)
 494         errno = err;
 495 #endif
 496     return (err == noErr ? 0 : -1);
 497 }
 498 #endif
 499
 500
 501 #ifdef STANDALONE_REGISTRY
 502 #ifndef XP_MACOSX
 503 char *strdup(const char *source)
 504 {
 505         char    *newAllocation;
 506         size_t  stringLength;
 507
 508         stringLength = strlen(source) + 1;
 509
 510         newAllocation = (char *)XP_ALLOC(stringLength);
 511         if (newAllocation == NULL)
 512                 return NULL;
 513         BlockMoveData(source, newAllocation, stringLength);
 514         return newAllocation;
 515 }
 516
 517 int strcasecmp(const char *str1, const char *str2)
 518 {
 519     char    currentChar1, currentChar2;
 520
 521     while (1) {
 522
 523         currentChar1 = *str1;
 524         currentChar2 = *str2;
 525
 526         if ((currentChar1 >= 'a') && (currentChar1 <= 'z'))
 527             currentChar1 += ('A' - 'a');
 528
 529         if ((currentChar2 >= 'a') && (currentChar2 <= 'z'))
 530             currentChar2 += ('A' - 'a');
 531
 532         if (currentChar1 == '\0')
 533             break;
 534
 535         if (currentChar1 != currentChar2)
 536             return currentChar1 - currentChar2;
 537
 538         str1++;
 539         str2++;
 540
 541     }
 542
 543     return currentChar1 - currentChar2;
 544 }
 545
 546 int strncasecmp(const char *str1, const char *str2, int length)
 547 {
 548     char    currentChar1, currentChar2;
 549
 550     while (length > 0) {
 551
 552         currentChar1 = *str1;
 553         currentChar2 = *str2;
 554
 555         if ((currentChar1 >= 'a') && (currentChar1 <= 'z'))
 556             currentChar1 += ('A' - 'a');
 557
 558         if ((currentChar2 >= 'a') && (currentChar2 <= 'z'))
 559             currentChar2 += ('A' - 'a');
 560
 561         if (currentChar1 == '\0')
 562             break;
 563
 564         if (currentChar1 != currentChar2)
 565             return currentChar1 - currentChar2;
 566
 567         str1++;
 568         str2++;
 569
 570         length--;
 571     }
 572
 573     return currentChar1 - currentChar2;
 574 }
 575 #endif /* XP_MACOSX */
 576 #endif /* STANDALONE_REGISTRY */
 577
 578 #endif /* XP_MAC */
 579
 580
 581 /* ------------------------------------------------------------------
 582  *  UNIX STUBS
 583  * ------------------------------------------------------------------
 584  */
 585
 586 /*allow OS/2 and Macintosh to use this main to test...*/
 587 #if (defined(STANDALONE_REGISTRY) && defined(XP_MAC)) || defined(XP_UNIX) || defined(XP_OS2) || defined(XP_BEOS)
 588
 589 #include <stdlib.h>
 590
 591 #ifdef XP_OS2
 592 #include <io.h>
 593 #define W_OK 0x02 /*evil hack from the docs...*/
 594 #else
 595 #include <unistd.h>
 596 #endif
 597
 598 #include "NSReg.h"
 599 #include "VerReg.h"
 600
 601 char *TheRegistry = "registry";
 602 char *Flist;
 603
 604 REGERR vr_ParseVersion(char *verstr, VERSION *result);
 605
 606 #if defined(XP_UNIX) && !defined(XP_MACOSX)
 607
 608 #ifdef STANDALONE_REGISTRY
 609 extern XP_File vr_fileOpen (const char *name, const char * mode)
 610 {
 611     XP_File fh = NULL;
 612     struct stat st;
 613
 614     if ( name != NULL ) {
 615         if ( stat( name, &st ) == 0 )
 616             fh = fopen( name, XP_FILE_UPDATE_BIN );
 617         else
 618             fh = fopen( name, XP_FILE_TRUNCATE_BIN );
 619     }
 620
 621     return fh;
 622 }
 623 #endif /*STANDALONE_REGISTRY*/
 624
 625 extern void vr_findGlobalRegName ()
 626 {
 627 #ifndef STANDALONE_REGISTRY
 628     char *def = NULL;
 629     char *home = getenv("HOME");
 630     if (home != NULL) {
 631         def = (char *) XP_ALLOC(XP_STRLEN(home) + XP_STRLEN(DEF_REG)+1);
 632         if (def != NULL) {
 633           XP_STRCPY(def, home);
 634           XP_STRCAT(def, DEF_REG);
 635         }
 636     }
 637     if (def != NULL) {
 638         globalRegName = XP_STRDUP(def);
 639     } else {
 640         globalRegName = XP_STRDUP(TheRegistry);
 641     }
 642     XP_FREEIF(def);
 643 #else
 644     globalRegName = XP_STRDUP(TheRegistry);
 645 #endif /*STANDALONE_REGISTRY*/
 646 }
 647
 648 char* vr_findVerRegName ()
 649 {
 650     if ( verRegName != NULL )
 651         return verRegName;
 652
 653 #ifndef STANDALONE_REGISTRY
 654     {
 655         char *def = NULL;
 656         char *home = getenv("HOME");
 657         if (home != NULL) {
 658             def = (char *) XP_ALLOC(XP_STRLEN(home) + XP_STRLEN(DEF_VERREG)+1);
 659             if (def != NULL) {
 660                 XP_STRCPY(def, home);
 661                 XP_STRCAT(def, DEF_VERREG);
 662             }
 663         }
 664         if (def != NULL) {
 665             verRegName = XP_STRDUP(def);
 666         }
 667         XP_FREEIF(def);
 668     }
 669 #else
 670     verRegName = XP_STRDUP(TheRegistry);
 671 #endif /*STANDALONE_REGISTRY*/
 672
 673     return verRegName;
 674 }
 675
 676 #endif /*XP_UNIX*/
 677
 678  /* ------------------------------------------------------------------
 679  *  BeOS STUBS
 680  * ------------------------------------------------------------------
 681  */
 682
 683 #ifdef XP_BEOS
 684
 685 #ifdef STANDALONE_REGISTRY
 686 extern XP_File vr_fileOpen (const char *name, const char * mode)
 687 {
 688     XP_File fh = NULL;
 689     struct stat st;
 690
 691     if ( name != NULL ) {
 692         if ( stat( name, &st ) == 0 )
 693             fh = fopen( name, XP_FILE_UPDATE_BIN );
 694         else
 695             fh = fopen( name, XP_FILE_TRUNCATE_BIN );
 696     }
 697
 698     return fh;
 699 }
 700 #endif /*STANDALONE_REGISTRY*/
 701
 702 extern void vr_findGlobalRegName ()
 703 {
 704 #ifndef STANDALONE_REGISTRY
 705     char *def = NULL;
 706       char settings[1024];
 707       find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, settings, sizeof(settings));
 708     if (settings != NULL) {
 709         def = (char *) XP_ALLOC(XP_STRLEN(settings) + XP_STRLEN(BEOS_REG)+1);
 710         if (def != NULL) {
 711           XP_STRCPY(def, settings);
 712           XP_STRCAT(def, BEOS_REG);
 713         }
 714     }
 715     if (def != NULL) {
 716         globalRegName = XP_STRDUP(def);
 717     } else {
 718         globalRegName = XP_STRDUP(TheRegistry);
 719     }
 720     XP_FREEIF(def);
 721 #else
 722     globalRegName = XP_STRDUP(TheRegistry);
 723 #endif /*STANDALONE_REGISTRY*/
 724 }
 725
 726 char* vr_findVerRegName ()
 727 {
 728     if ( verRegName != NULL )
 729         return verRegName;
 730
 731 #ifndef STANDALONE_REGISTRY
 732     {
 733         char *def = NULL;
 734         char settings[1024];
 735         find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, settings, sizeof(settings));
 736         if (settings != NULL) {
 737             def = (char *) XP_ALLOC(XP_STRLEN(settings) + XP_STRLEN(BEOS_VERREG)+1);
 738             if (def != NULL) {
 739                 XP_STRCPY(def, settings);
 740                 XP_STRCAT(def, BEOS_VERREG);
 741             }
 742         }
 743         if (def != NULL) {
 744             verRegName = XP_STRDUP(def);
 745         }
 746         XP_FREEIF(def);
 747     }
 748 #else
 749     verRegName = XP_STRDUP(TheRegistry);
 750 #endif /*STANDALONE_REGISTRY*/
 751
 752     return verRegName;
 753 }
 754
 755 #endif /*XP_BEOS*/
 756
 757 #endif /* XP_UNIX || XP_OS2 */