libspf2 1.2.10
|
00001 /* 00002 * This program is free software; you can redistribute it and/or modify 00003 * it under the terms of either: 00004 * 00005 * a) The GNU Lesser General Public License as published by the Free 00006 * Software Foundation; either version 2.1, or (at your option) any 00007 * later version, 00008 * 00009 * OR 00010 * 00011 * b) The two-clause BSD license. 00012 * 00013 * These licenses can be found with the distribution in the file LICENSES 00014 */ 00015 00016 00017 00018 00019 #ifndef INC_SPF_INTERNAL 00020 #define INC_SPF_INTERNAL 00021 00022 #ifndef TRUE 00023 #define TRUE 1 00024 #define FALSE 0 00025 #endif 00026 00027 #ifndef NULL 00028 #define NULL ((void *)0) 00029 #endif 00030 00031 #define array_elem(x) ((long int)(sizeof( x ) / sizeof( *x ))) 00032 00033 00034 /* 00035 * misc macros to make the code look cleaner than it really is 00036 */ 00037 00038 #ifndef SPF_MAX_DNS_MECH 00039 00055 #define SPF_MAX_DNS_MECH 10 00056 #endif 00057 #ifndef SPF_MAX_DNS_PTR 00058 00062 #define SPF_MAX_DNS_PTR 10 00063 #endif 00064 #ifndef SPF_MAX_DNS_MX 00065 00069 #define SPF_MAX_DNS_MX 10 00070 #endif 00071 00072 #if 1 00073 #define _ALIGN_SZ 4 00074 static inline size_t _align_sz(size_t s) 00075 { return (s + (_ALIGN_SZ - 1 - (((s - 1) & (_ALIGN_SZ - 1))))); } 00076 static inline char * _align_ptr(char *s) 00077 { return (s + (_ALIGN_SZ - 1 - ((((size_t)s - 1) & (_ALIGN_SZ - 1))))); } 00078 #else 00079 static inline size_t _align_sz(size_t s) { return s; } 00080 static inline char * _align_ptr(char *s) { return s; } 00081 #endif 00082 00083 #include "spf_record.h" 00084 00085 /* FIXME: need to make these network/compiler portable */ 00086 /* FIXME: Several of these duplicate each other. Bad. */ 00087 static inline size_t SPF_mech_data_len( SPF_mech_t * mech ) 00088 { return (mech->mech_type == MECH_IP4) 00089 ? sizeof( struct in_addr ) 00090 : (mech->mech_type == MECH_IP6) 00091 ? sizeof( struct in6_addr ) 00092 : mech->mech_len; } 00093 static inline SPF_mech_t *SPF_mech_next( SPF_mech_t * mech ) 00094 { return (SPF_mech_t *)_align_ptr( 00095 (char *)mech + sizeof(SPF_mech_t) + SPF_mech_data_len( mech ) 00096 ); } 00097 static inline SPF_data_t *SPF_mech_data( SPF_mech_t *mech ) 00098 { return (SPF_data_t *)( (char *)mech + sizeof(SPF_mech_t)); } 00099 static inline SPF_data_t *SPF_mech_end_data( SPF_mech_t *mech ) 00100 { return (SPF_data_t *)( (char *)SPF_mech_data(mech) + 00101 SPF_mech_data_len( mech ));} 00102 static inline struct in_addr *SPF_mech_ip4_data( SPF_mech_t *mech ) 00103 { return (struct in_addr *)( (char *)mech + sizeof(SPF_mech_t)); } 00104 static inline struct in6_addr *SPF_mech_ip6_data( SPF_mech_t *mech ) 00105 { return (struct in6_addr *)( (char *)mech + sizeof(SPF_mech_t)); } 00106 00107 static inline size_t SPF_data_len( SPF_data_t *data ) 00108 { return sizeof(SPF_data_t) + 00109 (data->ds.parm_type == PARM_STRING ? data->ds.len : 0); } 00110 static inline SPF_data_t *SPF_data_next( SPF_data_t *data ) 00111 { return (SPF_data_t *)_align_ptr( 00112 (char *)data + SPF_data_len(data) 00113 ); } 00114 static inline char *SPF_data_str( SPF_data_t *data ) 00115 { return (char *)data + sizeof(SPF_data_t); } 00116 00117 static inline size_t SPF_mod_len( SPF_mod_t *mod ) 00118 { return _align_sz(sizeof(SPF_mod_t) + mod->name_len) + mod->data_len; } 00119 static inline SPF_mod_t *SPF_mod_next( SPF_mod_t *mod ) 00120 { return (SPF_mod_t *)_align_ptr( 00121 (char *)mod + SPF_mod_len(mod) 00122 ); } 00123 static inline char *SPF_mod_name( SPF_mod_t *mod ) 00124 { return (char *)mod + sizeof(SPF_mod_t); } 00125 static inline SPF_data_t *SPF_mod_data( SPF_mod_t *mod ) 00126 { return (SPF_data_t *)_align_ptr( 00127 (char *)mod + sizeof(SPF_mod_t) + mod->name_len 00128 ); } 00129 static inline SPF_data_t *SPF_mod_end_data( SPF_mod_t *mod ) 00130 { return (SPF_data_t *)((char *)SPF_mod_data(mod) + mod->data_len); } 00131 00132 static inline size_t SPF_macro_data_len( SPF_macro_t * mac ) 00133 { return mac->macro_len; } 00134 static inline SPF_data_t *SPF_macro_data( SPF_macro_t * mac ) 00135 { return (SPF_data_t *)( (char *)mac + sizeof(SPF_macro_t)); } 00136 00137 00138 char *SPF_sanitize( SPF_server_t *spf_server, char *str ); 00139 00140 void SPF_print_sizeof(void); 00141 00148 SPF_errcode_t SPF_recalloc(char **bufp, size_t *buflenp, size_t buflen) __attribute__((warn_unused_result)); 00149 00150 00158 #define SPF_WRAP_FUNCTION(name, proto, args) \ 00159 SPF_errcode_t name proto { \ 00160 SPF_errcode_t err = name ## _real args; \ 00161 SPF_debug(#name " returns %d\n", err); \ 00162 return err; \ 00163 } \ 00164 SPF_errcode_t name ## _real proto 00165 00166 #endif