Context Navigation

source: trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFile.cpp@ 170

Last change on this file since 170 was 170, checked in by Valery V. Sedletski, 7 years ago
vboxsf.ifs: Shared folders enhancements.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 45.4 KB

Line
1	/** $Id: VBoxSFFile.cpp 170 2018-10-20 07:58:56Z valerius $ */
2	/** @file
3	* VBoxSF - OS/2 Shared Folders, the file level IFS EPs.
4	*/
5
6	/*
7	* Copyright (c) 2007 knut st. osmundsen <bird-src-spam@anduin.net>
8	* Copyright (c) 2015-2018 Valery V. Sedletski <_valerius-no-spam@mail.ru>
9	*
10	* Permission is hereby granted, free of charge, to any person
11	* obtaining a copy of this software and associated documentation
12	* files (the "Software"), to deal in the Software without
13	* restriction, including without limitation the rights to use,
14	* copy, modify, merge, publish, distribute, sublicense, and/or sell
15	* copies of the Software, and to permit persons to whom the
16	* Software is furnished to do so, subject to the following
17	* conditions:
18	*
19	* The above copyright notice and this permission notice shall be
20	* included in all copies or substantial portions of the Software.
21	*
22	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
24	* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26	* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
27	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
29	* OTHER DEALINGS IN THE SOFTWARE.
30	*/
31
32
33	/*********************************************************************************************************************************
34	* Header Files *
35	*********************************************************************************************************************************/
36	#define LOG_GROUP LOG_GROUP_DEFAULT
37	#include "VBoxSFInternal.h"
38
39	#include <VBox/log.h>
40	#include <iprt/mem.h>
41	#include <iprt/assert.h>
42
43	extern VBGLSFCLIENT g_clientHandle;
44
45	uint32_t VBoxToOS2Attr(uint32_t fMode);
46
47	/**
48	* Resolve a file name to a share map handle and the path relative to this share
49	*
50	* @param Path
51	* @param pcdfsi
52	*
53	*/
54	APIRET APIENTRY parseFileName(const char *pszPath, PCDFSI pcdfsi,
55	char pszParsedPath, int pcbParsedPath, VBGLSFMAP *map)
56	{
57	PVPFSI pvpfsi;
58	PVPFSD pvpfsd;
59	PVBOXSFVP pvboxsfvp;
60	char *p;
61	int len;
62
63	if (! pszPath \|\| !pcdfsi \|\| ! pszParsedPath \|\| ! *pcbParsedPath)
64	return ERROR_INVALID_PARAMETER;
65
66	FSH32_GETVOLPARM(pcdfsi->cdi_hVPB, &pvpfsi, &pvpfsd);
67
68	pvboxsfvp = (PVBOXSFVP)pvpfsd;
69
70	if ( (p = strstr(pszPath, ":")) && p == pszPath + 1 )
71	{
72	/* absolute pathname starting from "d:\" */
73	len = strlen(p + 2);
74
75	if (len > *pcbParsedPath)
76	return ERROR_FILENAME_EXCED_RANGE;
77
78	strcpy(pszParsedPath, p + 2);
79	*map = pvboxsfvp->map;
80	}
81	else if ( (p = strstr(pszPath, "\\\\")) && p == pszPath )
82	{
83	// UNC name
84	return ERROR_NOT_SUPPORTED;
85	}
86	else if ( (p = strstr(pszPath, "\\")) && p == pszPath )
87	{
88	/* absolute pathname starting from "\" */
89	len = strlen(p + 1);
90
91	if (len > *pcbParsedPath)
92	return ERROR_FILENAME_EXCED_RANGE;
93
94	strcpy(pszParsedPath, p + 1);
95	*map = pvboxsfvp->map;
96	}
97	else if (! (p = strstr(pszPath, "\\")) )
98	{
99	/* relative pathname */
100	len = strlen(pcdfsi->cdi_curdir) + strlen(pszPath) + 1;
101
102	if (len > *pcbParsedPath)
103	return ERROR_FILENAME_EXCED_RANGE;
104
105	strcpy(pszParsedPath, pcdfsi->cdi_curdir);
106	strcat(pszParsedPath, "\\");
107	strcat(pszParsedPath, pszPath);
108	*map = pvboxsfvp->map;
109	}
110
111	return NO_ERROR;
112	}
113
114	DECLASM(int)
115	FS32_OPENCREATE(PCDFSI pcdfsi, PVBOXSFCD pcdfsd, PCSZ pszName, USHORT iCurDirEnd,
116	PSFFSI psffsi, PVBOXSFFSD psffsd, ULONG ulOpenMode, USHORT usOpenFlags,
117	PUSHORT pusAction, USHORT usAttr, PBYTE pcEABuf, PUSHORT pfgenflag)
118	{
119	SHFLCREATEPARMS params = {0};
120	APIRET hrc = NO_ERROR;
121	char *pszFullName;
122	int cbFullName;
123	VBGLSFMAP map;
124	char *pwsz;
125	PSHFLSTRING path;
126	PVPFSI pvpfsi;
127	PVPFSD pvpfsd;
128	PVBOXSFVP pvboxsfvp;
129	RTTIME time;
130	FDATE d;
131	FTIME t;
132	int rc;
133
134	dprintf("VBOXSF: FS32_OPENCREATE(%s, %lx, %x, %x)\n", pszName, ulOpenMode, usOpenFlags, usAttr);
135
136	RT_ZERO(params);
137	params.Handle = SHFL_HANDLE_NIL;
138
139	pszFullName = (char *)RTMemAlloc(CCHMAXPATHCOMP + 1);
140
141	if (! pszFullName)
142	{
143	hrc = ERROR_NOT_ENOUGH_MEMORY;
144	goto FS32_OPENCREATEEXIT;
145	}
146
147	cbFullName = CCHMAXPATHCOMP + 1;
148
149	hrc = parseFileName((char *)pszName, pcdfsi, pszFullName, &cbFullName, &map);
150
151	if (hrc)
152	{
153	dprintf("Filename parse error!\n");
154	goto FS32_OPENCREATEEXIT;
155	}
156
157	dprintf("pszFullName=%s\n", pszFullName);
158
159	if (ulOpenMode & OPEN_FLAGS_DASD)
160	{
161	hrc = ERROR_NOT_SUPPORTED;
162	goto FS32_OPENCREATEEXIT;
163	}
164	else if (ulOpenMode & OPEN_ACCESS_READWRITE)
165	params.CreateFlags \|= SHFL_CF_ACCESS_READWRITE;
166	else if (ulOpenMode & OPEN_ACCESS_READONLY)
167	params.CreateFlags \|= SHFL_CF_ACCESS_READ;
168	else if (ulOpenMode & OPEN_ACCESS_WRITEONLY)
169	params.CreateFlags \|= SHFL_CF_ACCESS_WRITE;
170
171	if (usOpenFlags & OPEN_ACTION_CREATE_IF_NEW)
172	{
173	params.CreateFlags \|= SHFL_CF_ACT_CREATE_IF_NEW;
174	if (usOpenFlags & OPEN_ACTION_FAIL_IF_EXISTS)
175	params.CreateFlags \|= SHFL_CF_ACT_FAIL_IF_EXISTS;
176	else if (usOpenFlags & OPEN_ACTION_REPLACE_IF_EXISTS)
177	params.CreateFlags \|= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
178	else if (usOpenFlags & OPEN_ACTION_OPEN_IF_EXISTS)
179	params.CreateFlags \|= SHFL_CF_ACT_OPEN_IF_EXISTS;
180
181	*pusAction = FILE_CREATED;
182	}
183	else if (usOpenFlags & OPEN_ACTION_FAIL_IF_NEW)
184	{
185	params.CreateFlags \|= SHFL_CF_ACT_FAIL_IF_NEW;
186	if (usOpenFlags & OPEN_ACTION_REPLACE_IF_EXISTS)
187	{
188	params.CreateFlags \|= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
189	*pusAction = FILE_TRUNCATED;
190	}
191	else if (usOpenFlags & OPEN_ACTION_OPEN_IF_EXISTS)
192	{
193	params.CreateFlags \|= SHFL_CF_ACT_OPEN_IF_EXISTS;
194	*pusAction = FILE_EXISTED;
195	}
196	}
197	else
198	params.CreateFlags \|= SHFL_CF_ACCESS_APPEND;
199
200	if (ulOpenMode & OPEN_SHARE_DENYREADWRITE)
201	params.CreateFlags \|= SHFL_CF_ACCESS_DENYALL;
202	else if (ulOpenMode & OPEN_SHARE_DENYWRITE)
203	params.CreateFlags \|= SHFL_CF_ACCESS_DENYWRITE;
204	else if (ulOpenMode & OPEN_SHARE_DENYREAD)
205	params.CreateFlags \|= SHFL_CF_ACCESS_DENYREAD;
206	else if (ulOpenMode & OPEN_SHARE_DENYNONE)
207	params.CreateFlags \|= SHFL_CF_ACCESS_DENYNONE;
208
209	params.CreateFlags \|= SHFL_CF_ACCESS_ATTR_READWRITE;
210
211	if (usAttr & FILE_READONLY)
212	params.CreateFlags &= ~SHFL_CF_ACCESS_ATTR_WRITE;
213
214	pwsz = (char )RTMemAlloc(2 CCHMAXPATHCOMP + 2);
215	vboxsfStrToUtf8(pwsz, (char *)pszFullName);
216
217	path = make_shflstring((char *)pwsz);
218	rc = VbglR0SfCreate(&g_clientHandle, &map, path, &params);
219	RTMemFree(pwsz);
220	RTMemFree(pszFullName);
221
222	if (!RT_SUCCESS(rc))
223	{
224	dprintf("VbglR0SfCreate returned %d\n", rc);
225	free_shflstring(path);
226	hrc = vbox_err_to_os2_err(rc);
227	goto FS32_OPENCREATEEXIT;
228	}
229
230	psffsd->filebuf = (PFILEBUF)RTMemAlloc(sizeof(FILEBUF));
231
232	if (!psffsd->filebuf)
233	{
234	dprintf("couldn't allocate file buf\n");
235	hrc = ERROR_NOT_ENOUGH_MEMORY;
236	goto FS32_OPENCREATEEXIT;
237	}
238
239	dprintf("filebuf=%x\n", psffsd->filebuf);
240
241	psffsd->filebuf->handle = params.Handle;
242	psffsd->filebuf->path = path;
243
244	psffsi->sfi_positionl = 0;
245	psffsi->sfi_position = 0;
246
247	psffsi->sfi_sizel = params.Info.cbObject;
248	psffsi->sfi_size = (LONG)params.Info.cbObject;
249
250	/* Creation time */
251	RTTimeExplode(&time, &params.Info.BirthTime);
252
253	t.hours = time.u8Hour;
254	t.minutes = time.u8Minute;
255	t.twosecs = time.u8Second / 2;
256	d.year = time.i32Year - 1980;
257	d.month = time.u8Month;
258	d.day = time.u8MonthDay;
259	psffsi->sfi_ctime = *(PUSHORT)&t;
260	psffsi->sfi_cdate = *(PUSHORT)&d;
261
262	/* Last access time */
263	RTTimeExplode(&time, &params.Info.AccessTime);
264
265	t.hours = time.u8Hour;
266	t.minutes = time.u8Minute;
267	t.twosecs = time.u8Second / 2;
268	d.year = time.i32Year - 1980;
269	d.month = time.u8Month;
270	d.day = time.u8MonthDay;
271	psffsi->sfi_atime = *(PUSHORT)&t;
272	psffsi->sfi_adate = *(PUSHORT)&d;
273
274	/* Last write time */
275	RTTimeExplode(&time, &params.Info.ModificationTime);
276
277	t.hours = time.u8Hour;
278	t.minutes = time.u8Minute;
279	t.twosecs = time.u8Second / 2;
280	d.year = time.i32Year - 1980;
281	d.month = time.u8Month;
282	d.day = time.u8MonthDay;
283	psffsi->sfi_mtime = *(PUSHORT)&t;
284	psffsi->sfi_mdate = *(PUSHORT)&d;
285
286	// @todo omit ST_SCREAT \| ST_PCREAT if not creating the file
287	psffsi->sfi_tstamp = ST_SCREAT \| ST_PCREAT \| ST_SREAD \| ST_PREAD \| ST_SWRITE \| ST_PWRITE;
288
289	psffsi->sfi_DOSattr = VBoxToOS2Attr(params.Info.Attr.fMode);
290
291	FS32_OPENCREATEEXIT:
292	dprintf(" => %d\n", hrc);
293	return hrc;
294	}
295
296
297	DECLASM(int)
298	FS32_CLOSE(ULONG type, ULONG IOflag, PSFFSI psffsi, PVBOXSFFSD psffsd)
299	{
300	APIRET hrc = NO_ERROR;
301	PVPFSI pvpfsi;
302	PVPFSD pvpfsd;
303	PVBOXSFVP pvboxsfvp;
304	PFILEBUF filebuf = psffsd->filebuf;
305	int rc;
306
307	dprintf("VBOXSF: FS32_CLOSE(%lx, %lx)\n", type, IOflag);
308
309	if (type != 2)
310	{
311	hrc = NO_ERROR;
312	goto FS32_CLOSEEXIT;
313	}
314
315	FSH32_GETVOLPARM(psffsi->sfi_hVPB, &pvpfsi, &pvpfsd);
316
317	pvboxsfvp = (PVBOXSFVP)pvpfsd;
318
319	rc = VbglR0SfClose(&g_clientHandle, &pvboxsfvp->map, filebuf->handle);
320	hrc = vbox_err_to_os2_err(rc);
321	free_shflstring(filebuf->path);
322	//__asm__ __volatile__ (".byte 0xcc\n\t");
323	dprintf("filebuf=%x\n", filebuf);
324	RTMemFree(filebuf);
325
326	FS32_CLOSEEXIT:
327	dprintf(" => %d\n", hrc);
328	return hrc;
329	}
330
331
332	DECLASM(int)
333	FS32_COMMIT(ULONG type, ULONG IOflag, PSFFSI psffsi, PVBOXSFFSD psffsd)
334	{
335	dprintf("VBOXSF: FS32_COMMIT(%lx, %lx)\n", type, IOflag);
336	return NO_ERROR;
337	}
338
339
340	extern "C" APIRET APIENTRY
341	FS32_CHGFILEPTRL(PSFFSI psffsi, PVBOXSFFSD psffsd, LONGLONG off, ULONG ulMethod, ULONG IOflag)
342	{
343	APIRET hrc = NO_ERROR;
344	LONGLONG llNewOffset = 0;
345
346	dprintf("VBOXSF: FS32_CHGFILEPTRL(%lld, %lx, %lx)\n", off, ulMethod, IOflag);
347
348	switch (ulMethod)
349	{
350	case 0: /* relative to the beginning */
351	llNewOffset = off;
352	break;
353
354	case 1: /* relative to the current position */
355	llNewOffset = psffsi->sfi_positionl + off;
356	break;
357
358	case 2: /* relative to the end of file */
359	llNewOffset = psffsi->sfi_sizel + off;
360	}
361	if (llNewOffset < 0)
362	{
363	hrc = ERROR_NEGATIVE_SEEK;
364	goto FS32_CHGFILEPTRLEXIT;
365	}
366	if (llNewOffset != psffsi->sfi_positionl)
367	psffsi->sfi_positionl = llNewOffset;
368
369	psffsi->sfi_position = (LONG)psffsi->sfi_positionl;
370
371	FS32_CHGFILEPTRLEXIT:
372	dprintf(" => %d\n", hrc);
373	return hrc;
374	}
375
376
377	/** Forwards the call to FS32_CHGFILEPTRL. */
378	extern "C" APIRET APIENTRY
379	FS32_CHGFILEPTR(PSFFSI psffsi, PVBOXSFFSD psffsd, LONG off, ULONG ulMethod, ULONG IOflag)
380	{
381	dprintf("VBOXSF: FS32_CHGFILEPTR(%ld, %lx, %lx)\n", off, ulMethod, IOflag);
382	return FS32_CHGFILEPTRL(psffsi, psffsd, off, ulMethod, IOflag);
383	}
384
385
386	DECLASM(int)
387	FS32_FILEINFO(ULONG flag, PSFFSI psffsi, PVBOXSFFSD psffsd, ULONG level,
388	PBYTE pData, ULONG cbData, ULONG IOflag)
389	{
390	APIRET hrc = NO_ERROR;
391	SHFLCREATEPARMS params = {0};
392	USHORT usNeededSize;
393	PVPFSI pvpfsi;
394	PVPFSD pvpfsd;
395	PVBOXSFVP pvboxsfvp;
396	PSHFLDIRINFO file = NULL;
397	uint32_t len = sizeof(SHFLDIRINFO);
398	int rc;
399
400	dprintf("VBOXSF: FS32_FILEINFO(%lx, %lx, %lx)\n", flag, level, IOflag);
401
402	FSH32_GETVOLPARM(psffsi->sfi_hVPB, &pvpfsi, &pvpfsd);
403
404	pvboxsfvp = (PVBOXSFVP)pvpfsd;
405
406	switch (flag)
407	{
408	case 0: // retrieve
409	{
410	switch (level)
411	{
412	case FIL_STANDARD:
413	usNeededSize = sizeof(FILESTATUS);
414	break;
415
416	case FIL_STANDARDL:
417	usNeededSize = sizeof(FILESTATUS3L);
418	break;
419
420	case FIL_QUERYEASIZE:
421	usNeededSize = sizeof(FILESTATUS2);
422	break;
423
424	case FIL_QUERYEASIZEL:
425	usNeededSize = sizeof(FILESTATUS4L);
426	break;
427
428	case FIL_QUERYEASFROMLIST:
429	case FIL_QUERYEASFROMLISTL:
430	case 4:
431	usNeededSize = sizeof(EAOP);
432	break;
433
434	default:
435	hrc = ERROR_INVALID_LEVEL;
436	goto FS32_FILEINFOEXIT;
437	}
438
439	if (cbData < usNeededSize)
440	{
441	hrc = ERROR_BUFFER_OVERFLOW;
442	goto FS32_FILEINFOEXIT;
443	}
444
445	file = (PSHFLDIRINFO)RTMemAlloc(len);
446
447	if (! file)
448	{
449	dprintf("Not enough memory 1\n");
450	hrc = ERROR_NOT_ENOUGH_MEMORY;
451	goto FS32_FILEINFOEXIT;
452	}
453
454	dprintf("pvboxsfvp->map=%x\n", pvboxsfvp->map);
455	dprintf("psffsd->filebuf->handle=%x\n", psffsd->filebuf->handle);
456
457	rc = VbglR0SfFsInfo(&g_clientHandle, &pvboxsfvp->map, psffsd->filebuf->handle,
458	SHFL_INFO_GET \| SHFL_INFO_FILE, &len, file);
459
460	hrc = vbox_err_to_os2_err(rc);
461
462	if (RT_FAILURE(rc))
463	{
464	dprintf("VbglR0SfFsInfo failed: %d\n", rc);
465	goto FS32_FILEINFOEXIT;
466	}
467
468	if (level == FIL_STANDARD \|\| level == FIL_STANDARDL \|\|
469	level == FIL_QUERYEASIZE \|\| level == FIL_QUERYEASIZEL)
470	{
471	RTTIME time;
472	FDATE Date;
473	FTIME Time;
474	/* Creation time */
475	RTTimeExplode(&time, &file->Info.BirthTime);
476	Date.day = time.u8MonthDay;
477	Date.month = time.u8Month;
478	Date.year = time.i32Year - 1980;
479	Time.twosecs = time.u8Second / 2;
480	Time.minutes = time.u8Minute;
481	Time.hours = time.u8Hour;
482	memcpy(&psffsi->sfi_cdate, &Date, sizeof(USHORT));
483	memcpy(&psffsi->sfi_ctime, &Time, sizeof(USHORT));
484	/* Last access time */
485	RTTimeExplode(&time, &file->Info.AccessTime);
486	Date.day = time.u8MonthDay;
487	Date.month = time.u8Month;
488	Date.year = time.i32Year - 1980;
489	Time.twosecs = time.u8Second / 2;
490	Time.minutes = time.u8Minute;
491	Time.hours = time.u8Hour;
492	memcpy(&psffsi->sfi_adate, &Date, sizeof(USHORT));
493	memcpy(&psffsi->sfi_atime, &Time, sizeof(USHORT));
494	/* Last write time */
495	RTTimeExplode(&time, &file->Info.ModificationTime);
496	Date.day = time.u8MonthDay;
497	Date.month = time.u8Month;
498	Date.year = time.i32Year - 1980;
499	Time.twosecs = time.u8Second / 2;
500	Time.minutes = time.u8Minute;
501	Time.hours = time.u8Hour;
502	memcpy(&psffsi->sfi_mdate, &Date, sizeof(USHORT));
503	memcpy(&psffsi->sfi_mtime, &Time, sizeof(USHORT));
504	psffsi->sfi_DOSattr = VBoxToOS2Attr(file->Info.Attr.fMode);
505	}
506
507	switch (level)
508	{
509	case FIL_STANDARD:
510	{
511	FILESTATUS filestatus;
512	RTTIME time;
513	FDATE Date;
514	FTIME Time;
515	/* Creation time */
516	RTTimeExplode(&time, &file->Info.BirthTime);
517	Date.day = time.u8MonthDay;
518	Date.month = time.u8Month;
519	Date.year = time.i32Year - 1980;
520	Time.twosecs = time.u8Second / 2;
521	Time.minutes = time.u8Minute;
522	Time.hours = time.u8Hour;
523	memcpy(&filestatus.fdateCreation, &Date, sizeof(USHORT));
524	memcpy(&filestatus.ftimeCreation, &Time, sizeof(USHORT));
525	/* Last access time */
526	RTTimeExplode(&time, &file->Info.AccessTime);
527	Date.day = time.u8MonthDay;
528	Date.month = time.u8Month;
529	Date.year = time.i32Year - 1980;
530	Time.twosecs = time.u8Second / 2;
531	Time.minutes = time.u8Minute;
532	Time.hours = time.u8Hour;
533	memcpy(&filestatus.fdateLastAccess, &Date, sizeof(USHORT));
534	memcpy(&filestatus.ftimeLastAccess, &Time, sizeof(USHORT));
535	/* Last write time */
536	RTTimeExplode(&time, &file->Info.ModificationTime);
537	Date.day = time.u8MonthDay;
538	Date.month = time.u8Month;
539	Date.year = time.i32Year - 1980;
540	Time.twosecs = time.u8Second / 2;
541	Time.minutes = time.u8Minute;
542	Time.hours = time.u8Hour;
543	memcpy(&filestatus.fdateLastWrite, &Date, sizeof(USHORT));
544	memcpy(&filestatus.ftimeLastWrite, &Time, sizeof(USHORT));
545	filestatus.attrFile = VBoxToOS2Attr(file->Info.Attr.fMode);
546	filestatus.cbFile = (ULONG)file->Info.cbObject;
547	filestatus.cbFileAlloc = (ULONG)file->Info.cbAllocated;
548	KernCopyOut(pData, &filestatus, sizeof(FILESTATUS));
549	break;
550	}
551
552	case FIL_STANDARDL:
553	{
554	FILESTATUS3L filestatus;
555	RTTIME time;
556	FDATE Date;
557	FTIME Time;
558	/* Creation time */
559	RTTimeExplode(&time, &file->Info.BirthTime);
560	Date.day = time.u8MonthDay;
561	Date.month = time.u8Month;
562	Date.year = time.i32Year - 1980;
563	Time.twosecs = time.u8Second / 2;
564	Time.minutes = time.u8Minute;
565	Time.hours = time.u8Hour;
566	memcpy(&filestatus.fdateCreation, &Date, sizeof(USHORT));
567	memcpy(&filestatus.ftimeCreation, &Time, sizeof(USHORT));
568	/* Last access time */
569	RTTimeExplode(&time, &file->Info.AccessTime);
570	Date.day = time.u8MonthDay;
571	Date.month = time.u8Month;
572	Date.year = time.i32Year - 1980;
573	Time.twosecs = time.u8Second / 2;
574	Time.minutes = time.u8Minute;
575	Time.hours = time.u8Hour;
576	memcpy(&filestatus.fdateLastAccess, &Date, sizeof(USHORT));
577	memcpy(&filestatus.ftimeLastAccess, &Time, sizeof(USHORT));
578	/* Last write time */
579	RTTimeExplode(&time, &file->Info.ModificationTime);
580	Date.day = time.u8MonthDay;
581	Date.month = time.u8Month;
582	Date.year = time.i32Year - 1980;
583	Time.twosecs = time.u8Second / 2;
584	Time.minutes = time.u8Minute;
585	Time.hours = time.u8Hour;
586	memcpy(&filestatus.fdateLastWrite, &Date, sizeof(USHORT));
587	memcpy(&filestatus.ftimeLastWrite, &Time, sizeof(USHORT));
588	filestatus.attrFile = VBoxToOS2Attr(file->Info.Attr.fMode);
589	filestatus.cbFile = file->Info.cbObject;
590	filestatus.cbFileAlloc = file->Info.cbAllocated;
591	KernCopyOut(pData, &filestatus, sizeof(FILESTATUS3L));
592	break;
593	}
594
595	case FIL_QUERYEASIZE:
596	{
597	FILESTATUS2 filestatus;
598	RTTIME time;
599	FDATE Date;
600	FTIME Time;
601	/* Creation time */
602	RTTimeExplode(&time, &file->Info.BirthTime);
603	Date.day = time.u8MonthDay;
604	Date.month = time.u8Month;
605	Date.year = time.i32Year - 1980;
606	Time.twosecs = time.u8Second / 2;
607	Time.minutes = time.u8Minute;
608	Time.hours = time.u8Hour;
609	memcpy(&filestatus.fdateCreation, &Date, sizeof(USHORT));
610	memcpy(&filestatus.ftimeCreation, &Time, sizeof(USHORT));
611	/* Last access time */
612	RTTimeExplode(&time, &file->Info.AccessTime);
613	Date.day = time.u8MonthDay;
614	Date.month = time.u8Month;
615	Date.year = time.i32Year - 1980;
616	Time.twosecs = time.u8Second / 2;
617	Time.minutes = time.u8Minute;
618	Time.hours = time.u8Hour;
619	memcpy(&filestatus.fdateLastAccess, &Date, sizeof(USHORT));
620	memcpy(&filestatus.ftimeLastAccess, &Time, sizeof(USHORT));
621	/* Last write time */
622	RTTimeExplode(&time, &file->Info.ModificationTime);
623	Date.day = time.u8MonthDay;
624	Date.month = time.u8Month;
625	Date.year = time.i32Year - 1980;
626	Time.twosecs = time.u8Second / 2;
627	Time.minutes = time.u8Minute;
628	Time.hours = time.u8Hour;
629	memcpy(&filestatus.fdateLastWrite, &Date, sizeof(USHORT));
630	memcpy(&filestatus.ftimeLastWrite, &Time, sizeof(USHORT));
631	filestatus.attrFile = VBoxToOS2Attr(file->Info.Attr.fMode);
632	filestatus.cbFile = (ULONG)file->Info.cbObject;
633	filestatus.cbFileAlloc = (ULONG)file->Info.cbAllocated;
634	filestatus.cbList = sizeof(filestatus.cbList);
635	KernCopyOut(pData, &filestatus, sizeof(FILESTATUS2));
636	break;
637	}
638
639	case FIL_QUERYEASIZEL:
640	{
641	FILESTATUS4L filestatus;
642	RTTIME time;
643	FDATE Date;
644	FTIME Time;
645	/* Creation time */
646	RTTimeExplode(&time, &file->Info.BirthTime);
647	Date.day = time.u8MonthDay;
648	Date.month = time.u8Month;
649	Date.year = time.i32Year - 1980;
650	Time.twosecs = time.u8Second / 2;
651	Time.minutes = time.u8Minute;
652	Time.hours = time.u8Hour;
653	memcpy(&filestatus.fdateCreation, &Date, sizeof(USHORT));
654	memcpy(&filestatus.ftimeCreation, &Time, sizeof(USHORT));
655	/* Last access time */
656	RTTimeExplode(&time, &file->Info.AccessTime);
657	Date.day = time.u8MonthDay;
658	Date.month = time.u8Month;
659	Date.year = time.i32Year - 1980;
660	Time.twosecs = time.u8Second / 2;
661	Time.minutes = time.u8Minute;
662	Time.hours = time.u8Hour;
663	memcpy(&filestatus.fdateLastAccess, &Date, sizeof(USHORT));
664	memcpy(&filestatus.ftimeLastAccess, &Time, sizeof(USHORT));
665	/* Last write time */
666	RTTimeExplode(&time, &file->Info.ModificationTime);
667	Date.day = time.u8MonthDay;
668	Date.month = time.u8Month;
669	Date.year = time.i32Year - 1980;
670	Time.twosecs = time.u8Second / 2;
671	Time.minutes = time.u8Minute;
672	Time.hours = time.u8Hour;
673	memcpy(&filestatus.fdateLastWrite, &Date, sizeof(USHORT));
674	memcpy(&filestatus.ftimeLastWrite, &Time, sizeof(USHORT));
675	filestatus.attrFile = VBoxToOS2Attr(file->Info.Attr.fMode);
676	filestatus.cbFile = file->Info.cbObject;
677	filestatus.cbFileAlloc = file->Info.cbAllocated;
678	filestatus.cbList = sizeof(filestatus.cbList);
679	KernCopyOut(pData, &filestatus, sizeof(FILESTATUS4L));
680	break;
681	}
682
683	case FIL_QUERYEASFROMLIST:
684	case FIL_QUERYEASFROMLISTL:
685	{
686	EAOP filestatus;
687	KernCopyIn(&filestatus, pData, sizeof(EAOP));
688	PFEALIST pFEA = (PFEALIST)KernSelToFlat((ULONG)filestatus.fpFEAList);
689	// @todo: get empty EAs
690	memset(pFEA, 0, (USHORT)pFEA->cbList);
691	pFEA->cbList = sizeof(pFEA->cbList);
692	KernCopyOut(pData, &filestatus, sizeof(EAOP));
693	break;
694	}
695
696	case 4: // FIL_QUERYALLEAS
697	{
698	EAOP filestatus;
699	KernCopyIn(&filestatus, pData, sizeof(EAOP));
700	PFEALIST pFEA = (PFEALIST)KernSelToFlat((ULONG)filestatus.fpFEAList);
701	memset(pFEA, 0, (USHORT)pFEA->cbList);
702	pFEA->cbList = sizeof(pFEA->cbList);
703	KernCopyOut(pData, &filestatus, sizeof(EAOP));
704	break;
705	}
706
707	default:
708	hrc = ERROR_INVALID_LEVEL;
709	goto FS32_FILEINFOEXIT;
710	}
711
712	hrc = NO_ERROR;
713	}
714	break;
715
716	case 1: // set
717	{
718	if (!(psffsi->sfi_mode & OPEN_ACCESS_WRITEONLY) &&
719	!(psffsi->sfi_mode & OPEN_ACCESS_READWRITE))
720	{
721	hrc = ERROR_ACCESS_DENIED;
722	goto FS32_FILEINFOEXIT;
723	}
724
725	file = (PSHFLDIRINFO)RTMemAlloc(len);
726
727	if (! file)
728	{
729	hrc = ERROR_NOT_ENOUGH_MEMORY;
730	goto FS32_FILEINFOEXIT;
731	}
732
733	switch (level)
734	{
735	case FIL_STANDARD:
736	{
737	USHORT usMask;
738	FILESTATUS filestatus;
739	RTTIME time;
740	FDATE Date;
741	FTIME Time;
742
743	if (cbData < sizeof(filestatus))
744	{
745	hrc = ERROR_INSUFFICIENT_BUFFER;
746	goto FS32_FILEINFOEXIT;
747	}
748
749	KernCopyIn(&filestatus, pData, sizeof(filestatus));
750
751	/* Creation time */
752	memcpy(&Date, &filestatus.fdateCreation, sizeof(USHORT));
753	memcpy(&Time, &filestatus.ftimeCreation, sizeof(USHORT));
754	time.u8MonthDay = Date.day;
755	time.u8Month = Date.month;
756	time.i32Year = Date.year + 1980;
757	time.u8Second = Time.twosecs * 2;
758	time.u8Minute = Time.minutes;
759	time.u8Hour = Time.hours;
760	RTTimeImplode(&file->Info.BirthTime, &time);
761	/* Last access time */
762	memcpy(&Date, &filestatus.fdateLastAccess, sizeof(USHORT));
763	memcpy(&Time, &filestatus.ftimeLastAccess, sizeof(USHORT));
764	time.u8MonthDay = Date.day;
765	time.u8Month = Date.month;
766	time.i32Year = Date.year + 1980;
767	time.u8Second = Time.twosecs * 2;
768	time.u8Minute = Time.minutes;
769	time.u8Hour = Time.hours;
770	RTTimeImplode(&file->Info.AccessTime, &time);
771	/* Last write time */
772	memcpy(&Date, &filestatus.fdateLastWrite, sizeof(USHORT));
773	memcpy(&Time, &filestatus.ftimeLastWrite, sizeof(USHORT));
774	time.u8MonthDay = Date.day;
775	time.u8Month = Date.month;
776	time.i32Year = Date.year + 1980;
777	time.u8Second = Time.twosecs * 2;
778	time.u8Minute = Time.minutes;
779	time.u8Hour = Time.hours;
780	RTTimeImplode(&file->Info.ModificationTime, &time);
781
782	file->Info.cbObject = filestatus.cbFile;
783	file->Info.cbAllocated = filestatus.cbFileAlloc;
784	file->Info.Attr.fMode = OS2ToVBoxAttr(filestatus.attrFile);
785
786	usMask = ~(FILE_READONLY \| FILE_HIDDEN \| FILE_SYSTEM \| FILE_ARCHIVED);
787
788	if (filestatus.attrFile & usMask)
789	{
790	hrc = ERROR_ACCESS_DENIED;
791	goto FS32_FILEINFOEXIT;
792	}
793
794	usMask = 0;
795	if (memcmp(&filestatus.fdateCreation, &usMask, sizeof(usMask)) \|\|
796	memcmp(&filestatus.ftimeCreation, &usMask, sizeof(usMask)))
797	{
798	psffsi->sfi_tstamp &= ~ST_SCREAT;
799	psffsi->sfi_tstamp \|= ST_PCREAT;
800	memcpy(&psffsi->sfi_ctime, &filestatus.ftimeCreation, sizeof(USHORT));
801	memcpy(&psffsi->sfi_cdate, &filestatus.fdateCreation, sizeof(USHORT));
802	}
803
804	if (memcmp(&filestatus.fdateLastWrite, &usMask, sizeof(usMask)) \|\|
805	memcmp(&filestatus.ftimeLastWrite, &usMask, sizeof(usMask)))
806	{
807	psffsi->sfi_tstamp &= ~ST_SWRITE;
808	psffsi->sfi_tstamp \|= ST_PWRITE;
809	memcpy(&psffsi->sfi_mtime, &filestatus.ftimeLastWrite, sizeof(USHORT));
810	memcpy(&psffsi->sfi_mdate, &filestatus.fdateLastWrite, sizeof(USHORT));
811	}
812
813	if (memcmp(&filestatus.fdateLastAccess, &usMask, sizeof(usMask)) \|\|
814	memcmp(&filestatus.ftimeLastAccess, &usMask, sizeof(usMask)))
815	{
816	psffsi->sfi_tstamp &= ~ST_SREAD;
817	psffsi->sfi_tstamp \|= ST_PREAD;
818	memcpy(&psffsi->sfi_atime, &filestatus.ftimeLastAccess, sizeof(USHORT));
819	memcpy(&psffsi->sfi_adate, &filestatus.fdateLastAccess, sizeof(USHORT));
820	}
821
822	if (psffsi->sfi_DOSattr != (BYTE)filestatus.attrFile)
823	psffsi->sfi_DOSattr = (BYTE)filestatus.attrFile;
824
825	break;
826	}
827
828	case FIL_STANDARDL:
829	{
830	USHORT usMask;
831	FILESTATUS3L filestatus;
832	RTTIME time;
833	FDATE Date;
834	FTIME Time;
835
836	if (cbData < sizeof(filestatus))
837	{
838	hrc = ERROR_INSUFFICIENT_BUFFER;
839	goto FS32_FILEINFOEXIT;
840	}
841
842	KernCopyIn(&filestatus, pData, sizeof(filestatus));
843
844	/* Creation time */
845	memcpy(&Date, &filestatus.fdateCreation, sizeof(USHORT));
846	memcpy(&Time, &filestatus.ftimeCreation, sizeof(USHORT));
847	time.u8MonthDay = Date.day;
848	time.u8Month = Date.month;
849	time.i32Year = Date.year + 1980;
850	time.u8Second = Time.twosecs * 2;
851	time.u8Minute = Time.minutes;
852	time.u8Hour = Time.hours;
853	RTTimeImplode(&file->Info.BirthTime, &time);
854	/* Last access time */
855	memcpy(&Date, &filestatus.fdateLastAccess, sizeof(USHORT));
856	memcpy(&Time, &filestatus.ftimeLastAccess, sizeof(USHORT));
857	time.u8MonthDay = Date.day;
858	time.u8Month = Date.month;
859	time.i32Year = Date.year + 1980;
860	time.u8Second = Time.twosecs * 2;
861	time.u8Minute = Time.minutes;
862	time.u8Hour = Time.hours;
863	RTTimeImplode(&file->Info.AccessTime, &time);
864	/* Last write time */
865	memcpy(&Date, &filestatus.fdateLastWrite, sizeof(USHORT));
866	memcpy(&Time, &filestatus.ftimeLastWrite, sizeof(USHORT));
867	time.u8MonthDay = Date.day;
868	time.u8Month = Date.month;
869	time.i32Year = Date.year + 1980;
870	time.u8Second = Time.twosecs * 2;
871	time.u8Minute = Time.minutes;
872	time.u8Hour = Time.hours;
873	RTTimeImplode(&file->Info.ModificationTime, &time);
874
875	file->Info.cbObject = filestatus.cbFile;
876	file->Info.cbAllocated = filestatus.cbFileAlloc;
877	file->Info.Attr.fMode = OS2ToVBoxAttr(filestatus.attrFile);
878
879	usMask = ~(FILE_READONLY \| FILE_HIDDEN \| FILE_SYSTEM \| FILE_ARCHIVED);
880
881	if (filestatus.attrFile & usMask)
882	{
883	hrc = ERROR_ACCESS_DENIED;
884	goto FS32_FILEINFOEXIT;
885	}
886
887	usMask = 0;
888	if (memcmp(&filestatus.fdateCreation, &usMask, sizeof(usMask)) \|\|
889	memcmp(&filestatus.ftimeCreation, &usMask, sizeof(usMask)))
890	{
891	psffsi->sfi_tstamp &= ~ST_SCREAT;
892	psffsi->sfi_tstamp \|= ST_PCREAT;
893	memcpy(&psffsi->sfi_ctime, &filestatus.ftimeCreation, sizeof(USHORT));
894	memcpy(&psffsi->sfi_cdate, &filestatus.fdateCreation, sizeof(USHORT));
895	}
896
897	if (memcmp(&filestatus.fdateLastWrite, &usMask, sizeof(usMask)) \|\|
898	memcmp(&filestatus.ftimeLastWrite, &usMask, sizeof(usMask)))
899	{
900	psffsi->sfi_tstamp &= ~ST_SWRITE;
901	psffsi->sfi_tstamp \|= ST_PWRITE;
902	memcpy(&psffsi->sfi_mtime, &filestatus.ftimeLastWrite, sizeof(USHORT));
903	memcpy(&psffsi->sfi_mdate, &filestatus.fdateLastWrite, sizeof(USHORT));
904	}
905
906	if (memcmp(&filestatus.fdateLastAccess, &usMask, sizeof(usMask)) \|\|
907	memcmp(&filestatus.ftimeLastAccess, &usMask, sizeof(usMask)))
908	{
909	psffsi->sfi_tstamp &= ~ST_SREAD;
910	psffsi->sfi_tstamp \|= ST_PREAD;
911	memcpy(&psffsi->sfi_atime, &filestatus.ftimeLastAccess, sizeof(USHORT));
912	memcpy(&psffsi->sfi_adate, &filestatus.fdateLastAccess, sizeof(USHORT));
913	}
914
915	if (psffsi->sfi_DOSattr != (BYTE)filestatus.attrFile)
916	psffsi->sfi_DOSattr = (BYTE)filestatus.attrFile;
917
918	break;
919	}
920
921	case FIL_QUERYEASIZE:
922	case FIL_QUERYEASIZEL:
923	break;
924
925	default:
926	hrc = ERROR_INVALID_LEVEL;
927	}
928
929	rc = VbglR0SfFsInfo(&g_clientHandle, &pvboxsfvp->map, psffsd->filebuf->handle,
930	SHFL_INFO_SET \| SHFL_INFO_FILE, &len, file);
931
932	if (RT_FAILURE(rc))
933	{
934	dprintf("VbglR0SfFsInfo failed: %d\n", rc);
935	hrc = vbox_err_to_os2_err(rc);
936	goto FS32_FILEINFOEXIT;
937	}
938	}
939	break;
940
941	default:
942	hrc = ERROR_INVALID_FUNCTION;
943	}
944
945	FS32_FILEINFOEXIT:
946	if (file)
947	RTMemFree(file);
948
949	dprintf(" => %d\n", hrc);
950	return hrc;
951	}
952
953	int chsize(PVBOXSFVP pvboxsfvp, PVBOXSFFSD psffsd, ULONG size)
954	{
955	PSHFLFSOBJINFO pObjInfo = NULL;
956	uint32_t cbBuf = sizeof(SHFLFSOBJINFO);
957	int rc;
958
959	pObjInfo = (PSHFLFSOBJINFO)RTMemAlloc(cbBuf);
960
961	if (! pObjInfo)
962	{
963	return VERR_NO_MEMORY;
964	}
965
966	memset(pObjInfo, 0, cbBuf);
967	pObjInfo->cbObject = size;
968
969	rc = VbglR0SfFsInfo(&g_clientHandle, &pvboxsfvp->map, psffsd->filebuf->handle,
970	SHFL_INFO_SET \| SHFL_INFO_SIZE, &cbBuf, (PSHFLDIRINFO)pObjInfo);
971
972	if (pObjInfo)
973	RTMemFree(pObjInfo);
974
975	return rc;
976	}
977
978	DECLASM(int)
979	FS32_NEWSIZEL(PSFFSI psffsi, PVBOXSFFSD psffsd, LONGLONG cbFile, ULONG IOflag)
980	{
981	APIRET hrc = NO_ERROR;
982	PVPFSI pvpfsi;
983	PVPFSD pvpfsd;
984	PVBOXSFVP pvboxsfvp;
985	PSHFLSTRING path;
986	int rc;
987
988	dprintf("VBOXSF: FS32_NEWSIZEL(%lld, %lx)\n", cbFile, IOflag);
989
990	FSH32_GETVOLPARM(psffsi->sfi_hVPB, &pvpfsi, &pvpfsd);
991
992	pvboxsfvp = (PVBOXSFVP)pvpfsd;
993
994	rc = chsize(pvboxsfvp, psffsd, cbFile);
995
996	hrc = vbox_err_to_os2_err(rc);
997
998	FS32_NEWSIZELEXIT:
999	dprintf(" => %d\n", hrc);
1000
1001	return hrc;
1002	}
1003
1004
1005	extern "C" APIRET APIENTRY
1006	FS32_READ(PSFFSI psffsi, PVBOXSFFSD psffsd, PVOID pvData, PULONG pcb, ULONG IOflag)
1007	{
1008	APIRET hrc;
1009	PVPFSI pvpfsi;
1010	PVPFSD pvpfsd;
1011	PVBOXSFVP pvboxsfvp;
1012	uint8_t *pBuf;
1013	ULONG cb = *pcb;
1014	int rc;
1015
1016	dprintf("VBOXSF: FS32_READ(%lx)\n", IOflag);
1017
1018	FSH32_GETVOLPARM(psffsi->sfi_hVPB, &pvpfsi, &pvpfsd);
1019
1020	pvboxsfvp = (PVBOXSFVP)pvpfsd;
1021
1022	pBuf = (uint8_t )RTMemAlloc(pcb);
1023
1024	if (psffsi->sfi_positionl > psffsi->sfi_sizel)
1025	{
1026	*pcb = 0;
1027	}
1028	else if (*pcb > psffsi->sfi_sizel - psffsi->sfi_positionl)
1029	{
1030	*pcb = psffsi->sfi_sizel - psffsi->sfi_positionl;
1031	}
1032
1033	memset(pBuf, 0, cb);
1034
1035	rc = VbglR0SfRead(&g_clientHandle, &pvboxsfvp->map, psffsd->filebuf->handle,
1036	psffsi->sfi_positionl, (uint32_t *)pcb, pBuf, false);
1037
1038	if (RT_SUCCESS(rc))
1039	{
1040	KernCopyOut((char )pvData, pBuf, pcb);
1041	psffsi->sfi_positionl += *pcb;
1042	psffsi->sfi_position += *pcb;
1043	}
1044
1045	psffsi->sfi_tstamp \|= (ST_SREAD \| ST_PREAD);
1046
1047	hrc = vbox_err_to_os2_err(rc);
1048
1049	FS32_READEXIT:
1050	if (pBuf)
1051	RTMemFree(pBuf);
1052
1053	dprintf(" => %d\n", hrc);
1054	return hrc;
1055	}
1056
1057
1058	extern "C" APIRET APIENTRY
1059	FS32_WRITE(PSFFSI psffsi, PVBOXSFFSD psffsd, PVOID pvData, PULONG pcb, ULONG IOflag)
1060	{
1061	APIRET hrc;
1062	PVPFSI pvpfsi;
1063	PVPFSD pvpfsd;
1064	PVBOXSFVP pvboxsfvp;
1065	uint32_t cbNewPos;
1066	uint8_t *pBuf;
1067	int rc;
1068
1069	dprintf("VBOXSF: FS32_WRITE(%lx)\n", IOflag);
1070
1071	FSH32_GETVOLPARM(psffsi->sfi_hVPB, &pvpfsi, &pvpfsd);
1072
1073	pvboxsfvp = (PVBOXSFVP)pvpfsd;
1074
1075	pBuf = (uint8_t )RTMemAlloc(pcb);
1076
1077	if (! pBuf)
1078	{
1079	hrc = ERROR_NOT_ENOUGH_MEMORY;
1080	goto FS32_WRITEEXIT;
1081	}
1082
1083	KernCopyIn(pBuf, (char )pvData, pcb);
1084
1085	cbNewPos = psffsi->sfi_positionl + *pcb;
1086
1087	if (cbNewPos > psffsi->sfi_sizel)
1088	{
1089	rc = chsize(pvboxsfvp, psffsd, cbNewPos);
1090
1091	if (rc)
1092	{
1093	hrc = vbox_err_to_os2_err(rc);
1094	goto FS32_WRITEEXIT;
1095	}
1096
1097	psffsi->sfi_sizel = cbNewPos;
1098	psffsi->sfi_size = cbNewPos;
1099	}
1100
1101	rc = VbglR0SfWrite(&g_clientHandle, &pvboxsfvp->map, psffsd->filebuf->handle,
1102	psffsi->sfi_positionl, (uint32_t *)pcb, pBuf, false);
1103
1104	if (RT_SUCCESS(rc))
1105	{
1106	psffsi->sfi_positionl += *pcb;
1107	psffsi->sfi_position += *pcb;
1108	psffsi->sfi_tstamp \|= (ST_SWRITE \| ST_PWRITE);
1109	}
1110
1111	hrc = vbox_err_to_os2_err(rc);
1112
1113	FS32_WRITEEXIT:
1114	if (pBuf)
1115	RTMemFree(pBuf);
1116
1117	dprintf(" => %d\n", hrc);
1118	return hrc;
1119	}
1120
1121
1122	extern "C" APIRET APIENTRY
1123	FS32_READFILEATCACHE(PSFFSI psffsi, PVBOXSFFSD psffsd, ULONG IOflag, LONGLONG off, ULONG pcb, KernCacheList_t **ppCacheList)
1124	{
1125	dprintf("VBOXSF: FS32_READFILEATCACHE(%lx, %lld)\n", IOflag, off);
1126	return ERROR_NOT_SUPPORTED;
1127	}
1128
1129
1130	extern "C" APIRET APIENTRY
1131	FS32_RETURNFILECACHE(KernCacheList_t *pCacheList)
1132	{
1133	dprintf("VBOXSF: FS32_RETURNFILECACHE\n");
1134	return ERROR_NOT_SUPPORTED;
1135	}
1136
1137
1138	/* oddments */
1139
1140	DECLASM(int)
1141	FS32_CANCELLOCKREQUESTL(PSFFSI psffsi, PVBOXSFFSD psffsd, struct filelockl *pLockRange)
1142	{
1143	dprintf("VBOXSF: FS32_CANCELLOCKREQUESTL\n");
1144	return ERROR_NOT_SUPPORTED;
1145	}
1146
1147
1148	DECLASM(int)
1149	FS32_CANCELLOCKREQUEST(PSFFSI psffsi, PVBOXSFFSD psffsd, struct filelock *pLockRange)
1150	{
1151	dprintf("VBOXSF: FS32_CANCELLOCKREQUEST\n");
1152	return ERROR_NOT_SUPPORTED;
1153	}
1154
1155
1156	DECLASM(int)
1157	FS32_FILELOCKSL(PSFFSI psffsi, PVBOXSFFSD psffsd, struct filelockl *pUnLockRange,
1158	struct filelockl *pLockRange, ULONG timeout, ULONG flags)
1159	{
1160	dprintf("VBOXSF: FS32_FILELOCKSL(%lu, %lx)\n", timeout, flags);
1161	return ERROR_NOT_SUPPORTED;
1162	}
1163
1164
1165	DECLASM(int)
1166	FS32_FILELOCKS(PSFFSI psffsi, PVBOXSFFSD psffsd, struct filelock *pUnLockRange,
1167	struct filelock *pLockRange, ULONG timeout, ULONG flags)
1168	{
1169	dprintf("VBOXSF: FS32_FILELOCKS(%lu, %lx)\n", timeout, flags);
1170	return ERROR_NOT_SUPPORTED;
1171	}
1172
1173
1174	DECLASM(int)
1175	FS32_IOCTL(PSFFSI psffsi, PVBOXSFFSD psffsd, USHORT cat, USHORT func,
1176	PVOID pParm, USHORT lenParm, PUSHORT plenParmIO,
1177	PVOID pData, USHORT lenData, PUSHORT plenDataIO)
1178	{
1179	dprintf("VBOXSF: FS32_IOCTL(%x, %x)\n", cat, func);
1180	return ERROR_NOT_SUPPORTED;
1181	}
1182
1183
1184	DECLASM(int)
1185	FS32_FILEIO(PSFFSI psffsi, PVBOXSFFSD psffsd, PBYTE pCmdList, USHORT cbCmdList,
1186	PUSHORT poError, USHORT IOflag)
1187	{
1188	dprintf("VBOXSF: FS32_FILEIO(%x)\n", IOflag);
1189	return ERROR_NOT_SUPPORTED;
1190	}
1191
1192
1193	DECLASM(int)
1194	FS32_NMPIPE(PSFFSI psffsi, PVBOXSFFSD psffsd, USHORT OpType, union npoper *pOpRec,
1195	PBYTE pData, PCSZ pszName)
1196	{
1197	dprintf("VBOXSF: FS32_NPIPE(%x, %s)\n", OpType, pszName);
1198	return ERROR_NOT_SUPPORTED;
1199	}
1200
1201
1202	DECLASM(int)
1203	FS32_VERIFYUNCNAME(ULONG flag, PCSZ pszName)
1204	{
1205	dprintf("VBOXSF: FS32_VERIFYUNCNAME(%x, %s)\n", flag, pszName);
1206
1207	if (! stricmp((char *)pszName, "\\\\vboxsvr"))
1208	return NO_ERROR;
1209	else
1210	return ERROR_INVALID_NAME;
1211	}
1212
1213	DECLASM(int)
1214	FS32_OPENPAGEFILE(PULONG pFlag, PULONG pcMaxReq, PCSZ pszName, PSFFSI psffsi, PVBOXSFFSD psffsd,
1215	USHORT ulOpenMode, USHORT usOpenFlag, USHORT usAttr, ULONG Reserved)
1216	{
1217	dprintf("VBOXSF: FS32_OPENPAGEFILE(%s, %x, %x, %x)\n", pszName, ulOpenMode, usOpenFlag, usAttr);
1218	return ERROR_NOT_SUPPORTED;
1219	}
1220
1221
1222	DECLASM(int)
1223	FS32_SETSWAP(PSFFSI psffsi, PVBOXSFFSD psffsd)
1224	{
1225	dprintf("VBOXSF: FS32_SETSWAP\n");
1226	return ERROR_NOT_SUPPORTED;
1227	}
1228
1229
1230	DECLASM(int)
1231	FS32_ALLOCATEPAGESPACE(PSFFSI psffsi, PVBOXSFFSD psffsd, ULONG cb, USHORT cbWantContig)
1232	{
1233	dprintf("VBOXSF: FS32_ALLOCATEPAGESPACE(%lu, %u)\n", cb, cbWantContig);
1234	return ERROR_NOT_SUPPORTED;
1235	}
1236
1237
1238	DECLASM(int)
1239	FS32_DOPAGEIO(PSFFSI psffsi, PVBOXSFFSD psffsd, struct PageCmdHeader *pList)
1240	{
1241	dprintf("VBOXSF: FS32_DOPAGEIO\n");
1242	return ERROR_NOT_SUPPORTED;
1243	}
1244

Note: See TracBrowser for help on using the repository browser.

Download in other formats: