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