source: vendor/3.6.9/source3/libsmb/libsmb_stat.c

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

Samba Server: update vendor to 3.6.0
File size: 13.7 KB
Line 
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
35static ino_t
36generate_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
53static int
54setup_stat(SMBCCTX *context,
55 struct stat *st,
56 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
106int
107SMBC_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, (char *) 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
199int
200SMBC_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 */
300int
301SMBC_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
353int
354SMBC_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}
Note: See TracBrowser for help on using the repository browser.