1 /* NFSv4.1 client for Windows
2 * Copyright © 2012 The Regents of the University of Michigan
4 * Olga Kornievskaia <aglo@umich.edu>
5 * Casey Bodley <cbodley@umich.edu>
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.
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.
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
25 #include "daemon_debug.h"
26 #include "from_kernel.h"
27 #include "nfs41_driver.h"
28 #include "nfs41_ops.h"
31 #include "rpc/auth_sspi.h"
33 static int g_debug_level
= DEFAULT_DEBUG_LEVEL
;
35 void set_debug_level(int level
) { g_debug_level
= level
; }
37 FILE *dlog_file
, *elog_file
;
39 #ifndef STANDALONE_NFSD
42 const char dfile
[] = "nfsddbg.log";
43 const char efile
[] = "nfsderr.log";
44 const char mode
[] = "w";
45 if (g_debug_level
> 0) {
46 dlog_file
= fopen(dfile
, mode
);
47 if (dlog_file
== NULL
) {
48 ReportStatusToSCMgr(SERVICE_STOPPED
, GetLastError(), 0);
49 exit (GetLastError());
52 elog_file
= fopen(efile
, mode
);
53 if (elog_file
== NULL
) {
54 ReportStatusToSCMgr(SERVICE_STOPPED
, GetLastError(), 0);
55 exit (GetLastError());
59 void close_log_files()
61 if (dlog_file
) fclose(dlog_file
);
62 if (elog_file
) fclose(elog_file
);
72 void dprintf(int level
, LPCSTR format
, ...)
74 if (level
<= g_debug_level
) {
76 va_start(args
, format
);
77 fprintf(dlog_file
, "%04x: ", GetCurrentThreadId());
78 vfprintf(dlog_file
, format
, args
);
79 #ifndef STANDALONE_NFSD
86 void eprintf(LPCSTR format
, ...)
89 va_start(args
, format
);
90 fprintf(elog_file
, "%04x: ", GetCurrentThreadId());
91 vfprintf(elog_file
, format
, args
);
92 #ifndef STANDALONE_NFSD
98 void print_hexbuf(int level
, unsigned char *title
, unsigned char *buf
, int len
)
101 if (level
> g_debug_level
) return;
102 fprintf(dlog_file
, "%s", title
);
103 for(j
= 0, k
= 0; j
< len
; j
++, k
++) {
104 fprintf(dlog_file
, "%02x '%c' ", buf
[j
], isascii(buf
[j
])? buf
[j
]:' ');
105 if (((k
+1) % 10 == 0 && k
> 0)) {
106 fprintf(dlog_file
, "\n");
109 fprintf(dlog_file
, "\n");
112 void print_hexbuf_no_asci(int level
, unsigned char *title
, unsigned char *buf
, int len
)
115 if (level
> g_debug_level
) return;
116 fprintf(dlog_file
, "%s", title
);
117 for(j
= 0, k
= 0; j
< len
; j
++, k
++) {
118 fprintf(dlog_file
, "%02x ", buf
[j
]);
119 if (((k
+1) % 10 == 0 && k
> 0)) {
120 fprintf(dlog_file
, "\n");
123 fprintf(dlog_file
, "\n");
126 void print_create_attributes(int level
, DWORD create_opts
) {
127 if (level
> g_debug_level
) return;
128 fprintf(dlog_file
, "create attributes: ");
129 if (create_opts
& FILE_DIRECTORY_FILE
)
130 fprintf(dlog_file
, "DIRECTORY_FILE ");
131 if (create_opts
& FILE_NON_DIRECTORY_FILE
)
132 fprintf(dlog_file
, "NON_DIRECTORY_FILE ");
133 if (create_opts
& FILE_WRITE_THROUGH
)
134 fprintf(dlog_file
, "WRITE_THROUGH ");
135 if (create_opts
& FILE_SEQUENTIAL_ONLY
)
136 fprintf(dlog_file
, "SEQUENTIAL_ONLY ");
137 if (create_opts
& FILE_RANDOM_ACCESS
)
138 fprintf(dlog_file
, "RANDOM_ACCESS ");
139 if (create_opts
& FILE_NO_INTERMEDIATE_BUFFERING
)
140 fprintf(dlog_file
, "NO_INTERMEDIATE_BUFFERING ");
141 if (create_opts
& FILE_SYNCHRONOUS_IO_ALERT
)
142 fprintf(dlog_file
, "SYNCHRONOUS_IO_ALERT ");
143 if (create_opts
& FILE_SYNCHRONOUS_IO_NONALERT
)
144 fprintf(dlog_file
, "SYNCHRONOUS_IO_NONALERT ");
145 if (create_opts
& FILE_CREATE_TREE_CONNECTION
)
146 fprintf(dlog_file
, "CREATE_TREE_CONNECTION ");
147 if (create_opts
& FILE_COMPLETE_IF_OPLOCKED
)
148 fprintf(dlog_file
, "COMPLETE_IF_OPLOCKED ");
149 if (create_opts
& FILE_NO_EA_KNOWLEDGE
)
150 fprintf(dlog_file
, "NO_EA_KNOWLEDGE ");
151 if (create_opts
& FILE_OPEN_REPARSE_POINT
)
152 fprintf(dlog_file
, "OPEN_REPARSE_POINT ");
153 if (create_opts
& FILE_DELETE_ON_CLOSE
)
154 fprintf(dlog_file
, "DELETE_ON_CLOSE ");
155 if (create_opts
& FILE_OPEN_BY_FILE_ID
)
156 fprintf(dlog_file
, "OPEN_BY_FILE_ID ");
157 if (create_opts
& FILE_OPEN_FOR_BACKUP_INTENT
)
158 fprintf(dlog_file
, "OPEN_FOR_BACKUP_INTENT ");
159 if (create_opts
& FILE_RESERVE_OPFILTER
)
160 fprintf(dlog_file
, "RESERVE_OPFILTER");
161 fprintf(dlog_file
, "\n");
164 void print_disposition(int level
, DWORD disposition
) {
165 if (level
> g_debug_level
) return;
166 fprintf(dlog_file
, "userland disposition = ");
167 if (disposition
== FILE_SUPERSEDE
)
168 fprintf(dlog_file
, "FILE_SUPERSEDE\n");
169 else if (disposition
== FILE_CREATE
)
170 fprintf(dlog_file
, "FILE_CREATE\n");
171 else if (disposition
== FILE_OPEN
)
172 fprintf(dlog_file
, "FILE_OPEN\n");
173 else if (disposition
== FILE_OPEN_IF
)
174 fprintf(dlog_file
, "FILE_OPEN_IF\n");
175 else if (disposition
== FILE_OVERWRITE
)
176 fprintf(dlog_file
, "FILE_OVERWRITE\n");
177 else if (disposition
== FILE_OVERWRITE_IF
)
178 fprintf(dlog_file
, "FILE_OVERWRITE_IF\n");
181 void print_access_mask(int level
, DWORD access_mask
) {
182 if (level
> g_debug_level
) return;
183 fprintf(dlog_file
, "access mask: ");
184 if (access_mask
& FILE_READ_DATA
)
185 fprintf(dlog_file
, "READ ");
186 if (access_mask
& STANDARD_RIGHTS_READ
)
187 fprintf(dlog_file
, "READ_ACL ");
188 if (access_mask
& FILE_READ_ATTRIBUTES
)
189 fprintf(dlog_file
, "READ_ATTR ");
190 if (access_mask
& FILE_READ_EA
)
191 fprintf(dlog_file
, "READ_EA ");
192 if (access_mask
& FILE_WRITE_DATA
)
193 fprintf(dlog_file
, "WRITE ");
194 if (access_mask
& STANDARD_RIGHTS_WRITE
)
195 fprintf(dlog_file
, "WRITE_ACL ");
196 if (access_mask
& FILE_WRITE_ATTRIBUTES
)
197 fprintf(dlog_file
, "WRITE_ATTR ");
198 if (access_mask
& FILE_WRITE_EA
)
199 fprintf(dlog_file
, "WRITE_EA ");
200 if (access_mask
& FILE_APPEND_DATA
)
201 fprintf(dlog_file
, "APPEND ");
202 if (access_mask
& FILE_EXECUTE
)
203 fprintf(dlog_file
, "EXECUTE ");
204 if (access_mask
& FILE_LIST_DIRECTORY
)
205 fprintf(dlog_file
, "LIST ");
206 if (access_mask
& FILE_TRAVERSE
)
207 fprintf(dlog_file
, "TRAVERSE ");
208 if (access_mask
& SYNCHRONIZE
)
209 fprintf(dlog_file
, "SYNC ");
210 if (access_mask
& FILE_DELETE_CHILD
)
211 fprintf(dlog_file
, "DELETE_CHILD");
212 fprintf(dlog_file
, "\n");
215 void print_share_mode(int level
, DWORD mode
)
217 if (level
> g_debug_level
) return;
218 fprintf(dlog_file
, "share mode: ");
219 if (mode
& FILE_SHARE_READ
)
220 fprintf(dlog_file
, "READ ");
221 if (mode
& FILE_SHARE_WRITE
)
222 fprintf(dlog_file
, "WRITE ");
223 if (mode
& FILE_SHARE_DELETE
)
224 fprintf(dlog_file
, "DELETE");
225 fprintf(dlog_file
, "\n");
228 void print_file_id_both_dir_info(int level
, FILE_ID_BOTH_DIR_INFO
*pboth_dir_info
)
230 if (level
> g_debug_level
) return;
231 fprintf(dlog_file
, "FILE_ID_BOTH_DIR_INFO %p %d\n",
232 pboth_dir_info
, sizeof(unsigned char *));
233 fprintf(dlog_file
, "\tNextEntryOffset=%ld %d %d\n",
234 pboth_dir_info
->NextEntryOffset
,
235 sizeof(pboth_dir_info
->NextEntryOffset
), sizeof(DWORD
));
236 fprintf(dlog_file
, "\tFileIndex=%ld %d\n", pboth_dir_info
->FileIndex
,
237 sizeof(pboth_dir_info
->FileIndex
));
238 fprintf(dlog_file
, "\tCreationTime=0x%x %d\n",
239 pboth_dir_info
->CreationTime
.QuadPart
,
240 sizeof(pboth_dir_info
->CreationTime
));
241 fprintf(dlog_file
, "\tLastAccessTime=0x%x %d\n",
242 pboth_dir_info
->LastAccessTime
.QuadPart
,
243 sizeof(pboth_dir_info
->LastAccessTime
));
244 fprintf(dlog_file
, "\tLastWriteTime=0x%x %d\n",
245 pboth_dir_info
->LastWriteTime
.QuadPart
,
246 sizeof(pboth_dir_info
->LastWriteTime
));
247 fprintf(dlog_file
, "\tChangeTime=0x%x %d\n",
248 pboth_dir_info
->ChangeTime
.QuadPart
,
249 sizeof(pboth_dir_info
->ChangeTime
));
250 fprintf(dlog_file
, "\tEndOfFile=0x%x %d\n",
251 pboth_dir_info
->EndOfFile
.QuadPart
,
252 sizeof(pboth_dir_info
->EndOfFile
));
253 fprintf(dlog_file
, "\tAllocationSize=0x%x %d\n",
254 pboth_dir_info
->AllocationSize
.QuadPart
,
255 sizeof(pboth_dir_info
->AllocationSize
));
256 fprintf(dlog_file
, "\tFileAttributes=%ld %d\n",
257 pboth_dir_info
->FileAttributes
,
258 sizeof(pboth_dir_info
->FileAttributes
));
259 fprintf(dlog_file
, "\tFileNameLength=%ld %d\n",
260 pboth_dir_info
->FileNameLength
,
261 sizeof(pboth_dir_info
->FileNameLength
));
262 fprintf(dlog_file
, "\tEaSize=%ld %d\n",
263 pboth_dir_info
->EaSize
, sizeof(pboth_dir_info
->EaSize
));
264 fprintf(dlog_file
, "\tShortNameLength=%d %d\n",
265 pboth_dir_info
->ShortNameLength
,
266 sizeof(pboth_dir_info
->ShortNameLength
));
267 fprintf(dlog_file
, "\tShortName='%S' %d\n", pboth_dir_info
->ShortName
,
268 sizeof(pboth_dir_info
->ShortName
));
269 fprintf(dlog_file
, "\tFileId=0x%x %d\n", pboth_dir_info
->FileId
.QuadPart
,
270 sizeof(pboth_dir_info
->FileId
));
271 fprintf(dlog_file
, "\tFileName='%S' %p\n", pboth_dir_info
->FileName
,
272 pboth_dir_info
->FileName
);
275 void print_opcode(int level
, DWORD opcode
)
277 dprintf(level
, (LPCSTR
)opcode2string(opcode
));
280 const char* opcode2string(DWORD opcode
)
283 case NFS41_SHUTDOWN
: return "NFS41_SHUTDOWN";
284 case NFS41_MOUNT
: return "NFS41_MOUNT";
285 case NFS41_UNMOUNT
: return "NFS41_UNMOUNT";
286 case NFS41_OPEN
: return "NFS41_OPEN";
287 case NFS41_CLOSE
: return "NFS41_CLOSE";
288 case NFS41_READ
: return "NFS41_READ";
289 case NFS41_WRITE
: return "NFS41_WRITE";
290 case NFS41_LOCK
: return "NFS41_LOCK";
291 case NFS41_UNLOCK
: return "NFS41_UNLOCK";
292 case NFS41_DIR_QUERY
: return "NFS41_DIR_QUERY";
293 case NFS41_FILE_QUERY
: return "NFS41_FILE_QUERY";
294 case NFS41_FILE_SET
: return "NFS41_FILE_SET";
295 case NFS41_EA_SET
: return "NFS41_EA_SET";
296 case NFS41_EA_GET
: return "NFS41_EA_GET";
297 case NFS41_SYMLINK
: return "NFS41_SYMLINK";
298 case NFS41_VOLUME_QUERY
: return "NFS41_VOLUME_QUERY";
299 case NFS41_ACL_QUERY
: return "NFS41_ACL_QUERY";
300 case NFS41_ACL_SET
: return "NFS41_ACL_SET";
301 default: return "UNKNOWN";
305 const char* nfs_opnum_to_string(int opnum
)
309 case OP_ACCESS
: return "ACCESS";
310 case OP_CLOSE
: return "CLOSE";
311 case OP_COMMIT
: return "COMMIT";
312 case OP_CREATE
: return "CREATE";
313 case OP_DELEGPURGE
: return "DELEGPURGE";
314 case OP_DELEGRETURN
: return "DELEGRETURN";
315 case OP_GETATTR
: return "GETATTR";
316 case OP_GETFH
: return "GETFH";
317 case OP_LINK
: return "LINK";
318 case OP_LOCK
: return "LOCK";
319 case OP_LOCKT
: return "LOCKT";
320 case OP_LOCKU
: return "LOCKU";
321 case OP_LOOKUP
: return "LOOKUP";
322 case OP_LOOKUPP
: return "LOOKUPP";
323 case OP_NVERIFY
: return "NVERIFY";
324 case OP_OPEN
: return "OPEN";
325 case OP_OPENATTR
: return "OPENATTR";
326 case OP_OPEN_CONFIRM
: return "OPEN_CONFIRM";
327 case OP_OPEN_DOWNGRADE
: return "OPEN_DOWNGRADE";
328 case OP_PUTFH
: return "PUTFH";
329 case OP_PUTPUBFH
: return "PUTPUBFH";
330 case OP_PUTROOTFH
: return "PUTROOTFH";
331 case OP_READ
: return "READ";
332 case OP_READDIR
: return "READDIR";
333 case OP_READLINK
: return "READLINK";
334 case OP_REMOVE
: return "REMOVE";
335 case OP_RENAME
: return "RENAME";
336 case OP_RENEW
: return "RENEW";
337 case OP_RESTOREFH
: return "RESTOREFH";
338 case OP_SAVEFH
: return "SAVEFH";
339 case OP_SECINFO
: return "SECINFO";
340 case OP_SETATTR
: return "SETATTR";
341 case OP_SETCLIENTID
: return "SETCLIENTID";
342 case OP_SETCLIENTID_CONFIRM
: return "SETCLIENTID_CONFIRM";
343 case OP_VERIFY
: return "VERIFY";
344 case OP_WRITE
: return "WRITE";
345 case OP_RELEASE_LOCKOWNER
: return "RELEASE_LOCKOWNER";
346 case OP_BACKCHANNEL_CTL
: return "BACKCHANNEL_CTL";
347 case OP_BIND_CONN_TO_SESSION
: return "BIND_CONN_TO_SESSION";
348 case OP_EXCHANGE_ID
: return "EXCHANGE_ID";
349 case OP_CREATE_SESSION
: return "CREATE_SESSION";
350 case OP_DESTROY_SESSION
: return "DESTROY_SESSION";
351 case OP_FREE_STATEID
: return "FREE_STATEID";
352 case OP_GET_DIR_DELEGATION
: return "GET_DIR_DELEGATION";
353 case OP_GETDEVICEINFO
: return "GETDEVICEINFO";
354 case OP_GETDEVICELIST
: return "GETDEVICELIST";
355 case OP_LAYOUTCOMMIT
: return "LAYOUTCOMMIT";
356 case OP_LAYOUTGET
: return "LAYOUTGET";
357 case OP_LAYOUTRETURN
: return "LAYOUTRETURN";
358 case OP_SECINFO_NO_NAME
: return "SECINFO_NO_NAME";
359 case OP_SEQUENCE
: return "SEQUENCE";
360 case OP_SET_SSV
: return "SET_SSV";
361 case OP_TEST_STATEID
: return "TEST_STATEID";
362 case OP_WANT_DELEGATION
: return "WANT_DELEGATION";
363 case OP_DESTROY_CLIENTID
: return "DESTROY_CLIENTID";
364 case OP_RECLAIM_COMPLETE
: return "RECLAIM_COMPLETE";
365 case OP_ILLEGAL
: return "ILLEGAL";
366 default: return "invalid nfs opnum";
370 const char* nfs_error_string(int status
)
374 case NFS4_OK
: return "NFS4_OK";
375 case NFS4ERR_PERM
: return "NFS4ERR_PERM";
376 case NFS4ERR_NOENT
: return "NFS4ERR_NOENT";
377 case NFS4ERR_IO
: return "NFS4ERR_IO";
378 case NFS4ERR_NXIO
: return "NFS4ERR_NXIO";
379 case NFS4ERR_ACCESS
: return "NFS4ERR_ACCESS";
380 case NFS4ERR_EXIST
: return "NFS4ERR_EXIST";
381 case NFS4ERR_XDEV
: return "NFS4ERR_XDEV";
382 case NFS4ERR_NOTDIR
: return "NFS4ERR_NOTDIR";
383 case NFS4ERR_ISDIR
: return "NFS4ERR_ISDIR";
384 case NFS4ERR_INVAL
: return "NFS4ERR_INVAL";
385 case NFS4ERR_FBIG
: return "NFS4ERR_FBIG";
386 case NFS4ERR_NOSPC
: return "NFS4ERR_NOSPC";
387 case NFS4ERR_ROFS
: return "NFS4ERR_ROFS";
388 case NFS4ERR_MLINK
: return "NFS4ERR_MLINK";
389 case NFS4ERR_NAMETOOLONG
: return "NFS4ERR_NAMETOOLONG";
390 case NFS4ERR_NOTEMPTY
: return "NFS4ERR_NOTEMPTY";
391 case NFS4ERR_DQUOT
: return "NFS4ERR_DQUOT";
392 case NFS4ERR_STALE
: return "NFS4ERR_STALE";
393 case NFS4ERR_BADHANDLE
: return "NFS4ERR_BADHANDLE";
394 case NFS4ERR_BAD_COOKIE
: return "NFS4ERR_BAD_COOKIE";
395 case NFS4ERR_NOTSUPP
: return "NFS4ERR_NOTSUPP";
396 case NFS4ERR_TOOSMALL
: return "NFS4ERR_TOOSMALL";
397 case NFS4ERR_SERVERFAULT
: return "NFS4ERR_SERVERFAULT";
398 case NFS4ERR_BADTYPE
: return "NFS4ERR_BADTYPE";
399 case NFS4ERR_DELAY
: return "NFS4ERR_DELAY";
400 case NFS4ERR_SAME
: return "NFS4ERR_SAME";
401 case NFS4ERR_DENIED
: return "NFS4ERR_DENIED";
402 case NFS4ERR_EXPIRED
: return "NFS4ERR_EXPIRED";
403 case NFS4ERR_LOCKED
: return "NFS4ERR_LOCKED";
404 case NFS4ERR_GRACE
: return "NFS4ERR_GRACE";
405 case NFS4ERR_FHEXPIRED
: return "NFS4ERR_FHEXPIRED";
406 case NFS4ERR_SHARE_DENIED
: return "NFS4ERR_SHARE_DENIED";
407 case NFS4ERR_WRONGSEC
: return "NFS4ERR_WRONGSEC";
408 case NFS4ERR_CLID_INUSE
: return "NFS4ERR_CLID_INUSE";
409 case NFS4ERR_RESOURCE
: return "NFS4ERR_RESOURCE";
410 case NFS4ERR_MOVED
: return "NFS4ERR_MOVED";
411 case NFS4ERR_NOFILEHANDLE
: return "NFS4ERR_NOFILEHANDLE";
412 case NFS4ERR_MINOR_VERS_MISMATCH
: return "NFS4ERR_MINOR_VERS_MISMATCH";
413 case NFS4ERR_STALE_CLIENTID
: return "NFS4ERR_STALE_CLIENTID";
414 case NFS4ERR_STALE_STATEID
: return "NFS4ERR_STALE_STATEID";
415 case NFS4ERR_OLD_STATEID
: return "NFS4ERR_OLD_STATEID";
416 case NFS4ERR_BAD_STATEID
: return "NFS4ERR_BAD_STATEID";
417 case NFS4ERR_BAD_SEQID
: return "NFS4ERR_BAD_SEQID";
418 case NFS4ERR_NOT_SAME
: return "NFS4ERR_NOT_SAME";
419 case NFS4ERR_LOCK_RANGE
: return "NFS4ERR_LOCK_RANGE";
420 case NFS4ERR_SYMLINK
: return "NFS4ERR_SYMLINK";
421 case NFS4ERR_RESTOREFH
: return "NFS4ERR_RESTOREFH";
422 case NFS4ERR_LEASE_MOVED
: return "NFS4ERR_LEASE_MOVED";
423 case NFS4ERR_ATTRNOTSUPP
: return "NFS4ERR_ATTRNOTSUPP";
424 case NFS4ERR_NO_GRACE
: return "NFS4ERR_NO_GRACE";
425 case NFS4ERR_RECLAIM_BAD
: return "NFS4ERR_RECLAIM_BAD";
426 case NFS4ERR_RECLAIM_CONFLICT
: return "NFS4ERR_RECLAIM_CONFLICT";
427 case NFS4ERR_BADXDR
: return "NFS4ERR_BADXDR";
428 case NFS4ERR_LOCKS_HELD
: return "NFS4ERR_LOCKS_HELD";
429 case NFS4ERR_OPENMODE
: return "NFS4ERR_OPENMODE";
430 case NFS4ERR_BADOWNER
: return "NFS4ERR_BADOWNER";
431 case NFS4ERR_BADCHAR
: return "NFS4ERR_BADCHAR";
432 case NFS4ERR_BADNAME
: return "NFS4ERR_BADNAME";
433 case NFS4ERR_BAD_RANGE
: return "NFS4ERR_BAD_RANGE";
434 case NFS4ERR_LOCK_NOTSUPP
: return "NFS4ERR_LOCK_NOTSUPP";
435 case NFS4ERR_OP_ILLEGAL
: return "NFS4ERR_OP_ILLEGAL";
436 case NFS4ERR_DEADLOCK
: return "NFS4ERR_DEADLOCK";
437 case NFS4ERR_FILE_OPEN
: return "NFS4ERR_FILE_OPEN";
438 case NFS4ERR_ADMIN_REVOKED
: return "NFS4ERR_ADMIN_REVOKED";
439 case NFS4ERR_CB_PATH_DOWN
: return "NFS4ERR_CB_PATH_DOWN";
440 case NFS4ERR_BADIOMODE
: return "NFS4ERR_BADIOMODE";
441 case NFS4ERR_BADLAYOUT
: return "NFS4ERR_BADLAYOUT";
442 case NFS4ERR_BAD_SESSION_DIGEST
: return "NFS4ERR_BAD_SESSION_DIGEST";
443 case NFS4ERR_BADSESSION
: return "NFS4ERR_BADSESSION";
444 case NFS4ERR_BADSLOT
: return "NFS4ERR_BADSLOT";
445 case NFS4ERR_COMPLETE_ALREADY
: return "NFS4ERR_COMPLETE_ALREADY";
446 case NFS4ERR_CONN_NOT_BOUND_TO_SESSION
: return "NFS4ERR_CONN_NOT_BOUND_TO_SESSION";
447 case NFS4ERR_DELEG_ALREADY_WANTED
: return "NFS4ERR_DELEG_ALREADY_WANTED";
448 case NFS4ERR_BACK_CHAN_BUSY
: return "NFS4ERR_BACK_CHAN_BUSY";
449 case NFS4ERR_LAYOUTTRYLATER
: return "NFS4ERR_LAYOUTTRYLATER";
450 case NFS4ERR_LAYOUTUNAVAILABLE
: return "NFS4ERR_LAYOUTUNAVAILABLE";
451 case NFS4ERR_NOMATCHING_LAYOUT
: return "NFS4ERR_NOMATCHING_LAYOUT";
452 case NFS4ERR_RECALLCONFLICT
: return "NFS4ERR_RECALLCONFLICT";
453 case NFS4ERR_UNKNOWN_LAYOUTTYPE
: return "NFS4ERR_UNKNOWN_LAYOUTTYPE";
454 case NFS4ERR_SEQ_MISORDERED
: return "NFS4ERR_SEQ_MISORDERED";
455 case NFS4ERR_SEQUENCE_POS
: return "NFS4ERR_SEQUENCE_POS";
456 case NFS4ERR_REQ_TOO_BIG
: return "NFS4ERR_REQ_TOO_BIG";
457 case NFS4ERR_REP_TOO_BIG
: return "NFS4ERR_REP_TOO_BIG";
458 case NFS4ERR_REP_TOO_BIG_TO_CACHE
: return "NFS4ERR_REP_TOO_BIG_TO_CACHE";
459 case NFS4ERR_RETRY_UNCACHED_REP
: return "NFS4ERR_RETRY_UNCACHED_REP";
460 case NFS4ERR_UNSAFE_COMPOUND
: return "NFS4ERR_UNSAFE_COMPOUND";
461 case NFS4ERR_TOO_MANY_OPS
: return "NFS4ERR_TOO_MANY_OPS";
462 case NFS4ERR_OP_NOT_IN_SESSION
: return "NFS4ERR_OP_NOT_IN_SESSION";
463 case NFS4ERR_HASH_ALG_UNSUPP
: return "NFS4ERR_HASH_ALG_UNSUPP";
464 case NFS4ERR_CLIENTID_BUSY
: return "NFS4ERR_CLIENTID_BUSY";
465 case NFS4ERR_PNFS_IO_HOLE
: return "NFS4ERR_PNFS_IO_HOLE";
466 case NFS4ERR_SEQ_FALSE_RETRY
: return "NFS4ERR_SEQ_FALSE_RETRY";
467 case NFS4ERR_BAD_HIGH_SLOT
: return "NFS4ERR_BAD_HIGH_SLOT";
468 case NFS4ERR_DEADSESSION
: return "NFS4ERR_DEADSESSION";
469 case NFS4ERR_ENCR_ALG_UNSUPP
: return "NFS4ERR_ENCR_ALG_UNSUPP";
470 case NFS4ERR_PNFS_NO_LAYOUT
: return "NFS4ERR_PNFS_NO_LAYOUT";
471 case NFS4ERR_NOT_ONLY_OP
: return "NFS4ERR_NOT_ONLY_OP";
472 case NFS4ERR_WRONG_CRED
: return "NFS4ERR_WRONG_CRED";
473 case NFS4ERR_WRONG_TYPE
: return "NFS4ERR_WRONG_TYPE";
474 case NFS4ERR_DIRDELEG_UNAVAIL
: return "NFS4ERR_DIRDELEG_UNAVAIL";
475 case NFS4ERR_REJECT_DELEG
: return "NFS4ERR_REJECT_DELEG";
476 case NFS4ERR_RETURNCONFLICT
: return "NFS4ERR_RETURNCONFLICT";
477 case NFS4ERR_DELEG_REVOKED
: return "NFS4ERR_DELEG_REVOKED";
478 default: return "invalid nfs error code";
482 const char* rpc_error_string(int status
)
486 case RPC_CANTENCODEARGS
: return "RPC_CANTENCODEARGS";
487 case RPC_CANTDECODERES
: return "RPC_CANTDECODERES";
488 case RPC_CANTSEND
: return "RPC_CANTSEND";
489 case RPC_CANTRECV
: return "RPC_CANTRECV";
490 case RPC_TIMEDOUT
: return "RPC_TIMEDOUT";
491 case RPC_INTR
: return "RPC_INTR";
492 case RPC_UDERROR
: return "RPC_UDERROR";
493 case RPC_VERSMISMATCH
: return "RPC_VERSMISMATCH";
494 case RPC_AUTHERROR
: return "RPC_AUTHERROR";
495 case RPC_PROGUNAVAIL
: return "RPC_PROGUNAVAIL";
496 case RPC_PROGVERSMISMATCH
: return "RPC_PROGVERSMISMATCH";
497 case RPC_PROCUNAVAIL
: return "RPC_PROCUNAVAIL";
498 case RPC_CANTDECODEARGS
: return "RPC_CANTDECODEARGS";
499 case RPC_SYSTEMERROR
: return "RPC_SYSTEMERROR";
500 default: return "invalid rpc error code";
504 const char* gssauth_string(int type
) {
506 case RPCSEC_SSPI_SVC_NONE
: return "RPCSEC_SSPI_SVC_NONE";
507 case RPCSEC_SSPI_SVC_INTEGRITY
: return "RPCSEC_SSPI_SVC_INTEGRITY";
508 case RPCSEC_SSPI_SVC_PRIVACY
: return "RPCSEC_SSPI_SVC_PRIVACY";
509 default: return "invalid gss auth type";
513 void print_condwait_status(int level
, int status
)
515 if (level
> g_debug_level
) return;
517 case WAIT_ABANDONED
: fprintf(dlog_file
, "WAIT_ABANDONED\n"); break;
518 case WAIT_OBJECT_0
: fprintf(dlog_file
, "WAIT_OBJECT_0\n"); break;
519 case WAIT_TIMEOUT
: fprintf(dlog_file
, "WAIT_TIMEOUT\n"); break;
520 case WAIT_FAILED
: fprintf(dlog_file
, "WAIT_FAILED %d\n", GetLastError());
521 default: fprintf(dlog_file
, "unknown status =%d\n", status
);
525 void print_sr_status_flags(int level
, int flags
)
527 if (level
> g_debug_level
) return;
528 fprintf(dlog_file
, "%04x: sr_status_flags: ", GetCurrentThreadId());
529 if (flags
& SEQ4_STATUS_CB_PATH_DOWN
)
530 fprintf(dlog_file
, "SEQ4_STATUS_CB_PATH_DOWN ");
531 if (flags
& SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING
)
532 fprintf(dlog_file
, "SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING ");
533 if (flags
& SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED
)
534 fprintf(dlog_file
, "SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED ");
535 if (flags
& SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED
)
536 fprintf(dlog_file
, "SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED ");
537 if (flags
& SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED
)
538 fprintf(dlog_file
, "SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED ");
539 if (flags
& SEQ4_STATUS_ADMIN_STATE_REVOKED
)
540 fprintf(dlog_file
, "SEQ4_STATUS_ADMIN_STATE_REVOKED ");
541 if (flags
& SEQ4_STATUS_RECALLABLE_STATE_REVOKED
)
542 fprintf(dlog_file
, "SEQ4_STATUS_RECALLABLE_STATE_REVOKED ");
543 if (flags
& SEQ4_STATUS_LEASE_MOVED
)
544 fprintf(dlog_file
, "SEQ4_STATUS_LEASE_MOVED ");
545 if (flags
& SEQ4_STATUS_RESTART_RECLAIM_NEEDED
)
546 fprintf(dlog_file
, "SEQ4_STATUS_RESTART_RECLAIM_NEEDED ");
547 if (flags
& SEQ4_STATUS_CB_PATH_DOWN_SESSION
)
548 fprintf(dlog_file
, "SEQ4_STATUS_CB_PATH_DOWN_SESSION ");
549 if (flags
& SEQ4_STATUS_BACKCHANNEL_FAULT
)
550 fprintf(dlog_file
, "SEQ4_STATUS_BACKCHANNEL_FAULT ");
551 if (flags
& SEQ4_STATUS_DEVID_CHANGED
)
552 fprintf(dlog_file
, "SEQ4_STATUS_DEVID_CHANGED ");
553 if (flags
& SEQ4_STATUS_DEVID_DELETED
)
554 fprintf(dlog_file
, "SEQ4_STATUS_DEVID_DELETED ");
555 fprintf(dlog_file
, "\n");
558 const char* secflavorop2name(DWORD sec_flavor
)
561 case RPCSEC_AUTH_SYS
: return "AUTH_SYS";
562 case RPCSEC_AUTHGSS_KRB5
: return "AUTHGSS_KRB5";
563 case RPCSEC_AUTHGSS_KRB5I
: return "AUTHGSS_KRB5I";
564 case RPCSEC_AUTHGSS_KRB5P
: return "AUTHGSS_KRB5P";
567 return "UNKNOWN FLAVOR";
570 void print_windows_access_mask(int on
, ACCESS_MASK m
)
573 dprintf(1, "--> print_windows_access_mask: %x\n", m
);
574 if (m
& GENERIC_READ
)
575 dprintf(1, "\tGENERIC_READ\n");
576 if (m
& GENERIC_WRITE
)
577 dprintf(1, "\tGENERIC_WRITE\n");
578 if (m
& GENERIC_EXECUTE
)
579 dprintf(1, "\tGENERIC_EXECUTE\n");
581 dprintf(1, "\tGENERIC_ALL\n");
582 if (m
& MAXIMUM_ALLOWED
)
583 dprintf(1, "\tMAXIMUM_ALLOWED\n");
584 if (m
& ACCESS_SYSTEM_SECURITY
)
585 dprintf(1, "\tACCESS_SYSTEM_SECURITY\n");
586 if ((m
& SPECIFIC_RIGHTS_ALL
) == SPECIFIC_RIGHTS_ALL
)
587 dprintf(1, "\tSPECIFIC_RIGHTS_ALL\n");
588 if ((m
& STANDARD_RIGHTS_ALL
) == STANDARD_RIGHTS_ALL
)
589 dprintf(1, "\tSTANDARD_RIGHTS_ALL\n");
590 if ((m
& STANDARD_RIGHTS_REQUIRED
) == STANDARD_RIGHTS_REQUIRED
)
591 dprintf(1, "\tSTANDARD_RIGHTS_REQUIRED\n");
593 dprintf(1, "\tSYNCHRONIZE\n");
595 dprintf(1, "\tWRITE_OWNER\n");
597 dprintf(1, "\tWRITE_DAC\n");
598 if (m
& READ_CONTROL
)
599 dprintf(1, "\tREAD_CONTROL\n");
601 dprintf(1, "\tDELETE\n");
602 if (m
& FILE_READ_DATA
)
603 dprintf(1, "\tFILE_READ_DATA\n");
604 if (m
& FILE_LIST_DIRECTORY
)
605 dprintf(1, "\tFILE_LIST_DIRECTORY\n");
606 if (m
& FILE_WRITE_DATA
)
607 dprintf(1, "\tFILE_WRITE_DATA\n");
608 if (m
& FILE_ADD_FILE
)
609 dprintf(1, "\tFILE_ADD_FILE\n");
610 if (m
& FILE_APPEND_DATA
)
611 dprintf(1, "\tFILE_APPEND_DATA\n");
612 if (m
& FILE_ADD_SUBDIRECTORY
)
613 dprintf(1, "\tFILE_ADD_SUBDIRECTORY\n");
614 if (m
& FILE_CREATE_PIPE_INSTANCE
)
615 dprintf(1, "\tFILE_CREATE_PIPE_INSTANCE\n");
616 if (m
& FILE_READ_EA
)
617 dprintf(1, "\tFILE_READ_EA\n");
618 if (m
& FILE_WRITE_EA
)
619 dprintf(1, "\tFILE_WRITE_EA\n");
620 if (m
& FILE_EXECUTE
)
621 dprintf(1, "\tFILE_EXECUTE\n");
622 if (m
& FILE_TRAVERSE
)
623 dprintf(1, "\tFILE_TRAVERSE\n");
624 if (m
& FILE_DELETE_CHILD
)
625 dprintf(1, "\tFILE_DELETE_CHILD\n");
626 if (m
& FILE_READ_ATTRIBUTES
)
627 dprintf(1, "\tFILE_READ_ATTRIBUTES\n");
628 if (m
& FILE_WRITE_ATTRIBUTES
)
629 dprintf(1, "\tFILE_WRITE_ATTRIBUTES\n");
630 if ((m
& FILE_ALL_ACCESS
) == FILE_ALL_ACCESS
)
631 dprintf(1, "\tFILE_ALL_ACCESS\n");
632 if ((m
& FILE_GENERIC_READ
) == FILE_GENERIC_READ
)
633 dprintf(1, "\tFILE_GENERIC_READ\n");
634 if ((m
& FILE_GENERIC_WRITE
) == FILE_GENERIC_WRITE
)
635 dprintf(1, "\tFILE_GENERIC_WRITE\n");
636 if ((m
& FILE_GENERIC_EXECUTE
) == FILE_GENERIC_EXECUTE
)
637 dprintf(1, "\tFILE_GENERIC_EXECUTE\n");
640 void print_nfs_access_mask(int on
, int m
)
643 dprintf(1, "--> print_nfs_access_mask: %x\n", m
);
644 if (m
& ACE4_READ_DATA
)
645 dprintf(1, "\tACE4_READ_DATA\n");
646 if (m
& ACE4_LIST_DIRECTORY
)
647 dprintf(1, "\tACE4_LIST_DIRECTORY\n");
648 if (m
& ACE4_WRITE_DATA
)
649 dprintf(1, "\tACE4_WRITE_DATA\n");
650 if (m
& ACE4_ADD_FILE
)
651 dprintf(1, "\tACE4_ADD_FILE\n");
652 if (m
& ACE4_APPEND_DATA
)
653 dprintf(1, "\tACE4_APPEND_DATA\n");
654 if (m
& ACE4_ADD_SUBDIRECTORY
)
655 dprintf(1, "\tACE4_ADD_SUBDIRECTORY\n");
656 if (m
& ACE4_READ_NAMED_ATTRS
)
657 dprintf(1, "\tACE4_READ_NAMED_ATTRS\n");
658 if (m
& ACE4_WRITE_NAMED_ATTRS
)
659 dprintf(1, "\tACE4_WRITE_NAMED_ATTRS\n");
660 if (m
& ACE4_EXECUTE
)
661 dprintf(1, "\tACE4_EXECUTE\n");
662 if (m
& ACE4_DELETE_CHILD
)
663 dprintf(1, "\tACE4_DELETE_CHILD\n");
664 if (m
& ACE4_READ_ATTRIBUTES
)
665 dprintf(1, "\tACE4_READ_ATTRIBUTES\n");
666 if (m
& ACE4_WRITE_ATTRIBUTES
)
667 dprintf(1, "\tACE4_WRITE_ATTRIBUTES\n");
669 dprintf(1, "\tACE4_DELETE\n");
670 if (m
& ACE4_READ_ACL
)
671 dprintf(1, "\tACE4_READ_ACL\n");
672 if (m
& ACE4_WRITE_ACL
)
673 dprintf(1, "\tACE4_WRITE_ACL\n");
674 if (m
& ACE4_WRITE_OWNER
)
675 dprintf(1, "\tACE4_WRITE_OWNER\n");
676 if (m
& ACE4_SYNCHRONIZE
)
677 dprintf(1, "\tACE4_SYNCHRONIZE\n");