src/OSD/OSD_File.cxx

   1 // Copyright (c) 1998-1999 Matra Datavision
   2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   3 //
   4 // This file is part of Open CASCADE Technology software library.
   5 //
   6 // This library is free software; you can redistribute it and/or modify it under
   7 // the terms of the GNU Lesser General Public License version 2.1 as published
   8 // by the Free Software Foundation, with special exception defined in the file
   9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  10 // distribution for complete text of the license and disclaimer of any warranty.
  11 //
  12 // Alternatively, this file may be used under the terms of Open CASCADE
  13 // commercial license or contractual agreement.
  14
  15 //------------------------------------------------------------------------
  16 //                    UNIX Part
  17 //------------------------------------------------------------------------
  18
  19 #ifndef _WIN32
  20
  21
  22 #include <OSD_File.hxx>
  23 #include <OSD_FromWhere.hxx>
  24 #include <OSD_OSDError.hxx>
  25 #include <OSD_Path.hxx>
  26 #include <OSD_Printer.hxx>
  27 #include <OSD_Protection.hxx>
  28 #include <OSD_WhoAmI.hxx>
  29 #include <Standard_PCharacter.hxx>
  30 #include <Standard_ProgramError.hxx>
  31 #include <TCollection_AsciiString.hxx>
  32
  33 const OSD_WhoAmI Iam = OSD_WFile;
  34
  35 #if defined (sun) || defined(SOLARIS)
  36 #define POSIX
  37 #else
  38 #define SYSV
  39 #endif
  40
  41 #include <errno.h>
  42 #include <stdlib.h>
  43 #include <stdio.h>
  44 #include <fcntl.h>
  45 #include <unistd.h>
  46 #include <sys/stat.h>
  47
  48 #define NEWLINE '\10';
  49
  50 // ---------------------------------------------------------------------
  51 // Create an empty file object
  52 // ---------------------------------------------------------------------
  53
  54 OSD_File::OSD_File():OSD_FileNode()
  55 {
  56  ImperativeFlag = Standard_False;
  57  myLock         = OSD_NoLock;
  58  myIO           = 0;
  59  myMode         = OSD_ReadWrite;
  60  myFILE         = (Standard_Address) NULL;
  61  myFileChannel  = -1;
  62  myFileHandle   = 0;
  63 }
  64
  65 // ---------------------------------------------------------------------
  66 // Create and initialize a file object
  67 // ---------------------------------------------------------------------
  68
  69 OSD_File::OSD_File(const OSD_Path& Name):OSD_FileNode(Name)
  70 {
  71  ImperativeFlag = Standard_False;
  72  myLock         = OSD_NoLock;
  73  myIO           = 0;
  74  myMode         = OSD_ReadWrite;
  75  myFILE         = (Standard_Address) NULL;
  76  myFileChannel  = -1;
  77  myFileHandle   = 0;
  78 }
  79
  80 // protect against occasional use of myFileHande in Linux code
  81 #define myFileHandle myFileHandle_is_only_for_Windows
  82
  83 // ---------------------------------------------------------------------
  84 // Build a file if it doesn't exist or create again if it already exists
  85 // ---------------------------------------------------------------------
  86
  87 void OSD_File::Build(const OSD_OpenMode Mode,
  88                      const OSD_Protection& Protect){
  89
  90  Standard_Integer internal_prot;
  91  Standard_Integer internal_mode = O_CREAT | O_TRUNC ;
  92  TCollection_AsciiString aBuffer;
  93
  94  if (myPath.Name().Length()==0)
  95   Standard_ProgramError::Raise("OSD_File::Build : no name was given");
  96
  97  if (myFileChannel != -1)
  98   Standard_ProgramError::Raise("OSD_File::Build : file is already open");
  99
 100
 101  myMode = Mode;
 102
 103  internal_prot = Protect.Internal();
 104
 105  const char* CMode = "r";
 106
 107  switch (Mode){
 108   case OSD_ReadOnly:
 109    internal_mode |= O_RDONLY;
 110    CMode = "r";
 111    break;
 112   case OSD_WriteOnly:
 113    internal_mode |= O_WRONLY;
 114    CMode = "w";
 115    break;
 116   case OSD_ReadWrite:
 117    internal_mode |= O_RDWR;
 118    CMode = "w+";
 119    break;
 120  }
 121
 122  myPath.SystemName( aBuffer );
 123  myFileChannel = open (aBuffer.ToCString(), internal_mode, internal_prot);
 124  if (myFileChannel >= 0) {
 125    myFILE = fdopen (myFileChannel, CMode);
 126  }
 127  else
 128  /* Handle OPEN errors */
 129
 130    myError.SetValue (errno, Iam, "Open");
 131
 132 }
 133
 134
 135
 136 // ---------------------------------------------------------------------
 137 // Append to an existing file
 138 // ---------------------------------------------------------------------
 139
 140 void  OSD_File::Append(const OSD_OpenMode Mode,
 141                        const OSD_Protection& Protect){
 142
 143  Standard_Integer internal_prot;
 144  Standard_Integer internal_mode = O_APPEND;;
 145  TCollection_AsciiString aBuffer;
 146
 147  if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
 148     Standard_ProgramError::Raise("OSD_File::Append : it is a directory");
 149  }
 150
 151  if (myPath.Name().Length()==0)
 152   Standard_ProgramError::Raise("OSD_File::Append : no name was given");
 153
 154  if (myFileChannel != -1)
 155   Standard_ProgramError::Raise("OSD_File::Append : file is already open");
 156
 157  internal_prot = Protect.Internal();
 158  myMode = Mode;
 159  const char* CMode = "r";
 160
 161  switch (Mode){
 162   case OSD_ReadOnly:
 163    internal_mode |= O_RDONLY;
 164    CMode = "r";
 165    break;
 166   case OSD_WriteOnly:
 167    internal_mode |= O_WRONLY;
 168    CMode = "a";
 169    break;
 170   case OSD_ReadWrite:
 171    internal_mode |= O_RDWR;
 172    CMode = "a+";
 173    break;
 174  }
 175
 176  // If file doesn't exist, creates it.
 177
 178  if (!Exists()) internal_mode |= O_CREAT;
 179
 180  myPath.SystemName ( aBuffer );
 181  myFileChannel = open (aBuffer.ToCString(), internal_mode, internal_prot);
 182  if (myFileChannel >= 0)
 183    myFILE = fdopen (myFileChannel, CMode);
 184  else
 185  /* Handle OPEN errors */
 186
 187    myError.SetValue (errno, Iam, "Open");
 188 }
 189
 190 // ---------------------------------------------------------------------
 191 // Open a file
 192 // ---------------------------------------------------------------------
 193
 194 void  OSD_File::Open(const OSD_OpenMode Mode,
 195                      const OSD_Protection& Protect){
 196
 197  Standard_Integer internal_prot;
 198  Standard_Integer internal_mode = 0;
 199  TCollection_AsciiString aBuffer;
 200
 201   if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
 202     myError.SetValue (1, Iam, "Could not be open : it is a directory");
 203   }
 204
 205  if (myPath.Name().Length()==0)
 206   Standard_ProgramError::Raise("OSD_File::Open : no name was given");
 207
 208  if (myFileChannel != -1)
 209   Standard_ProgramError::Raise("OSD_File::Open : file is already open");
 210
 211  internal_prot = Protect.Internal();
 212  myMode = Mode;
 213  const char* CMode = "r";
 214
 215  switch (Mode){
 216   case OSD_ReadOnly:
 217    internal_mode |= O_RDONLY;
 218    CMode = "r";
 219    break;
 220   case OSD_WriteOnly:
 221    internal_mode |= O_WRONLY;
 222    CMode = "w";
 223    break;
 224   case OSD_ReadWrite:
 225    internal_mode |= O_RDWR;
 226    CMode = "w+";
 227    break;
 228  }
 229
 230  myPath.SystemName ( aBuffer );
 231  myFileChannel = open (aBuffer.ToCString(), internal_mode, internal_prot);
 232  if (myFileChannel >= 0)
 233    myFILE = fdopen (myFileChannel, CMode);
 234  else
 235  /* Handle OPEN errors */
 236
 237    myError.SetValue (errno, Iam, "Open");
 238 }
 239
 240
 241
 242 // ---------------------------------------------------------------------
 243 // ---------------------------------------------------------------------
 244 OSD_File OSD_File::BuildTemporary(){
 245
 246 #if defined(vax) || defined(__vms) || defined(VAXVMS)
 247  FILE *fic;
 248  OSD_File result;
 249  int dummy;
 250
 251  fic = tmpfile();
 252  dummy = open("dummy", O_RDWR | O_CREAT);  // Open a dummy file
 253  result.myFileChannel = dummy - 1;         // This is file channel of "fic" +1
 254  close(dummy);                             // Close dummy file
 255  unlink("dummy");                          // Removes dummy file
 256
 257 #else
 258  OSD_File result;
 259  char *name = tmpnam((char*) 0) ;
 260
 261
 262  TCollection_AsciiString aName ( name ) ;
 263  OSD_Path aPath( aName ) ;
 264
 265  result.SetPath( aPath ) ;
 266
 267  result.myFILE  = fopen( name, "w+" ) ;
 268
 269  result.myFileChannel = fileno( (FILE*)result.myFILE );
 270
 271 #endif
 272
 273  result.myMode = OSD_ReadWrite;
 274
 275  return (result);
 276 }
 277
 278
 279
 280 // ---------------------------------------------------------------------
 281 // Read content of a file
 282 // ---------------------------------------------------------------------
 283
 284 void  OSD_File::Read(TCollection_AsciiString& Buffer,
 285                      const Standard_Integer Nbyte){
 286  Standard_PCharacter readbuf;
 287  int status;
 288
 289   if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
 290     Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
 291   }
 292
 293  if (myFileChannel == -1)
 294   Standard_ProgramError::Raise("OSD_File::Read : file is not open");
 295
 296  if (Failed()) Perror();
 297
 298  if (myMode == OSD_WriteOnly)
 299   Standard_ProgramError::Raise("OSD_File::Read : file is Write only");
 300
 301  if (Nbyte <= 0)
 302   Standard_ProgramError::Raise("OSD_File::Read : Nbyte is null");
 303
 304  TCollection_AsciiString transfert(Nbyte,' ');
 305  readbuf = (Standard_PCharacter)transfert.ToCString();
 306
 307  status = read (myFileChannel, readbuf, Nbyte);
 308  //
 309  Buffer = transfert;  // Copy transfert to Buffer
 310
 311  if (status == -1) myError.SetValue (errno, Iam, "Read");
 312  else
 313  if ( status < Nbyte ) myIO = EOF;
 314 }
 315
 316
 317 // ---------------------------------------------------------------------
 318 // Read a line from a file
 319 // ---------------------------------------------------------------------
 320
 321 void OSD_File::ReadLine(TCollection_AsciiString& Buffer,
 322                         const Standard_Integer Nbyte,
 323                         Standard_Integer& NByteRead)
 324 {
 325   Standard_PCharacter readbuf, abuffer;
 326   //
 327   if (OSD_File::KindOfFile() == OSD_DIRECTORY ) {
 328     Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
 329   }
 330   if (myFileChannel == -1){
 331     Standard_ProgramError::Raise("OSD_File::ReadLine : file is not open");
 332   }
 333   if (Failed()) {
 334     Perror();
 335   }
 336   if (myMode == OSD_WriteOnly) {
 337     Standard_ProgramError::Raise("OSD_File::ReadLine : file is Write only");
 338   }
 339   if (Nbyte <= 0){
 340     Standard_ProgramError::Raise("OSD_File::ReadLine : Nbyte is null");
 341   }
 342   //
 343   TCollection_AsciiString transfert(Nbyte,' ');
 344   readbuf = (Standard_PCharacter)transfert.ToCString();
 345   //
 346   abuffer = fgets(readbuf, Nbyte, (FILE *) myFILE);
 347   //
 348   if (abuffer == NULL) {
 349     if (!feof((FILE *) myFILE)) {
 350       myError.SetValue (errno, Iam, "ReadLine");
 351       return;
 352     }
 353     else {
 354       myIO = EOF;
 355       Buffer.Clear();
 356       NByteRead = 0 ;
 357     }
 358   }
 359   else   {
 360     NByteRead = (Standard_Integer)strlen(abuffer);
 361     Buffer.SetValue(1,abuffer);  // Copy transfert to Buffer
 362     Buffer.Trunc(NByteRead);
 363   }
 364 }
 365 // --------------------------------------------------------------------------
 366 // OSD::KindOfFile Retourne le type de fichier.
 367 // --------------------------------------------------------------------------
 368 OSD_KindFile OSD_File::KindOfFile ( ) const{
 369 int status;
 370 struct stat buffer;
 371 TCollection_AsciiString FullName;
 372 OSD_Path aPath;
 373
 374 Path(aPath);
 375 aPath.SystemName (FullName);
 376 status = stat (FullName.ToCString()  , &buffer );
 377 if ( status == 0) {
 378   if       (  S_ISDIR(buffer.st_mode)  )  { return OSD_DIRECTORY ; }
 379   else if  (  S_ISREG(buffer.st_mode)  )  { return OSD_FILE      ; }
 380   else if  (  S_ISLNK(buffer.st_mode)  )  { return OSD_LINK      ; }
 381   else if  (  S_ISSOCK(buffer.st_mode) )  { return OSD_SOCKET    ; }
 382   else                                    { return OSD_UNKNOWN   ; }
 383 }
 384 return OSD_UNKNOWN   ;
 385
 386 }
 387 // --------------------------------------------------------------------------
 388 // Read content of a file
 389 // --------------------------------------------------------------------------
 390 void  OSD_File::Read(      Standard_Address&  Buffer,
 391                      const Standard_Integer   Nbyte,
 392                            Standard_Integer&  Readbyte)
 393 {
 394   int status;
 395
 396   Readbyte = 0;
 397   if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
 398     Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
 399   }
 400
 401   if (myFileChannel == -1)
 402     Standard_ProgramError::Raise("OSD_File::Read : file is not open");
 403
 404   if (Failed()) Perror();
 405
 406   if (myMode == OSD_WriteOnly)
 407     Standard_ProgramError::Raise("OSD_File::Read : file is Write only");
 408
 409   if (Nbyte <= 0)
 410     Standard_ProgramError::Raise("OSD_File::Read : Nbyte is null");
 411
 412   if (Buffer == NULL)
 413     Standard_ProgramError::Raise("OSD_File::Read : Buffer is null");
 414
 415   status = read (myFileChannel, (char*) Buffer, Nbyte);
 416
 417   if (status == -1) myError.SetValue (errno, Iam, "Read");
 418   else{
 419     if ( status < Nbyte ) myIO = EOF;
 420     Readbyte = status;
 421   }
 422 }
 423
 424 // Write content of a file
 425
 426 void  OSD_File::Write(const TCollection_AsciiString &Buffer,
 427                       const Standard_Integer Nbyte){
 428
 429  Standard_CString writebuf;
 430  int status;
 431
 432  if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
 433    Standard_ProgramError::Raise("OSD_File::Write : it is a directory");
 434  }
 435
 436  if (myFileChannel == -1)
 437   Standard_ProgramError::Raise("OSD_File::Write : file is not open");
 438
 439  if (Failed()) Perror();
 440
 441  if (myMode == OSD_ReadOnly)
 442   Standard_ProgramError::Raise("OSD_File::Write : file is Read only");
 443
 444  if (Nbyte <= 0)
 445   Standard_ProgramError::Raise("OSD_File::Write : Nbyte is null");
 446
 447  writebuf = Buffer.ToCString();
 448
 449  status = write (myFileChannel, writebuf, Nbyte);
 450
 451  if ( status == -1) myError.SetValue (errno, Iam, "Write");
 452  else
 453  if ( status < Nbyte ) myIO = EOF;
 454 }
 455
 456
 457 void  OSD_File::Write(const Standard_Address   Buffer,
 458                       const Standard_Integer   Nbyte)
 459 {
 460
 461   int status;
 462
 463   if (myFileChannel == -1)
 464     Standard_ProgramError::Raise("OSD_File::Write : file is not open");
 465
 466   if (Failed()) Perror();
 467
 468   if (myMode == OSD_ReadOnly)
 469     Standard_ProgramError::Raise("OSD_File::Write : file is Read only");
 470
 471   if (Nbyte <= 0)
 472     Standard_ProgramError::Raise("OSD_File::Write : Nbyte is null");
 473
 474   status = write (myFileChannel, (const char *)Buffer, Nbyte);
 475
 476   if ( status == -1) myError.SetValue (errno, Iam, "Write");
 477   else
 478     if ( status < Nbyte ) myIO = EOF;
 479 }
 480
 481
 482
 483
 484
 485 // Move file pointer to a specified position
 486
 487 void  OSD_File::Seek(const Standard_Integer Offset,
 488                      const OSD_FromWhere Whence){
 489  int iwhere=0;
 490
 491  if (myFileChannel == -1)
 492   Standard_ProgramError::Raise("OSD_File::Seek : file is not open");
 493
 494  if (Failed()) Perror();
 495
 496  switch (Whence){
 497   case OSD_FromBeginning :
 498     iwhere = SEEK_SET;
 499     break;
 500   case OSD_FromHere:
 501     iwhere = SEEK_CUR;
 502     break;
 503   case OSD_FromEnd:
 504     iwhere = SEEK_END;
 505     break;
 506   default :
 507    myError.SetValue (EINVAL, Iam, "Seek");
 508  }
 509
 510  off_t status = lseek (myFileChannel, Offset, iwhere);
 511  if (status == -1) myError.SetValue (errno, Iam, "Seek");
 512 }
 513
 514
 515
 516
 517
 518
 519 // Close a file
 520
 521 void  OSD_File::Close(){
 522  int status;
 523
 524  if (myFileChannel == -1)
 525   Standard_ProgramError::Raise("OSD_File::Close : file is not open");
 526
 527  if (Failed()) Perror();
 528
 529  // note: it probably should be single call to fclose()...
 530  status = close (myFileChannel);
 531
 532  if (status == -1) myError.SetValue (errno, Iam, "Close");
 533  myFileChannel = -1;
 534  if ( myFILE != NULL ) {
 535    status = fclose ( (FILE*) myFILE );
 536    myFILE = NULL;
 537  }
 538  myIO = 0;
 539 }
 540
 541
 542
 543
 544 // --------------------------------------------------------------------------
 545 // Test if at end of file
 546 // --------------------------------------------------------------------------
 547
 548 Standard_Boolean OSD_File::IsAtEnd(){
 549  if (myFileChannel == -1)
 550   Standard_ProgramError::Raise("OSD_File::IsAtEnd : file is not open");
 551
 552  if (myIO == EOF) return (Standard_True);
 553  return (Standard_False);
 554 }
 555
 556
 557
 558 /*void  OSD_File::Link(const TCollection_AsciiString& ToFile){
 559  if (myFileChannel == -1)
 560   Standard_ProgramError::Raise("OSD_File::Link : file is not open");
 561
 562  TCollection_AsciiString aBuffer;
 563  myPath.SystemName ( aBuffer );
 564  link ( aBuffer.ToCString(), ToFile.ToCString() );
 565
 566 }*/
 567
 568
 569
 570 void  OSD_File::SetLock(const OSD_LockType Lock){
 571 int status;
 572
 573  if (myFileChannel == -1)
 574   Standard_ProgramError::Raise("OSD_File::SetLock : file is not open");
 575
 576
 577 #ifdef POSIX
 578  int lock;
 579  struct stat buf;
 580
 581  switch (Lock){
 582   case OSD_ExclusiveLock :
 583   case OSD_WriteLock     : lock = F_LOCK;
 584                            break;
 585   case OSD_ReadLock      : return;
 586                            break;
 587   default : myError.SetValue (EINVAL, Iam, "SetLock");
 588             return;
 589  }
 590
 591  if (fstat (myFileChannel, &buf) == -1) {
 592   myError.SetValue (errno, Iam, "SetLock");
 593   return;
 594  }
 595
 596  status = lockf(myFileChannel, lock, buf.st_size);
 597  if (status == -1) myError.SetValue (errno, Iam, "SetLock");
 598  else myLock = Lock;
 599
 600 #else
 601 #ifdef SYSV
 602  struct stat  buf;
 603  struct flock key;
 604
 605  switch (Lock){
 606   case OSD_ExclusiveLock :
 607   case OSD_WriteLock     : key.l_type = F_WRLCK;
 608                            break;
 609   case OSD_ReadLock      : key.l_type = F_RDLCK;
 610                            break;
 611   case OSD_NoLock : return;
 612  // default : myError.SetValue (EINVAL, Iam, "SetLock");
 613  }
 614
 615  key.l_whence = 0;
 616  key.l_start = 0;
 617  key.l_len = 0;
 618
 619  status = fcntl (myFileChannel, F_SETLKW, &key);
 620  if (status == -1) myError.SetValue (errno, Iam, "SetLock");
 621  else myLock = Lock;
 622
 623  if (Lock == OSD_ExclusiveLock){
 624   fstat (myFileChannel, &buf);
 625   TCollection_AsciiString aBuffer;
 626   myPath.SystemName ( aBuffer );
 627   chmod( aBuffer.ToCString() ,buf.st_mode | S_ISGID);
 628   ImperativeFlag = Standard_True;
 629  }
 630
 631 #else   /* BSD */
 632  int lock;
 633
 634  switch (Lock){
 635   case OSD_ExclusiveLock :
 636   case OSD_WriteLock     : lock = F_WRLCK;
 637                            break;
 638   case OSD_ReadLock      : lock = F_RDLCK;
 639                            break;
 640   default : myError.SetValue (EINVAL, Iam, "SetLock");
 641  }
 642
 643  status = flock (myFileChannel, lock);
 644  if (status == -1) myError.SetValue (errno, Iam, "SetLock");
 645  else myLock = Lock;
 646 #endif // SysV
 647 #endif // POSIX
 648 }
 649
 650
 651
 652
 653 // Remove a lock from a file
 654
 655 void  OSD_File::UnLock(){
 656 int status;
 657
 658  if (myFileChannel == -1)
 659   Standard_ProgramError::Raise("OSD_File::UnLock : file is not open");
 660
 661 #ifdef POSIX
 662  struct stat buf;
 663
 664  if (fstat(myFileChannel, &buf) == -1) {
 665   myError.SetValue(errno, Iam, "UnsetLock");
 666   return;
 667  }
 668
 669  status = lockf(myFileChannel,F_ULOCK, buf.st_size);
 670   if (status == -1) myError.SetValue (errno, Iam, "SetLock");
 671
 672 #else
 673 #ifdef SYSV
 674  struct stat  buf;
 675  struct flock key;
 676
 677  if (ImperativeFlag){
 678   fstat (myFileChannel, &buf);
 679   TCollection_AsciiString aBuffer;
 680   myPath.SystemName ( aBuffer );
 681   chmod(aBuffer.ToCString(),buf.st_mode & ~S_ISGID);
 682   ImperativeFlag = Standard_False;
 683  }
 684  key.l_type = F_UNLCK;
 685  status = fcntl (myFileChannel, F_SETLK, &key);
 686  if (status == -1) myError.SetValue (errno, Iam, "UnSetLock");
 687 #else
 688
 689  status = flock (myFileChannel, LOCK_UN);
 690  if (status == -1) myError.SetValue (errno, Iam, "UnSetLock");
 691 #endif
 692 #endif // POSIX
 693  else myLock = OSD_NoLock;
 694 }
 695
 696
 697
 698
 699
 700 // Return lock of a file
 701
 702 OSD_LockType  OSD_File::GetLock(){
 703  return(myLock);
 704 }
 705
 706
 707
 708
 709 // --------------------------------------------------------------------------
 710 // Return size of a file
 711 // --------------------------------------------------------------------------
 712
 713 Standard_Size  OSD_File::Size(){
 714  struct stat buffer;
 715  int status;
 716
 717  if (myPath.Name().Length()==0)
 718   Standard_ProgramError::Raise("OSD_File::Size : empty file name");
 719
 720  TCollection_AsciiString aBuffer;
 721  myPath.SystemName ( aBuffer );
 722  status = stat( aBuffer.ToCString() ,&buffer );
 723  if (status == -1) {
 724   myError.SetValue (errno, Iam, "Size");
 725   return 0;
 726  }
 727
 728  return (Standard_Size)buffer.st_size;
 729 }
 730
 731
 732 // --------------------------------------------------------------------------
 733 // Print contains of a file
 734 // --------------------------------------------------------------------------
 735
 736 void OSD_File::Print (const OSD_Printer &WhichPrinter ){
 737 char buffer[255];
 738 TCollection_AsciiString PrinterName;
 739
 740  if (myPath.Name().Length()==0)
 741    Standard_ProgramError::Raise("OSD_File::Print : empty file name");
 742
 743  WhichPrinter.Name(PrinterName);
 744
 745  TCollection_AsciiString aBuffer;
 746  myPath.SystemName ( aBuffer );
 747
 748  if (PrinterName.Length()==0)
 749    sprintf(buffer,"lp %s",aBuffer.ToCString());
 750  else
 751    sprintf(buffer,"lpr -P%s %s",PrinterName.ToCString(),aBuffer.ToCString());
 752
 753  system(buffer);
 754 }
 755
 756
 757 // --------------------------------------------------------------------------
 758 // Test if a file is open
 759 // --------------------------------------------------------------------------
 760
 761 Standard_Boolean OSD_File::IsOpen()const{
 762  return (myFileChannel != -1);
 763 }
 764
 765
 766 Standard_Boolean OSD_File::IsLocked(){
 767  return(myLock != OSD_NoLock);
 768 }
 769
 770 Standard_Boolean OSD_File::IsReadable()
 771 {
 772   TCollection_AsciiString FileName ;
 773
 774   myPath.SystemName(FileName) ;
 775
 776   if (access(FileName.ToCString(),F_OK|R_OK))
 777     return Standard_False;
 778   else
 779     return Standard_True;
 780 }
 781
 782 Standard_Boolean OSD_File::IsWriteable()
 783 {
 784   TCollection_AsciiString FileName ;
 785
 786   myPath.SystemName(FileName) ;
 787
 788   if (access(FileName.ToCString(),F_OK|R_OK|W_OK))
 789     return Standard_False;
 790   else
 791     return Standard_True;
 792 }
 793
 794 Standard_Boolean OSD_File::IsExecutable()
 795 {
 796   TCollection_AsciiString FileName ;
 797
 798   myPath.SystemName(FileName) ;
 799
 800   if (access(FileName.ToCString(),F_OK|X_OK))
 801     return Standard_False;
 802   else
 803     return Standard_True;
 804 }
 805
 806 #else /* _WIN32 */
 807
 808 //------------------------------------------------------------------------
 809 //-------------------  Windows NT sources for OSD_File -------------------
 810 //------------------------------------------------------------------------
 811
 812 #include <windows.h>
 813
 814 #include <OSD_File.hxx>
 815 #include <OSD_Protection.hxx>
 816 #include <OSD_Printer.hxx>
 817 #include <Standard_ProgramError.hxx>
 818
 819 #include <OSD_WNT_1.hxx>
 820
 821 #include <stdio.h>
 822 #include <io.h>
 823 #include <Standard_PCharacter.hxx>
 824 #include <TCollection_ExtendedString.hxx>
 825
 826 #ifndef _INC_TCHAR
 827 # include <tchar.h>
 828 #endif  // _INC_TCHAR
 829
 830 #if defined(__CYGWIN32__) || defined(__MINGW32__)
 831 #define VAC
 832 #define _int64 int
 833 #endif
 834
 835 #pragma comment( lib, "WSOCK32.LIB"  )
 836 #pragma comment( lib, "WINSPOOL.LIB" )
 837
 838 #define ACE_HEADER_SIZE (  sizeof ( ACCESS_ALLOWED_ACE ) - sizeof ( DWORD )  )
 839
 840 #define RAISE( arg ) Standard_ProgramError :: Raise (  ( arg )  )
 841 #define TEST_RAISE( arg ) _test_raise (  myFileHandle, ( arg )  )
 842
 843 #define OPEN_NEW    0
 844 #define OPEN_OLD    1
 845 #define OPEN_APPEND 2
 846
 847 void                            _osd_wnt_set_error        ( OSD_Error&, OSD_WhoAmI, ... );
 848 PSECURITY_DESCRIPTOR __fastcall _osd_wnt_protection_to_sd ( const OSD_Protection&, BOOL, wchar_t* = NULL );
 849 BOOL                 __fastcall _osd_wnt_sd_to_protection (
 850                                  PSECURITY_DESCRIPTOR, OSD_Protection&, BOOL
 851                                 );
 852 BOOL                 __fastcall _osd_print (const Standard_PCharacter, const wchar_t* );
 853
 854 static void      __fastcall _test_raise ( HANDLE, Standard_CString );
 855 static Standard_Integer __fastcall _get_line (Standard_PCharacter& buffer, DWORD dwBuffSize, LONG& theSeekPos);
 856 static int       __fastcall _get_buffer ( HANDLE, Standard_PCharacter&, DWORD, BOOL, BOOL );
 857 static DWORD     __fastcall _get_access_mask ( OSD_SingleProtection );
 858 static DWORD     __fastcall _get_dir_access_mask ( OSD_SingleProtection prt );
 859 static HANDLE    __fastcall _open_file  ( Standard_CString, OSD_OpenMode, DWORD, LPBOOL = NULL );
 860
 861 static OSD_SingleProtection __fastcall _get_protection     ( DWORD );
 862 static OSD_SingleProtection __fastcall _get_protection_dir ( DWORD );
 863
 864 typedef OSD_SingleProtection ( __fastcall *GET_PROT_FUNC ) ( DWORD );
 865
 866 Standard_Integer __fastcall _get_file_type ( Standard_CString, HANDLE );
 867
 868 // ---------------------------------------------------------------------
 869 // Create an empty file object
 870 // ---------------------------------------------------------------------
 871
 872 OSD_File :: OSD_File ()
 873 {
 874  ImperativeFlag = Standard_False;
 875  myLock         = OSD_NoLock;
 876  myIO           = 0;
 877  myFileChannel  = -1;
 878  myFileHandle   = INVALID_HANDLE_VALUE;
 879 }  // end constructor ( 1 )
 880
 881 // ---------------------------------------------------------------------
 882 // Create and initialize a file object
 883 // ---------------------------------------------------------------------
 884
 885 OSD_File :: OSD_File ( const OSD_Path& Name ) : OSD_FileNode ( Name )
 886 {
 887  ImperativeFlag = Standard_False;
 888  myLock         = OSD_NoLock;
 889  myIO           = 0;
 890  myPath         = Name;
 891  myFileChannel  = -1;
 892  myFileHandle   = INVALID_HANDLE_VALUE;
 893 }  // end constructor ( 2 )
 894
 895 // protect against occasional use of myFileHande in Windows code
 896 #define myFileChannel myFileChannel_is_only_for_Linux
 897
 898 // ---------------------------------------------------------------------
 899 // Build a file if it doesn't exist or create again if it already exists
 900 // ---------------------------------------------------------------------
 901
 902 void OSD_File :: Build (
 903                   const OSD_OpenMode Mode, const OSD_Protection& Protect
 904                  ) {
 905
 906  TCollection_AsciiString fName;
 907
 908  if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
 909    Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
 910  }
 911
 912  if (myFileHandle != INVALID_HANDLE_VALUE)
 913
 914   RAISE(  "OSD_File :: Build (): incorrect call - file already opened"  );
 915
 916  myMode = Mode;
 917  myPath.SystemName ( fName );
 918
 919  if (  fName.IsEmpty ()  )
 920
 921   RAISE(  "OSD_File :: Build (): incorrent call - no filename given"  );
 922
 923  myFileHandle = _open_file ( fName.ToCString (), Mode, OPEN_NEW );
 924
 925  if (myFileHandle == INVALID_HANDLE_VALUE)
 926
 927   _osd_wnt_set_error ( myError, OSD_WFile );
 928
 929  else {
 930
 931   SetProtection ( Protect );
 932   myIO |= FLAG_FILE;
 933
 934  }  // end else
 935
 936 }  // end OSD_File :: Build
 937
 938
 939
 940 // ---------------------------------------------------------------------
 941 // Open a file
 942 // ---------------------------------------------------------------------
 943
 944 void OSD_File :: Open (const OSD_OpenMode Mode, const OSD_Protection& /*Protect*/)
 945 {
 946
 947  TCollection_AsciiString fName;
 948
 949
 950  if (myFileHandle != INVALID_HANDLE_VALUE)
 951
 952   RAISE(  "OSD_File :: Open (): incorrect call - file already opened"  );
 953
 954  myMode = Mode;
 955  myPath.SystemName ( fName );
 956
 957  if (  fName.IsEmpty ()  )
 958
 959   RAISE(  "OSD_File :: Open (): incorrent call - no filename given"  );
 960
 961  myFileHandle = _open_file ( fName.ToCString (), Mode, OPEN_OLD );
 962
 963  if (myFileHandle == INVALID_HANDLE_VALUE) {
 964
 965    _osd_wnt_set_error ( myError, OSD_WFile );
 966  }
 967  else
 968    {
 969      myIO |= _get_file_type (  fName.ToCString (), myFileHandle  );
 970    }
 971 }  // end OSD_File :: Open
 972
 973 // ---------------------------------------------------------------------
 974 // Append to an existing file
 975 // ---------------------------------------------------------------------
 976
 977 void OSD_File :: Append (
 978                   const OSD_OpenMode Mode, const OSD_Protection& Protect
 979                  ) {
 980
 981  BOOL                    fNew = FALSE;
 982  TCollection_AsciiString fName;
 983
 984  if (myFileHandle != INVALID_HANDLE_VALUE)
 985
 986   RAISE(  "OSD_File :: Append (): incorrect call - file already opened"  );
 987
 988  myMode = Mode;
 989  myPath.SystemName ( fName );
 990
 991  if (  fName.IsEmpty ()  )
 992
 993   RAISE(  "OSD_File :: Append (): incorrent call - no filename given"  );
 994
 995  myFileHandle = _open_file ( fName.ToCString (), Mode, OPEN_APPEND, &fNew );
 996
 997  if (myFileHandle == INVALID_HANDLE_VALUE)
 998
 999   _osd_wnt_set_error ( myError, OSD_WFile );
1000
1001  else {
1002
1003   if ( !fNew ) {
1004
1005    myIO |= _get_file_type (  fName.ToCString (), myFileHandle  );
1006    Seek ( 0, OSD_FromEnd );
1007
1008   } else {
1009
1010    SetProtection ( Protect );
1011    myIO |= FLAG_FILE;
1012
1013   }  // end else
1014
1015  }  // end else;
1016
1017 }  // end OSD_File :: Append
1018
1019 // ---------------------------------------------------------------------
1020 // Read content of a file
1021 // ---------------------------------------------------------------------
1022
1023 void OSD_File :: Read (
1024                   TCollection_AsciiString& Buffer, const Standard_Integer Nbyte
1025                  ) {
1026
1027  if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
1028 #ifdef OCCT_DEBUG
1029    cout << " OSD_File::Read : it is a directory " << endl;
1030 #endif
1031    return ;
1032 //   Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
1033  }
1034
1035  Standard_Integer NbyteRead;
1036  Standard_Address buff;
1037
1038  TEST_RAISE(  "Read"  );
1039
1040  buff = ( Standard_Address )new Standard_Character[ Nbyte + 1 ];
1041
1042  Read ( buff, Nbyte, NbyteRead );
1043
1044  (  ( Standard_PCharacter )buff  )[ NbyteRead ] = 0;
1045
1046  if ( NbyteRead != 0 )
1047
1048   Buffer = ( Standard_PCharacter )buff;
1049
1050  else
1051
1052   Buffer.Clear ();
1053
1054  delete [] buff;
1055
1056 }  // end OSD_File :: Read
1057
1058 // ---------------------------------------------------------------------
1059 // Read a line from a file
1060 // ---------------------------------------------------------------------
1061
1062 // Modified so that we have <nl> at end of line if we have read <nl> or <cr>
1063 // in the file.
1064 // by LD 17 dec 98 for B4.4
1065
1066 void OSD_File :: ReadLine (
1067                   TCollection_AsciiString& Buffer,
1068                   const Standard_Integer NByte, Standard_Integer& NbyteRead
1069                  ) {
1070
1071  DWORD              dwBytesRead;
1072  DWORD              dwDummy;
1073  Standard_Character peekChar;
1074  Standard_PCharacter ppeekChar;
1075  Standard_PCharacter cBuffer;
1076  LONG               aSeekPos;
1077
1078  if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
1079    Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
1080  }
1081
1082  TEST_RAISE(  "ReadLine"  );
1083
1084  if (  myIO & FLAG_PIPE && !( myIO & FLAG_READ_PIPE )  )
1085
1086   RAISE(  "OSD_File :: ReadLine (): attempt to read from write only pipe"  );
1087
1088                                         // +----> leave space for end-of-string
1089                                         // |       plus <CR><LF> sequence
1090                                         // |
1091
1092  ppeekChar=&peekChar;
1093  cBuffer = new Standard_Character[ NByte + 3 ];
1094
1095  if ( myIO & FLAG_FILE ) {
1096
1097   if (!ReadFile (myFileHandle, cBuffer, NByte, &dwBytesRead, NULL)) {  // an error occured
1098
1099    _osd_wnt_set_error ( myError, OSD_WFile );
1100    Buffer.Clear ();
1101    NbyteRead = 0;
1102
1103   } else if ( dwBytesRead == 0 ) {  // end-of-file reached
1104
1105    Buffer.Clear ();
1106    NbyteRead = 0;
1107    myIO |= FLAG_EOF;
1108
1109   } else {
1110    myIO &= ~FLAG_EOF ;  // if the file increased since last read (LD)
1111    NbyteRead = _get_line (cBuffer, dwBytesRead, aSeekPos);
1112
1113    if ( NbyteRead == -1 )  // last character in the buffer is <CR> -
1114    {                       // peek next character to see if it is a <LF>
1115     if (!ReadFile (myFileHandle, ppeekChar, 1, &dwDummy, NULL)) {
1116
1117      _osd_wnt_set_error ( myError, OSD_WFile );
1118
1119     } else if ( dwDummy != 0 ) {  // end-of-file reached ?
1120
1121      if ( peekChar != '\n' )  // if we did not get a <CR><LF> sequence
1122
1123      // adjust file position
1124
1125       SetFilePointer (myFileHandle, -1, NULL, FILE_CURRENT);
1126
1127     } else
1128      myIO |= FLAG_EOF;
1129
1130     NbyteRead = dwBytesRead;
1131
1132    } else if ( aSeekPos != 0 )
1133    {
1134      SetFilePointer (myFileHandle, aSeekPos, NULL, FILE_CURRENT);
1135    }
1136
1137   }  // end else
1138
1139  } else if ( myIO & FLAG_SOCKET || myIO & FLAG_PIPE || myIO & FLAG_NAMED_PIPE ) {
1140
1141   dwBytesRead = (DWORD)_get_buffer (myFileHandle, cBuffer,
1142                                     (DWORD)NByte, TRUE, myIO & FLAG_SOCKET);
1143
1144   if (  ( int )dwBytesRead == -1  ) { // an error occured
1145
1146    _osd_wnt_set_error ( myError, OSD_WFile );
1147    Buffer.Clear ();
1148    NbyteRead = 0;
1149
1150   } else if ( dwBytesRead == 0 )  { // connection closed - set end-of-file flag
1151
1152    Buffer.Clear ();
1153    NbyteRead = 0;
1154    myIO |= FLAG_EOF;
1155
1156   } else {
1157
1158    NbyteRead = _get_line (cBuffer, dwBytesRead, aSeekPos);
1159
1160    if (NbyteRead == -1) // last character in the buffer is <CR> -
1161    {                     // peek next character to see if it is a <LF>
1162     NbyteRead = dwBytesRead; // (LD) always fits this case.
1163
1164     dwDummy = _get_buffer (myFileHandle, ppeekChar, 1, TRUE, myIO & FLAG_SOCKET);
1165     if (  ( int )dwDummy == -1  ) {  // an error occured
1166
1167      _osd_wnt_set_error ( myError, OSD_WFile );
1168
1169     } else if ( dwDummy != 0 ) {  // connection closed ?
1170
1171      if ( peekChar == '\n' )  // we got a <CR><LF> sequence
1172
1173        dwBytesRead++ ;  // (LD) we have to jump <LF>
1174     } else
1175
1176      myIO |= FLAG_EOF;
1177
1178    } else if (aSeekPos != 0)
1179    {
1180      dwBytesRead = dwBytesRead + aSeekPos;
1181    }
1182
1183    // Don't rewrite datas in cBuffer.
1184
1185    Standard_PCharacter cDummyBuffer = new Standard_Character[ NByte + 3 ];
1186
1187    // remove pending input
1188    _get_buffer (myFileHandle, cDummyBuffer, dwBytesRead, FALSE, myIO & FLAG_SOCKET);
1189    delete [] cDummyBuffer ;
1190
1191   }  // end else
1192
1193  } else
1194
1195   RAISE(  "OSD_File :: ReadLine (): incorrect call - file is a directory"  );
1196
1197  if (  !Failed () && !IsAtEnd ()  )
1198
1199   Buffer = cBuffer;
1200
1201  delete [] (Standard_PCharacter)cBuffer;
1202
1203 }  // end OSD_File :: ReadLine
1204
1205 // --------------------------------------------------------------------------
1206 // Read content of a file
1207 // --------------------------------------------------------------------------
1208
1209 void OSD_File :: Read (
1210                   Standard_Address& Buffer,
1211                   const Standard_Integer Nbyte, Standard_Integer& Readbyte
1212                  ) {
1213
1214  DWORD dwBytesRead;
1215
1216  if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
1217    Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
1218  }
1219
1220  TEST_RAISE(  "Read"  );
1221
1222  if (  myIO & FLAG_PIPE && !( myIO & FLAG_READ_PIPE )  )
1223
1224   RAISE(  "OSD_File :: Read (): attempt to read from write only pipe"  );
1225
1226  if (!ReadFile (myFileHandle, Buffer, (DWORD)Nbyte, &dwBytesRead, NULL)) {
1227
1228   _osd_wnt_set_error ( myError, OSD_WFile );
1229   dwBytesRead = 0;
1230
1231  } else if ( dwBytesRead == 0 )
1232
1233   myIO |= FLAG_EOF;
1234
1235  else
1236
1237   myIO &= ~FLAG_EOF;
1238
1239  Readbyte = ( Standard_Integer )dwBytesRead;
1240
1241 }  // end OSD_File :: Read
1242
1243 void OSD_File :: Write (
1244                   const TCollection_AsciiString& Buffer,
1245                   const Standard_Integer Nbyte
1246                  ) {
1247
1248  Write (  ( Standard_Address )Buffer.ToCString (), Nbyte  );
1249
1250 }  // end OSD_File :: Write
1251
1252 // --------------------------------------------------------------------------
1253 // Write content of a file
1254 // --------------------------------------------------------------------------
1255
1256 void OSD_File :: Write (
1257                   const Standard_Address Buffer,
1258                   const Standard_Integer Nbyte
1259                  ) {
1260
1261  DWORD dwBytesWritten;
1262
1263  TEST_RAISE(  "Write"  );
1264
1265  if ( myIO & FLAG_PIPE && myIO & FLAG_READ_PIPE )
1266
1267   RAISE(  "OSD_File :: Write (): attempt to write to read only pipe"  );
1268
1269  if (!WriteFile (myFileHandle, Buffer, (DWORD)Nbyte, &dwBytesWritten, NULL) ||
1270      dwBytesWritten != (DWORD)Nbyte)
1271
1272   _osd_wnt_set_error ( myError, OSD_WFile );
1273
1274 }  // end OSD_File :: Write
1275
1276 void OSD_File :: Seek (
1277                   const Standard_Integer Offset, const OSD_FromWhere Whence
1278                  ) {
1279
1280  DWORD dwMoveMethod = 0;
1281
1282  TEST_RAISE(  "Seek"  );
1283
1284  if ( myIO & FLAG_FILE || myIO & FLAG_DIRECTORY ) {
1285
1286   switch ( Whence ) {
1287
1288    case OSD_FromBeginning:
1289
1290     dwMoveMethod = FILE_BEGIN;
1291
1292    break;
1293
1294    case OSD_FromHere:
1295
1296     dwMoveMethod = FILE_CURRENT;
1297
1298    break;
1299
1300    case OSD_FromEnd:
1301
1302     dwMoveMethod = FILE_END;
1303
1304    break;
1305
1306    default:
1307
1308     RAISE(  "OSD_File :: Seek (): invalid parameter"  );
1309
1310   }  // end switch
1311
1312   if (SetFilePointer (myFileHandle, (LONG)Offset, NULL, dwMoveMethod) == 0xFFFFFFFF)
1313
1314    _osd_wnt_set_error ( myError, OSD_WFile );
1315
1316  }  // end if
1317
1318  myIO &= ~FLAG_EOF;
1319
1320 }  // end OSD_File :: Seek
1321
1322 // --------------------------------------------------------------------------
1323 // Close a file
1324 // --------------------------------------------------------------------------
1325
1326 void OSD_File :: Close () {
1327
1328  TEST_RAISE(  "Close"  );
1329
1330  CloseHandle (myFileHandle);
1331
1332  myFileHandle = INVALID_HANDLE_VALUE;
1333  myIO          = 0;
1334
1335 }  // end OSD_File :: Close
1336
1337 // --------------------------------------------------------------------------
1338 // Test if at end of file
1339 // --------------------------------------------------------------------------
1340
1341 Standard_Boolean OSD_File :: IsAtEnd () {
1342
1343  TEST_RAISE(  "IsAtEnd"  );
1344
1345  if (myIO & FLAG_EOF)
1346    return Standard_True ;
1347  return Standard_False ;
1348
1349 }  // end OSD_File :: IsAtEnd
1350
1351 OSD_KindFile OSD_File :: KindOfFile () const {
1352
1353  OSD_KindFile     retVal;
1354  Standard_Integer flags;
1355
1356  if (myFileHandle == INVALID_HANDLE_VALUE) {
1357
1358   TCollection_AsciiString fName;
1359
1360   myPath.SystemName ( fName );
1361
1362   if (  fName.IsEmpty ()  )
1363
1364    RAISE(  "OSD_File :: KindOfFile (): incorrent call - no filename given"  );
1365
1366   flags = _get_file_type (fName.ToCString(), INVALID_HANDLE_VALUE);
1367
1368  } else
1369
1370   flags = myIO;
1371
1372  switch ( flags & FLAG_TYPE ) {
1373
1374   case FLAG_FILE:
1375
1376    retVal = OSD_FILE;
1377
1378   break;
1379
1380   case FLAG_DIRECTORY:
1381
1382    retVal = OSD_DIRECTORY;
1383
1384   break;
1385
1386   case FLAG_SOCKET:
1387
1388    retVal = OSD_SOCKET;
1389
1390   break;
1391
1392   default:
1393
1394    retVal = OSD_UNKNOWN;
1395
1396  }  // end switch
1397
1398  return retVal;
1399
1400 }  // end OSD_File :: KindOfFile
1401
1402 #ifdef VAC
1403  char tmpbuf [MAX_PATH];
1404  if (GetTempPath (MAX_PATH, tmpbuf) == 0)
1405  {
1406     perror ("ERROR in GetTempPath");
1407     exit (10);
1408  }
1409  char tmpbuf2 [MAX_PATH];
1410  if (GetTempFileName (tmpbuf, NULL, 0, tmpbuf2) == 0)
1411  {
1412     perror ("ERROR in GetTempFileName");
1413     exit (10);
1414  }
1415  TCollection_AsciiString fileName (  tmpbuf2  );
1416 #else
1417  TCollection_AsciiString fileName (  _ttmpnam ( NULL )  );
1418 #endif
1419
1420
1421 //-------------------------------------------------debutpri???980424
1422
1423 typedef struct _osd_wnt_key {
1424
1425                 HKEY   hKey;
1426                 LPTSTR keyPath;
1427
1428                } OSD_WNT_KEY;
1429
1430
1431 OSD_File OSD_File :: BuildTemporary () {
1432
1433  OSD_Protection prt;
1434  OSD_File       retVal;
1435  HKEY           hKey;
1436  TCHAR          tmpPath[ MAX_PATH ];
1437  BOOL           fOK = FALSE;
1438  OSD_WNT_KEY    regKey[ 2 ] = {
1439
1440                  { HKEY_LOCAL_MACHINE,
1441                    "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment"
1442                  },
1443                  { HKEY_USERS,
1444                    ".DEFAULT\\Environment"
1445                  }
1446
1447                 };
1448
1449  for ( int i = 0; i < 2; ++i ) {
1450
1451   if (  RegOpenKeyEx (
1452          regKey[ i ].hKey, regKey[ i ].keyPath, 0, KEY_QUERY_VALUE, &hKey
1453        ) == ERROR_SUCCESS
1454   ) {
1455
1456    DWORD dwType;
1457    DWORD dwSize = 0;
1458
1459    if (  RegQueryValueEx (
1460           hKey, "TEMP", NULL, &dwType, NULL, &dwSize
1461          ) == ERROR_SUCCESS
1462    ) {
1463
1464     LPTSTR kVal = ( LPTSTR )HeapAlloc (
1465                              GetProcessHeap (), HEAP_ZERO_MEMORY | HEAP_GENERATE_EXCEPTIONS,
1466                              dwSize + sizeof ( TCHAR )
1467                             );
1468
1469      RegQueryValueEx (  hKey, "TEMP", NULL, &dwType, ( LPBYTE )kVal, &dwSize  );
1470
1471      if ( dwType == REG_EXPAND_SZ )
1472
1473       ExpandEnvironmentStrings ( kVal, tmpPath, MAX_PATH );
1474
1475      else
1476
1477       lstrcpy ( tmpPath, kVal );
1478
1479     HeapFree (  GetProcessHeap (), 0, ( LPVOID )kVal  );
1480     fOK = TRUE;
1481
1482    }  // end if
1483
1484    RegCloseKey ( hKey );
1485
1486   }  // end if
1487
1488   if ( fOK ) break;
1489
1490  }  // end for
1491
1492  if ( !fOK ) lstrcpy (  tmpPath, "./"  );
1493
1494  GetTempFileName ( tmpPath, "CSF", 0, tmpPath );
1495
1496  retVal.SetPath (  OSD_Path ( tmpPath )  );
1497  retVal.Build   (  OSD_ReadWrite, prt    );
1498
1499  return retVal;
1500
1501 }  // end OSD_File :: BuildTemporary
1502
1503 //-------------------------------------------------finpri???980424
1504
1505 #if defined(__CYGWIN32__) || defined(__MINGW32__)
1506 #define __try
1507 #define __finally
1508 #define __leave return
1509 #endif
1510
1511 void OSD_File :: SetLock ( const OSD_LockType Lock ) {
1512
1513  DWORD      dwFlags;
1514  OVERLAPPED ovlp;
1515
1516  TEST_RAISE(  "SetLock"  );
1517
1518  ZeroMemory (  &ovlp, sizeof ( OVERLAPPED )  );
1519
1520  __try {
1521
1522   if (  ( myLock = Lock ) == OSD_NoLock  ) {
1523
1524    UnLock ();
1525    __leave;
1526
1527   } else if ( myLock == OSD_ReadLock || myLock == OSD_ExclusiveLock ) {
1528
1529    dwFlags = LOCKFILE_EXCLUSIVE_LOCK;
1530
1531   } else
1532
1533    dwFlags = 0;
1534
1535   LARGE_INTEGER aSize;
1536   aSize.QuadPart = Size();
1537   if (!LockFileEx (myFileHandle, dwFlags, 0, aSize.LowPart, aSize.HighPart, &ovlp)) {
1538
1539    _osd_wnt_set_error ( myError, OSD_WFile );
1540    __leave;
1541
1542   }  // end if
1543
1544   ImperativeFlag = Standard_True;
1545
1546  }  // end __try
1547
1548  __finally {}
1549
1550 #ifdef VAC
1551 leave: ;         // added for VisualAge
1552 #endif
1553 }  // end OSD_File :: SetLock
1554
1555 #if defined(__CYGWIN32__) || defined(__MINGW32__)
1556 #undef __try
1557 #undef __finally
1558 #undef __leave
1559 #endif
1560
1561 void OSD_File :: UnLock () {
1562
1563  TEST_RAISE(  "Unlock"  );
1564
1565  if ( ImperativeFlag ) {
1566
1567   LARGE_INTEGER aSize;
1568   aSize.QuadPart = Size();
1569   if (!UnlockFile (myFileHandle, 0, 0, aSize.LowPart, aSize.HighPart))
1570
1571    _osd_wnt_set_error ( myError, OSD_WFile );
1572
1573   ImperativeFlag = Standard_False;
1574
1575  }  // end if
1576
1577 }  // end OSD_File :: UnLock
1578
1579 OSD_LockType OSD_File :: GetLock () {
1580
1581  return myLock;
1582
1583 }  // end OSD_File :: GetLock
1584
1585 Standard_Boolean OSD_File :: IsLocked () {
1586
1587  TEST_RAISE(  "IsLocked"  );
1588
1589  return ImperativeFlag;
1590
1591 }  // end OSD_File :: IsLocked
1592
1593
1594 // --------------------------------------------------------------------------
1595 // Return size of a file
1596 // --------------------------------------------------------------------------
1597
1598 Standard_Size OSD_File :: Size () {
1599
1600  Standard_Integer retVal;
1601
1602  TEST_RAISE(  "Size"  );
1603
1604  LARGE_INTEGER aSize;
1605  aSize.QuadPart = 0;
1606  retVal = GetFileSizeEx (myFileHandle, &aSize);
1607
1608  if (  retVal == 0  )
1609
1610   _osd_wnt_set_error ( myError, OSD_WFile );
1611
1612  return (Standard_Size)aSize.QuadPart;
1613
1614 }  // end OSD_File :: Size
1615
1616 // --------------------------------------------------------------------------
1617 // Print contains of a file
1618 // --------------------------------------------------------------------------
1619
1620 void OSD_File :: Print ( const OSD_Printer& WhichPrinter ) {
1621
1622  if (myFileHandle != INVALID_HANDLE_VALUE)
1623
1624   RAISE(  "OSD_File :: Print (): incorrect call - file opened"  );
1625
1626  TCollection_AsciiString pName, fName;
1627
1628  WhichPrinter.Name ( pName );
1629  myPath.SystemName ( fName );
1630  TCollection_ExtendedString fNameW(fName);
1631
1632  if (   !_osd_print ( (Standard_PCharacter)pName.ToCString (),
1633                       (const wchar_t*)fNameW.ToExtString ()  )   )
1634
1635   _osd_wnt_set_error ( myError, OSD_WFile );
1636
1637 }  // end OSD_File :: Print
1638
1639 // --------------------------------------------------------------------------
1640 // Test if a file is open
1641 // --------------------------------------------------------------------------
1642
1643 Standard_Boolean OSD_File :: IsOpen () const {
1644
1645  return myFileHandle != INVALID_HANDLE_VALUE;
1646
1647 }  // end OSD_File :: IsOpen
1648
1649 #if defined(__CYGWIN32__) || defined(__MINGW32__)
1650 #define __try
1651 #define __finally
1652 #define __leave return retVal
1653 #endif
1654
1655 PSECURITY_DESCRIPTOR __fastcall _osd_wnt_protection_to_sd (
1656                                  const OSD_Protection& prot, BOOL fDir, wchar_t* fName
1657                                 ) {
1658
1659  int                  i, j;
1660  BOOL                 fOK      = FALSE;
1661  PACL                 pACL     = NULL;
1662  HANDLE               hProcess = NULL;
1663  PSID                 pSIDowner;
1664  PSID                 pSIDadmin;
1665  PSID                 pSIDworld;
1666  PSID                 pSIDtemp;
1667  DWORD                dwAccessAdmin;
1668  DWORD                dwAccessGroup;
1669  DWORD                dwAccessOwner;
1670  DWORD                dwAccessWorld;
1671  DWORD                dwAccessAdminDir;
1672  DWORD                dwAccessGroupDir;
1673  DWORD                dwAccessOwnerDir;
1674  DWORD                dwAccessWorldDir;
1675  DWORD                dwACLsize       = sizeof ( ACL );
1676  DWORD                dwIndex         = 0;
1677  PTOKEN_OWNER         pTkOwner        = NULL;
1678  PTOKEN_GROUPS        pTkGroups       = NULL;
1679  PTOKEN_PRIMARY_GROUP pTkPrimaryGroup = NULL;
1680  PSECURITY_DESCRIPTOR retVal = NULL;
1681  PSECURITY_DESCRIPTOR pfSD = NULL;
1682  BOOL                 fDummy;
1683  PFILE_ACE            pFileACE;
1684
1685  __try {
1686
1687   j = fDir ? 1 : 0;
1688
1689   if (  !OpenProcessToken (
1690           GetCurrentProcess (), TOKEN_QUERY, &hProcess
1691          )
1692   ) __leave;
1693
1694   if (   (  pTkGroups = ( PTOKEN_GROUPS )GetTokenInformationEx (
1695                                           hProcess, TokenGroups
1696                                          )
1697          ) == NULL
1698   ) __leave;
1699
1700   if (   (  pTkOwner = ( PTOKEN_OWNER )GetTokenInformationEx (
1701                                         hProcess, TokenOwner
1702                                        )
1703          ) == NULL
1704   ) __leave;
1705
1706   if (   (  pTkPrimaryGroup = ( PTOKEN_PRIMARY_GROUP )GetTokenInformationEx (
1707                                                        hProcess, TokenPrimaryGroup
1708                                                       )
1709          ) == NULL
1710   ) __leave;
1711
1712
1713 retry:
1714   if ( fName == NULL )
1715
1716    pSIDowner = pTkOwner -> Owner;
1717
1718   else {
1719
1720    pfSD = GetFileSecurityEx ( fName, OWNER_SECURITY_INFORMATION );
1721
1722    if (  pfSD == NULL || !GetSecurityDescriptorOwner ( pfSD, &pSIDowner, &fDummy )  ) {
1723
1724     fName = NULL;
1725     goto retry;
1726
1727    }  // end if
1728
1729   }  // end else
1730
1731   pSIDadmin = AdminSid ();
1732   pSIDworld = WorldSid ();
1733
1734   dwAccessAdmin = _get_access_mask (  prot.System ()  );
1735   dwAccessGroup = _get_access_mask (  prot.Group  ()  );
1736   dwAccessOwner = _get_access_mask (  prot.User   ()  );
1737   dwAccessWorld = _get_access_mask (  prot.World  ()  );
1738
1739   dwAccessAdminDir = _get_dir_access_mask (  prot.System ()  );
1740   dwAccessGroupDir = _get_dir_access_mask (  prot.Group  ()  );
1741   dwAccessOwnerDir = _get_dir_access_mask (  prot.User   ()  );
1742   dwAccessWorldDir = _get_dir_access_mask (  prot.World  ()  );
1743
1744   if (  dwAccessGroup != 0  ) {
1745
1746    for ( i = 0; i < ( int )pTkGroups -> GroupCount; ++i ) {
1747
1748     pSIDtemp = pTkGroups -> Groups[ i ].Sid;
1749
1750     if (  !NtPredefinedSid ( pSIDtemp                                  ) &&
1751           !EqualSid        ( pSIDtemp, pSIDworld                       ) &&
1752           !EqualSid        ( pSIDtemp, pTkPrimaryGroup -> PrimaryGroup ) &&
1753            IsValidSid      ( pSIDtemp                                  )
1754     )
1755
1756      dwACLsize += ( (  GetLengthSid ( pSIDtemp ) + ACE_HEADER_SIZE  ) << j );
1757
1758    }  // end for
1759
1760   }  // end if
1761
1762   dwACLsize += (  ( ( GetLengthSid ( pSIDowner ) + ACE_HEADER_SIZE ) << j ) +
1763                   ( ( GetLengthSid ( pSIDadmin ) + ACE_HEADER_SIZE ) << j ) +
1764                   ( ( GetLengthSid ( pSIDworld ) + ACE_HEADER_SIZE ) << j )
1765                );
1766
1767   if (   (  pACL = CreateAcl ( dwACLsize )  ) == NULL   ) __leave;
1768
1769   if ( dwAccessAdmin != 0 )
1770
1771    if (   (  pFileACE = ( PFILE_ACE )AllocAccessAllowedAce (
1772                                       dwAccessAdmin, 0,
1773                                       pSIDadmin
1774                                      )
1775            ) != NULL
1776    ) {
1777
1778     AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
1779
1780     if ( fDir ) {
1781
1782      pFileACE -> dwMask = dwAccessAdminDir;
1783      pFileACE -> header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
1784      AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
1785
1786     }  // end if
1787
1788     FreeAce ( pFileACE );
1789
1790    }  // end if
1791
1792   if ( dwAccessOwner != 0 )
1793
1794    if (   (  pFileACE = ( PFILE_ACE )AllocAccessAllowedAce (
1795                                       dwAccessOwner, 0, pSIDowner
1796                                      )
1797           ) != NULL
1798    ) {
1799
1800     AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
1801
1802     if ( fDir ) {
1803
1804      pFileACE -> dwMask = dwAccessOwnerDir;
1805      pFileACE -> header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
1806      AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
1807
1808     }  // end if
1809
1810     FreeAce ( pFileACE );
1811
1812    }  // end if
1813
1814   if ( dwAccessWorld != 0 )
1815
1816    if (   (  pFileACE = ( PFILE_ACE )AllocAccessAllowedAce (
1817                                       dwAccessWorld, 0, pSIDworld
1818                                      )
1819           ) != NULL
1820    ) {
1821
1822     AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
1823
1824     if ( fDir ) {
1825
1826      pFileACE -> header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
1827      AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
1828
1829     }  // end if
1830
1831     FreeAce ( pFileACE );
1832
1833    }  // end if
1834
1835   if ( dwAccessGroup != 0 ) {
1836
1837    for ( i = 0; i < ( int )pTkGroups -> GroupCount; ++i ) {
1838
1839     pSIDtemp = pTkGroups -> Groups[ i ].Sid;
1840
1841     if (  !NtPredefinedSid ( pSIDtemp                                  ) &&
1842           !EqualSid        ( pSIDtemp, pSIDworld                       ) &&
1843           !EqualSid        ( pSIDtemp, pTkPrimaryGroup -> PrimaryGroup ) &&
1844            IsValidSid      ( pSIDtemp                                  )
1845     ) {
1846
1847      if ( dwAccessGroup != 0 )
1848
1849       if (   (  pFileACE = ( PFILE_ACE )AllocAccessAllowedAce (
1850                                          dwAccessGroup, 0, pSIDtemp
1851                                         )
1852              ) != NULL
1853       ) {
1854
1855        AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
1856
1857       if ( fDir ) {
1858
1859        pFileACE -> header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
1860        AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
1861
1862       }  // end if
1863
1864       FreeAce ( pFileACE );
1865
1866      }  // end if
1867
1868     }  // end if
1869
1870    }  // end for
1871
1872   }  // end if
1873
1874   if (   (  retVal = AllocSD ()  ) == NULL   ) __leave;
1875
1876   if (  !SetSecurityDescriptorDacl ( retVal, TRUE, pACL, TRUE )  ) __leave;
1877
1878   fOK = TRUE;
1879
1880  }  // end __try
1881
1882  __finally {
1883
1884   if ( !fOK ) {
1885
1886    if ( retVal != NULL )
1887
1888     FreeSD ( retVal );
1889
1890    else if ( pACL != NULL )
1891
1892     FreeAcl ( pACL );
1893
1894    retVal = NULL;
1895
1896   }  // end if
1897
1898   if ( hProcess        != NULL ) CloseHandle          ( hProcess        );
1899   if ( pTkOwner        != NULL ) FreeTokenInformation ( pTkOwner        );
1900   if ( pTkGroups       != NULL ) FreeTokenInformation ( pTkGroups       );
1901   if ( pTkPrimaryGroup != NULL ) FreeTokenInformation ( pTkPrimaryGroup );
1902   if ( pfSD            != NULL ) FreeFileSecurity     ( pfSD            );
1903
1904  }  // end __finally
1905
1906 #ifdef VAC
1907 leave: ;     // added for VisualAge
1908 #endif
1909
1910  return retVal;
1911
1912 }  // end _osd_wnt_protection_to_sd */
1913
1914 #if defined(__CYGWIN32__) || defined(__MINGW32__)
1915 #undef __try
1916 #undef __finally
1917 #undef __leave
1918 #endif
1919
1920 static void __fastcall _test_raise ( HANDLE hFile, Standard_CString str ) {
1921
1922  Standard_Character buff[ 64 ];
1923
1924  if (hFile == INVALID_HANDLE_VALUE) {
1925
1926   strcpy (  buff, "OSD_File :: "  );
1927   strcat (  buff, str );
1928   strcat (  buff, " (): wrong access"  );
1929
1930   Standard_ProgramError :: Raise ( buff );
1931
1932  }  // end if
1933
1934 }  // end _test_raise
1935
1936 // Returns number of bytes in the string (including end \n, but excluding \r);
1937 //
1938 static Standard_Integer __fastcall _get_line (Standard_PCharacter& buffer, DWORD dwBuffSize, LONG& theSeekPos)
1939 {
1940
1941  Standard_PCharacter ptr;
1942
1943  buffer[ dwBuffSize ] = 0;
1944  ptr                  = buffer;
1945
1946  while ( *ptr != 0 ) {
1947
1948   if (  *ptr == '\n'  )
1949   {
1950     ptr++ ;   // jump newline char.
1951     *ptr = 0 ;
1952     theSeekPos = (LONG)(ptr - buffer - dwBuffSize);
1953     return (Standard_Integer)(ptr - buffer);
1954   }
1955   else if (  *ptr == '\r' && ptr[ 1 ] == '\n'  )
1956   {
1957     *(ptr++) = '\n' ; // Substitue carriage return by newline.
1958     *ptr = 0 ;
1959     theSeekPos = (LONG)(ptr + 1 - buffer - dwBuffSize);
1960     return (Standard_Integer)(ptr - buffer);
1961   }
1962   else if (  *ptr == '\r' && ptr[ 1 ] == 0  ) {
1963     *ptr = '\n' ; // Substitue carriage return by newline
1964     return -1;
1965   }
1966   ++ptr;
1967
1968  }  // end while
1969
1970  theSeekPos = 0;
1971  return dwBuffSize;
1972 }  // end _get_line
1973
1974 static int __fastcall _get_buffer (
1975                         HANDLE hChannel,
1976                         Standard_PCharacter& buffer,
1977                                    DWORD dwSize,
1978                         BOOL fPeek, BOOL fSocket
1979                        ) {
1980
1981  int   retVal = -1;
1982  int   flags;
1983  DWORD dwDummy;
1984  DWORD dwBytesRead;
1985
1986  if ( fSocket ) {
1987
1988   flags = fPeek ? MSG_PEEK : 0;
1989
1990   retVal = recv (  ( SOCKET )hChannel, buffer, ( int )dwSize, flags  );
1991
1992   if ( retVal == SOCKET_ERROR ) retVal = -1;
1993
1994  } else {
1995
1996   if ( fPeek ) {
1997
1998    if (  !PeekNamedPipe (
1999            hChannel, buffer, dwSize, &dwBytesRead, &dwDummy, &dwDummy
2000           ) && GetLastError () != ERROR_BROKEN_PIPE
2001    )
2002
2003     retVal = -1;
2004
2005    else
2006
2007     retVal = ( int )dwBytesRead;
2008
2009   } else {
2010
2011    if (  !ReadFile ( hChannel, buffer, dwSize, &dwBytesRead, NULL )  )
2012
2013     retVal = -1;
2014
2015    else
2016
2017     retVal = ( int )dwBytesRead;
2018
2019   }  // end else
2020
2021  }  // end else
2022
2023  return retVal;
2024
2025 }  // end _get_buffer
2026
2027
2028 static DWORD __fastcall _get_access_mask ( OSD_SingleProtection prt ) {
2029
2030  DWORD retVal = 0;
2031
2032  switch ( prt ) {
2033
2034   case OSD_None:
2035
2036    retVal = 0;
2037
2038   break;
2039
2040   case OSD_R:
2041
2042    retVal = FILE_GENERIC_READ;
2043
2044   break;
2045
2046   case OSD_W:
2047
2048    retVal = FILE_GENERIC_WRITE;
2049
2050   break;
2051
2052   case OSD_RW:
2053
2054    retVal = FILE_GENERIC_READ | FILE_GENERIC_WRITE;
2055
2056   break;
2057
2058   case OSD_X:
2059
2060    retVal = FILE_GENERIC_EXECUTE;
2061
2062   break;
2063
2064   case OSD_RX:
2065
2066    retVal = FILE_GENERIC_READ | FILE_GENERIC_EXECUTE;
2067
2068   break;
2069
2070   case OSD_WX:
2071
2072    retVal = FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE;
2073
2074   break;
2075
2076   case OSD_RWX:
2077
2078    retVal = FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE;
2079
2080   break;
2081
2082   case OSD_D:
2083
2084    retVal = DELETE;
2085
2086   break;
2087
2088   case OSD_RD:
2089
2090    retVal = FILE_GENERIC_READ | DELETE;
2091
2092   break;
2093
2094   case OSD_WD:
2095
2096    retVal = FILE_GENERIC_WRITE | DELETE;
2097
2098   break;
2099
2100   case OSD_RWD:
2101
2102    retVal = FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE;
2103
2104   break;
2105
2106   case OSD_XD:
2107
2108    retVal = FILE_GENERIC_EXECUTE | DELETE;
2109
2110   break;
2111
2112   case OSD_RXD:
2113
2114    retVal = FILE_GENERIC_READ | FILE_GENERIC_EXECUTE | DELETE;
2115
2116   break;
2117
2118   case OSD_WXD:
2119
2120    retVal = FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE;
2121
2122   break;
2123
2124   case OSD_RWXD:
2125
2126    retVal = FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE;
2127
2128   break;
2129
2130   default:
2131
2132    RAISE(  "_get_access_mask (): incorrect parameter"  );
2133
2134  }  // end switch
2135
2136  return retVal;
2137
2138 }  // end _get_access_mask
2139
2140 static DWORD __fastcall _get_dir_access_mask ( OSD_SingleProtection prt ) {
2141
2142  DWORD retVal = 0;
2143
2144  switch ( prt ) {
2145
2146   case OSD_None:
2147
2148    retVal = 0;
2149
2150   break;
2151
2152   case OSD_R:
2153
2154    retVal = GENERIC_READ;
2155
2156   break;
2157
2158   case OSD_W:
2159
2160    retVal = GENERIC_WRITE;
2161
2162   break;
2163
2164   case OSD_RW:
2165
2166    retVal = GENERIC_READ | GENERIC_WRITE;
2167
2168   break;
2169
2170   case OSD_X:
2171
2172    retVal = GENERIC_EXECUTE;
2173
2174   break;
2175
2176   case OSD_RX:
2177
2178    retVal = GENERIC_READ | GENERIC_EXECUTE;
2179
2180   break;
2181
2182   case OSD_WX:
2183
2184    retVal = GENERIC_WRITE | GENERIC_EXECUTE;
2185
2186   break;
2187
2188   case OSD_RWX:
2189
2190    retVal = GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE;
2191
2192   break;
2193
2194   case OSD_D:
2195
2196    retVal = DELETE;
2197
2198   break;
2199
2200   case OSD_RD:
2201
2202    retVal = GENERIC_READ | DELETE;
2203
2204   break;
2205
2206   case OSD_WD:
2207
2208    retVal = GENERIC_WRITE | DELETE;
2209
2210   break;
2211
2212   case OSD_RWD:
2213
2214    retVal = GENERIC_READ | GENERIC_WRITE | DELETE;
2215
2216   break;
2217
2218   case OSD_XD:
2219
2220    retVal = GENERIC_EXECUTE | DELETE;
2221
2222   break;
2223
2224   case OSD_RXD:
2225
2226    retVal = GENERIC_READ | GENERIC_EXECUTE | DELETE;
2227
2228   break;
2229
2230   case OSD_WXD:
2231
2232    retVal = GENERIC_WRITE | GENERIC_EXECUTE | DELETE;
2233
2234   break;
2235
2236   case OSD_RWXD:
2237
2238    retVal = GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | DELETE;
2239
2240   break;
2241
2242   default:
2243
2244    RAISE(  "_get_dir_access_mask (): incorrect parameter"  );
2245
2246  }  // end switch
2247
2248  return retVal;
2249
2250 }  // end _get_dir_access_mask
2251
2252 static HANDLE __fastcall _open_file (
2253                           Standard_CString fName,
2254                           OSD_OpenMode oMode,
2255                           DWORD dwOptions, LPBOOL fNew
2256                          ) {
2257
2258  HANDLE retVal = INVALID_HANDLE_VALUE;
2259  DWORD  dwDesiredAccess = 0;
2260  DWORD  dwCreationDistribution;
2261
2262  switch ( oMode ) {
2263
2264   case OSD_ReadOnly:
2265
2266    dwDesiredAccess = GENERIC_READ;
2267
2268   break;
2269
2270   case OSD_WriteOnly:
2271
2272    dwDesiredAccess = GENERIC_WRITE;
2273
2274   break;
2275
2276   case OSD_ReadWrite:
2277
2278    dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
2279
2280   break;
2281
2282   default:
2283
2284    RAISE(  "_open_file (): incorrect parameter"  );
2285
2286  }  // end switch
2287
2288  dwCreationDistribution = ( dwOptions != OPEN_NEW ) ? OPEN_EXISTING : CREATE_ALWAYS;
2289
2290  // make wide character string from UTF-8
2291  TCollection_ExtendedString fNameW(fName, Standard_True);
2292  retVal = CreateFileW (
2293            (const wchar_t*) fNameW.ToExtString(), dwDesiredAccess,
2294            FILE_SHARE_READ | FILE_SHARE_WRITE,
2295            NULL, dwCreationDistribution, FILE_ATTRIBUTE_NORMAL, NULL
2296           );
2297
2298  if ( retVal          == INVALID_HANDLE_VALUE &&
2299       dwOptions       == OPEN_APPEND          &&
2300       GetLastError () == ERROR_FILE_NOT_FOUND
2301  ) {
2302
2303
2304   dwCreationDistribution = CREATE_ALWAYS;
2305
2306   retVal = CreateFileW (
2307             (const wchar_t*) fNameW.ToExtString(), dwDesiredAccess,
2308             FILE_SHARE_READ | FILE_SHARE_WRITE,
2309             NULL, dwCreationDistribution, FILE_ATTRIBUTE_NORMAL, NULL
2310            );
2311
2312   *fNew = TRUE;
2313
2314  }  // end if
2315
2316  return retVal;
2317
2318 }  // end _open_file
2319
2320 Standard_Integer __fastcall _get_file_type (
2321                              Standard_CString fName, HANDLE fileHandle
2322                             ) {
2323
2324  Standard_Integer retVal = 0;
2325  DWORD            dwType;
2326  int              fileType;
2327
2328  fileType = (fileHandle == INVALID_HANDLE_VALUE ?
2329              FILE_TYPE_DISK : GetFileType (fileHandle));
2330
2331  switch ( fileType ) {
2332
2333   case FILE_TYPE_UNKNOWN:
2334
2335    retVal = FLAG_SOCKET;
2336
2337   break;
2338
2339   case FILE_TYPE_DISK:
2340   {
2341    // make wide character string from UTF-8
2342    TCollection_ExtendedString fNameW(fName, Standard_True);
2343    dwType = GetFileAttributesW ( (const wchar_t*) fNameW.ToExtString() );
2344    if (  dwType  != 0xFFFFFFFF  )
2345
2346     retVal =  dwType & FILE_ATTRIBUTE_DIRECTORY ? FLAG_DIRECTORY : FLAG_FILE;
2347
2348    else
2349
2350     retVal = 0x80000000;
2351   }
2352   break;
2353
2354   case FILE_TYPE_CHAR:
2355
2356    retVal = FLAG_DEVICE;
2357
2358   break;
2359
2360   case FILE_TYPE_PIPE:
2361
2362    retVal = FLAG_PIPE;
2363
2364   break;
2365
2366  }  // end switch
2367
2368  return retVal;
2369
2370 }  // end _get_file_type
2371
2372 #if defined(__CYGWIN32__) || defined(__MINGW32__)
2373 #define __try
2374 #define __finally
2375 #define __leave return retVal
2376 #endif
2377
2378 BOOL __fastcall _osd_wnt_sd_to_protection (
2379                  PSECURITY_DESCRIPTOR pSD, OSD_Protection& prot, BOOL fDir
2380                 ) {
2381
2382  int           i;
2383  BOOL          fPresent;
2384  BOOL          fDefaulted;
2385  PACL          pACL;
2386  PSID          pSIDowner;
2387  PSID          pSIDadmin;
2388  PSID          pSIDworld;
2389  LPVOID        pACE;
2390  DWORD         dwAccessOwner = 0;
2391  DWORD         dwAccessGroup = 0;
2392  DWORD         dwAccessAdmin = 0;
2393  DWORD         dwAccessWorld = 0;
2394  BOOL          retVal = FALSE;
2395  GET_PROT_FUNC _get_prot_func = fDir ? &_get_protection_dir : &_get_protection;
2396
2397  __try {
2398
2399   if (  !GetSecurityDescriptorOwner ( pSD, &pSIDowner, &fDefaulted )  ) __leave;
2400
2401   if (  !GetSecurityDescriptorDacl ( pSD, &fPresent, &pACL, &fDefaulted ) ||
2402         !fPresent
2403   ) __leave;
2404
2405   if ( pSIDowner == NULL || pACL == NULL ) {
2406
2407    SetLastError ( ERROR_NO_SECURITY_ON_OBJECT );
2408    __leave;
2409
2410   }  // end if
2411
2412   pSIDadmin = AdminSid ();
2413   pSIDworld = WorldSid ();
2414
2415   for ( i = 0; i < ( int )pACL -> AceCount; ++i ) {
2416
2417    if (  GetAce ( pACL, i, &pACE )  ) {
2418
2419     if (   EqualSid (  pSIDowner, GET_SID( pACE )  )   )
2420
2421      dwAccessOwner = (  ( PACE_HEADER )pACE  ) -> AceType == ACCESS_DENIED_ACE_TYPE ?
2422                      0 : *GET_MSK( pACE );
2423
2424     else if (   EqualSid (  pSIDadmin, GET_SID( pACE )  )   )
2425
2426      dwAccessAdmin = (  ( PACE_HEADER )pACE  ) -> AceType == ACCESS_DENIED_ACE_TYPE ?
2427                      0 : *GET_MSK( pACE );
2428
2429     else if (   EqualSid (  pSIDworld, GET_SID( pACE )  )   )
2430
2431      dwAccessWorld = (  ( PACE_HEADER )pACE  ) -> AceType == ACCESS_DENIED_ACE_TYPE ?
2432                      0 : *GET_MSK( pACE );
2433
2434     else
2435
2436      dwAccessGroup = (  ( PACE_HEADER )pACE  ) -> AceType == ACCESS_DENIED_ACE_TYPE ?
2437                      0 : *GET_MSK( pACE );
2438
2439    }  // end if
2440
2441   }  // end for
2442
2443   prot.SetValues (
2444         ( *_get_prot_func ) ( dwAccessAdmin ),
2445         ( *_get_prot_func ) ( dwAccessOwner ),
2446         ( *_get_prot_func ) ( dwAccessGroup ),
2447         ( *_get_prot_func ) ( dwAccessWorld )
2448        );
2449
2450   retVal = TRUE;
2451
2452  }  // end __try
2453
2454  __finally {}
2455
2456 #ifdef VAC
2457 leave: ;      // added for VisualAge
2458 #endif
2459
2460  return retVal;
2461
2462 }  // end _osd_wnt_sd_to_protection
2463
2464 #if defined(__CYGWIN32__) || defined(__MINGW32__)
2465 #undef __try
2466 #undef __finally
2467 #undef __leave
2468 #endif
2469
2470 static OSD_SingleProtection __fastcall _get_protection ( DWORD mask ) {
2471
2472  OSD_SingleProtection retVal;
2473
2474  switch ( mask ) {
2475
2476   case FILE_GENERIC_READ:
2477
2478    retVal = OSD_R;
2479
2480   break;
2481
2482   case FILE_GENERIC_WRITE:
2483
2484    retVal = OSD_W;
2485
2486   break;
2487
2488   case FILE_GENERIC_READ | FILE_GENERIC_WRITE:
2489
2490    retVal = OSD_RW;
2491
2492   break;
2493
2494   case FILE_GENERIC_EXECUTE:
2495
2496    retVal = OSD_X;
2497
2498   break;
2499
2500   case FILE_GENERIC_READ | FILE_GENERIC_EXECUTE:
2501
2502    retVal = OSD_RX;
2503
2504   break;
2505
2506   case FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE:
2507
2508    retVal = OSD_WX;
2509
2510   break;
2511
2512   case FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE:
2513
2514    retVal = OSD_RWX;
2515
2516   break;
2517
2518   case DELETE:
2519
2520    retVal = OSD_D;
2521
2522   break;
2523
2524   case FILE_GENERIC_READ | DELETE:
2525
2526    retVal = OSD_RD;
2527
2528   break;
2529
2530   case FILE_GENERIC_WRITE | DELETE:
2531
2532    retVal = OSD_WD;
2533
2534   break;
2535
2536   case FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE:
2537
2538    retVal = OSD_RWD;
2539
2540   break;
2541
2542   case FILE_GENERIC_EXECUTE | DELETE:
2543
2544    retVal = OSD_XD;
2545
2546   break;
2547
2548   case FILE_GENERIC_READ | FILE_GENERIC_EXECUTE | DELETE:
2549
2550    retVal = OSD_RXD;
2551
2552   break;
2553
2554   case FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE:
2555
2556    retVal = OSD_WXD;
2557
2558   break;
2559
2560   case FILE_ALL_ACCESS:
2561   case FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE:
2562
2563    retVal = OSD_RWXD;
2564
2565   break;
2566
2567   case 0:
2568   default:
2569
2570    retVal = OSD_None;
2571
2572  }  // end switch
2573
2574  return retVal;
2575
2576 }  // end _get_protection
2577
2578 static OSD_SingleProtection __fastcall _get_protection_dir ( DWORD mask ) {
2579
2580  OSD_SingleProtection retVal;
2581
2582  switch ( mask ) {
2583
2584   case GENERIC_READ:
2585
2586    retVal = OSD_R;
2587
2588   break;
2589
2590   case GENERIC_WRITE:
2591
2592    retVal = OSD_W;
2593
2594   break;
2595
2596   case GENERIC_READ | GENERIC_WRITE:
2597
2598    retVal = OSD_RW;
2599
2600   break;
2601
2602   case GENERIC_EXECUTE:
2603
2604    retVal = OSD_X;
2605
2606   break;
2607
2608   case GENERIC_READ | GENERIC_EXECUTE:
2609
2610    retVal = OSD_RX;
2611
2612   break;
2613
2614   case GENERIC_WRITE | GENERIC_EXECUTE:
2615
2616    retVal = OSD_WX;
2617
2618   break;
2619
2620   case GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE:
2621
2622    retVal = OSD_RWX;
2623
2624   break;
2625
2626   case DELETE:
2627
2628    retVal = OSD_D;
2629
2630   break;
2631
2632   case GENERIC_READ | DELETE:
2633
2634    retVal = OSD_RD;
2635
2636   break;
2637
2638   case GENERIC_WRITE | DELETE:
2639
2640    retVal = OSD_WD;
2641
2642   break;
2643
2644   case GENERIC_READ | GENERIC_WRITE | DELETE:
2645
2646    retVal = OSD_RWD;
2647
2648   break;
2649
2650   case GENERIC_EXECUTE | DELETE:
2651
2652    retVal = OSD_XD;
2653
2654   break;
2655
2656   case GENERIC_READ | GENERIC_EXECUTE | DELETE:
2657
2658    retVal = OSD_RXD;
2659
2660   break;
2661
2662   case GENERIC_WRITE | GENERIC_EXECUTE | DELETE:
2663
2664    retVal = OSD_WXD;
2665
2666   break;
2667
2668   case FILE_ALL_ACCESS:
2669   case GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | DELETE:
2670
2671    retVal = OSD_RWXD;
2672
2673   break;
2674
2675   case 0:
2676   default:
2677
2678    retVal = OSD_None;
2679
2680  }  // end switch
2681
2682  return retVal;
2683
2684 }  // end _get_protection_dir
2685
2686 #if defined(__CYGWIN32__) || defined(__MINGW32__)
2687 #define __try
2688 #define __finally
2689 #define __leave return fOK
2690 #endif
2691
2692 BOOL __fastcall _osd_print (const Standard_PCharacter pName, const wchar_t* fName ) {
2693
2694  BOOL   fOK, fJob;
2695  HANDLE hPrinter = NULL;
2696  BYTE   jobInfo[ MAX_PATH + sizeof ( DWORD ) ];
2697  DWORD  dwNeeded, dwCode = 0;
2698
2699  fOK = fJob = FALSE;
2700
2701  __try {
2702
2703   if (  !OpenPrinter ( Standard_PCharacter(pName), &hPrinter, NULL )  ) {
2704
2705    hPrinter = NULL;
2706    __leave;
2707
2708   }  // end if
2709
2710   if (   !AddJobW (
2711            hPrinter, 1, jobInfo, MAX_PATH + sizeof ( DWORD ), &dwNeeded
2712           )
2713   ) __leave;
2714
2715   fJob = TRUE;
2716
2717   if (  !CopyFileW (
2718           fName, (LPWSTR) (  ( ADDJOB_INFO_1* )jobInfo  ) -> Path, FALSE
2719          )
2720   ) __leave;
2721
2722   if (  !ScheduleJob (
2723           hPrinter, (  ( ADDJOB_INFO_1* )jobInfo  ) -> JobId
2724          )
2725   ) __leave;
2726
2727   fOK = TRUE;
2728
2729  }  // end __try
2730
2731  __finally {
2732
2733   if ( !fOK ) {
2734
2735    BYTE  info[ 1024 ];
2736    DWORD dwBytesNeeded;
2737
2738    dwCode = GetLastError ();
2739
2740    if ( fJob && hPrinter != NULL ) {
2741
2742     GetJob (
2743      hPrinter, (  ( ADDJOB_INFO_1* )jobInfo  ) -> JobId, 1,
2744      info, 1024, &dwBytesNeeded
2745     );
2746
2747     if ( fJob ) SetJob (
2748                  hPrinter,
2749                  (  ( ADDJOB_INFO_1* )jobInfo  ) -> JobId,
2750                  1, info, JOB_CONTROL_CANCEL
2751                 );
2752
2753    }  // end if
2754
2755   }  // end if
2756
2757   if ( hPrinter != NULL ) ClosePrinter ( hPrinter );
2758
2759  }  // end __finally
2760
2761 #ifdef VAC
2762 leave: ;       // added for VisualAge
2763 #endif
2764
2765  if ( !fOK ) SetLastError ( dwCode );
2766
2767  return fOK;
2768
2769 }  // end _osd_print
2770
2771 #if defined(__CYGWIN32__) || defined(__MINGW32__)
2772 #undef __try
2773 #undef __finally
2774 #undef __leave
2775 #endif
2776
2777 Standard_Boolean OSD_File::IsReadable()
2778 {
2779   TCollection_AsciiString FileName ;
2780   HANDLE Channel ;
2781
2782   myPath.SystemName(FileName) ;
2783   Channel = _open_file(FileName.ToCString(), OSD_ReadOnly, OPEN_OLD) ;
2784   if (Channel == INVALID_HANDLE_VALUE)
2785     return Standard_False ;
2786   else {
2787     CloseHandle (Channel) ;
2788     return Standard_True ;
2789   }
2790 }
2791
2792
2793 Standard_Boolean OSD_File::IsWriteable()
2794 {
2795   TCollection_AsciiString FileName ;
2796   HANDLE Channel ;
2797
2798   myPath.SystemName(FileName) ;
2799   Channel = _open_file(FileName.ToCString(), OSD_ReadWrite, OPEN_OLD) ;
2800   if (Channel == INVALID_HANDLE_VALUE)
2801     return Standard_False ;
2802   else {
2803     CloseHandle (Channel) ;
2804     return Standard_True ;
2805   }
2806 }
2807
2808 Standard_Boolean OSD_File::IsExecutable()
2809 {
2810   return IsReadable() ;
2811
2812 //  if (_access(FileName.ToCString(),0))
2813 }
2814
2815 #endif /* _WIN32 */
2816
2817 // ---------------------------------------------------------------------
2818 // Destructs a file object (unlocks and closes file if it is open)
2819 // ---------------------------------------------------------------------
2820
2821 OSD_File::~OSD_File()
2822 {
2823   if (IsOpen())
2824   {
2825     if (IsLocked())
2826       UnLock();
2827     Close();
2828   }
2829 }
2830
2831 // ---------------------------------------------------------------------
2832 // Read lines in a file while it is increasing.
2833 // Each line is terminated with a <nl>.
2834 // ---------------------------------------------------------------------
2835
2836 #include <OSD.hxx>
2837
2838 Standard_Boolean OSD_File::ReadLastLine(TCollection_AsciiString& aLine,const Standard_Integer aDelay,const Standard_Integer aNbTries)
2839 {
2840   static Standard_Integer MaxLength = 1000 ;
2841   Standard_Integer Len ;
2842   Standard_Integer Count = aNbTries ;
2843
2844   if (Count <= 0)
2845       return Standard_False ;
2846   for(;;) {
2847     ReadLine(aLine, MaxLength, Len) ;
2848     if (!aLine.IsEmpty())
2849       return Standard_True ;
2850     if (!--Count)
2851       return Standard_False ;
2852     OSD::SecSleep(aDelay) ;
2853   }
2854 }
2855
2856
2857 Standard_Boolean OSD_File::Edit()
2858 {
2859   cout << "Function OSD_File::Edit() not yet implemented." << endl;
2860   return Standard_False ;
2861 }
2862
2863
2864
2865