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