source: trunk/include/slib.h@ 121

Last change on this file since 121 was 76, checked in by rainer, 18 years ago

Fix for ticket #38 (csv escaping) and #39 (building on cygwin). Also optimize a bit.
File size: 13.7 KB
RevLine 
[1]1/* --------------------------------------------------------------
2 *
3 * The developement of this library has been stimulated by reading
4 * a paper on 'Robust Programming' by Matt Bishop, although
5 * not all of his ideas might be implemented in the same
6 * strictness as discussed in the paper.
7 *
8 * --------------------------------------------------------------
9 */
10
11#ifndef SL_SLIB_H
12#define SL_SLIB_H
13
14#include <errno.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <stdarg.h>
18#include <sys/types.h>
19
20#include "config_xor.h"
21
22#ifdef HAVE_UNISTD_H
23#include <unistd.h>
24#endif
25
26/****************
27
28 -- Defined in config.h. --
29
30 #ifndef _(string)
31 #define _(string) string
32 #endif
33
34 #ifndef N_(string)
35 #define N_(string) string
36 #endif
37
38*****************/
39
40/* --------------------------------------------------------------
41 *
42 * Typedefs, global variables, macros.
43 *
44 * --------------------------------------------------------------
45 */
46
47extern long int sl_errno; /* Global error variable. */
48
49
50/* The ticketing system; used to hide internals from the
51 * programmer.
52 */
53typedef long int SL_TICKET; /* Unique ID for opened files. */
54
55
56/*
57 * TRUE, FALSE
58 */
59#define SL_TRUE 1
60#define SL_FALSE 0
61
62
63
64/*
65 * The following macros are provided:
66 *
67 * SL_ISERROR(x) TRUE if return status of 'x' is an error code.
68 * SL_REQUIRE(x, xstr) Abort if 'x' is false.
69 * SL_ENTER(s) Trace entry in function 's'.
70 * SL_RETURN(x, s) Trace return from function 's'.
71 */
72
73
74/*
75 * The error codes.
76 */
77#define SL_ENONE 0
78
79#define SL_ENULL -1024 /* Invalid use of NULL pointer. */
80#define SL_ERANGE -1025 /* Argument out of range. */
81#define SL_ETRUNC -1026 /* Result truncated. */
82#define SL_EREPEAT -1027 /* Illegal repeated use of function. */
83
84#define SL_EINTERNAL -1028 /* Internal error. */
85#define SL_ETICKET -1029 /* Bad ticket. */
86#define SL_EBADFILE -1030 /* File access error. Check errno. */
87#define SL_EBOGUS -1031 /* Bogus file. */
88#define SL_EMEM -1032 /* Out of memory. */
89#define SL_EUNLINK -1033 /* Unlink error. Check errno. */
90#define SL_EREWIND -1034 /* Rewind error. Check errno. */
91#define SL_EFORWARD -1035 /* Forward error. Check errno. */
92#define SL_EREAD -1036 /* Read error. Check errno. */
93#define SL_EWRITE -1037 /* Write error. Check errno. */
94#define SL_ESYNC -1038 /* Write error. Check errno. */
95
96#define SL_EBADNAME -1040 /* Invalid name. */
97#define SL_ESTAT -1041 /* stat of file failed. Check errno. */
98
99#define SL_EBADUID -1050 /* Owner not trustworthy. */
100#define SL_EBADGID -1051 /* Group writeable and not trustworthy.*/
101#define SL_EBADOTH -1052 /* World writeable. */
102
103#define SL_TOOMANY -1053 /* Too many open files */
104#define SL_TIMEOUT -1054 /* Timeout in read */
105/*
106 * All int functions return SL_NONE on success.
107 */
108
109#ifdef __cplusplus
110extern "C" {
111#endif
112
113 int dlog (int flag, char * file, int line, const char *fmt, ...);
114
115 char * sl_get_errmsg();
116
117 /* ----------------------------------------------------------------
118 *
119 * Heap consistency routines
120 *
121 * ---------------------------------------------------------------- */
122
123 int sl_test_heap();
124
125 /* ----------------------------------------------------------------
126 *
127 * Capability routines
128 *
129 * ---------------------------------------------------------------- */
130
131 extern int sl_useCaps;
132
133 int sl_drop_cap ();
134 int sl_drop_cap_sub();
135 int sl_get_cap_sub();
136 int sl_drop_cap_qdel();
137 int sl_get_cap_qdel();
138
139 /* ----------------------------------------------------------------
140 *
141 * String handling routines
142 *
143 * ---------------------------------------------------------------- */
144
145 /*
146 * A memset that does not get optimized away
147 */
148 void *sl_memset(void *s, int c, size_t n);
[11]149#if !defined(SH_REAL_SET)
[1]150#undef memset
151#define memset sl_memset
[11]152#endif
[1]153
154 /*
155 * Copy src to dst. siz is the length of dst.
156 */
157 int sl_strlcpy(char * dst, /*@null@*/const char * src, size_t siz);
158
159 /*
160 * Append src to dst. siz is the length of dst.
161 */
162 int sl_strlcat(char * dst, /*@null@*/const char *src, size_t siz);
163
164 /*
165 * An implementation of vsnprintf. va_start/va_end are in the caller
166 * function.
167 */
168 int sl_vsnprintf(char *str, size_t n,
169 const char *format, va_list vl );
170
171 /*
172 * An implementation of snprintf.
173 */
174 int sl_snprintf(char *str, size_t n,
175 const char *format, ... );
176
177 /*
178 * A robust drop-in replacement of strncpy. strlcpy is preferable.
179 */
180 char * sl_strncpy(/*@out@*/char *dst, const char *src, size_t size);
181
182 /*
183 * Robust strncat.
184 */
185 char * sl_strncat(char *dst, const char *src, size_t n);
186
187 /*
188 * strstr
189 */
190 char * sl_strstr (const char * haystack, const char * needle);
191
192 /*
193 * robust strncmp replacement
194 */
195 int sl_strncmp(const char * a, const char * b, size_t n);
196
197 /*
198 * robust strcmp replacement
199 */
200 int sl_strcmp(const char * a, const char * b);
201
202 /*
203 * robust strlen replacement
204 */
205#define sl_strlen(arg) ((arg == NULL) ? 0 : (strlen(arg)))
206
207 /* ----------------------------------------------------------------
208 *
209 * Privilege handling routines
210 *
211 * ---------------------------------------------------------------- */
212
213 /*
214 * ONE OF THE FOLLOWING THREE FUNCTIONS
215 * SHOULD BE CALLED BEFORE ANY OTHER OF THE
216 * UID HANDLING FUNCTIONS.
217 */
218 int sl_policy_get_user(char *username); /* drop SUID to <username> */
219 int sl_policy_get_real(char *username); /* drop privs to <username> */
220 int sl_policy_get_root(void); /* drop SUID to root */
221
222 /*
223 * If not using one of the above, use this function,
224 * and then call sh_unset_suid().
225 * This function saves the uid's.
226 * It calls abort() on error.
227 */
228 int sl_save_uids(void);
229
230 /*
231 * This function returns the saved euid.
232 * It calls abort() if the uid's are not saved already.
233 */
234 int sl_get_euid(/*@out@*/uid_t * ret);
235 uid_t sl_ret_euid();
236
237 /*
238 * This function returns the saved egid.
239 * It calls abort() if the uid's are not saved already.
240 */
241 int sl_get_egid(/*@out@*/gid_t * ret);
242
243 /*
244 * This function returns the saved current ruid.
245 * It calls abort() if the uid's are not saved already.
246 */
247 int sl_get_ruid(/*@out@*/uid_t * ret);
248
249 /*
250 * This function returns the saved current rgid.
251 * It calls abort() if the uid's are not saved already.
252 */
253 int sl_get_rgid(gid_t * ret);
254
255 /*
256 * This function returns the saved original ruid.
257 * It calls abort() if the uid's are not saved already.
258 */
259 int sl_get_ruid_orig(uid_t * ret);
260
261 /*
262 * This function returns the saved original rgid.
263 * It calls abort() if the uid's are not saved already.
264 */
265 int sl_get_rgid_orig(gid_t * ret);
266
267 /*
268 * This function returns true if the program is SUID.
269 * It calls abort() if the uid's are not saved already.
270 */
271 int sl_is_suid(void);
272
273 /*
274 * This function sets the effective uid
275 * to the saved effective uid.
276 */
277 int sl_set_suid (void);
278
279 /*
280 * This function sets the effective uid to the real uid.
281 */
282 int sl_unset_suid (void);
283
284 /*
285 * This function drops SUID privileges irrevocably.
286 */
287 int sl_drop_privileges(void);
288
289 /* ----------------------------------------------------------------
290 *
291 * File handling routines
292 *
293 * ---------------------------------------------------------------- */
294
[76]295 SL_TICKET sl_make_ticket (int fd, const char * path);
[1]296
297 /* Open for writing.
298 */
[20]299 SL_TICKET sl_open_write (const char * fname, int priviledge_mode);
[1]300
301 /* Open for reading.
302 */
[20]303 SL_TICKET sl_open_read (const char * fname, int priviledge_mode);
[1]304
305 /* Open for reading w/minimum checking.
306 */
[20]307 SL_TICKET sl_open_fastread (const char * fname, int priviledge_mode);
[1]308
309 /* Open for read and write.
310 */
[20]311 SL_TICKET sl_open_rdwr (const char * fname, int priviledge_mode);
[1]312
313 /* Open for read and write, fail if file exists.
314 */
[20]315 SL_TICKET sl_open_safe_rdwr (const char * fname, int priv);
[1]316
317 /* Open for write, truncate.
318 */
[20]319 SL_TICKET sl_open_write_trunc (const char * fname, int priviledge_mode);
[1]320
321 /* Open for read and write, truncate.
322 */
[20]323 SL_TICKET sl_open_rdwr_trunc (const char * fname, int priviledge_mode);
[1]324
325 /* Close file.
326 */
327 int sl_close (SL_TICKET ticket);
328
329 /* Unlink file.
330 */
331 int sl_unlink (SL_TICKET ticket);
332
333 /* Rewind file.
334 */
335 int sl_rewind (SL_TICKET ticket);
336
337 /* Seek file.
338 */
339 int sl_seek (SL_TICKET ticket, off_t off_data);
340
341 /* Forward file.
342 */
343 int sl_forward (SL_TICKET ticket);
344
345 /* Sync file.
346 */
347 int sl_sync (SL_TICKET ticket);
348
349 /* Read file.
350 */
351 int sl_read (SL_TICKET ticket, void * buf, size_t count);
352
[8]353 int sl_read_timeout_prep (SL_TICKET ticket);
354
[1]355 int sl_read_timeout (SL_TICKET ticket, void * buf,
356 size_t count, int timeout);
357
358 int sl_read_fast (SL_TICKET ticket, void * buf_in, size_t count);
359
360 /* Write file.
361 */
362 int sl_write (SL_TICKET ticket, void * msg, long nbytes);
363
364 /* Write file, terminate with newline.
365 */
366 int sl_write_line (SL_TICKET ticket, void * msg, long nbytes);
367
[76]368 /* As above, but only for non-constant strings.
369 */
370 int sl_write_line_fast (SL_TICKET ticket, void * msg, long nbytes);
371
[1]372 /* Drop all metadata for file descriptors >= fd.
373 */
374 int sl_dropall(int fd, int except);
375
376 /* Check whether file is trustworthy.
377 */
378 int sl_trustfile(char * path, uid_t * ok, uid_t * bad);
379
380 /* Check whether file is trustworthy.
381 */
382 int sl_trustfile_euid(char * filename, uid_t euid);
383
384 /* purge list of trusted users
385 */
386 int sl_trust_purge_user ();
387
388 /* Add a trusted user.
389 */
390 int sl_trust_add_user (uid_t pwid);
391
392 /* Get error string.
393 */
394 char * sl_error_string(int errorcode);
395
396 /* Get error file.
397 */
398 char * sl_trust_errfile(void);
399
[20]400 /* Overflow tests
401 */
402 int sl_ok_muli (int a, int b);
403 int sl_ok_divi (int a, int b);
404 int sl_ok_addi (int a, int b);
405 int sl_ok_subi (int a, int b);
[1]406
[34]407 int sl_ok_muls (size_t a, size_t b);
408 int sl_ok_adds (size_t a, size_t b);
409
410
[1]411#ifdef __cplusplus
412}
413#endif
414
415/* Privilege modes for file access.
416 */
417#define SL_YESPRIV 0x33
418#define SL_NOPRIV 0x34
419
[76]420/* Suitable for Linux
421 */
422#define MAXFILENAME 4096
[1]423
424
425/*
426 * This macro is TRUE if (x) < 0.
427 */
428#define SL_ISERROR(x) ((long)(x) < 0)
429
430#if defined(WITH_TPT)
431#define TPT(arg) dlog arg ;
432#else
433#define TPT(arg)
434#endif
435
436
437/*
438 * The 'require' macro.
439 */
440#define SL_REQUIRE(assertion, astext) \
441do { \
442 /*@i@*/ if (assertion) ; \
443 else { \
444 dlog(0, FIL__, __LINE__, SDG_AFAIL, \
445 FIL__, __LINE__, astext); \
446 _exit(EXIT_FAILURE); \
447 } \
448} while (0)
449
450
451/*
452 * The enter macro. Prints the trace if TRACE is on.
453 */
454extern int slib_do_trace;
455extern int slib_trace_fd;
456
457#if defined(SL_DEBUG)
458#define SL_ENTER(s) sl_stack_push(s, FIL__, __LINE__);
459#else
460#define SL_ENTER(s) if (slib_do_trace != 0) sl_trace_in(s, FIL__, __LINE__);
461#endif
462
463/*
464 * The return macro.
465 */
466#if defined(SL_DEBUG)
467#ifndef S_SPLINT_S
468#define SL_RETURN(x, s) \
469do { \
470 sl_stack_pop(s, FIL__, __LINE__); \
471 return(x); \
472} while(0)
473#else
474/*@notfunction@*/
475#define SL_RETURN(x, s) return(x);
476#endif /* S_SPLINT_S */
477#else
478#ifndef S_SPLINT_S
479#define SL_RETURN(x, s) \
480do { \
481 if (slib_do_trace != 0) \
482 sl_trace_out(s, FIL__, __LINE__); \
483 return(x); \
484} while(0)
485#else
486/*@notfunction@*/
487#define SL_RETURN(x, s) return(x);
488#endif /* S_SPLINT_S */
489#endif /* SL_RETURN macro */
490
491#if defined(SL_DEBUG)
492#define SL_RET0(s) \
493do { \
494 sl_stack_pop(s, FIL__, __LINE__); \
495 return; \
496} while(0)
497#else
498#ifndef S_SPLINT_S
499#define SL_RET0(s) \
500do { \
501 if (slib_do_trace != 0) \
502 sl_trace_out(s, FIL__, __LINE__); \
503 return; \
504} while(0)
505#else
506/*@notfunction@*/
507#define SL_RET0(s) return;
508#endif /* S_SPLINT_S */
509#endif /* SL_RETURN macro */
510
511#if defined(SL_DEBUG)
512void sl_stack_push(char * c, char * file, int line);
513void sl_stack_pop(char * c, char * file, int line);
514void sl_stack_print();
515#endif
516void sl_trace_in (char * str, char * file, int line);
517void sl_trace_out (char * str, char * file, int line);
[20]518int sl_trace_file (const char * str);
519int sl_trace_use (const char * str);
[1]520
521
522
523
524/*
525 * The internal return macro. Sets sl_errno to the return value.
526 */
527
528#if defined(SL_DEBUG)
529#define SL_IRETURN(x, s) \
530do { \
531 if((long)(x) < 0) { \
532 TPT((0, FIL__, __LINE__, SDG_ERROR, (long)(x))) \
533 sl_errno=(x); \
534 } \
535 sl_stack_pop(s, FIL__, __LINE__); \
536 if (1) return(x); \
537} while(0)
538#else
539#define SL_IRETURN(x, s) \
540do { \
541 if ((long)(x) < 0) sl_errno=(x); \
542 if (slib_do_trace) \
543 sl_trace_out(s, FIL__, __LINE__); \
544 if (1) return(x); \
545} while(0)
546
547#endif /* SL_IRETURN macro */
548
549
550
551/* slib.h */
552#endif
553
554
555
556
Note: See TracBrowser for help on using the repository browser.