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