mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-05 18:16:23 +03:00
d5f74e42d6
License statement text corrected; compiler warnings caused by Bison 2.41 disabled for MSVC; a few other compiler warnings on 54-bit Windows eliminated by appropriate type cast Wrong license statements corrected in several files. Copyright and license statements added in XSD and GLSL files. Copyright year updated in some files. Obsolete documentation files removed from DrawResources.
2934 lines
65 KiB
C++
2934 lines
65 KiB
C++
// Copyright (c) 1998-1999 Matra Datavision
|
|
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
|
//
|
|
// This file is part of Open CASCADE Technology software library.
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify it under
|
|
// the terms of the GNU Lesser General Public License version 2.1 as published
|
|
// by the Free Software Foundation, with special exception defined in the file
|
|
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
|
// distribution for complete text of the license and disclaimer of any warranty.
|
|
//
|
|
// Alternatively, this file may be used under the terms of Open CASCADE
|
|
// commercial license or contractual agreement.
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
//------------------------------------------------------------------------
|
|
// UNIX Part
|
|
//------------------------------------------------------------------------
|
|
|
|
#ifndef _WIN32
|
|
|
|
#include <Standard_ProgramError.hxx>
|
|
#include <OSD_OSDError.hxx>
|
|
#include <OSD_WhoAmI.hxx>
|
|
#include <OSD_FromWhere.hxx>
|
|
#include <OSD_File.ixx>
|
|
|
|
#include <Standard_PCharacter.hxx>
|
|
|
|
const OSD_WhoAmI Iam = OSD_WFile;
|
|
|
|
#if defined (sun) || defined(SOLARIS)
|
|
#define POSIX
|
|
#else
|
|
#define SYSV
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
# include <sys/types.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_STAT_H
|
|
# include <sys/stat.h>
|
|
#endif
|
|
|
|
#define NEWLINE '\10';
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Create an empty file object
|
|
// ---------------------------------------------------------------------
|
|
|
|
OSD_File::OSD_File():OSD_FileNode()
|
|
{
|
|
ImperativeFlag = Standard_False;
|
|
myLock = OSD_NoLock;
|
|
myIO = 0;
|
|
myMode = OSD_ReadWrite;
|
|
myFILE = (Standard_Address) NULL;
|
|
myFileChannel = -1;
|
|
myFileHandle = 0;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Create and initialize a file object
|
|
// ---------------------------------------------------------------------
|
|
|
|
OSD_File::OSD_File(const OSD_Path& Name):OSD_FileNode(Name)
|
|
{
|
|
ImperativeFlag = Standard_False;
|
|
myLock = OSD_NoLock;
|
|
myIO = 0;
|
|
myMode = OSD_ReadWrite;
|
|
myFILE = (Standard_Address) NULL;
|
|
myFileChannel = -1;
|
|
myFileHandle = 0;
|
|
}
|
|
|
|
// protect against occasional use of myFileHande in Linux code
|
|
#define myFileHandle myFileHandle_is_only_for_Windows
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Build a file if it doesn't exist or create again if it already exists
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File::Build(const OSD_OpenMode Mode,
|
|
const OSD_Protection& Protect){
|
|
|
|
Standard_Integer internal_prot;
|
|
Standard_Integer internal_mode = O_CREAT | O_TRUNC ;
|
|
TCollection_AsciiString aBuffer;
|
|
|
|
if (myPath.Name().Length()==0)
|
|
Standard_ProgramError::Raise("OSD_File::Build : no name was given");
|
|
|
|
if (myFileChannel != -1)
|
|
Standard_ProgramError::Raise("OSD_File::Build : file is already open");
|
|
|
|
|
|
myMode = Mode;
|
|
|
|
internal_prot = Protect.Internal();
|
|
|
|
const char* CMode = "r";
|
|
|
|
switch (Mode){
|
|
case OSD_ReadOnly:
|
|
internal_mode |= O_RDONLY;
|
|
CMode = "r";
|
|
break;
|
|
case OSD_WriteOnly:
|
|
internal_mode |= O_WRONLY;
|
|
CMode = "w";
|
|
break;
|
|
case OSD_ReadWrite:
|
|
internal_mode |= O_RDWR;
|
|
CMode = "w+";
|
|
break;
|
|
}
|
|
|
|
myPath.SystemName( aBuffer );
|
|
myFileChannel = open (aBuffer.ToCString(), internal_mode, internal_prot);
|
|
if (myFileChannel >= 0) {
|
|
myFILE = fdopen (myFileChannel, CMode);
|
|
}
|
|
else
|
|
/* Handle OPEN errors */
|
|
|
|
myError.SetValue (errno, Iam, "Open");
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Append to an existing file
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File::Append(const OSD_OpenMode Mode,
|
|
const OSD_Protection& Protect){
|
|
|
|
Standard_Integer internal_prot;
|
|
Standard_Integer internal_mode = O_APPEND;;
|
|
TCollection_AsciiString aBuffer;
|
|
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
Standard_ProgramError::Raise("OSD_File::Append : it is a directory");
|
|
}
|
|
|
|
if (myPath.Name().Length()==0)
|
|
Standard_ProgramError::Raise("OSD_File::Append : no name was given");
|
|
|
|
if (myFileChannel != -1)
|
|
Standard_ProgramError::Raise("OSD_File::Append : file is already open");
|
|
|
|
internal_prot = Protect.Internal();
|
|
myMode = Mode;
|
|
const char* CMode = "r";
|
|
|
|
switch (Mode){
|
|
case OSD_ReadOnly:
|
|
internal_mode |= O_RDONLY;
|
|
CMode = "r";
|
|
break;
|
|
case OSD_WriteOnly:
|
|
internal_mode |= O_WRONLY;
|
|
CMode = "a";
|
|
break;
|
|
case OSD_ReadWrite:
|
|
internal_mode |= O_RDWR;
|
|
CMode = "a+";
|
|
break;
|
|
}
|
|
|
|
// If file doesn't exist, creates it.
|
|
|
|
if (!Exists()) internal_mode |= O_CREAT;
|
|
|
|
myPath.SystemName ( aBuffer );
|
|
myFileChannel = open (aBuffer.ToCString(), internal_mode, internal_prot);
|
|
if (myFileChannel >= 0)
|
|
myFILE = fdopen (myFileChannel, CMode);
|
|
else
|
|
/* Handle OPEN errors */
|
|
|
|
myError.SetValue (errno, Iam, "Open");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Open a file
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File::Open(const OSD_OpenMode Mode,
|
|
const OSD_Protection& Protect){
|
|
|
|
Standard_Integer internal_prot;
|
|
Standard_Integer internal_mode = 0;
|
|
TCollection_AsciiString aBuffer;
|
|
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
myError.SetValue (1, Iam, "Could not be open : it is a directory");
|
|
}
|
|
|
|
if (myPath.Name().Length()==0)
|
|
Standard_ProgramError::Raise("OSD_File::Open : no name was given");
|
|
|
|
if (myFileChannel != -1)
|
|
Standard_ProgramError::Raise("OSD_File::Open : file is already open");
|
|
|
|
internal_prot = Protect.Internal();
|
|
myMode = Mode;
|
|
const char* CMode = "r";
|
|
|
|
switch (Mode){
|
|
case OSD_ReadOnly:
|
|
internal_mode |= O_RDONLY;
|
|
CMode = "r";
|
|
break;
|
|
case OSD_WriteOnly:
|
|
internal_mode |= O_WRONLY;
|
|
CMode = "w";
|
|
break;
|
|
case OSD_ReadWrite:
|
|
internal_mode |= O_RDWR;
|
|
CMode = "w+";
|
|
break;
|
|
}
|
|
|
|
myPath.SystemName ( aBuffer );
|
|
myFileChannel = open (aBuffer.ToCString(), internal_mode, internal_prot);
|
|
if (myFileChannel >= 0)
|
|
myFILE = fdopen (myFileChannel, CMode);
|
|
else
|
|
/* Handle OPEN errors */
|
|
|
|
myError.SetValue (errno, Iam, "Open");
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// ---------------------------------------------------------------------
|
|
OSD_File OSD_File::BuildTemporary(){
|
|
|
|
#if defined(vax) || defined(__vms) || defined(VAXVMS)
|
|
FILE *fic;
|
|
OSD_File result;
|
|
int dummy;
|
|
|
|
fic = tmpfile();
|
|
dummy = open("dummy", O_RDWR | O_CREAT); // Open a dummy file
|
|
result.myFileChannel = dummy - 1; // This is file channel of "fic" +1
|
|
close(dummy); // Close dummy file
|
|
unlink("dummy"); // Removes dummy file
|
|
|
|
#else
|
|
OSD_File result;
|
|
char *name = tmpnam((char*) 0) ;
|
|
|
|
|
|
TCollection_AsciiString aName ( name ) ;
|
|
OSD_Path aPath( aName ) ;
|
|
|
|
result.SetPath( aPath ) ;
|
|
|
|
result.myFILE = fopen( name, "w+" ) ;
|
|
|
|
result.myFileChannel = fileno( (FILE*)result.myFILE );
|
|
|
|
#endif
|
|
|
|
result.myMode = OSD_ReadWrite;
|
|
|
|
return (result);
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Read content of a file
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File::Read(TCollection_AsciiString& Buffer,
|
|
const Standard_Integer Nbyte){
|
|
Standard_PCharacter readbuf;
|
|
int status;
|
|
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
|
|
}
|
|
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::Read : file is not open");
|
|
|
|
if (Failed()) Perror();
|
|
|
|
if (myMode == OSD_WriteOnly)
|
|
Standard_ProgramError::Raise("OSD_File::Read : file is Write only");
|
|
|
|
if (Nbyte <= 0)
|
|
Standard_ProgramError::Raise("OSD_File::Read : Nbyte is null");
|
|
|
|
TCollection_AsciiString transfert(Nbyte,' ');
|
|
readbuf = (Standard_PCharacter)transfert.ToCString();
|
|
|
|
status = read (myFileChannel, readbuf, Nbyte);
|
|
//
|
|
Buffer = transfert; // Copy transfert to Buffer
|
|
|
|
if (status == -1) myError.SetValue (errno, Iam, "Read");
|
|
else
|
|
if ( status < Nbyte ) myIO = EOF;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Read a line from a file
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File::ReadLine(TCollection_AsciiString& Buffer,
|
|
const Standard_Integer Nbyte,
|
|
Standard_Integer& NByteRead)
|
|
{
|
|
Standard_PCharacter readbuf, abuffer;
|
|
//
|
|
if (OSD_File::KindOfFile() == OSD_DIRECTORY ) {
|
|
Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
|
|
}
|
|
if (myFileChannel == -1){
|
|
Standard_ProgramError::Raise("OSD_File::ReadLine : file is not open");
|
|
}
|
|
if (Failed()) {
|
|
Perror();
|
|
}
|
|
if (myMode == OSD_WriteOnly) {
|
|
Standard_ProgramError::Raise("OSD_File::ReadLine : file is Write only");
|
|
}
|
|
if (Nbyte <= 0){
|
|
Standard_ProgramError::Raise("OSD_File::ReadLine : Nbyte is null");
|
|
}
|
|
//
|
|
TCollection_AsciiString transfert(Nbyte,' ');
|
|
readbuf = (Standard_PCharacter)transfert.ToCString();
|
|
//
|
|
abuffer = fgets(readbuf, Nbyte, (FILE *) myFILE);
|
|
//
|
|
if (abuffer == NULL) {
|
|
if (!feof((FILE *) myFILE)) {
|
|
myError.SetValue (errno, Iam, "ReadLine");
|
|
return;
|
|
}
|
|
else {
|
|
myIO = EOF;
|
|
Buffer.Clear();
|
|
NByteRead = 0 ;
|
|
}
|
|
}
|
|
else {
|
|
NByteRead = (Standard_Integer)strlen(abuffer);
|
|
Buffer.SetValue(1,abuffer); // Copy transfert to Buffer
|
|
Buffer.Trunc(NByteRead);
|
|
}
|
|
}
|
|
// --------------------------------------------------------------------------
|
|
// OSD::KindOfFile Retourne le type de fichier.
|
|
// --------------------------------------------------------------------------
|
|
OSD_KindFile OSD_File::KindOfFile ( ) const{
|
|
int status;
|
|
struct stat buffer;
|
|
TCollection_AsciiString FullName;
|
|
OSD_Path aPath;
|
|
|
|
Path(aPath);
|
|
aPath.SystemName (FullName);
|
|
status = stat (FullName.ToCString() , &buffer );
|
|
if ( status == 0) {
|
|
if ( S_ISDIR(buffer.st_mode) ) { return OSD_DIRECTORY ; }
|
|
else if ( S_ISREG(buffer.st_mode) ) { return OSD_FILE ; }
|
|
else if ( S_ISLNK(buffer.st_mode) ) { return OSD_LINK ; }
|
|
else if ( S_ISSOCK(buffer.st_mode) ) { return OSD_SOCKET ; }
|
|
else { return OSD_UNKNOWN ; }
|
|
}
|
|
return OSD_UNKNOWN ;
|
|
|
|
}
|
|
// --------------------------------------------------------------------------
|
|
// Read content of a file
|
|
// --------------------------------------------------------------------------
|
|
void OSD_File::Read( Standard_Address& Buffer,
|
|
const Standard_Integer Nbyte,
|
|
Standard_Integer& Readbyte)
|
|
{
|
|
int status;
|
|
|
|
Readbyte = 0;
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
|
|
}
|
|
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::Read : file is not open");
|
|
|
|
if (Failed()) Perror();
|
|
|
|
if (myMode == OSD_WriteOnly)
|
|
Standard_ProgramError::Raise("OSD_File::Read : file is Write only");
|
|
|
|
if (Nbyte <= 0)
|
|
Standard_ProgramError::Raise("OSD_File::Read : Nbyte is null");
|
|
|
|
if (Buffer == NULL)
|
|
Standard_ProgramError::Raise("OSD_File::Read : Buffer is null");
|
|
|
|
status = read (myFileChannel, (char*) Buffer, Nbyte);
|
|
|
|
if (status == -1) myError.SetValue (errno, Iam, "Read");
|
|
else{
|
|
if ( status < Nbyte ) myIO = EOF;
|
|
Readbyte = status;
|
|
}
|
|
}
|
|
|
|
// Write content of a file
|
|
|
|
void OSD_File::Write(const TCollection_AsciiString &Buffer,
|
|
const Standard_Integer Nbyte){
|
|
|
|
Standard_CString writebuf;
|
|
int status;
|
|
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
Standard_ProgramError::Raise("OSD_File::Write : it is a directory");
|
|
}
|
|
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::Write : file is not open");
|
|
|
|
if (Failed()) Perror();
|
|
|
|
if (myMode == OSD_ReadOnly)
|
|
Standard_ProgramError::Raise("OSD_File::Write : file is Read only");
|
|
|
|
if (Nbyte <= 0)
|
|
Standard_ProgramError::Raise("OSD_File::Write : Nbyte is null");
|
|
|
|
writebuf = Buffer.ToCString();
|
|
|
|
status = write (myFileChannel, writebuf, Nbyte);
|
|
|
|
if ( status == -1) myError.SetValue (errno, Iam, "Write");
|
|
else
|
|
if ( status < Nbyte ) myIO = EOF;
|
|
}
|
|
|
|
|
|
void OSD_File::Write(const Standard_Address Buffer,
|
|
const Standard_Integer Nbyte)
|
|
{
|
|
|
|
int status;
|
|
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::Write : file is not open");
|
|
|
|
if (Failed()) Perror();
|
|
|
|
if (myMode == OSD_ReadOnly)
|
|
Standard_ProgramError::Raise("OSD_File::Write : file is Read only");
|
|
|
|
if (Nbyte <= 0)
|
|
Standard_ProgramError::Raise("OSD_File::Write : Nbyte is null");
|
|
|
|
status = write (myFileChannel, (const char *)Buffer, Nbyte);
|
|
|
|
if ( status == -1) myError.SetValue (errno, Iam, "Write");
|
|
else
|
|
if ( status < Nbyte ) myIO = EOF;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Move file pointer to a specified position
|
|
|
|
void OSD_File::Seek(const Standard_Integer Offset,
|
|
const OSD_FromWhere Whence){
|
|
int iwhere=0;
|
|
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::Seek : file is not open");
|
|
|
|
if (Failed()) Perror();
|
|
|
|
switch (Whence){
|
|
case OSD_FromBeginning :
|
|
iwhere = SEEK_SET;
|
|
break;
|
|
case OSD_FromHere:
|
|
iwhere = SEEK_CUR;
|
|
break;
|
|
case OSD_FromEnd:
|
|
iwhere = SEEK_END;
|
|
break;
|
|
default :
|
|
myError.SetValue (EINVAL, Iam, "Seek");
|
|
}
|
|
|
|
off_t status = lseek (myFileChannel, Offset, iwhere);
|
|
if (status == -1) myError.SetValue (errno, Iam, "Seek");
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Close a file
|
|
|
|
void OSD_File::Close(){
|
|
int status;
|
|
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::Close : file is not open");
|
|
|
|
if (Failed()) Perror();
|
|
|
|
// note: it probably should be single call to fclose()...
|
|
status = close (myFileChannel);
|
|
|
|
if (status == -1) myError.SetValue (errno, Iam, "Close");
|
|
myFileChannel = -1;
|
|
if ( myFILE != NULL ) {
|
|
status = fclose ( (FILE*) myFILE );
|
|
myFILE = NULL;
|
|
}
|
|
myIO = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Test if at end of file
|
|
// --------------------------------------------------------------------------
|
|
|
|
Standard_Boolean OSD_File::IsAtEnd(){
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::IsAtEnd : file is not open");
|
|
|
|
if (myIO == EOF) return (Standard_True);
|
|
return (Standard_False);
|
|
}
|
|
|
|
|
|
|
|
/*void OSD_File::Link(const TCollection_AsciiString& ToFile){
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::Link : file is not open");
|
|
|
|
TCollection_AsciiString aBuffer;
|
|
myPath.SystemName ( aBuffer );
|
|
link ( aBuffer.ToCString(), ToFile.ToCString() );
|
|
|
|
}*/
|
|
|
|
|
|
|
|
void OSD_File::SetLock(const OSD_LockType Lock){
|
|
int status;
|
|
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::SetLock : file is not open");
|
|
|
|
|
|
#ifdef POSIX
|
|
int lock;
|
|
struct stat buf;
|
|
|
|
switch (Lock){
|
|
case OSD_ExclusiveLock :
|
|
case OSD_WriteLock : lock = F_LOCK;
|
|
break;
|
|
case OSD_ReadLock : return;
|
|
break;
|
|
default : myError.SetValue (EINVAL, Iam, "SetLock");
|
|
return;
|
|
}
|
|
|
|
if (fstat (myFileChannel, &buf) == -1) {
|
|
myError.SetValue (errno, Iam, "SetLock");
|
|
return;
|
|
}
|
|
|
|
status = lockf(myFileChannel, lock, buf.st_size);
|
|
if (status == -1) myError.SetValue (errno, Iam, "SetLock");
|
|
else myLock = Lock;
|
|
|
|
#else
|
|
#ifdef SYSV
|
|
struct stat buf;
|
|
struct flock key;
|
|
|
|
switch (Lock){
|
|
case OSD_ExclusiveLock :
|
|
case OSD_WriteLock : key.l_type = F_WRLCK;
|
|
break;
|
|
case OSD_ReadLock : key.l_type = F_RDLCK;
|
|
break;
|
|
case OSD_NoLock : return;
|
|
// default : myError.SetValue (EINVAL, Iam, "SetLock");
|
|
}
|
|
|
|
key.l_whence = 0;
|
|
key.l_start = 0;
|
|
key.l_len = 0;
|
|
|
|
status = fcntl (myFileChannel, F_SETLKW, &key);
|
|
if (status == -1) myError.SetValue (errno, Iam, "SetLock");
|
|
else myLock = Lock;
|
|
|
|
if (Lock == OSD_ExclusiveLock){
|
|
fstat (myFileChannel, &buf);
|
|
TCollection_AsciiString aBuffer;
|
|
myPath.SystemName ( aBuffer );
|
|
chmod( aBuffer.ToCString() ,buf.st_mode | S_ISGID);
|
|
ImperativeFlag = Standard_True;
|
|
}
|
|
|
|
#else /* BSD */
|
|
int lock;
|
|
|
|
switch (Lock){
|
|
case OSD_ExclusiveLock :
|
|
case OSD_WriteLock : lock = F_WRLCK;
|
|
break;
|
|
case OSD_ReadLock : lock = F_RDLCK;
|
|
break;
|
|
default : myError.SetValue (EINVAL, Iam, "SetLock");
|
|
}
|
|
|
|
status = flock (myFileChannel, lock);
|
|
if (status == -1) myError.SetValue (errno, Iam, "SetLock");
|
|
else myLock = Lock;
|
|
#endif // SysV
|
|
#endif // POSIX
|
|
}
|
|
|
|
|
|
|
|
|
|
// Remove a lock from a file
|
|
|
|
void OSD_File::UnLock(){
|
|
int status;
|
|
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::UnLock : file is not open");
|
|
|
|
#ifdef POSIX
|
|
struct stat buf;
|
|
|
|
if (fstat(myFileChannel, &buf) == -1) {
|
|
myError.SetValue(errno, Iam, "UnsetLock");
|
|
return;
|
|
}
|
|
|
|
status = lockf(myFileChannel,F_ULOCK, buf.st_size);
|
|
if (status == -1) myError.SetValue (errno, Iam, "SetLock");
|
|
|
|
#else
|
|
#ifdef SYSV
|
|
struct stat buf;
|
|
struct flock key;
|
|
|
|
if (ImperativeFlag){
|
|
fstat (myFileChannel, &buf);
|
|
TCollection_AsciiString aBuffer;
|
|
myPath.SystemName ( aBuffer );
|
|
chmod(aBuffer.ToCString(),buf.st_mode & ~S_ISGID);
|
|
ImperativeFlag = Standard_False;
|
|
}
|
|
key.l_type = F_UNLCK;
|
|
status = fcntl (myFileChannel, F_SETLK, &key);
|
|
if (status == -1) myError.SetValue (errno, Iam, "UnSetLock");
|
|
#else
|
|
|
|
status = flock (myFileChannel, LOCK_UN);
|
|
if (status == -1) myError.SetValue (errno, Iam, "UnSetLock");
|
|
#endif
|
|
#endif // POSIX
|
|
else myLock = OSD_NoLock;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Return lock of a file
|
|
|
|
OSD_LockType OSD_File::GetLock(){
|
|
if (myFileChannel == -1)
|
|
Standard_ProgramError::Raise("OSD_File::GetLock : file is not open");
|
|
|
|
return(myLock);
|
|
}
|
|
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Return size of a file
|
|
// --------------------------------------------------------------------------
|
|
|
|
Standard_Size OSD_File::Size(){
|
|
struct stat buffer;
|
|
int status;
|
|
|
|
if (myPath.Name().Length()==0)
|
|
Standard_ProgramError::Raise("OSD_File::Size : empty file name");
|
|
|
|
TCollection_AsciiString aBuffer;
|
|
myPath.SystemName ( aBuffer );
|
|
status = stat( aBuffer.ToCString() ,&buffer );
|
|
if (status == -1) {
|
|
myError.SetValue (errno, Iam, "Size");
|
|
return 0;
|
|
}
|
|
|
|
return (Standard_Size)buffer.st_size;
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Print contains of a file
|
|
// --------------------------------------------------------------------------
|
|
|
|
void OSD_File::Print (const OSD_Printer &WhichPrinter ){
|
|
char buffer[255];
|
|
TCollection_AsciiString PrinterName;
|
|
|
|
if (myPath.Name().Length()==0)
|
|
Standard_ProgramError::Raise("OSD_File::Print : empty file name");
|
|
|
|
WhichPrinter.Name(PrinterName);
|
|
|
|
TCollection_AsciiString aBuffer;
|
|
myPath.SystemName ( aBuffer );
|
|
|
|
if (PrinterName.Length()==0)
|
|
sprintf(buffer,"lp %s",aBuffer.ToCString());
|
|
else
|
|
sprintf(buffer,"lpr -P%s %s",PrinterName.ToCString(),aBuffer.ToCString());
|
|
|
|
system(buffer);
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Test if a file is open
|
|
// --------------------------------------------------------------------------
|
|
|
|
Standard_Boolean OSD_File::IsOpen()const{
|
|
|
|
if (myPath.Name().Length()==0)
|
|
Standard_ProgramError::Raise("OSD_File::IsOpen : empty file name");
|
|
|
|
return (myFileChannel != -1);
|
|
}
|
|
|
|
|
|
Standard_Boolean OSD_File::IsLocked(){
|
|
|
|
if (myPath.Name().Length()==0)
|
|
Standard_ProgramError::Raise("OSD_File::IsLocked : empty file name");
|
|
|
|
return(myLock != OSD_NoLock);
|
|
}
|
|
|
|
Standard_Boolean OSD_File::IsReadable()
|
|
{
|
|
TCollection_AsciiString FileName ;
|
|
|
|
myPath.SystemName(FileName) ;
|
|
|
|
if (access(FileName.ToCString(),F_OK|R_OK))
|
|
return Standard_False;
|
|
else
|
|
return Standard_True;
|
|
}
|
|
|
|
Standard_Boolean OSD_File::IsWriteable()
|
|
{
|
|
TCollection_AsciiString FileName ;
|
|
|
|
myPath.SystemName(FileName) ;
|
|
|
|
if (access(FileName.ToCString(),F_OK|R_OK|W_OK))
|
|
return Standard_False;
|
|
else
|
|
return Standard_True;
|
|
}
|
|
|
|
Standard_Boolean OSD_File::IsExecutable()
|
|
{
|
|
TCollection_AsciiString FileName ;
|
|
|
|
myPath.SystemName(FileName) ;
|
|
|
|
if (access(FileName.ToCString(),F_OK|X_OK))
|
|
return Standard_False;
|
|
else
|
|
return Standard_True;
|
|
}
|
|
|
|
#else /* _WIN32 */
|
|
|
|
//------------------------------------------------------------------------
|
|
//------------------- Windows NT sources for OSD_File -------------------
|
|
//------------------------------------------------------------------------
|
|
|
|
#include <windows.h>
|
|
|
|
#include <OSD_File.hxx>
|
|
#include <OSD_Protection.hxx>
|
|
#include <OSD_Printer.hxx>
|
|
#include <Standard_ProgramError.hxx>
|
|
|
|
#include <OSD_WNT_1.hxx>
|
|
|
|
#include <stdio.h>
|
|
#include <io.h>
|
|
#include <Standard_PCharacter.hxx>
|
|
|
|
#ifndef _INC_TCHAR
|
|
# include <tchar.h>
|
|
#endif // _INC_TCHAR
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#define VAC
|
|
#define _int64 int
|
|
#endif
|
|
|
|
#pragma comment( lib, "WSOCK32.LIB" )
|
|
#pragma comment( lib, "WINSPOOL.LIB" )
|
|
|
|
#define ACE_HEADER_SIZE ( sizeof ( ACCESS_ALLOWED_ACE ) - sizeof ( DWORD ) )
|
|
|
|
#define RAISE( arg ) Standard_ProgramError :: Raise ( ( arg ) )
|
|
#define TEST_RAISE( arg ) _test_raise ( myFileHandle, ( arg ) )
|
|
|
|
#define OPEN_NEW 0
|
|
#define OPEN_OLD 1
|
|
#define OPEN_APPEND 2
|
|
|
|
void _osd_wnt_set_error ( OSD_Error&, OSD_WhoAmI, ... );
|
|
PSECURITY_DESCRIPTOR __fastcall _osd_wnt_protection_to_sd ( const OSD_Protection&, BOOL, char* = NULL );
|
|
BOOL __fastcall _osd_wnt_sd_to_protection (
|
|
PSECURITY_DESCRIPTOR, OSD_Protection&, BOOL
|
|
);
|
|
BOOL __fastcall _osd_print (const Standard_PCharacter, Standard_CString );
|
|
|
|
static void __fastcall _test_raise ( HANDLE, Standard_CString );
|
|
static DWORDLONG __fastcall _get_line ( Standard_PCharacter&, DWORD );
|
|
static int __fastcall _get_buffer ( HANDLE, Standard_PCharacter&, DWORD, BOOL, BOOL );
|
|
static DWORD __fastcall _get_access_mask ( OSD_SingleProtection );
|
|
static DWORD __fastcall _get_dir_access_mask ( OSD_SingleProtection prt );
|
|
static HANDLE __fastcall _open_file ( Standard_CString, OSD_OpenMode, DWORD, LPBOOL = NULL );
|
|
|
|
static OSD_SingleProtection __fastcall _get_protection ( DWORD );
|
|
static OSD_SingleProtection __fastcall _get_protection_dir ( DWORD );
|
|
|
|
typedef OSD_SingleProtection ( __fastcall *GET_PROT_FUNC ) ( DWORD );
|
|
|
|
Standard_Integer __fastcall _get_file_type ( Standard_CString, HANDLE );
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Create an empty file object
|
|
// ---------------------------------------------------------------------
|
|
|
|
OSD_File :: OSD_File ()
|
|
{
|
|
ImperativeFlag = Standard_False;
|
|
myLock = OSD_NoLock;
|
|
myIO = 0;
|
|
myFileChannel = -1;
|
|
myFileHandle = INVALID_HANDLE_VALUE;
|
|
} // end constructor ( 1 )
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Create and initialize a file object
|
|
// ---------------------------------------------------------------------
|
|
|
|
OSD_File :: OSD_File ( const OSD_Path& Name ) : OSD_FileNode ( Name )
|
|
{
|
|
ImperativeFlag = Standard_False;
|
|
myLock = OSD_NoLock;
|
|
myIO = 0;
|
|
myPath = Name;
|
|
myFileChannel = -1;
|
|
myFileHandle = INVALID_HANDLE_VALUE;
|
|
} // end constructor ( 2 )
|
|
|
|
// protect against occasional use of myFileHande in Windows code
|
|
#define myFileChannel myFileChannel_is_only_for_Linux
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Build a file if it doesn't exist or create again if it already exists
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File :: Build (
|
|
const OSD_OpenMode Mode, const OSD_Protection& Protect
|
|
) {
|
|
|
|
TCollection_AsciiString fName;
|
|
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
|
|
}
|
|
|
|
if (myFileHandle != INVALID_HANDLE_VALUE)
|
|
|
|
RAISE( TEXT( "OSD_File :: Build (): incorrect call - file already opened" ) );
|
|
|
|
myMode = Mode;
|
|
myPath.SystemName ( fName );
|
|
|
|
if ( fName.IsEmpty () )
|
|
|
|
RAISE( TEXT( "OSD_File :: Build (): incorrent call - no filename given" ) );
|
|
|
|
myFileHandle = _open_file ( fName.ToCString (), Mode, OPEN_NEW );
|
|
|
|
if (myFileHandle == INVALID_HANDLE_VALUE)
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
else {
|
|
|
|
SetProtection ( Protect );
|
|
myIO |= FLAG_FILE;
|
|
|
|
} // end else
|
|
|
|
} // end OSD_File :: Build
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Open a file
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File :: Open (const OSD_OpenMode Mode, const OSD_Protection& /*Protect*/)
|
|
{
|
|
|
|
TCollection_AsciiString fName;
|
|
|
|
|
|
if (myFileHandle != INVALID_HANDLE_VALUE)
|
|
|
|
RAISE( TEXT( "OSD_File :: Open (): incorrect call - file already opened" ) );
|
|
|
|
myMode = Mode;
|
|
myPath.SystemName ( fName );
|
|
|
|
if ( fName.IsEmpty () )
|
|
|
|
RAISE( TEXT( "OSD_File :: Open (): incorrent call - no filename given" ) );
|
|
|
|
myFileHandle = _open_file ( fName.ToCString (), Mode, OPEN_OLD );
|
|
|
|
if (myFileHandle == INVALID_HANDLE_VALUE) {
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
}
|
|
else
|
|
{
|
|
myIO |= _get_file_type ( fName.ToCString (), myFileHandle );
|
|
}
|
|
} // end OSD_File :: Open
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Append to an existing file
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File :: Append (
|
|
const OSD_OpenMode Mode, const OSD_Protection& Protect
|
|
) {
|
|
|
|
BOOL fNew = FALSE;
|
|
TCollection_AsciiString fName;
|
|
|
|
if (myFileHandle != INVALID_HANDLE_VALUE)
|
|
|
|
RAISE( TEXT( "OSD_File :: Append (): incorrect call - file already opened" ) );
|
|
|
|
myMode = Mode;
|
|
myPath.SystemName ( fName );
|
|
|
|
if ( fName.IsEmpty () )
|
|
|
|
RAISE( TEXT( "OSD_File :: Append (): incorrent call - no filename given" ) );
|
|
|
|
myFileHandle = _open_file ( fName.ToCString (), Mode, OPEN_APPEND, &fNew );
|
|
|
|
if (myFileHandle == INVALID_HANDLE_VALUE)
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
else {
|
|
|
|
if ( !fNew ) {
|
|
|
|
myIO |= _get_file_type ( fName.ToCString (), myFileHandle );
|
|
Seek ( 0, OSD_FromEnd );
|
|
|
|
} else {
|
|
|
|
SetProtection ( Protect );
|
|
myIO |= FLAG_FILE;
|
|
|
|
} // end else
|
|
|
|
} // end else;
|
|
|
|
} // end OSD_File :: Append
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Read content of a file
|
|
// ---------------------------------------------------------------------
|
|
|
|
void OSD_File :: Read (
|
|
TCollection_AsciiString& Buffer, const Standard_Integer Nbyte
|
|
) {
|
|
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
cout << " OSD_File::Read : it is a directory " << endl;
|
|
return ;
|
|
// Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
|
|
}
|
|
|
|
Standard_Integer NbyteRead;
|
|
Standard_Address buff;
|
|
|
|
TEST_RAISE( TEXT( "Read" ) );
|
|
|
|
buff = ( Standard_Address )new Standard_Character[ Nbyte + 1 ];
|
|
|
|
Read ( buff, Nbyte, NbyteRead );
|
|
|
|
( ( Standard_PCharacter )buff )[ NbyteRead ] = 0;
|
|
|
|
if ( NbyteRead != 0 )
|
|
|
|
Buffer = ( Standard_PCharacter )buff;
|
|
|
|
else
|
|
|
|
Buffer.Clear ();
|
|
|
|
delete [] buff;
|
|
|
|
} // end OSD_File :: Read
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Read a line from a file
|
|
// ---------------------------------------------------------------------
|
|
|
|
// Modified so that we have <nl> at end of line if we have read <nl> or <cr>
|
|
// in the file.
|
|
// by LD 17 dec 98 for B4.4
|
|
|
|
void OSD_File :: ReadLine (
|
|
TCollection_AsciiString& Buffer,
|
|
const Standard_Integer NByte, Standard_Integer& NbyteRead
|
|
) {
|
|
|
|
DWORDLONG status;
|
|
DWORD dwBytesRead;
|
|
DWORD dwDummy;
|
|
Standard_Character peekChar;
|
|
Standard_PCharacter ppeekChar;
|
|
Standard_PCharacter cBuffer;
|
|
Standard_CString eos;
|
|
DWORD dwSeekPos;
|
|
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
|
|
}
|
|
|
|
TEST_RAISE( TEXT( "ReadLine" ) );
|
|
|
|
if ( myIO & FLAG_PIPE && !( myIO & FLAG_READ_PIPE ) )
|
|
|
|
RAISE( TEXT( "OSD_File :: ReadLine (): attempt to read from write only pipe" ) );
|
|
|
|
// +----> leave space for end-of-string
|
|
// | plus <CR><LF> sequence
|
|
// |
|
|
|
|
ppeekChar=&peekChar;
|
|
cBuffer = new Standard_Character[ NByte + 3 ];
|
|
|
|
if ( myIO & FLAG_FILE ) {
|
|
|
|
if (!ReadFile (myFileHandle, cBuffer, (DWORD)NByte, &dwBytesRead, NULL)) { // an error occured
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
Buffer.Clear ();
|
|
NbyteRead = 0;
|
|
|
|
} else if ( dwBytesRead == 0 ) { // end-of-file reached
|
|
|
|
Buffer.Clear ();
|
|
NbyteRead = 0;
|
|
myIO |= FLAG_EOF;
|
|
|
|
} else {
|
|
myIO &= ~FLAG_EOF ; // if the file increased since last read (LD)
|
|
status = _get_line ( cBuffer, dwBytesRead );
|
|
|
|
dwSeekPos = LODWORD( status );
|
|
eos = ( Standard_CString )HIDWORD( status );
|
|
#ifdef VAC
|
|
if ( (__int64) status == (__int64) -1 ) { // last character in the buffer is <CR> -
|
|
#else
|
|
if ( status == 0xFFFFFFFFFFFFFFFF ) { // last character in the buffer is <CR> -
|
|
// peek next character to see if it is a <LF>
|
|
#endif
|
|
if (!ReadFile (myFileHandle, ppeekChar, 1, &dwDummy, NULL)) {
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
} else if ( dwDummy != 0 ) { // end-of-file reached ?
|
|
|
|
if ( peekChar != '\n' ) // if we did not get a <CR><LF> sequence
|
|
|
|
// adjust file position
|
|
|
|
SetFilePointer (myFileHandle, -1, NULL, FILE_CURRENT);
|
|
|
|
} else
|
|
myIO |= FLAG_EOF;
|
|
|
|
NbyteRead = dwBytesRead;
|
|
|
|
} else {
|
|
|
|
if ( dwSeekPos != 0 )
|
|
SetFilePointer (myFileHandle, (LONG)dwSeekPos, NULL, FILE_CURRENT);
|
|
|
|
NbyteRead = ( Standard_Integer )( eos - cBuffer );
|
|
|
|
}
|
|
|
|
} // end else
|
|
|
|
} else if ( myIO & FLAG_SOCKET || myIO & FLAG_PIPE || myIO & FLAG_NAMED_PIPE ) {
|
|
|
|
dwBytesRead = (DWORD)_get_buffer (myFileHandle, cBuffer,
|
|
(DWORD)NByte, TRUE, myIO & FLAG_SOCKET);
|
|
|
|
if ( ( int )dwBytesRead == -1 ) { // an error occured
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
Buffer.Clear ();
|
|
NbyteRead = 0;
|
|
|
|
} else if ( dwBytesRead == 0 ) { // connection closed - set end-of-file flag
|
|
|
|
Buffer.Clear ();
|
|
NbyteRead = 0;
|
|
myIO |= FLAG_EOF;
|
|
|
|
} else {
|
|
|
|
status = _get_line ( cBuffer, dwBytesRead );
|
|
|
|
dwSeekPos = LODWORD( status );
|
|
eos = ( Standard_CString )HIDWORD( status );
|
|
|
|
#ifdef VAC
|
|
if ( (__int64) status == (__int64) -1 ) { // last character in the buffer is <CR> -
|
|
#else
|
|
if ( status == 0xFFFFFFFFFFFFFFFF ) { // last character in the buffer is <CR> -
|
|
// peek next character to see if it is a <LF>
|
|
#endif
|
|
|
|
NbyteRead = dwBytesRead; // (LD) always fits this case.
|
|
|
|
dwDummy = _get_buffer (myFileHandle, ppeekChar, 1, TRUE, myIO & FLAG_SOCKET);
|
|
if ( ( int )dwDummy == -1 ) { // an error occured
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
} else if ( dwDummy != 0 ) { // connection closed ?
|
|
|
|
if ( peekChar == '\n' ) // we got a <CR><LF> sequence
|
|
|
|
dwBytesRead++ ; // (LD) we have to jump <LF>
|
|
} else
|
|
|
|
myIO |= FLAG_EOF;
|
|
|
|
} else {
|
|
|
|
if ( dwSeekPos != 0 )
|
|
dwBytesRead = dwBytesRead + dwSeekPos;
|
|
|
|
NbyteRead = ( Standard_Integer )( eos - cBuffer );
|
|
|
|
}
|
|
|
|
// Don't rewrite datas in cBuffer.
|
|
|
|
Standard_PCharacter cDummyBuffer = new Standard_Character[ NByte + 3 ];
|
|
|
|
// remove pending input
|
|
_get_buffer (myFileHandle, cDummyBuffer, dwBytesRead, FALSE, myIO & FLAG_SOCKET);
|
|
delete [] cDummyBuffer ;
|
|
|
|
} // end else
|
|
|
|
} else
|
|
|
|
RAISE( TEXT( "OSD_File :: ReadLine (): incorrect call - file is a directory" ) );
|
|
|
|
if ( !Failed () && !IsAtEnd () )
|
|
|
|
Buffer = cBuffer;
|
|
|
|
delete [] (Standard_PCharacter)cBuffer;
|
|
|
|
} // end OSD_File :: ReadLine
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Read content of a file
|
|
// --------------------------------------------------------------------------
|
|
|
|
void OSD_File :: Read (
|
|
Standard_Address& Buffer,
|
|
const Standard_Integer Nbyte, Standard_Integer& Readbyte
|
|
) {
|
|
|
|
DWORD dwBytesRead;
|
|
|
|
if ( OSD_File::KindOfFile ( ) == OSD_DIRECTORY ) {
|
|
Standard_ProgramError::Raise("OSD_File::Read : it is a directory");
|
|
}
|
|
|
|
TEST_RAISE( TEXT( "Read" ) );
|
|
|
|
if ( myIO & FLAG_PIPE && !( myIO & FLAG_READ_PIPE ) )
|
|
|
|
RAISE( TEXT( "OSD_File :: Read (): attempt to read from write only pipe" ) );
|
|
|
|
if (!ReadFile (myFileHandle, Buffer, (DWORD)Nbyte, &dwBytesRead, NULL)) {
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
dwBytesRead = 0;
|
|
|
|
} else if ( dwBytesRead == 0 )
|
|
|
|
myIO |= FLAG_EOF;
|
|
|
|
else
|
|
|
|
myIO &= ~FLAG_EOF;
|
|
|
|
Readbyte = ( Standard_Integer )dwBytesRead;
|
|
|
|
} // end OSD_File :: Read
|
|
|
|
void OSD_File :: Write (
|
|
const TCollection_AsciiString& Buffer,
|
|
const Standard_Integer Nbyte
|
|
) {
|
|
|
|
Write ( ( Standard_Address )Buffer.ToCString (), Nbyte );
|
|
|
|
} // end OSD_File :: Write
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Write content of a file
|
|
// --------------------------------------------------------------------------
|
|
|
|
void OSD_File :: Write (
|
|
const Standard_Address Buffer,
|
|
const Standard_Integer Nbyte
|
|
) {
|
|
|
|
DWORD dwBytesWritten;
|
|
|
|
TEST_RAISE( TEXT( "Write" ) );
|
|
|
|
if ( myIO & FLAG_PIPE && myIO & FLAG_READ_PIPE )
|
|
|
|
RAISE( TEXT( "OSD_File :: Write (): attempt to write to read only pipe" ) );
|
|
|
|
if (!WriteFile (myFileHandle, Buffer, (DWORD)Nbyte, &dwBytesWritten, NULL) ||
|
|
dwBytesWritten != (DWORD)Nbyte)
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
} // end OSD_File :: Write
|
|
|
|
void OSD_File :: Seek (
|
|
const Standard_Integer Offset, const OSD_FromWhere Whence
|
|
) {
|
|
|
|
DWORD dwMoveMethod = 0;
|
|
|
|
TEST_RAISE( TEXT( "Seek" ) );
|
|
|
|
if ( myIO & FLAG_FILE || myIO & FLAG_DIRECTORY ) {
|
|
|
|
switch ( Whence ) {
|
|
|
|
case OSD_FromBeginning:
|
|
|
|
dwMoveMethod = FILE_BEGIN;
|
|
|
|
break;
|
|
|
|
case OSD_FromHere:
|
|
|
|
dwMoveMethod = FILE_CURRENT;
|
|
|
|
break;
|
|
|
|
case OSD_FromEnd:
|
|
|
|
dwMoveMethod = FILE_END;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
RAISE( TEXT( "OSD_File :: Seek (): invalid parameter" ) );
|
|
|
|
} // end switch
|
|
|
|
if (SetFilePointer (myFileHandle, (LONG)Offset, NULL, dwMoveMethod) == 0xFFFFFFFF)
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
} // end if
|
|
|
|
myIO &= ~FLAG_EOF;
|
|
|
|
} // end OSD_File :: Seek
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Close a file
|
|
// --------------------------------------------------------------------------
|
|
|
|
void OSD_File :: Close () {
|
|
|
|
TEST_RAISE( TEXT( "Close" ) );
|
|
|
|
CloseHandle (myFileHandle);
|
|
|
|
myFileHandle = INVALID_HANDLE_VALUE;
|
|
myIO = 0;
|
|
|
|
} // end OSD_File :: Close
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Test if at end of file
|
|
// --------------------------------------------------------------------------
|
|
|
|
Standard_Boolean OSD_File :: IsAtEnd () {
|
|
|
|
TEST_RAISE( TEXT( "IsAtEnd" ) );
|
|
|
|
if (myIO & FLAG_EOF)
|
|
return Standard_True ;
|
|
return Standard_False ;
|
|
|
|
} // end OSD_File :: IsAtEnd
|
|
|
|
OSD_KindFile OSD_File :: KindOfFile () const {
|
|
|
|
OSD_KindFile retVal;
|
|
Standard_Integer flags;
|
|
|
|
if (myFileHandle == INVALID_HANDLE_VALUE) {
|
|
|
|
TCollection_AsciiString fName;
|
|
|
|
myPath.SystemName ( fName );
|
|
|
|
if ( fName.IsEmpty () )
|
|
|
|
RAISE( TEXT( "OSD_File :: KindOfFile (): incorrent call - no filename given" ) );
|
|
|
|
flags = _get_file_type (fName.ToCString(), INVALID_HANDLE_VALUE);
|
|
|
|
} else
|
|
|
|
flags = myIO;
|
|
|
|
switch ( flags & FLAG_TYPE ) {
|
|
|
|
case FLAG_FILE:
|
|
|
|
retVal = OSD_FILE;
|
|
|
|
break;
|
|
|
|
case FLAG_DIRECTORY:
|
|
|
|
retVal = OSD_DIRECTORY;
|
|
|
|
break;
|
|
|
|
case FLAG_SOCKET:
|
|
|
|
retVal = OSD_SOCKET;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
retVal = OSD_UNKNOWN;
|
|
|
|
} // end switch
|
|
|
|
return retVal;
|
|
|
|
} // end OSD_File :: KindOfFile
|
|
#define PRO13792
|
|
#ifndef PRO13792
|
|
|
|
OSD_File OSD_File :: BuildTemporary () {
|
|
|
|
OSD_Protection prt;
|
|
OSD_File retVal;
|
|
|
|
#ifdef VAC
|
|
char tmpbuf [MAX_PATH];
|
|
if (GetTempPath (MAX_PATH, tmpbuf) == 0)
|
|
{
|
|
perror ("ERROR in GetTempPath");
|
|
exit (10);
|
|
}
|
|
char tmpbuf2 [MAX_PATH];
|
|
if (GetTempFileName (tmpbuf, NULL, 0, tmpbuf2) == 0)
|
|
{
|
|
perror ("ERROR in GetTempFileName");
|
|
exit (10);
|
|
}
|
|
TCollection_AsciiString fileName ( tmpbuf2 );
|
|
#else
|
|
TCollection_AsciiString fileName ( _ttmpnam ( NULL ) );
|
|
#endif
|
|
|
|
OSD_Path filePath ( fileName );
|
|
|
|
retVal.SetPath ( filePath );
|
|
retVal.Build ( OSD_ReadWrite, prt );
|
|
|
|
return retVal;
|
|
|
|
} // end OSD_File :: BuildTemporary
|
|
|
|
#else // PRO13792
|
|
|
|
//-------------------------------------------------debutpri???980424
|
|
|
|
typedef struct _osd_wnt_key {
|
|
|
|
HKEY hKey;
|
|
LPTSTR keyPath;
|
|
|
|
} OSD_WNT_KEY;
|
|
|
|
|
|
OSD_File OSD_File :: BuildTemporary () {
|
|
|
|
OSD_Protection prt;
|
|
OSD_File retVal;
|
|
HKEY hKey;
|
|
TCHAR tmpPath[ MAX_PATH ];
|
|
BOOL fOK = FALSE;
|
|
OSD_WNT_KEY regKey[ 2 ] = {
|
|
|
|
{ HKEY_LOCAL_MACHINE,
|
|
TEXT( "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment" )
|
|
},
|
|
{ HKEY_USERS,
|
|
TEXT( ".DEFAULT\\Environment" )
|
|
}
|
|
|
|
};
|
|
|
|
for ( int i = 0; i < 2; ++i ) {
|
|
|
|
if ( RegOpenKeyEx (
|
|
regKey[ i ].hKey, regKey[ i ].keyPath, 0, KEY_QUERY_VALUE, &hKey
|
|
) == ERROR_SUCCESS
|
|
) {
|
|
|
|
DWORD dwType;
|
|
DWORD dwSize = 0;
|
|
|
|
if ( RegQueryValueEx (
|
|
hKey, TEXT( "TEMP" ), NULL, &dwType, NULL, &dwSize
|
|
) == ERROR_SUCCESS
|
|
) {
|
|
|
|
LPTSTR kVal = ( LPTSTR )HeapAlloc (
|
|
GetProcessHeap (), HEAP_ZERO_MEMORY | HEAP_GENERATE_EXCEPTIONS,
|
|
dwSize + sizeof ( TCHAR )
|
|
);
|
|
|
|
RegQueryValueEx ( hKey, TEXT( "TEMP" ), NULL, &dwType, ( LPBYTE )kVal, &dwSize );
|
|
|
|
if ( dwType == REG_EXPAND_SZ )
|
|
|
|
ExpandEnvironmentStrings ( kVal, tmpPath, MAX_PATH );
|
|
|
|
else
|
|
|
|
lstrcpy ( tmpPath, kVal );
|
|
|
|
HeapFree ( GetProcessHeap (), 0, ( LPVOID )kVal );
|
|
fOK = TRUE;
|
|
|
|
} // end if
|
|
|
|
RegCloseKey ( hKey );
|
|
|
|
} // end if
|
|
|
|
if ( fOK ) break;
|
|
|
|
} // end for
|
|
|
|
if ( !fOK ) lstrcpy ( tmpPath, TEXT( "./" ) );
|
|
|
|
GetTempFileName ( tmpPath, "CSF", 0, tmpPath );
|
|
|
|
retVal.SetPath ( OSD_Path ( tmpPath ) );
|
|
retVal.Build ( OSD_ReadWrite, prt );
|
|
|
|
return retVal;
|
|
|
|
} // end OSD_File :: BuildTemporary
|
|
|
|
#endif // PRO13792
|
|
|
|
//-------------------------------------------------finpri???980424
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#define __try
|
|
#define __finally
|
|
#define __leave return
|
|
#endif
|
|
|
|
void OSD_File :: SetLock ( const OSD_LockType Lock ) {
|
|
|
|
DWORD dwFlags;
|
|
OVERLAPPED ovlp;
|
|
|
|
TEST_RAISE( TEXT( "SetLock" ) );
|
|
|
|
ZeroMemory ( &ovlp, sizeof ( OVERLAPPED ) );
|
|
|
|
__try {
|
|
|
|
if ( ( myLock = Lock ) == OSD_NoLock ) {
|
|
|
|
UnLock ();
|
|
__leave;
|
|
|
|
} else if ( myLock == OSD_ReadLock || myLock == OSD_ExclusiveLock ) {
|
|
|
|
dwFlags = LOCKFILE_EXCLUSIVE_LOCK;
|
|
|
|
} else
|
|
|
|
dwFlags = 0;
|
|
|
|
LARGE_INTEGER aSize;
|
|
aSize.QuadPart = Size();
|
|
if (!LockFileEx (myFileHandle, dwFlags, 0, aSize.LowPart, aSize.HighPart, &ovlp)) {
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
__leave;
|
|
|
|
} // end if
|
|
|
|
ImperativeFlag = Standard_True;
|
|
|
|
} // end __try
|
|
|
|
__finally {}
|
|
|
|
#ifdef VAC
|
|
leave: ; // added for VisualAge
|
|
#endif
|
|
} // end OSD_File :: SetLock
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#undef __try
|
|
#undef __finally
|
|
#undef __leave
|
|
#endif
|
|
|
|
void OSD_File :: UnLock () {
|
|
|
|
TEST_RAISE( TEXT( "Unlock" ) );
|
|
|
|
if ( ImperativeFlag ) {
|
|
|
|
LARGE_INTEGER aSize;
|
|
aSize.QuadPart = Size();
|
|
if (!UnlockFile (myFileHandle, 0, 0, aSize.LowPart, aSize.HighPart))
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
ImperativeFlag = Standard_False;
|
|
|
|
} // end if
|
|
|
|
} // end OSD_File :: UnLock
|
|
|
|
OSD_LockType OSD_File :: GetLock () {
|
|
|
|
return myLock;
|
|
|
|
} // end OSD_File :: GetLock
|
|
|
|
Standard_Boolean OSD_File :: IsLocked () {
|
|
|
|
TEST_RAISE( TEXT( "IsLocked" ) );
|
|
|
|
return ImperativeFlag;
|
|
|
|
} // end OSD_File :: IsLocked
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Return size of a file
|
|
// --------------------------------------------------------------------------
|
|
|
|
Standard_Size OSD_File :: Size () {
|
|
|
|
Standard_Integer retVal;
|
|
|
|
TEST_RAISE( TEXT( "Size" ) );
|
|
|
|
LARGE_INTEGER aSize;
|
|
aSize.QuadPart = 0;
|
|
retVal = GetFileSizeEx (myFileHandle, &aSize);
|
|
|
|
if ( retVal == 0 )
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
return (Standard_Size)aSize.QuadPart;
|
|
|
|
} // end OSD_File :: Size
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Print contains of a file
|
|
// --------------------------------------------------------------------------
|
|
|
|
void OSD_File :: Print ( const OSD_Printer& WhichPrinter ) {
|
|
|
|
if (myFileHandle != INVALID_HANDLE_VALUE)
|
|
|
|
RAISE( TEXT( "OSD_File :: Print (): incorrect call - file opened" ) );
|
|
|
|
TCollection_AsciiString pName, fName;
|
|
|
|
WhichPrinter.Name ( pName );
|
|
myPath.SystemName ( fName );
|
|
|
|
if ( !_osd_print ( (Standard_PCharacter)pName.ToCString (), fName.ToCString () ) )
|
|
|
|
_osd_wnt_set_error ( myError, OSD_WFile );
|
|
|
|
} // end OSD_File :: Print
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Test if a file is open
|
|
// --------------------------------------------------------------------------
|
|
|
|
Standard_Boolean OSD_File :: IsOpen () const {
|
|
|
|
return myFileHandle != INVALID_HANDLE_VALUE;
|
|
|
|
} // end OSD_File :: IsOpen
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#define __try
|
|
#define __finally
|
|
#define __leave return retVal
|
|
#endif
|
|
|
|
PSECURITY_DESCRIPTOR __fastcall _osd_wnt_protection_to_sd (
|
|
const OSD_Protection& prot, BOOL fDir, char* fName
|
|
) {
|
|
|
|
int i, j;
|
|
BOOL fOK = FALSE;
|
|
PACL pACL = NULL;
|
|
HANDLE hProcess = NULL;
|
|
PSID pSIDowner;
|
|
PSID pSIDadmin;
|
|
PSID pSIDworld;
|
|
PSID pSIDtemp;
|
|
DWORD dwAccessAdmin;
|
|
DWORD dwAccessGroup;
|
|
DWORD dwAccessOwner;
|
|
DWORD dwAccessWorld;
|
|
DWORD dwAccessAdminDir;
|
|
DWORD dwAccessGroupDir;
|
|
DWORD dwAccessOwnerDir;
|
|
DWORD dwAccessWorldDir;
|
|
DWORD dwACLsize = sizeof ( ACL );
|
|
DWORD dwIndex = 0;
|
|
PTOKEN_OWNER pTkOwner = NULL;
|
|
PTOKEN_GROUPS pTkGroups = NULL;
|
|
PTOKEN_PRIMARY_GROUP pTkPrimaryGroup = NULL;
|
|
PSECURITY_DESCRIPTOR retVal = NULL;
|
|
PSECURITY_DESCRIPTOR pfSD = NULL;
|
|
BOOL fDummy;
|
|
PFILE_ACE pFileACE;
|
|
|
|
__try {
|
|
|
|
j = fDir ? 1 : 0;
|
|
|
|
if ( !OpenProcessToken (
|
|
GetCurrentProcess (), TOKEN_QUERY, &hProcess
|
|
)
|
|
) __leave;
|
|
|
|
if ( ( pTkGroups = ( PTOKEN_GROUPS )GetTokenInformationEx (
|
|
hProcess, TokenGroups
|
|
)
|
|
) == NULL
|
|
) __leave;
|
|
|
|
if ( ( pTkOwner = ( PTOKEN_OWNER )GetTokenInformationEx (
|
|
hProcess, TokenOwner
|
|
)
|
|
) == NULL
|
|
) __leave;
|
|
|
|
if ( ( pTkPrimaryGroup = ( PTOKEN_PRIMARY_GROUP )GetTokenInformationEx (
|
|
hProcess, TokenPrimaryGroup
|
|
)
|
|
) == NULL
|
|
) __leave;
|
|
|
|
|
|
retry:
|
|
if ( fName == NULL )
|
|
|
|
pSIDowner = pTkOwner -> Owner;
|
|
|
|
else {
|
|
|
|
pfSD = GetFileSecurityEx ( fName, OWNER_SECURITY_INFORMATION );
|
|
|
|
if ( pfSD == NULL || !GetSecurityDescriptorOwner ( pfSD, &pSIDowner, &fDummy ) ) {
|
|
|
|
fName = NULL;
|
|
goto retry;
|
|
|
|
} // end if
|
|
|
|
} // end else
|
|
|
|
pSIDadmin = AdminSid ();
|
|
pSIDworld = WorldSid ();
|
|
|
|
dwAccessAdmin = _get_access_mask ( prot.System () );
|
|
dwAccessGroup = _get_access_mask ( prot.Group () );
|
|
dwAccessOwner = _get_access_mask ( prot.User () );
|
|
dwAccessWorld = _get_access_mask ( prot.World () );
|
|
|
|
dwAccessAdminDir = _get_dir_access_mask ( prot.System () );
|
|
dwAccessGroupDir = _get_dir_access_mask ( prot.Group () );
|
|
dwAccessOwnerDir = _get_dir_access_mask ( prot.User () );
|
|
dwAccessWorldDir = _get_dir_access_mask ( prot.World () );
|
|
|
|
if ( dwAccessGroup != 0 ) {
|
|
|
|
for ( i = 0; i < ( int )pTkGroups -> GroupCount; ++i ) {
|
|
|
|
pSIDtemp = pTkGroups -> Groups[ i ].Sid;
|
|
|
|
if ( !NtPredefinedSid ( pSIDtemp ) &&
|
|
!EqualSid ( pSIDtemp, pSIDworld ) &&
|
|
!EqualSid ( pSIDtemp, pTkPrimaryGroup -> PrimaryGroup ) &&
|
|
IsValidSid ( pSIDtemp )
|
|
)
|
|
|
|
dwACLsize += ( ( GetLengthSid ( pSIDtemp ) + ACE_HEADER_SIZE ) << j );
|
|
|
|
} // end for
|
|
|
|
} // end if
|
|
|
|
dwACLsize += ( ( ( GetLengthSid ( pSIDowner ) + ACE_HEADER_SIZE ) << j ) +
|
|
( ( GetLengthSid ( pSIDadmin ) + ACE_HEADER_SIZE ) << j ) +
|
|
( ( GetLengthSid ( pSIDworld ) + ACE_HEADER_SIZE ) << j )
|
|
);
|
|
|
|
if ( ( pACL = CreateAcl ( dwACLsize ) ) == NULL ) __leave;
|
|
|
|
if ( dwAccessAdmin != 0 )
|
|
|
|
if ( ( pFileACE = ( PFILE_ACE )AllocAccessAllowedAce (
|
|
dwAccessAdmin, 0,
|
|
pSIDadmin
|
|
)
|
|
) != NULL
|
|
) {
|
|
|
|
AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
|
|
|
|
if ( fDir ) {
|
|
|
|
pFileACE -> dwMask = dwAccessAdminDir;
|
|
pFileACE -> header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
|
|
AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
|
|
|
|
} // end if
|
|
|
|
FreeAce ( pFileACE );
|
|
|
|
} // end if
|
|
|
|
if ( dwAccessOwner != 0 )
|
|
|
|
if ( ( pFileACE = ( PFILE_ACE )AllocAccessAllowedAce (
|
|
dwAccessOwner, 0, pSIDowner
|
|
)
|
|
) != NULL
|
|
) {
|
|
|
|
AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
|
|
|
|
if ( fDir ) {
|
|
|
|
pFileACE -> dwMask = dwAccessOwnerDir;
|
|
pFileACE -> header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
|
|
AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
|
|
|
|
} // end if
|
|
|
|
FreeAce ( pFileACE );
|
|
|
|
} // end if
|
|
|
|
if ( dwAccessWorld != 0 )
|
|
|
|
if ( ( pFileACE = ( PFILE_ACE )AllocAccessAllowedAce (
|
|
dwAccessWorld, 0, pSIDworld
|
|
)
|
|
) != NULL
|
|
) {
|
|
|
|
AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
|
|
|
|
if ( fDir ) {
|
|
|
|
pFileACE -> header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
|
|
AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
|
|
|
|
} // end if
|
|
|
|
FreeAce ( pFileACE );
|
|
|
|
} // end if
|
|
|
|
if ( dwAccessGroup != 0 ) {
|
|
|
|
for ( i = 0; i < ( int )pTkGroups -> GroupCount; ++i ) {
|
|
|
|
pSIDtemp = pTkGroups -> Groups[ i ].Sid;
|
|
|
|
if ( !NtPredefinedSid ( pSIDtemp ) &&
|
|
!EqualSid ( pSIDtemp, pSIDworld ) &&
|
|
!EqualSid ( pSIDtemp, pTkPrimaryGroup -> PrimaryGroup ) &&
|
|
IsValidSid ( pSIDtemp )
|
|
) {
|
|
|
|
if ( dwAccessGroup != 0 )
|
|
|
|
if ( ( pFileACE = ( PFILE_ACE )AllocAccessAllowedAce (
|
|
dwAccessGroup, 0, pSIDtemp
|
|
)
|
|
) != NULL
|
|
) {
|
|
|
|
AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
|
|
|
|
if ( fDir ) {
|
|
|
|
pFileACE -> header.AceFlags = OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
|
|
AddAce ( pACL, ACL_REVISION, dwIndex++, pFileACE, pFileACE -> header.AceSize );
|
|
|
|
} // end if
|
|
|
|
FreeAce ( pFileACE );
|
|
|
|
} // end if
|
|
|
|
} // end if
|
|
|
|
} // end for
|
|
|
|
} // end if
|
|
|
|
if ( ( retVal = AllocSD () ) == NULL ) __leave;
|
|
|
|
if ( !SetSecurityDescriptorDacl ( retVal, TRUE, pACL, TRUE ) ) __leave;
|
|
|
|
fOK = TRUE;
|
|
|
|
} // end __try
|
|
|
|
__finally {
|
|
|
|
if ( !fOK ) {
|
|
|
|
if ( retVal != NULL )
|
|
|
|
FreeSD ( retVal );
|
|
|
|
else if ( pACL != NULL )
|
|
|
|
FreeAcl ( pACL );
|
|
|
|
retVal = NULL;
|
|
|
|
} // end if
|
|
|
|
if ( hProcess != NULL ) CloseHandle ( hProcess );
|
|
if ( pTkOwner != NULL ) FreeTokenInformation ( pTkOwner );
|
|
if ( pTkGroups != NULL ) FreeTokenInformation ( pTkGroups );
|
|
if ( pTkPrimaryGroup != NULL ) FreeTokenInformation ( pTkPrimaryGroup );
|
|
if ( pfSD != NULL ) FreeFileSecurity ( pfSD );
|
|
|
|
} // end __finally
|
|
|
|
#ifdef VAC
|
|
leave: ; // added for VisualAge
|
|
#endif
|
|
|
|
return retVal;
|
|
|
|
} // end _osd_wnt_protection_to_sd */
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#undef __try
|
|
#undef __finally
|
|
#undef __leave
|
|
#endif
|
|
|
|
static void __fastcall _test_raise ( HANDLE hFile, Standard_CString str ) {
|
|
|
|
Standard_Character buff[ 64 ];
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE) {
|
|
|
|
_tcscpy ( buff, TEXT( "OSD_File :: " ) );
|
|
_tcscat ( buff, str );
|
|
_tcscat ( buff, TEXT( " (): wrong access" ) );
|
|
|
|
Standard_ProgramError :: Raise ( buff );
|
|
|
|
} // end if
|
|
|
|
} // end _test_raise
|
|
|
|
// Modified so that we have <nl> at end of line if we have read <nl> or <cr>
|
|
// by LD 17 dec 98 for B4.4
|
|
|
|
static DWORDLONG __fastcall _get_line ( Standard_PCharacter& buffer, DWORD dwBuffSize ) {
|
|
|
|
DWORDLONG retVal;
|
|
Standard_PCharacter ptr;
|
|
|
|
buffer[ dwBuffSize ] = 0;
|
|
ptr = buffer;
|
|
|
|
while ( *ptr != 0 ) {
|
|
|
|
if ( *ptr == TEXT( '\n' ) ) {
|
|
|
|
ptr++ ; // jump newline char.
|
|
*ptr = 0 ;
|
|
retVal = ptr - buffer - dwBuffSize;
|
|
retVal &= 0x0000000FFFFFFFF;// import 32-bit to 64-bit
|
|
#ifdef VAC
|
|
retVal = (DWORDLONG) ( (unsigned __int64) retVal | (((unsigned __int64) ptr) << 32) );
|
|
#else
|
|
retVal |= ( ( ( DWORDLONG )( DWORD )ptr ) << 32 );
|
|
#endif
|
|
return retVal;
|
|
|
|
} else if ( *ptr == TEXT( '\r' ) && ptr[ 1 ] == TEXT( '\n' ) ) {
|
|
|
|
*(ptr++) = '\n' ; // Substitue carriage return by newline.
|
|
*ptr = 0 ;
|
|
retVal = ptr + 1 - buffer - dwBuffSize;
|
|
retVal &= 0x0000000FFFFFFFF;// import 32-bit to 64-bit
|
|
#ifdef VAC
|
|
retVal = (DWORDLONG) ( (unsigned __int64) retVal | (((unsigned __int64) ptr) << 32) );
|
|
#else
|
|
retVal |= ( ( ( DWORDLONG )( DWORD )ptr ) << 32 );
|
|
#endif
|
|
return retVal;
|
|
|
|
} else if ( *ptr == TEXT( '\r' ) && ptr[ 1 ] == 0 ) {
|
|
*ptr = '\n' ; // Substitue carriage return by newline
|
|
|
|
#ifdef VAC
|
|
return (DWORDLONG) (__int64) (-1);
|
|
#else
|
|
return 0xFFFFFFFFFFFFFFFF;
|
|
#endif
|
|
}
|
|
++ptr;
|
|
|
|
} // end while
|
|
|
|
#ifdef VAC
|
|
retVal = (DWORDLONG) ( ( (unsigned __int64) ((DWORD) buffer + dwBuffSize) ) << 32 );
|
|
retVal = (DWORDLONG) ( (unsigned __int64) retVal & (((unsigned __int64) 0xFFFFFFFF) << 32) );
|
|
#else
|
|
retVal = ( ( ( DWORDLONG )( ( DWORD )buffer + dwBuffSize ) ) << 32 );
|
|
retVal &= 0xFFFFFFFF00000000;
|
|
#endif
|
|
|
|
return retVal;
|
|
|
|
} // end _get_line
|
|
|
|
static int __fastcall _get_buffer (
|
|
HANDLE hChannel,
|
|
Standard_PCharacter& buffer,
|
|
DWORD dwSize,
|
|
BOOL fPeek, BOOL fSocket
|
|
) {
|
|
|
|
int retVal = -1;
|
|
int flags;
|
|
DWORD dwDummy;
|
|
DWORD dwBytesRead;
|
|
|
|
if ( fSocket ) {
|
|
|
|
flags = fPeek ? MSG_PEEK : 0;
|
|
|
|
retVal = recv ( ( SOCKET )hChannel, buffer, ( int )dwSize, flags );
|
|
|
|
if ( retVal == SOCKET_ERROR ) retVal = -1;
|
|
|
|
} else {
|
|
|
|
if ( fPeek ) {
|
|
|
|
if ( !PeekNamedPipe (
|
|
hChannel, buffer, dwSize, &dwBytesRead, &dwDummy, &dwDummy
|
|
) && GetLastError () != ERROR_BROKEN_PIPE
|
|
)
|
|
|
|
retVal = -1;
|
|
|
|
else
|
|
|
|
retVal = ( int )dwBytesRead;
|
|
|
|
} else {
|
|
|
|
if ( !ReadFile ( hChannel, buffer, dwSize, &dwBytesRead, NULL ) )
|
|
|
|
retVal = -1;
|
|
|
|
else
|
|
|
|
retVal = ( int )dwBytesRead;
|
|
|
|
} // end else
|
|
|
|
} // end else
|
|
|
|
return retVal;
|
|
|
|
} // end _get_buffer
|
|
|
|
|
|
static DWORD __fastcall _get_access_mask ( OSD_SingleProtection prt ) {
|
|
|
|
DWORD retVal = 0;
|
|
|
|
switch ( prt ) {
|
|
|
|
case OSD_None:
|
|
|
|
retVal = 0;
|
|
|
|
break;
|
|
|
|
case OSD_R:
|
|
|
|
retVal = FILE_GENERIC_READ;
|
|
|
|
break;
|
|
|
|
case OSD_W:
|
|
|
|
retVal = FILE_GENERIC_WRITE;
|
|
|
|
break;
|
|
|
|
case OSD_RW:
|
|
|
|
retVal = FILE_GENERIC_READ | FILE_GENERIC_WRITE;
|
|
|
|
break;
|
|
|
|
case OSD_X:
|
|
|
|
retVal = FILE_GENERIC_EXECUTE;
|
|
|
|
break;
|
|
|
|
case OSD_RX:
|
|
|
|
retVal = FILE_GENERIC_READ | FILE_GENERIC_EXECUTE;
|
|
|
|
break;
|
|
|
|
case OSD_WX:
|
|
|
|
retVal = FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE;
|
|
|
|
break;
|
|
|
|
case OSD_RWX:
|
|
|
|
retVal = FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE;
|
|
|
|
break;
|
|
|
|
case OSD_D:
|
|
|
|
retVal = DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_RD:
|
|
|
|
retVal = FILE_GENERIC_READ | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_WD:
|
|
|
|
retVal = FILE_GENERIC_WRITE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_RWD:
|
|
|
|
retVal = FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_XD:
|
|
|
|
retVal = FILE_GENERIC_EXECUTE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_RXD:
|
|
|
|
retVal = FILE_GENERIC_READ | FILE_GENERIC_EXECUTE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_WXD:
|
|
|
|
retVal = FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_RWXD:
|
|
|
|
retVal = FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
RAISE( TEXT( "_get_access_mask (): incorrect parameter" ) );
|
|
|
|
} // end switch
|
|
|
|
return retVal;
|
|
|
|
} // end _get_access_mask
|
|
|
|
static DWORD __fastcall _get_dir_access_mask ( OSD_SingleProtection prt ) {
|
|
|
|
DWORD retVal = 0;
|
|
|
|
switch ( prt ) {
|
|
|
|
case OSD_None:
|
|
|
|
retVal = 0;
|
|
|
|
break;
|
|
|
|
case OSD_R:
|
|
|
|
retVal = GENERIC_READ;
|
|
|
|
break;
|
|
|
|
case OSD_W:
|
|
|
|
retVal = GENERIC_WRITE;
|
|
|
|
break;
|
|
|
|
case OSD_RW:
|
|
|
|
retVal = GENERIC_READ | GENERIC_WRITE;
|
|
|
|
break;
|
|
|
|
case OSD_X:
|
|
|
|
retVal = GENERIC_EXECUTE;
|
|
|
|
break;
|
|
|
|
case OSD_RX:
|
|
|
|
retVal = GENERIC_READ | GENERIC_EXECUTE;
|
|
|
|
break;
|
|
|
|
case OSD_WX:
|
|
|
|
retVal = GENERIC_WRITE | GENERIC_EXECUTE;
|
|
|
|
break;
|
|
|
|
case OSD_RWX:
|
|
|
|
retVal = GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE;
|
|
|
|
break;
|
|
|
|
case OSD_D:
|
|
|
|
retVal = DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_RD:
|
|
|
|
retVal = GENERIC_READ | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_WD:
|
|
|
|
retVal = GENERIC_WRITE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_RWD:
|
|
|
|
retVal = GENERIC_READ | GENERIC_WRITE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_XD:
|
|
|
|
retVal = GENERIC_EXECUTE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_RXD:
|
|
|
|
retVal = GENERIC_READ | GENERIC_EXECUTE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_WXD:
|
|
|
|
retVal = GENERIC_WRITE | GENERIC_EXECUTE | DELETE;
|
|
|
|
break;
|
|
|
|
case OSD_RWXD:
|
|
|
|
retVal = GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | DELETE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
RAISE( TEXT( "_get_dir_access_mask (): incorrect parameter" ) );
|
|
|
|
} // end switch
|
|
|
|
return retVal;
|
|
|
|
} // end _get_dir_access_mask
|
|
|
|
static HANDLE __fastcall _open_file (
|
|
Standard_CString fName,
|
|
OSD_OpenMode oMode,
|
|
DWORD dwOptions, LPBOOL fNew
|
|
) {
|
|
|
|
HANDLE retVal = INVALID_HANDLE_VALUE;
|
|
DWORD dwDesiredAccess = 0;
|
|
DWORD dwCreationDistribution;
|
|
|
|
switch ( oMode ) {
|
|
|
|
case OSD_ReadOnly:
|
|
|
|
dwDesiredAccess = GENERIC_READ;
|
|
|
|
break;
|
|
|
|
case OSD_WriteOnly:
|
|
|
|
dwDesiredAccess = GENERIC_WRITE;
|
|
|
|
break;
|
|
|
|
case OSD_ReadWrite:
|
|
|
|
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
RAISE( TEXT( "_open_file (): incorrect parameter" ) );
|
|
|
|
} // end switch
|
|
|
|
dwCreationDistribution = ( dwOptions != OPEN_NEW ) ? OPEN_EXISTING : CREATE_ALWAYS;
|
|
|
|
retVal = CreateFile (
|
|
fName, dwDesiredAccess,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, dwCreationDistribution, FILE_ATTRIBUTE_NORMAL, NULL
|
|
);
|
|
|
|
if ( retVal == INVALID_HANDLE_VALUE &&
|
|
dwOptions == OPEN_APPEND &&
|
|
GetLastError () == ERROR_FILE_NOT_FOUND
|
|
) {
|
|
|
|
|
|
dwCreationDistribution = CREATE_ALWAYS;
|
|
|
|
retVal = CreateFile (
|
|
fName, dwDesiredAccess,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, dwCreationDistribution, FILE_ATTRIBUTE_NORMAL, NULL
|
|
);
|
|
|
|
*fNew = TRUE;
|
|
|
|
} // end if
|
|
|
|
return retVal;
|
|
|
|
} // end _open_file
|
|
|
|
Standard_Integer __fastcall _get_file_type (
|
|
Standard_CString fName, HANDLE fileHandle
|
|
) {
|
|
|
|
Standard_Integer retVal = 0;
|
|
DWORD dwType;
|
|
int fileType;
|
|
|
|
fileType = (fileHandle == INVALID_HANDLE_VALUE ?
|
|
FILE_TYPE_DISK : GetFileType (fileHandle));
|
|
|
|
switch ( fileType ) {
|
|
|
|
case FILE_TYPE_UNKNOWN:
|
|
|
|
retVal = FLAG_SOCKET;
|
|
|
|
break;
|
|
|
|
case FILE_TYPE_DISK:
|
|
|
|
if ( ( dwType = GetFileAttributes ( fName ) ) != 0xFFFFFFFF )
|
|
|
|
retVal = dwType & FILE_ATTRIBUTE_DIRECTORY ? FLAG_DIRECTORY : FLAG_FILE;
|
|
|
|
else
|
|
|
|
retVal = 0x80000000;
|
|
|
|
break;
|
|
|
|
case FILE_TYPE_CHAR:
|
|
|
|
retVal = FLAG_DEVICE;
|
|
|
|
break;
|
|
|
|
case FILE_TYPE_PIPE:
|
|
|
|
retVal = FLAG_PIPE;
|
|
|
|
break;
|
|
|
|
} // end switch
|
|
|
|
return retVal;
|
|
|
|
} // end _get_file_type
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#define __try
|
|
#define __finally
|
|
#define __leave return retVal
|
|
#endif
|
|
|
|
BOOL __fastcall _osd_wnt_sd_to_protection (
|
|
PSECURITY_DESCRIPTOR pSD, OSD_Protection& prot, BOOL fDir
|
|
) {
|
|
|
|
int i;
|
|
BOOL fPresent;
|
|
BOOL fDefaulted;
|
|
PACL pACL;
|
|
PSID pSIDowner;
|
|
PSID pSIDadmin;
|
|
PSID pSIDworld;
|
|
LPVOID pACE;
|
|
DWORD dwAccessOwner = 0;
|
|
DWORD dwAccessGroup = 0;
|
|
DWORD dwAccessAdmin = 0;
|
|
DWORD dwAccessWorld = 0;
|
|
BOOL retVal = FALSE;
|
|
GET_PROT_FUNC _get_prot_func = fDir ? &_get_protection_dir : &_get_protection;
|
|
|
|
__try {
|
|
|
|
if ( !GetSecurityDescriptorOwner ( pSD, &pSIDowner, &fDefaulted ) ) __leave;
|
|
|
|
if ( !GetSecurityDescriptorDacl ( pSD, &fPresent, &pACL, &fDefaulted ) ||
|
|
!fPresent
|
|
) __leave;
|
|
|
|
if ( pSIDowner == NULL || pACL == NULL ) {
|
|
|
|
SetLastError ( ERROR_NO_SECURITY_ON_OBJECT );
|
|
__leave;
|
|
|
|
} // end if
|
|
|
|
pSIDadmin = AdminSid ();
|
|
pSIDworld = WorldSid ();
|
|
|
|
for ( i = 0; i < ( int )pACL -> AceCount; ++i ) {
|
|
|
|
if ( GetAce ( pACL, i, &pACE ) ) {
|
|
|
|
if ( EqualSid ( pSIDowner, GET_SID( pACE ) ) )
|
|
|
|
dwAccessOwner = ( ( PACE_HEADER )pACE ) -> AceType == ACCESS_DENIED_ACE_TYPE ?
|
|
0 : *GET_MSK( pACE );
|
|
|
|
else if ( EqualSid ( pSIDadmin, GET_SID( pACE ) ) )
|
|
|
|
dwAccessAdmin = ( ( PACE_HEADER )pACE ) -> AceType == ACCESS_DENIED_ACE_TYPE ?
|
|
0 : *GET_MSK( pACE );
|
|
|
|
else if ( EqualSid ( pSIDworld, GET_SID( pACE ) ) )
|
|
|
|
dwAccessWorld = ( ( PACE_HEADER )pACE ) -> AceType == ACCESS_DENIED_ACE_TYPE ?
|
|
0 : *GET_MSK( pACE );
|
|
|
|
else
|
|
|
|
dwAccessGroup = ( ( PACE_HEADER )pACE ) -> AceType == ACCESS_DENIED_ACE_TYPE ?
|
|
0 : *GET_MSK( pACE );
|
|
|
|
} // end if
|
|
|
|
} // end for
|
|
|
|
prot.SetValues (
|
|
( *_get_prot_func ) ( dwAccessAdmin ),
|
|
( *_get_prot_func ) ( dwAccessOwner ),
|
|
( *_get_prot_func ) ( dwAccessGroup ),
|
|
( *_get_prot_func ) ( dwAccessWorld )
|
|
);
|
|
|
|
retVal = TRUE;
|
|
|
|
} // end __try
|
|
|
|
__finally {}
|
|
|
|
#ifdef VAC
|
|
leave: ; // added for VisualAge
|
|
#endif
|
|
|
|
return retVal;
|
|
|
|
} // end _osd_wnt_sd_to_protection
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#undef __try
|
|
#undef __finally
|
|
#undef __leave
|
|
#endif
|
|
|
|
static OSD_SingleProtection __fastcall _get_protection ( DWORD mask ) {
|
|
|
|
OSD_SingleProtection retVal;
|
|
|
|
switch ( mask ) {
|
|
|
|
case FILE_GENERIC_READ:
|
|
|
|
retVal = OSD_R;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_WRITE:
|
|
|
|
retVal = OSD_W;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_READ | FILE_GENERIC_WRITE:
|
|
|
|
retVal = OSD_RW;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_EXECUTE:
|
|
|
|
retVal = OSD_X;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_READ | FILE_GENERIC_EXECUTE:
|
|
|
|
retVal = OSD_RX;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE:
|
|
|
|
retVal = OSD_WX;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE:
|
|
|
|
retVal = OSD_RWX;
|
|
|
|
break;
|
|
|
|
case DELETE:
|
|
|
|
retVal = OSD_D;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_READ | DELETE:
|
|
|
|
retVal = OSD_RD;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_WRITE | DELETE:
|
|
|
|
retVal = OSD_WD;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE:
|
|
|
|
retVal = OSD_RWD;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_EXECUTE | DELETE:
|
|
|
|
retVal = OSD_XD;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_READ | FILE_GENERIC_EXECUTE | DELETE:
|
|
|
|
retVal = OSD_RXD;
|
|
|
|
break;
|
|
|
|
case FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE:
|
|
|
|
retVal = OSD_WXD;
|
|
|
|
break;
|
|
|
|
case FILE_ALL_ACCESS:
|
|
case FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE:
|
|
|
|
retVal = OSD_RWXD;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
default:
|
|
|
|
retVal = OSD_None;
|
|
|
|
} // end switch
|
|
|
|
return retVal;
|
|
|
|
} // end _get_protection
|
|
|
|
static OSD_SingleProtection __fastcall _get_protection_dir ( DWORD mask ) {
|
|
|
|
OSD_SingleProtection retVal;
|
|
|
|
switch ( mask ) {
|
|
|
|
case GENERIC_READ:
|
|
|
|
retVal = OSD_R;
|
|
|
|
break;
|
|
|
|
case GENERIC_WRITE:
|
|
|
|
retVal = OSD_W;
|
|
|
|
break;
|
|
|
|
case GENERIC_READ | GENERIC_WRITE:
|
|
|
|
retVal = OSD_RW;
|
|
|
|
break;
|
|
|
|
case GENERIC_EXECUTE:
|
|
|
|
retVal = OSD_X;
|
|
|
|
break;
|
|
|
|
case GENERIC_READ | GENERIC_EXECUTE:
|
|
|
|
retVal = OSD_RX;
|
|
|
|
break;
|
|
|
|
case GENERIC_WRITE | GENERIC_EXECUTE:
|
|
|
|
retVal = OSD_WX;
|
|
|
|
break;
|
|
|
|
case GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE:
|
|
|
|
retVal = OSD_RWX;
|
|
|
|
break;
|
|
|
|
case DELETE:
|
|
|
|
retVal = OSD_D;
|
|
|
|
break;
|
|
|
|
case GENERIC_READ | DELETE:
|
|
|
|
retVal = OSD_RD;
|
|
|
|
break;
|
|
|
|
case GENERIC_WRITE | DELETE:
|
|
|
|
retVal = OSD_WD;
|
|
|
|
break;
|
|
|
|
case GENERIC_READ | GENERIC_WRITE | DELETE:
|
|
|
|
retVal = OSD_RWD;
|
|
|
|
break;
|
|
|
|
case GENERIC_EXECUTE | DELETE:
|
|
|
|
retVal = OSD_XD;
|
|
|
|
break;
|
|
|
|
case GENERIC_READ | GENERIC_EXECUTE | DELETE:
|
|
|
|
retVal = OSD_RXD;
|
|
|
|
break;
|
|
|
|
case GENERIC_WRITE | GENERIC_EXECUTE | DELETE:
|
|
|
|
retVal = OSD_WXD;
|
|
|
|
break;
|
|
|
|
case FILE_ALL_ACCESS:
|
|
case GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | DELETE:
|
|
|
|
retVal = OSD_RWXD;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
default:
|
|
|
|
retVal = OSD_None;
|
|
|
|
} // end switch
|
|
|
|
return retVal;
|
|
|
|
} // end _get_protection_dir
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#define __try
|
|
#define __finally
|
|
#define __leave return fOK
|
|
#endif
|
|
|
|
BOOL __fastcall _osd_print (const Standard_PCharacter pName, Standard_CString fName ) {
|
|
|
|
BOOL fOK, fJob;
|
|
HANDLE hPrinter = NULL;
|
|
BYTE jobInfo[ MAX_PATH + sizeof ( DWORD ) ];
|
|
DWORD dwNeeded, dwCode = 0;
|
|
|
|
fOK = fJob = FALSE;
|
|
|
|
__try {
|
|
|
|
if ( !OpenPrinter ( Standard_PCharacter(pName), &hPrinter, NULL ) ) {
|
|
|
|
hPrinter = NULL;
|
|
__leave;
|
|
|
|
} // end if
|
|
|
|
if ( !AddJob (
|
|
hPrinter, 1, jobInfo, MAX_PATH + sizeof ( DWORD ), &dwNeeded
|
|
)
|
|
) __leave;
|
|
|
|
fJob = TRUE;
|
|
|
|
if ( !CopyFile (
|
|
fName, ( ( ADDJOB_INFO_1* )jobInfo ) -> Path, FALSE
|
|
)
|
|
) __leave;
|
|
|
|
if ( !ScheduleJob (
|
|
hPrinter, ( ( ADDJOB_INFO_1* )jobInfo ) -> JobId
|
|
)
|
|
) __leave;
|
|
|
|
fOK = TRUE;
|
|
|
|
} // end __try
|
|
|
|
__finally {
|
|
|
|
if ( !fOK ) {
|
|
|
|
BYTE info[ 1024 ];
|
|
DWORD dwBytesNeeded;
|
|
|
|
dwCode = GetLastError ();
|
|
|
|
if ( fJob && hPrinter != NULL ) {
|
|
|
|
GetJob (
|
|
hPrinter, ( ( ADDJOB_INFO_1* )jobInfo ) -> JobId, 1,
|
|
info, 1024, &dwBytesNeeded
|
|
);
|
|
|
|
if ( fJob ) SetJob (
|
|
hPrinter,
|
|
( ( ADDJOB_INFO_1* )jobInfo ) -> JobId,
|
|
1, info, JOB_CONTROL_CANCEL
|
|
);
|
|
|
|
} // end if
|
|
|
|
} // end if
|
|
|
|
if ( hPrinter != NULL ) ClosePrinter ( hPrinter );
|
|
|
|
} // end __finally
|
|
|
|
#ifdef VAC
|
|
leave: ; // added for VisualAge
|
|
#endif
|
|
|
|
if ( !fOK ) SetLastError ( dwCode );
|
|
|
|
return fOK;
|
|
|
|
} // end _osd_print
|
|
|
|
#if defined(__CYGWIN32__) || defined(__MINGW32__)
|
|
#undef __try
|
|
#undef __finally
|
|
#undef __leave
|
|
#endif
|
|
|
|
Standard_Boolean OSD_File::IsReadable()
|
|
{
|
|
TCollection_AsciiString FileName ;
|
|
HANDLE Channel ;
|
|
|
|
myPath.SystemName(FileName) ;
|
|
Channel = _open_file(FileName.ToCString(), OSD_ReadOnly, OPEN_OLD) ;
|
|
if (Channel == INVALID_HANDLE_VALUE)
|
|
return Standard_False ;
|
|
else {
|
|
CloseHandle (Channel) ;
|
|
return Standard_True ;
|
|
}
|
|
}
|
|
|
|
|
|
Standard_Boolean OSD_File::IsWriteable()
|
|
{
|
|
TCollection_AsciiString FileName ;
|
|
HANDLE Channel ;
|
|
|
|
myPath.SystemName(FileName) ;
|
|
Channel = _open_file(FileName.ToCString(), OSD_ReadWrite, OPEN_OLD) ;
|
|
if (Channel == INVALID_HANDLE_VALUE)
|
|
return Standard_False ;
|
|
else {
|
|
CloseHandle (Channel) ;
|
|
return Standard_True ;
|
|
}
|
|
}
|
|
|
|
Standard_Boolean OSD_File::IsExecutable()
|
|
{
|
|
return IsReadable() ;
|
|
|
|
// if (_access(FileName.ToCString(),0))
|
|
}
|
|
|
|
#endif /* _WIN32 */
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Read lines in a file while it is increasing.
|
|
// Each line is terminated with a <nl>.
|
|
// ---------------------------------------------------------------------
|
|
|
|
#include <OSD.hxx>
|
|
|
|
Standard_Boolean OSD_File::ReadLastLine(TCollection_AsciiString& aLine,const Standard_Integer aDelay,const Standard_Integer aNbTries)
|
|
{
|
|
static Standard_Integer MaxLength = 1000 ;
|
|
Standard_Integer Len ;
|
|
Standard_Integer Count = aNbTries ;
|
|
|
|
if (Count <= 0)
|
|
return Standard_False ;
|
|
for(;;) {
|
|
ReadLine(aLine, MaxLength, Len) ;
|
|
if (!aLine.IsEmpty())
|
|
return Standard_True ;
|
|
if (!--Count)
|
|
return Standard_False ;
|
|
OSD::SecSleep(aDelay) ;
|
|
}
|
|
}
|
|
|
|
|
|
Standard_Boolean OSD_File::Edit()
|
|
{
|
|
cout << "Function OSD_File::Edit() not yet implemented." << endl;
|
|
return Standard_False ;
|
|
}
|
|
|
|
|
|
|
|
|