source: trunk/dll/wrappers.c@ 1372

Last change on this file since 1372 was 1358, checked in by Gregg Young, 17 years ago

Comments for CS 1354/55
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.4 KB
Line 
1
2/***********************************************************************
3
4 $Id: wrappers.c 1358 2008-12-27 00:03:08Z gyoung $
5
6 Wrappers with error checking
7
8 Copyright (c) 2006, 2008 Steven H.Levine
9
10 22 Jul 06 SHL Baseline
11 29 Jul 06 SHL Add xgets_stripped
12 18 Aug 06 SHL Correct Runtime_Error line number report
13 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
14 01 Sep 07 GKY Add xDosSetPathInfo to fix case where FS3 buffer crosses 64k boundry
15 06 Oct 07 SHL Add xDos...() wrappers to support systems wo/large file support (Gregg, Steven)
16 05 May 08 SHL Add FORTIFY support
17 25 Dec 08 GKY Add code to allow write verify to be turned off on a per drive basis
18
19***********************************************************************/
20
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24#include <ctype.h>
25
26#define INCL_WIN
27#define INCL_DOS
28#define INCL_DOSERRORS
29#define INCL_LONGLONG
30#include <os2.h>
31
32#include "fm3dll.h"
33#include "init.h" // Data declaration(s)
34#include "wrappers.h"
35#include "fm3str.h"
36#include "errutil.h" // Dos_Error...
37#include "strutil.h" // GetPString
38#include "command.h"
39#include "tools.h"
40#include "avl.h"
41#include "strips.h" // bstrip
42
43#include "fortify.h" // GetPString
44#include "info.h" // driveflags
45#include "notebook.h" // fVerify
46
47// Data definitions
48static PSZ pszSrcFile = __FILE__;
49
50#pragma data_seg(GLOBAL1)
51BOOL fNoLargeFileSupport;
52
53APIRET xDosFindFirst(PSZ pszFileSpec,
54 PHDIR phdir,
55 ULONG flAttribute,
56 PVOID pfindbuf,
57 ULONG cbBuf,
58 PULONG pcFileNames,
59 ULONG ulInfoLevel)
60{
61 APIRET rc;
62 if (fNoLargeFileSupport) {
63 switch (ulInfoLevel) {
64 case FIL_STANDARDL:
65 {
66 FILEFINDBUF3 ffb3;
67 ulInfoLevel = FIL_STANDARD;
68 *pcFileNames = 1; // fixme to support larger counts
69 rc = DosFindFirst(pszFileSpec, phdir, flAttribute, &ffb3, sizeof(ffb3),
70 pcFileNames, ulInfoLevel);
71 if (!rc) {
72 *(PFILEFINDBUF3)pfindbuf = ffb3; // Copy aligned data
73 ((PFILEFINDBUF3L)pfindbuf)->cbFile = ffb3.cbFile; // Copy unaligned data
74 ((PFILEFINDBUF3L)pfindbuf)->cbFileAlloc = ffb3.cbFileAlloc;
75 ((PFILEFINDBUF3L)pfindbuf)->attrFile = ffb3.attrFile;
76 ((PFILEFINDBUF3L)pfindbuf)->cchName = ffb3.cchName;
77 memcpy(((PFILEFINDBUF3L)pfindbuf)->achName, ffb3.achName, ffb3.cchName + 1);
78 }
79 }
80 break;
81 case FIL_QUERYEASIZEL:
82 {
83 FILEFINDBUF4 ffb4;
84 *pcFileNames = 1; // fixme to support larger counts
85 ulInfoLevel = FIL_QUERYEASIZE;
86 rc = DosFindFirst(pszFileSpec, phdir, flAttribute, &ffb4, sizeof(ffb4),
87 pcFileNames, ulInfoLevel);
88 if (!rc) {
89 *(PFILEFINDBUF4)pfindbuf = ffb4; // Copy aligned data
90 ((PFILEFINDBUF4L)pfindbuf)->cbFile = ffb4.cbFile; // Copy unaligned data
91 ((PFILEFINDBUF4L)pfindbuf)->cbFileAlloc = ffb4.cbFileAlloc;
92 ((PFILEFINDBUF4L)pfindbuf)->attrFile = ffb4.attrFile;
93 ((PFILEFINDBUF4L)pfindbuf)->cbList = ffb4.cbList;
94 ((PFILEFINDBUF4L)pfindbuf)->cchName = ffb4.cchName;
95 memcpy(((PFILEFINDBUF4L)pfindbuf)->achName, ffb4.achName, ffb4.cchName + 1);
96 }
97 }
98 break;
99 default:
100 Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
101 rc = ERROR_INVALID_PARAMETER;
102 } // switch
103 }
104 else
105 rc = DosFindFirst(pszFileSpec, phdir, flAttribute, pfindbuf, cbBuf,
106 pcFileNames, ulInfoLevel);
107 return rc;
108}
109
110APIRET xDosFindNext(HDIR hDir,
111 PVOID pfindbuf,
112 ULONG cbfindbuf,
113 PULONG pcFileNames,
114 ULONG ulInfoLevel)
115{
116 APIRET rc;
117 if (fNoLargeFileSupport) {
118 switch (ulInfoLevel) {
119 case FIL_STANDARDL:
120 {
121 FILEFINDBUF3 ffb3;
122 *pcFileNames = 1; // fixme to support larger counts
123 rc = DosFindNext(hDir, &ffb3, sizeof(ffb3), pcFileNames);
124 if (!rc) {
125 *(PFILEFINDBUF3)pfindbuf = ffb3; // Copy aligned data
126 ((PFILEFINDBUF3L)pfindbuf)->cbFile = ffb3.cbFile; // Copy unaligned data
127 ((PFILEFINDBUF3L)pfindbuf)->cbFileAlloc = ffb3.cbFileAlloc;
128 ((PFILEFINDBUF3L)pfindbuf)->attrFile = ffb3.attrFile;
129 ((PFILEFINDBUF3L)pfindbuf)->cchName = ffb3.cchName;
130 memcpy(((PFILEFINDBUF3L)pfindbuf)->achName, ffb3.achName, ffb3.cchName + 1);
131 }
132 }
133 break;
134 case FIL_QUERYEASIZEL:
135 {
136 FILEFINDBUF4 ffb4;
137 *pcFileNames = 1; // fixme to support larger counts
138 rc = DosFindNext(hDir, &ffb4, sizeof(ffb4), pcFileNames);
139 if (!rc) {
140 *(PFILEFINDBUF4)pfindbuf = ffb4; // Copy aligned data
141 ((PFILEFINDBUF4L)pfindbuf)->cbFile = ffb4.cbFile; // Copy unaligned data
142 ((PFILEFINDBUF4L)pfindbuf)->cbFileAlloc = ffb4.cbFileAlloc;
143 ((PFILEFINDBUF4L)pfindbuf)->attrFile = ffb4.attrFile;
144 ((PFILEFINDBUF4L)pfindbuf)->cbList = ffb4.cbList;
145 ((PFILEFINDBUF4L)pfindbuf)->cchName = ffb4.cchName;
146 memcpy(((PFILEFINDBUF4L)pfindbuf)->achName, ffb4.achName, ffb4.cchName + 1);
147 }
148 }
149 break;
150 default:
151 Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
152 rc = ERROR_INVALID_PARAMETER;
153 } // switch
154 }
155 else
156 rc = DosFindNext(hDir, pfindbuf, cbfindbuf, pcFileNames);
157
158 return rc;
159}
160
161/**
162 * DosQueryPathInfo wrapper
163 * Translate request for systems without large file support
164 */
165
166APIRET xDosQueryPathInfo (PSZ pszPathName, ULONG ulInfoLevel, PVOID pInfoBuf, ULONG cbInfoBuf)
167{
168 FILESTATUS3 fs3;
169 FILESTATUS4 fs4;
170 APIRET rc;
171
172 if (fNoLargeFileSupport) {
173 switch (ulInfoLevel) {
174 case FIL_STANDARDL:
175 rc = DosQueryPathInfo(pszPathName, ulInfoLevel, &fs3, sizeof(fs3));
176 if (!rc) {
177 *(PFILESTATUS3)pInfoBuf = fs3; // Copy aligned data
178 ((PFILESTATUS3L)pInfoBuf)->cbFile = fs3.cbFile; // Copy unaligned data
179 ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc = fs3.cbFileAlloc;
180 ((PFILESTATUS3L)pInfoBuf)->attrFile = fs3.attrFile;
181 }
182 break;
183 case FIL_QUERYEASIZEL:
184 rc = DosQueryPathInfo(pszPathName, ulInfoLevel, &fs4, sizeof(fs4));
185 if (!rc) {
186 *(PFILESTATUS4)pInfoBuf = fs4; // Copy aligned data
187 ((PFILESTATUS4L)pInfoBuf)->cbFile = fs4.cbFile; // Copy unaligned data
188 ((PFILESTATUS4L)pInfoBuf)->cbFileAlloc = fs4.cbFileAlloc;
189 ((PFILESTATUS4L)pInfoBuf)->attrFile = fs4.attrFile;
190 ((PFILESTATUS4L)pInfoBuf)->cbList = fs4.cbList;
191 }
192 break;
193 default:
194 Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
195 rc = ERROR_INVALID_PARAMETER;
196 } // switch
197 }
198 else
199 DosQueryPathInfo (pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf);
200
201 return rc;
202}
203
204/**
205 * Wrap DosSetPathInfo to avoid spurious ERROR_INVALID_NAME returns and
206 * support systems without large file support
207 *
208 * Some kernels to do not correctly handle FILESTATUS3 and PEAOP2 buffers
209 * that cross a 64K boundary.
210 * When this occurs, they return ERROR_INVALID_NAME.
211 * This code works around the problem because if the passed buffer crosses
212 * the boundary the alternate buffer will not because both are on the stack
213 * and we don't put enough additional data on the stack for this to occur.
214 * It is caller's responsitibility to report errors
215 * @param pInfoBuf pointer to FILESTATUS3(L) or EAOP2 buffer
216 * @param ulInfoLevel FIL_STANDARD(L) or FIL_QUERYEASIZE
217 * @returns Same as DosSetPathInfo
218 */
219
220APIRET xDosSetPathInfo(PSZ pszPathName,
221 ULONG ulInfoLevel,
222 PVOID pInfoBuf,
223 ULONG cbInfoBuf,
224 ULONG flOptions)
225{
226 FILESTATUS3 fs3;
227 FILESTATUS3 fs3_a;
228 FILESTATUS3L fs3l;
229 EAOP2 eaop2;
230 APIRET rc;
231 BOOL crosses = ((ULONG)pInfoBuf ^
232 ((ULONG)pInfoBuf + cbInfoBuf - 1)) & ~0xffff;
233 BOOL fResetVerify = FALSE;
234
235 if (fVerify && driveflags[toupper(*pszPathName) - 'A'] & DRIVE_WRITEVERIFYOFF) {
236 DosSetVerify(FALSE);
237 fResetVerify = TRUE;
238 }
239 switch (ulInfoLevel) {
240 case FIL_STANDARD:
241 if (crosses) {
242 fs3 = *(PFILESTATUS3)pInfoBuf; // Copy to buffer that does not cross 64K boundary
243 rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3, cbInfoBuf, flOptions);
244 }
245 else
246 rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
247 break;
248
249 case FIL_STANDARDL:
250 if (fNoLargeFileSupport) {
251 ulInfoLevel = FIL_STANDARD;
252 fs3 = *(PFILESTATUS3)pInfoBuf; // Copy aligned data
253 // Check size too big to handle
254 if (((PFILESTATUS3L)pInfoBuf)->cbFile >= 1LL << 32 ||
255 ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc >= 2LL << 32)
256 {
257 rc = ERROR_INVALID_PARAMETER;
258 }
259 else {
260 fs3.cbFile = ((PFILESTATUS3L)pInfoBuf)->cbFile; // Copy unaligned data
261 fs3.cbFileAlloc = ((PFILESTATUS3L)pInfoBuf)->cbFileAlloc;
262 fs3.attrFile = ((PFILESTATUS3L)pInfoBuf)->attrFile;
263 rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3, sizeof(fs3), flOptions);
264 }
265 if (rc == ERROR_INVALID_NAME) {
266 // fixme to validate counts?
267 fs3_a = fs3; // Copy to buffer that does not cross
268 rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3_a, sizeof(fs3_a), flOptions);
269 }
270 }
271 else {
272 rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
273 if (rc == ERROR_INVALID_NAME) {
274 fs3l = *(PFILESTATUS3L)pInfoBuf; // Copy to buffer that does not cross
275 rc = DosSetPathInfo(pszPathName, ulInfoLevel, &fs3l, sizeof(fs3l), flOptions);
276 }
277 }
278 break;
279 case FIL_QUERYEASIZE:
280 rc = DosSetPathInfo(pszPathName, ulInfoLevel, pInfoBuf, cbInfoBuf, flOptions);
281 if (rc == ERROR_INVALID_NAME) {
282 // fixme to validate counts?
283 eaop2 = *(PEAOP2)pInfoBuf; // Copy to buffer that does not cross
284 rc = DosSetPathInfo(pszPathName, ulInfoLevel, &eaop2, sizeof(eaop2), flOptions);
285 }
286 break;
287 default:
288 Runtime_Error(pszSrcFile, __LINE__, "ulInfoLevel %u unexpected", ulInfoLevel);
289 rc = ERROR_INVALID_PARAMETER;
290 } // switch
291 if (fResetVerify) {
292 DosSetVerify(fVerify);
293 fResetVerify = FALSE;
294 }
295 return rc;
296}
297
298PSZ xfgets(PSZ pszBuf, size_t cMaxBytes, FILE * fp, PCSZ pszSrcFile,
299 UINT uiLineNumber)
300{
301 PSZ psz = fgets(pszBuf, cMaxBytes, fp);
302
303 if (!psz) {
304 if (ferror(fp))
305 Runtime_Error(pszSrcFile, uiLineNumber, "fgets");
306 }
307 else {
308 size_t c = strlen(psz);
309
310 if (c + 1 > cMaxBytes)
311 Runtime_Error(pszSrcFile, uiLineNumber, "buffer overflow");
312 else if (!c || (psz[c - 1] != '\n' && psz[c - 1] != '\r'))
313 Runtime_Error(pszSrcFile, uiLineNumber, "missing EOL");
314 }
315 return psz;
316}
317
318PSZ xfgets_bstripcr(PSZ pszBuf, size_t cMaxBytes, FILE * fp, PCSZ pszSrcFile,
319 UINT uiLineNumber)
320{
321 PSZ psz = xfgets(pszBuf, cMaxBytes, fp, pszSrcFile, uiLineNumber);
322
323 if (psz)
324 bstripcr(psz);
325 return psz;
326}
327
328FILE *xfopen(PCSZ pszFileName, PCSZ pszMode, PCSZ pszSrcFile,
329 UINT uiLineNumber)
330{
331 FILE *fp = fopen(pszFileName, pszMode);
332
333 if (!fp)
334 Runtime_Error(pszSrcFile, uiLineNumber, "fopen");
335 return fp;
336}
337
338FILE *xfsopen(PCSZ pszFileName, PCSZ pszMode, INT fSharemode, PCSZ pszSrcFile,
339 UINT uiLineNumber)
340{
341 FILE *fp = _fsopen((PSZ) pszFileName, (PSZ) pszMode, fSharemode);
342
343 if (!fp)
344 Runtime_Error(pszSrcFile, uiLineNumber, "_fsopen");
345 return fp;
346}
347
348//== xfree - safe free ==
349
350VOID xfree(PVOID pv, PCSZ pszSrcFile, UINT uiLineNumber)
351{
352 if (pv && pv != NullStr) {
353# ifdef FORTIFY
354 Fortify_free(pv, pszSrcFile, uiLineNumber);
355# else
356 free(pv);
357# endif
358
359 }
360}
361
362//== xmalloc() malloc with error checking ==
363
364PVOID xmalloc(size_t cBytes, PCSZ pszSrcFile, UINT uiLineNumber)
365{
366# ifdef FORTIFY
367 PVOID pv = Fortify_malloc(cBytes, pszSrcFile, uiLineNumber);
368# else
369 PVOID pv = malloc(cBytes);
370# endif
371
372 if (!pv)
373 Runtime_Error(pszSrcFile, uiLineNumber, GetPString(IDS_OUTOFMEMORY));
374
375 return pv;
376}
377
378//== xmallocz() malloc and zero with error checking ==
379
380PVOID xmallocz(size_t cBytes, PCSZ pszSrcFile, UINT uiLineNumber)
381{
382 PVOID pv = xmalloc(cBytes, pszSrcFile, uiLineNumber);
383
384 if (pv)
385 memset(pv, 0, cBytes);
386
387 return pv;
388}
389
390//== xrealloc() realloc with error checking ==
391
392PVOID xrealloc(PVOID pvIn, size_t cBytes, PCSZ pszSrcFile, UINT uiLineNumber)
393{
394 if (pvIn != NullStr) {
395# ifdef FORTIFY
396 PVOID pv = Fortify_realloc(pvIn, cBytes, pszSrcFile, uiLineNumber);
397# else
398 PVOID pv = realloc(pvIn, cBytes);
399# endif
400
401 if (!pv && cBytes)
402 Runtime_Error(pszSrcFile, uiLineNumber, GetPString(IDS_OUTOFMEMORY));
403
404 return pv;
405 }
406 else
407 return xmalloc(cBytes, pszSrcFile, uiLineNumber);
408}
409
410//== xstrdup() strdup with error checking ==
411
412PVOID xstrdup(PCSZ pszIn, PCSZ pszSrcFile, UINT uiLineNumber)
413{
414# ifdef FORTIFY
415 PSZ psz = Fortify_strdup(pszIn, pszSrcFile, uiLineNumber);
416# else
417 PSZ psz = strdup(pszIn);
418# endif
419
420 if (!psz)
421 Runtime_Error(pszSrcFile, uiLineNumber, GetPString(IDS_OUTOFMEMORY));
422
423 return psz;
424}
425
426
427#pragma alloc_text(WRAPPERS1,xfree,xfopen,xfsopen,xmalloc,xrealloc,xstrdup)
428#pragma alloc_text(WRAPPERS2,xDosSetPathInfo,xDosFindFirst,xDosFindNext)
Note: See TracBrowser for help on using the repository browser.