[Bug 6228] SMBC_open_ctx failure due to path resolve failure doesn't set errno
[samba.git] / source3 / libsmb / libsmb_stat.c
1 /* 
2    Unix SMB/Netbios implementation.
3    SMB client library implementation
4    Copyright (C) Andrew Tridgell 1998
5    Copyright (C) Richard Sharpe 2000, 2002
6    Copyright (C) John Terpstra 2000
7    Copyright (C) Tom Jansen (Ninja ISD) 2002 
8    Copyright (C) Derrell Lipman 2003-2008
9    Copyright (C) Jeremy Allison 2007, 2008
10    
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15    
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20    
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "includes.h"
26 #include "libsmbclient.h"
27 #include "libsmb_internal.h"
28
29
30 /* 
31  * Generate an inode number from file name for those things that need it
32  */
33
34 static ino_t
35 generate_inode(SMBCCTX *context,
36                const char *name)
37 {
38         if (!context || !context->internal->initialized) {
39                 
40                 errno = EINVAL;
41                 return -1;
42                 
43         }
44         
45         if (!*name) return 2; /* FIXME, why 2 ??? */
46         return (ino_t)str_checksum(name);
47         
48 }
49
50 /*
51  * Routine to put basic stat info into a stat structure ... Used by stat and
52  * fstat below.
53  */
54
55 static int
56 setup_stat(SMBCCTX *context,
57            struct stat *st,
58            char *fname,
59            SMB_OFF_T size,
60            int mode)
61 {
62         TALLOC_CTX *frame = talloc_stackframe();
63         
64         st->st_mode = 0;
65         
66         if (IS_DOS_DIR(mode)) {
67                 st->st_mode = SMBC_DIR_MODE;
68         } else {
69                 st->st_mode = SMBC_FILE_MODE;
70         }
71         
72         if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
73         if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
74         if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
75         if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
76         
77         st->st_size = size;
78 #ifdef HAVE_STAT_ST_BLKSIZE
79         st->st_blksize = 512;
80 #endif
81 #ifdef HAVE_STAT_ST_BLOCKS
82         st->st_blocks = (size+511)/512;
83 #endif
84 #ifdef HAVE_STRUCT_STAT_ST_RDEV
85         st->st_rdev = 0;
86 #endif
87         st->st_uid = getuid();
88         st->st_gid = getgid();
89         
90         if (IS_DOS_DIR(mode)) {
91                 st->st_nlink = 2;
92         } else {
93                 st->st_nlink = 1;
94         }
95         
96         if (st->st_ino == 0) {
97                 st->st_ino = generate_inode(context, fname);
98         }
99         
100         TALLOC_FREE(frame);
101         return True;  /* FIXME: Is this needed ? */
102         
103 }
104
105 /*
106  * Routine to stat a file given a name
107  */
108
109 int
110 SMBC_stat_ctx(SMBCCTX *context,
111               const char *fname,
112               struct stat *st)
113 {
114         SMBCSRV *srv = NULL;
115         char *server = NULL;
116         char *share = NULL;
117         char *user = NULL;
118         char *password = NULL;
119         char *workgroup = NULL;
120         char *path = NULL;
121         struct timespec write_time_ts;
122         struct timespec access_time_ts;
123         struct timespec change_time_ts;
124         SMB_OFF_T size = 0;
125         uint16 mode = 0;
126         SMB_INO_T ino = 0;
127         TALLOC_CTX *frame = talloc_stackframe();
128         
129         if (!context || !context->internal->initialized) {
130                 
131                 errno = EINVAL;  /* Best I can think of ... */
132                 TALLOC_FREE(frame);
133                 return -1;
134         }
135         
136         if (!fname) {
137                 errno = EINVAL;
138                 TALLOC_FREE(frame);
139                 return -1;
140         }
141         
142         DEBUG(4, ("smbc_stat(%s)\n", fname));
143         
144         if (SMBC_parse_path(frame,
145                             context,
146                             fname,
147                             &workgroup,
148                             &server,
149                             &share,
150                             &path,
151                             &user,
152                             &password,
153                             NULL)) {
154                 errno = EINVAL;
155                 TALLOC_FREE(frame);
156                 return -1;
157         }
158
159         if (!user || user[0] == (char)0) {
160                 user = talloc_strdup(frame, smbc_getUser(context));
161                 if (!user) {
162                         errno = ENOMEM;
163                         TALLOC_FREE(frame);
164                         return -1;
165                 }
166         }
167         
168         srv = SMBC_server(frame, context, True,
169                           server, share, &workgroup, &user, &password);
170         
171         if (!srv) {
172                 TALLOC_FREE(frame);
173                 return -1;  /* errno set by SMBC_server */
174         }
175         
176         if (!SMBC_getatr(context, srv, path, &mode, &size,
177                          NULL,
178                          &access_time_ts,
179                          &write_time_ts,
180                          &change_time_ts,
181                          &ino)) {
182                 errno = SMBC_errno(context, srv->cli);
183                 TALLOC_FREE(frame);
184                 return -1;
185         }
186         
187         st->st_ino = ino;
188         
189         setup_stat(context, st, (char *) fname, size, mode);
190         
191         set_atimespec(st, access_time_ts);
192         set_ctimespec(st, change_time_ts);
193         set_mtimespec(st, write_time_ts);
194         st->st_dev   = srv->dev;
195         
196         TALLOC_FREE(frame);
197         return 0;
198         
199 }
200
201 /*
202  * Routine to stat a file given an fd
203  */
204
205 int
206 SMBC_fstat_ctx(SMBCCTX *context,
207                SMBCFILE *file,
208                struct stat *st)
209 {
210         struct timespec change_time_ts;
211         struct timespec access_time_ts;
212         struct timespec write_time_ts;
213         SMB_OFF_T size;
214         uint16 mode;
215         char *server = NULL;
216         char *share = NULL;
217         char *user = NULL;
218         char *password = NULL;
219         char *path = NULL;
220         char *targetpath = NULL;
221         struct cli_state *targetcli = NULL;
222         SMB_INO_T ino = 0;
223         TALLOC_CTX *frame = talloc_stackframe();
224         
225         if (!context || !context->internal->initialized) {
226                 
227                 errno = EINVAL;
228                 TALLOC_FREE(frame);
229                 return -1;
230         }
231         
232         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
233                 errno = EBADF;
234                 TALLOC_FREE(frame);
235                 return -1;
236         }
237         
238         if (!file->file) {
239                 TALLOC_FREE(frame);
240                 return smbc_getFunctionFstatdir(context)(context, file, st);
241         }
242         
243         /*d_printf(">>>fstat: parsing %s\n", file->fname);*/
244         if (SMBC_parse_path(frame,
245                             context,
246                             file->fname,
247                             NULL,
248                             &server,
249                             &share,
250                             &path,
251                             &user,
252                             &password,
253                             NULL)) {
254                 errno = EINVAL;
255                 TALLOC_FREE(frame);
256                 return -1;
257         }
258         
259         /*d_printf(">>>fstat: resolving %s\n", path);*/
260         if (!cli_resolve_path(frame, "", context->internal->auth_info,
261                         file->srv->cli, path,
262                         &targetcli, &targetpath)) {
263                 d_printf("Could not resolve %s\n", path);
264                 errno = ENOENT;
265                 TALLOC_FREE(frame);
266                 return -1;
267         }
268         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
269         
270         if (!cli_qfileinfo(targetcli, file->cli_fd, &mode, &size,
271                            NULL,
272                            &access_time_ts,
273                            &write_time_ts,
274                            &change_time_ts,
275                            &ino)) {
276                 
277                 time_t change_time, access_time, write_time;
278                 
279                 if (!cli_getattrE(targetcli, file->cli_fd, &mode, &size,
280                                   &change_time, &access_time, &write_time)) {
281                         
282                         errno = EINVAL;
283                         TALLOC_FREE(frame);
284                         return -1;
285                 }
286                 
287                 change_time_ts = convert_time_t_to_timespec(change_time);
288                 access_time_ts = convert_time_t_to_timespec(access_time);
289                 write_time_ts = convert_time_t_to_timespec(write_time);
290         }
291         
292         st->st_ino = ino;
293         
294         setup_stat(context, st, file->fname, size, mode);
295         
296         set_atimespec(st, access_time_ts);
297         set_ctimespec(st, change_time_ts);
298         set_mtimespec(st, write_time_ts);
299         st->st_dev = file->srv->dev;
300         
301         TALLOC_FREE(frame);
302         return 0;
303         
304 }
305
306
307 /*
308  * Routine to obtain file system information given a path
309  */
310 int
311 SMBC_statvfs_ctx(SMBCCTX *context,
312                  char *path,
313                  struct statvfs *st)
314 {
315         int             ret;
316         bool            bIsDir;
317         struct stat     statbuf;
318         SMBCFILE *      pFile;
319
320         /* Determine if the provided path is a file or a folder */
321         if (SMBC_stat_ctx(context, path, &statbuf) < 0) {
322                 return -1;
323         }
324
325         /* Is it a file or a directory?  */
326         if (S_ISDIR(statbuf.st_mode)) {
327                 /* It's a directory. */
328                 if ((pFile = SMBC_opendir_ctx(context, path)) == NULL) {
329                         return -1;
330                 }
331                 bIsDir = true;
332         } else if (S_ISREG(statbuf.st_mode)) {
333                 /* It's a file. */
334                 if ((pFile = SMBC_open_ctx(context, path,
335                                            O_RDONLY, 0)) == NULL) {
336                         return -1;
337                 }
338                 bIsDir = false;
339         } else {
340                 /* It's neither a file nor a directory. Not supported. */
341                 errno = ENOSYS;
342                 return -1;
343         }
344
345         /* Now we have an open file handle, so just use SMBC_fstatvfs */
346         ret = SMBC_fstatvfs_ctx(context, pFile, st);
347
348         /* Close the file or directory */
349         if (bIsDir) {
350                 SMBC_closedir_ctx(context, pFile);
351         } else {
352                 SMBC_close_ctx(context, pFile);
353         }
354
355         return ret;
356 }
357
358
359 /*
360  * Routine to obtain file system information given an fd
361  */
362
363 int
364 SMBC_fstatvfs_ctx(SMBCCTX *context,
365                   SMBCFILE *file,
366                   struct statvfs *st)
367 {
368         unsigned long flags = 0;
369         uint32 fs_attrs = 0;
370         struct cli_state *cli = file->srv->cli;
371                 
372
373         /* Initialize all fields (at least until we actually use them) */
374         memset(st, 0, sizeof(*st));
375
376         /*
377          * The state of each flag is such that the same bits are unset as
378          * would typically be unset on a local file system on a POSIX OS. Thus
379          * the bit is on, for example, only for case-insensitive file systems
380          * since most POSIX file systems are case sensitive and fstatvfs()
381          * would typically return zero in these bits on such a local file
382          * system.
383          */
384
385         /* See if the server has UNIX CIFS support */
386         if (! SERVER_HAS_UNIX_CIFS(cli)) {
387                 uint64_t total_allocation_units;
388                 uint64_t caller_allocation_units;
389                 uint64_t actual_allocation_units;
390                 uint64_t sectors_per_allocation_unit;
391                 uint64_t bytes_per_sector;
392                 
393                 /* Nope. If size data is available... */
394                 if (cli_get_fs_full_size_info(cli,
395                                               &total_allocation_units,
396                                               &caller_allocation_units,
397                                               &actual_allocation_units,
398                                               &sectors_per_allocation_unit,
399                                               &bytes_per_sector)) {
400
401                         /* ... then provide it */
402                         st->f_bsize =
403                                 (unsigned long) bytes_per_sector;
404 #if HAVE_FRSIZE
405                         st->f_frsize =
406                                 (unsigned long) sectors_per_allocation_unit;
407 #endif
408                         st->f_blocks =
409                                 (fsblkcnt_t) total_allocation_units;
410                         st->f_bfree =
411                                 (fsblkcnt_t) actual_allocation_units;
412                 }
413
414                 flags |= SMBC_VFS_FEATURE_NO_UNIXCIFS;
415         } else {
416                 uint32 optimal_transfer_size;
417                 uint32 block_size;
418                 uint64_t total_blocks;
419                 uint64_t blocks_available;
420                 uint64_t user_blocks_available;
421                 uint64_t total_file_nodes;
422                 uint64_t free_file_nodes;
423                 uint64_t fs_identifier;
424
425                 /* Has UNIXCIFS. If POSIX filesystem info is available... */
426                 if (cli_get_posix_fs_info(cli,
427                                           &optimal_transfer_size,
428                                           &block_size,
429                                           &total_blocks,
430                                           &blocks_available,
431                                           &user_blocks_available,
432                                           &total_file_nodes,
433                                           &free_file_nodes,
434                                           &fs_identifier)) {
435
436                         /* ... then what's provided here takes precedence. */
437                         st->f_bsize =
438                                 (unsigned long) block_size;
439                         st->f_blocks =
440                                 (fsblkcnt_t) total_blocks;
441                         st->f_bfree =
442                                 (fsblkcnt_t) blocks_available;
443                         st->f_bavail =
444                                 (fsblkcnt_t) user_blocks_available;
445                         st->f_files =
446                                 (fsfilcnt_t) total_file_nodes;
447                         st->f_ffree =
448                                 (fsfilcnt_t) free_file_nodes;
449 #if HAVE_FSID_INT
450                         st->f_fsid =
451                                 (unsigned long) fs_identifier;
452 #endif
453                 }
454         }
455
456         /* See if the share is case sensitive */
457         if (!cli_get_fs_attr_info(cli, &fs_attrs)) {
458                 /*
459                  * We can't determine the case sensitivity of
460                  * the share. We have no choice but to use the
461                  * user-specified case sensitivity setting.
462                  */
463                 if (! smbc_getOptionCaseSensitive(context)) {
464                         flags |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
465                 }
466         } else {
467                 if (! (fs_attrs & FILE_CASE_SENSITIVE_SEARCH)) {
468                         flags |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
469                 }
470         }
471
472         /* See if DFS is supported */
473         if ((cli->capabilities & CAP_DFS) &&  cli->dfsroot) {
474                 flags |= SMBC_VFS_FEATURE_DFS;
475         }
476
477 #if HAVE_STATVFS_F_FLAG
478         st->f_flag = flags;
479 #elif HAVE_STATVFS_F_FLAGS
480         st->f_flags = flags;
481 #endif
482
483         return 0;
484 }