Mercurial > hg > CbC > CbC_gcc
comparison zlib/contrib/minizip/iowin32.c @ 51:ae3a4bfb450b
add some files of version 4.4.3 that have been forgotten.
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Sun, 07 Feb 2010 18:27:48 +0900 |
parents | |
children | 04ced10e8804 |
comparison
equal
deleted
inserted
replaced
47:3bfb6c00c1e0 | 51:ae3a4bfb450b |
---|---|
1 /* iowin32.c -- IO base function header for compress/uncompress .zip | |
2 files using zlib + zip or unzip API | |
3 This IO API version uses the Win32 API (for Microsoft Windows) | |
4 | |
5 Version 1.01e, February 12th, 2005 | |
6 | |
7 Copyright (C) 1998-2005 Gilles Vollant | |
8 */ | |
9 | |
10 #include <stdlib.h> | |
11 | |
12 #include "zlib.h" | |
13 #include "ioapi.h" | |
14 #include "iowin32.h" | |
15 | |
16 #ifndef INVALID_HANDLE_VALUE | |
17 #define INVALID_HANDLE_VALUE (0xFFFFFFFF) | |
18 #endif | |
19 | |
20 #ifndef INVALID_SET_FILE_POINTER | |
21 #define INVALID_SET_FILE_POINTER ((DWORD)-1) | |
22 #endif | |
23 | |
24 voidpf ZCALLBACK win32_open_file_func OF(( | |
25 voidpf opaque, | |
26 const char* filename, | |
27 int mode)); | |
28 | |
29 uLong ZCALLBACK win32_read_file_func OF(( | |
30 voidpf opaque, | |
31 voidpf stream, | |
32 void* buf, | |
33 uLong size)); | |
34 | |
35 uLong ZCALLBACK win32_write_file_func OF(( | |
36 voidpf opaque, | |
37 voidpf stream, | |
38 const void* buf, | |
39 uLong size)); | |
40 | |
41 long ZCALLBACK win32_tell_file_func OF(( | |
42 voidpf opaque, | |
43 voidpf stream)); | |
44 | |
45 long ZCALLBACK win32_seek_file_func OF(( | |
46 voidpf opaque, | |
47 voidpf stream, | |
48 uLong offset, | |
49 int origin)); | |
50 | |
51 int ZCALLBACK win32_close_file_func OF(( | |
52 voidpf opaque, | |
53 voidpf stream)); | |
54 | |
55 int ZCALLBACK win32_error_file_func OF(( | |
56 voidpf opaque, | |
57 voidpf stream)); | |
58 | |
59 typedef struct | |
60 { | |
61 HANDLE hf; | |
62 int error; | |
63 } WIN32FILE_IOWIN; | |
64 | |
65 voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode) | |
66 voidpf opaque; | |
67 const char* filename; | |
68 int mode; | |
69 { | |
70 const char* mode_fopen = NULL; | |
71 DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; | |
72 HANDLE hFile = 0; | |
73 voidpf ret=NULL; | |
74 | |
75 dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0; | |
76 | |
77 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) | |
78 { | |
79 dwDesiredAccess = GENERIC_READ; | |
80 dwCreationDisposition = OPEN_EXISTING; | |
81 dwShareMode = FILE_SHARE_READ; | |
82 } | |
83 else | |
84 if (mode & ZLIB_FILEFUNC_MODE_EXISTING) | |
85 { | |
86 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; | |
87 dwCreationDisposition = OPEN_EXISTING; | |
88 } | |
89 else | |
90 if (mode & ZLIB_FILEFUNC_MODE_CREATE) | |
91 { | |
92 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; | |
93 dwCreationDisposition = CREATE_ALWAYS; | |
94 } | |
95 | |
96 if ((filename!=NULL) && (dwDesiredAccess != 0)) | |
97 hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, | |
98 dwCreationDisposition, dwFlagsAndAttributes, NULL); | |
99 | |
100 if (hFile == INVALID_HANDLE_VALUE) | |
101 hFile = NULL; | |
102 | |
103 if (hFile != NULL) | |
104 { | |
105 WIN32FILE_IOWIN w32fiow; | |
106 w32fiow.hf = hFile; | |
107 w32fiow.error = 0; | |
108 ret = malloc(sizeof(WIN32FILE_IOWIN)); | |
109 if (ret==NULL) | |
110 CloseHandle(hFile); | |
111 else *((WIN32FILE_IOWIN*)ret) = w32fiow; | |
112 } | |
113 return ret; | |
114 } | |
115 | |
116 | |
117 uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size) | |
118 voidpf opaque; | |
119 voidpf stream; | |
120 void* buf; | |
121 uLong size; | |
122 { | |
123 uLong ret=0; | |
124 HANDLE hFile = NULL; | |
125 if (stream!=NULL) | |
126 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; | |
127 if (hFile != NULL) | |
128 if (!ReadFile(hFile, buf, size, &ret, NULL)) | |
129 { | |
130 DWORD dwErr = GetLastError(); | |
131 if (dwErr == ERROR_HANDLE_EOF) | |
132 dwErr = 0; | |
133 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; | |
134 } | |
135 | |
136 return ret; | |
137 } | |
138 | |
139 | |
140 uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size) | |
141 voidpf opaque; | |
142 voidpf stream; | |
143 const void* buf; | |
144 uLong size; | |
145 { | |
146 uLong ret=0; | |
147 HANDLE hFile = NULL; | |
148 if (stream!=NULL) | |
149 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; | |
150 | |
151 if (hFile !=NULL) | |
152 if (!WriteFile(hFile, buf, size, &ret, NULL)) | |
153 { | |
154 DWORD dwErr = GetLastError(); | |
155 if (dwErr == ERROR_HANDLE_EOF) | |
156 dwErr = 0; | |
157 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; | |
158 } | |
159 | |
160 return ret; | |
161 } | |
162 | |
163 long ZCALLBACK win32_tell_file_func (opaque, stream) | |
164 voidpf opaque; | |
165 voidpf stream; | |
166 { | |
167 long ret=-1; | |
168 HANDLE hFile = NULL; | |
169 if (stream!=NULL) | |
170 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; | |
171 if (hFile != NULL) | |
172 { | |
173 DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); | |
174 if (dwSet == INVALID_SET_FILE_POINTER) | |
175 { | |
176 DWORD dwErr = GetLastError(); | |
177 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; | |
178 ret = -1; | |
179 } | |
180 else | |
181 ret=(long)dwSet; | |
182 } | |
183 return ret; | |
184 } | |
185 | |
186 long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin) | |
187 voidpf opaque; | |
188 voidpf stream; | |
189 uLong offset; | |
190 int origin; | |
191 { | |
192 DWORD dwMoveMethod=0xFFFFFFFF; | |
193 HANDLE hFile = NULL; | |
194 | |
195 long ret=-1; | |
196 if (stream!=NULL) | |
197 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; | |
198 switch (origin) | |
199 { | |
200 case ZLIB_FILEFUNC_SEEK_CUR : | |
201 dwMoveMethod = FILE_CURRENT; | |
202 break; | |
203 case ZLIB_FILEFUNC_SEEK_END : | |
204 dwMoveMethod = FILE_END; | |
205 break; | |
206 case ZLIB_FILEFUNC_SEEK_SET : | |
207 dwMoveMethod = FILE_BEGIN; | |
208 break; | |
209 default: return -1; | |
210 } | |
211 | |
212 if (hFile != NULL) | |
213 { | |
214 DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); | |
215 if (dwSet == INVALID_SET_FILE_POINTER) | |
216 { | |
217 DWORD dwErr = GetLastError(); | |
218 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; | |
219 ret = -1; | |
220 } | |
221 else | |
222 ret=0; | |
223 } | |
224 return ret; | |
225 } | |
226 | |
227 int ZCALLBACK win32_close_file_func (opaque, stream) | |
228 voidpf opaque; | |
229 voidpf stream; | |
230 { | |
231 int ret=-1; | |
232 | |
233 if (stream!=NULL) | |
234 { | |
235 HANDLE hFile; | |
236 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; | |
237 if (hFile != NULL) | |
238 { | |
239 CloseHandle(hFile); | |
240 ret=0; | |
241 } | |
242 free(stream); | |
243 } | |
244 return ret; | |
245 } | |
246 | |
247 int ZCALLBACK win32_error_file_func (opaque, stream) | |
248 voidpf opaque; | |
249 voidpf stream; | |
250 { | |
251 int ret=-1; | |
252 if (stream!=NULL) | |
253 { | |
254 ret = ((WIN32FILE_IOWIN*)stream) -> error; | |
255 } | |
256 return ret; | |
257 } | |
258 | |
259 void fill_win32_filefunc (pzlib_filefunc_def) | |
260 zlib_filefunc_def* pzlib_filefunc_def; | |
261 { | |
262 pzlib_filefunc_def->zopen_file = win32_open_file_func; | |
263 pzlib_filefunc_def->zread_file = win32_read_file_func; | |
264 pzlib_filefunc_def->zwrite_file = win32_write_file_func; | |
265 pzlib_filefunc_def->ztell_file = win32_tell_file_func; | |
266 pzlib_filefunc_def->zseek_file = win32_seek_file_func; | |
267 pzlib_filefunc_def->zclose_file = win32_close_file_func; | |
268 pzlib_filefunc_def->zerror_file = win32_error_file_func; | |
269 pzlib_filefunc_def->opaque=NULL; | |
270 } |