d589f7ef712b61b32a9b157f0eacdbd3de1e5fed
[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, "", file->srv->cli, path,
261                               &targetcli, &targetpath)) {
262                 d_printf("Could not resolve %s\n", path);
263                 TALLOC_FREE(frame);
264                 return -1;
265         }
266         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
267         
268         if (!cli_qfileinfo(targetcli, file->cli_fd, &mode, &size,
269                            NULL,
270                            &access_time_ts,
271                            &write_time_ts,
272                            &change_time_ts,
273                            &ino)) {
274                 
275                 time_t change_time, access_time, write_time;
276                 
277                 if (!cli_getattrE(targetcli, file->cli_fd, &mode, &size,
278                                   &change_time, &access_time, &write_time)) {
279                         
280                         errno = EINVAL;
281                         TALLOC_FREE(frame);
282                         return -1;
283                 }
284                 
285                 change_time_ts = convert_time_t_to_timespec(change_time);
286                 access_time_ts = convert_time_t_to_timespec(access_time);
287                 write_time_ts = convert_time_t_to_timespec(write_time);
288         }
289         
290         st->st_ino = ino;
291         
292         setup_stat(context, st, file->fname, size, mode);
293         
294         set_atimespec(st, access_time_ts);
295         set_ctimespec(st, change_time_ts);
296         set_mtimespec(st, write_time_ts);
297         st->st_dev = file->srv->dev;
298         
299         TALLOC_FREE(frame);
300         return 0;
301         
302 }
303
304
305 /*
306  * Routine to obtain file system information given a path
307  */
308 int
309 SMBC_statvfs_ctx(SMBCCTX *context,
310                  char *path,
311                  struct statvfs *st)
312 {
313         int             ret;
314         bool            bIsDir;
315         struct stat     statbuf;
316         SMBCFILE *      pFile;
317
318         /* Determine if the provided path is a file or a folder */
319         if (SMBC_stat_ctx(context, path, &statbuf) < 0) {
320                 return -1;
321         }
322
323         /* Is it a file or a directory?  */
324         if (S_ISDIR(statbuf.st_mode)) {
325                 /* It's a directory. */
326                 if ((pFile = SMBC_opendir_ctx(context, path)) < 0) {
327                         return -1;
328                 }
329                 bIsDir = true;
330         } else if (S_ISREG(statbuf.st_mode)) {
331                 /* It's a file. */
332                 if ((pFile = SMBC_open_ctx(context, path, O_RDONLY, 0)) < 0) {
333                         return -1;
334                 }
335                 bIsDir = false;
336         } else {
337                 /* It's neither a file nor a directory. Not supported. */
338                 errno = ENOSYS;
339                 return -1;
340         }
341
342         /* Now we have an open file handle, so just use SMBC_fstatvfs */
343         ret = SMBC_fstatvfs_ctx(context, pFile, st);
344
345         /* Close the file or directory */
346         if (bIsDir) {
347                 SMBC_closedir_ctx(context, pFile);
348         } else {
349                 SMBC_close_ctx(context, pFile);
350         }
351
352         return ret;
353 }
354
355
356 /*
357  * Routine to obtain file system information given an fd
358  */
359
360 int
361 SMBC_fstatvfs_ctx(SMBCCTX *context,
362                   SMBCFILE *file,
363                   struct statvfs *st)
364 {
365         uint32 fs_attrs = 0;
366         struct cli_state *cli = file->srv->cli;
367                 
368
369         /* Initialize all fields (at least until we actually use them) */
370         memset(st, 0, sizeof(*st));
371
372         /*
373          * The state of each flag is such that the same bits are unset as
374          * would typically be unset on a local file system on a POSIX OS. Thus
375          * the bit is on, for example, only for case-insensitive file systems
376          * since most POSIX file systems are case sensitive and fstatvfs()
377          * would typically return zero in these bits on such a local file
378          * system.
379          */
380
381         /* See if the server has UNIX CIFS support */
382         if (! SERVER_HAS_UNIX_CIFS(cli)) {
383                 uint64_t total_allocation_units;
384                 uint64_t caller_allocation_units;
385                 uint64_t actual_allocation_units;
386                 uint64_t sectors_per_allocation_unit;
387                 uint64_t bytes_per_sector;
388                 
389                 /* Nope. If size data is available... */
390                 if (cli_get_fs_full_size_info(cli,
391                                               &total_allocation_units,
392                                               &caller_allocation_units,
393                                               &actual_allocation_units,
394                                               &sectors_per_allocation_unit,
395                                               &bytes_per_sector)) {
396
397                         /* ... then provide it */
398                         st->f_bsize =
399                                 (unsigned long) bytes_per_sector;
400                         st->f_frsize =
401                                 (unsigned long) sectors_per_allocation_unit;
402                         st->f_blocks =
403                                 (fsblkcnt_t) total_allocation_units;
404                         st->f_bfree =
405                                 (fsblkcnt_t) actual_allocation_units;
406                 }
407
408                 st->f_flag |= SMBC_VFS_FEATURE_NO_UNIXCIFS;
409         } else {
410                 uint32 optimal_transfer_size;
411                 uint32 block_size;
412                 uint64_t total_blocks;
413                 uint64_t blocks_available;
414                 uint64_t user_blocks_available;
415                 uint64_t total_file_nodes;
416                 uint64_t free_file_nodes;
417                 uint64_t fs_identifier;
418
419                 /* Has UNIXCIFS. If POSIX filesystem info is available... */
420                 if (cli_get_posix_fs_info(cli,
421                                           &optimal_transfer_size,
422                                           &block_size,
423                                           &total_blocks,
424                                           &blocks_available,
425                                           &user_blocks_available,
426                                           &total_file_nodes,
427                                           &free_file_nodes,
428                                           &fs_identifier)) {
429
430                         /* ... then what's provided here takes precedence. */
431                         st->f_bsize =
432                                 (unsigned long) block_size;
433                         st->f_blocks =
434                                 (fsblkcnt_t) total_blocks;
435                         st->f_bfree =
436                                 (fsblkcnt_t) blocks_available;
437                         st->f_bavail =
438                                 (fsblkcnt_t) user_blocks_available;
439                         st->f_files =
440                                 (fsfilcnt_t) total_file_nodes;
441                         st->f_ffree =
442                                 (fsfilcnt_t) free_file_nodes;
443                         st->f_fsid =
444                                 (unsigned long) fs_identifier;
445                         
446                 }
447         }
448
449         /* See if the share is case sensitive */
450         if (!cli_get_fs_attr_info(cli, &fs_attrs)) {
451                 /*
452                  * We can't determine the case sensitivity of
453                  * the share. We have no choice but to use the
454                  * user-specified case sensitivity setting.
455                  */
456                 if (! smbc_getOptionCaseSensitive(context)) {
457                         st->f_flag |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
458                 }
459         } else {
460                 if (! (fs_attrs & FILE_CASE_SENSITIVE_SEARCH)) {
461                         st->f_flag |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
462                 }
463         }
464
465         /* See if DFS is supported */
466         if ((cli->capabilities & CAP_DFS) &&  cli->dfsroot) {
467                 st->f_flag |= SMBC_VFS_FEATURE_DFS;
468         }
469
470         return 0;
471 }