Context Navigation

source: vendor/3.6.9/source3/lib/system.c

Visit:

Last change on this file was 746, checked in by Silvan Scherrer, 13 years ago
Samba Server: updated vendor to 3.6.9
File size: 73.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: