r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text
[tprouty/samba.git] / source / libsmb / clierror.c
1 /* 
2    Unix SMB/CIFS implementation.
3    client error handling routines
4    Copyright (C) Andrew Tridgell 1994-1998
5    Copyright (C) Jelmer Vernooij 2003
6    Copyright (C) Jeremy Allison 2006
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23
24 /*****************************************************
25  RAP error codes - a small start but will be extended.
26
27  XXX: Perhaps these should move into a common function because they're
28  duplicated in clirap2.c
29
30 *******************************************************/
31
32 static const struct {
33         int err;
34         const char *message;
35 } rap_errmap[] = {
36         {5,    "RAP5: User has insufficient privilege" },
37         {50,   "RAP50: Not supported by server" },
38         {65,   "RAP65: Access denied" },
39         {86,   "RAP86: The specified password is invalid" },
40         {2220, "RAP2220: Group does not exist" },
41         {2221, "RAP2221: User does not exist" },
42         {2226, "RAP2226: Operation only permitted on a Primary Domain Controller"  },
43         {2237, "RAP2237: User is not in group" },
44         {2242, "RAP2242: The password of this user has expired." },
45         {2243, "RAP2243: The password of this user cannot change." },
46         {2244, "RAP2244: This password cannot be used now (password history conflict)." },
47         {2245, "RAP2245: The password is shorter than required." },
48         {2246, "RAP2246: The password of this user is too recent to change."},
49
50         /* these really shouldn't be here ... */
51         {0x80, "Not listening on called name"},
52         {0x81, "Not listening for calling name"},
53         {0x82, "Called name not present"},
54         {0x83, "Called name present, but insufficient resources"},
55
56         {0, NULL}
57 };  
58
59 /****************************************************************************
60  Return a description of an SMB error.
61 ****************************************************************************/
62
63 static const char *cli_smb_errstr(struct cli_state *cli)
64 {
65         return smb_dos_errstr(cli->inbuf);
66 }
67
68 /****************************************************************************
69  Convert a socket error into an NTSTATUS.
70 ****************************************************************************/
71
72 static NTSTATUS cli_smb_rw_error_to_ntstatus(struct cli_state *cli)
73 {
74         switch(cli->smb_rw_error) {
75                 case READ_TIMEOUT:
76                         return NT_STATUS_IO_TIMEOUT;
77                 case READ_EOF:
78                         return NT_STATUS_END_OF_FILE;
79                 /* What we shoud really do for read/write errors is convert from errno. */
80                 /* FIXME. JRA. */
81                 case READ_ERROR:
82                         return NT_STATUS_INVALID_NETWORK_RESPONSE;
83                 case WRITE_ERROR:
84                         return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
85                 case READ_BAD_SIG:
86                 case READ_BAD_DECRYPT:
87                         return NT_STATUS_INVALID_PARAMETER;
88                 default:
89                         break;
90         }
91         return NT_STATUS_UNSUCCESSFUL;
92 }
93
94 /***************************************************************************
95  Return an error message - either an NT error, SMB error or a RAP error.
96  Note some of the NT errors are actually warnings or "informational" errors
97  in which case they can be safely ignored.
98 ****************************************************************************/
99
100 const char *cli_errstr(struct cli_state *cli)
101 {   
102         static fstring cli_error_message;
103         uint32 flgs2 = SVAL(cli->inbuf,smb_flg2), errnum;
104         uint8 errclass;
105         int i;
106
107         if (!cli->initialised) {
108                 fstrcpy(cli_error_message, "[Programmer's error] cli_errstr called on unitialized cli_stat struct!\n");
109                 return cli_error_message;
110         }
111
112         /* Was it server socket error ? */
113         if (cli->fd == -1 && cli->smb_rw_error) {
114                 switch(cli->smb_rw_error) {
115                         case READ_TIMEOUT:
116                                 slprintf(cli_error_message, sizeof(cli_error_message) - 1,
117                                         "Call timed out: server did not respond after %d milliseconds",
118                                         cli->timeout);
119                                 break;
120                         case READ_EOF:
121                                 slprintf(cli_error_message, sizeof(cli_error_message) - 1,
122                                         "Call returned zero bytes (EOF)" );
123                                 break;
124                         case READ_ERROR:
125                                 slprintf(cli_error_message, sizeof(cli_error_message) - 1,
126                                         "Read error: %s", strerror(errno) );
127                                 break;
128                         case WRITE_ERROR:
129                                 slprintf(cli_error_message, sizeof(cli_error_message) - 1,
130                                         "Write error: %s", strerror(errno) );
131                                 break;
132                         case READ_BAD_SIG:
133                                 slprintf(cli_error_message, sizeof(cli_error_message) - 1,
134                                         "Server packet had invalid SMB signature!");
135                                 break;
136                         case READ_BAD_DECRYPT:
137                                 slprintf(cli_error_message, sizeof(cli_error_message) - 1,
138                                         "Server packet could not be decrypted !");
139                                 break;
140                         default:
141                                 slprintf(cli_error_message, sizeof(cli_error_message) - 1,
142                                         "Unknown error code %d\n", cli->smb_rw_error );
143                                 break;
144                 }
145                 return cli_error_message;
146         }
147
148         /* Case #1: RAP error */
149         if (cli->rap_error) {
150                 for (i = 0; rap_errmap[i].message != NULL; i++) {
151                         if (rap_errmap[i].err == cli->rap_error) {
152                                 return rap_errmap[i].message;
153                         }
154                 }
155
156                 slprintf(cli_error_message, sizeof(cli_error_message) - 1, "RAP code %d",
157                         cli->rap_error);
158
159                 return cli_error_message;
160         }
161
162         /* Case #2: 32-bit NT errors */
163         if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
164                 NTSTATUS status = NT_STATUS(IVAL(cli->inbuf,smb_rcls));
165
166                 return nt_errstr(status);
167         }
168
169         cli_dos_error(cli, &errclass, &errnum);
170
171         /* Case #3: SMB error */
172
173         return cli_smb_errstr(cli);
174 }
175
176
177 /****************************************************************************
178  Return the 32-bit NT status code from the last packet.
179 ****************************************************************************/
180
181 NTSTATUS cli_nt_error(struct cli_state *cli)
182 {
183         int flgs2 = SVAL(cli->inbuf,smb_flg2);
184
185         /* Deal with socket errors first. */
186         if (cli->fd == -1 && cli->smb_rw_error) {
187                 return cli_smb_rw_error_to_ntstatus(cli);
188         }
189
190         if (!(flgs2 & FLAGS2_32_BIT_ERROR_CODES)) {
191                 int e_class  = CVAL(cli->inbuf,smb_rcls);
192                 int code  = SVAL(cli->inbuf,smb_err);
193                 return dos_to_ntstatus(e_class, code);
194         }
195
196         return NT_STATUS(IVAL(cli->inbuf,smb_rcls));
197 }
198
199
200 /****************************************************************************
201  Return the DOS error from the last packet - an error class and an error
202  code.
203 ****************************************************************************/
204
205 void cli_dos_error(struct cli_state *cli, uint8 *eclass, uint32 *ecode)
206 {
207         int  flgs2;
208
209         if(!cli->initialised) {
210                 return;
211         }
212
213         /* Deal with socket errors first. */
214         if (cli->fd == -1 && cli->smb_rw_error) {
215                 NTSTATUS status = cli_smb_rw_error_to_ntstatus(cli);
216                 ntstatus_to_dos( status, eclass, ecode);
217                 return;
218         }
219
220         flgs2 = SVAL(cli->inbuf,smb_flg2);
221
222         if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
223                 NTSTATUS ntstatus = NT_STATUS(IVAL(cli->inbuf, smb_rcls));
224                 ntstatus_to_dos(ntstatus, eclass, ecode);
225                 return;
226         }
227
228         *eclass  = CVAL(cli->inbuf,smb_rcls);
229         *ecode  = SVAL(cli->inbuf,smb_err);
230 }
231
232 /* Return a UNIX errno from a NT status code */
233 static const struct {
234         NTSTATUS status;
235         int error;
236 } nt_errno_map[] = {
237         {NT_STATUS_ACCESS_VIOLATION, EACCES},
238         {NT_STATUS_INVALID_HANDLE, EBADF},
239         {NT_STATUS_ACCESS_DENIED, EACCES},
240         {NT_STATUS_OBJECT_NAME_NOT_FOUND, ENOENT},
241         {NT_STATUS_SHARING_VIOLATION, EBUSY},
242         {NT_STATUS_OBJECT_PATH_INVALID, ENOTDIR},
243         {NT_STATUS_OBJECT_NAME_COLLISION, EEXIST},
244         {NT_STATUS_PATH_NOT_COVERED, ENOENT},
245         {NT_STATUS_UNSUCCESSFUL, EINVAL},
246         {NT_STATUS_NOT_IMPLEMENTED, ENOSYS},
247         {NT_STATUS_IN_PAGE_ERROR, EFAULT}, 
248         {NT_STATUS_BAD_NETWORK_NAME, ENOENT},
249 #ifdef EDQUOT
250         {NT_STATUS_PAGEFILE_QUOTA, EDQUOT},
251         {NT_STATUS_QUOTA_EXCEEDED, EDQUOT},
252         {NT_STATUS_REGISTRY_QUOTA_LIMIT, EDQUOT},
253         {NT_STATUS_LICENSE_QUOTA_EXCEEDED, EDQUOT},
254 #endif
255 #ifdef ETIME
256         {NT_STATUS_TIMER_NOT_CANCELED, ETIME},
257 #endif
258         {NT_STATUS_INVALID_PARAMETER, EINVAL},
259         {NT_STATUS_NO_SUCH_DEVICE, ENODEV},
260         {NT_STATUS_NO_SUCH_FILE, ENOENT},
261 #ifdef ENODATA
262         {NT_STATUS_END_OF_FILE, ENODATA}, 
263 #endif
264 #ifdef ENOMEDIUM
265         {NT_STATUS_NO_MEDIA_IN_DEVICE, ENOMEDIUM}, 
266         {NT_STATUS_NO_MEDIA, ENOMEDIUM},
267 #endif
268         {NT_STATUS_NONEXISTENT_SECTOR, ESPIPE}, 
269         {NT_STATUS_NO_MEMORY, ENOMEM},
270         {NT_STATUS_CONFLICTING_ADDRESSES, EADDRINUSE},
271         {NT_STATUS_NOT_MAPPED_VIEW, EINVAL},
272         {NT_STATUS_UNABLE_TO_FREE_VM, EADDRINUSE},
273         {NT_STATUS_ACCESS_DENIED, EACCES}, 
274         {NT_STATUS_BUFFER_TOO_SMALL, ENOBUFS},
275         {NT_STATUS_WRONG_PASSWORD, EACCES},
276         {NT_STATUS_LOGON_FAILURE, EACCES},
277         {NT_STATUS_INVALID_WORKSTATION, EACCES},
278         {NT_STATUS_INVALID_LOGON_HOURS, EACCES},
279         {NT_STATUS_PASSWORD_EXPIRED, EACCES},
280         {NT_STATUS_ACCOUNT_DISABLED, EACCES},
281         {NT_STATUS_DISK_FULL, ENOSPC},
282         {NT_STATUS_INVALID_PIPE_STATE, EPIPE},
283         {NT_STATUS_PIPE_BUSY, EPIPE},
284         {NT_STATUS_PIPE_DISCONNECTED, EPIPE},
285         {NT_STATUS_PIPE_NOT_AVAILABLE, ENOSYS},
286         {NT_STATUS_FILE_IS_A_DIRECTORY, EISDIR},
287         {NT_STATUS_NOT_SUPPORTED, ENOSYS},
288         {NT_STATUS_NOT_A_DIRECTORY, ENOTDIR},
289         {NT_STATUS_DIRECTORY_NOT_EMPTY, ENOTEMPTY},
290         {NT_STATUS_NETWORK_UNREACHABLE, ENETUNREACH},
291         {NT_STATUS_HOST_UNREACHABLE, EHOSTUNREACH},
292         {NT_STATUS_CONNECTION_ABORTED, ECONNABORTED},
293         {NT_STATUS_CONNECTION_REFUSED, ECONNREFUSED},
294         {NT_STATUS_TOO_MANY_LINKS, EMLINK},
295         {NT_STATUS_NETWORK_BUSY, EBUSY},
296         {NT_STATUS_DEVICE_DOES_NOT_EXIST, ENODEV},
297 #ifdef ELIBACC
298         {NT_STATUS_DLL_NOT_FOUND, ELIBACC},
299 #endif
300         {NT_STATUS_PIPE_BROKEN, EPIPE},
301         {NT_STATUS_REMOTE_NOT_LISTENING, ECONNREFUSED},
302         {NT_STATUS_NETWORK_ACCESS_DENIED, EACCES},
303         {NT_STATUS_TOO_MANY_OPENED_FILES, EMFILE},
304 #ifdef EPROTO
305         {NT_STATUS_DEVICE_PROTOCOL_ERROR, EPROTO},
306 #endif
307         {NT_STATUS_FLOAT_OVERFLOW, ERANGE},
308         {NT_STATUS_FLOAT_UNDERFLOW, ERANGE},
309         {NT_STATUS_INTEGER_OVERFLOW, ERANGE},
310         {NT_STATUS_MEDIA_WRITE_PROTECTED, EROFS},
311         {NT_STATUS_PIPE_CONNECTED, EISCONN},
312         {NT_STATUS_MEMORY_NOT_ALLOCATED, EFAULT},
313         {NT_STATUS_FLOAT_INEXACT_RESULT, ERANGE},
314         {NT_STATUS_ILL_FORMED_PASSWORD, EACCES},
315         {NT_STATUS_PASSWORD_RESTRICTION, EACCES},
316         {NT_STATUS_ACCOUNT_RESTRICTION, EACCES},
317         {NT_STATUS_PORT_CONNECTION_REFUSED, ECONNREFUSED},
318         {NT_STATUS_NAME_TOO_LONG, ENAMETOOLONG},
319         {NT_STATUS_REMOTE_DISCONNECT, ESHUTDOWN},
320         {NT_STATUS_CONNECTION_DISCONNECTED, ECONNABORTED},
321         {NT_STATUS_CONNECTION_RESET, ENETRESET},
322 #ifdef ENOTUNIQ
323         {NT_STATUS_IP_ADDRESS_CONFLICT1, ENOTUNIQ},
324         {NT_STATUS_IP_ADDRESS_CONFLICT2, ENOTUNIQ},
325 #endif
326         {NT_STATUS_PORT_MESSAGE_TOO_LONG, EMSGSIZE},
327         {NT_STATUS_PROTOCOL_UNREACHABLE, ENOPROTOOPT},
328         {NT_STATUS_ADDRESS_ALREADY_EXISTS, EADDRINUSE},
329         {NT_STATUS_PORT_UNREACHABLE, EHOSTUNREACH},
330         {NT_STATUS_IO_TIMEOUT, ETIMEDOUT},
331         {NT_STATUS_RETRY, EAGAIN},
332 #ifdef ENOTUNIQ
333         {NT_STATUS_DUPLICATE_NAME, ENOTUNIQ},
334 #endif
335 #ifdef ECOMM
336         {NT_STATUS_NET_WRITE_FAULT, ECOMM},
337 #endif
338 #ifdef EXDEV
339         {NT_STATUS_NOT_SAME_DEVICE, EXDEV},
340 #endif
341         {NT_STATUS(0), 0}
342 };
343
344 /****************************************************************************
345  The following mappings need tidying up and moving into libsmb/errormap.c...
346 ****************************************************************************/
347
348 static int cli_errno_from_nt(NTSTATUS status)
349 {
350         int i;
351         DEBUG(10,("cli_errno_from_nt: 32 bit codes: code=%08x\n", NT_STATUS_V(status)));
352
353         /* Status codes without this bit set are not errors */
354
355         if (!(NT_STATUS_V(status) & 0xc0000000)) {
356                 return 0;
357         }
358
359         for (i=0;nt_errno_map[i].error;i++) {
360                 if (NT_STATUS_V(nt_errno_map[i].status) ==
361                     NT_STATUS_V(status)) return nt_errno_map[i].error;
362         }
363
364         /* for all other cases - a default code */
365         return EINVAL;
366 }
367
368 /* Return a UNIX errno appropriate for the error received in the last
369    packet. */
370
371 int cli_errno(struct cli_state *cli)
372 {
373         NTSTATUS status;
374
375         if (cli_is_nt_error(cli)) {
376                 status = cli_nt_error(cli);
377                 return cli_errno_from_nt(status);
378         }
379
380         if (cli_is_dos_error(cli)) {
381                 uint8 eclass;
382                 uint32 ecode;
383
384                 cli_dos_error(cli, &eclass, &ecode);
385                 status = dos_to_ntstatus(eclass, ecode);
386                 return cli_errno_from_nt(status);
387         }
388
389         /*
390          * Yuck!  A special case for this Vista error.  Since its high-order
391          * byte isn't 0xc0, it doesn't match cli_is_nt_error() above.
392          */
393         status = cli_nt_error(cli);
394         if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INACCESSIBLE_SYSTEM_SHORTCUT)) {
395             return EACCES;
396         }
397
398         /* for other cases */
399         return EINVAL;
400 }
401
402 /* Return true if the last packet was in error */
403
404 BOOL cli_is_error(struct cli_state *cli)
405 {
406         uint32 flgs2 = SVAL(cli->inbuf,smb_flg2), rcls = 0;
407
408         /* A socket error is always an error. */
409         if (cli->fd == -1 && cli->smb_rw_error != 0) {
410                 return True;
411         }
412
413         if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
414                 /* Return error is error bits are set */
415                 rcls = IVAL(cli->inbuf, smb_rcls);
416                 return (rcls & 0xF0000000) == 0xC0000000;
417         }
418                 
419         /* Return error if error class in non-zero */
420
421         rcls = CVAL(cli->inbuf, smb_rcls);
422         return rcls != 0;
423 }
424
425 /* Return true if the last error was an NT error */
426
427 BOOL cli_is_nt_error(struct cli_state *cli)
428 {
429         uint32 flgs2 = SVAL(cli->inbuf,smb_flg2);
430
431         /* A socket error is always an NT error. */
432         if (cli->fd == -1 && cli->smb_rw_error != 0) {
433                 return True;
434         }
435
436         return cli_is_error(cli) && (flgs2 & FLAGS2_32_BIT_ERROR_CODES);
437 }
438
439 /* Return true if the last error was a DOS error */
440
441 BOOL cli_is_dos_error(struct cli_state *cli)
442 {
443         uint32 flgs2 = SVAL(cli->inbuf,smb_flg2);
444
445         /* A socket error is always a DOS error. */
446         if (cli->fd == -1 && cli->smb_rw_error != 0) {
447                 return True;
448         }
449
450         return cli_is_error(cli) && !(flgs2 & FLAGS2_32_BIT_ERROR_CODES);
451 }
452
453 /* Return the last error always as an NTSTATUS. */
454
455 NTSTATUS cli_get_nt_error(struct cli_state *cli)
456 {
457         if (cli_is_nt_error(cli)) {
458                 return cli_nt_error(cli);
459         } else if (cli_is_dos_error(cli)) {
460                 uint32 ecode;
461                 uint8 eclass;
462                 cli_dos_error(cli, &eclass, &ecode);
463                 return dos_to_ntstatus(eclass, ecode);
464         } else {
465                 /* Something went wrong, we don't know what. */
466                 return NT_STATUS_UNSUCCESSFUL;
467         }
468 }
469
470 /* Push an error code into the inbuf to be returned on the next
471  * query. */
472
473 void cli_set_nt_error(struct cli_state *cli, NTSTATUS status)
474 {
475         SSVAL(cli->inbuf,smb_flg2, SVAL(cli->inbuf,smb_flg2)|FLAGS2_32_BIT_ERROR_CODES);
476         SIVAL(cli->inbuf, smb_rcls, NT_STATUS_V(status));
477 }