source: trunk/src/sh_calls.c@ 316

Last change on this file since 316 was 315, checked in by katerina, 14 years ago

Fix for ticket #236 (blocking on NFS mounts).
File size: 19.8 KB
Line 
1/* SAMHAIN file system integrity testing */
2/* Copyright (C) 1999 Rainer Wichmann */
3/* */
4/* This program is free software; you can redistribute it */
5/* and/or modify */
6/* it under the terms of the GNU General Public License as */
7/* published by */
8/* the Free Software Foundation; either version 2 of the License, or */
9/* (at your option) any later version. */
10/* */
11/* This program is distributed in the hope that it will be useful, */
12/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
13/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
14/* GNU General Public License for more details. */
15/* */
16/* You should have received a copy of the GNU General Public License */
17/* along with this program; if not, write to the Free Software */
18/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20#include "config_xor.h"
21
22#ifdef HOST_IS_HPUX
23#define _XOPEN_SOURCE_EXTENDED
24#endif
25
26#include <stdlib.h>
27#include <string.h>
28#include <errno.h>
29
30#include <sys/types.h>
31#include <unistd.h>
32#include <sys/stat.h>
33#include <fcntl.h>
34#include <signal.h>
35#include <sys/socket.h>
36#include <netinet/in.h>
37
38#ifndef S_SPLINT_S
39#include <arpa/inet.h>
40#else
41#define AF_INET 2
42#endif
43
44#include <time.h>
45
46#ifndef HAVE_LSTAT
47#define lstat stat
48#endif
49
50#include "samhain.h"
51#include "sh_error.h"
52#include "sh_calls.h"
53#include "sh_ipvx.h"
54#include "sh_sub.h"
55#include "sh_utils.h"
56
57#undef FIL__
58#define FIL__ _("sh_calls.c")
59
60char aud_err_message[64];
61
62typedef struct cht_struct
63{
64 const char * str;
65 unsigned long val;
66} cht_type;
67
68static cht_type aud_tab[] =
69{
70 { N_("execve"), AUD_EXEC },
71 { N_("utime"), AUD_UTIME },
72 { N_("unlink"), AUD_UNLINK },
73 { N_("dup"), AUD_DUP },
74 { N_("chdir"), AUD_CHDIR },
75 { N_("open"), AUD_OPEN },
76 { N_("kill"), AUD_KILL },
77 { N_("exit"), AUD_EXIT },
78 { N_("fork"), AUD_FORK },
79 { N_("setuid"), AUD_SETUID },
80 { N_("setgid"), AUD_SETGID },
81 { N_("pipe"), AUD_PIPE },
82 { NULL, 0 }
83};
84
85/* Set aud functions
86 */
87int sh_aud_set_functions(const char * str_s)
88{
89 int i = 0;
90
91 SL_ENTER(_("sh_aud_set_functions"));
92
93 if (str_s == NULL)
94 return -1;
95
96 while (aud_tab[i].str != NULL)
97 {
98 if (NULL != sl_strstr (str_s, _(aud_tab[i].str)))
99 {
100 sh.flag.audit = 1;
101 sh.flag.aud_mask |= aud_tab[i].val;
102 }
103 ++i;
104 }
105
106 SL_RETURN(0,_("sh_aud_set_functions"));
107}
108
109
110
111
112/* Need to catch EINTR for these functions.
113 */
114long int retry_sigaction(const char * file, int line,
115 int signum, const struct sigaction *act,
116 struct sigaction *oldact)
117{
118 int error;
119 long int val_retry = -1;
120 char errbuf[SH_ERRBUF_SIZE];
121 errno = 0;
122
123 SL_ENTER(_("retry_sigaction"));
124
125 do {
126 val_retry = sigaction(signum, act, oldact);
127 } while (val_retry < 0 && errno == EINTR);
128
129 error = errno;
130 if (val_retry < 0) {
131 sh_error_handle ((-1), file, line, error, MSG_ERR_SIGACT,
132 sh_error_message(error, errbuf, sizeof(errbuf)),
133 (long) signum );
134 }
135 errno = error;
136 SL_RETURN(val_retry, _("retry_sigaction"));
137}
138
139static struct sh_sockaddr bind_addr;
140static int use_bind_addr = 0;
141
142int sh_calls_set_bind_addr (const char * str)
143{
144 static int reject = 0;
145
146 if (reject == 1)
147 return (0);
148
149 if (sh.flag.opts == S_TRUE)
150 reject = 1;
151
152#if defined(USE_IPVX)
153 if (0 == sh_ipvx_aton(str, &bind_addr))
154 return -1;
155#else
156 if (0 == inet_aton(str, &(bind_addr.sin.sin_addr)))
157 return -1;
158#endif
159
160 use_bind_addr = 1;
161 return 0;
162}
163
164
165long int retry_connect(const char * file, int line, int sockfd,
166 struct sockaddr *serv_addr, int addrlen)
167{
168 int error;
169 long int val_retry = 0;
170 char errbuf[SH_ERRBUF_SIZE];
171
172 SL_ENTER(_("retry_connect"));
173
174 errno = 0;
175
176 if (0 != use_bind_addr)
177 {
178 int slen = SH_SS_LEN(bind_addr);
179
180 val_retry = bind(sockfd, sh_ipvx_sockaddr_cast(&bind_addr), slen);
181 }
182
183 if (val_retry == 0)
184 {
185 do {
186 val_retry = connect(sockfd, serv_addr, addrlen);
187 } while (val_retry < 0 && (errno == EINTR || errno == EINPROGRESS));
188 }
189
190 error = errno;
191 if (val_retry != 0) {
192 long eport;
193 char eaddr[SH_IP_BUF];
194
195 struct sh_sockaddr ss;
196 sh_ipvx_save(&ss, serv_addr->sa_family, serv_addr);
197 sh_ipvx_ntoa(eaddr, sizeof(eaddr), &ss);
198
199 if (serv_addr->sa_family == AF_INET)
200 eport = (long) ntohs(((struct sockaddr_in *)serv_addr)->sin_port);
201 else
202 eport = (long) ntohs(((struct sockaddr_in6 *)serv_addr)->sin6_port);
203
204 sh_error_handle ((-1), file, line, error, MSG_ERR_CONNECT,
205 sh_error_message(error, errbuf, sizeof(errbuf)),
206 (long) sockfd, eport, eaddr);
207 }
208 errno = error;
209 SL_RETURN(val_retry, _("retry_connect"));
210}
211
212long int retry_accept(const char * file, int line, int fd,
213 struct sh_sockaddr *serv_addr, int * addrlen)
214{
215 int error;
216 long int val_retry = -1;
217 char errbuf[SH_ERRBUF_SIZE];
218 struct sockaddr_storage ss;
219
220 ACCEPT_TYPE_ARG3 my_addrlen = sizeof(ss);
221
222 errno = 0;
223
224 SL_ENTER(_("retry_accept"));
225
226 do {
227 val_retry = accept(fd, (struct sockaddr *)&ss, &my_addrlen);
228 } while (val_retry < 0 && errno == EINTR);
229
230 error = errno;
231 if (val_retry < 0) {
232 sh_error_handle ((-1), file, line, error, MSG_ERR_ACCEPT,
233 sh_error_message(error, errbuf, sizeof(errbuf)),
234 (long) fd );
235 }
236 errno = error;
237
238 sh_ipvx_save(serv_addr, ss.ss_family, (struct sockaddr *) &ss);
239
240 *addrlen = (int) my_addrlen;
241 SL_RETURN(val_retry, _("retry_accept"));
242}
243
244static int sh_use_sub = 0;
245
246int sh_calls_set_sub (const char * str)
247{
248 return sh_util_flagval(str, &sh_use_sub);
249}
250
251long int retry_lstat(const char * file, int line,
252 const char *file_name, struct stat *buf)
253{
254 int error;
255 long int val_retry = -1;
256 char errbuf[SH_ERRBUF_SIZE];
257
258 SL_ENTER(_("retry_lstat"));
259
260 if (sh_use_sub)
261 {
262 val_retry = sh_sub_lstat (file_name, buf);
263 }
264 else
265 {
266 do {
267 val_retry = /*@-unrecog@*/lstat (file_name, buf)/*@+unrecog@*/;
268 } while (val_retry < 0 && errno == EINTR);
269 }
270
271 error = errno;
272 if (val_retry < 0) {
273 (void) sh_error_message(error, aud_err_message, 64);
274 sh_error_handle ((-1), file, line, error, MSG_ERR_LSTAT,
275 sh_error_message(error, errbuf, sizeof(errbuf)),
276 file_name );
277 }
278 errno = error;
279
280 SL_RETURN(val_retry, _("retry_lstat"));
281}
282
283long int retry_stat(const char * file, int line,
284 const char *file_name, struct stat *buf)
285{
286 int error;
287 long int val_retry = -1;
288 char errbuf[SH_ERRBUF_SIZE];
289
290 SL_ENTER(_("retry_stat"));
291
292 if (sh_use_sub)
293 {
294 val_retry = sh_sub_stat (file_name, buf);
295 }
296 else
297 {
298 do {
299 val_retry = stat (file_name, buf);
300 } while (val_retry < 0 && errno == EINTR);
301 }
302
303 error = errno;
304 if (val_retry < 0) {
305 (void) sh_error_message(error, aud_err_message, 64);
306 sh_error_handle ((-1), file, line, error, MSG_ERR_STAT,
307 sh_error_message(error, errbuf, sizeof(errbuf)),
308 file_name );
309 }
310 errno = error;
311
312 SL_RETURN(val_retry, _("retry_stat"));
313}
314
315long int retry_fstat(const char * file, int line, int filed, struct stat *buf)
316{
317 int error;
318 long int val_retry = -1;
319 char errbuf[SH_ERRBUF_SIZE];
320
321 SL_ENTER(_("retry_fstat"));
322
323 do {
324 val_retry = fstat (filed, buf);
325 } while (val_retry < 0 && errno == EINTR);
326 error = errno;
327 if (val_retry < 0) {
328 sh_error_handle ((-1), file, line, error, MSG_ERR_FSTAT,
329 sh_error_message(error, errbuf, sizeof(errbuf)),
330 (long) filed );
331 }
332 errno = error;
333 SL_RETURN(val_retry, _("retry_fstat"));
334}
335
336long int retry_fcntl(const char * file, int line, int fd, int cmd, long arg)
337{
338 int error;
339 long int val_retry = -1;
340 char errbuf[SH_ERRBUF_SIZE];
341 errno = 0;
342
343 SL_ENTER(_("retry_fcntl"));
344
345 if (cmd == F_GETFD || cmd == F_GETFL)
346 {
347 do {
348 val_retry = fcntl(fd, cmd);
349 } while (val_retry < 0 && errno == EINTR);
350 }
351 else
352 {
353 do {
354 val_retry = fcntl(fd, cmd, arg);
355 } while (val_retry < 0 && errno == EINTR);
356 }
357 error = errno;
358 if (val_retry < 0) {
359 sh_error_handle ((-1), file, line, error, MSG_ERR_FCNTL,
360 sh_error_message(error, errbuf, sizeof(errbuf)),
361 (long) fd, (long) cmd, arg );
362 }
363 errno = error;
364 SL_RETURN(val_retry, _("retry_fcntl"));
365}
366
367long int retry_msleep (int sec, int millisec)
368{
369 int result = 0;
370#if defined(HAVE_NANOSLEEP)
371 struct timespec req, rem;
372#endif
373
374 SL_ENTER(_("retry_msleep"));
375
376 errno = 0;
377 if (millisec > 999) millisec = 999;
378 if (millisec < 0) millisec = 0;
379 if (sec < 0) sec = 0;
380
381#if defined(HAVE_NANOSLEEP)
382 /*@-usedef@*/
383 req.tv_sec = sec; rem.tv_sec = 0;
384 req.tv_nsec = millisec * 1000000; rem.tv_nsec = 0;
385 /*@+usedef@*/
386 do {
387 result = /*@-unrecog@*/nanosleep(&req, &rem)/*@+unrecog@*/;
388
389 req.tv_sec = rem.tv_sec; rem.tv_sec = 0;
390 req.tv_nsec = rem.tv_nsec; rem.tv_nsec = 0;
391
392 } while ((result == -1) && (errno == EINTR));
393#else
394 if (sec > 0)
395 {
396 sleep (sec); /* nanosleep not available */
397 }
398 else
399 {
400#ifdef HAVE_USLEEP
401 if (millisec > 0)
402 {
403 usleep(1000 * millisec);
404 }
405#else
406 if (millisec > 0)
407 {
408 sleep (1);
409 }
410#endif
411 }
412#endif
413 SL_RETURN(result, _("retry_msleep"));
414}
415
416/***************************************************
417 *
418 * Audit these functions.
419 *
420 ***************************************************/
421
422long int retry_aud_execve (const char * file, int line,
423 const char *dateiname, char * argv[],
424 char * envp[])
425{
426 uid_t a = geteuid();
427 gid_t b = getegid();
428 int i;
429 int error;
430 char errbuf[SH_ERRBUF_SIZE];
431
432 SL_ENTER(_("retry_aud_execve"));
433
434 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_EXEC) != 0)
435 sh_error_handle ((-1), file, line, 0, MSG_AUD_EXEC,
436 dateiname, (long) a, (long) b );
437 do {
438 i = execve(dateiname, argv, envp);
439 } while (i < 0 && errno == EINTR);
440
441 error = errno;
442 if (i < 0) {
443 sh_error_handle ((-1), file, line, error, MSG_ERR_EXEC,
444 sh_error_message(error, errbuf, sizeof(errbuf)),
445 dateiname, (long) a, (long) b );
446 }
447 errno = error;
448 SL_RETURN(i, _("retry_aud_execve"));
449}
450
451
452long int retry_aud_utime (const char * file, int line,
453 char * path, struct utimbuf *buf)
454{
455 long int val_return;
456 int error;
457 char errbuf[SH_ERRBUF_SIZE];
458 errno = 0;
459
460 SL_ENTER(_("retry_aud_utime"));
461
462 do {
463 val_return = utime (path, buf);
464 } while (val_return < 0 && errno == EINTR);
465
466 error = errno;
467 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_UTIME) != 0)
468 sh_error_handle ((-1), file, line, 0, MSG_AUD_UTIME,
469 path,
470 (unsigned long) buf->actime,
471 (unsigned long) buf->modtime);
472 if (val_return < 0) {
473 sh_error_handle ((-1), file, line, error, MSG_ERR_UTIME,
474 sh_error_message(error, errbuf, sizeof(errbuf)),
475 path,
476 (unsigned long) buf->actime,
477 (unsigned long) buf->modtime);
478 }
479 errno = error;
480 SL_RETURN(val_return, _("retry_aud_utime"));
481}
482
483long int retry_aud_unlink (const char * file, int line,
484 char * path)
485{
486 long int val_return;
487 int error;
488 char errbuf[SH_ERRBUF_SIZE];
489 errno = 0;
490
491 SL_ENTER(_("retry_aud_unlink"));
492
493 do {
494 val_return = unlink (path);
495 } while (val_return < 0 && errno == EINTR);
496
497 error = errno;
498 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_UNLINK) != 0)
499 sh_error_handle ((-1), file, line, 0, MSG_AUD_UNLINK,
500 path);
501 if (val_return < 0) {
502 sh_error_handle ((-1), file, line, error, MSG_ERR_UNLINK,
503 sh_error_message(error, errbuf, sizeof(errbuf)),
504 path);
505 }
506 errno = error;
507 SL_RETURN(val_return, _("retry_aud_unlink"));
508}
509
510long int retry_aud_dup2 (const char * file, int line,
511 int fd, int fd2)
512{
513 long int val_return;
514 int error;
515 char errbuf[SH_ERRBUF_SIZE];
516 errno = 0;
517
518 SL_ENTER(_("retry_aud_dup2"));
519
520 do {
521 val_return = dup2 (fd, fd2);
522 } while (val_return < 0 && errno == EINTR);
523
524 error = errno;
525 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_DUP) != 0)
526 sh_error_handle ((-1), file, line, 0, MSG_AUD_DUP,
527 (long) fd, val_return);
528 if (val_return < 0) {
529 sh_error_handle ((-1), file, line, error, MSG_ERR_DUP,
530 sh_error_message(error, errbuf, sizeof(errbuf)),
531 (long) fd, val_return);
532 }
533 errno = error;
534 SL_RETURN(val_return, _("retry_aud_dup2"));
535}
536
537long int retry_aud_dup (const char * file, int line,
538 int fd)
539{
540 long int val_return;
541 int error;
542 char errbuf[SH_ERRBUF_SIZE];
543 errno = 0;
544
545 SL_ENTER(_("retry_aud_dup"));
546
547 do {
548 val_return = dup (fd);
549 } while (val_return < 0 && errno == EINTR);
550 error = errno;
551 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_DUP) != 0)
552 sh_error_handle ((-1), file, line, 0, MSG_AUD_DUP,
553 (long) fd, val_return);
554 if (val_return < 0) {
555 sh_error_handle ((-1), file, line, error, MSG_ERR_DUP,
556 sh_error_message(error, errbuf, sizeof(errbuf)),
557 (long) fd, val_return);
558 }
559 errno = error;
560 SL_RETURN(val_return, _("retry_aud_dup"));
561}
562
563
564
565long int retry_aud_chdir (const char * file, int line,
566 const char *path)
567{
568 long int val_return;
569 int error = 0;
570 char errbuf[SH_ERRBUF_SIZE];
571 errno = 0;
572
573 SL_ENTER(_("retry_aud_chdir"));
574
575 do {
576 val_return = chdir (path);
577 } while (val_return < 0 && errno == EINTR);
578
579 error = errno;
580 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_CHDIR) != 0)
581 sh_error_handle ((-1), file, line, 0, MSG_AUD_CHDIR,
582 path);
583 if (val_return < 0) {
584 sh_error_handle ((-1), file, line, error, MSG_ERR_CHDIR,
585 sh_error_message(error, errbuf, sizeof(errbuf)),
586 path);
587 }
588 errno = error;
589 SL_RETURN(val_return, _("retry_aud_chdir"));
590}
591
592
593long int aud_open_noatime (const char * file, int line, int privs,
594 const char *pathname, int flags, mode_t mode,
595 int * o_noatime)
596{
597 long int val_return;
598 int error;
599 char errbuf[SH_ERRBUF_SIZE];
600
601 SL_ENTER(_("aud_open"));
602
603 val_return = open (pathname, *o_noatime|flags, mode);
604 if ((val_return < 0) && (*o_noatime != 0))
605 {
606 val_return = open (pathname, flags, mode);
607 if (val_return >= 0)
608 *o_noatime = 0;
609 }
610 error = errno;
611 /*@-noeffect@*/
612 (void) privs; /* fix compiler warning */
613 /*@+noeffect@*/
614
615 if (val_return < 0)
616 {
617 (void) sh_error_message(error, aud_err_message, 64);
618 }
619
620 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_OPEN) != 0)
621 {
622 sh_error_handle ((-1), file, line, 0, MSG_AUD_OPEN,
623 pathname, (long) flags, (long) mode, val_return);
624 }
625 if (val_return < 0) {
626 sh_error_handle ((-1), file, line, error, MSG_ERR_OPEN,
627 sh_error_message(error, errbuf, sizeof(errbuf)),
628 pathname, (long) flags, (long) mode, val_return);
629 }
630 errno = error;
631 SL_RETURN(val_return, _("aud_open"));
632}
633
634long int aud_open (const char * file, int line, int privs,
635 const char *pathname, int flags, mode_t mode)
636{
637 long int val_return;
638 int error;
639 char errbuf[SH_ERRBUF_SIZE];
640
641 SL_ENTER(_("aud_open"));
642
643 val_return = open (pathname, flags, mode);
644 error = errno;
645 /*@-noeffect@*/
646 (void) privs; /* fix compiler warning */
647 /*@+noeffect@*/
648
649 if (val_return < 0)
650 {
651 (void) sh_error_message(error, aud_err_message, 64);
652 }
653
654 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_OPEN) != 0)
655 {
656 sh_error_handle ((-1), file, line, 0, MSG_AUD_OPEN,
657 pathname, (long) flags, (long) mode, val_return);
658 }
659 if (val_return < 0) {
660 sh_error_handle ((-1), file, line, error, MSG_ERR_OPEN,
661 sh_error_message(error, errbuf, sizeof(errbuf)),
662 pathname, (long) flags, (long) mode, val_return);
663 }
664 errno = error;
665 SL_RETURN(val_return, _("aud_open"));
666}
667
668long int aud_kill (const char * file, int line, pid_t pid, int sig)
669{
670 int myerror;
671 long int val_return = kill (pid, sig);
672 char errbuf[SH_ERRBUF_SIZE];
673 myerror = errno;
674
675 SL_ENTER(_("aud_kill"));
676
677 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_KILL) != 0)
678 sh_error_handle ((-1), file, line, 0, MSG_AUD_KILL,
679 (long) pid, (long) sig);
680 if (val_return < 0) {
681 sh_error_handle ((-1), file, line, myerror, MSG_ERR_KILL,
682 sh_error_message(myerror, errbuf, sizeof(errbuf)),
683 (long) pid, (long) sig);
684 }
685 errno = myerror;
686 SL_RETURN(val_return, _("aud_kill"));
687}
688
689/*@noreturn@*/
690void aud_exit (const char * file, int line, int fd)
691{
692 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_EXIT) != 0)
693 sh_error_handle ((-1), file, line, 0, MSG_AUD_EXIT,
694 (long) fd);
695
696 SL_ENTER(_("aud_exit"));
697
698 sh.flag.exit = fd;
699 exit(fd);
700}
701
702/*@noreturn@*/
703void aud__exit (const char * file, int line, int fd)
704{
705 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_EXIT) != 0)
706 sh_error_handle ((-1), file, line, 0, MSG_AUD_EXIT,
707 (long) fd);
708
709 SL_ENTER(_("aud__exit"));
710
711 sh.flag.exit = fd;
712 _exit(fd);
713}
714
715pid_t aud_fork (const char * file, int line)
716{
717 int error;
718 pid_t i = fork();
719 char errbuf[SH_ERRBUF_SIZE];
720
721 error = errno;
722 SL_ENTER(_("aud_fork"));
723
724 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_FORK) != 0 && (i > 0))
725 sh_error_handle ((-1), file, line, 0, MSG_AUD_FORK,
726 (long) i);
727 if (i == (pid_t) -1) {
728 sh_error_handle ((-1), file, line, error, MSG_ERR_FORK,
729 sh_error_message(error, errbuf, sizeof(errbuf)),
730 (long) i);
731 }
732 errno = error;
733 SL_RETURN(i, _("aud_fork"));
734}
735
736int aud_setuid (const char * file, int line, uid_t uid)
737{
738 int error = 0;
739 int i = 0;
740 char errbuf[SH_ERRBUF_SIZE];
741
742 SL_ENTER(_("aud_setuid"));
743
744 if (uid != (uid_t) 0) {
745 i = setuid(uid);
746 error = errno;
747 }
748 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_SETUID) != 0)
749 sh_error_handle ((-1), file, line, 0, MSG_AUD_SETUID,
750 (long) uid);
751 if (uid == (uid_t) 0) {
752 i = setuid(uid);
753 error = errno;
754 }
755 if (i < 0) {
756 sh_error_handle ((-1), file, line, error, MSG_ERR_SETUID,
757 sh_error_message(error, errbuf, sizeof(errbuf)),
758 (long) uid);
759 }
760 errno = error;
761 SL_RETURN(i, _("aud_setuid"));
762}
763
764int aud_setgid (const char * file, int line, gid_t gid)
765{
766 int error = 0;
767 int i = 0;
768 char errbuf[SH_ERRBUF_SIZE];
769
770 SL_ENTER(_("aud_setgid"));
771
772 if (gid != (gid_t) 0) {
773 i = setgid(gid);
774 error = errno;
775 }
776
777 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_SETGID) != 0)
778 sh_error_handle ((-1), file, line, 0, MSG_AUD_SETGID,
779 (long) gid);
780 if (gid == (gid_t) 0) {
781 i = setgid(gid);
782 error = errno;
783 }
784 if (i < 0) {
785 sh_error_handle ((-1), file, line, error, MSG_ERR_SETGID,
786 sh_error_message(error, errbuf, sizeof(errbuf)),
787 (long) gid);
788 }
789 errno = error;
790 SL_RETURN(i, _("aud_setgid"));
791}
792
793int aud_pipe (const char * file, int line, int * modus)
794{
795 int error;
796 int i = pipe (modus);
797 char errbuf[SH_ERRBUF_SIZE];
798
799 SL_ENTER(_("aud_pipe"));
800
801 error = errno;
802 if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_PIPE) != 0)
803 {
804 if (i < 0)
805 sh_error_handle ((-1), file, line, 0, MSG_AUD_PIPE,
806 (long) 0, (long) 0);
807 else
808 sh_error_handle ((-1), file, line, 0, MSG_AUD_PIPE,
809 (long) modus[0], (long) modus[1]);
810 }
811 if (i < 0) {
812 if (i < 0)
813 sh_error_handle ((-1), file, line, error, MSG_ERR_PIPE,
814 sh_error_message(error, errbuf, sizeof(errbuf)),
815 (long) 0, (long) 0);
816 else
817 sh_error_handle ((-1), file, line, error, MSG_ERR_PIPE,
818 sh_error_message(error, errbuf, sizeof(errbuf)),
819 (long) modus[0], (long) modus[1]);
820 }
821 SL_RETURN(i, _("aud_pipe"));
822}
Note: See TracBrowser for help on using the repository browser.