1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
////////////////////////////////////////////////////////////////////////////////
// This source file is part of the ZipArchive Library Open Source distribution
// and is Copyrighted 2000 - 2022 by Artpol Software - Tadeusz Dracz
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// For the licensing details refer to the License.txt file.
//
// Web Site: https://www.artpol-software.com
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#if (defined _ZIP_IMPL_STL && (!defined _ZIP_FILE_IMPLEMENTATION || _ZIP_FILE_IMPLEMENTATION == ZIP_ZFI_DEFAULT)) || _ZIP_FILE_IMPLEMENTATION == ZIP_ZFI_STL
#if defined __APPLE__ || defined __CYGWIN__
#define FILE_FUNCTIONS_64B_BY_DEFAULT
#else
#undef FILE_FUNCTIONS_64B_BY_DEFAULT
#endif
#include "ZipFile.h"
#include "ZipException.h"
#include "ZipPlatform.h"
#include "BitFlag.h"
#include <fcntl.h>
CZipFile::CZipFile(LPCTSTR lpszFileName, UINT openFlags)
{
m_hFile = -1;
Open(lpszFileName, openFlags, true);
}
CZipFile::CZipFile()
{
m_hFile = -1;
}
void CZipFile::ThrowError() const
{
CZipException::Throw(errno, m_szFileName);
}
ZIP_FILE_USIZE CZipFile::GetLength() const
{
// cannot use Seek here, Seek is not const
ZIP_SIZE_TYPE lLen, lCur;
#ifdef FILE_FUNCTIONS_64B_BY_DEFAULT
lCur = (ZIP_SIZE_TYPE)_lseek(m_hFile, 0, current);
#else
lCur = (ZIP_SIZE_TYPE)_lseeki64(m_hFile, 0, current);
#endif
if (lCur == (ZIP_SIZE_TYPE)-1)
ThrowError();
#ifdef FILE_FUNCTIONS_64B_BY_DEFAULT
lLen = (ZIP_SIZE_TYPE)_lseek(m_hFile, 0, end);
#else
lLen = (ZIP_SIZE_TYPE)_lseeki64(m_hFile, 0, end);
#endif
// first go back
#ifdef FILE_FUNCTIONS_64B_BY_DEFAULT
bool err = _lseek(m_hFile, lCur, begin) == -1;
#else
bool err = _lseeki64(m_hFile, lCur, begin) == -1;
#endif
if (err || lLen == (ZIP_SIZE_TYPE)-1)
ThrowError();
return lLen;
}
bool CZipFile::Open(LPCTSTR lpszFileName, UINT openFlags, bool bThrow)
{
if (!IsClosed())
Close();
#ifdef O_BINARY
UINT iNewFlags = O_BINARY;
#else
UINT iNewFlags = 0;
#endif
bool bReadOnly = false;
DWORD temp = openFlags & 3;
if (temp == modeWrite)
{
iNewFlags |= O_WRONLY;
}
else if (temp == modeReadWrite)
{
iNewFlags |= O_RDWR;
}
else
{
// O_RDONLY is defined as 0
bReadOnly = true;
iNewFlags |= O_RDONLY;
}
if (openFlags & modeCreate)
iNewFlags |= O_CREAT;
if (!(openFlags & modeNoTruncate) && !bReadOnly)
iNewFlags |= O_TRUNC;
m_hFile = ZipPlatform::OpenFile(lpszFileName, iNewFlags, openFlags & 0x70);
if (m_hFile == -1)
{
if (bThrow)
CZipException::Throw(errno, lpszFileName);
else
return false;
}
m_szFileName = lpszFileName;
return true;
}
void CZipFile::SetLength(ULONGLONG uNewLen)
{
if (!ZipPlatform::TruncateFile(m_hFile, uNewLen))
{
ThrowError();
}
}
ZIP_FILE_USIZE CZipFile::GetPosition() const
{
#ifdef FILE_FUNCTIONS_64B_BY_DEFAULT
#ifndef __GNUC__
ZIP_FILE_USIZE ret = _tell(m_hFile);
#else
ZIP_FILE_USIZE ret = lseek(m_hFile, 0, SEEK_CUR);
#endif
#else
#ifndef __GNUC__
ZIP_FILE_USIZE ret = (ZIP_FILE_USIZE)_telli64(m_hFile);
#else
ZIP_FILE_USIZE ret = (ZIP_FILE_USIZE)lseek64(m_hFile, 0, SEEK_CUR);
#endif
#endif
if (ret == (ZIP_FILE_USIZE)-1)
ThrowError();
return ret;
}
ZIP_FILE_USIZE CZipFile::Seek(ZIP_FILE_SIZE dOff, int nFrom)
{
// restricted to signed
#ifdef FILE_FUNCTIONS_64B_BY_DEFAULT
ZIP_FILE_USIZE ret = (ZIP_FILE_USIZE)_lseek(m_hFile, dOff, nFrom);
#else
ZIP_FILE_USIZE ret = (ZIP_FILE_USIZE)_lseeki64(m_hFile, dOff, nFrom);
#endif
if (ret == (ZIP_FILE_USIZE)-1)
ThrowError();
return (ZIP_FILE_USIZE)ret;
}
void CZipFile::Close()
{
if (IsClosed())
return;
if (_close(m_hFile) != 0)
ThrowError();
else
{
m_szFileName.Empty();
m_hFile = -1;
}
}
void CZipFile::Flush()
{
if (!ZipPlatform::FlushFile(m_hFile))
ThrowError();
}
CZipFile::operator HANDLE()
{
intptr_t fh = ZipPlatform::GetFileSystemHandle(m_hFile);
if (fh == -1)
ThrowError();
return (HANDLE)fh;
}
void CZipFile::Write(const void* lpBuf, size_t nCount)
{
if (nCount == 0)
{
return;
}
#ifdef _MSC_VER
if (_write(m_hFile, lpBuf, (unsigned int)nCount) != (int) nCount)
#else
if (_write(m_hFile, lpBuf, nCount) != (int)nCount)
#endif
ThrowError();
}
size_t CZipFile::Read(void *lpBuf, size_t nCount)
{
if (nCount == 0)
{
return 0;
}
errno = 0;
#ifdef _MSC_VER
int ret = (int)_read(m_hFile, lpBuf, (unsigned int)nCount);
#else
int ret = (int)_read(m_hFile, lpBuf, nCount);
#endif
if (ret < (int) nCount && errno != 0)
ThrowError();
return ret;
}
#endif
|
