?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4 dns: Implement RFC-compatible update prescan
[Samba/gebeck_regimport.git] / source3 / lib / system.c
blob85988417a65ed434403b3f7bbc0779fa1a0622e6
1 /*
2 Unix SMB/CIFS implementation.
3 Samba system utilities
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 1998-2005
6 Copyright (C) Timur Bakeyev 2005
7 Copyright (C) Bjoern Jacke 2006-2007
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "system/syslog.h"
25 #include "system/capability.h"
26 #include "system/passwd.h"
27 #include "system/filesys.h"
28
29 #ifdef HAVE_SYS_PRCTL_H
30 #include <sys/prctl.h>
31 #endif
32
33 /*
34 The idea is that this file will eventually have wrappers around all
35 important system calls in samba. The aims are:
36
37 - to enable easier porting by putting OS dependent stuff in here
38
39 - to allow for hooks into other "pseudo-filesystems"
40
41 - to allow easier integration of things like the japanese extensions
42
43 - to support the philosophy of Samba to expose the features of
44 the OS within the SMB model. In general whatever file/printer/variable
45 expansions/etc make sense to the OS should be acceptable to Samba.
46 */
47
48
49
50 /*******************************************************************
51 A wrapper for usleep in case we don't have one.
52 ********************************************************************/
53
54 int sys_usleep(long usecs)
55 {
56 #ifndef HAVE_USLEEP
57 struct timeval tval;
58 #endif
59
60 /*
61 * We need this braindamage as the glibc usleep
62 * is not SPEC1170 complient... grumble... JRA.
63 */
64
65 if(usecs < 0 || usecs > 999999) {
66 errno = EINVAL;
67 return -1;
68 }
69
70 #if HAVE_USLEEP
71 usleep(usecs);
72 return 0;
73 #else /* HAVE_USLEEP */
74 /*
75 * Fake it with select...
76 */
77 tval.tv_sec = 0;
78 tval.tv_usec = usecs/1000;
79 select(0,NULL,NULL,NULL,&tval);
80 return 0;
81 #endif /* HAVE_USLEEP */
82 }
83
84 /*******************************************************************
85 A read wrapper that will deal with EINTR.
86 ********************************************************************/
87
88 ssize_t sys_read(int fd, void *buf, size_t count)
89 {
90 ssize_t ret;
91
92 do {
93 ret = read(fd, buf, count);
94 #if defined(EWOULDBLOCK)
95 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
96 #else
97 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
98 #endif
99 return ret;
100 }
101
102 /*******************************************************************
103 A write wrapper that will deal with EINTR.
104 ********************************************************************/
105
106 ssize_t sys_write(int fd, const void *buf, size_t count)
107 {
108 ssize_t ret;
109
110 do {
111 ret = write(fd, buf, count);
112 #if defined(EWOULDBLOCK)
113 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
114 #else
115 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
116 #endif
117 return ret;
118 }
119
120 /*******************************************************************
121 A writev wrapper that will deal with EINTR.
122 ********************************************************************/
123
124 ssize_t sys_writev(int fd, const struct iovec *iov, int iovcnt)
125 {
126 ssize_t ret;
127
128 #if 0
129 /* Try to confuse write_data_iov a bit */
130 if ((random() % 5) == 0) {
131 return sys_write(fd, iov[0].iov_base, iov[0].iov_len);
132 }
133 if (iov[0].iov_len > 1) {
134 return sys_write(fd, iov[0].iov_base,
135 (random() % (iov[0].iov_len-1)) + 1);
136 }
137 #endif
138
139 do {
140 ret = writev(fd, iov, iovcnt);
141 #if defined(EWOULDBLOCK)
142 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
143 #else
144 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
145 #endif
146 return ret;
147 }
148
149 /*******************************************************************
150 A pread wrapper that will deal with EINTR and 64-bit file offsets.
151 ********************************************************************/
152
153 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
154 ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
155 {
156 ssize_t ret;
157
158 do {
159 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PREAD64)
160 ret = pread64(fd, buf, count, off);
161 #else
162 ret = pread(fd, buf, count, off);
163 #endif
164 } while (ret == -1 && errno == EINTR);
165 return ret;
166 }
167 #endif
168
169 /*******************************************************************
170 A write wrapper that will deal with EINTR and 64-bit file offsets.
171 ********************************************************************/
172
173 #if defined(HAVE_PWRITE) || defined(HAVE_PWRITE64)
174 ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off)
175 {
176 ssize_t ret;
177
178 do {
179 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64)
180 ret = pwrite64(fd, buf, count, off);
181 #else
182 ret = pwrite(fd, buf, count, off);
183 #endif
184 } while (ret == -1 && errno == EINTR);
185 return ret;
186 }
187 #endif
188
189 /*******************************************************************
190 A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
191 ********************************************************************/
192
193 ssize_t sys_send(int s, const void *msg, size_t len, int flags)
194 {
195 ssize_t ret;
196
197 do {
198 ret = send(s, msg, len, flags);
199 #if defined(EWOULDBLOCK)
200 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
201 #else
202 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
203 #endif
204 return ret;
205 }
206
207 /*******************************************************************
208 A sendto wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
209 ********************************************************************/
210
211 ssize_t sys_sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
212 {
213 ssize_t ret;
214
215 do {
216 ret = sendto(s, msg, len, flags, to, tolen);
217 #if defined(EWOULDBLOCK)
218 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
219 #else
220 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
221 #endif
222 return ret;
223 }
224
225 /*******************************************************************
226 A recv wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
227 ********************************************************************/
228
229 ssize_t sys_recv(int fd, void *buf, size_t count, int flags)
230 {
231 ssize_t ret;
232
233 do {
234 ret = recv(fd, buf, count, flags);
235 #if defined(EWOULDBLOCK)
236 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
237 #else
238 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
239 #endif
240 return ret;
241 }
242
243 /*******************************************************************
244 A recvfrom wrapper that will deal with EINTR.
245 ********************************************************************/
246
247 ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
248 {
249 ssize_t ret;
250
251 do {
252 ret = recvfrom(s, buf, len, flags, from, fromlen);
253 #if defined(EWOULDBLOCK)
254 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
255 #else
256 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
257 #endif
258 return ret;
259 }
260
261 /*******************************************************************
262 A fcntl wrapper that will deal with EINTR.
263 ********************************************************************/
264
265 int sys_fcntl_ptr(int fd, int cmd, void *arg)
266 {
267 int ret;
268
269 do {
270 ret = fcntl(fd, cmd, arg);
271 } while (ret == -1 && errno == EINTR);
272 return ret;
273 }
274
275 /*******************************************************************
276 A fcntl wrapper that will deal with EINTR.
277 ********************************************************************/
278
279 int sys_fcntl_long(int fd, int cmd, long arg)
280 {
281 int ret;
282
283 do {
284 ret = fcntl(fd, cmd, arg);
285 } while (ret == -1 && errno == EINTR);
286 return ret;
287 }
288
289 /****************************************************************************
290 Get/Set all the possible time fields from a stat struct as a timespec.
291 ****************************************************************************/
292
293 static struct timespec get_atimespec(const struct stat *pst)
294 {
295 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
296 struct timespec ret;
297
298 /* Old system - no ns timestamp. */
299 ret.tv_sec = pst->st_atime;
300 ret.tv_nsec = 0;
301 return ret;
302 #else
303 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
304 return pst->st_atim;
305 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
306 struct timespec ret;
307 ret.tv_sec = pst->st_atime;
308 ret.tv_nsec = pst->st_atimensec;
309 return ret;
310 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
311 struct timespec ret;
312 ret.tv_sec = pst->st_atime;
313 ret.tv_nsec = pst->st_atime_n;
314 return ret;
315 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
316 struct timespec ret;
317 ret.tv_sec = pst->st_atime;
318 ret.tv_nsec = pst->st_uatime * 1000;
319 return ret;
320 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
321 return pst->st_atimespec;
322 #else
323 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
324 #endif
325 #endif
326 }
327
328 static struct timespec get_mtimespec(const struct stat *pst)
329 {
330 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
331 struct timespec ret;
332
333 /* Old system - no ns timestamp. */
334 ret.tv_sec = pst->st_mtime;
335 ret.tv_nsec = 0;
336 return ret;
337 #else
338 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
339 return pst->st_mtim;
340 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
341 struct timespec ret;
342 ret.tv_sec = pst->st_mtime;
343 ret.tv_nsec = pst->st_mtimensec;
344 return ret;
345 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
346 struct timespec ret;
347 ret.tv_sec = pst->st_mtime;
348 ret.tv_nsec = pst->st_mtime_n;
349 return ret;
350 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
351 struct timespec ret;
352 ret.tv_sec = pst->st_mtime;
353 ret.tv_nsec = pst->st_umtime * 1000;
354 return ret;
355 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
356 return pst->st_mtimespec;
357 #else
358 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
359 #endif
360 #endif
361 }
362
363 static struct timespec get_ctimespec(const struct stat *pst)
364 {
365 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
366 struct timespec ret;
367
368 /* Old system - no ns timestamp. */
369 ret.tv_sec = pst->st_ctime;
370 ret.tv_nsec = 0;
371 return ret;
372 #else
373 #if defined(HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
374 return pst->st_ctim;
375 #elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
376 struct timespec ret;
377 ret.tv_sec = pst->st_ctime;
378 ret.tv_nsec = pst->st_ctimensec;
379 return ret;
380 #elif defined(HAVE_STRUCT_STAT_ST_MTIME_N)
381 struct timespec ret;
382 ret.tv_sec = pst->st_ctime;
383 ret.tv_nsec = pst->st_ctime_n;
384 return ret;
385 #elif defined(HAVE_STRUCT_STAT_ST_UMTIME)
386 struct timespec ret;
387 ret.tv_sec = pst->st_ctime;
388 ret.tv_nsec = pst->st_uctime * 1000;
389 return ret;
390 #elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
391 return pst->st_ctimespec;
392 #else
393 #error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
394 #endif
395 #endif
396 }
397
398 /****************************************************************************
399 Return the best approximation to a 'create time' under UNIX from a stat
400 structure.
401 ****************************************************************************/
402
403 static struct timespec calc_create_time_stat(const struct stat *st)
404 {
405 struct timespec ret, ret1;
406 struct timespec c_time = get_ctimespec(st);
407 struct timespec m_time = get_mtimespec(st);
408 struct timespec a_time = get_atimespec(st);
409
410 ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
411 ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
412
413 if(!null_timespec(ret1)) {
414 return ret1;
415 }
416
417 /*
418 * One of ctime, mtime or atime was zero (probably atime).
419 * Just return MIN(ctime, mtime).
420 */
421 return ret;
422 }
423
424 /****************************************************************************
425 Return the best approximation to a 'create time' under UNIX from a stat_ex
426 structure.
427 ****************************************************************************/
428
429 static struct timespec calc_create_time_stat_ex(const struct stat_ex *st)
430 {
431 struct timespec ret, ret1;
432 struct timespec c_time = st->st_ex_ctime;
433 struct timespec m_time = st->st_ex_mtime;
434 struct timespec a_time = st->st_ex_atime;
435
436 ret = timespec_compare(&c_time, &m_time) < 0 ? c_time : m_time;
437 ret1 = timespec_compare(&ret, &a_time) < 0 ? ret : a_time;
438
439 if(!null_timespec(ret1)) {
440 return ret1;
441 }
442
443 /*
444 * One of ctime, mtime or atime was zero (probably atime).
445 * Just return MIN(ctime, mtime).
446 */
447 return ret;
448 }
449
450 /****************************************************************************
451 Return the 'create time' from a stat struct if it exists (birthtime) or else
452 use the best approximation.
453 ****************************************************************************/
454
455 static void make_create_timespec(const struct stat *pst, struct stat_ex *dst,
456 bool fake_dir_create_times)
457 {
458 if (S_ISDIR(pst->st_mode) && fake_dir_create_times) {
459 dst->st_ex_btime.tv_sec = 315493200L; /* 1/1/1980 */
460 dst->st_ex_btime.tv_nsec = 0;
461 }
462
463 dst->st_ex_calculated_birthtime = false;
464
465 #if defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
466 dst->st_ex_btime = pst->st_birthtimespec;
467 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC)
468 dst->st_ex_btime.tv_sec = pst->st_birthtime;
469 dst->st_ex_btime.tv_nsec = pst->st_birthtimenspec;
470 #elif defined(HAVE_STRUCT_STAT_ST_BIRTHTIME)
471 dst->st_ex_btime.tv_sec = pst->st_birthtime;
472 dst->st_ex_btime.tv_nsec = 0;
473 #else
474 dst->st_ex_btime = calc_create_time_stat(pst);
475 dst->st_ex_calculated_birthtime = true;
476 #endif
477
478 /* Deal with systems that don't initialize birthtime correctly.
479 * Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
480 */
481 if (null_timespec(dst->st_ex_btime)) {
482 dst->st_ex_btime = calc_create_time_stat(pst);
483 dst->st_ex_calculated_birthtime = true;
484 }
485 }
486
487 /****************************************************************************
488 If we update a timestamp in a stat_ex struct we may have to recalculate
489 the birthtime. For now only implement this for write time, but we may
490 also need to do it for atime and ctime. JRA.
491 ****************************************************************************/
492
493 void update_stat_ex_mtime(struct stat_ex *dst,
494 struct timespec write_ts)
495 {
496 dst->st_ex_mtime = write_ts;
497
498 /* We may have to recalculate btime. */
499 if (dst->st_ex_calculated_birthtime) {
500 dst->st_ex_btime = calc_create_time_stat_ex(dst);
501 }
502 }
503
504 void update_stat_ex_create_time(struct stat_ex *dst,
505 struct timespec create_time)
506 {
507 dst->st_ex_btime = create_time;
508 dst->st_ex_calculated_birthtime = false;
509 }
510
511 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
512 void init_stat_ex_from_stat (struct stat_ex *dst,
513 const struct stat64 *src,
514 bool fake_dir_create_times)
515 #else
516 void init_stat_ex_from_stat (struct stat_ex *dst,
517 const struct stat *src,
518 bool fake_dir_create_times)
519 #endif
520 {
521 dst->st_ex_dev = src->st_dev;
522 dst->st_ex_ino = src->st_ino;
523 dst->st_ex_mode = src->st_mode;
524 dst->st_ex_nlink = src->st_nlink;
525 dst->st_ex_uid = src->st_uid;
526 dst->st_ex_gid = src->st_gid;
527 dst->st_ex_rdev = src->st_rdev;
528 dst->st_ex_size = src->st_size;
529 dst->st_ex_atime = get_atimespec(src);
530 dst->st_ex_mtime = get_mtimespec(src);
531 dst->st_ex_ctime = get_ctimespec(src);
532 make_create_timespec(src, dst, fake_dir_create_times);
533 #ifdef HAVE_STAT_ST_BLKSIZE
534 dst->st_ex_blksize = src->st_blksize;
535 #else
536 dst->st_ex_blksize = STAT_ST_BLOCKSIZE;
537 #endif
538
539 #ifdef HAVE_STAT_ST_BLOCKS
540 dst->st_ex_blocks = src->st_blocks;
541 #else
542 dst->st_ex_blocks = src->st_size / dst->st_ex_blksize + 1;
543 #endif
544
545 #ifdef HAVE_STAT_ST_FLAGS
546 dst->st_ex_flags = src->st_flags;
547 #else
548 dst->st_ex_flags = 0;
549 #endif
550 }
551
552 /*******************************************************************
553 A stat() wrapper that will deal with 64 bit filesizes.
554 ********************************************************************/
555
556 int sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf,
557 bool fake_dir_create_times)
558 {
559 int ret;
560 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_STAT64)
561 struct stat64 statbuf;
562 ret = stat64(fname, &statbuf);
563 #else
564 struct stat statbuf;
565 ret = stat(fname, &statbuf);
566 #endif
567 if (ret == 0) {
568 /* we always want directories to appear zero size */
569 if (S_ISDIR(statbuf.st_mode)) {
570 statbuf.st_size = 0;
571 }
572 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
573 }
574 return ret;
575 }
576
577 /*******************************************************************
578 An fstat() wrapper that will deal with 64 bit filesizes.
579 ********************************************************************/
580
581 int sys_fstat(int fd, SMB_STRUCT_STAT *sbuf, bool fake_dir_create_times)
582 {
583 int ret;
584 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FSTAT64)
585 struct stat64 statbuf;
586 ret = fstat64(fd, &statbuf);
587 #else
588 struct stat statbuf;
589 ret = fstat(fd, &statbuf);
590 #endif
591 if (ret == 0) {
592 /* we always want directories to appear zero size */
593 if (S_ISDIR(statbuf.st_mode)) {
594 statbuf.st_size = 0;
595 }
596 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
597 }
598 return ret;
599 }
600
601 /*******************************************************************
602 An lstat() wrapper that will deal with 64 bit filesizes.
603 ********************************************************************/
604
605 int sys_lstat(const char *fname,SMB_STRUCT_STAT *sbuf,
606 bool fake_dir_create_times)
607 {
608 int ret;
609 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSTAT64)
610 struct stat64 statbuf;
611 ret = lstat64(fname, &statbuf);
612 #else
613 struct stat statbuf;
614 ret = lstat(fname, &statbuf);
615 #endif
616 if (ret == 0) {
617 /* we always want directories to appear zero size */
618 if (S_ISDIR(statbuf.st_mode)) {
619 statbuf.st_size = 0;
620 }
621 init_stat_ex_from_stat(sbuf, &statbuf, fake_dir_create_times);
622 }
623 return ret;
624 }
625
626 /*******************************************************************
627 An posix_fallocate() wrapper that will deal with 64 bit filesizes.
628 ********************************************************************/
629 int sys_posix_fallocate(int fd, SMB_OFF_T offset, SMB_OFF_T len)
630 {
631 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_POSIX_FALLOCATE64) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
632 return posix_fallocate64(fd, offset, len);
633 #elif defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
634 return posix_fallocate(fd, offset, len);
635 #elif defined(F_RESVSP64)
636 /* this handles XFS on IRIX */
637 struct flock64 fl;
638 SMB_OFF_T new_len = offset + len;
639 int ret;
640 struct stat64 sbuf;
641
642 /* unlikely to get a too large file on a 64bit system but ... */
643 if (new_len < 0)
644 return EFBIG;
645
646 fl.l_whence = SEEK_SET;
647 fl.l_start = offset;
648 fl.l_len = len;
649
650 ret=fcntl(fd, F_RESVSP64, &fl);
651
652 if (ret != 0)
653 return errno;
654
655 /* Make sure the file gets enlarged after we allocated space: */
656 fstat64(fd, &sbuf);
657 if (new_len > sbuf.st_size)
658 ftruncate64(fd, new_len);
659 return 0;
660 #else
661 return ENOSYS;
662 #endif
663 }
664
665 /*******************************************************************
666 An fallocate() function that matches the semantics of the Linux one.
667 ********************************************************************/
668
669 #ifdef HAVE_LINUX_FALLOC_H
670 #include <linux/falloc.h>
671 #endif
672
673 int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len)
674 {
675 #if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE)
676 int lmode;
677 switch (mode) {
678 case VFS_FALLOCATE_EXTEND_SIZE:
679 lmode = 0;
680 break;
681 case VFS_FALLOCATE_KEEP_SIZE:
682 lmode = FALLOC_FL_KEEP_SIZE;
683 break;
684 default:
685 errno = EINVAL;
686 return -1;
687 }
688 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LINUX_FALLOCATE64)
689 return fallocate64(fd, lmode, offset, len);
690 #elif defined(HAVE_LINUX_FALLOCATE)
691 return fallocate(fd, lmode, offset, len);
692 #endif
693 #else
694 /* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
695 errno = ENOSYS;
696 return -1;
697 #endif
698 }
699
700 /*******************************************************************
701 An ftruncate() wrapper that will deal with 64 bit filesizes.
702 ********************************************************************/
703
704 int sys_ftruncate(int fd, SMB_OFF_T offset)
705 {
706 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_FTRUNCATE64)
707 return ftruncate64(fd, offset);
708 #else
709 return ftruncate(fd, offset);
710 #endif
711 }
712
713 /*******************************************************************
714 An lseek() wrapper that will deal with 64 bit filesizes.
715 ********************************************************************/
716
717 SMB_OFF_T sys_lseek(int fd, SMB_OFF_T offset, int whence)
718 {
719 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LSEEK64)
720 return lseek64(fd, offset, whence);
721 #else
722 return lseek(fd, offset, whence);
723 #endif
724 }
725
726 /*******************************************************************
727 An fseek() wrapper that will deal with 64 bit filesizes.
728 ********************************************************************/
729
730 int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
731 {
732 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
733 return fseek64(fp, offset, whence);
734 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
735 return fseeko64(fp, offset, whence);
736 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO)
737 return fseeko(fp, offset, whence);
738 #else
739 return fseek(fp, offset, whence);
740 #endif
741 }
742
743 /*******************************************************************
744 An ftell() wrapper that will deal with 64 bit filesizes.
745 ********************************************************************/
746
747 SMB_OFF_T sys_ftell(FILE *fp)
748 {
749 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
750 return (SMB_OFF_T)ftell64(fp);
751 #elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
752 return (SMB_OFF_T)ftello64(fp);
753 #else
754 return (SMB_OFF_T)ftell(fp);
755 #endif
756 }
757
758 /*******************************************************************
759 A creat() wrapper that will deal with 64 bit filesizes.
760 ********************************************************************/
761
762 int sys_creat(const char *path, mode_t mode)
763 {
764 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CREAT64)
765 return creat64(path, mode);
766 #else
767 /*
768 * If creat64 isn't defined then ensure we call a potential open64.
769 * JRA.
770 */
771 return sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
772 #endif
773 }
774
775 /*******************************************************************
776 An open() wrapper that will deal with 64 bit filesizes.
777 ********************************************************************/
778
779 int sys_open(const char *path, int oflag, mode_t mode)
780 {
781 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPEN64)
782 return open64(path, oflag, mode);
783 #else
784 return open(path, oflag, mode);
785 #endif
786 }
787
788 /*******************************************************************
789 An fopen() wrapper that will deal with 64 bit filesizes.
790 ********************************************************************/
791
792 FILE *sys_fopen(const char *path, const char *type)
793 {
794 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FOPEN64)
795 return fopen64(path, type);
796 #else
797 return fopen(path, type);
798 #endif
799 }
800
801
802 #if HAVE_KERNEL_SHARE_MODES
803 #ifndef LOCK_MAND
804 #define LOCK_MAND 32 /* This is a mandatory flock */
805 #define LOCK_READ 64 /* ... Which allows concurrent read operations */
806 #define LOCK_WRITE 128 /* ... Which allows concurrent write operations */
807 #define LOCK_RW 192 /* ... Which allows concurrent read & write ops */
808 #endif
809 #endif
810
811 /*******************************************************************
812 A flock() wrapper that will perform the kernel flock.
813 ********************************************************************/
814
815 void kernel_flock(int fd, uint32 share_mode, uint32 access_mask)
816 {
817 #if HAVE_KERNEL_SHARE_MODES
818 int kernel_mode = 0;
819 if (share_mode == FILE_SHARE_WRITE) {
820 kernel_mode = LOCK_MAND|LOCK_WRITE;
821 } else if (share_mode == FILE_SHARE_READ) {
822 kernel_mode = LOCK_MAND|LOCK_READ;
823 } else if (share_mode == FILE_SHARE_NONE) {
824 kernel_mode = LOCK_MAND;
825 }
826 if (kernel_mode) {
827 flock(fd, kernel_mode);
828 }
829 #endif
830 ;
831 }
832
833
834
835 /*******************************************************************
836 An opendir wrapper that will deal with 64 bit filesizes.
837 ********************************************************************/
838
839 SMB_STRUCT_DIR *sys_opendir(const char *name)
840 {
841 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OPENDIR64)
842 return opendir64(name);
843 #else
844 return opendir(name);
845 #endif
846 }
847
848 /*******************************************************************
849 An fdopendir wrapper that will deal with 64 bit filesizes.
850 Ugly hack - we need dirfd for this to work correctly in the
851 calling code.. JRA.
852 ********************************************************************/
853
854 SMB_STRUCT_DIR *sys_fdopendir(int fd)
855 {
856 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FDOPENDIR64) && defined(HAVE_DIRFD)
857 return fdopendir64(fd);
858 #elif defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD)
859 return fdopendir(fd);
860 #else
861 errno = ENOSYS;
862 return NULL;
863 #endif
864 }
865
866 /*******************************************************************
867 A readdir wrapper that will deal with 64 bit filesizes.
868 ********************************************************************/
869
870 SMB_STRUCT_DIRENT *sys_readdir(SMB_STRUCT_DIR *dirp)
871 {
872 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_READDIR64)
873 return readdir64(dirp);
874 #else
875 return readdir(dirp);
876 #endif
877 }
878
879 /*******************************************************************
880 A seekdir wrapper that will deal with 64 bit filesizes.
881 ********************************************************************/
882
883 void sys_seekdir(SMB_STRUCT_DIR *dirp, long offset)
884 {
885 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_SEEKDIR64)
886 seekdir64(dirp, offset);
887 #else
888 seekdir(dirp, offset);
889 #endif
890 }
891
892 /*******************************************************************
893 A telldir wrapper that will deal with 64 bit filesizes.
894 ********************************************************************/
895
896 long sys_telldir(SMB_STRUCT_DIR *dirp)
897 {
898 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_TELLDIR64)
899 return (long)telldir64(dirp);
900 #else
901 return (long)telldir(dirp);
902 #endif
903 }
904
905 /*******************************************************************
906 A rewinddir wrapper that will deal with 64 bit filesizes.
907 ********************************************************************/
908
909 void sys_rewinddir(SMB_STRUCT_DIR *dirp)
910 {
911 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_REWINDDIR64)
912 rewinddir64(dirp);
913 #else
914 rewinddir(dirp);
915 #endif
916 }
917
918 /*******************************************************************
919 A close wrapper that will deal with 64 bit filesizes.
920 ********************************************************************/
921
922 int sys_closedir(SMB_STRUCT_DIR *dirp)
923 {
924 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_CLOSEDIR64)
925 return closedir64(dirp);
926 #else
927 return closedir(dirp);
928 #endif
929 }
930
931 /*******************************************************************
932 An mknod() wrapper that will deal with 64 bit filesizes.
933 ********************************************************************/
934
935 int sys_mknod(const char *path, mode_t mode, SMB_DEV_T dev)
936 {
937 #if defined(HAVE_MKNOD) || defined(HAVE_MKNOD64)
938 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_MKNOD64) && defined(HAVE_DEV64_T)
939 return mknod64(path, mode, dev);
940 #else
941 return mknod(path, mode, dev);
942 #endif
943 #else
944 /* No mknod system call. */
945 errno = ENOSYS;
946 return -1;
947 #endif
948 }
949
950 /*******************************************************************
951 The wait() calls vary between systems
952 ********************************************************************/
953
954 int sys_waitpid(pid_t pid,int *status,int options)
955 {
956 #ifdef HAVE_WAITPID
957 return waitpid(pid,status,options);
958 #else /* HAVE_WAITPID */
959 return wait4(pid, status, options, NULL);
960 #endif /* HAVE_WAITPID */
961 }
962
963 /*******************************************************************
964 System wrapper for getwd. Always returns MALLOC'ed memory, or NULL
965 on error (malloc fail usually).
966 ********************************************************************/
967
968 char *sys_getwd(void)
969 {
970 #ifdef GETCWD_TAKES_NULL
971 return getcwd(NULL, 0);
972 #elif HAVE_GETCWD
973 char *wd = NULL, *s = NULL;
974 size_t allocated = PATH_MAX;
975
976 while (1) {
977 s = SMB_REALLOC_ARRAY(s, char, allocated);
978 if (s == NULL) {
979 return NULL;
980 }
981 wd = getcwd(s, allocated);
982 if (wd) {
983 break;
984 }
985 if (errno != ERANGE) {
986 SAFE_FREE(s);
987 break;
988 }
989 allocated *= 2;
990 if (allocated < PATH_MAX) {
991 SAFE_FREE(s);
992 break;
993 }
994 }
995 return wd;
996 #else
997 char *s = SMB_MALLOC_ARRAY(char, PATH_MAX);
998 if (s == NULL) {
999 return NULL;
1000 }
1001 return getwd(s);
1002 #endif
1003 }
1004
1005 #if defined(HAVE_POSIX_CAPABILITIES)
1006
1007 /**************************************************************************
1008 Try and abstract process capabilities (for systems that have them).
1009 ****************************************************************************/
1010
1011 /* Set the POSIX capabilities needed for the given purpose into the effective
1012 * capability set of the current process. Make sure they are always removed
1013 * from the inheritable set, because there is no circumstance in which our
1014 * children should inherit our elevated privileges.
1015 */
1016 static bool set_process_capability(enum smbd_capability capability,
1017 bool enable)
1018 {
1019 cap_value_t cap_vals[2] = {0};
1020 int num_cap_vals = 0;
1021
1022 cap_t cap;
1023
1024 #if defined(HAVE_PRCTL) && defined(PR_GET_KEEPCAPS) && defined(PR_SET_KEEPCAPS)
1025 /* On Linux, make sure that any capabilities we grab are sticky
1026 * across UID changes. We expect that this would allow us to keep both
1027 * the effective and permitted capability sets, but as of circa 2.6.16,
1028 * only the permitted set is kept. It is a bug (which we work around)
1029 * that the effective set is lost, but we still require the effective
1030 * set to be kept.
1031 */
1032 if (!prctl(PR_GET_KEEPCAPS)) {
1033 prctl(PR_SET_KEEPCAPS, 1);
1034 }
1035 #endif
1036
1037 cap = cap_get_proc();
1038 if (cap == NULL) {
1039 DEBUG(0,("set_process_capability: cap_get_proc failed: %s\n",
1040 strerror(errno)));
1041 return False;
1042 }
1043
1044 switch (capability) {
1045 case KERNEL_OPLOCK_CAPABILITY:
1046 #ifdef CAP_NETWORK_MGT
1047 /* IRIX has CAP_NETWORK_MGT for oplocks. */
1048 cap_vals[num_cap_vals++] = CAP_NETWORK_MGT;
1049 #endif
1050 break;
1051 case DMAPI_ACCESS_CAPABILITY:
1052 #ifdef CAP_DEVICE_MGT
1053 /* IRIX has CAP_DEVICE_MGT for DMAPI access. */
1054 cap_vals[num_cap_vals++] = CAP_DEVICE_MGT;
1055 #elif CAP_MKNOD
1056 /* Linux has CAP_MKNOD for DMAPI access. */
1057 cap_vals[num_cap_vals++] = CAP_MKNOD;
1058 #endif
1059 break;
1060 case LEASE_CAPABILITY:
1061 #ifdef CAP_LEASE
1062 cap_vals[num_cap_vals++] = CAP_LEASE;
1063 #endif
1064 break;
1065 }
1066
1067 SMB_ASSERT(num_cap_vals <= ARRAY_SIZE(cap_vals));
1068
1069 if (num_cap_vals == 0) {
1070 cap_free(cap);
1071 return True;
1072 }
1073
1074 cap_set_flag(cap, CAP_EFFECTIVE, num_cap_vals, cap_vals,
1075 enable ? CAP_SET : CAP_CLEAR);
1076
1077 /* We never want to pass capabilities down to our children, so make
1078 * sure they are not inherited.
1079 */
1080 cap_set_flag(cap, CAP_INHERITABLE, num_cap_vals, cap_vals, CAP_CLEAR);
1081
1082 if (cap_set_proc(cap) == -1) {
1083 DEBUG(0, ("set_process_capability: cap_set_proc failed: %s\n",
1084 strerror(errno)));
1085 cap_free(cap);
1086 return False;
1087 }
1088
1089 cap_free(cap);
1090 return True;
1091 }
1092
1093 #endif /* HAVE_POSIX_CAPABILITIES */
1094
1095 /****************************************************************************
1096 Gain the oplock capability from the kernel if possible.
1097 ****************************************************************************/
1098
1099 void set_effective_capability(enum smbd_capability capability)
1100 {
1101 #if defined(HAVE_POSIX_CAPABILITIES)
1102 set_process_capability(capability, True);
1103 #endif /* HAVE_POSIX_CAPABILITIES */
1104 }
1105
1106 void drop_effective_capability(enum smbd_capability capability)
1107 {
1108 #if defined(HAVE_POSIX_CAPABILITIES)
1109 set_process_capability(capability, False);
1110 #endif /* HAVE_POSIX_CAPABILITIES */
1111 }
1112
1113 /**************************************************************************
1114 Wrapper for random().
1115 ****************************************************************************/
1116
1117 long sys_random(void)
1118 {
1119 #if defined(HAVE_RANDOM)
1120 return (long)random();
1121 #elif defined(HAVE_RAND)
1122 return (long)rand();
1123 #else
1124 DEBUG(0,("Error - no random function available !\n"));
1125 exit(1);
1126 #endif
1127 }
1128
1129 /**************************************************************************
1130 Wrapper for srandom().
1131 ****************************************************************************/
1132
1133 void sys_srandom(unsigned int seed)
1134 {
1135 #if defined(HAVE_SRANDOM)
1136 srandom(seed);
1137 #elif defined(HAVE_SRAND)
1138 srand(seed);
1139 #else
1140 DEBUG(0,("Error - no srandom function available !\n"));
1141 exit(1);
1142 #endif
1143 }
1144
1145 #ifndef NGROUPS_MAX
1146 #define NGROUPS_MAX 32 /* Guess... */
1147 #endif
1148
1149 /**************************************************************************
1150 Returns equivalent to NGROUPS_MAX - using sysconf if needed.
1151 ****************************************************************************/
1152
1153 int groups_max(void)
1154 {
1155 #if defined(SYSCONF_SC_NGROUPS_MAX)
1156 int ret = sysconf(_SC_NGROUPS_MAX);
1157 return (ret == -1) ? NGROUPS_MAX : ret;
1158 #else
1159 return NGROUPS_MAX;
1160 #endif
1161 }
1162
1163 /**************************************************************************
1164 Wrap setgroups and getgroups for systems that declare getgroups() as
1165 returning an array of gid_t, but actuall return an array of int.
1166 ****************************************************************************/
1167
1168 #if defined(HAVE_BROKEN_GETGROUPS)
1169
1170 #ifdef HAVE_BROKEN_GETGROUPS
1171 #define GID_T int
1172 #else
1173 #define GID_T gid_t
1174 #endif
1175
1176 static int sys_broken_getgroups(int setlen, gid_t *gidset)
1177 {
1178 GID_T gid;
1179 GID_T *group_list;
1180 int i, ngroups;
1181
1182 if(setlen == 0) {
1183 return getgroups(setlen, &gid);
1184 }
1185
1186 /*
1187 * Broken case. We need to allocate a
1188 * GID_T array of size setlen.
1189 */
1190
1191 if(setlen < 0) {
1192 errno = EINVAL;
1193 return -1;
1194 }
1195
1196 if (setlen == 0)
1197 setlen = groups_max();
1198
1199 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
1200 DEBUG(0,("sys_getgroups: Malloc fail.\n"));
1201 return -1;
1202 }
1203
1204 if((ngroups = getgroups(setlen, group_list)) < 0) {
1205 int saved_errno = errno;
1206 SAFE_FREE(group_list);
1207 errno = saved_errno;
1208 return -1;
1209 }
1210
1211 for(i = 0; i < ngroups; i++)
1212 gidset[i] = (gid_t)group_list[i];
1213
1214 SAFE_FREE(group_list);
1215 return ngroups;
1216 }
1217
1218 static int sys_broken_setgroups(int setlen, gid_t *gidset)
1219 {
1220 GID_T *group_list;
1221 int i ;
1222
1223 if (setlen == 0)
1224 return 0 ;
1225
1226 if (setlen < 0 || setlen > groups_max()) {
1227 errno = EINVAL;
1228 return -1;
1229 }
1230
1231 /*
1232 * Broken case. We need to allocate a
1233 * GID_T array of size setlen.
1234 */
1235
1236 if((group_list = SMB_MALLOC_ARRAY(GID_T, setlen)) == NULL) {
1237 DEBUG(0,("sys_setgroups: Malloc fail.\n"));
1238 return -1;
1239 }
1240
1241 for(i = 0; i < setlen; i++)
1242 group_list[i] = (GID_T) gidset[i];
1243
1244 if(setgroups(setlen, group_list) != 0) {
1245 int saved_errno = errno;
1246 SAFE_FREE(group_list);
1247 errno = saved_errno;
1248 return -1;
1249 }
1250
1251 SAFE_FREE(group_list);
1252 return 0 ;
1253 }
1254
1255 #endif /* HAVE_BROKEN_GETGROUPS */
1256
1257 /* This is a list of systems that require the first GID passed to setgroups(2)
1258 * to be the effective GID. If your system is one of these, add it here.
1259 */
1260 #if defined (FREEBSD) || defined (DARWINOS)
1261 #define USE_BSD_SETGROUPS
1262 #endif
1263
1264 #if defined(USE_BSD_SETGROUPS)
1265 /* Depending on the particular BSD implementation, the first GID that is
1266 * passed to setgroups(2) will either be ignored or will set the credential's
1267 * effective GID. In either case, the right thing to do is to guarantee that
1268 * gidset[0] is the effective GID.
1269 */
1270 static int sys_bsd_setgroups(gid_t primary_gid, int setlen, const gid_t *gidset)
1271 {
1272 gid_t *new_gidset = NULL;
1273 int max;
1274 int ret;
1275
1276 /* setgroups(2) will fail with EINVAL if we pass too many groups. */
1277 max = groups_max();
1278
1279 /* No group list, just make sure we are setting the efective GID. */
1280 if (setlen == 0) {
1281 return setgroups(1, &primary_gid);
1282 }
1283
1284 /* If the primary gid is not the first array element, grow the array
1285 * and insert it at the front.
1286 */
1287 if (gidset[0] != primary_gid) {
1288 new_gidset = SMB_MALLOC_ARRAY(gid_t, setlen + 1);
1289 if (new_gidset == NULL) {
1290 return -1;
1291 }
1292
1293 memcpy(new_gidset + 1, gidset, (setlen * sizeof(gid_t)));
1294 new_gidset[0] = primary_gid;
1295 setlen++;
1296 }
1297
1298 if (setlen > max) {
1299 DEBUG(3, ("forced to truncate group list from %d to %d\n",
1300 setlen, max));
1301 setlen = max;
1302 }
1303
1304 #if defined(HAVE_BROKEN_GETGROUPS)
1305 ret = sys_broken_setgroups(setlen, new_gidset ? new_gidset : gidset);
1306 #else
1307 ret = setgroups(setlen, new_gidset ? new_gidset : gidset);
1308 #endif
1309
1310 if (new_gidset) {
1311 int errsav = errno;
1312 SAFE_FREE(new_gidset);
1313 errno = errsav;
1314 }
1315
1316 return ret;
1317 }
1318
1319 #endif /* USE_BSD_SETGROUPS */
1320
1321 /**************************************************************************
1322 Wrapper for getgroups. Deals with broken (int) case.
1323 ****************************************************************************/
1324
1325 int sys_getgroups(int setlen, gid_t *gidset)
1326 {
1327 #if defined(HAVE_BROKEN_GETGROUPS)
1328 return sys_broken_getgroups(setlen, gidset);
1329 #else
1330 return getgroups(setlen, gidset);
1331 #endif
1332 }
1333
1334 /**************************************************************************
1335 Wrapper for setgroups. Deals with broken (int) case and BSD case.
1336 ****************************************************************************/
1337
1338 int sys_setgroups(gid_t UNUSED(primary_gid), int setlen, gid_t *gidset)
1339 {
1340 #if !defined(HAVE_SETGROUPS)
1341 errno = ENOSYS;
1342 return -1;
1343 #endif /* HAVE_SETGROUPS */
1344
1345 #if defined(USE_BSD_SETGROUPS)
1346 return sys_bsd_setgroups(primary_gid, setlen, gidset);
1347 #elif defined(HAVE_BROKEN_GETGROUPS)
1348 return sys_broken_setgroups(setlen, gidset);
1349 #else
1350 return setgroups(setlen, gidset);
1351 #endif
1352 }
1353
1354 /**************************************************************************
1355 Extract a command into an arg list.
1356 ****************************************************************************/
1357
1358 static char **extract_args(TALLOC_CTX *mem_ctx, const char *command)
1359 {
1360 char *trunc_cmd;
1361 char *saveptr;
1362 char *ptr;
1363 int argcl;
1364 char **argl = NULL;
1365 int i;
1366
1367 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1368 DEBUG(0, ("talloc failed\n"));
1369 goto nomem;
1370 }
1371
1372 if(!(ptr = strtok_r(trunc_cmd, " \t", &saveptr))) {
1373 TALLOC_FREE(trunc_cmd);
1374 errno = EINVAL;
1375 return NULL;
1376 }
1377
1378 /*
1379 * Count the args.
1380 */
1381
1382 for( argcl = 1; ptr; ptr = strtok_r(NULL, " \t", &saveptr))
1383 argcl++;
1384
1385 TALLOC_FREE(trunc_cmd);
1386
1387 if (!(argl = talloc_array(mem_ctx, char *, argcl + 1))) {
1388 goto nomem;
1389 }
1390
1391 /*
1392 * Now do the extraction.
1393 */
1394
1395 if (!(trunc_cmd = talloc_strdup(mem_ctx, command))) {
1396 goto nomem;
1397 }
1398
1399 ptr = strtok_r(trunc_cmd, " \t", &saveptr);
1400 i = 0;
1401
1402 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1403 goto nomem;
1404 }
1405
1406 while((ptr = strtok_r(NULL, " \t", &saveptr)) != NULL) {
1407
1408 if (!(argl[i++] = talloc_strdup(argl, ptr))) {
1409 goto nomem;
1410 }
1411 }
1412
1413 argl[i++] = NULL;
1414 TALLOC_FREE(trunc_cmd);
1415 return argl;
1416
1417 nomem:
1418 DEBUG(0, ("talloc failed\n"));
1419 TALLOC_FREE(trunc_cmd);
1420 TALLOC_FREE(argl);
1421 errno = ENOMEM;
1422 return NULL;
1423 }
1424
1425 /**************************************************************************
1426 Wrapper for popen. Safer as it doesn't search a path.
1427 Modified from the glibc sources.
1428 modified by tridge to return a file descriptor. We must kick our FILE* habit
1429 ****************************************************************************/
1430
1431 typedef struct _popen_list
1432 {
1433 int fd;
1434 pid_t child_pid;
1435 struct _popen_list *next;
1436 } popen_list;
1437
1438 static popen_list *popen_chain;
1439
1440 int sys_popen(const char *command)
1441 {
1442 int parent_end, child_end;
1443 int pipe_fds[2];
1444 popen_list *entry = NULL;
1445 char **argl = NULL;
1446
1447 if (pipe(pipe_fds) < 0)
1448 return -1;
1449
1450 parent_end = pipe_fds[0];
1451 child_end = pipe_fds[1];
1452
1453 if (!*command) {
1454 errno = EINVAL;
1455 goto err_exit;
1456 }
1457
1458 if((entry = SMB_MALLOC_P(popen_list)) == NULL)
1459 goto err_exit;
1460
1461 ZERO_STRUCTP(entry);
1462
1463 /*
1464 * Extract the command and args into a NULL terminated array.
1465 */
1466
1467 if(!(argl = extract_args(NULL, command)))
1468 goto err_exit;
1469
1470 entry->child_pid = sys_fork();
1471
1472 if (entry->child_pid == -1) {
1473 goto err_exit;
1474 }
1475
1476 if (entry->child_pid == 0) {
1477
1478 /*
1479 * Child !
1480 */
1481
1482 int child_std_end = STDOUT_FILENO;
1483 popen_list *p;
1484
1485 close(parent_end);
1486 if (child_end != child_std_end) {
1487 dup2 (child_end, child_std_end);
1488 close (child_end);
1489 }
1490
1491 /*
1492 * POSIX.2: "popen() shall ensure that any streams from previous
1493 * popen() calls that remain open in the parent process are closed
1494 * in the new child process."
1495 */
1496
1497 for (p = popen_chain; p; p = p->next)
1498 close(p->fd);
1499
1500 execv(argl[0], argl);
1501 _exit (127);
1502 }
1503
1504 /*
1505 * Parent.
1506 */
1507
1508 close (child_end);
1509 TALLOC_FREE(argl);
1510
1511 /* Link into popen_chain. */
1512 entry->next = popen_chain;
1513 popen_chain = entry;
1514 entry->fd = parent_end;
1515
1516 return entry->fd;
1517
1518 err_exit:
1519
1520 SAFE_FREE(entry);
1521 TALLOC_FREE(argl);
1522 close(pipe_fds[0]);
1523 close(pipe_fds[1]);
1524 return -1;
1525 }
1526
1527 /**************************************************************************
1528 Wrapper for pclose. Modified from the glibc sources.
1529 ****************************************************************************/
1530
1531 int sys_pclose(int fd)
1532 {
1533 int wstatus;
1534 popen_list **ptr = &popen_chain;
1535 popen_list *entry = NULL;
1536 pid_t wait_pid;
1537 int status = -1;
1538
1539 /* Unlink from popen_chain. */
1540 for ( ; *ptr != NULL; ptr = &(*ptr)->next) {
1541 if ((*ptr)->fd == fd) {
1542 entry = *ptr;
1543 *ptr = (*ptr)->next;
1544 status = 0;
1545 break;
1546 }
1547 }
1548
1549 if (status < 0 || close(entry->fd) < 0)
1550 return -1;
1551
1552 /*
1553 * As Samba is catching and eating child process
1554 * exits we don't really care about the child exit
1555 * code, a -1 with errno = ECHILD will do fine for us.
1556 */
1557
1558 do {
1559 wait_pid = sys_waitpid (entry->child_pid, &wstatus, 0);
1560 } while (wait_pid == -1 && errno == EINTR);
1561
1562 SAFE_FREE(entry);
1563
1564 if (wait_pid == -1)
1565 return -1;
1566 return wstatus;
1567 }
1568
1569 /**************************************************************************
1570 Wrapper for Admin Logs.
1571 ****************************************************************************/
1572
1573 void sys_adminlog(int priority, const char *format_str, ...)
1574 {
1575 va_list ap;
1576 int ret;
1577 char *msgbuf = NULL;
1578
1579 va_start( ap, format_str );
1580 ret = vasprintf( &msgbuf, format_str, ap );
1581 va_end( ap );
1582
1583 if (ret == -1)
1584 return;
1585
1586 #if defined(HAVE_SYSLOG)
1587 syslog( priority, "%s", msgbuf );
1588 #else
1589 DEBUG(0,("%s", msgbuf ));
1590 #endif
1591 SAFE_FREE(msgbuf);
1592 }
1593
1594 /******** Solaris EA helper function prototypes ********/
1595 #ifdef HAVE_ATTROPEN
1596 #define SOLARIS_ATTRMODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP
1597 static int solaris_write_xattr(int attrfd, const char *value, size_t size);
1598 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size);
1599 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size);
1600 static int solaris_unlinkat(int attrdirfd, const char *name);
1601 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode);
1602 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode);
1603 #endif
1604
1605 /**************************************************************************
1606 Wrappers for extented attribute calls. Based on the Linux package with
1607 support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
1608 ****************************************************************************/
1609
1610 ssize_t sys_getxattr (const char *path, const char *name, void *value, size_t size)
1611 {
1612 #if defined(HAVE_GETXATTR)
1613 #ifndef XATTR_ADD_OPT
1614 return getxattr(path, name, value, size);
1615 #else
1616 int options = 0;
1617 return getxattr(path, name, value, size, 0, options);
1618 #endif
1619 #elif defined(HAVE_GETEA)
1620 return getea(path, name, value, size);
1621 #elif defined(HAVE_EXTATTR_GET_FILE)
1622 char *s;
1623 ssize_t retval;
1624 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1625 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1626 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1627 /*
1628 * The BSD implementation has a nasty habit of silently truncating
1629 * the returned value to the size of the buffer, so we have to check
1630 * that the buffer is large enough to fit the returned value.
1631 */
1632 if((retval=extattr_get_file(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1633 if(retval > size) {
1634 errno = ERANGE;
1635 return -1;
1636 }
1637 if((retval=extattr_get_file(path, attrnamespace, attrname, value, size)) >= 0)
1638 return retval;
1639 }
1640
1641 DEBUG(10,("sys_getxattr: extattr_get_file() failed with: %s\n", strerror(errno)));
1642 return -1;
1643 #elif defined(HAVE_ATTR_GET)
1644 int retval, flags = 0;
1645 int valuelength = (int)size;
1646 char *attrname = strchr(name,'.') + 1;
1647
1648 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1649
1650 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1651
1652 return retval ? retval : valuelength;
1653 #elif defined(HAVE_ATTROPEN)
1654 ssize_t ret = -1;
1655 int attrfd = solaris_attropen(path, name, O_RDONLY, 0);
1656 if (attrfd >= 0) {
1657 ret = solaris_read_xattr(attrfd, value, size);
1658 close(attrfd);
1659 }
1660 return ret;
1661 #else
1662 errno = ENOSYS;
1663 return -1;
1664 #endif
1665 }
1666
1667 ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size)
1668 {
1669 #if defined(HAVE_LGETXATTR)
1670 return lgetxattr(path, name, value, size);
1671 #elif defined(HAVE_GETXATTR) && defined(XATTR_ADD_OPT)
1672 int options = XATTR_NOFOLLOW;
1673 return getxattr(path, name, value, size, 0, options);
1674 #elif defined(HAVE_LGETEA)
1675 return lgetea(path, name, value, size);
1676 #elif defined(HAVE_EXTATTR_GET_LINK)
1677 char *s;
1678 ssize_t retval;
1679 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1680 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1681 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1682
1683 if((retval=extattr_get_link(path, attrnamespace, attrname, NULL, 0)) >= 0) {
1684 if(retval > size) {
1685 errno = ERANGE;
1686 return -1;
1687 }
1688 if((retval=extattr_get_link(path, attrnamespace, attrname, value, size)) >= 0)
1689 return retval;
1690 }
1691
1692 DEBUG(10,("sys_lgetxattr: extattr_get_link() failed with: %s\n", strerror(errno)));
1693 return -1;
1694 #elif defined(HAVE_ATTR_GET)
1695 int retval, flags = ATTR_DONTFOLLOW;
1696 int valuelength = (int)size;
1697 char *attrname = strchr(name,'.') + 1;
1698
1699 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1700
1701 retval = attr_get(path, attrname, (char *)value, &valuelength, flags);
1702
1703 return retval ? retval : valuelength;
1704 #elif defined(HAVE_ATTROPEN)
1705 ssize_t ret = -1;
1706 int attrfd = solaris_attropen(path, name, O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1707 if (attrfd >= 0) {
1708 ret = solaris_read_xattr(attrfd, value, size);
1709 close(attrfd);
1710 }
1711 return ret;
1712 #else
1713 errno = ENOSYS;
1714 return -1;
1715 #endif
1716 }
1717
1718 ssize_t sys_fgetxattr (int filedes, const char *name, void *value, size_t size)
1719 {
1720 #if defined(HAVE_FGETXATTR)
1721 #ifndef XATTR_ADD_OPT
1722 return fgetxattr(filedes, name, value, size);
1723 #else
1724 int options = 0;
1725 return fgetxattr(filedes, name, value, size, 0, options);
1726 #endif
1727 #elif defined(HAVE_FGETEA)
1728 return fgetea(filedes, name, value, size);
1729 #elif defined(HAVE_EXTATTR_GET_FD)
1730 char *s;
1731 ssize_t retval;
1732 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
1733 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
1734 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
1735
1736 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0)) >= 0) {
1737 if(retval > size) {
1738 errno = ERANGE;
1739 return -1;
1740 }
1741 if((retval=extattr_get_fd(filedes, attrnamespace, attrname, value, size)) >= 0)
1742 return retval;
1743 }
1744
1745 DEBUG(10,("sys_fgetxattr: extattr_get_fd() failed with: %s\n", strerror(errno)));
1746 return -1;
1747 #elif defined(HAVE_ATTR_GETF)
1748 int retval, flags = 0;
1749 int valuelength = (int)size;
1750 char *attrname = strchr(name,'.') + 1;
1751
1752 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
1753
1754 retval = attr_getf(filedes, attrname, (char *)value, &valuelength, flags);
1755
1756 return retval ? retval : valuelength;
1757 #elif defined(HAVE_ATTROPEN)
1758 ssize_t ret = -1;
1759 int attrfd = solaris_openat(filedes, name, O_RDONLY|O_XATTR, 0);
1760 if (attrfd >= 0) {
1761 ret = solaris_read_xattr(attrfd, value, size);
1762 close(attrfd);
1763 }
1764 return ret;
1765 #else
1766 errno = ENOSYS;
1767 return -1;
1768 #endif
1769 }
1770
1771 #if defined(HAVE_EXTATTR_LIST_FILE)
1772
1773 #define EXTATTR_PREFIX(s) (s), (sizeof((s))-1)
1774
1775 static struct {
1776 int space;
1777 const char *name;
1778 size_t len;
1779 }
1780 extattr[] = {
1781 { EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
1782 { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
1783 };
1784
1785 typedef union {
1786 const char *path;
1787 int filedes;
1788 } extattr_arg;
1789
1790 static ssize_t bsd_attr_list (int type, extattr_arg arg, char *list, size_t size)
1791 {
1792 ssize_t list_size, total_size = 0;
1793 int i, t, len;
1794 char *buf;
1795 /* Iterate through extattr(2) namespaces */
1796 for(t = 0; t < (sizeof(extattr)/sizeof(extattr[0])); t++) {
1797 switch(type) {
1798 #if defined(HAVE_EXTATTR_LIST_FILE)
1799 case 0:
1800 list_size = extattr_list_file(arg.path, extattr[t].space, list, size);
1801 break;
1802 #endif
1803 #if defined(HAVE_EXTATTR_LIST_LINK)
1804 case 1:
1805 list_size = extattr_list_link(arg.path, extattr[t].space, list, size);
1806 break;
1807 #endif
1808 #if defined(HAVE_EXTATTR_LIST_FD)
1809 case 2:
1810 list_size = extattr_list_fd(arg.filedes, extattr[t].space, list, size);
1811 break;
1812 #endif
1813 default:
1814 errno = ENOSYS;
1815 return -1;
1816 }
1817 /* Some error happend. Errno should be set by the previous call */
1818 if(list_size < 0)
1819 return -1;
1820 /* No attributes */
1821 if(list_size == 0)
1822 continue;
1823 /* XXX: Call with an empty buffer may be used to calculate
1824 necessary buffer size. Unfortunately, we can't say, how
1825 many attributes were returned, so here is the potential
1826 problem with the emulation.
1827 */
1828 if(list == NULL) {
1829 /* Take the worse case of one char attribute names -
1830 two bytes per name plus one more for sanity.
1831 */
1832 total_size += list_size + (list_size/2 + 1)*extattr[t].len;
1833 continue;
1834 }
1835 /* Count necessary offset to fit namespace prefixes */
1836 len = 0;
1837 for(i = 0; i < list_size; i += list[i] + 1)
1838 len += extattr[t].len;
1839
1840 total_size += list_size + len;
1841 /* Buffer is too small to fit the results */
1842 if(total_size > size) {
1843 errno = ERANGE;
1844 return -1;
1845 }
1846 /* Shift results back, so we can prepend prefixes */
1847 buf = (char *)memmove(list + len, list, list_size);
1848
1849 for(i = 0; i < list_size; i += len + 1) {
1850 len = buf[i];
1851 strncpy(list, extattr[t].name, extattr[t].len + 1);
1852 list += extattr[t].len;
1853 strncpy(list, buf + i + 1, len);
1854 list[len] = '\0';
1855 list += len + 1;
1856 }
1857 size -= total_size;
1858 }
1859 return total_size;
1860 }
1861
1862 #endif
1863
1864 #if defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1865 static char attr_buffer[ATTR_MAX_VALUELEN];
1866
1867 static ssize_t irix_attr_list(const char *path, int filedes, char *list, size_t size, int flags)
1868 {
1869 int retval = 0, index;
1870 attrlist_cursor_t *cursor = 0;
1871 int total_size = 0;
1872 attrlist_t * al = (attrlist_t *)attr_buffer;
1873 attrlist_ent_t *ae;
1874 size_t ent_size, left = size;
1875 char *bp = list;
1876
1877 while (True) {
1878 if (filedes)
1879 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1880 else
1881 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1882 if (retval) break;
1883 for (index = 0; index < al->al_count; index++) {
1884 ae = ATTR_ENTRY(attr_buffer, index);
1885 ent_size = strlen(ae->a_name) + sizeof("user.");
1886 if (left >= ent_size) {
1887 strncpy(bp, "user.", sizeof("user."));
1888 strncat(bp, ae->a_name, ent_size - sizeof("user."));
1889 bp += ent_size;
1890 left -= ent_size;
1891 } else if (size) {
1892 errno = ERANGE;
1893 retval = -1;
1894 break;
1895 }
1896 total_size += ent_size;
1897 }
1898 if (al->al_more == 0) break;
1899 }
1900 if (retval == 0) {
1901 flags |= ATTR_ROOT;
1902 cursor = 0;
1903 while (True) {
1904 if (filedes)
1905 retval = attr_listf(filedes, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1906 else
1907 retval = attr_list(path, attr_buffer, ATTR_MAX_VALUELEN, flags, cursor);
1908 if (retval) break;
1909 for (index = 0; index < al->al_count; index++) {
1910 ae = ATTR_ENTRY(attr_buffer, index);
1911 ent_size = strlen(ae->a_name) + sizeof("system.");
1912 if (left >= ent_size) {
1913 strncpy(bp, "system.", sizeof("system."));
1914 strncat(bp, ae->a_name, ent_size - sizeof("system."));
1915 bp += ent_size;
1916 left -= ent_size;
1917 } else if (size) {
1918 errno = ERANGE;
1919 retval = -1;
1920 break;
1921 }
1922 total_size += ent_size;
1923 }
1924 if (al->al_more == 0) break;
1925 }
1926 }
1927 return (ssize_t)(retval ? retval : total_size);
1928 }
1929
1930 #endif
1931
1932 ssize_t sys_listxattr (const char *path, char *list, size_t size)
1933 {
1934 #if defined(HAVE_LISTXATTR)
1935 #ifndef XATTR_ADD_OPT
1936 return listxattr(path, list, size);
1937 #else
1938 int options = 0;
1939 return listxattr(path, list, size, options);
1940 #endif
1941 #elif defined(HAVE_LISTEA)
1942 return listea(path, list, size);
1943 #elif defined(HAVE_EXTATTR_LIST_FILE)
1944 extattr_arg arg;
1945 arg.path = path;
1946 return bsd_attr_list(0, arg, list, size);
1947 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1948 return irix_attr_list(path, 0, list, size, 0);
1949 #elif defined(HAVE_ATTROPEN)
1950 ssize_t ret = -1;
1951 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
1952 if (attrdirfd >= 0) {
1953 ret = solaris_list_xattr(attrdirfd, list, size);
1954 close(attrdirfd);
1955 }
1956 return ret;
1957 #else
1958 errno = ENOSYS;
1959 return -1;
1960 #endif
1961 }
1962
1963 ssize_t sys_llistxattr (const char *path, char *list, size_t size)
1964 {
1965 #if defined(HAVE_LLISTXATTR)
1966 return llistxattr(path, list, size);
1967 #elif defined(HAVE_LISTXATTR) && defined(XATTR_ADD_OPT)
1968 int options = XATTR_NOFOLLOW;
1969 return listxattr(path, list, size, options);
1970 #elif defined(HAVE_LLISTEA)
1971 return llistea(path, list, size);
1972 #elif defined(HAVE_EXTATTR_LIST_LINK)
1973 extattr_arg arg;
1974 arg.path = path;
1975 return bsd_attr_list(1, arg, list, size);
1976 #elif defined(HAVE_ATTR_LIST) && defined(HAVE_SYS_ATTRIBUTES_H)
1977 return irix_attr_list(path, 0, list, size, ATTR_DONTFOLLOW);
1978 #elif defined(HAVE_ATTROPEN)
1979 ssize_t ret = -1;
1980 int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
1981 if (attrdirfd >= 0) {
1982 ret = solaris_list_xattr(attrdirfd, list, size);
1983 close(attrdirfd);
1984 }
1985 return ret;
1986 #else
1987 errno = ENOSYS;
1988 return -1;
1989 #endif
1990 }
1991
1992 ssize_t sys_flistxattr (int filedes, char *list, size_t size)
1993 {
1994 #if defined(HAVE_FLISTXATTR)
1995 #ifndef XATTR_ADD_OPT
1996 return flistxattr(filedes, list, size);
1997 #else
1998 int options = 0;
1999 return flistxattr(filedes, list, size, options);
2000 #endif
2001 #elif defined(HAVE_FLISTEA)
2002 return flistea(filedes, list, size);
2003 #elif defined(HAVE_EXTATTR_LIST_FD)
2004 extattr_arg arg;
2005 arg.filedes = filedes;
2006 return bsd_attr_list(2, arg, list, size);
2007 #elif defined(HAVE_ATTR_LISTF)
2008 return irix_attr_list(NULL, filedes, list, size, 0);
2009 #elif defined(HAVE_ATTROPEN)
2010 ssize_t ret = -1;
2011 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
2012 if (attrdirfd >= 0) {
2013 ret = solaris_list_xattr(attrdirfd, list, size);
2014 close(attrdirfd);
2015 }
2016 return ret;
2017 #else
2018 errno = ENOSYS;
2019 return -1;
2020 #endif
2021 }
2022
2023 int sys_removexattr (const char *path, const char *name)
2024 {
2025 #if defined(HAVE_REMOVEXATTR)
2026 #ifndef XATTR_ADD_OPT
2027 return removexattr(path, name);
2028 #else
2029 int options = 0;
2030 return removexattr(path, name, options);
2031 #endif
2032 #elif defined(HAVE_REMOVEEA)
2033 return removeea(path, name);
2034 #elif defined(HAVE_EXTATTR_DELETE_FILE)
2035 char *s;
2036 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2037 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2038 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2039
2040 return extattr_delete_file(path, attrnamespace, attrname);
2041 #elif defined(HAVE_ATTR_REMOVE)
2042 int flags = 0;
2043 char *attrname = strchr(name,'.') + 1;
2044
2045 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
2046
2047 return attr_remove(path, attrname, flags);
2048 #elif defined(HAVE_ATTROPEN)
2049 int ret = -1;
2050 int attrdirfd = solaris_attropen(path, ".", O_RDONLY, 0);
2051 if (attrdirfd >= 0) {
2052 ret = solaris_unlinkat(attrdirfd, name);
2053 close(attrdirfd);
2054 }
2055 return ret;
2056 #else
2057 errno = ENOSYS;
2058 return -1;
2059 #endif
2060 }
2061
2062 int sys_lremovexattr (const char *path, const char *name)
2063 {
2064 #if defined(HAVE_LREMOVEXATTR)
2065 return lremovexattr(path, name);
2066 #elif defined(HAVE_REMOVEXATTR) && defined(XATTR_ADD_OPT)
2067 int options = XATTR_NOFOLLOW;
2068 return removexattr(path, name, options);
2069 #elif defined(HAVE_LREMOVEEA)
2070 return lremoveea(path, name);
2071 #elif defined(HAVE_EXTATTR_DELETE_LINK)
2072 char *s;
2073 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2074 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2075 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2076
2077 return extattr_delete_link(path, attrnamespace, attrname);
2078 #elif defined(HAVE_ATTR_REMOVE)
2079 int flags = ATTR_DONTFOLLOW;
2080 char *attrname = strchr(name,'.') + 1;
2081
2082 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
2083
2084 return attr_remove(path, attrname, flags);
2085 #elif defined(HAVE_ATTROPEN)
2086 int ret = -1;
2087 int attrdirfd = solaris_attropen(path, ".", O_RDONLY|AT_SYMLINK_NOFOLLOW, 0);
2088 if (attrdirfd >= 0) {
2089 ret = solaris_unlinkat(attrdirfd, name);
2090 close(attrdirfd);
2091 }
2092 return ret;
2093 #else
2094 errno = ENOSYS;
2095 return -1;
2096 #endif
2097 }
2098
2099 int sys_fremovexattr (int filedes, const char *name)
2100 {
2101 #if defined(HAVE_FREMOVEXATTR)
2102 #ifndef XATTR_ADD_OPT
2103 return fremovexattr(filedes, name);
2104 #else
2105 int options = 0;
2106 return fremovexattr(filedes, name, options);
2107 #endif
2108 #elif defined(HAVE_FREMOVEEA)
2109 return fremoveea(filedes, name);
2110 #elif defined(HAVE_EXTATTR_DELETE_FD)
2111 char *s;
2112 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2113 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2114 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2115
2116 return extattr_delete_fd(filedes, attrnamespace, attrname);
2117 #elif defined(HAVE_ATTR_REMOVEF)
2118 int flags = 0;
2119 char *attrname = strchr(name,'.') + 1;
2120
2121 if (strncmp(name, "system", 6) == 0) flags |= ATTR_ROOT;
2122
2123 return attr_removef(filedes, attrname, flags);
2124 #elif defined(HAVE_ATTROPEN)
2125 int ret = -1;
2126 int attrdirfd = solaris_openat(filedes, ".", O_RDONLY|O_XATTR, 0);
2127 if (attrdirfd >= 0) {
2128 ret = solaris_unlinkat(attrdirfd, name);
2129 close(attrdirfd);
2130 }
2131 return ret;
2132 #else
2133 errno = ENOSYS;
2134 return -1;
2135 #endif
2136 }
2137
2138 int sys_setxattr (const char *path, const char *name, const void *value, size_t size, int flags)
2139 {
2140 #if defined(HAVE_SETXATTR)
2141 #ifndef XATTR_ADD_OPT
2142 return setxattr(path, name, value, size, flags);
2143 #else
2144 int options = 0;
2145 return setxattr(path, name, value, size, 0, options);
2146 #endif
2147 #elif defined(HAVE_SETEA)
2148 return setea(path, name, value, size, flags);
2149 #elif defined(HAVE_EXTATTR_SET_FILE)
2150 char *s;
2151 int retval = 0;
2152 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2153 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2154 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2155 if (flags) {
2156 /* Check attribute existence */
2157 retval = extattr_get_file(path, attrnamespace, attrname, NULL, 0);
2158 if (retval < 0) {
2159 /* REPLACE attribute, that doesn't exist */
2160 if (flags & XATTR_REPLACE && errno == ENOATTR) {
2161 errno = ENOATTR;
2162 return -1;
2163 }
2164 /* Ignore other errors */
2165 }
2166 else {
2167 /* CREATE attribute, that already exists */
2168 if (flags & XATTR_CREATE) {
2169 errno = EEXIST;
2170 return -1;
2171 }
2172 }
2173 }
2174 retval = extattr_set_file(path, attrnamespace, attrname, value, size);
2175 return (retval < 0) ? -1 : 0;
2176 #elif defined(HAVE_ATTR_SET)
2177 int myflags = 0;
2178 char *attrname = strchr(name,'.') + 1;
2179
2180 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2181 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2182 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2183
2184 return attr_set(path, attrname, (const char *)value, size, myflags);
2185 #elif defined(HAVE_ATTROPEN)
2186 int ret = -1;
2187 int myflags = O_RDWR;
2188 int attrfd;
2189 if (flags & XATTR_CREATE) myflags |= O_EXCL;
2190 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2191 attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2192 if (attrfd >= 0) {
2193 ret = solaris_write_xattr(attrfd, value, size);
2194 close(attrfd);
2195 }
2196 return ret;
2197 #else
2198 errno = ENOSYS;
2199 return -1;
2200 #endif
2201 }
2202
2203 int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags)
2204 {
2205 #if defined(HAVE_LSETXATTR)
2206 return lsetxattr(path, name, value, size, flags);
2207 #elif defined(HAVE_SETXATTR) && defined(XATTR_ADD_OPT)
2208 int options = XATTR_NOFOLLOW;
2209 return setxattr(path, name, value, size, 0, options);
2210 #elif defined(LSETEA)
2211 return lsetea(path, name, value, size, flags);
2212 #elif defined(HAVE_EXTATTR_SET_LINK)
2213 char *s;
2214 int retval = 0;
2215 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2216 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2217 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2218 if (flags) {
2219 /* Check attribute existence */
2220 retval = extattr_get_link(path, attrnamespace, attrname, NULL, 0);
2221 if (retval < 0) {
2222 /* REPLACE attribute, that doesn't exist */
2223 if (flags & XATTR_REPLACE && errno == ENOATTR) {
2224 errno = ENOATTR;
2225 return -1;
2226 }
2227 /* Ignore other errors */
2228 }
2229 else {
2230 /* CREATE attribute, that already exists */
2231 if (flags & XATTR_CREATE) {
2232 errno = EEXIST;
2233 return -1;
2234 }
2235 }
2236 }
2237
2238 retval = extattr_set_link(path, attrnamespace, attrname, value, size);
2239 return (retval < 0) ? -1 : 0;
2240 #elif defined(HAVE_ATTR_SET)
2241 int myflags = ATTR_DONTFOLLOW;
2242 char *attrname = strchr(name,'.') + 1;
2243
2244 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2245 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2246 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2247
2248 return attr_set(path, attrname, (const char *)value, size, myflags);
2249 #elif defined(HAVE_ATTROPEN)
2250 int ret = -1;
2251 int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW;
2252 int attrfd;
2253 if (flags & XATTR_CREATE) myflags |= O_EXCL;
2254 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2255 attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2256 if (attrfd >= 0) {
2257 ret = solaris_write_xattr(attrfd, value, size);
2258 close(attrfd);
2259 }
2260 return ret;
2261 #else
2262 errno = ENOSYS;
2263 return -1;
2264 #endif
2265 }
2266
2267 int sys_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags)
2268 {
2269 #if defined(HAVE_FSETXATTR)
2270 #ifndef XATTR_ADD_OPT
2271 return fsetxattr(filedes, name, value, size, flags);
2272 #else
2273 int options = 0;
2274 return fsetxattr(filedes, name, value, size, 0, options);
2275 #endif
2276 #elif defined(HAVE_FSETEA)
2277 return fsetea(filedes, name, value, size, flags);
2278 #elif defined(HAVE_EXTATTR_SET_FD)
2279 char *s;
2280 int retval = 0;
2281 int attrnamespace = (strncmp(name, "system", 6) == 0) ?
2282 EXTATTR_NAMESPACE_SYSTEM : EXTATTR_NAMESPACE_USER;
2283 const char *attrname = ((s=strchr_m(name, '.')) == NULL) ? name : s + 1;
2284 if (flags) {
2285 /* Check attribute existence */
2286 retval = extattr_get_fd(filedes, attrnamespace, attrname, NULL, 0);
2287 if (retval < 0) {
2288 /* REPLACE attribute, that doesn't exist */
2289 if (flags & XATTR_REPLACE && errno == ENOATTR) {
2290 errno = ENOATTR;
2291 return -1;
2292 }
2293 /* Ignore other errors */
2294 }
2295 else {
2296 /* CREATE attribute, that already exists */
2297 if (flags & XATTR_CREATE) {
2298 errno = EEXIST;
2299 return -1;
2300 }
2301 }
2302 }
2303 retval = extattr_set_fd(filedes, attrnamespace, attrname, value, size);
2304 return (retval < 0) ? -1 : 0;
2305 #elif defined(HAVE_ATTR_SETF)
2306 int myflags = 0;
2307 char *attrname = strchr(name,'.') + 1;
2308
2309 if (strncmp(name, "system", 6) == 0) myflags |= ATTR_ROOT;
2310 if (flags & XATTR_CREATE) myflags |= ATTR_CREATE;
2311 if (flags & XATTR_REPLACE) myflags |= ATTR_REPLACE;
2312
2313 return attr_setf(filedes, attrname, (const char *)value, size, myflags);
2314 #elif defined(HAVE_ATTROPEN)
2315 int ret = -1;
2316 int myflags = O_RDWR | O_XATTR;
2317 int attrfd;
2318 if (flags & XATTR_CREATE) myflags |= O_EXCL;
2319 if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
2320 attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
2321 if (attrfd >= 0) {
2322 ret = solaris_write_xattr(attrfd, value, size);
2323 close(attrfd);
2324 }
2325 return ret;
2326 #else
2327 errno = ENOSYS;
2328 return -1;
2329 #endif
2330 }
2331
2332 /**************************************************************************
2333 helper functions for Solaris' EA support
2334 ****************************************************************************/
2335 #ifdef HAVE_ATTROPEN
2336 static ssize_t solaris_read_xattr(int attrfd, void *value, size_t size)
2337 {
2338 struct stat sbuf;
2339
2340 if (fstat(attrfd, &sbuf) == -1) {
2341 errno = ENOATTR;
2342 return -1;
2343 }
2344
2345 /* This is to return the current size of the named extended attribute */
2346 if (size == 0) {
2347 return sbuf.st_size;
2348 }
2349
2350 /* check size and read xattr */
2351 if (sbuf.st_size > size) {
2352 errno = ERANGE;
2353 return -1;
2354 }
2355
2356 return read(attrfd, value, sbuf.st_size);
2357 }
2358
2359 static ssize_t solaris_list_xattr(int attrdirfd, char *list, size_t size)
2360 {
2361 ssize_t len = 0;
2362 DIR *dirp;
2363 struct dirent *de;
2364 int newfd = dup(attrdirfd);
2365 /* CAUTION: The originating file descriptor should not be
2366 used again following the call to fdopendir().
2367 For that reason we dup() the file descriptor
2368 here to make things more clear. */
2369 dirp = fdopendir(newfd);
2370
2371 while ((de = readdir(dirp))) {
2372 size_t listlen = strlen(de->d_name) + 1;
2373 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
2374 /* we don't want "." and ".." here: */
2375 DEBUG(10,("skipped EA %s\n",de->d_name));
2376 continue;
2377 }
2378
2379 if (size == 0) {
2380 /* return the current size of the list of extended attribute names*/
2381 len += listlen;
2382 } else {
2383 /* check size and copy entrieѕ + nul into list. */
2384 if ((len + listlen) > size) {
2385 errno = ERANGE;
2386 len = -1;
2387 break;
2388 } else {
2389 strlcpy(list + len, de->d_name, listlen);
2390 len += listlen;
2391 }
2392 }
2393 }
2394
2395 if (closedir(dirp) == -1) {
2396 DEBUG(0,("closedir dirp failed: %s\n",strerror(errno)));
2397 return -1;
2398 }
2399 return len;
2400 }
2401
2402 static int solaris_unlinkat(int attrdirfd, const char *name)
2403 {
2404 if (unlinkat(attrdirfd, name, 0) == -1) {
2405 if (errno == ENOENT) {
2406 errno = ENOATTR;
2407 }
2408 return -1;
2409 }
2410 return 0;
2411 }
2412
2413 static int solaris_attropen(const char *path, const char *attrpath, int oflag, mode_t mode)
2414 {
2415 int filedes = attropen(path, attrpath, oflag, mode);
2416 if (filedes == -1) {
2417 DEBUG(10,("attropen FAILED: path: %s, name: %s, errno: %s\n",path,attrpath,strerror(errno)));
2418 if (errno == EINVAL) {
2419 errno = ENOTSUP;
2420 } else {
2421 errno = ENOATTR;
2422 }
2423 }
2424 return filedes;
2425 }
2426
2427 static int solaris_openat(int fildes, const char *path, int oflag, mode_t mode)
2428 {
2429 int filedes = openat(fildes, path, oflag, mode);
2430 if (filedes == -1) {
2431 DEBUG(10,("openat FAILED: fd: %d, path: %s, errno: %s\n",filedes,path,strerror(errno)));
2432 if (errno == EINVAL) {
2433 errno = ENOTSUP;
2434 } else {
2435 errno = ENOATTR;
2436 }
2437 }
2438 return filedes;
2439 }
2440
2441 static int solaris_write_xattr(int attrfd, const char *value, size_t size)
2442 {
2443 if ((ftruncate(attrfd, 0) == 0) && (write(attrfd, value, size) == size)) {
2444 return 0;
2445 } else {
2446 DEBUG(10,("solaris_write_xattr FAILED!\n"));
2447 return -1;
2448 }
2449 }
2450 #endif /*HAVE_ATTROPEN*/
2451
2452
2453 /****************************************************************************
2454 Return the major devicenumber for UNIX extensions.
2455 ****************************************************************************/
2456
2457 uint32 unix_dev_major(SMB_DEV_T dev)
2458 {
2459 #if defined(HAVE_DEVICE_MAJOR_FN)
2460 return (uint32)major(dev);
2461 #else
2462 return (uint32)(dev >> 8);
2463 #endif
2464 }
2465
2466 /****************************************************************************
2467 Return the minor devicenumber for UNIX extensions.
2468 ****************************************************************************/
2469
2470 uint32 unix_dev_minor(SMB_DEV_T dev)
2471 {
2472 #if defined(HAVE_DEVICE_MINOR_FN)
2473 return (uint32)minor(dev);
2474 #else
2475 return (uint32)(dev & 0xff);
2476 #endif
2477 }
2478
2479 #if defined(WITH_AIO)
2480
2481 /*******************************************************************
2482 An aio_read wrapper that will deal with 64-bit sizes.
2483 ********************************************************************/
2484
2485 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2486 {
2487 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_READ64)
2488 return aio_read64(aiocb);
2489 #elif defined(HAVE_AIO_READ)
2490 return aio_read(aiocb);
2491 #else
2492 errno = ENOSYS;
2493 return -1;
2494 #endif
2495 }
2496
2497 /*******************************************************************
2498 An aio_write wrapper that will deal with 64-bit sizes.
2499 ********************************************************************/
2500
2501 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2502 {
2503 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_WRITE64)
2504 return aio_write64(aiocb);
2505 #elif defined(HAVE_AIO_WRITE)
2506 return aio_write(aiocb);
2507 #else
2508 errno = ENOSYS;
2509 return -1;
2510 #endif
2511 }
2512
2513 /*******************************************************************
2514 An aio_return wrapper that will deal with 64-bit sizes.
2515 ********************************************************************/
2516
2517 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2518 {
2519 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_RETURN64)
2520 return aio_return64(aiocb);
2521 #elif defined(HAVE_AIO_RETURN)
2522 return aio_return(aiocb);
2523 #else
2524 errno = ENOSYS;
2525 return -1;
2526 #endif
2527 }
2528
2529 /*******************************************************************
2530 An aio_cancel wrapper that will deal with 64-bit sizes.
2531 ********************************************************************/
2532
2533 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2534 {
2535 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_CANCEL64)
2536 return aio_cancel64(fd, aiocb);
2537 #elif defined(HAVE_AIO_CANCEL)
2538 return aio_cancel(fd, aiocb);
2539 #else
2540 errno = ENOSYS;
2541 return -1;
2542 #endif
2543 }
2544
2545 /*******************************************************************
2546 An aio_error wrapper that will deal with 64-bit sizes.
2547 ********************************************************************/
2548
2549 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2550 {
2551 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_ERROR64)
2552 return aio_error64(aiocb);
2553 #elif defined(HAVE_AIO_ERROR)
2554 return aio_error(aiocb);
2555 #else
2556 errno = ENOSYS;
2557 return -1;
2558 #endif
2559 }
2560
2561 /*******************************************************************
2562 An aio_fsync wrapper that will deal with 64-bit sizes.
2563 ********************************************************************/
2564
2565 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2566 {
2567 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_FSYNC64)
2568 return aio_fsync64(op, aiocb);
2569 #elif defined(HAVE_AIO_FSYNC)
2570 return aio_fsync(op, aiocb);
2571 #else
2572 errno = ENOSYS;
2573 return -1;
2574 #endif
2575 }
2576
2577 /*******************************************************************
2578 An aio_fsync wrapper that will deal with 64-bit sizes.
2579 ********************************************************************/
2580
2581 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2582 {
2583 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_AIOCB64) && defined(HAVE_AIO_SUSPEND64)
2584 return aio_suspend64(cblist, n, timeout);
2585 #elif defined(HAVE_AIO_FSYNC)
2586 return aio_suspend(cblist, n, timeout);
2587 #else
2588 errno = ENOSYS;
2589 return -1;
2590 #endif
2591 }
2592 #else /* !WITH_AIO */
2593
2594 int sys_aio_read(SMB_STRUCT_AIOCB *aiocb)
2595 {
2596 errno = ENOSYS;
2597 return -1;
2598 }
2599
2600 int sys_aio_write(SMB_STRUCT_AIOCB *aiocb)
2601 {
2602 errno = ENOSYS;
2603 return -1;
2604 }
2605
2606 ssize_t sys_aio_return(SMB_STRUCT_AIOCB *aiocb)
2607 {
2608 errno = ENOSYS;
2609 return -1;
2610 }
2611
2612 int sys_aio_cancel(int fd, SMB_STRUCT_AIOCB *aiocb)
2613 {
2614 errno = ENOSYS;
2615 return -1;
2616 }
2617
2618 int sys_aio_error(const SMB_STRUCT_AIOCB *aiocb)
2619 {
2620 errno = ENOSYS;
2621 return -1;
2622 }
2623
2624 int sys_aio_fsync(int op, SMB_STRUCT_AIOCB *aiocb)
2625 {
2626 errno = ENOSYS;
2627 return -1;
2628 }
2629
2630 int sys_aio_suspend(const SMB_STRUCT_AIOCB * const cblist[], int n, const struct timespec *timeout)
2631 {
2632 errno = ENOSYS;
2633 return -1;
2634 }
2635 #endif /* WITH_AIO */
reg import