/usr/include/postfix/check_arg.h is in postfix-dev 3.1.0-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | #ifndef _CHECK_ARG_INCLUDED_
#define _CHECK_ARG_INCLUDED_
/*++
/* NAME
/* check_arg 3h
/* SUMMARY
/* type checking/narrowing/widening for unprototyped arguments
/* SYNOPSIS
/* #include <check_arg.h>
/*
/* /* Example checking infrastructure for int, int *, const int *. */
/* CHECK_VAL_HELPER_DCL(tag, int);
/* CHECK_PTR_HELPER_DCL(tag, int);
/* CHECK_CPTR_HELPER_DCL(tag, int);
/*
/* /* Example variables with type int, int *, const int *. */
/* int int_val;
/* int *int_ptr;
/* const int *int_cptr;
/*
/* /* Example variadic function with type-flag arguments. */
/* func(FLAG_INT_VAL, CHECK_VAL(tag, int, int_val),
/* FLAG_INT_PTR, CHECK_PTR(tag, int, int_ptr),
/* FLAG_INT_CPTR, CHECK_CPTR(tag, int, int_cptr)
/* FLAG_END);
/* DESCRIPTION
/* This module implements wrappers for unprototyped function
/* arguments, to enable the same type checking, type narrowing,
/* and type widening as for prototyped function arguments. The
/* wrappers may also be useful in other contexts.
/*
/* Typically, these wrappers are hidden away in a per-module
/* header file that is read by the consumers of that module.
/* To protect consumers against name collisions between wrappers
/* in different header files, wrappers should be called with
/* a distinct per-module tag value. The tag syntax is that
/* of a C identifier.
/*
/* Use CHECK_VAL(tag, type, argument) for arguments with a
/* basic type: int, long, etc., and types defined with "typedef"
/* where indirection is built into the type itself (for example,
/* the result of "typedef int *foo" or function pointer
/* typedefs).
/*
/* Use CHECK_PTR(tag, type, argument) for non-const pointer
/* arguments, CHECK_CPTR(tag, type, argument) for const pointer
/* arguments, and CHECK_PPTR(tag, type, argument) for pointer-
/* to-pointer arguments.
/*
/* Use CHECK_*_HELPER_DCL(tag, type) to provide the
/* checking infrastructure for all CHECK_*(tag, type, ...)
/* instances with the same *, tag and type. Depending on
/* the compilation environment, the infrastructure consists
/* of an inline function definition or a dummy assignment
/* target declaration.
/*
/* The compiler should report the following problems:
/* .IP \(bu
/* Const pointer argument where a non-const pointer is expected.
/* .IP \(bu
/* Pointer argument where a non-pointer is expected and
/* vice-versa.
/* .IP \(bu
/* Pointer/pointer type mismatches except void/non-void pointers.
/* Just like function prototypes, all CHECK_*PTR() wrappers
/* cast their result to the desired type.
/* .IP \(bu
/* Non-constant non-pointer argument where a pointer is expected.
/*. PP
/* Just like function prototypes, the CHECK_*PTR() wrappers
/* handle "bare" numerical constants by casting their argument
/* to the desired pointer type.
/*
/* Just like function prototypes, the CHECK_VAL() wrapper
/* cannot force the caller to specify a particular non-pointer
/* type and casts its argument value to the desired type which
/* may wider or narrower than the argument value.
/* IMPLEMENTATION
/*
* Choose between an implementation based on inline functions (standardized
* with C99) or conditional assignment (portable to older compilers, with
* some caveats as discussed below).
*/
#ifndef NO_INLINE
/*
* Parameter checks expand into inline helper function calls.
*/
#define CHECK_VAL(tag, type, v) check_val_##tag##type(v)
#define CHECK_PTR(tag, type, v) check_ptr_##tag##type(v)
#define CHECK_CPTR(tag, type, v) check_cptr_##tag##type(v)
#define CHECK_PPTR(tag, type, v) check_pptr_##tag##type(v)
/*
* Macros to instantiate the inline helper functions.
*/
#define CHECK_VAL_HELPER_DCL(tag, type) \
static inline type check_val_##tag##type(type v) { return v; }
#define CHECK_PTR_HELPER_DCL(tag, type) \
static inline type *check_ptr_##tag##type(type *v) { return v; }
#define CHECK_CPTR_HELPER_DCL(tag, type) \
static inline const type *check_cptr_##tag##type(const type *v) \
{ return v; }
#define CHECK_PPTR_HELPER_DCL(tag, type) \
static inline type **check_pptr_##tag##type(type **v) { return v; }
#else /* NO_INLINE */
/*
* Parameter checks expand into unreachable conditional assignments.
* Inspired by OpenSSL's verified pointer check, our implementation also
* detects const/non-const pointer conflicts, and it also supports
* non-pointer expressions.
*/
#define CHECK_VAL(tag, type, v) ((type) (1 ? (v) : (CHECK_VAL_DUMMY(type) = (v))))
#define CHECK_PTR(tag, type, v) ((type *) (1 ? (v) : (CHECK_PTR_DUMMY(type) = (v))))
#define CHECK_CPTR(tag, type, v) \
((const type *) (1 ? (v) : (CHECK_CPTR_DUMMY(type) = (v))))
#define CHECK_PPTR(tag, type, v) ((type **) (1 ? (v) : (CHECK_PPTR_DUMMY(type) = (v))))
/*
* These macros instantiate assignment target declarations. Since the
* assignment is made in unreachable code, the compiler "should" not emit
* any references to those assignment targets. We use the "extern" class so
* that gcc will not complain about unused variables. Using "extern" breaks
* when a compiler does emit references unreachable assignment targets.
* Hopefully, those cases will be rare.
*/
#define CHECK_VAL_HELPER_DCL(tag, type) extern type CHECK_VAL_DUMMY(type)
#define CHECK_PTR_HELPER_DCL(tag, type) extern type *CHECK_PTR_DUMMY(type)
#define CHECK_CPTR_HELPER_DCL(tag, type) extern const type *CHECK_CPTR_DUMMY(type)
#define CHECK_PPTR_HELPER_DCL(tag, type) extern type **CHECK_PPTR_DUMMY(type)
/*
* The actual dummy assignment target names.
*/
#define CHECK_VAL_DUMMY(type) check_val_dummy_##type
#define CHECK_PTR_DUMMY(type) check_ptr_dummy_##type
#define CHECK_CPTR_DUMMY(type) check_cptr_dummy_##type
#define CHECK_PPTR_DUMMY(type) check_pptr_dummy_##type
#endif /* NO_INLINE */
/* LICENSE
/* .ad
/* .fi
/* The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/* Wietse Venema
/* IBM T.J. Watson Research
/* P.O. Box 704
/* Yorktown Heights, NY 10598, USA
/*--*/
#endif
|