huwcampbell.com
Reactos
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#include <windows.h>
23#include <stdio.h>
24
25#include "daemon_debug.h"
26#include "from_kernel.h"
27#include "nfs41_driver.h"
28#include "nfs41_ops.h"
29#include "service.h"
30#include "rpc/rpc.h"
31#include "rpc/auth_sspi.h"
32
33static int g_debug_level = DEFAULT_DEBUG_LEVEL;
34
35void set_debug_level(int level) { g_debug_level = level; }
36
37FILE *dlog_file, *elog_file;
38
39#ifndef STANDALONE_NFSD
40void open_log_files()
41{
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());
50 }
51 }
52 elog_file = fopen(efile, mode);
53 if (elog_file == NULL) {
54 ReportStatusToSCMgr(SERVICE_STOPPED, GetLastError(), 0);
55 exit (GetLastError());
56 }
57}
58
59void close_log_files()
60{
61 if (dlog_file) fclose(dlog_file);
62 if (elog_file) fclose(elog_file);
63}
64#else
65void open_log_files()
66{
67 dlog_file = stdout;
68 elog_file = stderr;
69}
70#endif
71
72void dprintf(int level, LPCSTR format, ...)
73{
74 if (level <= g_debug_level) {
75 va_list args;
76 va_start(args, format);
77 fprintf(dlog_file, "%04x: ", GetCurrentThreadId());
78 vfprintf(dlog_file, format, args);
79#ifndef STANDALONE_NFSD
80 fflush(dlog_file);
81#endif
82 va_end(args);
83 }
84}
85
86void eprintf(LPCSTR format, ...)
87{
88 va_list args;
89 va_start(args, format);
90 fprintf(elog_file, "%04x: ", GetCurrentThreadId());
91 vfprintf(elog_file, format, args);
92#ifndef STANDALONE_NFSD
93 fflush(elog_file);
94#endif
95 va_end(args);
96}
97
98void print_hexbuf(int level, unsigned char *title, unsigned char *buf, int len)
99{
100 int j, k;
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");
107 }
108 }
109 fprintf(dlog_file, "\n");
110}
111
112void print_hexbuf_no_asci(int level, unsigned char *title, unsigned char *buf, int len)
113{
114 int j, k;
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");
121 }
122 }
123 fprintf(dlog_file, "\n");
124}
125
126void 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");
162}
163
164void 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");
179}
180
181void 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");
213}
214
215void print_share_mode(int level, DWORD mode)
216{
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");
226}
227
228void print_file_id_both_dir_info(int level, FILE_ID_BOTH_DIR_INFO *pboth_dir_info)
229{
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);
273}
274
275void print_opcode(int level, DWORD opcode)
276{
277 dprintf(level, (LPCSTR)opcode2string(opcode));
278}
279
280const char* opcode2string(DWORD opcode)
281{
282 switch(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";
302 }
303}
304
305const char* nfs_opnum_to_string(int opnum)
306{
307 switch (opnum)
308 {
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";
367 }
368}
369
370const char* nfs_error_string(int status)
371{
372 switch (status)
373 {
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";
479 }
480}
481
482const char* rpc_error_string(int status)
483{
484 switch (status)
485 {
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";
501 }
502}
503
504const char* gssauth_string(int type) {
505 switch(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";
510 }
511}
512
513void print_condwait_status(int level, int status)
514{
515 if (level > g_debug_level) return;
516 switch(status) {
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);
522 }
523}
524
525void print_sr_status_flags(int level, int flags)
526{
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");
556}
557
558const char* secflavorop2name(DWORD sec_flavor)
559{
560 switch(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";
565 }
566
567 return "UNKNOWN FLAVOR";
568}
569
570void print_windows_access_mask(int on, ACCESS_MASK m)
571{
572 if (!on) return;
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");
580 if (m & GENERIC_ALL)
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");
592 if (m & SYNCHRONIZE)
593 dprintf(1, "\tSYNCHRONIZE\n");
594 if (m & WRITE_OWNER)
595 dprintf(1, "\tWRITE_OWNER\n");
596 if (m & WRITE_DAC)
597 dprintf(1, "\tWRITE_DAC\n");
598 if (m & READ_CONTROL)
599 dprintf(1, "\tREAD_CONTROL\n");
600 if (m & DELETE)
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");
638}
639
640void print_nfs_access_mask(int on, int m)
641{
642 if (!on) return;
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");
668 if (m & ACE4_DELETE)
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");
678}