"Fossies" - the Fresh Open Source Software Archive 
Member "libspf2-1.2.10/src/include/spf_response.h" (28 Jan 2012, 8802 Bytes) of package /linux/privat/libspf2-1.2.10.tar.gz:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style:
standard) with prefixed line numbers and
code folding option.
Alternatively you can here
view or
download the uninterpreted source code file.
For more information about "spf_response.h" see the
Fossies "Dox" file reference documentation.
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of either:
4 *
5 * a) The GNU Lesser General Public License as published by the Free
6 * Software Foundation; either version 2.1, or (at your option) any
7 * later version,
8 *
9 * OR
10 *
11 * b) The two-clause BSD license.
12 *
13 * These licenses can be found with the distribution in the file LICENSES
14 */
15
16 #ifndef INC_SPF_RESPONSE
17 #define INC_SPF_RESPONSE
18
19 /**
20 * @file
21 *
22 * Results from an SPF check
23 *
24 * The results of the SPF check (as defined by the official SPF spec)
25 *
26 * To quote from doc/draft-mengwong-spf-00.txt Section 3:
27 *
28 * 3. SPF Record Evaluation
29 *
30 * An SPF client evaluates an SPF record and produces one of seven
31 * results:
32 *
33 * None: The domain does not publish SPF data.
34 *
35 * Neutral (?): The SPF client MUST proceed as if a domain did not
36 * publish SPF data. This result occurs if the domain explicitly
37 * specifies a "?" value, or if processing "falls off the end" of
38 * the SPF record.
39 *
40 * Pass (+): the message meets the publishing domain's definition of
41 * legitimacy. MTAs proceed to apply local policy and MAY accept or
42 * reject the message accordingly.
43 *
44 * Fail (-): the message does not meet a domain's definition of
45 * legitimacy. MTAs MAY reject the message using a permanent
46 * failure reply code. (Code 550 is RECOMMENDED. See RFC2821
47 * section 7.1.)
48 *
49 * Softfail (~): the message does not meet a domain's strict
50 * definition of legitimacy, but the domain cannot confidently state
51 * that the message is a forgery. MTAs SHOULD accept the message
52 * but MAY subject it to a higher transaction cost, deeper scrutiny,
53 * or an unfavourable score.
54 *
55 * There are two error conditions, one temporary and one permanent.
56 *
57 * Error: indicates an error during lookup; an MTA MAY reject the
58 * message using a transient failure code, such as 450.
59 *
60 * Unknown: indicates incomplete processing: an MTA MUST proceed as
61 * if a domain did not publish SPF data.
62 *
63 * When SPF-aware SMTP receivers accept a message, they SHOULD prepend a
64 * Received-SPF header. See section 6.
65 *
66 * SPF clients MUST use the algorithm described in this section
67 * or its functional equivalent.
68 *
69 * If an SPF client encounters a syntax error in an
70 * SPF record, it must terminate processing and return a result
71 * of "unknown".
72 *
73 *
74 * note: SPF_RESULT_* values are constrained by the internal PREFIX_* values
75 */
76
77
78 typedef
79 enum SPF_result_enum {
80 SPF_RESULT_INVALID = 0, /**< We should never return this. */
81 SPF_RESULT_NEUTRAL,
82 SPF_RESULT_PASS,
83 SPF_RESULT_FAIL,
84 SPF_RESULT_SOFTFAIL,
85
86 SPF_RESULT_NONE,
87 SPF_RESULT_TEMPERROR,
88 SPF_RESULT_PERMERROR
89 } SPF_result_t;
90
91 /**
92 * The reason that the result was returned
93 *
94 * This is what triggered the SPF result. Usually, it is a mechanism in the
95 * SPF record that causes the result, but if it was something else, the
96 * calling program will often want to take a different action or issue
97 * a different message.
98 */
99 typedef
100 enum SPF_reason_enum {
101 SPF_REASON_NONE = 0
102 , SPF_REASON_FAILURE
103 , SPF_REASON_LOCALHOST /**< localhost always gets a free ride */
104 , SPF_REASON_LOCAL_POLICY /**< local policy caused the match */
105 , SPF_REASON_MECH /**< mechanism caused the match */
106 , SPF_REASON_DEFAULT /**< ran off the end of the rec */
107 , SPF_REASON_2MX /**< sent from a secondary MX */
108 } SPF_reason_t;
109
110 /**
111 * error codes returned by various SPF functions. (including SPF_compile()
112 * and SPF_id2str(), spf_result(), etc.).
113 *
114 * The function SPF_strerror() will return a longer explanation of these
115 * errors.
116 */
117
118 typedef
119 enum SPF_errcode_t {
120 SPF_E_SUCCESS = 0 /**< No errors */
121 , SPF_E_NO_MEMORY /**< Out of memory */
122 , SPF_E_NOT_SPF /**< Could not find a valid SPF record */
123 , SPF_E_SYNTAX /**< Syntax error */
124 , SPF_E_MOD_W_PREF /**< Modifiers can not have prefixes */
125 , SPF_E_INVALID_CHAR /**< Invalid character found */
126 , SPF_E_UNKNOWN_MECH /**< Unknown mechanism found */
127 , SPF_E_INVALID_OPT /**< Invalid option found */
128 , SPF_E_INVALID_CIDR /**< Invalid CIDR length */
129 , SPF_E_MISSING_OPT /**< Required option is missing */
130 , SPF_E_INTERNAL_ERROR /**< Internal programming error */
131 , SPF_E_INVALID_ESC /**< Invalid %-escape character */
132 , SPF_E_INVALID_VAR /**< Invalid macro variable */
133 , SPF_E_BIG_SUBDOM /**< Subdomain truncation depth too large */
134 , SPF_E_INVALID_DELIM /**< Invalid delimiter character */
135 , SPF_E_BIG_STRING /**< Option string too long */
136 , SPF_E_BIG_MECH /**< Too many mechanisms */
137 , SPF_E_BIG_MOD /**< Too many modifiers */
138 , SPF_E_BIG_DNS /**< Mechanisms used too many DNS lookups */
139 , SPF_E_INVALID_IP4 /**< Invalid IPv4 address literal */
140 , SPF_E_INVALID_IP6 /**< Invalid IPv6 address literal */
141 , SPF_E_INVALID_PREFIX /**< Invalid mechanism prefix */
142 , SPF_E_RESULT_UNKNOWN /**< SPF result is \"unknown\" */
143 , SPF_E_UNINIT_VAR /**< Uninitialized variable */
144 , SPF_E_MOD_NOT_FOUND /**< Modifier not found */
145 , SPF_E_NOT_CONFIG /**< Not configured */
146 , SPF_E_DNS_ERROR /**< DNS lookup failure */
147 , SPF_E_BAD_HOST_IP /**< Invalid hostname (an IP address?) */
148 , SPF_E_BAD_HOST_TLD /**< Hostname has a missing or invalid TLD */
149 , SPF_E_MECH_AFTER_ALL /**< Mechanisms found after the \"all:\"
150 mechanism will be ignored */
151 , SPF_E_INCLUDE_RETURNED_NONE /**< If an include recursive query returns none it's a perm error */
152 , SPF_E_RECURSIVE /**< Recursive include */
153 , SPF_E_MULTIPLE_RECORDS /**< Multiple SPF or TXT records found */
154 } SPF_errcode_t;
155
156 typedef
157 struct SPF_error_struct
158 {
159 SPF_errcode_t code;
160 char *message;
161 char is_error;
162 } SPF_error_t;
163
164 typedef struct SPF_response_struct SPF_response_t;
165
166 #include "spf.h"
167 #include "spf_request.h"
168
169 struct SPF_response_struct {
170 /* Structure variables */
171 SPF_request_t *spf_request;
172 SPF_record_t *spf_record_exp;
173
174 /* The answer itself. */
175 SPF_result_t result;
176 SPF_reason_t reason;
177 SPF_errcode_t err;
178
179 char *received_spf;
180 char *received_spf_value;
181 char *header_comment;
182 char *smtp_comment;
183 char *explanation;
184
185 /* The errors */
186 SPF_error_t *errors;
187 unsigned short errors_size; /**< Allocated */
188 unsigned short errors_length; /**< Used */
189 unsigned short num_errors; /**< Excluding warnings */
190
191 /* Stuff which lets us get there. */
192 int num_dns_mech;
193 };
194
195
196 SPF_response_t *SPF_response_new(SPF_request_t *spf_request);
197 void SPF_response_free(SPF_response_t *rp);
198 SPF_response_t *SPF_response_combine(SPF_response_t *main,
199 SPF_response_t *r2mx);
200
201 /* Query functions for elements of the result */
202 SPF_result_t SPF_response_result(SPF_response_t *rp);
203 SPF_reason_t SPF_response_reason(SPF_response_t *rp);
204 SPF_errcode_t SPF_response_errcode(SPF_response_t *rp);
205 const char *SPF_response_get_received_spf(SPF_response_t *rp);
206 const char *SPF_response_get_received_spf_value(SPF_response_t*rp);
207 const char *SPF_response_get_header_comment(SPF_response_t *rp);
208 const char *SPF_response_get_smtp_comment(SPF_response_t *rp);
209 const char *SPF_response_get_explanation(SPF_response_t *rp);
210
211 /** How many warnings were generated? */
212 int SPF_response_messages(SPF_response_t *rp);
213 /** How many errors were generated? */
214 int SPF_response_errors(SPF_response_t *rp);
215 /** Errors + warnings */
216 int SPF_response_warnings(SPF_response_t *rp);
217 /** Returns an individual message */
218 SPF_error_t *SPF_response_message(SPF_response_t *rp, int idx);
219
220 SPF_errcode_t SPF_error_code(SPF_error_t *err);
221 const char * SPF_error_message(SPF_error_t *err);
222 char SPF_error_errorp(SPF_error_t *err);
223
224 /** Internal functions for adding errors. */
225
226 SPF_errcode_t SPF_response_add_error_ptr(SPF_response_t *rp,
227 SPF_errcode_t code,
228 const char *text, const char *tptr,
229 const char *format, ...);
230 SPF_errcode_t SPF_response_add_error_idx(SPF_response_t *rp,
231 SPF_errcode_t code,
232 const char *text, int idx,
233 const char *format, ...);
234 SPF_errcode_t SPF_response_add_error(SPF_response_t *rp,
235 SPF_errcode_t code,
236 const char *format, ...);
237 SPF_errcode_t SPF_response_add_warn_ptr(SPF_response_t *rp,
238 SPF_errcode_t code,
239 const char *text, const char *tptr,
240 const char *format, ...);
241 SPF_errcode_t SPF_response_add_warn_idx(SPF_response_t *rp,
242 SPF_errcode_t code,
243 const char *text, int idx,
244 const char *format, ...);
245 SPF_errcode_t SPF_response_add_warn(SPF_response_t *rp,
246 SPF_errcode_t code,
247 const char *format, ...);
248
249 #endif