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