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