static int hb_zipStoreFile( zipFile hZip, int iParamFileName, int iParamZipName, const char * szPassword, int iParamComment, HB_BOOL fUnicode )
{
const char * szFileName = hb_parc( iParamFileName );
const char * szName = hb_parc( iParamZipName );
char * pString;
HB_FHANDLE hFile;
HB_SIZE nLen;
HB_FATTR ulExtAttr;
zip_fileinfo zfi;
int iResult;
HB_BOOL fError;
HB_BOOL fText;
HB_U32 ulCRC;
uLong flags = 0;
void * hZipName = NULL;
void * hComment = NULL;
char * szZipName;
const char * szComment;
memset( &zfi, 0, sizeof( zfi ) );
fError = HB_FALSE;
ulExtAttr = 0;
#if defined( HB_OS_WIN )
{
LPTSTR lpFileNameFree;
LPCTSTR lpFileName = HB_FSNAMECONV( szFileName, &lpFileNameFree );
DWORD attr = GetFileAttributes( lpFileName );
if( attr != INVALID_FILE_ATTRIBUTES )
{
ulExtAttr = hb_translateExtAttr( szFileName, attr &
( FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY |
FILE_ATTRIBUTE_ARCHIVE ) );
}
else
fError = HB_TRUE;
if( lpFileNameFree )
hb_xfree( lpFileNameFree );
}
#elif defined( HB_OS_UNIX )
{
struct stat statbuf;
struct tm st;
time_t ftime;
char * pszFree;
if( stat( hb_fsNameConv( szFileName, &pszFree ), &statbuf ) == 0 )
{
if( S_ISDIR( statbuf.st_mode ) )
{
ulExtAttr |= 0x40000000;
ulExtAttr |= 0x10; /* FILE_ATTRIBUTE_DIRECTORY */
}
else
{
ulExtAttr |= 0x80000000;
ulExtAttr |= 0x20; /* FILE_ATTRIBUTE_ARCHIVE */
}
ulExtAttr |= ( ( statbuf.st_mode & S_IXOTH ) ? 0x00010000 : 0 ) |
( ( statbuf.st_mode & S_IWOTH ) ? 0x00020000 : 0 ) |
( ( statbuf.st_mode & S_IROTH ) ? 0x00040000 : 0 ) |
( ( statbuf.st_mode & S_IXGRP ) ? 0x00080000 : 0 ) |
( ( statbuf.st_mode & S_IWGRP ) ? 0x00100000 : 0 ) |
( ( statbuf.st_mode & S_IRGRP ) ? 0x00200000 : 0 ) |
( ( statbuf.st_mode & S_IXUSR ) ? 0x00400000 : 0 ) |
( ( statbuf.st_mode & S_IWUSR ) ? 0x00800000 : 0 ) |
( ( statbuf.st_mode & S_IRUSR ) ? 0x01000000 : 0 );
ftime = statbuf.st_mtime;
# if defined( HB_HAS_LOCALTIME_R )
localtime_r( &ftime, &st );
# else
st = *localtime( &ftime );
# endif
zfi.tmz_date.tm_sec = st.tm_sec;
zfi.tmz_date.tm_min = st.tm_min;
zfi.tmz_date.tm_hour = st.tm_hour;
zfi.tmz_date.tm_mday = st.tm_mday;
zfi.tmz_date.tm_mon = st.tm_mon;
zfi.tmz_date.tm_year = st.tm_year;
}
else
fError = HB_TRUE;
if( pszFree )
hb_xfree( pszFree );
}
#elif defined( HB_OS_DOS )
{
# if defined( __DJGPP__ ) || defined( __RSX32__ ) || defined( __GNUC__ )
int attr;
char * pszFree;
attr = _chmod( hb_fsNameConv( szFileName, &pszFree ), 0, 0 );
if( pszFree )
hb_xfree( pszFree );
if( attr != -1 )
# else
HB_FATTR attr;
if( hb_fsGetAttr( szFileName, &attr ) )
# endif
{
ulExtAttr = attr & ( HB_FA_READONLY | HB_FA_HIDDEN | HB_FA_SYSTEM |
HB_FA_DIRECTORY | HB_FA_ARCHIVE );
ulExtAttr = hb_translateExtAttr( szFileName, ulExtAttr );
}
else
fError = HB_TRUE;
}
#elif defined( HB_OS_OS2 )
{
FILESTATUS3 fs3;
APIRET ulrc;
HB_FATTR ulAttr;
char * pszFree;
ulrc = DosQueryPathInfo( ( PCSZ ) hb_fsNameConv( szFileName, &pszFree ), FIL_STANDARD, &fs3, sizeof( fs3 ) );
if( pszFree )
hb_xfree( pszFree );
if( ulrc == NO_ERROR )
{
ulAttr = 0;
if( fs3.attrFile & FILE_READONLY )
ulAttr |= HB_FA_READONLY;
if( fs3.attrFile & FILE_HIDDEN )
ulAttr |= HB_FA_HIDDEN;
if( fs3.attrFile & FILE_SYSTEM )
ulAttr |= HB_FA_SYSTEM;
if( fs3.attrFile & FILE_DIRECTORY )
ulAttr |= HB_FA_DIRECTORY;
if( fs3.attrFile & FILE_ARCHIVED )
ulAttr |= HB_FA_ARCHIVE;
ulExtAttr = hb_translateExtAttr( szFileName, ulAttr );
zfi.tmz_date.tm_sec = fs3.ftimeLastWrite.twosecs * 2;
zfi.tmz_date.tm_min = fs3.ftimeLastWrite.minutes;
zfi.tmz_date.tm_hour = fs3.ftimeLastWrite.hours;
zfi.tmz_date.tm_mday = fs3.fdateLastWrite.day;
zfi.tmz_date.tm_mon = fs3.fdateLastWrite.month;
zfi.tmz_date.tm_year = fs3.fdateLastWrite.year + 1980;
}
else
fError = HB_TRUE;
}
#else
{
HB_FATTR attr;
if( ! hb_fsGetAttr( szFileName, &attr ) )
ulExtAttr = 0x81B60020; /* FILE_ATTRIBUTE_ARCHIVE | rw-rw-rw- */
else
{
ulExtAttr = attr & ( HB_FA_READONLY | HB_FA_HIDDEN | HB_FA_SYSTEM |
HB_FA_DIRECTORY | HB_FA_ARCHIVE );
ulExtAttr = hb_translateExtAttr( szFileName, ulExtAttr );
}
}
#endif
if( fError )
return -200;
if( ! HB_ISCHAR( iParamZipName ) )
iParamZipName = iParamFileName;
if( fUnicode )
{
szZipName = hb_strdup( hb_parstr_utf8( iParamZipName, &hZipName, NULL ) );
szComment = hb_parstr_utf8( iParamComment, &hComment, NULL );
flags |= _ZIP_FLAG_UNICODE;
}
else
{
szZipName = hb_strdup( hb_parc( iParamZipName ) );
szComment = hb_parc( iParamComment );
}
if( szName )
{
/* change path separators to '/' */
nLen = strlen( szZipName );
pString = szZipName;
while( nLen-- )
{
if( pString[ nLen ] == '\\' )
pString[ nLen ] = '/';
}
}
else
{
/* get file name */
szZipName = hb_strdup( szFileName );
nLen = strlen( szZipName );
pString = szZipName;
while( nLen-- )
{
if( pString[ nLen ] == '/' || pString[ nLen ] == '\\' )
{
memmove( szZipName, &pString[ nLen + 1 ], strlen( szZipName ) - nLen );
break;
}
}
}
fText = HB_FALSE;
ulCRC = 0;
zfi.external_fa = ulExtAttr;
/* TODO: zip.exe test: 0 for binary file, 1 for text. Does not depend on
extension. We should analyse content of file to determine this??? */
zfi.internal_fa = 0;
if( ulExtAttr & 0x40000000 )
{
iResult = zipOpenNewFileInZip4( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
szPassword, ulCRC, _version_made_by( fUnicode ), flags );
if( iResult == 0 )
zipCloseFileInZip( hZip );
}
else
{
hFile = hb_fsOpen( szFileName, FO_READ );
if( hFile != FS_ERROR )
{
#if defined( HB_OS_WIN )
{
FILETIME ftutc, ft;
SYSTEMTIME st;
if( GetFileTime( ( HANDLE ) hb_fsGetOsHandle( hFile ), NULL, NULL, &ftutc ) &&
FileTimeToLocalFileTime( &ftutc, &ft ) &&
FileTimeToSystemTime( &ft, &st ) )
{
zfi.tmz_date.tm_sec = st.wSecond;
zfi.tmz_date.tm_min = st.wMinute;
zfi.tmz_date.tm_hour = st.wHour;
zfi.tmz_date.tm_mday = st.wDay;
zfi.tmz_date.tm_mon = st.wMonth - 1;
zfi.tmz_date.tm_year = st.wYear;
}
}
#endif
if( szPassword )
{
if( hb_zipGetFileInfo( szFileName, &ulCRC, &fText ) )
zfi.internal_fa = fText ? 1 : 0;
}
iResult = zipOpenNewFileInZip4( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
szPassword, ulCRC, _version_made_by( fUnicode ), flags );
if( iResult == 0 )
{
pString = ( char * ) hb_xgrab( HB_Z_IOBUF_SIZE );
while( ( nLen = hb_fsReadLarge( hFile, pString, HB_Z_IOBUF_SIZE ) ) > 0 )
zipWriteInFileInZip( hZip, pString, ( unsigned ) nLen );
hb_xfree( pString );
zipCloseFileInZip( hZip );
}
hb_fsClose( hFile );
}
else
iResult = -200 - hb_fsError();
}
hb_xfree( szZipName );
if( fUnicode )
{
hb_strfree( hZipName );
hb_strfree( hComment );
}
return iResult;
}
HB_BOOL hb_printerIsReady( const char * pszPrinterName )
{
HB_BOOL bIsPrinter;
#if defined( HB_OS_DOS )
/* NOTE: MS-DOS specific solution, using BIOS interrupt */
{
int iPort;
if( pszPrinterName == NULL )
pszPrinterName = "LPT1";
if( hb_strnicmp( pszPrinterName, "PRN", 3 ) == 0 )
{
union REGS regs;
regs.h.ah = 2;
regs.HB_XREGS.dx = 0; /* LPT1 */
HB_DOS_INT86( 0x17, ®s, ®s );
bIsPrinter = ( regs.h.ah == 0x90 );
}
else if( strlen( pszPrinterName ) >= 4 &&
hb_strnicmp( pszPrinterName, "LPT", 3 ) == 0 &&
( iPort = atoi( pszPrinterName + 3 ) ) > 0 )
{
union REGS regs;
regs.h.ah = 2;
regs.HB_XREGS.dx = iPort - 1;
HB_DOS_INT86( 0x17, ®s, ®s );
bIsPrinter = ( regs.h.ah == 0x90 );
}
else
bIsPrinter = HB_FALSE;
}
#else
/* NOTE: Platform independent method, at least it will compile and run
on any platform, but the result may not be the expected one,
since Unix/Linux doesn't support LPT/COM by nature, other OSs
may not reflect the actual physical presence of the printer when
trying to open it, since we are talking to the spooler.
[vszakats] */
{
HB_FHANDLE fhnd;
if( pszPrinterName == NULL )
#if defined( HB_OS_UNIX )
pszPrinterName = "/dev/lp0";
#else
pszPrinterName = "LPT1";
#endif
fhnd = hb_fsOpen( pszPrinterName, FO_WRITE | FO_SHARED | FO_PRIVATE );
bIsPrinter = ( fhnd != FS_ERROR );
hb_fsClose( fhnd );
}
#endif
return bIsPrinter;
}
HB_FOFFSET hb_fsFSize( const char * pszFileName, HB_BOOL bUseDirEntry )
{
if( bUseDirEntry )
{
#if defined( HB_OS_WIN )
typedef BOOL ( WINAPI * _HB_GETFILEATTRIBUTESEX )( LPCTSTR, GET_FILEEX_INFO_LEVELS, LPVOID );
static _HB_GETFILEATTRIBUTESEX s_pGetFileAttributesEx = ( _HB_GETFILEATTRIBUTESEX ) -1;
if( s_pGetFileAttributesEx == ( _HB_GETFILEATTRIBUTESEX ) -1 )
{
HMODULE hModule = GetModuleHandle( TEXT( "kernel32.dll" ) );
if( hModule )
s_pGetFileAttributesEx = ( _HB_GETFILEATTRIBUTESEX )
HB_WINAPI_GETPROCADDRESST( hModule, "GetFileAttributesEx" );
else
s_pGetFileAttributesEx = NULL;
}
if( s_pGetFileAttributesEx )
{
LPCTSTR lpFileName;
LPTSTR lpFree;
WIN32_FILE_ATTRIBUTE_DATA attrex;
HB_BOOL fResult;
lpFileName = HB_FSNAMECONV( pszFileName, &lpFree );
memset( &attrex, 0, sizeof( attrex ) );
fResult = s_pGetFileAttributesEx( lpFileName, GetFileExInfoStandard, &attrex ) &&
( attrex.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) == 0;
hb_fsSetIOError( fResult, 0 );
if( lpFree )
hb_xfree( lpFree );
if( fResult )
return ( HB_FOFFSET ) attrex.nFileSizeLow +
( ( HB_FOFFSET ) attrex.nFileSizeHigh << 32 );
}
else
{
PHB_FFIND ffind = hb_fsFindFirst( pszFileName, HB_FA_ALL );
hb_fsSetIOError( ffind != NULL, 0 );
if( ffind )
{
HB_FOFFSET size = ffind->size;
hb_fsFindClose( ffind );
return size;
}
}
#elif defined( HB_USE_LARGEFILE64 )
char * pszFree;
HB_BOOL fResult;
struct stat64 statbuf;
pszFileName = hb_fsNameConv( pszFileName, &pszFree );
statbuf.st_size = 0;
hb_vmUnlock();
fResult = stat64( pszFileName, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( pszFree )
hb_xfree( pszFree );
if( fResult )
return ( HB_FOFFSET ) statbuf.st_size;
#else
char * pszFree;
HB_BOOL fResult;
struct stat statbuf;
pszFileName = hb_fsNameConv( pszFileName, &pszFree );
statbuf.st_size = 0;
hb_vmUnlock();
fResult = stat( ( char * ) pszFileName, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( pszFree )
hb_xfree( pszFree );
if( fResult )
return ( HB_FOFFSET ) statbuf.st_size;
#endif
}
else
{
HB_FHANDLE hFileHandle = hb_fsOpen( pszFileName, FO_READ | FO_COMPAT );
if( hFileHandle != FS_ERROR )
{
HB_FOFFSET nPos = hb_fsSeekLarge( hFileHandle, 0, FS_END );
hb_fsClose( hFileHandle );
return nPos;
}
}
return 0;
}
