source: trunk/src/slib.c@ 238

Last change on this file since 238 was 237, checked in by katerina, 15 years ago

Eliminate C99-style comments (ticket #154).
File size: 64.9 KB
RevLine 
[1]1#include "config_xor.h"
2
[196]3#if defined(HAVE_POSIX_FADVISE) && defined(HAVE_MINCORE)
4#define _XOPEN_SOURCE 600
5#define _BSD_SOURCE
6#endif
[1]7
8#include <stdio.h>
9#include <stdlib.h>
10#include <stdarg.h>
11#include <string.h>
[20]12#include <limits.h>
[34]13#ifdef HAVE_STDINT_H
14/* for SIZE_MAX */
15#include <stdint.h>
16#endif
[1]17
18#include <unistd.h>
19#include <sys/stat.h>
20#include <sys/types.h>
21#include <fcntl.h>
22#include <signal.h>
23
[196]24#if defined(HAVE_POSIX_FADVISE) && defined(HAVE_MINCORE)
25#include <sys/mman.h>
26#endif
27
[1]28#if TIME_WITH_SYS_TIME
29#include <sys/time.h>
30#include <time.h>
31#else
32#if HAVE_SYS_TIME_H
33#include <sys/time.h>
34#else
35#include <time.h>
36#endif
37#endif
38
39#ifdef HAVE_MEMORY_H
40#include <memory.h>
41#endif
42#ifdef HAVE_SYS_SELECT_H
43#include <sys/select.h>
44#endif
45
46#ifndef FD_SET
47#define NFDBITS 32
48#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
49#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
50#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
51#endif /* !FD_SET */
52#ifndef FD_SETSIZE
53#define FD_SETSIZE 32
54#endif
55#ifndef FD_ZERO
56#define FD_ZERO(p) memset((char *)(p), '\0', sizeof(*(p)))
57#endif
58
[76]59#define SH_REAL_SET
60
[1]61#include "slib.h"
62#include "sh_calls.h"
63#define SH_NEED_PWD_GRP 1
64#include "sh_static.h"
[144]65#include "sh_pthread.h"
[167]66#include "sh_string.h"
[1]67
68#undef FIL__
69#define FIL__ _("slib.c")
70
71const uid_t sh_uid_neg = ((uid_t) -1);
72const gid_t sh_gid_neg = ((gid_t) -1);
73
74#undef BREAKEXIT
75#if defined(SCREW_IT_UP) && defined(__linux__) && defined(__i386__)
76
77#ifdef SH_DEBUG
78#define BREAKEXIT(expr) \
79 do { \
80 int ixi; \
81 for (ixi = 0; ixi < 8; ++ixi) { \
82 if ((*(volatile unsigned *)((unsigned) expr + ixi) & 0xff) == 0xcc) \
83 { dlog(0, FIL__, __LINE__, _("BREAKEXIT")); _exit(EXIT_FAILURE); } \
84 } \
85 } \
86 while (1 == 0)
87#else
88#define BREAKEXIT(expr) \
89 do { \
90 int ixi; \
91 for (ixi = 0; ixi < 8; ++ixi) { \
92 if ((*(volatile unsigned *)((unsigned) expr + ixi) & 0xff) == 0xcc) \
93 _exit(EXIT_FAILURE); \
94 } \
95 } \
96 while (1 == 0)
97#endif
98
99#else
100#define BREAKEXIT(expr)
101#endif
102
103/****************************************************************
104 *
105 * The debug/trace subsystem
106 *
107 ****************************************************************/
108
109int slib_do_trace = 0;
110int slib_trace_fd = -1;
111
112static char trace_log[256] = { '\0' };
113static int trace_level = 0;
114static FILE * trace_fp = NULL;
115
[20]116int sl_trace_use (const char * dummy)
[1]117{
[169]118 (void) dummy;
119 slib_do_trace = 1;
[1]120 return 0;
121}
122
[20]123int sl_trace_file (const char * str)
[1]124{
125 if (!str)
126 return -1;
127 if (str[0] != '/')
128 return -1;
129 sl_strlcpy(trace_log, str, 256);
130 return 0;
131}
132
[170]133FILE * sl_tracefile_open(const char * file, const char * mode)
[1]134{
135 FILE * xp = NULL;
136 slib_trace_fd = open(file, O_WRONLY|O_CREAT|O_APPEND, 0600);
137 if (slib_trace_fd >= 0)
138 xp = fdopen(slib_trace_fd, mode);
139 return xp;
140}
141
[170]142void sl_trace_in(const char * str, const char * file, int line)
[1]143{
144 int i;
145 if (trace_log[0] == '\0')
146 {
147 fprintf(stderr, "++ ");
148 for (i = 0; i < trace_level; ++i)
149 fprintf(stderr, ". ");
150 fprintf(stderr, "[%2d] %s \t - File %c%s%c at line %d\n",
151 trace_level, str, 0x22, file, 0x22, line);
152 }
153 else if (!sl_is_suid())
154 {
155 if (!trace_fp)
156 trace_fp = sl_tracefile_open(trace_log, "a");
157 if (trace_fp)
158 {
159 fprintf(trace_fp, "++ ");
160 for (i = 0; i < trace_level; ++i)
161 fprintf(trace_fp, ". ");
162 fprintf(trace_fp, "[%2d] %s \t - File %c%s%c at line %d\n",
163 trace_level, str, 0x22, file, 0x22, line);
[169]164 fflush(trace_fp);
[1]165 }
166 else
167 {
168 perror(_("sl_trace_in: fopen"));
169 _exit(1);
170 }
171 }
172 ++trace_level;
173}
174
[170]175void sl_trace_out(const char * str, const char * file, int line)
[1]176{
177 int i;
178
179 --trace_level; if (trace_level < 0) trace_level = 0;
180
181 if (trace_log[0] == '\0')
182 {
183 fprintf(stderr, "-- ");
184 for (i = 0; i < trace_level; ++i)
185 fprintf(stderr, ". ");
186 fprintf(stderr, _("[%2d] %s \t - File %c%s%c at line %d\n"),
187 trace_level, str, 0x22, file, 0x22, line);
188 }
189 else if (!sl_is_suid())
190 {
191 if (!trace_fp)
192 trace_fp = sl_tracefile_open(trace_log, "a");
193 if (trace_fp)
194 {
195 fprintf(trace_fp, "-- ");
196 for (i = 0; i < trace_level; ++i)
197 fprintf(trace_fp, ". ");
198 fprintf(trace_fp, _("[%2d] %s \t - File %c%s%c at line %d\n"),
199 trace_level, str, 0x22, file, 0x22, line);
[169]200 fflush(trace_fp);
[1]201 }
202 else
203 {
204 perror(_("sl_trace_out: fopen"));
205 _exit(1);
206 }
207 }
208}
209
[170]210extern int sh_log_console (const char * msg);
[1]211
212static int dlogActive = 0;
213
214/* this is called from sh_error_setprint()
215 */
216void dlog_set_active(int flag)
217{
218 dlogActive = flag;
219}
220
221/* flag = 0 debug messages
222 * = 1 descriptive error messages
223 * = 3 backtrace
224 */
[170]225int dlog (int flag, const char * file, int line, const char *fmt, ...)
[1]226{
227 va_list ap;
228 char val[81];
229 char msg[512];
230 char tmp[512];
231 int retval = 0;
232 int i;
233
234#ifdef SH_STEALTH
235 /*
236 * do not even print descriptive failure messages in stealth mode
237 */
238 if (dlogActive == 0)
239 return 0;
240 if (dlogActive == 1 && flag == 0) /* debug requires debug level */
241 return 0;
242#else
243 if (dlogActive <= 1 && flag == 0) /* debug requires debug level */
244 return 0;
245#endif
246
247 if (flag == 1)
248 {
[22]249 sl_snprintf (val, 81, _("\n--------- %10s "), file);
[1]250 sl_strlcpy (msg, val, 80);
[22]251 sl_snprintf (val, 81, _(" --- %6d ---------\n"), line);
[1]252 sl_strlcat (msg, val, 80);
253 sh_log_console (msg);
254 }
255
256 va_start (ap, fmt);
257 if (flag == 1)
258 sl_strlcpy(tmp, fmt, 512);
259 else
260 sl_strlcpy(tmp, fmt, 256);
261 retval = sl_strlen(tmp);
262 if (retval > 0 && tmp[retval-1] == '\n')
263 tmp[retval-1] = '\0';
264 retval = 0;
265 if (flag == 1)
266 {
267 sl_vsnprintf (msg, 511, tmp, ap);
268 }
269 else
270 {
271 sl_strlcpy (msg, "## ", 256);
272 for (i = 0; i < trace_level; ++i)
273 sl_strlcat (msg, ". ", 256);
274 sprintf (val, _("[%2d] "), trace_level);
275 sl_strlcat (msg, val, 256);
276 sl_vsnprintf (&msg[sl_strlen(msg)], 255, tmp, ap);
277 sl_snprintf (tmp, 255, _(" \t - File %c%s%c at line %d"),
278 0x22, file, 0x22, line);
279 sl_strlcat (msg, tmp, 512);
280 }
281 va_end (ap);
282 if (flag != 0 || sl_is_suid())
283 retval = sh_log_console (msg);
284 else
285 {
286 if (trace_log[0] == '\0')
287 {
288 /* sh_log_console (msg); */
289 fprintf(stderr, "%s\n", msg);
290 }
291 else
292 {
293 if (!trace_fp)
294 trace_fp = sl_tracefile_open(trace_log, "a");
295 if (trace_fp)
296 {
297 fprintf(trace_fp, "%s\n", msg);
298 }
299 else
300 {
301 perror(_("dlog: fopen"));
302 _exit(1);
303 }
304 }
305 }
306 if (flag == 1)
307 sh_log_console (_("\n----------------------------------------------\n"));
308 return retval;
309}
310
311extern char aud_err_message[64];
312static char alt_err_message[64];
313char * sl_get_errmsg()
314{
315 if (aud_err_message[0] == '\0')
316 {
317 sl_strlcpy(alt_err_message, sl_error_string(sl_errno), 64);
318 return &alt_err_message[0];
319 }
320 return &aud_err_message[0];
321}
322
323
324#if defined(SL_DEBUG)
325#define SL_MAX_MYSTACK 128
326
327static char sl_mystack[SL_MAX_MYSTACK][32];
328static int sl_mystack_count = 0;
329
330void sl_stack_push(char * c, char * file, int line )
331{
332 if (slib_do_trace)
333 sl_trace_in(c, file, line);
334 if (c && sl_mystack_count < SL_MAX_MYSTACK)
335 {
336 strncpy(sl_mystack[sl_mystack_count], c, 31);
337 sl_mystack[sl_mystack_count][31] = '\0';
338 ++sl_mystack_count;
339 /*
340 fprintf(stderr, "#%03d %s\n", sl_mystack_count,
341 sl_mystack[sl_mystack_count-1]);
342 */
343 }
344 return;
345}
346
347void sl_stack_pop(char * c, char * file, int line)
348{
349 if (slib_do_trace)
350 sl_trace_out(c, file, line);
351 if (sl_mystack_count > 0)
352 {
353 /*
354 fprintf(stderr, " <- #%03d %s\n", sl_mystack_count,
355 sl_mystack[sl_mystack_count-1]);
356 */
357 --sl_mystack_count;
358 }
359 return;
360}
361
362void sl_stack_print()
363{
364 int i;
365 /* FILE * dfile; */
366
367 if (sl_mystack_count > 0)
368 {
369 sh_log_console(_("\nBacktrace:\n"));
370 /* dlog(3, FIL__, __LINE__, _("\nBacktrace:\n")); */
371 for (i = 0; i < sl_mystack_count; ++i)
372 sh_log_console(sl_mystack[i]);
373 /* dlog(3, FIL__, __LINE__, _("#%03d %s\n"), i, sl_mystack[i]); */
374 }
375 return;
376}
377
378#endif
379
380
381/*
382 * The global errno.
383 * On error, this is set to the return value of the function.
384 */
385long int sl_errno;
386
387
388/* ----------------------------------------------------------------
389 *
390 * Capability routines
391 *
392 * ---------------------------------------------------------------- */
393
394int sl_useCaps = 0;
395
396#ifdef FANCY_LIBCAP
397#include <sys/capability.h>
398
399/*
400 * While these routines are tested and work, we don't use POSIX
401 * capabilities, as they don't seem to be useful (root can write
402 * to root-owned files anyway). Things would be more interesting
403 * if we could switch to a non-root UID with just a few capabilities
404 * enabled.
405 */
406int sl_drop_cap ()
407{
408 int error;
409 cap_t caps;
410 cap_flag_t capflag;
411 cap_flag_value_t capfval = CAP_CLEAR;
412 cap_value_t capvals_e[] =
413 {
414 CAP_CHOWN, CAP_FOWNER, CAP_FSETID,
415 CAP_LINUX_IMMUTABLE, CAP_MKNOD, CAP_NET_ADMIN,
416 CAP_NET_BIND_SERVICE, CAP_NET_BROADCAST, CAP_NET_RAW,
417 CAP_SYS_ADMIN, CAP_SYS_BOOT, CAP_SYS_CHROOT,
418 CAP_SYS_PACCT, CAP_SYS_PTRACE, CAP_SYS_RAWIO,
419 CAP_SYS_RESOURCE, CAP_SYS_TIME, CAP_SYS_TTY_CONFIG,
420 CAP_SETGID, CAP_SETUID, CAP_KILL,
421 CAP_DAC_OVERRIDE,
422#if !defined(WITH_MESSAGE_QUEUE)
423 CAP_IPC_OWNER,
424#endif
425 CAP_SYS_MODULE, CAP_LEASE
426 };
427 cap_value_t capvals_p[] =
428 {
429 CAP_CHOWN, CAP_LEASE, CAP_FSETID,
430 CAP_LINUX_IMMUTABLE, CAP_MKNOD, CAP_NET_ADMIN,
431 CAP_NET_BIND_SERVICE, CAP_NET_BROADCAST, CAP_NET_RAW,
432 CAP_SYS_ADMIN, CAP_SYS_BOOT, CAP_SYS_CHROOT,
433 CAP_SYS_PACCT, CAP_SYS_PTRACE, CAP_SYS_RAWIO,
434 CAP_SYS_RESOURCE, CAP_SYS_TIME, CAP_SYS_TTY_CONFIG,
435#if !defined(WITH_EXTERNAL) && !defined(HAVE_UNIX_RANDOM)
436 CAP_SETGID, CAP_SETUID, CAP_KILL,
437#endif
438#if !defined(SH_USE_SUIDCHK)
439 CAP_DAC_OVERRIDE, CAP_FOWNER,
440#endif
441#if !defined(WITH_MESSAGE_QUEUE)
442 CAP_IPC_OWNER,
443#endif
444 CAP_SYS_MODULE
445 };
446
447 if (0 == sl_useCaps) /* 0 = S_FALSE */
448 {
449 return 0;
450 }
451
452 if(NULL == (caps = cap_get_proc()))
453 {
454 return errno;
455 }
456
457 capflag = CAP_EFFECTIVE;
458 if (0 != cap_set_flag(caps, capflag, sizeof(capvals_e)/sizeof(cap_value_t),
459 capvals_e, capfval))
460 {
461 error = errno;
462 cap_free(caps);
463 return error;
464 }
465 if (0 != cap_set_proc(caps))
466 {
467 error = errno;
468 cap_free(caps);
469 return error;
470 }
471
472 capflag = CAP_PERMITTED;
473 if (0 != cap_set_flag(caps, capflag, sizeof(capvals_p)/sizeof(cap_value_t),
474 capvals_p, capfval))
475 {
476 error = errno;
477 cap_free(caps);
478 return error;
479 }
480 if (0 != cap_set_proc(caps))
481 {
482 error = errno;
483 cap_free(caps);
484 return error;
485 }
486 cap_free(caps);
487 return 0;
488}
489
490int sl_drop_cap_int(int what)
491{
492#if defined(SL_DEBUG)
493 char * captext;
494#endif
495 cap_flag_t capflag = CAP_EFFECTIVE;
496 cap_flag_value_t capfval = CAP_CLEAR;
497 cap_value_t capvals_a[] = { CAP_SETGID, CAP_SETUID, CAP_KILL };
498 cap_value_t capvals_b[] = { CAP_DAC_OVERRIDE, CAP_FOWNER };
499 cap_value_t * capvals;
500 int nvals;
501 int error = 0;
502 cap_t caps = cap_get_proc();
503
504 if (0 == sl_useCaps) /* 0 = S_FALSE */
505 {
506 return 0;
507 }
508
509 if (caps == NULL)
510 {
511 return errno;
512 }
513
514 switch (what) {
515 case 1:
516 capvals = capvals_a;
517 nvals = 3;
518 capfval = CAP_CLEAR;
519 break;
520 case 2:
521 capvals = capvals_a;
522 nvals = 3;
523 capfval = CAP_SET;
524 break;
525 case 3:
526 capvals = capvals_b;
527 nvals = 2;
528 capfval = CAP_CLEAR;
529 break;
530 case 4:
531 capvals = capvals_b;
532 nvals = 2;
533 capfval = CAP_SET;
534 break;
535 default:
536 return (0);
537 }
538
539 if (0 != cap_set_flag(caps, capflag, nvals, capvals, capfval))
540 {
541 error = errno;
542 cap_free(caps);
543 return error;
544 }
545 if (0 != cap_set_proc(caps))
546 {
547 error = errno;
548 cap_free(caps);
549 return error;
550 }
551#if defined(SL_DEBUG)
552 captext = cap_to_text(caps, NULL);
553 TPT(( 0, FIL__, __LINE__, _("msg=<cap_int %d: %s>\n"), what, captext));
554 cap_free(captext);
555#endif
556 cap_free(caps);
557 return 0;
558}
559
560int sl_drop_cap_sub() { return sl_drop_cap_int(1); }
561int sl_get_cap_sub() { return sl_drop_cap_int(2); }
562int sl_drop_cap_qdel() { return sl_drop_cap_int(3); }
563int sl_get_cap_qdel() { return sl_drop_cap_int(4); }
564
565#else
566int sl_drop_cap () { return 0; }
567int sl_drop_cap_sub() { return 0; }
568int sl_get_cap_sub() { return 0; }
569int sl_drop_cap_qdel() { return 0; }
570int sl_get_cap_qdel() { return 0; }
571#endif
572
573/* ----------------------------------------------------------------
574 *
575 * String handling routines
576 *
577 * ---------------------------------------------------------------- */
578
579/*
[76]580 * Have memset in a different translation unit (i.e. this) to prevent
581 * it to get optimized away
[1]582 */
583void *sl_memset(void *s, int c, size_t n)
584{
[76]585 return memset(s, c,n);
[1]586}
587
588
589#if !defined (VA_COPY)
590#if defined (__GNUC__) && defined (__PPC__) && (defined (_CALL_SYSV) || defined (_WIN32))
591#define VA_COPY(ap1, ap2) (*(ap1) = *(ap2))
592#elif defined (VA_COPY_AS_ARRAY)
593#define VA_COPY(ap1, ap2) memmove ((ap1), (ap2), sizeof (va_list))
594#else /* va_list is a pointer */
595#define VA_COPY(ap1, ap2) ((ap1) = (ap2))
596#endif
597#endif
598
599#if !defined(HAVE_VSNPRINTF) || defined(HAVE_BROKEN_VSNPRINTF)
600static
601size_t sl_printf_count (const char * fmt, va_list vl)
602{
603 size_t length = 1;
604 int fini = 0;
605 int islong = 0;
606 int islonglong = 0;
607 int islongdouble = 0;
608 char * string_arg;
609
610 SL_ENTER(_("sl_printf_count"));
611
612 if (fmt == NULL)
613 SL_IRETURN(SL_ENULL, _("sl_printf_count"));
614
615 while (*fmt) {
616
617 if ( (*fmt) == '%' ) { /* a format specifier */
618
619 fmt++; /* point to first char after '%' */
620
621 fini = 0;
622 islong = 0;
623 islongdouble = 0;
624
625 while (*fmt && (fini == 0) ) {
626
627 switch (*fmt) {
628
629 case '*': /* field width supplied by an integer */
630 length = length + va_arg (vl, int);
631 ++fmt;
632 break;
633 case '1':
634 case '2':
635 case '3':
636 case '4':
637 case '5':
638 case '6':
639 case '7':
640 case '8':
641 case '9':
642 length = length + strtol (fmt, (char**) &fmt, 10);
643 /* strtol makes FastForward to first invalid char */
644 break;
645
646 case 'l': /* 'long' modifier */
647 if (islong == 0)
648 islong = 1;
649 else
650 {
651 islonglong = 1;
652 islong = 0;
653 }
654 ++fmt;
655 break;
656
657 case 'L': /* 'long double' modifier */
658#ifdef HAVE_LONG_DOUBLE
659 islongdouble = 1;
660#else
661 islong = 1;
662#endif
663 ++fmt;
664 break;
665
666 case 'd':
667 case 'i':
668 case 'o':
669 case 'u':
670 case 'x':
671 case 'X':
672 if (islonglong == 1)
673#ifdef HAVE_LONG_LONG
674 (void) va_arg (vl, long long);
675#else
676 (void) va_arg (vl, long);
677#endif
678 else if (islong == 1)
679 (void) va_arg (vl, long);
680 else
681 (void) va_arg (vl, int);
682 islong = 0;
683 islonglong = 0;
684 length = length + 24;
685 ++fmt;
686 fini = 1;
687 break;
688
689 case 'D':
690 case 'O':
691 case 'U':
692 (void) va_arg (vl, long);
693 length = length + 24;
694 fmt++;
695 fini = 1;
696 break;
697
698 case 'e':
699 case 'E':
700 case 'f':
701 case 'g':
702#ifdef HAVE_LONG_DOUBLE
703 if (islongdouble == 1) {
704 (void) va_arg (vl, long double);
705 islongdouble = 0;
706 length = length + 20;
707 }
708 else
709#endif
710 (void) va_arg (vl, double);
711 length = length + 20;
712 fini = 1;
713 ++fmt;
714 break;
715
716 case 's':
717 string_arg = va_arg (vl, char *);
718 if (string_arg != NULL)
719 length = length + sl_strlen (string_arg);
720 else
721 length = length + 16;
722 fini = 1;
723 ++fmt;
724 break;
725
726 case 'c':
727 (void) va_arg (vl, int);
728 length = length + 1;
729 fini = 1;
730 ++fmt;
731 break;
732
733 case 'p':
734 case 'n':
735 (void) va_arg (vl, void * );
736 length = length + 32;
737 fini = 1;
738 ++fmt;
739 break;
740
741 case '%': /* %% will print '%' */
742 length = length + 1;
743 fini = 1;
744 ++fmt;
745 break;
746
747 default:
748 length = length + 1;
749 ++fmt;
750 break;
751
752 } /* end switch */
753 }
754 /* end parsing a single format specifier */
755 } else {
756 length = length + 1;
757 fmt++;
758 }
759 }
760 SL_IRETURN(length, _("sl_printf_count"));
761}
762#endif /* #ifndef HAVE_VSNPRINTF */
763
764/*
765 * An implementation of vsnprintf. va_start/va_end are in the caller
766 * function.
767 * Returns C99 (#bytes that would heve been written) on success.
768 */
769int sl_vsnprintf(char *str, size_t n,
770 const char *format, va_list vl )
771{
772 int len = 0;
773#if !defined(HAVE_VSNPRINTF) || defined(HAVE_BROKEN_VSNPRINTF)
774 size_t total;
775 va_list vl2;
776#endif
777
778 SL_ENTER(_("sl_vsnprintf"));
779 if (str == NULL || format == NULL)
780 SL_IRETURN(0, _("sl_vsnprintf"));
781
782#if defined(HAVE_VSNPRINTF) && !defined(HAVE_BROKEN_VSNPRINTF)
[22]783 len = vsnprintf (str, n, format, vl); /* flawfinder: ignore */
[1]784 str[n-1] = '\0';
785#else
[22]786 VA_COPY (vl2, vl); /* save the argument list */
[1]787 total = sl_printf_count (format, vl);
[22]788 len = (int) total;
[1]789 if (total < n)
790 {
[22]791 /* flawfinder: ignore */
[1]792 vsprintf (str, format, vl2); /* program has checked that it fits */
793 str[n-1] = '\0';
794 }
795 else
796 {
797 sl_strlcpy (str, format, n);
798 va_end(vl2);
799 SL_IRETURN(len, _("sl_vsnprintf"));
800 }
801 va_end(vl2);
802#endif
803 SL_IRETURN(len, _("sl_vsnprintf"));
804}
805
806/*
807 * An implementation of snprintf.
808 * Returns SL_ENONE on success.
809 * ENULL: src || format == NULL
810 * ERANGE: n out of range
[22]811 * ETRUNC: truncated (unimplemented)
[1]812 */
813int sl_snprintf(char *str, size_t n,
814 const char *format, ... )
815{
816 va_list vl;
817#if !defined(HAVE_VSNPRINTF) || defined(HAVE_BROKEN_VSNPRINTF)
818 size_t total = 0;
819 va_list vl2;
820#endif
821
822 SL_ENTER(_("sl_snprintf"));
823 if (str == NULL || format == NULL)
824 SL_IRETURN(SL_ENULL, _("sl_snprintf"));
825
826 va_start (vl, format);
827#if defined(HAVE_VSNPRINTF) && !defined(HAVE_BROKEN_VSNPRINTF)
[22]828 /* flawfinder: ignore */
[1]829 vsnprintf (str, n, format, vl);
830 str[n-1] = '\0';
831#else
832 VA_COPY (vl2, vl); /* save the argument list */
833 total = sl_printf_count (format, vl);
834 if (total < n)
835 {
[22]836 /* flawfinder: ignore */
[1]837 vsprintf (str, format, vl2); /* program has checked that it fits */
838 str[n-1] = '\0';
839 }
840 else
841 {
842 sl_strlcpy (str, format, n);
843 va_end(vl2);
844 va_end(vl);
845 SL_IRETURN(SL_ETRUNC, _("sl_snprintf"));
846 }
847 va_end(vl2);
848#endif
849 va_end(vl);
850 SL_IRETURN(SL_ENONE, _("sl_snprintf"));
851}
852
853/*
854 * Appends src to string dst of size siz (unlike strncat, siz is the
855 * full size of dst, not space left). At most siz-1 characters
856 * will be copied. Always NUL terminates (unless siz == 0).
857 * Returns SL_NONE on success, errcode on failure.
858 *
859 * ENULL: dst == NULL
860 * ERANGE: siz out of range
861 * ETRUNC: src truncated
862 */
863int sl_strlcat(char * dst, /*@null@*/const char *src, size_t siz)
864{
865 register size_t dst_end;
866 register size_t dst_free;
867
868 register char * p;
869 register const char * q;
870
[76]871 if (!(dst == NULL || src == NULL || *src == '\0'))
872 {
873 if (siz > 0)
874 {
[1]875
[76]876 /* How much free space do we have ?
877 */
878 dst_end = strlen(dst);
879 dst_free = siz - dst_end - 1;
880
881 p = &dst[dst_end];
882 q = src;
883
884 while (dst_free > 0 && *q != '\0')
885 {
886 *p++ = *q++;
887 --dst_free;
888 }
889
890 /* NULL terminate dst.
891 */
892 *p = '\0';
893
894 if (*q == '\0')
895 return SL_ENONE;
896 else
897 return SL_ETRUNC;
898 }
899 }
[1]900 return SL_ENONE;
901}
902
903/*
904 * An alternative implementation of the OpenBSD strlcpy() function.
905 *
906 * Copy src to string dst of size siz. At most siz-1 characters
907 * will be copied. Always NUL terminates (unless siz == 0).
908 * Returns SL_NONE on success, errcode on failure.
909 *
910 * ENULL: dst == NULL
911 * ERANGE: siz out of range
912 * ETRUNC: src truncated
913 */
914int sl_strlcpy(char * dst, /*@null@*/const char * src, size_t siz)
915{
916 /* SL_ENTER(_("sl_strlcpy")); */
917
[76]918 if (!((dst == NULL) || (src == NULL)))
919 {
920 if (siz > 0) {
921 /* copy siz-1 characters
922 */
923 (void) strncpy(dst, src, siz-1);
924
925 /* NULL terminate
926 */
927 dst[siz-1] = '\0';
928 }
929 return SL_ENONE;
930 }
931 else if (src == NULL)
932 {
[1]933 if (siz > 0)
934 dst[0] = '\0';
935 return SL_ENONE;
936 }
[76]937 else
938 {
939 return SL_ENULL;
940 }
[1]941}
942
943/*
944 * A robust drop-in replacement of strncpy. strlcpy is preferable.
945 */
946char * sl_strncpy(char *dst, const char *src, size_t size)
947{
948
949#ifdef SL_FAIL_ON_ERROR
950 SL_REQUIRE(dst != NULL, _("dst != NULL"));
951 SL_REQUIRE(src != NULL, _("src != NULL"));
952 SL_REQUIRE(size > 0, _("size > 0"));
953#endif
954
955 if (dst == NULL)
956 {
957 sl_errno = SL_ENULL;
958 return (NULL);
959 }
960 if (size < 1)
961 {
962 sl_errno = SL_ERANGE;
963 return (dst);
964 }
965 if (!src)
966 {
967 sl_errno = SL_ENULL;
968 dst[0] = '\0';
969 }
970 else if (src[0] == '\0')
971 dst[0] = '\0';
972 else
973 strncpy(dst, src, size);
974
975 if (sl_strlen(src) >= size)
976 {
977 errno = ENOSPC;
978 dst[size-1] = '\0';
979 }
980 return (dst);
981}
982
983/*
984 * A robust drop-in replacement of strncat. strlcat is preferable.
985 */
986char * sl_strncat(char *dst, const char *src, size_t n)
987{
988#ifdef SL_FAIL_ON_ERROR
989 SL_REQUIRE(dst != NULL, _("dst != NULL"));
990 SL_REQUIRE(src != NULL, _("src != NULL"));
991 SL_REQUIRE(n > 0, _("n > 0"));
992#endif
993
994 if (dst == NULL)
995 {
996 sl_errno = SL_ENULL;
997 return (NULL);
998 }
999 if (n < 1)
1000 {
1001 sl_errno = SL_ERANGE;
1002 return (dst);
1003 }
1004 if (!src)
1005 {
1006 sl_errno = SL_ENULL;
1007 return (dst);
1008 }
1009 else if (src[0] == '\0')
1010 dst[0] = '\0';
1011 else
1012 strncat(dst, src, n);
1013
1014 return (dst);
1015}
1016
[169]1017#include <ctype.h>
1018int sl_strcasecmp(const char * one, const char * two)
1019{
1020#ifdef SL_FAIL_ON_ERROR
1021 SL_REQUIRE (one != NULL, _("one != NULL"));
1022 SL_REQUIRE (two != NULL, _("two != NULL"));
1023#endif
[1]1024
[169]1025 if (one && two)
1026 {
1027 do {
1028 if (*one && *two)
1029 {
1030 if (tolower(*one) == tolower(*two))
1031 {
1032 ++one; ++two;
1033 }
1034 else if (tolower(*one) < tolower(*two))
1035 return -1;
1036 else
1037 return 1;
1038 }
1039 else if (*one == '\0' && *two == '\0')
1040 return 0;
1041 else if (*one == '\0')
1042 return -1;
1043 else
1044 return 1;
1045 } while (1 == 1);
1046 }
1047 else if (one == NULL && two != NULL)
1048 return -1;
1049 else if (one != NULL && two == NULL)
1050 return 1;
1051 else
1052 return -7; /* default to not equal */
1053}
1054
[1]1055int sl_strcmp(const char * a, const char * b)
1056{
1057#ifdef SL_FAIL_ON_ERROR
1058 SL_REQUIRE (a != NULL, _("a != NULL"));
1059 SL_REQUIRE (b != NULL, _("b != NULL"));
1060#endif
1061
1062 if (a != NULL && b != NULL)
1063 return (strcmp(a, b));
1064 else if (a == NULL && b != NULL)
1065 return (-1);
1066 else if (a != NULL && b == NULL)
1067 return (1);
1068 else
[169]1069 return (-7); /* default to not equal */
[1]1070}
1071
1072int sl_strncmp(const char * a, const char * b, size_t n)
1073{
1074#ifdef SL_FAIL_ON_ERROR
1075 SL_REQUIRE (a != NULL, _("a != NULL"));
1076 SL_REQUIRE (b != NULL, _("b != NULL"));
1077 SL_REQUIRE (n > 0, _("n > 0"));
1078#endif
1079
1080 if (a != NULL && b != NULL)
1081 return (strncmp(a, b, n));
1082 else if (a == NULL && b != NULL)
1083 return (-1);
1084 else if (a != NULL && b == NULL)
1085 return (1);
1086 else
[169]1087 return (-7); /* default to not equal */
[1]1088}
1089
1090/* string searching
1091 */
1092
[214]1093char * sl_strstr (const char * haystack, const char * needle)
[1]1094{
1095#ifndef HAVE_STRSTR
[203]1096 unsigned int i;
[1]1097 size_t needle_len;
1098 size_t haystack_len;
1099#endif
1100
1101 if (haystack == NULL || needle == NULL)
1102 return NULL;
1103 if (*needle == '\0' || *haystack == '\0')
1104 return NULL;
1105
1106#if defined(HAVE_STRSTR)
1107 return (strstr(haystack, needle));
1108#else
1109 needle_len = strlen(needle);
1110 haystack_len = strlen(haystack);
1111
1112 for (i = 0; i <= (haystack_len-needle_len); ++i)
1113 if (0 == sl_strncmp(&haystack[i], needle, needle_len))
1114 return (needle);
1115 return NULL;
1116#endif
1117}
1118
1119
1120/* ----------------------------------------------------------------
1121 *
1122 * Privilege handling routines
1123 *
1124 * ---------------------------------------------------------------- */
1125
1126
1127
1128static uid_t euid;
1129static uid_t ruid;
1130static uid_t ruid_orig;
1131static gid_t egid;
1132static gid_t rgid;
1133static gid_t rgid_orig;
1134
1135static int uids_are_stored = SL_FALSE;
1136static int suid_is_set = SL_TRUE;
1137
1138#ifdef HAVE_SETRESUID
1139extern int setresuid (uid_t truid, uid_t teuid, uid_t tsuid);
1140extern int setresgid (gid_t trgid, gid_t tegid, gid_t tsgid);
1141#endif
1142
1143
1144/*
1145 * This function returns true if the program is SUID.
1146 * It calls abort() if the uid's are not saved already.
1147 */
1148int sl_is_suid()
1149{
1150 if (uids_are_stored == SL_FALSE)
1151 {
1152 if (getuid() == geteuid() && getgid() == getegid())
1153 return (0); /* FALSE */
1154 else
1155 return (1); /* TRUE */
1156 }
1157 else
1158 {
1159 if (euid == ruid && egid == rgid)
1160 return (0); /* FALSE */
1161 else
1162 return (1); /* TRUE */
1163 }
1164}
1165
1166/*
1167 * This function returns the saved euid.
1168 * It calls abort() if the uid's are not saved already.
1169 */
1170int sl_get_euid(uid_t * ret)
1171{
1172 SL_ENTER(_("sl_get_euid"));
1173 /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
1174 if (uids_are_stored == SL_TRUE)
1175 *ret = euid;
1176 else
1177 *ret = geteuid();
1178 SL_IRETURN (SL_ENONE, _("sl_get_euid"));
1179}
1180
1181uid_t sl_ret_euid()
1182{
1183 /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
1184 if (uids_are_stored == SL_TRUE)
1185 return (euid);
1186 else
1187 return (geteuid());
1188}
1189
1190/*
1191 * This function returns the saved egid.
1192 * It calls abort() if the uid's are not saved already.
1193 */
1194int sl_get_egid(gid_t * ret)
1195{
1196 SL_ENTER(_("sl_get_egid"));
1197 /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
1198 if (uids_are_stored == SL_TRUE)
1199 *ret = egid;
1200 else
1201 *ret = getegid();
1202 SL_IRETURN (SL_ENONE, _("sl_get_egid"));
1203}
1204
1205/*
1206 * This function returns the saved ruid.
1207 * It calls abort() if the uid's are not saved already.
1208 */
1209int sl_get_ruid(uid_t * ret)
1210{
1211 SL_ENTER(_("sl_get_ruid"));
1212 /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
1213 if (uids_are_stored == SL_TRUE)
1214 *ret = ruid;
1215 else
1216 *ret = getuid();
1217 SL_IRETURN (SL_ENONE, _("sl_get_ruid"));
1218}
1219
1220/*
1221 * This function returns the saved rgid.
1222 * It calls abort() if the uid's are not saved already.
1223 */
1224int sl_get_rgid(gid_t * ret)
1225{
1226 SL_ENTER(_("sl_get_rgid"));
1227 /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
1228 if (uids_are_stored == SL_TRUE)
1229 *ret = rgid;
1230 else
1231 *ret = getgid();
1232 SL_IRETURN (SL_ENONE, _("sl_get_rgid"));
1233}
1234
1235/*
1236 * This function returns the saved original ruid.
1237 * It calls abort() if the uid's are not saved already.
1238 */
1239int sl_get_ruid_orig(uid_t * ret)
1240{
1241 SL_ENTER(_("sl_get_ruid_orig"));
1242 /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
1243 if (uids_are_stored == SL_TRUE)
1244 *ret = ruid_orig;
1245 else
1246 *ret = getuid();
1247 SL_IRETURN (SL_ENONE, _("sl_get_ruid_orig"));
1248}
1249
1250/*
1251 * This function returns the saved original rgid.
1252 * It calls abort() if the uid's are not saved already.
1253 */
1254int sl_get_rgid_orig(gid_t * ret)
1255{
1256 SL_ENTER(_("sl_get_rgid_orig"));
1257 /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
1258 if (uids_are_stored == SL_TRUE)
1259 *ret = rgid_orig;
1260 else
1261 *ret = getgid();
1262 SL_IRETURN (SL_ENONE, _("sl_get_rgid_orig"));
1263}
1264
1265static int suid_warn_flag = 1;
1266static void suid_warn(int a)
1267{
1268 fprintf(stderr, _("ERROR: open set/unset suid !!! %d\n"), a);
1269 return;
1270}
1271
1272/*
1273 * This function sets the effective uid
1274 * to the saved effective uid.
1275 * It will abort on failure.
1276 */
1277int sl_set_suid ()
1278{
1279 int retval;
1280
1281 SL_ENTER(_("sl_set_suid"));
1282
1283 if (uids_are_stored == SL_FALSE)
1284 {
1285 SL_IRETURN(SL_ENONE, _("sl_set_suid"));
1286 }
1287
1288 SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));
1289
1290 if (ruid == euid && rgid == egid)
1291 {
1292 suid_is_set = SL_TRUE;
1293 SL_IRETURN(SL_ENONE, _("sl_set_suid"));
1294 }
1295 SL_REQUIRE(suid_is_set == SL_FALSE, _("suid_is_set == SL_FALSE"));
1296
1297#if defined(HAVE_SETRESUID)
1298 retval = setresuid (sh_uid_neg, euid, sh_uid_neg);
1299 if (retval == 0)
1300 retval = setresgid (sh_gid_neg, egid, sh_gid_neg);
1301
1302#elif defined(HAVE_SETEUID)
1303 retval = seteuid (egid);
1304 if (retval == 0)
1305 retval = setegid (euid);
1306
1307 /* on AIX, setreuid does not behave well for non-root users.
1308 */
1309#elif defined(HAVE_SETREUID)
1310 retval = setreuid (ruid, euid);
1311 if (retval == 0)
1312 retval = setregid (rgid, egid);
1313
1314#else
1315 retval = setuid (euid);
1316 if (retval == 0)
1317 retval = setgid (egid);
1318#endif
1319 if (suid_warn_flag == 1)
1320 suid_warn(1);
1321 suid_warn_flag = 1;
1322
1323 SL_REQUIRE(retval == 0, _("retval == 0"));
1324 suid_is_set = SL_TRUE;
1325 SL_IRETURN(SL_ENONE, _("sl_set_suid"));
1326}
1327
1328/*
1329 * This function sets the effective uid to the real uid.
1330 * It will abort on failure.
1331 */
1332int sl_unset_suid ()
1333{
1334 register int retval;
1335
1336 SL_ENTER(_("sl_unset_suid"));
1337
1338 if (uids_are_stored == SL_FALSE)
1339 {
1340 SL_IRETURN(SL_ENONE, _("sl_unset_suid"));
1341 }
1342
1343 SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));
1344
1345 if (ruid == euid && rgid == egid)
1346 {
1347 suid_is_set = SL_FALSE;
1348 SL_IRETURN(SL_ENONE, _("sl_unset_suid"));
1349 }
1350 SL_REQUIRE(suid_is_set == SL_TRUE, _("suid_is_set == SL_TRUE"));
1351
1352#if defined(HAVE_SETRESUID)
1353 retval = setresgid (sh_gid_neg, rgid, sh_gid_neg);
1354 if (retval == 0)
1355 retval = setresuid (sh_uid_neg, ruid, sh_uid_neg);
1356
1357#elif defined(HAVE_SETEUID)
1358 retval = setegid (rgid);
1359 if (retval == 0)
1360 retval = seteuid (ruid);
1361
1362#elif defined(HAVE_SETREUID)
1363 retval = setregid (egid, rgid);
1364 if (retval == 0)
1365 retval = setreuid (euid, ruid);
1366
1367#else
1368 retval = setgid (rgid);
1369 if (retval == 0)
1370 retval = setuid (ruid);
1371#endif
1372
1373 if (suid_warn_flag == 0)
1374 suid_warn(0);
1375 suid_warn_flag = 0;
1376
1377 SL_REQUIRE(retval == 0, _("retval == 0"));
1378 suid_is_set = SL_FALSE;
1379 SL_IRETURN(SL_ENONE, _("sl_unset_suid"));
1380}
1381
1382
1383/*
1384 * This function saves the uid's.
1385 */
1386int sl_save_uids()
1387{
1388 SL_ENTER(_("sl_save_uids"));
1389 if (uids_are_stored == SL_TRUE)
1390 SL_IRETURN(SL_EREPEAT, _("sl_save_uids"));
1391
1392 ruid_orig = getuid();
1393 rgid_orig = getgid();
1394 egid = getegid();
1395 euid = geteuid();
1396 ruid = ruid_orig;
1397 rgid = rgid_orig;
1398 uids_are_stored = SL_TRUE;
1399
1400 SL_IRETURN(SL_ENONE, _("sl_save_uids"));
1401}
1402
1403/*
1404 * This function drops SUID privileges irrevocably.
1405 * It set the effective uid to the original real uid.
1406 */
1407extern int sh_unix_initgroups2 (uid_t in_pid, gid_t in_gid);
1408int sl_drop_privileges()
1409{
1410 SL_ENTER(_("sl_drop_privileges"));
1411 SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));
1412
1413 SL_REQUIRE(setgid(rgid_orig) == 0, _("setgid(rgid_orig) == 0"));
1414 SL_REQUIRE(sh_unix_initgroups2(ruid_orig, rgid_orig) == 0, _("sh_unix_initgroups2(ruid_orig,rgid_orig) == 0"));
1415 SL_REQUIRE(setuid(ruid_orig) == 0, _("setuid(ruid_orig) == 0"));
1416
1417 /* make sure that setuid(0) fails
1418 */
1419 SL_REQUIRE(setuid(0) < 0, _("setuid(0) < 0"));
1420
1421 euid = ruid_orig;
1422 egid = rgid_orig;
1423 ruid = ruid_orig;
1424 rgid = rgid_orig;
1425
1426 SL_IRETURN(SL_ENONE, _("sl_drop_privileges"));
1427}
1428
1429/*
1430 * Define a policy: Stay root.
1431 * Do nothing if not SUID.
1432 */
1433int sl_policy_get_root()
1434{
1435 SL_ENTER(_("sl_policy_get_root"));
1436 SL_REQUIRE(uids_are_stored == SL_FALSE, _("uids_are_stored == SL_FALSE"));
1437
1438 SL_REQUIRE (sl_save_uids() == SL_ENONE, _("sl_save_uids() == SL_ENONE"));
1439
1440 if (euid != ruid || egid != rgid)
1441 {
1442 SL_REQUIRE(setgid(egid) == 0, _("setgid(egid) == 0"));
1443 SL_REQUIRE(setuid(euid) == 0, _("setuid(euid) == 0"));
1444 SL_REQUIRE(ruid == getuid() && rgid == getgid(),
1445 _("ruid == getuid() && rgid == getgid()"));
1446 ruid = euid;
1447 rgid = egid;
1448 }
1449 suid_is_set = SL_TRUE;
1450 if (euid == 0)
1451 {
1452 SL_REQUIRE(sh_unix_initgroups2(euid, egid) == 0, _("sh_unix_initgroups2(euid,egid) == 0"));
1453 }
1454 SL_IRETURN(SL_ENONE, _("sl_policy_get_root"));
1455}
1456
1457#include <pwd.h>
1458
1459/*
1460 * Define a policy: Get real (irrevocably).
1461 * This function drops SUID privileges irrevocably.
1462 * Do nothing if not SUID (? not true - drops if root).
1463 */
1464
1465int sl_policy_get_real(char * user)
1466{
1467 SL_ENTER(_("sl_policy_get_real"));
1468 SL_REQUIRE(uids_are_stored == SL_FALSE, _("uids_are_stored == SL_FALSE"));
1469 SL_REQUIRE (sl_save_uids() == SL_ENONE, _("sl_save_uids() == SL_ENONE"));
1470
1471 if (euid == 0 || ruid == 0)
1472 {
[131]1473#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
1474 struct passwd pwd;
[227]1475 char * buffer;
[131]1476 struct passwd * tempres;
[227]1477 buffer = malloc(SH_PWBUF_SIZE);
1478 SL_REQUIRE (buffer != NULL, _("buffer != NULL"));
1479 sh_getpwnam_r(user, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
[131]1480#else
1481 struct passwd * tempres = sh_getpwnam(user);
1482#endif
[1]1483
1484 SL_REQUIRE (NULL != tempres, _("tempres != NULL"));
1485
1486 rgid_orig = tempres->pw_gid;
1487 ruid_orig = tempres->pw_uid;
[227]1488#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
1489 free(buffer);
1490#endif
[1]1491 }
1492 else
1493 {
1494 rgid_orig = rgid;
1495 ruid_orig = ruid;
1496 }
1497
1498 SL_REQUIRE (sl_drop_privileges() == SL_ENONE,
1499 _("sl_drop_privileges() == SL_ENONE"));
1500
1501 suid_is_set = SL_TRUE;
1502 SL_IRETURN(SL_ENONE, _("sl_policy_get_real"));
1503}
1504
1505
1506/*
1507 * Define a policy: Get user.
1508 * Drops privileges.
1509 * Do nothing if not SUID.
1510 */
[170]1511int sl_policy_get_user(const char * user)
[1]1512{
1513 SL_ENTER(_("sl_policy_get_user"));
1514
1515 SL_REQUIRE(user != NULL, _("user != NULL"));
1516 SL_REQUIRE(uids_are_stored == SL_FALSE, _("uids_are_stored == SL_FALSE"));
1517 SL_REQUIRE (sl_save_uids() == SL_ENONE, _("sl_save_uids() == SL_ENONE"));
1518
1519 if (euid != ruid || egid != rgid)
1520 {
[131]1521#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
1522 struct passwd pwd;
[227]1523 char * buffer;
[131]1524 struct passwd * tempres;
[227]1525 buffer = malloc(SH_PWBUF_SIZE);
1526 SL_REQUIRE (buffer != NULL, _("buffer != NULL"));
1527 sh_getpwnam_r(user, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
[131]1528#else
1529 struct passwd * tempres = sh_getpwnam(user);
1530#endif
[1]1531
1532 SL_REQUIRE (NULL != tempres, _("tempres != NULL"));
1533
1534 SL_REQUIRE (sl_drop_privileges() == SL_ENONE,
1535 _("sl_drop_privileges() == SL_ENONE"));
[227]1536#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
1537 free(buffer);
1538#endif
[1]1539 }
1540 SL_IRETURN(SL_ENONE, _("sl_policy_get_user"));
1541}
1542
1543
1544
1545/* ----------------------------------------------------------------
1546 *
1547 * File access routines
1548 *
1549 * ---------------------------------------------------------------- */
1550
1551#define TOFFSET 0x1234
1552
1553/* this would prevent opening files if the first 16 fds are open :( */
1554/* #define MAXFD FOPEN_MAX */
1555
1556#define MAXFD 1024
1557
1558typedef struct openfiles {
1559 SL_TICKET ticket; /* The unique ID. */
1560 int fd; /* The file descriptor. */
1561 char * path; /* The file path. */
[196]1562 int flush; /* Whether we want to flush the cache */
[167]1563 sh_string * content; /* The file content */
[1]1564} SL_OFILE;
1565
1566static SL_OFILE * ofiles[MAXFD];
1567
[144]1568SH_MUTEX_STATIC(mutex_ticket, PTHREAD_MUTEX_INITIALIZER);
[1]1569
1570static unsigned int nonce_counter = TOFFSET;
1571
1572static
1573SL_TICKET sl_create_ticket (unsigned int myindex)
1574{
1575 unsigned int high; /* index */
1576 unsigned int low; /* nonce */
[144]1577 SL_TICKET retval = SL_EINTERNAL;
[1]1578
1579 SL_ENTER(_("sl_create_ticket"));
1580
[144]1581 if (myindex >= MAXFD)
1582 goto out_ticket;
[1]1583
1584 /* mask out the high bit and check that it is not used
1585 * -> verify that it fits into 16 bits as positive
1586 */
1587 high = (myindex + TOFFSET) & 0x7fff;
1588
1589 if (high != myindex + TOFFSET)
[144]1590 goto out_ticket;
[1]1591
[144]1592 SH_MUTEX_LOCK_UNSAFE(mutex_ticket);
1593
[1]1594 low = nonce_counter & 0xffff;
1595
1596 /* Overflow -> nonce too big.
1597 */
1598 if ((low != nonce_counter++) || low == 0)
[144]1599 goto out_ticket;
[1]1600
1601 /* Wrap around the nonce counter.
1602 * This is a dirty trick.
1603 */
1604 if (nonce_counter > 0x7fff)
1605 nonce_counter = TOFFSET;
1606
[144]1607 retval = (SL_TICKET) ((high << 16) | low);
1608
1609 out_ticket:
1610 ;
1611
1612 SH_MUTEX_UNLOCK_UNSAFE(mutex_ticket);
1613 SL_RETURN (retval, _("sl_create_ticket"));
[1]1614}
1615
1616static
1617int sl_read_ticket (SL_TICKET fno)
1618{
1619 register unsigned myindex;
1620 register SL_OFILE *of;
1621
1622 myindex = ((fno >> 16) & 0xffff) - TOFFSET;
1623 if (myindex >= MAXFD)
1624 return (SL_ETICKET);
1625
1626 if (ofiles[myindex] == NULL)
1627 return (SL_ETICKET);
1628
1629 if (ofiles[myindex]->ticket != fno)
1630 return (SL_ETICKET);
1631
1632 if ((of = ofiles[myindex])->fd < 0 || of->fd >= MAXFD )
1633 return (SL_EINTERNAL);
1634
1635 if (((of->ticket) & 0xffff) == 0)
1636 return (SL_EINTERNAL);
1637
1638 return (myindex);
1639}
1640
[76]1641SL_TICKET sl_make_ticket (int fd, const char * filename)
[1]1642{
[22]1643 size_t len;
[1]1644 SL_TICKET ticket;
1645 SL_ENTER(_("sl_make_ticket"));
1646 /* Make entry.
1647 */
1648 if (fd >= MAXFD || fd < 0)
1649 {
1650 SL_IRETURN(SL_TOOMANY, _("sl_make_ticket"));
1651 }
1652
1653 if (ofiles[fd] != NULL)
1654 {
1655 SL_IRETURN(SL_EINTERNAL, _("sl_make_ticket"));
1656 }
1657
1658 if ( (ofiles[fd] = (SL_OFILE *) malloc(sizeof(SL_OFILE))) == NULL)
1659 {
1660 SL_IRETURN(SL_EMEM, _("sl_make_ticket"));
1661 }
1662
[22]1663 len = sl_strlen(filename)+1;
1664
1665 if ( (ofiles[fd]->path = (char *) malloc(len) ) == NULL)
[1]1666 {
1667 free(ofiles[fd]);
1668 ofiles[fd] = NULL;
1669 SL_IRETURN(SL_EMEM, _("sl_make_ticket"));
1670 }
1671
1672 /* Get a ticket.
1673 */
1674 ticket = sl_create_ticket((unsigned int)fd);
1675
1676 if (SL_ISERROR(ticket))
1677 {
1678 (void) free (ofiles[fd]->path);
1679 (void) free (ofiles[fd]);
1680 SL_IRETURN(ticket, _("sl_make_ticket"));
1681 }
1682
[22]1683 sl_strlcpy (ofiles[fd]->path, filename, len);
[167]1684 ofiles[fd]->ticket = ticket;
1685 ofiles[fd]->fd = fd;
1686 ofiles[fd]->content = NULL;
[196]1687 ofiles[fd]->flush = SL_FALSE;
[1]1688
1689 SL_IRETURN(ticket, _("sl_make_ticket"));
1690}
1691
1692#define SL_OPEN_MIN 113
1693#define SL_OPEN_FOR_READ 113
1694#define SL_OPEN_FOR_WRITE 114
1695#define SL_OPEN_FOR_RDWR 115
1696#define SL_OPEN_FOR_WTRUNC 116
1697#define SL_OPEN_FOR_RWTRUNC 117
1698#define SL_OPEN_SAFE_RDWR 118
1699#define SL_OPEN_FOR_FASTREAD 119
1700#define SL_OPEN_MAX 119
1701
1702#if !defined(O_NOATIME)
1703#if defined(__linux__) && (defined(__i386__) || defined(__PPC__))
1704#define O_NOATIME 01000000
1705#else
1706 /*
1707 * bitwise 'or' with zero does not modify any bit
1708 */
1709#define O_NOATIME 0
1710#endif
1711#endif
1712
1713static int o_noatime = O_NOATIME;
1714static mode_t open_mode = (S_IWUSR|S_IRUSR|S_IRGRP);
1715
1716
1717static
[20]1718int sl_open_file (const char *filename, int mode, int priv)
[1]1719{
1720 struct stat lbuf;
1721 struct stat buf;
[192]1722 int errval = 0;
[1]1723 int lstat_return;
1724 int stat_return;
1725 int fd;
1726 int sflags;
[22]1727 size_t len;
[1]1728 SL_TICKET ticket;
1729
1730#if !defined(O_NONBLOCK)
1731#if defined(O_NDELAY)
1732#define O_NONBLOCK O_NDELAY
1733#else
1734#define O_NONBLOCK 0
1735#endif
1736#endif
1737
1738 SL_ENTER(_("sl_open_file"));
1739
1740 if (filename == NULL)
1741 SL_IRETURN(SL_ENULL, _("sl_open_file"));
1742 if (mode < SL_OPEN_MIN || mode > SL_OPEN_MAX)
1743 SL_IRETURN(SL_EINTERNAL, _("sl_open_file"));
1744
1745 /* "This system call always succeeds and the previous value of
1746 * the mask is returned."
1747 */
1748 (void) umask (0);
1749
1750 if (mode == SL_OPEN_FOR_FASTREAD)
1751 {
1752 fd = aud_open_noatime (FIL__, __LINE__, priv, filename,
1753 O_RDONLY|O_NONBLOCK, 0, &o_noatime);
[8]1754 /*
[1]1755 if (fd >= 0) {
1756 sflags = retry_fcntl(FIL__, __LINE__, fd, F_GETFL, 0);
1757 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags & ~O_NONBLOCK);
1758 }
[8]1759 */
[1]1760 if (fd < 0)
1761 SL_IRETURN(SL_EBADFILE, _("sl_open_file"));
1762 goto createTicket;
1763 }
1764
1765#ifdef USE_SUID
1766 if (priv == SL_YESPRIV)
1767 sl_set_suid();
1768#endif
1769 if (mode == SL_OPEN_FOR_READ)
1770 lstat_return = retry_stat (FIL__, __LINE__, filename, &lbuf);
1771 else
1772 lstat_return = retry_lstat(FIL__, __LINE__, filename, &lbuf);
[192]1773 errval = errno;
[1]1774#ifdef USE_SUID
1775 if (priv == SL_YESPRIV)
1776 sl_unset_suid();
1777#endif
1778
1779 if (lstat_return == -1)
1780 {
1781 lstat_return = ENOENT;
1782 if ( (mode == SL_OPEN_FOR_READ && lstat_return == ENOENT) ||
[192]1783 (errval != ENOENT))
[1]1784 {
1785 TPT(( 0, FIL__, __LINE__, _("msg=<lstat: %s> errno=<%d>\n"),
[192]1786 filename, errval));
1787 errno = errval;
1788 SL_IRETURN(SL_ESTAT, _("sl_open_file"));
[1]1789 }
1790 }
1791
1792 if ( (mode != SL_OPEN_FOR_READ) && (lstat_return != ENOENT) &&
1793 ( S_ISDIR(lbuf.st_mode) || (S_IWOTH & lbuf.st_mode) )
1794 )
[192]1795 {
1796 int retval = S_ISDIR(lbuf.st_mode) ? SL_EISDIR : SL_EBADOTH;
1797 errno = 0;
1798 SL_IRETURN(retval, _("sl_open_file"));
1799 }
[1]1800
1801 /* O_NOATIME has an effect for read(). But write() ?.
1802 */
1803 switch (mode)
1804 {
1805 case SL_OPEN_FOR_READ:
1806 fd = aud_open_noatime (FIL__, __LINE__, priv, filename,
1807 O_RDONLY|O_NONBLOCK, 0, &o_noatime);
[192]1808 errval = errno;
[1]1809 if (fd >= 0) {
1810 sflags = retry_fcntl(FIL__, __LINE__, fd, F_GETFL, 0);
1811 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags & ~O_NONBLOCK);
1812 }
1813 break;
1814 case SL_OPEN_FOR_WRITE:
1815 if (lstat_return == ENOENT)
1816 fd = aud_open (FIL__, __LINE__, priv, filename,
1817 O_WRONLY|O_CREAT|O_EXCL, open_mode);
1818 else
1819 fd = aud_open (FIL__, __LINE__, priv, filename,
1820 O_WRONLY, open_mode);
[192]1821 errval = errno;
[1]1822 break;
1823 case SL_OPEN_SAFE_RDWR:
1824 if (lstat_return == ENOENT)
[192]1825 {
1826 fd = aud_open (FIL__, __LINE__, priv, filename,
1827 O_RDWR|O_CREAT|O_EXCL, open_mode);
1828 errval = errno;
1829 }
[1]1830 else
[192]1831 {
1832 errno = errval;
1833 SL_IRETURN(SL_EBADFILE, _("sl_open_file"));
1834 }
[1]1835 break;
1836 case SL_OPEN_FOR_RDWR:
1837 if (lstat_return == ENOENT)
[192]1838 fd = aud_open (FIL__, __LINE__, priv, filename,
1839 O_RDWR|O_CREAT|O_EXCL, open_mode);
[1]1840 else
1841 fd = aud_open (FIL__, __LINE__, priv, filename,
1842 O_RDWR, open_mode);
[192]1843 errval = errno;
[1]1844 break;
1845 case SL_OPEN_FOR_WTRUNC:
1846 if (lstat_return == ENOENT)
1847 fd = aud_open (FIL__, __LINE__, priv, filename,
1848 O_WRONLY|O_CREAT|O_EXCL, open_mode);
1849 else
1850 fd = aud_open (FIL__, __LINE__, priv, filename,
1851 O_WRONLY|O_TRUNC, open_mode);
[192]1852 errval = errno;
[1]1853 break;
1854 case SL_OPEN_FOR_RWTRUNC:
1855 if (lstat_return == ENOENT)
1856 fd = aud_open (FIL__, __LINE__, priv, filename,
1857 O_RDWR|O_CREAT|O_EXCL, open_mode);
1858 else
1859 fd = aud_open (FIL__, __LINE__, priv, filename,
1860 O_RDWR|O_TRUNC, open_mode);
[192]1861 errval = errno;
[1]1862 break;
1863 default:
[192]1864 errno = 0;
[1]1865 SL_IRETURN(SL_EINTERNAL, _("sl_open_file"));
1866 }
1867
1868 if (fd < 0)
1869 {
1870 TPT(( 0, FIL__, __LINE__, _("msg=<Error opening: %s> errno=<%d>\n"),
[192]1871 filename, errval));
1872 errno = errval;
[1]1873 SL_IRETURN(SL_EBADFILE, _("sl_open_file"));
1874 }
1875
1876#ifdef USE_SUID
1877 if (priv == SL_YESPRIV)
1878 sl_set_suid();
1879#endif
1880 stat_return = retry_fstat(FIL__, __LINE__, fd, &buf);
[192]1881 errval = errno;
[1]1882#ifdef USE_SUID
1883 if (priv == SL_YESPRIV)
1884 sl_unset_suid();
1885#endif
1886
1887 if (stat_return < 0)
1888 {
1889 close (fd);
[192]1890 errno = errval;
1891 SL_IRETURN(SL_EFSTAT, _("sl_open_file"));
[1]1892 }
1893
[192]1894 errno = 0;
1895
[1]1896 if (lstat_return != ENOENT && buf.st_ino != lbuf.st_ino)
1897 {
1898 close (fd);
1899 SL_IRETURN(SL_EBOGUS, _("sl_open_file"));
1900 }
1901
1902 createTicket:
1903
1904 /* Make entry.
1905 */
1906 if (fd >= MAXFD)
1907 {
1908 close(fd);
1909 SL_IRETURN(SL_TOOMANY, _("sl_open_file"));
1910 }
1911
1912 if (ofiles[fd] != NULL)
1913 {
1914 close(fd);
1915 SL_IRETURN(SL_EINTERNAL, _("sl_open_file"));
1916 }
1917
1918 if ( (ofiles[fd] = (SL_OFILE *) malloc(sizeof(SL_OFILE))) == NULL)
1919 {
1920 close(fd);
1921 SL_IRETURN(SL_EMEM, _("sl_open_file"));
1922 }
1923
[22]1924 len = sl_strlen(filename)+1;
1925
1926 if ( (ofiles[fd]->path = (char *) malloc(len) ) == NULL)
[1]1927 {
1928 free(ofiles[fd]);
1929 ofiles[fd] = NULL;
1930 close(fd);
1931 SL_IRETURN(SL_EMEM, _("sl_open_file"));
1932 }
1933
1934 /* Get a ticket.
1935 */
1936 ticket = sl_create_ticket(fd);
1937
1938 if (SL_ISERROR(ticket))
1939 {
1940 (void) free (ofiles[fd]->path);
1941 (void) free (ofiles[fd]);
1942 close(fd);
1943 SL_IRETURN(ticket, _("sl_open_file"));
1944 }
1945
[22]1946 sl_strlcpy (ofiles[fd]->path, filename, len);
[167]1947 ofiles[fd]->ticket = ticket;
1948 ofiles[fd]->fd = fd;
1949 ofiles[fd]->content = NULL;
[196]1950 ofiles[fd]->flush = SL_FALSE;
[1]1951
1952 SL_IRETURN(ticket, _("sl_open_file"));
1953}
1954
[196]1955int get_the_fd (SL_TICKET ticket)
1956{
1957 int fd;
1958
1959 if (SL_ISERROR(fd = sl_read_ticket(ticket)))
1960 return (fd);
1961
1962 if (ofiles[fd] == NULL || fd != ofiles[fd]->fd || fd < 0)
1963 return (SL_EINTERNAL);
1964 return (fd);
1965}
1966
[1]1967static
[20]1968int check_fname_priv (const char * fname, int priv)
[1]1969{
1970 SL_ENTER(_("check_fname_priv"));
1971 if (fname == NULL)
1972 SL_IRETURN(SL_ENULL, _("check_fname_priv"));
1973 if (priv != SL_YESPRIV && priv != SL_NOPRIV)
1974 SL_IRETURN(SL_EINTERNAL, _("check_fname_priv"));
1975 SL_IRETURN(SL_ENONE, _("check_fname_priv"));
1976}
1977
[20]1978SL_TICKET sl_open_write (const char * fname, int priv)
[1]1979{
1980 long status;
1981 SL_ENTER(_("sl_open_write"));
1982
1983 if (SL_ENONE != (status = check_fname_priv (fname, priv)))
1984 SL_IRETURN(status, _("sl_open_write"));
1985
1986 status = sl_open_file(fname, SL_OPEN_FOR_WRITE, priv);
1987 SL_IRETURN(status, _("sl_open_write"));
1988}
1989
[20]1990SL_TICKET sl_open_read (const char * fname, int priv)
[1]1991{
1992 long status;
1993 SL_ENTER(_("sl_open_read"));
1994
1995 if (SL_ENONE != (status = check_fname_priv (fname, priv)))
1996 {
1997 TPT(( 0, FIL__, __LINE__,
1998 _("msg=<Error in check_fname_priv.> status=<%ld>\n"),
1999 status));
2000 SL_IRETURN(status, _("sl_open_read"));
2001 }
2002
2003 status = sl_open_file(fname, SL_OPEN_FOR_READ, priv);
2004 SL_IRETURN(status, _("sl_open_read"));
2005}
2006
[196]2007#if defined(HAVE_POSIX_FADVISE) && defined(HAVE_MINCORE) && defined(POSIX_FADV_DONTNEED)
2008static int sl_check_mincore(int fd)
2009{
2010 /* Idea from Tobias Oetiker (http://insights.oetiker.ch/linux/fadvise.html)
2011 */
2012 struct stat fbuf;
2013 int retval = -1;
2014
2015 if (0 == fstat(fd, &fbuf))
2016 {
2017 void *f_map;
2018
2019 f_map = mmap((void *)0, fbuf.st_size, PROT_NONE, MAP_SHARED, fd, 0);
2020 if (MAP_FAILED != f_map)
2021 {
2022 extern int sh_unix_pagesize(void);
2023 size_t i;
2024 size_t page_size = sh_unix_pagesize();
2025 size_t vec_size = (fbuf.st_size+page_size-1)/page_size;
2026 unsigned char * vec = calloc(1, vec_size);
2027
2028 if (vec)
2029 {
2030 mincore(f_map, fbuf.st_size, vec);
[237]2031 /* imax = fbuf.st_size/page_size; */
[196]2032 for (i = 0; i <= vec_size; ++i)
2033 {
2034 if (vec[i]&1)
2035 {
2036 goto incore;
2037 }
2038 }
2039 retval = 0;
2040 incore:
2041 free(vec);
2042 }
2043 munmap(f_map, fbuf.st_size);
2044 }
2045 }
2046 return retval;
2047}
2048#endif
2049
2050static int sl_drop_cache = SL_FALSE;
2051
2052int sl_set_drop_cache(const char * str)
2053{
2054 extern int sh_util_flagval(const char * c, int * fval);
2055 return sh_util_flagval(str, &sl_drop_cache);
2056}
2057
[20]2058SL_TICKET sl_open_fastread (const char * fname, int priv)
[1]2059{
2060 long status;
2061 SL_ENTER(_("sl_open_fastread"));
2062
2063 if (SL_ENONE != (status = check_fname_priv (fname, priv)))
2064 SL_IRETURN(status, _("sl_open_read"));
2065
2066 status = sl_open_file(fname, SL_OPEN_FOR_FASTREAD, priv);
[196]2067
2068#if defined(HAVE_POSIX_FADVISE) && defined(HAVE_MINCORE) && defined(POSIX_FADV_DONTNEED)
2069
2070 if (SL_FALSE != sl_drop_cache && !SL_ISERROR(status))
2071 {
2072 int fd = get_the_fd(status);
2073 if (fd >= 0)
2074 {
2075 if (0 == sl_check_mincore(fd))
2076 ofiles[fd]->flush = SL_TRUE;
2077 }
2078 }
2079
2080#endif
2081
[1]2082 SL_IRETURN(status, _("sl_open_fastread"));
2083}
2084
[20]2085SL_TICKET sl_open_rdwr (const char * fname, int priv)
[1]2086{
2087 long status;
2088 SL_ENTER(_("sl_open_rdwr"));
2089
2090 if (SL_ENONE != (status = check_fname_priv (fname, priv)))
2091 SL_IRETURN(status, _("sl_open_rdwr"));
2092
2093 status = sl_open_file(fname, SL_OPEN_FOR_RDWR, priv);
2094 SL_IRETURN(status, _("sl_open_rdwr"));
2095}
2096
[20]2097SL_TICKET sl_open_safe_rdwr (const char * fname, int priv)
[1]2098{
2099 long status;
2100 SL_ENTER(_("sl_open_safe_rdwr"));
2101
2102 if (SL_ENONE != (status = check_fname_priv (fname, priv)))
2103 SL_IRETURN(status, _("sl_open_safe_rdwr"));
2104
2105 status = sl_open_file(fname, SL_OPEN_SAFE_RDWR, priv);
2106 SL_IRETURN(status, _("sl_open_safe_rdwr"));
2107}
2108
[20]2109SL_TICKET sl_open_write_trunc (const char * fname, int priv)
[1]2110{
2111 long status;
2112 SL_ENTER(_("sl_open_write_trunc"));
2113
2114 if (SL_ENONE != (status = check_fname_priv (fname, priv)))
2115 SL_IRETURN(status, _("sl_open_write_trunc"));
2116
2117 status = sl_open_file(fname, SL_OPEN_FOR_WTRUNC, priv);
2118 SL_IRETURN(status, _("sl_open_write_trunc"));
2119}
2120
[20]2121SL_TICKET sl_open_rdwr_trunc (const char * fname, int priv)
[1]2122{
2123 long status;
2124 SL_ENTER(_("sl_open_rdwr_trunc"));
2125
2126 if (SL_ENONE != (status = check_fname_priv (fname, priv)))
2127 SL_IRETURN(status, _("sl_open_rdwr_trunc"));
2128
2129 status = sl_open_file(fname, SL_OPEN_FOR_RWTRUNC, priv);
2130 SL_IRETURN(status, _("sl_open_rdwr_trunc"));
2131}
2132
2133
[167]2134int sl_init_content (SL_TICKET ticket, size_t size)
2135{
2136 int fd;
2137
2138 if (SL_ISERROR(fd = sl_read_ticket(ticket)))
2139 return (fd);
2140
2141 if (ofiles[fd] == NULL || fd != ofiles[fd]->fd || fd < 0)
2142 return (SL_EINTERNAL);
2143
2144 if (ofiles[fd]->content)
2145 sh_string_destroy(&(ofiles[fd]->content));
2146 ofiles[fd]->content = sh_string_new(size);
2147
2148 return SL_ENONE;
2149}
2150
2151sh_string * sl_get_content (SL_TICKET ticket)
2152{
2153 int fd;
2154
2155 if (SL_ISERROR(fd = sl_read_ticket(ticket)))
2156 return (NULL);
2157
2158 if (ofiles[fd] == NULL || fd != ofiles[fd]->fd || fd < 0)
2159 return (NULL);
2160
2161 return (ofiles[fd]->content);
2162}
2163
[212]2164int sl_lock (SL_TICKET ticket)
2165{
2166 int fd;
2167 struct flock lock;
2168 int retval;
2169
2170 SL_ENTER(_("sl_lock"));
2171
2172 if (SL_ISERROR(fd = get_the_fd (ticket)))
2173 SL_IRETURN(fd, _("sl_lock"));
2174
2175 lock.l_type = F_WRLCK;
2176 lock.l_whence = SEEK_SET;
2177 lock.l_start = 0;
2178 lock.l_len = 0;
2179
2180 /* F_SETLK returns if the lock cannot be obtained */
2181 do {
2182 retval = fcntl(fd, F_SETLK, &lock);
2183 } while (retval < 0 && errno == EINTR);
2184
2185 if (retval < 0 && errno == EBADF)
2186 SL_IRETURN(SL_ETICKET, _("sl_lock"));
2187 else if (retval < 0)
2188 SL_IRETURN(SL_EBADFILE, _("sl_lock"));
2189 else
2190 SL_IRETURN(SL_ENONE, _("sl_lock"));
2191 }
2192
[1]2193int sl_close (SL_TICKET ticket)
2194{
2195 register int fd;
2196
2197 SL_ENTER(_("sl_close"));
2198
2199 if (SL_ISERROR(fd = get_the_fd (ticket)))
2200 SL_IRETURN(fd, _("sl_close"));
2201
[196]2202#if defined(HAVE_POSIX_FADVISE) && defined(HAVE_MINCORE) && defined(POSIX_FADV_DONTNEED)
2203
2204 if (ofiles[fd]->flush == SL_TRUE)
2205 {
2206 posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
2207 }
2208
2209#endif
2210
[1]2211 /* This may fail, but what to do then ?
2212 */
2213 if (0 != close(fd) && ofiles[fd] != NULL)
2214 {
2215 TPT((0, FIL__, __LINE__,
[29]2216 _("msg=<Error closing file.>, path=<%s>, fd=<%d>, err=<%s>\n"),
2217 ofiles[fd]->path, fd, strerror(errno)));
[1]2218 }
2219
2220 if (ofiles[fd] != NULL)
2221 {
[167]2222 if (ofiles[fd]->content)
2223 sh_string_destroy(&(ofiles[fd]->content));
[1]2224 (void) free(ofiles[fd]->path);
2225 (void) free(ofiles[fd]);
2226 ofiles[fd] = NULL;
2227 }
2228
2229 SL_IRETURN(SL_ENONE, _("sl_close"));
2230}
2231
2232int sl_dropall(int fd, int except)
2233{
2234 while (fd < MAXFD)
2235 {
2236 if (ofiles[fd] != NULL && fd != except)
2237 {
[167]2238 if (ofiles[fd]->content)
2239 sh_string_destroy(&(ofiles[fd]->content));
[1]2240 if (ofiles[fd]->path != NULL)
2241 (void) free(ofiles[fd]->path);
2242 (void) free(ofiles[fd]);
2243 ofiles[fd] = NULL;
2244 }
2245 ++fd;
2246 }
2247 return 0;
2248}
2249
[174]2250int sl_dropall_dirty(int fd, int except)
2251{
2252 while (fd < MAXFD)
2253 {
2254 if (ofiles[fd] != NULL && fd != except)
2255 {
2256 ofiles[fd] = NULL;
2257 }
2258 ++fd;
2259 }
2260 return 0;
2261}
[1]2262
[174]2263
[1]2264int sl_unlink (SL_TICKET ticket)
2265{
2266 register int fd;
2267
2268 SL_ENTER(_("sl_unlink"));
2269
2270 if (SL_ISERROR(fd = get_the_fd(ticket)))
2271 SL_IRETURN(fd, _("sl_unlink"));
2272
2273 if (retry_aud_unlink(FIL__, __LINE__, ofiles[fd]->path) < 0)
2274 SL_IRETURN(SL_EUNLINK, _("sl_unlink"));
2275
2276 SL_IRETURN(SL_ENONE, _("sl_unlink"));
2277}
2278
2279
2280int sl_seek (SL_TICKET ticket, off_t off_data)
2281{
2282 register int fd;
2283
2284 SL_ENTER(_("sl_seek"));
2285
2286 if (SL_ISERROR(fd = get_the_fd(ticket)))
2287 SL_IRETURN(fd, _("sl_seek"));
2288
2289 if (lseek(fd, off_data, SEEK_SET) == (off_t)-1)
2290 SL_IRETURN(SL_EREWIND, _("sl_seek"));
2291
2292 SL_IRETURN(SL_ENONE, _("sl_seek"));
2293}
2294
2295int sl_rewind (SL_TICKET ticket)
2296{
2297 register int fd;
2298
2299 SL_ENTER(_("sl_rewind"));
2300
2301 if (SL_ISERROR(fd = get_the_fd(ticket)))
2302 SL_IRETURN(fd, _("sl_rewind"));
2303
2304 if (lseek (fd, 0L, SEEK_SET) == (off_t)-1)
2305 SL_IRETURN(SL_EREWIND, _("sl_rewind"));
2306
2307 SL_IRETURN(SL_ENONE, _("sl_rewind"));
2308}
2309
2310int sl_forward (SL_TICKET ticket)
2311{
2312 register int fd;
2313
2314 SL_ENTER(_("sl_forward"));
2315
2316 if (SL_ISERROR(fd = get_the_fd(ticket)))
2317 SL_IRETURN(fd, _("sl_forward"));
2318
2319 if (lseek (fd, 0L, SEEK_END) == (off_t)-1)
2320 SL_IRETURN(SL_EFORWARD, _("sl_forward"));
2321
2322 SL_IRETURN(SL_ENONE, _("sl_forward"));
2323}
2324
2325
2326int sl_sync (SL_TICKET ticket)
2327{
2328 register int fd;
2329
2330 SL_ENTER(_("sl_sync"));
2331
2332 if (SL_ISERROR(fd = get_the_fd(ticket)))
2333 SL_IRETURN(fd, _("sl_sync"));
2334
2335 if (fsync (fd) == -1)
2336 SL_IRETURN(SL_ESYNC, _("sl_sync"));
2337
2338 SL_IRETURN(SL_ENONE, _("sl_sync"));
2339}
2340
[8]2341int sl_read_timeout_prep (SL_TICKET ticket)
2342{
2343 int fd;
2344 int sflags;
[1]2345
[8]2346 SL_ENTER(_("sl_read_timeout_prep"));
2347
2348 if (SL_ISERROR(fd = get_the_fd(ticket)))
2349 {
2350 TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd));
2351 SL_IRETURN(fd, _("sl_read_timeout_prep"));
2352 }
2353
2354 /* set to non-blocking mode
2355 */
2356 sflags = retry_fcntl(FIL__, __LINE__, fd, F_GETFL, 0);
2357 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags | O_NONBLOCK);
2358
2359 SL_IRETURN(SL_ENONE, _("sl_read_timeout_prep"));
2360}
2361
[131]2362
2363int sl_read_timeout_fd (int fd, void * buf_in, size_t count,
2364 int timeout, int is_nonblocking)
[1]2365{
[137]2366 int sflags = 0;
[1]2367 fd_set readfds;
2368 struct timeval tv;
[8]2369 /* int sflags; */
[1]2370 int retval;
[192]2371 int error;
[1]2372
2373 int byteread = 0;
2374 int bytes = 0;
2375 char * buf;
2376
2377 time_t tnow;
2378 time_t tstart;
2379 time_t tdiff;
2380 extern volatile int sig_termfast;
2381
[131]2382 if (is_nonblocking == SL_FALSE)
[1]2383 {
[131]2384 /* set to non-blocking mode
2385 */
2386 sflags = retry_fcntl(FIL__, __LINE__, fd, F_GETFL, 0);
2387 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags | O_NONBLOCK);
[1]2388 }
2389
2390 buf = (char *) buf_in;
2391
2392 tstart = time(NULL);
2393 tdiff = 0;
2394
2395 while (count > 0)
2396 {
2397 FD_ZERO(&readfds);
2398 FD_SET(fd, &readfds);
2399
2400 tv.tv_sec = timeout - tdiff;
2401 tv.tv_usec = 0;
2402
2403 retval = select (fd+1, &readfds, NULL, NULL, &tv);
2404
2405 if (retval > 0)
2406 {
2407 byteread = read (fd, buf, count);
[8]2408
2409 if (byteread > 0)
[1]2410 {
2411 bytes += byteread; count -= byteread;
2412 buf += byteread;
2413 if (count == 0)
2414 break;
2415 }
2416 else if (byteread == 0)
2417 {
2418 break;
2419 }
2420 else
2421 {
2422 if (errno == EINTR || errno == EAGAIN)
2423 {
2424 retry_msleep(1, 0);
2425 tnow = time(NULL);
2426 tdiff = tnow - tstart;
2427 continue;
2428 }
2429 else
2430 {
[192]2431 error = errno;
[131]2432 if (is_nonblocking == SL_FALSE)
2433 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
[169]2434 TPT(( 0, FIL__, __LINE__, _("msg=<read error>")));
[192]2435 errno = error;
[1]2436 return (SL_EREAD);
2437 }
2438 }
2439 }
2440 else if ((retval == -1) && (errno == EINTR || errno == EAGAIN))
2441 {
2442 retry_msleep(1, 0);
2443 tnow = time(NULL);
2444 tdiff = tnow - tstart;
2445 continue;
2446 }
2447 else if (retval == 0)
2448 {
[131]2449 if (is_nonblocking == SL_FALSE)
2450 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
[169]2451 TPT(( 0, FIL__, __LINE__, _("msg=<timeout>")));
[192]2452 errno = 0;
[1]2453 return (SL_TIMEOUT);
2454 }
2455 else
2456 {
[192]2457 error = errno;
[131]2458 if (is_nonblocking == SL_FALSE)
2459 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
[169]2460 TPT(( 0, FIL__, __LINE__, _("msg=<timeout>")));
[192]2461 errno = error;
[1]2462 return (SL_EREAD);
2463 }
[8]2464
2465 if (sig_termfast == 1)
2466 {
[131]2467 if (is_nonblocking == SL_FALSE)
2468 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
[169]2469 TPT(( 0, FIL__, __LINE__, _("msg=<terminated>")));
[192]2470 errno = 0;
[8]2471 return (SL_EREAD);
2472 }
2473
[1]2474 tnow = time(NULL);
2475 tdiff = tnow - tstart;
[8]2476
2477 if (tdiff > timeout)
2478 {
[131]2479 if (is_nonblocking == SL_FALSE)
2480 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
[169]2481 TPT(( 0, FIL__, __LINE__, _("msg=<timeout>")));
[192]2482 errno = 0;
[8]2483 return (SL_TIMEOUT);
2484 }
[1]2485 }
2486
[131]2487 if (is_nonblocking == SL_FALSE)
2488 retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
[1]2489 return ((int) bytes);
2490}
2491
[131]2492int sl_read_timeout (SL_TICKET ticket, void * buf_in, size_t count,
2493 int timeout, int is_nonblocking)
2494{
[169]2495 int fd, retval;
[131]2496
[169]2497 SL_ENTER(_("sl_read_timeout"));
2498
[131]2499 if (buf_in == NULL || SL_ISERROR(fd = get_the_fd(ticket)))
2500 {
2501 if (buf_in == NULL)
2502 {
2503 TPT(( 0, FIL__, __LINE__, _("msg=<null buffer>")));
[169]2504 SL_IRETURN((SL_ENULL), _("sl_read_timeout"));
[131]2505 }
2506 if (SL_ISERROR(fd = get_the_fd(ticket)))
2507 {
2508 TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd));
[169]2509 SL_IRETURN((fd), _("sl_read_timeout"));
[131]2510 }
2511 }
[1]2512
[169]2513 retval = sl_read_timeout_fd (fd, buf_in, count, timeout, is_nonblocking);
2514 SL_IRETURN((retval), _("sl_read_timeout"));
[131]2515}
2516
2517
[1]2518int sl_read (SL_TICKET ticket, void * buf_in, size_t count)
2519{
2520 int fd;
2521 int byteread = 0;
2522 int bytes = 0;
2523
2524 char * buf;
2525
[169]2526 SL_ENTER(_("sl_read"));
2527
[1]2528 if (count < 1)
2529 {
2530 TPT(( 0, FIL__, __LINE__, _("msg=<range error>")));
[169]2531 SL_IRETURN((SL_ERANGE), _("sl_read"));
[1]2532 }
2533 if (buf_in == NULL)
2534 {
2535 TPT(( 0, FIL__, __LINE__, _("msg=<null buffer>")));
[169]2536 SL_IRETURN((SL_ENULL), _("sl_read"));
[1]2537 }
2538
2539 if (SL_ISERROR(fd = get_the_fd(ticket)))
2540 {
2541 TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd));
[169]2542 SL_IRETURN((fd), _("sl_read"));
[1]2543 }
2544
2545 buf = (char *) buf_in;
2546
2547 do
2548 {
2549 byteread = read (fd, buf, count);
2550 if (byteread > 0)
2551 {
2552 bytes += byteread; count -= byteread;
2553 buf += byteread;
2554 }
2555 } while ( byteread > 0 ||
[5]2556 ( byteread == -1 && (errno == EINTR || errno == EAGAIN))
[1]2557 );
2558
2559
2560 if (byteread == (-1))
2561 {
2562 TPT(( 0, FIL__, __LINE__, _("msg=<read error> errno=<%d>\n"), errno));
[169]2563 SL_IRETURN((SL_EREAD), _("sl_read"));
[1]2564 }
[169]2565 SL_IRETURN((bytes), _("sl_read"));
[1]2566}
2567
2568int sl_read_fast (SL_TICKET ticket, void * buf_in, size_t count)
2569{
2570 int fd;
2571 int byteread = 0;
2572
2573 char * buf;
2574
[169]2575 SL_ENTER(_("sl_read_fast"));
2576
[1]2577 if (count < 1)
2578 {
2579 TPT(( 0, FIL__, __LINE__, _("msg=<range error>")));
[169]2580 SL_IRETURN((SL_ERANGE), _("sl_read_fast"));
[1]2581 }
2582 if (buf_in == NULL)
2583 {
2584 TPT(( 0, FIL__, __LINE__, _("msg=<null buffer>")));
[169]2585 SL_IRETURN((SL_ENULL), _("sl_read_fast"));
[1]2586 }
2587
2588 if (SL_ISERROR(fd = get_the_fd(ticket)))
2589 {
2590 TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd));
[169]2591 SL_IRETURN((fd), _("sl_read_fast"));
[1]2592 }
2593
2594 buf = (char *) buf_in;
2595
2596 do
2597 {
2598 byteread = read (fd, buf, count);
2599 if (byteread >= 0)
2600 {
[169]2601 SL_IRETURN((byteread), _("sl_read_fast"));
[1]2602 }
[5]2603 } while ( byteread == -1 && (errno == EINTR || errno == EAGAIN));
[1]2604
2605
2606 if (byteread == (-1))
2607 {
2608 TPT(( 0, FIL__, __LINE__, _("msg=<read error> errno=<%d>\n"), errno));
[169]2609 SL_IRETURN((SL_EREAD), _("sl_read_fast"));
[1]2610 }
[169]2611 SL_IRETURN((0), _("sl_read_fast"));
[1]2612}
2613
2614
[170]2615int sl_write (SL_TICKET ticket, const void * msg_in, long nbytes)
[1]2616{
2617 long bytewritten;
2618 long bytecount;
2619 int fd;
2620
[170]2621 const char * msg;
[1]2622
2623 SL_ENTER(_("sl_write"));
2624
2625 if (nbytes < 1)
2626 SL_IRETURN(SL_ERANGE, _("sl_write"));
2627 if (msg_in == NULL)
2628 SL_IRETURN(SL_ENULL, _("sl_write"));
2629 if (SL_ISERROR(fd = get_the_fd(ticket)))
2630 SL_IRETURN(fd, _("sl_write"));
2631
[170]2632 msg = (const char *) msg_in;
[1]2633
2634 /* write
2635 */
2636 bytecount = 0;
2637 bytewritten = 0;
2638 while (bytecount < nbytes)
2639 {
2640 if ((bytewritten = write (fd, msg, nbytes-bytecount)) > 0)
2641 {
2642 bytecount += bytewritten;
2643 msg += bytewritten; /* move buffer pointer forward */
2644 }
2645 else if (bytewritten <= 0)
2646 {
2647 if ( errno == EINTR || errno == EAGAIN) /* try again */
2648 continue;
2649 else
2650 SL_IRETURN(SL_EWRITE, _("sl_write"));
2651 }
2652 }
2653 SL_IRETURN(SL_ENONE, _("sl_write"));
2654}
2655
[170]2656int sl_write_line (SL_TICKET ticket, const void * msg, long nbytes)
[1]2657{
2658 int status;
2659
2660 SL_ENTER(_("sl_write_line"));
2661
2662 status = sl_write(ticket, msg, nbytes);
2663 if (!SL_ISERROR(status))
2664 status = sl_write(ticket, "\n", 1);
2665
2666 SL_IRETURN(status, _("sl_write_line"));
2667}
2668
[76]2669int sl_write_line_fast (SL_TICKET ticket, void * msg, long nbytes)
2670{
2671 int status;
2672 char * p = (char *) msg;
[1]2673
[76]2674 SL_ENTER(_("sl_write_line_fast"));
2675
2676 /* Here nbytes is strlen(msg), so p[nbytes] is the terminating '\0'
2677 * Overwrite the terminator, write out, then write back the terminator.
2678 */
2679 p[nbytes] = '\n';
2680 status = sl_write(ticket, msg, nbytes+1);
2681 p[nbytes] = '\0';
2682
2683 SL_IRETURN(status, _("sl_write_line_fast"));
2684}
2685
2686
[1]2687/* ----------------------------------------------------------------
2688 *
2689 * Trustfile interface
2690 *
2691 * ---------------------------------------------------------------- */
2692
2693extern uid_t rootonly[];
2694extern int EUIDSLOT;
2695extern int ORIG_EUIDSLOT;
2696
2697extern char tf_path[MAXFILENAME]; /* Error path for trust function. */
2698extern uid_t tf_euid; /* Space for EUID of process. */
2699
2700char * sl_error_string(int errorcode)
2701{
[192]2702
[1]2703 switch (errorcode)
2704 {
2705 case SL_EBOGUS:
[214]2706 return _("Bogus file, modified during access");
[1]2707 case SL_EWRITE:
[200]2708 return _("Write error");
[1]2709 case SL_EREAD:
[200]2710 return _("Read error");
[1]2711 case SL_ESYNC:
[200]2712 return _("Error in fsync()");
[1]2713 case SL_EFORWARD:
[200]2714 return _("Error in lseek()");
[1]2715 case SL_EREWIND:
[200]2716 return _("Error in lseek()");
[1]2717 case SL_EUNLINK:
[200]2718 return _("Error in unlink()");
[1]2719 case SL_EMEM:
[200]2720 return _("Out of memory");
[1]2721 case SL_EINTERNAL:
[200]2722 return _("Internal error");
[1]2723 case SL_ETICKET:
[200]2724 return _("Bad ticket");
[1]2725 case SL_EREPEAT:
[200]2726 return _("Illegal repeated use of function");
[1]2727 case SL_ERANGE:
[200]2728 return _("Argument out of range");
[1]2729 case SL_ENULL:
[200]2730 return _("Dereferenced NULL pointer");
[1]2731
2732 case SL_EBADUID:
[200]2733 return _("Owner not trustworthy");
[1]2734 case SL_EBADGID:
[200]2735 return _("Group writeable and member not trustworthy");
[1]2736 case SL_EBADOTH:
[200]2737 return _("World writeable");
[192]2738 case SL_EISDIR:
[200]2739 return _("Is a directory");
[1]2740 case SL_EBADFILE:
[200]2741 return _("File access error");
[1]2742 case SL_EBADNAME:
[200]2743 return _("Invalid filename (prob. too long or null)");
[1]2744
2745 case SL_ETRUNC:
[200]2746 return _("Truncation occured");
[1]2747 case SL_ESTAT:
[200]2748 return _("stat() failed");
[192]2749 case SL_EFSTAT:
[200]2750 return _("fstat() failed");
[1]2751 default:
[200]2752 return _("Unknown error");
[1]2753 }
2754}
2755
2756
2757
[170]2758char * sl_trust_errfile(void)
[1]2759{
2760 return &tf_path[0];
2761}
2762
2763extern uid_t tf_baduid;
[170]2764uid_t sl_trust_baduid(void)
[1]2765{
2766 return tf_baduid;
2767}
2768
2769extern gid_t tf_badgid;
[170]2770gid_t sl_trust_badgid(void)
[1]2771{
2772 return tf_badgid;
2773}
2774
2775
2776static int trust_count = 0;
2777
[170]2778int sl_trust_purge_user (void)
[1]2779{
2780 int i;
2781
2782 EUIDSLOT = ORIG_EUIDSLOT;
2783 trust_count = 0;
2784
2785 for (i = EUIDSLOT; i < (EUIDSLOT + 15); ++i)
2786 rootonly[i] = sh_uid_neg;
2787 return 0;
2788}
2789
2790int sl_trust_add_user (uid_t pwid)
2791{
2792 SL_ENTER(_("sl_trust_add_user"));
2793
2794 if (trust_count == 15)
2795 SL_IRETURN(SL_ERANGE, _("sl_trust_add_user"));
2796
2797 rootonly[EUIDSLOT] = pwid;
2798 ++EUIDSLOT;
2799 ++trust_count;
2800
2801 SL_IRETURN(SL_ENONE, _("sl_trust_add_user"));
2802}
2803
[76]2804#include "sh_mem.h"
2805extern char * sh_util_strdup (const char * str);
2806
2807struct sl_trustfile_store {
2808 char * filename;
2809 uid_t teuid;
2810 struct sl_trustfile_store * next;
2811};
2812
2813static struct sl_trustfile_store * sl_trusted_files = NULL;
2814
[183]2815static void sl_add_trusted_file(const char * filename, uid_t teuid)
[76]2816{
2817 struct sl_trustfile_store *new = SH_ALLOC(sizeof(struct sl_trustfile_store));
2818
2819 new->filename = sh_util_strdup (filename);
2820 new->teuid = teuid;
2821 new->next = sl_trusted_files;
2822
2823 sl_trusted_files = new;
2824 return;
2825}
2826
[183]2827static const char * sl_check_trusted_file(const char * filename, uid_t teuid)
[76]2828{
2829 struct sl_trustfile_store *new = sl_trusted_files;
2830
2831 while (new)
2832 {
2833 if ((new->teuid == teuid) && (0 == strcmp(new->filename, filename)))
2834 return filename;
2835 new = new->next;
2836 }
2837
2838 return NULL;
2839}
2840
[183]2841static void sl_clear_trusted_file(struct sl_trustfile_store * file)
[76]2842{
2843 if (file)
2844 {
2845 if (file->next != NULL)
2846 sl_clear_trusted_file(file->next);
2847 SH_FREE(file->filename);
2848 SH_FREE(file);
2849 }
2850 return;
2851}
2852
[183]2853int sl_trustfile_euid(const char * filename, uid_t teuid)
[1]2854{
[76]2855 long status;
2856 static time_t old = 0;
2857 static time_t now;
2858
[1]2859 SL_ENTER(_("sl_trustfile_euid"));
2860
2861 tf_path[0] = '\0';
2862 if (filename == NULL || filename[0] == '\0')
2863 SL_IRETURN(SL_EBADNAME, _("sl_trustfile_euid"));
2864
[76]2865 now = time(NULL);
2866 if (now < (old + 300))
2867 {
2868 if (NULL != sl_check_trusted_file(filename, teuid))
2869 {
2870 sl_strlcpy(tf_path, filename, sizeof(tf_path));
2871 SL_IRETURN(SL_ENONE, _("sl_trustfile_euid"));
2872 }
2873 }
2874 else
2875 {
2876 sl_clear_trusted_file(sl_trusted_files);
2877 sl_trusted_files = NULL;
2878 old = now;
2879 }
2880
[1]2881 tf_euid = teuid;
2882 status = sl_trustfile(filename, NULL, NULL);
[76]2883 if (status == SL_ENONE)
2884 sl_add_trusted_file(filename, teuid);
[1]2885 SL_IRETURN(status, _("sl_trustfile_euid"));
2886}
2887
[20]2888/* ----------------------------------------------------------------
2889 *
2890 * Overflow tests
2891 *
2892 * ---------------------------------------------------------------- */
[1]2893
[34]2894#ifndef SIZE_MAX
2895#define SIZE_MAX (4294967295U)
2896#endif
2897
[20]2898int sl_ok_muli (int a, int b) /* a*b */
2899{
[34]2900 if ((b == 0) || (a >= (INT_MIN / b) && a <= (INT_MAX / b)))
[20]2901 return SL_TRUE; /* no overflow */
2902 return SL_FALSE;
2903}
2904
[34]2905int sl_ok_muls (size_t a, size_t b) /* a*b */
2906{
2907 if ((b == 0) || (a <= (SIZE_MAX / b)))
2908 return SL_TRUE; /* no overflow */
2909 return SL_FALSE;
2910}
2911
[20]2912int sl_ok_divi (int a, int b) /* a/b */
2913{
2914 (void) a;
2915 if (b != 0)
2916 return SL_TRUE; /* no overflow */
2917 return SL_FALSE;
2918}
2919
2920int sl_ok_addi (int a, int b) /* a+b */
2921{
2922 if (a >= 0 && b >= 0)
2923 {
2924 if (a <= (INT_MAX - b))
2925 return SL_TRUE; /* no overflow */
2926 else
2927 return SL_FALSE;
2928 }
2929 else if (a < 0 && b < 0)
2930 {
2931 if (a >= (INT_MIN - b))
2932 return SL_TRUE; /* no overflow */
2933 else
2934 return SL_FALSE;
2935 }
2936 return SL_TRUE;
2937}
2938
[34]2939int sl_ok_adds (size_t a, size_t b) /* a+b */
2940{
2941 if (a <= (SIZE_MAX - b))
2942 return SL_TRUE; /* no overflow */
2943 else
2944 return SL_FALSE;
2945}
2946
[20]2947int sl_ok_subi (int a, int b) /* a-b */
2948{
2949 if (a >= 0 && b < 0)
2950 {
2951 if (a <= (INT_MAX + b))
2952 return SL_TRUE; /* no overflow */
2953 else
2954 return SL_FALSE;
2955 }
2956 else if (a < 0 && b >= 0)
2957 {
2958 if (a >= (INT_MIN + b))
2959 return SL_TRUE; /* no overflow */
2960 else
2961 return SL_FALSE;
2962 }
2963 return SL_TRUE;
2964}
Note: See TracBrowser for help on using the repository browser.