1 /* NFSv4.1 client for Windows
2  * Copyright � 2012 The Regents of the University of Michigan
3  *
4  * Olga Kornievskaia <aglo@umich.edu>
5  * Casey Bodley <cbodley@umich.edu>
6  *
7  * This library is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU Lesser General Public License as published by
9  * the Free Software Foundation; either version 2.1 of the License, or (at
10  * your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful, but
13  * without any warranty; without even the implied warranty of merchantability
14  * or fitness for a particular purpose.  See the GNU Lesser General Public
15  * License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License
18  * along with this library; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20  */
21 
22 #define MINIRDR__NAME "Value is ignored, only fact of definition"
23 #include <rx.h>
24 
25 #include "nfs41_driver.h"
26 #include "nfs41_debug.h"
27 #include <stdio.h>
28 #include <stdarg.h>
29 #include <ntstrsafe.h>
30 #include <winerror.h>
31 
32 #if defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_WIN7)
33 NTSTATUS NTAPI RtlUnicodeToUTF8N(CHAR *utf8_dest, ULONG utf8_bytes_max,
34                                  ULONG *utf8_bytes_written,
35                                  const WCHAR *uni_src, ULONG uni_bytes);
36 NTSTATUS NTAPI RtlUTF8ToUnicodeN(WCHAR *uni_dest, ULONG uni_bytes_max,
37                                  ULONG *uni_bytes_written,
38                                  const CHAR *utf8_src, ULONG utf8_bytes);
39 #endif /* defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_WIN7) */
40 
41 //#define INCLUDE_TIMESTAMPS
42 
DbgP(IN PCCH fmt,...)43 ULONG __cdecl DbgP(IN PCCH fmt, ...)
44 {
45     CHAR msg[512];
46     va_list args;
47     NTSTATUS status;
48 
49     va_start(args, fmt);
50     ASSERT(fmt != NULL);
51     status = RtlStringCbVPrintfA(msg, sizeof(msg), fmt, args);
52     if (NT_SUCCESS(status)) {
53 #ifdef INCLUDE_TIMESTAMPS
54         LARGE_INTEGER timestamp, local_time;
55         TIME_FIELDS time_fields;
56 
57         KeQuerySystemTime(&timestamp);
58         ExSystemTimeToLocalTime(&timestamp,&local_time);
59         RtlTimeToTimeFields(&local_time, &time_fields);
60 
61         DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL,
62             "[%ld].[%02u:%02u:%02u.%u] %s", IoGetCurrentProcess(),
63             time_fields.Hour, time_fields.Minute, time_fields.Second,
64             time_fields.Milliseconds, msg);
65 #else
66         DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL,
67             "[%04x] %s", PsGetCurrentProcessId(), msg);
68 #endif
69     }
70     va_end(args);
71 
72     return 0;
73 }
74 
print_error(IN PCCH fmt,...)75 ULONG __cdecl print_error(IN PCCH fmt, ...)
76 {
77     CHAR msg[512];
78     va_list args;
79     NTSTATUS status;
80 
81     va_start(args, fmt);
82     ASSERT(fmt != NULL);
83     status = RtlStringCbVPrintfA(msg, sizeof(msg), fmt, args);
84     if (NT_SUCCESS(status)) {
85 #ifdef INCLUDE_TIMESTAMPS
86         LARGE_INTEGER timestamp, local_time;
87         TIME_FIELDS time_fields;
88 
89         KeQuerySystemTime(&timestamp);
90         ExSystemTimeToLocalTime(&timestamp,&local_time);
91         RtlTimeToTimeFields(&local_time, &time_fields);
92 
93         DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL,
94             "[%ld].[%02u:%02u:%02u.%u] %s", IoGetCurrentProcess(),
95             time_fields.Hour, time_fields.Minute, time_fields.Second,
96             time_fields.Milliseconds, msg);
97 #else
98         DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL,
99             "[%04x] %s", PsGetCurrentProcessId(), msg);
100 #endif
101     }
102     va_end(args);
103 
104     return 0;
105 }
106 
print_hexbuf(int on,unsigned char * title,unsigned char * buf,int len)107 void print_hexbuf(int on, unsigned char *title, unsigned char *buf, int len)
108 {
109     int j, k;
110     LARGE_INTEGER timestamp, local_time;
111     TIME_FIELDS time_fields;
112 
113     if (!on) return;
114 
115     KeQuerySystemTime(&timestamp);
116     ExSystemTimeToLocalTime(&timestamp,&local_time);
117     RtlTimeToTimeFields(&local_time, &time_fields);
118 
119     DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL,
120         "[%ld].[%02u:%02u:%02u.%u] %s\n", IoGetCurrentProcess(),
121         time_fields.Hour, time_fields.Minute, time_fields.Second,
122         time_fields.Milliseconds, title);
123     for(j = 0, k = 0; j < len; j++, k++) {
124         DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL,
125             "%02x ", buf[j]);
126         if (((k+1) % 30 == 0 && k > 0))
127             DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL, "\n");
128     }
129     DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL, "\n");
130 }
131 
print_ioctl(int on,int op)132 void print_ioctl(int on, int op)
133 {
134     if(!on) return;
135     switch(op) {
136         case IRP_MJ_FILE_SYSTEM_CONTROL:
137             DbgP("IRP_MJ_FILE_SYSTEM_CONTROL\n");
138             break;
139         case IRP_MJ_DEVICE_CONTROL:
140             DbgP("IRP_MJ_DEVICE_CONTROL\n");
141             break;
142         case IRP_MJ_INTERNAL_DEVICE_CONTROL:
143             DbgP("IRP_MJ_INTERNAL_DEVICE_CONTROL\n");
144             break;
145         default:
146             DbgP("UNKNOWN MJ IRP %d\n", op);
147     };
148 }
149 
print_fs_ioctl(int on,int op)150 void print_fs_ioctl(int on, int op)
151 {
152     if(!on) return;
153     switch(op) {
154         case IOCTL_NFS41_INVALCACHE:
155             DbgP("IOCTL_NFS41_INVALCACHE\n");
156             break;
157         case IOCTL_NFS41_READ:
158             DbgP("IOCTL_NFS41_UPCALL\n");
159             break;
160         case IOCTL_NFS41_WRITE:
161             DbgP("IOCTL_NFS41_DOWNCALL\n");
162             break;
163         case IOCTL_NFS41_ADDCONN:
164             DbgP("IOCTL_NFS41_ADDCONN\n");
165             break;
166         case IOCTL_NFS41_DELCONN:
167             DbgP("IOCTL_NFS41_DELCONN\n");
168             break;
169         case IOCTL_NFS41_GETSTATE:
170             DbgP("IOCTL_NFS41_GETSTATE\n");
171             break;
172         case IOCTL_NFS41_START:
173             DbgP("IOCTL_NFS41_START\n");
174             break;
175         case IOCTL_NFS41_STOP:
176             DbgP("IOCTL_NFS41_STOP\n");
177             break;
178         default:
179             DbgP("UNKNOWN FS IOCTL %d\n", op);
180     };
181 }
182 
print_driver_state(int state)183 void print_driver_state(int state)
184 {
185     switch (state) {
186         case NFS41_START_DRIVER_STARTABLE:
187             DbgP("NFS41_START_DRIVER_STARTABLE\n");
188             break;
189         case NFS41_START_DRIVER_STOPPED:
190             DbgP("NFS41_START_DRIVER_STOPPED\n");
191             break;
192         case NFS41_START_DRIVER_START_IN_PROGRESS:
193             DbgP("NFS41_START_DRIVER_START_IN_PROGRESS\n");
194             break;
195         case NFS41_START_DRIVER_STARTED:
196             DbgP("NFS41_START_DRIVER_STARTED\n");
197             break;
198         default:
199             DbgP("UNKNOWN DRIVER STATE %d\n", state);
200     };
201 
202 }
203 
print_basic_info(int on,PFILE_BASIC_INFORMATION info)204 void print_basic_info(int on, PFILE_BASIC_INFORMATION info)
205 {
206     if (!on) return;
207     DbgP("BASIC_INFO: Create=%lx Access=%lx Write=%lx Change=%lx Attr=%x\n",
208         info->CreationTime.QuadPart, info->LastAccessTime.QuadPart,
209         info->LastWriteTime.QuadPart, info->ChangeTime.QuadPart,
210         info->FileAttributes);
211 }
print_std_info(int on,PFILE_STANDARD_INFORMATION info)212 void print_std_info(int on, PFILE_STANDARD_INFORMATION info)
213 {
214     if (!on) return;
215     DbgP("STD_INFO: Type=%s #Links=%d Alloc=%lx EOF=%lx Delete=%d\n",
216         info->Directory?"DIR":"FILE", info->NumberOfLinks,
217         info->AllocationSize.QuadPart, info->EndOfFile.QuadPart,
218         info->DeletePending);
219 }
220 
print_ea_info(int on,PFILE_FULL_EA_INFORMATION info)221 void print_ea_info(int on, PFILE_FULL_EA_INFORMATION info)
222 {
223     if (!on) return;
224     DbgP("FULL_EA_INFO: NextOffset=%d Flags=%x EaNameLength=%d "
225         "ExValueLength=%x EaName=%s\n", info->NextEntryOffset, info->Flags,
226         info->EaNameLength, info->EaValueLength, info->EaName);
227     if (info->EaValueLength)
228         print_hexbuf(0, (unsigned char *)"eavalue",
229             (unsigned char *)info->EaName + info->EaNameLength + 1,
230             info->EaValueLength);
231 }
232 
print_get_ea(int on,PFILE_GET_EA_INFORMATION info)233 void print_get_ea(int on, PFILE_GET_EA_INFORMATION info)
234 {
235     if (!on || !info) return;
236     DbgP("GET_EA_INFO: NextOffset=%d EaNameLength=%d EaName=%s\n",
237         info->NextEntryOffset, info->EaNameLength, info->EaName);
238 }
239 
print_srv_call(int on,IN PMRX_SRV_CALL p)240 VOID print_srv_call(int on, IN PMRX_SRV_CALL p)
241 {
242     if (!on) return;
243     DbgP("PMRX_SRV_CALL %p\n", p);
244 #if 0
245     DbgP("\tNodeReferenceCount %ld\n", p->NodeReferenceCount);
246     //DbgP("Context %p\n", p->Context);
247     //DbgP("Context2 %p\n", p->Context2);
248     //DbgP("pSrvCallName %wZ\n", p->pSrvCallName);
249     //DbgP("pPrincipalName %wZ\n", p->pPrincipalName);
250     //DbgP("PDomainName %wZ\n", p->pDomainName);
251     //DbgP("Flags %08lx\n", p->Flags);
252     //DbgP("MaximumNumberOfCloseDelayedFiles %ld\n", p->MaximumNumberOfCloseDelayedFiles);
253     //DbgP("Status %ld\n", p->Status);
254     DbgP("*****************\n");
255 #endif
256 }
257 
print_net_root(int on,IN PMRX_NET_ROOT p)258 VOID print_net_root(int on, IN PMRX_NET_ROOT p)
259 {
260     if (!on) return;
261     DbgP("PMRX_NET_ROOT %p\n", p);
262 #if 0
263     DbgP("\tNodeReferenceCount %ld\n", p->NodeReferenceCount);
264     DbgP("\tpSrvCall %p\n", p->pSrvCall);
265     //DbgP("Context %p\n", p->Context);
266     //DbgP("Context2 %p\n", p->Context2);
267     //DbgP("Flags %08lx\n", p->Flags);
268     DbgP("\tNumberOfFcbs %ld\n", p->NumberOfFcbs);
269     DbgP("\tNumberofSrvOpens %ld\n", p->NumberOfSrvOpens);
270     //DbgP("MRxNetRootState %ld\n", p->MRxNetRootState);
271     //DbgP("Type %ld\n", p->Type);
272     //DbgP("DeviceType %ld\n", p->DeviceType);
273     //DbgP("pNetRootName %wZ\n", p->pNetRootName);
274     //DbgP("InnerNamePrefix %wZ\n", &p->InnerNamePrefix);
275     DbgP("*****************\n");
276 #endif
277 }
278 
print_v_net_root(int on,IN PMRX_V_NET_ROOT p)279 VOID print_v_net_root(int on, IN PMRX_V_NET_ROOT p)
280 {
281     if (!on) return;
282     DbgP("PMRX_V_NET_ROOT %p\n", p);
283 #if 0
284     DbgP("\tNodeReferenceCount %ld\n", p->NodeReferenceCount);
285     DbgP("\tpNetRoot %p\n", p->pNetRoot);
286     //DbgP("Context %p\n", p->Context);
287     //DbgP("Context2 %p\n", p->Context2);
288     //DbgP("Flags %08lx\n", p->Flags);
289     DbgP("\tNumberofOpens %ld\n", p->NumberOfOpens);
290     DbgP("\tNumberofFobxs %ld\n", p->NumberOfFobxs);
291     //DbgP("LogonId\n");
292     //DbgP("pUserDomainName %wZ\n", p->pUserDomainName);
293     //DbgP("pUserName %wZ\n", p->pUserName);
294     //DbgP("pPassword %wZ\n", p->pPassword);
295     //DbgP("SessionId %ld\n", p->SessionId);
296     //DbgP("ConstructionStatus %08lx\n", p->ConstructionStatus);
297     //DbgP("IsExplicitConnection %d\n", p->IsExplicitConnection);
298     DbgP("*****************\n");
299 #endif
300 }
301 
print_file_object(int on,PFILE_OBJECT file)302 void print_file_object(int on, PFILE_OBJECT file)
303 {
304     if (!on) return;
305     DbgP("FsContext %p FsContext2 %p\n", file->FsContext, file->FsContext2);
306     DbgP("DeletePending %d ReadAccess %d WriteAccess %d DeleteAccess %d\n",
307         file->DeletePending, file->WriteAccess, file->DeleteAccess);
308     DbgP("SharedRead %d SharedWrite %d SharedDelete %d Flags %x\n",
309         file->SharedRead, file->SharedWrite, file->SharedDelete, file->Flags);
310 }
311 
print_fo_all(int on,PRX_CONTEXT c)312 void print_fo_all(int on, PRX_CONTEXT c)
313 {
314     if (!on) return;
315     if (c->pFcb && c->pRelevantSrvOpen)
316         DbgP("OpenCount %d FCB %p SRV %p FOBX %p VNET %p NET %p\n",
317             c->pFcb->OpenCount, c->pFcb, c->pRelevantSrvOpen, c->pFobx,
318             c->pRelevantSrvOpen->pVNetRoot, c->pFcb->pNetRoot);
319 }
320 
print_fcb(int on,IN PMRX_FCB p)321 VOID print_fcb(int on, IN PMRX_FCB p)
322 {
323     if (!on) return;
324     DbgP("PMRX_FCB %p OpenCount %d\n", p, p->OpenCount);
325 #if 0
326     DbgP("\tNodeReferenceCount %ld\n", p->NodeReferenceCount);
327     DbgP("\tpNetRoot %p\n", p->pNetRoot);
328     //DbgP("Context %p\n", p->Context);
329     //DbgP("Context2 %p\n", p->Context2);
330     //DbgP("FcbState %ld\n", p->FcbState);
331     //DbgP("UncleanCount %ld\n", p->UncleanCount);
332     //DbgP("UncachedUncleanCount %ld\n", p->UncachedUncleanCount);
333     DbgP("\tOpenCount %ld\n", p->OpenCount);
334     //DbgP("OutstandingLockOperationsCount %ld\n", p->OutstandingLockOperationsCount);
335     //DbgP("ActualAllocationLength %ull\n", p->ActualAllocationLength);
336     //DbgP("Attributes %ld\n", p->Attributes);
337     //DbgP("IsFileWritten %d\n", p->IsFileWritten);
338     //DbgP("fShouldBeOrphaned %d\n", p->fShouldBeOrphaned);
339     //DbgP("fMiniInited %ld\n", p->fMiniInited);
340     //DbgP("CachedNetRootType %c\n", p->CachedNetRootType);
341     //DbgP("SrvOpenList\n");
342     //DbgP("SrvOpenListVersion %ld\n", p->SrvOpenListVersion);
343     DbgP("*****************\n");
344 #endif
345 }
346 
print_srv_open(int on,IN PMRX_SRV_OPEN p)347 VOID print_srv_open(int on, IN PMRX_SRV_OPEN p)
348 {
349     if (!on) return;
350     DbgP("PMRX_SRV_OPEN %p\n", p);
351 #if 0
352     DbgP("\tNodeReferenceCount %ld\n", p->NodeReferenceCount);
353     DbgP("\tpFcb %p\n", p->pFcb);
354     DbgP("\tpVNetRoot %p\n", p->pVNetRoot);
355     //DbgP("Context %p\n", p->Context);
356     //DbgP("Context2 %p\n", p->Context2);
357     //DbgP("Flags %08lx\n", p->Flags);
358     //DbgP("pAlreadyPrefixedName %wZ\n", p->pAlreadyPrefixedName);
359     //DbgP("UncleanFobxCount %ld\n", p->UncleanFobxCount);
360     DbgP("\tOpenCount %ld\n", p->OpenCount);
361     //DbgP("Key %p\n", p->Key);
362     //DbgP("DesiredAccess\n");
363     //DbgP("ShareAccess %ld\n", p->ShareAccess);
364     //DbgP("CreateOptions %ld\n", p->CreateOptions);
365     //DbgP("BufferingFlags %ld\n", p->BufferingFlags);
366     //DbgP("ulFileSizeVersion %ld\n", p->ulFileSizeVersion);
367     //DbgP("SrvOpenQLinks\n");
368     DbgP("*****************\n");
369 #endif
370 }
371 
print_fobx(int on,IN PMRX_FOBX p)372 VOID print_fobx(int on, IN PMRX_FOBX p)
373 {
374     if (!on) return;
375     DbgP("PMRX_FOBX %p\n", p);
376 #if 0
377     DbgP("\tNodeReferenceCount %ld\n", p->NodeReferenceCount);
378     DbgP("\tpSrvOpen %p\n", p->pSrvOpen);
379     DbgP("\tAssociatedFileObject %p\n", p->AssociatedFileObject);
380     //DbgP("Context %p\n", p->Context);
381     //DbgP("Context2 %p\n", p->Context2);
382     //DbgP("Flags %08lx\n", p->Flags);
383     DbgP("*****************\n");
384 #endif
385 }
386 
print_irp_flags(int on,PIRP irp)387 VOID print_irp_flags(int on, PIRP irp)
388 {
389     if (!on) return;
390     if (irp->Flags)
391         DbgP("IRP FLAGS: 0x%x %s %s %s %s %s %s %s %s %s %s %s %s %s %s\n",
392             irp->Flags,
393             (irp->Flags & IRP_NOCACHE)?"NOCACHE":"",
394             (irp->Flags & IRP_PAGING_IO)?"PAGING_IO":"",
395             (irp->Flags & IRP_MOUNT_COMPLETION)?"MOUNT":"",
396             (irp->Flags & IRP_SYNCHRONOUS_API)?"SYNC":"",
397             (irp->Flags & IRP_ASSOCIATED_IRP)?"ASSOC_IPR":"",
398             (irp->Flags & IRP_BUFFERED_IO)?"BUFFERED":"",
399             (irp->Flags & IRP_DEALLOCATE_BUFFER)?"DEALLOC_BUF":"",
400             (irp->Flags & IRP_INPUT_OPERATION)?"INPUT_OP":"",
401             (irp->Flags & IRP_SYNCHRONOUS_PAGING_IO)?"SYNC_PAGIN_IO":"",
402             (irp->Flags & IRP_CREATE_OPERATION)?"CREATE_OP":"",
403             (irp->Flags & IRP_READ_OPERATION)?"READ_OP":"",
404             (irp->Flags & IRP_WRITE_OPERATION)?"WRITE_OP":"",
405             (irp->Flags & IRP_CLOSE_OPERATION)?"CLOSE_OP":"",
406             (irp->Flags & IRP_DEFER_IO_COMPLETION)?"DEFER_IO":"");
407 }
408 
print_irps_flags(int on,PIO_STACK_LOCATION irps)409 void print_irps_flags(int on, PIO_STACK_LOCATION irps)
410 {
411     if (!on) return;
412     if (irps->Flags)
413         DbgP("IRPSP FLAGS 0x%x %s %s %s %s\n", irps->Flags,
414             (irps->Flags & SL_CASE_SENSITIVE)?"CASE_SENSITIVE":"",
415             (irps->Flags & SL_OPEN_PAGING_FILE)?"PAGING_FILE":"",
416             (irps->Flags & SL_FORCE_ACCESS_CHECK)?"ACCESS_CHECK":"",
417             (irps->Flags & SL_OPEN_TARGET_DIRECTORY)?"TARGET_DIR":"");
418 }
print_nt_create_params(int on,NT_CREATE_PARAMETERS params)419 void print_nt_create_params(int on, NT_CREATE_PARAMETERS params)
420 {
421     if (!on) return;
422     if (params.FileAttributes)
423         DbgP("File attributes %x: %s %s %s %s %s %s %s %s %s %s %s %s %s %s\n",
424             params.FileAttributes,
425             (params.FileAttributes & FILE_ATTRIBUTE_TEMPORARY)?"TEMPFILE ":"",
426             (params.FileAttributes & FILE_ATTRIBUTE_READONLY)?"READONLY ":"",
427             (params.FileAttributes & FILE_ATTRIBUTE_HIDDEN)?"HIDDEN ":"",
428             (params.FileAttributes & FILE_ATTRIBUTE_SYSTEM)?"SYSTEM ":"",
429             (params.FileAttributes & FILE_ATTRIBUTE_ARCHIVE)?"ARCHIVE ":"",
430             (params.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)?"DIR ":"",
431             (params.FileAttributes & FILE_ATTRIBUTE_DEVICE)?"DEVICE ":"",
432             (params.FileAttributes & FILE_ATTRIBUTE_NORMAL)?"NORMAL ":"",
433             (params.FileAttributes & FILE_ATTRIBUTE_SPARSE_FILE)?"SPARSE_FILE ":"",
434             (params.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)?"REPARSE_POINT ":"",
435             (params.FileAttributes & FILE_ATTRIBUTE_COMPRESSED)?"COMPRESSED ":"",
436             (params.FileAttributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED)?"NOT INDEXED ":"",
437             (params.FileAttributes & FILE_ATTRIBUTE_ENCRYPTED)?"ENCRYPTED ":"",
438             (params.FileAttributes & FILE_ATTRIBUTE_VIRTUAL)?"VIRTUAL":"");
439 
440     if (params.Disposition  == FILE_SUPERSEDE)
441         DbgP("Create Dispositions: FILE_SUPERSEDE\n");
442     if (params.Disposition == FILE_CREATE)
443         DbgP("Create Dispositions: FILE_CREATE\n");
444     if (params.Disposition == FILE_OPEN)
445         DbgP("Create Dispositions: FILE_OPEN\n");
446     if (params.Disposition == FILE_OPEN_IF)
447         DbgP("Create Dispositions: FILE_OPEN_IF\n");
448     if (params.Disposition == FILE_OVERWRITE)
449         DbgP("Create Dispositions: FILE_OVERWRITE\n");
450     if (params.Disposition == FILE_OVERWRITE_IF)
451         DbgP("Create Dispositions: FILE_OVERWRITE_IF\n");
452 
453     DbgP("Create Attributes: 0x%x %s %s %s %s %s %s %s %s %s %s %s %s %s %s "
454         "%s %s\n", params.CreateOptions,
455         (params.CreateOptions & FILE_DIRECTORY_FILE)?"DIRFILE":"",
456         (params.CreateOptions & FILE_NON_DIRECTORY_FILE)?"FILE":"",
457         (params.CreateOptions & FILE_DELETE_ON_CLOSE)?"DELETE_ON_CLOSE":"",
458         (params.CreateOptions & FILE_WRITE_THROUGH)?"WRITE_THROUGH":"",
459         (params.CreateOptions & FILE_SEQUENTIAL_ONLY)?"SEQUENTIAL":"",
460         (params.CreateOptions & FILE_RANDOM_ACCESS)?"RANDOM":"",
461         (params.CreateOptions & FILE_NO_INTERMEDIATE_BUFFERING)?"NO_BUFFERING":"",
462         (params.CreateOptions & FILE_SYNCHRONOUS_IO_ALERT)?"SYNC_ALERT":"",
463         (params.CreateOptions & FILE_SYNCHRONOUS_IO_NONALERT)?"SYNC_NOALERT":"",
464         (params.CreateOptions & FILE_CREATE_TREE_CONNECTION)?"CREATE_TREE_CONN":"",
465         (params.CreateOptions & FILE_COMPLETE_IF_OPLOCKED)?"OPLOCKED":"",
466         (params.CreateOptions & FILE_NO_EA_KNOWLEDGE)?"NO_EA":"",
467         (params.CreateOptions & FILE_OPEN_REPARSE_POINT)?"OPEN_REPARSE":"",
468         (params.CreateOptions & FILE_OPEN_BY_FILE_ID)?"BY_ID":"",
469         (params.CreateOptions & FILE_OPEN_FOR_BACKUP_INTENT)?"4_BACKUP":"",
470         (params.CreateOptions & FILE_RESERVE_OPFILTER)?"OPFILTER":"");
471 
472     DbgP("Share Access: %s %s %s\n",
473         (params.ShareAccess & FILE_SHARE_READ)?"READ":"",
474         (params.ShareAccess & FILE_SHARE_WRITE)?"WRITE":"",
475         (params.ShareAccess & FILE_SHARE_DELETE)?"DELETE":"");
476 
477     DbgP("Desired Access: 0x%x %s %s %s %s %s %s %s %s %s %s %s\n",
478         params.DesiredAccess,
479         (params.DesiredAccess & FILE_READ_DATA)?"READ":"",
480         (params.DesiredAccess & STANDARD_RIGHTS_READ)?"READ_ACL":"",
481         (params.DesiredAccess & FILE_READ_ATTRIBUTES)?"GETATTR":"",
482         (params.DesiredAccess & FILE_READ_EA)?"READ_EA":"",
483         (params.DesiredAccess & FILE_WRITE_DATA)?"WRITE":"",
484         (params.DesiredAccess & FILE_WRITE_ATTRIBUTES)?"SETATTR":"",
485         (params.DesiredAccess & FILE_WRITE_EA)?"WRITE_EA":"",
486         (params.DesiredAccess & FILE_APPEND_DATA)?"APPEND":"",
487         (params.DesiredAccess & FILE_EXECUTE)?"EXEC":"",
488         (params.DesiredAccess & FILE_LIST_DIRECTORY)?"LSDIR":"",
489         (params.DesiredAccess & FILE_TRAVERSE)?"TRAVERSE":"",
490         (params.DesiredAccess & FILE_LIST_DIRECTORY)?"LSDIR":"",
491         (params.DesiredAccess & DELETE)?"DELETE":"",
492         (params.DesiredAccess & READ_CONTROL)?"READ_CONTROL":"",
493         (params.DesiredAccess & WRITE_DAC)?"WRITE_DAC":"",
494         (params.DesiredAccess & WRITE_OWNER)?"WRITE_OWNER":"",
495         (params.DesiredAccess & SYNCHRONIZE)?"SYNCHRONIZE":"");
496 }
497 
print_file_information_class(int InfoClass)498 unsigned char * print_file_information_class(int InfoClass)
499 {
500     switch(InfoClass) {
501         case FileBothDirectoryInformation:
502             return (unsigned char *)"FileBothDirectoryInformation";
503         case FileDirectoryInformation:
504             return (unsigned char *)"FileDirectoryInformation";
505         case FileFullDirectoryInformation:
506             return (unsigned char *)"FileFullDirectoryInformation";
507         case FileIdBothDirectoryInformation:
508             return (unsigned char *)"FileIdBothDirectoryInformation";
509         case FileIdFullDirectoryInformation:
510             return (unsigned char *)"FileIdFullDirectoryInformation";
511         case FileNamesInformation:
512             return (unsigned char *)"FileNamesInformation";
513         case FileObjectIdInformation:
514             return (unsigned char *)"FileObjectIdInformation";
515         case FileQuotaInformation:
516             return (unsigned char *)"FileQuotaInformation";
517         case FileReparsePointInformation:
518             return (unsigned char *)"FileReparsePointInformation";
519         case FileAllInformation:
520             return (unsigned char *)"FileAllInformation";
521         case FileAttributeTagInformation:
522             return (unsigned char *)"FileAttributeTagInformation";
523         case FileBasicInformation:
524             return (unsigned char *)"FileBasicInformation";
525         case FileCompressionInformation:
526             return (unsigned char *)"FileCompressionInformation";
527         case FileEaInformation:
528             return (unsigned char *)"FileEaInformation";
529         case FileInternalInformation:
530             return (unsigned char *)"FileInternalInformation";
531         case FileNameInformation:
532             return (unsigned char *)"FileNameInformation";
533         case FileNetworkOpenInformation:
534             return (unsigned char *)"FileNetworkOpenInformation";
535         case FilePositionInformation:
536             return (unsigned char *)"FilePositionInformation";
537         case FileStandardInformation:
538             return (unsigned char *)"FileStandardInformation";
539         case FileStreamInformation:
540             return (unsigned char *)"FileStreamInformation";
541         case FileAllocationInformation:
542             return (unsigned char *)"FileAllocationInformation";
543         case FileDispositionInformation:
544             return (unsigned char *)"FileDispositionInformation";
545         case FileEndOfFileInformation:
546             return (unsigned char *)"FileEndOfFileInformation";
547         case FileLinkInformation:
548             return (unsigned char *)"FileLinkInformation";
549         case FileRenameInformation:
550             return (unsigned char *)"FileRenameInformation";
551         case FileValidDataLengthInformation:
552             return (unsigned char *)"FileValidDataLengthInformation";
553         default:
554             return (unsigned char *)"UNKNOWN";
555     }
556 }
557 
print_fs_information_class(int InfoClass)558 unsigned char *print_fs_information_class(int InfoClass)
559 {
560     switch (InfoClass) {
561         case FileFsAttributeInformation:
562             return (unsigned char *)"FileFsAttributeInformation";
563         case FileFsControlInformation:
564             return (unsigned char *)"FileFsControlInformation";
565         case FileFsDeviceInformation:
566             return (unsigned char *)"FileFsDeviceInformation";
567         case FileFsDriverPathInformation:
568             return (unsigned char *)"FileFsDriverPathInformation";
569         case FileFsFullSizeInformation:
570             return (unsigned char *)"FileFsFullSizeInformation";
571         case FileFsObjectIdInformation:
572             return (unsigned char *)"FileFsObjectIdInformation";
573         case FileFsSizeInformation:
574             return (unsigned char *)"FileFsSizeInformation";
575         case FileFsVolumeInformation:
576             return (unsigned char *)"FileFsVolumeInformation";
577         default:
578             return (unsigned char *)"UNKNOWN";
579     }
580 }
581 
print_caching_level(int on,ULONG flag,PUNICODE_STRING name)582 void print_caching_level(int on, ULONG flag, PUNICODE_STRING name)
583 {
584     if (!on) return;
585     switch(flag) {
586         case 0:
587             DbgP("enable_caching: DISABLE_CACHING %wZ\n", name);
588             break;
589         case 1:
590             DbgP("enable_caching: ENABLE_READ_CACHING %wZ\n", name);
591             break;
592         case 2:
593             DbgP("enable_caching: ENABLE_WRITE_CACHING %wZ\n", name);
594             break;
595         case 3:
596             DbgP("enable_caching: ENABLE_READWRITE_CACHING %wZ\n", name);
597             break;
598     }
599 }
600 
opcode2string(int opcode)601 const char *opcode2string(int opcode)
602 {
603     switch(opcode) {
604     case NFS41_SHUTDOWN: return "NFS41_SHUTDOWN";
605     case NFS41_MOUNT: return "NFS41_MOUNT";
606     case NFS41_UNMOUNT: return "NFS41_UNMOUNT";
607     case NFS41_OPEN: return "NFS41_OPEN";
608     case NFS41_CLOSE: return "NFS41_CLOSE";
609     case NFS41_READ: return "NFS41_READ";
610     case NFS41_WRITE: return "NFS41_WRITE";
611     case NFS41_LOCK: return "NFS41_LOCK";
612     case NFS41_UNLOCK: return "NFS41_UNLOCK";
613     case NFS41_DIR_QUERY: return "NFS41_DIR_QUERY";
614     case NFS41_FILE_QUERY: return "NFS41_FILE_QUERY";
615     case NFS41_FILE_SET: return "NFS41_FILE_SET";
616     case NFS41_EA_SET: return "NFS41_EA_SET";
617     case NFS41_EA_GET: return "NFS41_EA_GET";
618     case NFS41_SYMLINK: return "NFS41_SYMLINK";
619     case NFS41_VOLUME_QUERY: return "NFS41_VOLUME_QUERY";
620     case NFS41_ACL_QUERY: return "NFS41_ACL_QUERY";
621     case NFS41_ACL_SET: return "NFS41_ACL_SET";
622     default: return "UNKNOWN";
623     }
624 }
625 
print_acl_args(SECURITY_INFORMATION info)626 void print_acl_args(
627     SECURITY_INFORMATION info)
628 {
629     DbgP("Security query: %s %s %s\n",
630         (info & OWNER_SECURITY_INFORMATION)?"OWNER":"",
631         (info & GROUP_SECURITY_INFORMATION)?"GROUP":"",
632         (info & DACL_SECURITY_INFORMATION)?"DACL":"",
633         (info & SACL_SECURITY_INFORMATION)?"SACL":"");
634 }
635 
print_open_error(int on,int status)636 void print_open_error(int on, int status)
637 {
638     if (!on) return;
639     switch (status) {
640     case STATUS_ACCESS_DENIED:
641         DbgP("[ERROR] nfs41_Create: STATUS_ACCESS_DENIED\n");
642         break;
643     case STATUS_NETWORK_ACCESS_DENIED:
644         DbgP("[ERROR] nfs41_Create: STATUS_NETWORK_ACCESS_DENIED\n");
645         break;
646     case STATUS_OBJECT_NAME_INVALID:
647         DbgP("[ERROR] nfs41_Create: STATUS_OBJECT_NAME_INVALID\n");
648         break;
649     case STATUS_OBJECT_NAME_COLLISION:
650         DbgP("[ERROR] nfs41_Create: STATUS_OBJECT_NAME_COLLISION\n");
651         break;
652     case STATUS_FILE_INVALID:
653         DbgP("[ERROR] nfs41_Create: STATUS_FILE_INVALID\n");
654         break;
655     case STATUS_OBJECT_NAME_NOT_FOUND:
656         DbgP("[ERROR] nfs41_Create: STATUS_OBJECT_NAME_NOT_FOUND\n");
657         break;
658     case STATUS_NAME_TOO_LONG:
659         DbgP("[ERROR] nfs41_Create: STATUS_NAME_TOO_LONG\n");
660         break;
661     case STATUS_OBJECT_PATH_NOT_FOUND:
662         DbgP("[ERROR] nfs41_Create: STATUS_OBJECT_PATH_NOT_FOUND\n");
663         break;
664     case STATUS_BAD_NETWORK_PATH:
665         DbgP("[ERROR] nfs41_Create: STATUS_BAD_NETWORK_PATH\n");
666         break;
667     case STATUS_SHARING_VIOLATION:
668         DbgP("[ERROR] nfs41_Create: STATUS_SHARING_VIOLATION\n");
669         break;
670     case ERROR_REPARSE:
671         DbgP("[ERROR] nfs41_Create: STATUS_REPARSE\n");
672         break;
673     case ERROR_TOO_MANY_LINKS:
674         DbgP("[ERROR] nfs41_Create: STATUS_TOO_MANY_LINKS\n");
675         break;
676     case ERROR_DIRECTORY:
677         DbgP("[ERROR] nfs41_Create: STATUS_FILE_IS_A_DIRECTORY\n");
678         break;
679     case ERROR_BAD_FILE_TYPE:
680         DbgP("[ERROR] nfs41_Create: STATUS_NOT_A_DIRECTORY\n");
681         break;
682     default:
683         DbgP("[ERROR] nfs41_Create: STATUS_INSUFFICIENT_RESOURCES\n");
684         break;
685     }
686 }
687 
print_wait_status(int on,const char * prefix,NTSTATUS status,const char * opcode,PVOID entry,LONGLONG xid)688 void print_wait_status(int on, const char *prefix, NTSTATUS status,
689                        const char *opcode, PVOID entry, LONGLONG xid)
690 {
691     if (!on) return;
692     switch (status) {
693     case STATUS_SUCCESS:
694         if (opcode)
695             DbgP("%s Got a wakeup call, finishing %s entry=%p xid=%lld\n",
696                 prefix, opcode, entry, xid);
697         else
698             DbgP("%s Got a wakeup call\n", prefix);
699         break;
700     case STATUS_USER_APC:
701         DbgP("%s KeWaitForSingleObject returned STATUS_USER_APC\n", prefix);
702         break;
703     case STATUS_ALERTED:
704         DbgP("%s KeWaitForSingleObject returned STATUS_ALERTED\n", prefix);
705         break;
706     default:
707         DbgP("%s KeWaitForSingleObject returned %d\n", prefix, status);
708     }
709 }
710 /* This is taken from toaster/func.  Rumor says this should be replaced
711  * with a WMI interface???
712  */
713 ULONG
dprintk(IN PCHAR func,IN ULONG flags,IN PCHAR format,...)714 dprintk(
715     IN PCHAR func,
716     IN ULONG flags,
717     IN PCHAR format,
718     ...)
719 {
720     #define     TEMP_BUFFER_SIZE        1024
721     va_list    list;
722     CHAR      debugMessageBuffer[TEMP_BUFFER_SIZE];
723     NTSTATUS status, rv = STATUS_SUCCESS;
724 
725     va_start(list, format);
726 
727     if (format)
728     {
729         //
730         // Use the safe string function, RtlStringCbVPrintfA, instead of _vsnprintf.
731         // RtlStringCbVPrintfA NULL terminates the output buffer even if the message
732         // is longer than the buffer. This prevents malicious code from compromising
733         // the security of the system.
734         //
735         status = RtlStringCbVPrintfA(debugMessageBuffer, sizeof(debugMessageBuffer),
736                                     format, list);
737 
738         if (!NT_SUCCESS(status))
739             rv = DbgPrintEx(PNFS_FLTR_ID, DPFLTR_MASK | flags,
740                             "RtlStringCbVPrintfA failed %x \n", status);
741         else
742             rv = DbgPrintEx(PNFS_FLTR_ID, DPFLTR_MASK | flags, "%s    %s: %s\n",
743                     PNFS_TRACE_TAG, func, debugMessageBuffer);
744     }
745     va_end(list);
746 
747     return rv;
748 }
749 
750