doxygen/html/main_8c-source.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<title>libSPF v1.0: main.c Source File</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
</head><body>
<!-- Generated by Doxygen 1.3.8 -->
<div class="qindex">  <form class="search" action="search.php" method="get">
<a class="qindex" href="main.html">Main&nbsp;Page</a> | <a class="qindex" href="annotated.html">Data&nbsp;Structures</a> | <a class="qindex" href="files.html">File&nbsp;List</a> | <a class="qindex" href="functions.html">Data&nbsp;Fields</a> | <a class="qindex" href="globals.html">Globals</a>  | <span class="search"><u>S</u>earch&nbsp;for&nbsp;<input class="search" type="text" name="query" value="" size="20" accesskey="s"/></span></form></div>
<h1>main.c</h1><a href="main_8c.html">Go to the documentation of this file.</a><pre class="fragment"><div>00001 <span class="comment">/* libspf - Sender Policy Framework library</span>
00002 <span class="comment">*</span>
00003 <span class="comment">*  ANSI C implementation of spf-draft-200405.txt</span>
00004 <span class="comment">*</span>
00005 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
00006 <span class="comment">*  Author: Sean Comeau   &lt;scomeau@obscurity.org&gt;</span>
00007 <span class="comment">*</span>
00008 <span class="comment">*  File:   spf.c</span>
00009 <span class="comment">*  Desc:   Main library functionality</span>
00010 <span class="comment">*</span>
00011 <span class="comment">*  License:</span>
00012 <span class="comment">*</span>
00013 <span class="comment">*  The libspf Software License, Version 1.0</span>
00014 <span class="comment">*</span>
00015 <span class="comment">*  Copyright (c) 2004 James Couzens &amp; Sean Comeau  All rights</span>
00016 <span class="comment">*  reserved.</span>
00017 <span class="comment">*</span>
00018 <span class="comment">*  Redistribution and use in source and binary forms, with or without</span>
00019 <span class="comment">*  modification, are permitted provided that the following conditions</span>
00020 <span class="comment">*  are met:</span>
00021 <span class="comment">*</span>
00022 <span class="comment">*  1. Redistributions of source code must retain the above copyright</span>
00023 <span class="comment">*     notice, this list of conditions and the following disclaimer.</span>
00024 <span class="comment">*</span>
00025 <span class="comment">*  2. Redistributions in binary form must reproduce the above copyright</span>
00026 <span class="comment">*     notice, this list of conditions and the following disclaimer in</span>
00027 <span class="comment">*     the documentation and/or other materials provided with the</span>
00028 <span class="comment">*     distribution.</span>
00029 <span class="comment">*</span>
00030 <span class="comment">*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED</span>
00031 <span class="comment">*  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES</span>
00032 <span class="comment">*  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE</span>
00033 <span class="comment">*  DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS MAKING USE OF THIS LICESEN</span>
00034 <span class="comment">*  OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,</span>
00035 <span class="comment">*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT</span>
00036 <span class="comment">*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF</span>
00037 <span class="comment">*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND</span>
00038 <span class="comment">*  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,</span>
00039 <span class="comment">*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT</span>
00040 <span class="comment">*  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF</span>
00041 <span class="comment">*  SUCH DAMAGE.</span>
00042 <span class="comment">*</span>
00043 <span class="comment">*/</span>
00044 
00045 <span class="preprocessor">#ifdef _WITH_PTHREADS</span>
00046 <span class="preprocessor"></span><span class="preprocessor">#include &lt;pthread.h&gt;</span>           <span class="comment">/* pthread_mutex */</span>
00047 <span class="preprocessor">#endif </span><span class="comment">/* _WITH_PTHREDS */</span>
00048 
00049 <span class="preprocessor">#include "../../config.h"</span>      <span class="comment">/* autoconf */</span>
00050 <span class="preprocessor">#include "<a class="code" href="main_8h.html">main.h</a>"</span>              <span class="comment">/* our header */</span>
00051 <span class="preprocessor">#include "<a class="code" href="util_8h.html">util.h</a>"</span>              <span class="comment">/* Utility functions */</span>
00052 <span class="preprocessor">#include "<a class="code" href="dns_8h.html">dns.h</a>"</span>               <span class="comment">/* DNS functions */</span>
00053 <span class="preprocessor">#include "<a class="code" href="macro_8h.html">macro.h</a>"</span>             <span class="comment">/* MACRO parsing functions */</span>
00054 
00055 <span class="preprocessor">#undef VERSION                 </span><span class="comment">/* autoconf */</span>
00056 
<a name="l00057"></a><a class="code" href="spf_8h.html#a47">00057</a> <a class="code" href="structspf__config__s.html">spf_config_t</a> <a class="code" href="main_8c.html#a0">confg</a>;            <span class="comment">/* global config struct */</span>
00058 
<a name="l00059"></a><a class="code" href="main_8c.html#a1">00059</a> <span class="keywordtype">int</span> <a class="code" href="dns_8h.html#a6">h_errno</a>;                   <span class="comment">/* error handling */</span>
00060 
00061 <span class="preprocessor">#ifdef _WITH_PTHREADS</span>
00062 <span class="preprocessor"></span><span class="comment">/* mutex for _DNS_gethostbyname_r wrapper */</span>
00063 <span class="keyword">extern</span> pthread_mutex_t <a class="code" href="dns_8c.html#a0">dns_mutex</a>;
00064 <span class="preprocessor">#endif </span><span class="comment">/* _WITH_PTHREADS */</span>
00065 
00066 <span class="keyword">static</span> <a class="code" href="spf_8h.html#a35">SPF_BOOL</a> <a class="code" href="main_8c.html#a2">_SPF_clear_holdbufs</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *);
00067 
00068 <span class="comment">/* SPF_init</span>
00069 <span class="comment">*</span>
00070 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
00071 <span class="comment">*</span>
00072 <span class="comment">*  Date:   12/25/03</span>
00073 <span class="comment">*</span>
00074 <span class="comment">*  Desc:</span>
00075 <span class="comment">*         Applies config options and returns allocated memory to a peer_info_t</span>
00076 <span class="comment">*  structure.  Malloc returns NULL on a failure, and as such this function exits</span>
00077 <span class="comment">*  with NULL upon failure to allocate memory which there by results in a</span>
00078 <span class="comment">*  complete failure of the entire library.</span>
00079 <span class="comment">*</span>
00080 <span class="comment">*/</span>
<a name="l00081"></a><a class="code" href="spf_8h.html#a77">00081</a> <a class="code" href="structpeer__info__s.html">peer_info_t</a> *<a class="code" href="spf_8h.html#a77">SPF_init</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *local, <span class="keyword">const</span> <span class="keywordtype">char</span> *rip, <span class="keyword">const</span> <span class="keywordtype">char</span> *expl,
00082   <span class="keyword">const</span> <span class="keywordtype">char</span> *tf, <span class="keyword">const</span> <span class="keywordtype">char</span> *guess, u_int32_t use_trust, u_int32_t use_guess)
00083 {
00084   time_t curtime;           <span class="comment">/* time */</span>
00085 
00086   <span class="keywordtype">char</span> *cur_utc_time;       <span class="comment">/* time */</span>
00087 
00088   <a class="code" href="structpeer__info__s.html">peer_info_t</a> *p = NULL;    <span class="comment">/* return structure buffer */</span>
00089 
00090    <span class="comment">/*</span>
00091 <span class="comment">   *  spf_result struct including header texts.  This structure is used</span>
00092 <span class="comment">   *  during message header generation and has intended future purposes. </span>
00093 <span class="comment">   *  Each string has associated with it its actual size which is used </span>
00094 <span class="comment">   *  to provide some measure of protection against overflowing the strings</span>
00095 <span class="comment">   *  as they are (currently) statically defined in util.h</span>
00096 <span class="comment">  */</span>
00097   <span class="keyword">static</span> <a class="code" href="structspf__result__t.html">spf_result_t</a> spf_result[] =
00098   {{<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a24">HR_PASS</a>),    <a class="code" href="spf_8h.html#a24">HR_PASS</a>,    <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>,    <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="main_8h.html#a17">HDR_PASS</a>),    <a class="code" href="main_8h.html#a17">HDR_PASS</a>,    <span class="charliteral">'+'</span> },
00099    {<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a25">HR_NONE</a>),    <a class="code" href="spf_8h.html#a25">HR_NONE</a>,    <a class="code" href="spf_8h.html#a88a52">SPF_NONE</a>,    <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="main_8h.html#a18">HDR_NONE</a>),    <a class="code" href="main_8h.html#a18">HDR_NONE</a>,    <span class="charliteral">'\0'</span>},
00100    {<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a26">HR_S_FAIL</a>),  <a class="code" href="spf_8h.html#a26">HR_S_FAIL</a>,  <a class="code" href="spf_8h.html#a88a53">SPF_S_FAIL</a>,  <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="main_8h.html#a19">HDR_S_FAIL</a>),  <a class="code" href="main_8h.html#a19">HDR_S_FAIL</a>,  <span class="charliteral">'~'</span> },
00101    {<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a27">HR_H_FAIL</a>),  <a class="code" href="spf_8h.html#a27">HR_H_FAIL</a>,  <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>,  <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="main_8h.html#a20">HDR_H_FAIL</a>),  <a class="code" href="main_8h.html#a20">HDR_H_FAIL</a>,  <span class="charliteral">'-'</span> },
00102    {<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a28">HR_ERROR</a>),   <a class="code" href="spf_8h.html#a28">HR_ERROR</a>,   <a class="code" href="spf_8h.html#a88a55">SPF_ERROR</a>,   <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="main_8h.html#a21">HDR_ERROR</a>),   <a class="code" href="main_8h.html#a21">HDR_ERROR</a>,   <span class="charliteral">'\0'</span>},
00103    {<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a29">HR_NEUTRAL</a>), <a class="code" href="spf_8h.html#a29">HR_NEUTRAL</a>, <a class="code" href="spf_8h.html#a88a56">SPF_NEUTRAL</a>, <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="main_8h.html#a22">HDR_NEUTRAL</a>), <a class="code" href="main_8h.html#a22">HDR_NEUTRAL</a>, <span class="charliteral">'?'</span> },
00104    {<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a30">HR_UNKNOWN</a>), <a class="code" href="spf_8h.html#a30">HR_UNKNOWN</a>, <a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>, <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="main_8h.html#a23">HDR_UNKNOWN</a>), <a class="code" href="main_8h.html#a23">HDR_UNKNOWN</a>, <span class="charliteral">'\0'</span>},
00105    {<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a31">HR_UNMECH</a>),  <a class="code" href="spf_8h.html#a31">HR_UNMECH</a>,  <a class="code" href="spf_8h.html#a88a58">SPF_UNMECH</a>,  <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="main_8h.html#a24">HDR_UNMECH</a>),  <a class="code" href="main_8h.html#a24">HDR_UNMECH</a>,  <span class="charliteral">'\0'</span>}};
00106 
00107    <span class="comment">/*</span>
00108 <span class="comment">   * This structure here is the heart and soul or effectively the 'context' </span>
00109 <span class="comment">   * of libSPF.  This structure is passed back and forth between nearly </span>
00110 <span class="comment">   * every function which will operate on it in one way or another.</span>
00111 <span class="comment">  */</span>
00112   p = <a class="code" href="util_8h.html#a4">xmalloc</a>(<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a>));
00113 
00114   p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a> = spf_result;
00115    
00116 
00117    <span class="comment">/*</span>
00118 <span class="comment">   * Set the SPF query recursion level to zero.  This counter is</span>
00119 <span class="comment">   * incremeneted to a maximum of SPF_MAX_RECURSE (default value of</span>
00120 <span class="comment">   * that macro is 20) to provide a limit of recursiveness.  Not only does</span>
00121 <span class="comment">   * it astound me to see people creating infinite loops unintentionally</span>
00122 <span class="comment">   * through the use of the 'include' and 'redirect' facilities within SPF,</span>
00123 <span class="comment">   * but there is also the greater than average chance that a skriptkiddie</span>
00124 <span class="comment">   * or some other individual with malicious intentions would use a lack of</span>
00125 <span class="comment">   * such a level (or a poorly set one, you REALLY should not raise this</span>
00126 <span class="comment">   * above 20) to faciliate a very effective DoS or dDoS attack against your</span>
00127 <span class="comment">   * server using SPF checks.</span>
00128 <span class="comment">  */</span>
00129   p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a> = 0;
00130 
00131    <span class="comment">/*</span>
00132 <span class="comment">   * RFC2821 (pre-DATA) related variables</span>
00133 <span class="comment">   *</span>
00134 <span class="comment">  */</span>
00135 
00136   p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a> = NULL;
00137   p-&gt;<a class="code" href="structpeer__info__s.html#o9">ehlo</a> = NULL;
00138   p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> = NULL;
00139 
00140   <span class="keywordflow">if</span> (local != NULL &amp;&amp; (*local &amp;&amp; *(local + 1)))
00141   {
00142     p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(local, <a class="code" href="spf_8h.html#a7">SPF_MAX_LOCAL_PART</a>);
00143     p-&gt;<a class="code" href="structpeer__info__s.html#o18">r_vhname</a>  = <a class="code" href="util_8h.html#a8">xstrndup</a>(local, <a class="code" href="spf_8h.html#a7">SPF_MAX_LOCAL_PART</a>);
00144   }
00145   <span class="keywordflow">else</span>
00146   {
00147     p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a> = NULL;
00148     p-&gt;<a class="code" href="structpeer__info__s.html#o18">r_vhname</a>  = NULL;
00149     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"Warning: Invalid local-part detected (DSN or NULL?)\n"</span>);
00150   }
00151 
00152   <span class="comment">/* don't change this, this is for Solaris which can't print NULL strings */</span>
00153   <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Called with: (%s) (%s) (%s) (%s) (%s) %u:%u\n"</span>,
00154      local ? local : <span class="stringliteral">"NULL"</span>,
00155      rip   ? rip   : <span class="stringliteral">"NULL"</span>,
00156      expl  ? expl  : <span class="stringliteral">"NULL"</span>,
00157      tf    ? tf    : <span class="stringliteral">"NULL"</span>,
00158      guess ? guess : <span class="stringliteral">"NULL"</span>,
00159      use_trust, use_guess);
00160 
00161    <span class="comment">/*</span>
00162 <span class="comment">   * Set the default SPF version level to zero.  This is important because</span>
00163 <span class="comment">   * the lack of a valid SPF version here is relied upon within SPF_parse_policy</span>
00164 <span class="comment">   * to determine an appropriate exit enforcing the RFC requirement that each</span>
00165 <span class="comment">   * SPF record publish a valid version within their SPF query.</span>
00166 <span class="comment">  */</span>
00167   p-&gt;<a class="code" href="structpeer__info__s.html#o5">spf_ver</a> = 0;
00168 
00169    <span class="comment">/* </span>
00170 <span class="comment">   * "Trusted Forwarder" enabled?  This is also what you could use if you wanted to</span>
00171 <span class="comment">   * operate an 'in-house' whitelist for your server.  For more information about</span>
00172 <span class="comment">   * the officla "Trusted Forwarder" service visit http://trustedforwarder.org </span>
00173 <span class="comment">  */</span>
00174   <span class="keywordflow">if</span> (use_trust == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>)
00175   {
00176     p-&gt;<a class="code" href="structpeer__info__s.html#o3">use_trust</a> = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
00177   }
00178   <span class="keywordflow">else</span>
00179   {
00180     p-&gt;<a class="code" href="structpeer__info__s.html#o3">use_trust</a> = <a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>;
00181   }
00182 
00183    <span class="comment">/*</span>
00184 <span class="comment">   * "Best Guess" enabled?  This is a great way to provide a "generic" SPF check</span>
00185 <span class="comment">   * against domains who do not publish SPF either through ignorance or refusal</span>
00186 <span class="comment">   * to do so.  The default best guess is defined in spf.h and is comprised of</span>
00187 <span class="comment">   * SPF syntax facilitating 'a', 'mx', and 'ptr' checks against the connected</span>
00188 <span class="comment">   * host when enabled in an attempt to validate them</span>
00189 <span class="comment">  */</span>
00190   <span class="keywordflow">if</span> (use_guess == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>)
00191   {
00192     p-&gt;<a class="code" href="structpeer__info__s.html#o4">use_guess</a> = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
00193   }
00194   <span class="keywordflow">else</span>
00195   {
00196     p-&gt;<a class="code" href="structpeer__info__s.html#o4">use_guess</a> = <a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>;
00197   }
00198 
00199   p-&gt;<a class="code" href="structpeer__info__s.html#o0">ALL</a> = <a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>;
00200   p-&gt;<a class="code" href="structpeer__info__s.html#o6">p</a>   = NULL;
00201 
00202    <span class="comment">/*</span>
00203 <span class="comment">   * SPF Explanation.  This can be optionally pre-pended to the RFC2822</span>
00204 <span class="comment">   * message body as a means of informing a client when rejecting their</span>
00205 <span class="comment">   * message for a failure to appropriate pass a desired SPF level.</span>
00206 <span class="comment">  */</span> 
00207   <span class="keywordflow">if</span> (expl != NULL &amp;&amp; (*expl &amp;&amp; *(expl + 1)))
00208   {
00209     p-&gt;<a class="code" href="structpeer__info__s.html#o11">explain</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(expl, (strlen(expl) + 1));
00210   }
00211   <span class="keywordflow">else</span>
00212   {
00213     p-&gt;<a class="code" href="structpeer__info__s.html#o11">explain</a> = NULL;
00214   }
00215 
00216   <span class="keywordflow">if</span> (guess != NULL &amp;&amp; (*guess &amp;&amp; *(guess + 1)))
00217   {
00218     p-&gt;<a class="code" href="structpeer__info__s.html#o12">guess</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(guess, (strlen(guess) + 1));
00219   }
00220   <span class="keywordflow">else</span>
00221   {
00222     p-&gt;<a class="code" href="structpeer__info__s.html#o12">guess</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(<a class="code" href="spf_8h.html#a33">SPF_GUESS</a>, (<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a33">SPF_GUESS</a>) + 1));
00223   }
00224 
00225   <span class="keywordflow">if</span> ((tf != NULL) &amp;&amp; (*tf &amp;&amp; *(tf + 1)))
00226   {
00227     p-&gt;<a class="code" href="structpeer__info__s.html#o13">trusted</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(tf, (strlen(tf) + 1));
00228   }
00229   <span class="keywordflow">else</span>
00230   {
00231     p-&gt;<a class="code" href="structpeer__info__s.html#o13">trusted</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(<a class="code" href="spf_8h.html#a34">SPF_TRUSTED</a>, (<a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="spf_8h.html#a34">SPF_TRUSTED</a>) + 1));
00232   }
00233 
00234   p-&gt;<a class="code" href="structpeer__info__s.html#o14">ptr_mhost</a>        = NULL;    <span class="comment">/* MTA hostname */</span>
00235   p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>   = NULL;    <span class="comment">/* Current domain name (of client) */</span>
00236   p-&gt;<a class="code" href="structpeer__info__s.html#o19">cur_eaddr</a>        = NULL;    <span class="comment">/* Current email-address (of client) */</span>
00237 
00238    <span class="comment">/* </span>
00239 <span class="comment">   * inet_pton is used to convert the IP address of the remotely connected</span>
00240 <span class="comment">   * client into a network address structure which will be used during</span>
00241 <span class="comment">   * and SPF parse to perform CIDR calculations against a variety of SPF</span>
00242 <span class="comment">   * mechanisms ('ip4', 'ip6', etc.).  Currently hard set for IPv4.</span>
00243 <span class="comment">   *</span>
00244 <span class="comment">   * A character version of the remote peer is retained within the </span>
00245 <span class="comment">   * peer_info_t structure by reason that there is no sense not doign</span>
00246 <span class="comment">   * so since we will need to reference it in a human readable form,</span>
00247 <span class="comment">   * and since the MTA has already performed the labour necessary to</span>
00248 <span class="comment">   * get it into this form, we might as well keep it.</span>
00249 <span class="comment">  */</span>
00250   <span class="keywordflow">if</span> (((rip != NULL) &amp;&amp; (*rip &amp;&amp; *(rip + 1))) &amp;&amp; (inet_pton(AF_INET, rip,
00251     &amp;p-&gt;<a class="code" href="structpeer__info__s.html#o26">addr</a>) &gt;= 0)) 
00252   {
00253      p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(rip, <a class="code" href="spf_8h.html#a11">SPF_MAX_IP_ADDR</a>);
00254   }
00255   <span class="keywordflow">else</span>
00256   {
00257     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"Warning: Unable to execute inet_print (bad passed ipaddr?)\n"</span>);
00258     <a class="code" href="spf_8h.html#a78">SPF_close</a>(p);
00259 
00260     <span class="keywordflow">return</span>(NULL);
00261   }
00262 
00263    <span class="comment">/* </span>
00264 <span class="comment">   * 'ip_ver' is the Internet Address protocol version being used</span>
00265 <span class="comment">   * at any given time during an SPF parse.  Whilst this is intended to </span>
00266 <span class="comment">   * support IPv6 at this time it is hard set to IPv4 (AF_INET)</span>
00267 <span class="comment">  */</span>
00268   snprintf(p-&gt;<a class="code" href="structpeer__info__s.html#o20">ip_ver</a>, <a class="code" href="spf_8h.html#a11">SPF_MAX_IP_ADDR</a>, <span class="stringliteral">"in-addr"</span>);
00269 
00270    <span class="comment">/*</span>
00271 <span class="comment">   * Obtain the number of seconds since the UNIX Epoch or UTC time</span>
00272 <span class="comment">   * which we may optionally be used when pre-pending the Received-SPF</span>
00273 <span class="comment">   * header after an SPF parse</span>
00274 <span class="comment">  */</span>
00275   cur_utc_time = <a class="code" href="util_8h.html#a4">xmalloc</a>(<a class="code" href="util_8h.html#a1">SPF_MAX_DATETIME</a>);
00276   snprintf(cur_utc_time, <a class="code" href="util_8h.html#a1">SPF_MAX_DATETIME</a>, <span class="stringliteral">"%lu"</span>, time(&amp;curtime));
00277   memcpy(p-&gt;<a class="code" href="structpeer__info__s.html#o22">utc_time</a>, cur_utc_time, <a class="code" href="util_8h.html#a1">SPF_MAX_DATETIME</a>);
00278   <a class="code" href="util_8h.html#a6">xfree</a>(cur_utc_time);
00279 
00280    <span class="comment">/*</span>
00281 <span class="comment">   * As per the SPF RFC, localhost shall always be considered exempt from</span>
00282 <span class="comment">   * any SPF checks.  There is no facility to override this, nor should</span>
00283 <span class="comment">   * you.</span>
00284 <span class="comment">  */</span>
00285   <span class="keywordflow">if</span> ((strcmp(rip, <span class="stringliteral">"127.0.0.1"</span>) == 0) || (strcmp(rip, <span class="stringliteral">"localhost"</span>) == 0))
00286   {
00287     <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>, NULL);
00288   }
00289   <span class="keywordflow">else</span>
00290   {
00291     <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a56">SPF_NEUTRAL</a>, NULL);
00292   }
00293 
00294   <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"libspf initialized succesfully. (%i bytes allocated)\n"</span>,
00295     <a class="code" href="util_8h.html#a3">SIZEOF</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a>));
00296 
00297   <span class="keywordflow">return</span>(p);
00298 }
00299 
00300 
00301 <span class="comment">/* SPF_close</span>
00302 <span class="comment">*</span>
00303 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
00304 <span class="comment">*</span>
00305 <span class="comment">*  Date: 12/25/03</span>
00306 <span class="comment">*</span>
00307 <span class="comment">*  Desc:</span>
00308 <span class="comment">*       Free memory associated with passed peer_info_t structure.</span>
00309 <span class="comment">*  p _MUST_ be nulled, checks in the various MTA code rely</span>
00310 <span class="comment">*  on it to be NULL for various checks.</span>
00311 <span class="comment">*</span>
00312 <span class="comment">*/</span>
<a name="l00313"></a><a class="code" href="spf_8h.html#a78">00313</a> <a class="code" href="structpeer__info__s.html">peer_info_t</a> *<a class="code" href="spf_8h.html#a78">SPF_close</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p)
00314 {
00315   <span class="keywordflow">if</span> (p == NULL)
00316   {
00317     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"peer structure null.  Aborting!\n"</span>);
00318 
00319     <span class="keywordflow">return</span>(NULL);
00320   }
00321 
00322   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>);
00323   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>);
00324   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
00325   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>);
00326   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>);
00327   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o14">ptr_mhost</a>);
00328   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o19">cur_eaddr</a>);
00329   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o13">trusted</a>);
00330   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o12">guess</a>);
00331   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o11">explain</a>);
00332   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o18">r_vhname</a>);
00333 
00334   <a class="code" href="util_8h.html#a6">xfree</a>(p);
00335   p = NULL;
00336 
00337   <span class="keywordflow">return</span>(p);
00338 }
00339 
00340 
00341 <span class="comment">/* SPF_policy_main</span>
00342 <span class="comment">*</span>
00343 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
00344 <span class="comment">*</span>
00345 <span class="comment">*  Date:   12/10/03</span>
00346 <span class="comment">*  Date:   01/24/04 by James &lt;jcouzens@codeshare.ca&gt;</span>
00347 <span class="comment">*  Date:   05/02/04 by Teddy &lt;teddy@teddy.ch&gt;</span>
00348 <span class="comment">*</span>
00349 <span class="comment">*  Desc:</span>
00350 <span class="comment">*          This calls only the recursive version SPF_policy_main.</span>
00351 <span class="comment">*  In earlier versions, SPF_policy_main was not able to handle CNAME</span>
00352 <span class="comment">*</span>
00353 <span class="comment">*/</span>
00354 <span class="comment">/*</span>
00355 <span class="comment">SPF_RESULT SPF_policy_main(peer_info_t *p)</span>
00356 <span class="comment">{</span>
00357 <span class="comment">  return(SPF_policy_main(p, 0));</span>
00358 <span class="comment">}</span>
00359 <span class="comment">*/</span>
00360 
00361 
00362 <span class="comment">/* SPF_policy_main</span>
00363 <span class="comment">*</span>
00364 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
00365 <span class="comment">*</span>
00366 <span class="comment">*  Date:   09/08/04 by James &lt;jcouzens@codeshare.ca&gt;</span>
00367 <span class="comment">*</span>
00368 <span class="comment">*  Desc:</span>
00369 <span class="comment">*          This is the primary SPF function from which effectively all underlying</span>
00370 <span class="comment">*  operation of the library is manipulated.  Passed a 'peer_info_t' structure when</span>
00371 <span class="comment">*  properly populated DNS queries of T_TXT and T_CNAME are made to obtain and </span>
00372 <span class="comment">*  recusrively follow SPF records through DNS up to a limit hard set through</span>
00373 <span class="comment">*  the macro 'SPF_MAX_RECURSE'.</span>
00374 <span class="comment">*</span>
00375 <span class="comment">*  As per the RFC 'include' and 'redirect' are cached until all other mechanisms</span>
00376 <span class="comment">*  and modifiers of a particular SPF query are exhausted before being attempted</span>
00377 <span class="comment">*  as they are the most expensive SPF operations.</span>
00378 <span class="comment">*</span>
00379 <span class="comment">*  Returns 'SPF_RESULT' which describes the overall outcome of however many </span>
00380 <span class="comment">*  actual parses may have been involved.  Based on this outcome the calling</span>
00381 <span class="comment">*  function is expected to further call SPF_build_header and SPF_get_explain,</span>
00382 <span class="comment">*  and finally SPF_close to finalize their SPF query.</span>
00383 <span class="comment">*</span>
00384 <span class="comment">*  SPF return types are often represented by single characters however not all</span>
00385 <span class="comment">*  SPF_RESULT return types may be references this way.  The characters are</span>
00386 <span class="comment">*  as follows:</span>
00387 <span class="comment">*</span>
00388 <span class="comment">*  '+' - SPF_PASS      (pass)</span>
00389 <span class="comment">*  '-' - SPF_HARD_FAIL (fail)</span>
00390 <span class="comment">*  '~' - SPF_SOFT_FAIL (softfail)</span>
00391 <span class="comment">*  '?' - SPF_NEUTRAL   (neutral)</span>
00392 <span class="comment">*</span>
00393 <span class="comment">*  These chars and default error messages related to them are all managed</span>
00394 <span class="comment">*  through the structure spf_result_t so if you wish to modify them</span>
00395 <span class="comment">*  you will need to seek out the various macro's that are referenced</span>
00396 <span class="comment">*  through this structure (which is declared within the SPF_init function).</span>
00397 <span class="comment">*</span>
00398 <span class="comment">*/</span>
<a name="l00399"></a><a class="code" href="spf_8h.html#a79">00399</a> <a class="code" href="spf_8h.html#a36">SPF_RESULT</a> <a class="code" href="spf_8h.html#a79">SPF_policy_main</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p)
00400 {
00401   <a class="code" href="spf_8h.html#a36">SPF_RESULT</a> res;               <span class="comment">/* result of an SPF parse */</span>
00402 
00403   <span class="keywordtype">char</span> *tmp          = NULL;    <span class="comment">/* temporary pointer */</span>
00404   <span class="keywordtype">char</span> *cname_buf    = NULL;    <span class="comment">/* tmp cname placeholder */</span>
00405   <span class="keywordtype">char</span> *include_buf  = NULL;    <span class="comment">/* tmp include placeholder */</span>
00406   <span class="keywordtype">char</span> *redirect_buf = NULL;    <span class="comment">/* tmp redirect placeholder */</span>
00407 
00408 
00409   <span class="keywordflow">if</span> (p == NULL)
00410   {
00411     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"Unable to continue with a NULL peer_info_t structure!\n"</span>);
00412 
00413     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>);
00414   }
00415 
00416   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a> &gt;= <a class="code" href="main_8h.html#a8">SPF_MAX_RECURSE</a>)
00417   {
00418     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"recursion level exceeded (%u) levels; Aborting.\n"</span>, 
00419       p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a>);
00420 
00421     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>);
00422   }
00423 
00424   <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"[%i] current domain: (%s)\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>);
00425   <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"[%i] include buffer: (%s)\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a>);
00426   <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"[%i] redirect buffer: (%s)\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>);
00427   
00428   <span class="comment">/* increment recursion count */</span>
00429   p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a>++;
00430 
00431    <span class="comment">/*</span>
00432 <span class="comment">   * ensure that our buffer placeholders are clean within our</span>
00433 <span class="comment">   * peer_info_t structure otherwise you will get exceptionally</span>
00434 <span class="comment">   * negative and unpredictable results from the rest of this </span>
00435 <span class="comment">   * function!</span>
00436 <span class="comment">  */</span>
00437   <a class="code" href="main_8c.html#a2">_SPF_clear_holdbufs</a>(p);
00438 
00439   <span class="comment">/* fire off a peer_info_t structure for an SPF policy parse */</span>
00440   res = <a class="code" href="spf_8h.html#a80">SPF_policy_main_rec</a>(p);
00441 
00442   <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"result of SPF parse is %i\n"</span>, res); 
00443 
00444   <span class="comment">/* store these here for now, we'll take them back in a moment */</span>
00445   cname_buf    = p-&gt;<a class="code" href="structpeer__info__s.html#o28">cname_buf</a>;
00446   include_buf  = p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a>;
00447   redirect_buf = p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>;
00448 
00449   <span class="comment">/* play it safe */</span>
00450   p-&gt;<a class="code" href="structpeer__info__s.html#o28">cname_buf</a>     = NULL;
00451   p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a>   = NULL;
00452   p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>  = NULL;
00453 
00454   <span class="keywordflow">if</span> (res != <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>)
00455   {
00456     <span class="comment">/* store this here for now, we'll take it back in a moment */</span>
00457     tmp = p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>;
00458 
00459     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"tmp is holding the current domain: (%s)\n"</span>, tmp);
00460 
00461      <span class="comment">/*</span>
00462 <span class="comment">     * First the CNAME is looked at, and separate from the 'include'</span>
00463 <span class="comment">     * and 'redirect' buffer placeholders because its not possible</span>
00464 <span class="comment">     * to have either 'include' or 'redirect' if you have a CNAME!</span>
00465 <span class="comment">    */</span> 
00466     <span class="keywordflow">if</span> (cname_buf != NULL)
00467     {
00468       p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a> = cname_buf;
00469 
00470       <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Current domain: (%s); CNAME Buffer: (%s)\n"</span>,
00471         p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>, cname_buf);
00472 
00473       res = <a class="code" href="spf_8h.html#a79">SPF_policy_main</a>(p);
00474     }
00475     <span class="keywordflow">else</span>
00476     {
00477        <span class="comment">/*</span>
00478 <span class="comment">       * In the event that during our original parse we happend</span>
00479 <span class="comment">       * upon either the 'include' or 'redirect' markers, we would</span>
00480 <span class="comment">       * have saved their contents in the placeholder buffer within</span>
00481 <span class="comment">       * the peer_info_t structure until after the entire other </span>
00482 <span class="comment">       * items within the SPF language have been exhausted.  Once</span>
00483 <span class="comment">       * this has taken place we perform a brand new parse with the</span>
00484 <span class="comment">       * contents of either of the two buffers shouldl they have</span>
00485 <span class="comment">       * any data.</span>
00486 <span class="comment">      */</span>
00487       <span class="keywordflow">if</span> (include_buf != NULL)
00488       {
00489         p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a> = include_buf;
00490 
00491         <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"current domain is now (%s) from INCLUDE\n"</span>,
00492           p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>);
00493 
00494         res = <a class="code" href="spf_8h.html#a79">SPF_policy_main</a>(p);
00495      
00496         <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"result of SPF parse was %i\n"</span>, res);
00497 
00498          <span class="comment">/*</span>
00499 <span class="comment">         * this is quick hack and should go somewhere else but I</span>
00500 <span class="comment">         * don't have time to do that right now.  If an include</span>
00501 <span class="comment">         * results in SPF_NONE then the RFC states we must return</span>
00502 <span class="comment">         * 'unknown'</span>
00503 <span class="comment">        */</span>
00504         <span class="keywordflow">if</span> (res == <a class="code" href="spf_8h.html#a88a52">SPF_NONE</a>)
00505         {
00506           <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"INCLUDE resulted in SPF_NONE, returning UNKNOWN\n"</span>);
00507           res = <a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>;
00508           <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>, NULL);
00509         }
00510       }
00511 
00512        <span class="comment">/*</span>
00513 <span class="comment">       * The 'include_buf' induced SPF parse may have resulted in</span>
00514 <span class="comment">       * an SPF_PASS result.  In the event that it didn't we then</span>
00515 <span class="comment">       * examine the 'redirect_buf' and send it off if necessary</span>
00516 <span class="comment">       * trying again with a brand new SPF query (effectively).</span>
00517 <span class="comment">      */</span>
00518       <span class="keywordflow">if</span> ((res != <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>) &amp;&amp; (redirect_buf != NULL))
00519       {
00520         <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"found a redirect buffer with valid data (%s)\n"</span>, 
00521           redirect_buf);
00522 
00523         p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a> = redirect_buf;
00524 
00525         <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"current domain is now: (%s) from REDIRECT\n"</span>,
00526           p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>);
00527 
00528         res = <a class="code" href="spf_8h.html#a79">SPF_policy_main</a>(p);
00529 
00530         <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"result of SPF parse was %i\n"</span>, res);
00531       }
00532     }
00533 
00534     <span class="comment">/* reset our original domain */</span>
00535     p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a> = tmp;
00536 
00537     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"current domain is now: (%s); received back from tmp\n"</span>,
00538       p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>);
00539   }
00540 
00541   <span class="comment">/* place the old values back into our peer_info_t structure */</span>
00542   p-&gt;<a class="code" href="structpeer__info__s.html#o28">cname_buf</a>     = cname_buf;
00543   p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a>   = include_buf;
00544   p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>  = redirect_buf;
00545 
00546   <a class="code" href="main_8c.html#a2">_SPF_clear_holdbufs</a>(p);
00547 
00548   <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"leaving function; returning with value: (%i)\n"</span>, res);
00549 
00550   <span class="keywordflow">return</span>(res);
00551 }
00552 
00553 
00554 
00555 <span class="comment">/* SPF_policy_main</span>
00556 <span class="comment">*</span>
00557 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
00558 <span class="comment">*</span>
00559 <span class="comment">*  Date:    12/10/03</span>
00560 <span class="comment">*  Date:    01/24/04 by James &lt;jcouzens@codeshare.ca&gt;</span>
00561 <span class="comment">*  Date:    05/02/04 by Teddy &lt;teddy@teddy.ch&gt;</span>
00562 <span class="comment">*</span>
00563 <span class="comment">*  Desc:</span>
00564 <span class="comment">*          Fetches the SERVER_POLICY records from the FQDN's NS server</span>
00565 <span class="comment">*  and returns an SPF_RESULT enumeration indicating the level of</span>
00566 <span class="comment">*  compliance with an SPF policy (match, fail, error etc.. see spf.h)</span>
00567 <span class="comment">*  Recursion inserted by Teddy</span>
00568 <span class="comment">*</span>
00569 <span class="comment">*/</span>
<a name="l00570"></a><a class="code" href="spf_8h.html#a80">00570</a> <a class="code" href="spf_8h.html#a36">SPF_RESULT</a> <a class="code" href="spf_8h.html#a80">SPF_policy_main_rec</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p)
00571 {
00572   <a class="code" href="spf_8h.html#a36">SPF_RESULT</a> res = <a class="code" href="spf_8h.html#a88a56">SPF_NEUTRAL</a>;   <span class="comment">/* SPF parse result */</span>
00573   <span class="keywordtype">char</span> *rr_data  = NULL;          <span class="comment">/* record */</span>
00574 
00575 
00576   <span class="keywordflow">if</span> (p == NULL)
00577   {
00578     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"Error peer structure is NULL.  Aborting\n"</span>);
00579 
00580     <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a55">SPF_ERROR</a>, NULL);
00581     
00582 <span class="preprocessor">#ifdef _SPF_LOGFILE_STATS</span>
00583 <span class="preprocessor"></span>    <a class="code" href="util_8h.html#a31">UTIL_log_result</a>(p);
00584 <span class="preprocessor">#endif </span><span class="comment">/* _SPF_LOGFILE_STATS */</span>
00585    
00586 
00587     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"leaving function; returning SPF_ERROR\n"</span>);
00588 
00589     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a88a55">SPF_ERROR</a>);
00590   }
00591   <span class="keywordflow">else</span> <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o26">addr</a>.s_addr &lt;= 0)
00592   {
00593     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"Error no idea who the remote peer is.  Abort!\n"</span>);
00594 
00595     <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a55">SPF_ERROR</a>, NULL);
00596     
00597 <span class="preprocessor">#ifdef _SPF_LOGFILE_STATS</span>
00598 <span class="preprocessor"></span>    <a class="code" href="util_8h.html#a31">UTIL_log_result</a>(p);
00599 <span class="preprocessor">#endif </span><span class="comment">/* _SPF_LOGFILE_STATS */</span>
00600 
00601     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"leaving function; returning SPF_ERROR\n"</span>);
00602 
00603     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a88a55">SPF_ERROR</a>);
00604   }
00605 
00606    <span class="comment">/*</span>
00607 <span class="comment">   * As is stated in SPF_init, localhost is always exempt from SPF</span>
00608 <span class="comment">   * checks.  A check for this was done in SPF_init and to keep</span>
00609 <span class="comment">   * actions being brought about by the proper functions p-&gt;RES</span>
00610 <span class="comment">   * would have been intentionally set to SPF_PASS and we check</span>
00611 <span class="comment">   * for that here.</span>
00612 <span class="comment">  */</span>
00613   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a> == <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>)
00614   {
00615 <span class="preprocessor">#ifdef _SPF_LOGFILE_STATS</span>
00616 <span class="preprocessor"></span>    <a class="code" href="util_8h.html#a31">UTIL_log_result</a>(p);
00617 <span class="preprocessor">#endif </span><span class="comment">/* _SPF_LOGFILE_STATS */</span>
00618 
00619     <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"localhost exempt from SPF checks; returning SPF_PASS\n"</span>);
00620 
00621     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>);
00622   }
00623 
00624   <span class="keywordflow">if</span> ((rr_data = <a class="code" href="dns_8h.html#a8">DNS_query</a>(p, p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>, T_TXT, NULL)) != NULL)
00625   {
00626     <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"DNS_query returned with answer: (%s)\n"</span>, rr_data);
00627 
00628     <a class="code" href="spf_8h.html#a81">SPF_parse_policy</a>(p, rr_data);
00629 
00630     <a class="code" href="util_8h.html#a6">xfree</a>(rr_data);
00631   }
00632   <span class="keywordflow">else</span> <span class="keywordflow">if</span> ((rr_data = <a class="code" href="dns_8h.html#a8">DNS_query</a>(p, p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>, T_CNAME, NULL)) != NULL)
00633   {
00634     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"domain (%s) is CNAME of (%s). Restarting SPF_policy_main."</span>,
00635       p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>, rr_data);
00636 
00637     <span class="comment">/* store the result of the CNAME lookup in the CNAME buf */</span>
00638     p-&gt;<a class="code" href="structpeer__info__s.html#o28">cname_buf</a> = rr_data;
00639   } <span class="comment">/* if rr_data */</span>
00640 
00641    <span class="comment">/*</span>
00642 <span class="comment">   * If either of the three placeholder buffers have anything in</span>
00643 <span class="comment">   * them check the peer_info_t structure for an SPF parse result</span>
00644 <span class="comment">   * and return it.</span>
00645 <span class="comment">  */</span>
00646   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o28">cname_buf</a> || p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> || p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>)
00647   {
00648     <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a> != <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>)
00649     {
00650       <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"leaving function; returning (%i)\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>);
00651 
00652       <span class="keywordflow">return</span>(p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>);
00653     }
00654   }
00655 
00656    <span class="comment">/*</span>
00657 <span class="comment">   *  this is intentionally outside of the above statements so it can be</span>
00658 <span class="comment">   *  called if the user has decided to implement best guess but has</span>
00659 <span class="comment">   *  disabled trusted forwarder.</span>
00660 <span class="comment">  */</span>
00661   <span class="keywordflow">if</span> ((p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a> != <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>) &amp;&amp; (p-&gt;<a class="code" href="structpeer__info__s.html#o3">use_trust</a> == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>))
00662   {
00663     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Error obtaining record, trying Trusted Fwdr (%s)\n"</span>,
00664       p-&gt;<a class="code" href="structpeer__info__s.html#o13">trusted</a>);
00665 
00666     res = <a class="code" href="spf_8h.html#a81">SPF_parse_policy</a>(p, p-&gt;<a class="code" href="structpeer__info__s.html#o13">trusted</a>);
00667 
00668     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"SPF_parse_policy returned %i\n"</span>, res);
00669   }
00670 
00671   <span class="keywordflow">if</span> ((p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a> != <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>) &amp;&amp; (p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> || p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>))
00672   {
00673     <span class="keywordflow">return</span>(p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>);
00674   }
00675 
00676   <span class="keywordflow">if</span> ((p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a> != <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>) &amp;&amp; (p-&gt;<a class="code" href="structpeer__info__s.html#o4">use_guess</a> == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>))
00677   {
00678     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Attempting a best guess effort as a last resort "</span>
00679       <span class="stringliteral">"using: (%s)\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o12">guess</a>);
00680 
00681     res = <a class="code" href="spf_8h.html#a81">SPF_parse_policy</a>(p, p-&gt;<a class="code" href="structpeer__info__s.html#o12">guess</a>);
00682 
00683     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"SPF_parse_policy returned %i\n"</span>, res);
00684   }
00685 
00686   <span class="keywordflow">if</span> ((p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a> != <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>) &amp;&amp; (p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> || p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>))
00687   {
00688     <span class="keywordflow">return</span>(p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>);
00689   }
00690 
00691   <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"Return policy %i on mech: (%s) with outcome: (%s)\n"</span>,
00692     p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o23">last_m</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o7">rs</a>);
00693 
00694   <span class="comment">/*</span>
00695 <span class="comment">   * If logging is enabled this will write to a statistics log </span>
00696 <span class="comment">   * at (by default) /var/log/spflog.txt where you can over time</span>
00697 <span class="comment">   * get a good idea of how SPF performs on your network.</span>
00698 <span class="comment">   *</span>
00699 <span class="comment">  */</span>
00700 <span class="preprocessor">#ifdef _SPF_LOGFILE_STATS</span>
00701 <span class="preprocessor"></span>    <a class="code" href="util_8h.html#a31">UTIL_log_result</a>(p);
00702 <span class="preprocessor">#endif </span><span class="comment">/* _SPF_LOGFILE_STATS */</span>
00703 
00704   <span class="keywordflow">return</span>(p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>);
00705 }
00706 
00707 
00708 <span class="comment">/*  SPF_parse_policy</span>
00709 <span class="comment">*</span>
00710 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
00711 <span class="comment">*</span>
00712 <span class="comment">*  Date:   12/19/03</span>
00713 <span class="comment">*</span>
00714 <span class="comment">*  Desc:</span>
00715 <span class="comment">*          Parses the passed 'policy' and interprets the policies</span>
00716 <span class="comment">*  contained within it to decide if based on various comparisons against</span>
00717 <span class="comment">*  r_ip (remote peer's ipaddress) whether or not it meets the SPF</span>
00718 <span class="comment">*  policy.</span>
00719 <span class="comment">*</span>
00720 <span class="comment">*/</span>
<a name="l00721"></a><a class="code" href="spf_8h.html#a81">00721</a> <a class="code" href="spf_8h.html#a35">SPF_BOOL</a> <a class="code" href="spf_8h.html#a81">SPF_parse_policy</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p, <span class="keyword">const</span> <span class="keywordtype">char</span> *policy)
00722 {
00723   <a class="code" href="spf_8h.html#a38">SPF_MECHANISM</a> POLICY_TYPE;    <span class="comment">/* SPF policy mechanism type */</span>
00724 
00725   <a class="code" href="spf_8h.html#a36">SPF_RESULT</a> PREFIX_TYPE;       <span class="comment">/* SPF mechanism prefix type */</span>
00726 
00727   <a class="code" href="spf_8h.html#a35">SPF_BOOL</a> POLICY_MATCH;        <span class="comment">/* T / F on a policy match */</span>
00728   <a class="code" href="spf_8h.html#a35">SPF_BOOL</a> POLICY_ERROR;        <span class="comment">/* T / F for errors to return early */</span>
00729 
00730   int16_t pos;                  <span class="comment">/* position in the policy */</span>
00731   int16_t s_pos;                <span class="comment">/* position in a policy token */</span>
00732 
00733   size_t p_len;                 <span class="comment">/* length of passed policy string */</span>
00734 
00735   <span class="keywordtype">char</span> *copy;                   <span class="comment">/* storage container for passed policy */</span>
00736   <span class="keywordtype">char</span> *cp;                     <span class="comment">/* working pointer to passed policy */</span>
00737 
00738   <span class="keywordtype">char</span> *token;                  <span class="comment">/* token pointer to piece of policy */</span>
00739   <span class="keywordtype">char</span> *token_ptr;              <span class="comment">/* working pointer for token */</span>
00740 
00741   <span class="keywordtype">char</span> *tmp_ptr;                <span class="comment">/* temporary utility pointer */</span>
00742   <span class="keywordtype">char</span> *tmp_ptr2;               <span class="comment">/* 2nd temporary utility pointer */</span>
00743   <span class="keywordtype">char</span> *macro;                  <span class="comment">/* expanded macro storage container */</span>
00744 
00745   <span class="comment">/* include */</span>
00746   <a class="code" href="structpeer__info__s.html">peer_info_t</a> *i_p;             <span class="comment">/* copy of p with replaced domain */</span>
00747 
00748   <a class="code" href="structpolicy__addr__s.html">policy_addr_t</a> *policy_ip;     <span class="comment">/* ip address of a policy record */</span>
00749 
00750 
00751   POLICY_MATCH    = <a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>;
00752   POLICY_ERROR    = <a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>;
00753   PREFIX_TYPE     = <a class="code" href="spf_8h.html#a88a56">SPF_NEUTRAL</a>;
00754 
00755   policy_ip       = NULL;
00756   i_p             = NULL;
00757   pos             = 0;
00758   token           = NULL;
00759   token_ptr       = NULL;
00760   macro           = NULL;
00761 
00762   <span class="keywordflow">if</span> ((policy == NULL) || (p == NULL))
00763   {
00764     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"Unable to continue called with NULL structure\n"</span>);
00765 
00766     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
00767   }
00768 
00769   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a> &gt;= <a class="code" href="main_8h.html#a8">SPF_MAX_RECURSE</a>)
00770   {
00771     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"recursion breach (%i levels); Terminated.\n"</span>,
00772       p-&gt;<a class="code" href="structpeer__info__s.html#o27">spf_rlevel</a>);
00773 
00774     snprintf(p-&gt;<a class="code" href="structpeer__info__s.html#o24">error</a>, <a class="code" href="spf_8h.html#a16">SPF_MAX_ERROR</a>, <span class="stringliteral">"Recursion loop, terminated."</span>);
00775     <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>, NULL);
00776 
00777     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
00778   }
00779 
00780   p_len = strlen(policy);
00781 
00782   <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"about to parse (%s) of len: %i (%s)\n"</span>,
00783     policy, p_len, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>].s);
00784 
00785   <span class="comment">/* allocate memory and assign working pointer for policy */</span>
00786   cp = copy = <a class="code" href="util_8h.html#a8">xstrndup</a>(policy, (p_len + 1));
00787 
00788   <span class="comment">/* loops through the entire policy string until its exhausted */</span>
00789   <span class="keywordflow">while</span> (*cp)
00790   {
00791     <span class="comment">/* skip white space */</span>
00792     <span class="keywordflow">while</span> ((*cp == <span class="charliteral">' '</span>) &amp;&amp; (*(cp + 1) == <span class="charliteral">' '</span>))
00793     {
00794       cp++;
00795     } 
00796     pos = <a class="code" href="util_8h.html#a35">UTIL_index</a>(cp, <span class="charliteral">' '</span>);
00797 
00798     <span class="keywordflow">if</span> (!*(cp + 1))
00799     {
00800       <a class="code" href="util_8h.html#a6">xfree</a>(copy);
00801       <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"leaving function; nothing more to parse, returning SPF_TRUE\n"</span>);
00802 
00803       <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>);
00804     }
00805 
00806     token     = <a class="code" href="util_8h.html#a8">xstrndup</a>(cp, (pos + 1));
00807     token_ptr = token;
00808     s_pos     = 0;
00809 
00810     <span class="comment">/* look for a mechanism modifier prefix */</span>
00811     <span class="keywordflow">if</span> (<a class="code" href="util_8h.html#a40">UTIL_is_spf_result</a>(*token_ptr) ||
00812       (strncmp(token_ptr, <span class="stringliteral">"default"</span>, 7) == 0))
00813     {
00814       PREFIX_TYPE = <a class="code" href="util_8h.html#a46">UTIL_get_mech_prefix</a>(p, token_ptr);
00815       snprintf(p-&gt;<a class="code" href="structpeer__info__s.html#o23">last_m</a>, <a class="code" href="spf_8h.html#a20">SPF_MAX_MECHANISM</a>, <span class="stringliteral">"%s"</span>, token_ptr);
00816 
00817       <span class="keywordflow">if</span>  (*token_ptr != <span class="charliteral">'d'</span>)
00818       {
00819         <span class="comment">/* move ahead one because a prefix was specified */</span>
00820         token_ptr++;
00821       }
00822     }
00823     <span class="keywordflow">else</span>
00824     {
00825       snprintf(p-&gt;<a class="code" href="structpeer__info__s.html#o23">last_m</a>, <a class="code" href="spf_8h.html#a20">SPF_MAX_MECHANISM</a>, <span class="stringliteral">"%s"</span>, token_ptr);
00826       PREFIX_TYPE = <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>;
00827     }
00828 
00829     <span class="comment">/* figure out what sort of mechanism we're working with */</span>
00830     POLICY_TYPE = <a class="code" href="util_8h.html#a45">UTIL_get_policy_mech</a>(token_ptr);
00831 
00832     <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"SPF Policy Mechanism: %i (token: %s) (pos: %i)\n"</span>,
00833       POLICY_TYPE, token_ptr, pos);
00834 
00835     <span class="keywordflow">switch</span> (POLICY_TYPE)
00836     {
00837 
00838        <span class="comment">/*</span>
00839 <span class="comment">       *  no policy set</span>
00840 <span class="comment">      */</span>
00841       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a63">NO_POLICY</a>:
00842         <span class="keywordflow">break</span>;
00843 
00844        <span class="comment">/*</span>
00845 <span class="comment">       *  unrecognized mechanism</span>
00846 <span class="comment">      */</span>
00847       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a76">UNMECH</a>:
00848         <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a58">SPF_UNMECH</a>, NULL);
00849 
00850         <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Unrecognized mechanism (%s); returning SPF_FALSE\n"</span>, token);
00851 
00852         <a class="code" href="util_8h.html#a6">xfree</a>(token);
00853         <a class="code" href="util_8h.html#a6">xfree</a>(copy);
00854 
00855         <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
00856 
00857        <span class="comment">/*</span>
00858 <span class="comment">       *  'version' mechanism </span>
00859 <span class="comment">      */</span>
00860       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a64">VERSION</a>:
00861         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is version (%s)\n"</span>, token_ptr);
00862 
00863         <span class="keywordflow">if</span> ((s_pos = <a class="code" href="util_8h.html#a35">UTIL_index</a>(token_ptr, <span class="charliteral">'='</span>)) &gt; 0)
00864         {
00865           token_ptr += s_pos + 4; <span class="comment">/* skip =spf */</span>
00866 
00867           <span class="keywordflow">if</span> (atoi(token_ptr) &gt; <a class="code" href="spf_8h.html#a1">SPF_VERSION</a>)
00868           {
00869             <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a52">SPF_NONE</a>, NULL);
00870 
00871             <a class="code" href="util_8h.html#a6">xfree</a>(token);
00872             <a class="code" href="util_8h.html#a6">xfree</a>(copy);
00873 
00874             <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
00875           }
00876 
00877           p-&gt;<a class="code" href="structpeer__info__s.html#o5">spf_ver</a> = atoi(token_ptr);
00878 
00879           <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"SPF Version defined as: %u\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o5">spf_ver</a>);
00880         }
00881         <span class="keywordflow">else</span>
00882         {
00883            <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"SPF version redefined! (%u)\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o5">spf_ver</a>);
00884            <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a53">SPF_S_FAIL</a>, NULL);
00885 
00886            <a class="code" href="util_8h.html#a6">xfree</a>(token);
00887            <a class="code" href="util_8h.html#a6">xfree</a>(copy);
00888 
00889            <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
00890         }
00891 
00892         <span class="keywordflow">break</span>;
00893 
00894        <span class="comment">/*</span>
00895 <span class="comment">       *  'all' mechanism</span>
00896 <span class="comment">      */</span>
00897       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a65">ALL</a>:
00898         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is all (%s) policy: (%i)\n"</span>,
00899           token_ptr, POLICY_TYPE);
00900 
00901         <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, PREFIX_TYPE, NULL);
00902         POLICY_MATCH = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
00903         p-&gt;<a class="code" href="structpeer__info__s.html#o0">ALL</a>       = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
00904 
00905         <span class="keywordflow">break</span>;
00906 
00907        <span class="comment">/*</span>
00908 <span class="comment">       *  'default' policy</span>
00909 <span class="comment">      */</span>
00910       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a75">DEFAULT</a>:
00911         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is default (%s) policy: (%i)\n"</span>,
00912           token_ptr, POLICY_TYPE);
00913 
00914         POLICY_MATCH = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
00915         p-&gt;<a class="code" href="structpeer__info__s.html#o0">ALL</a>       = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
00916 
00917         <span class="keywordflow">break</span>;
00918 
00919        <span class="comment">/*</span>
00920 <span class="comment">       *  'include' mechanism </span>
00921 <span class="comment">      */</span>
00922       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a66">INCLUDE</a>:
00923         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is include (%s)\n"</span>, token_ptr);
00924 
00925         <span class="keywordflow">if</span> ((tmp_ptr = strstr(token_ptr, <span class="stringliteral">":"</span>)) != NULL)
00926         {
00927           tmp_ptr++;
00928 
00929           <span class="keywordflow">if</span> (<a class="code" href="util_8h.html#a41">UTIL_is_macro</a>(tmp_ptr) == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>)
00930           {
00931             <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"this INCLUDE mechanism contained macros (%s)\n"</span>, tmp_ptr);
00932 
00933             <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> == NULL)
00934             {
00935               <span class="keywordflow">if</span> ((macro = <a class="code" href="macro_8h.html#a1">MACRO_expand</a>(p, tmp_ptr)) != NULL)
00936               {
00937                 p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(macro, <a class="code" href="spf_8h.html#a5">SPF_MAX_STR</a>);
00938 
00939                 <a class="code" href="util_8h.html#a6">xfree</a>(macro);
00940               }
00941             }
00942             <span class="keywordflow">else</span>
00943             {
00944               <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Got include=%s, but include already set. Ignoring.\n"</span>,
00945                 tmp_ptr);
00946             }
00947           }
00948           <span class="keywordflow">else</span>
00949           {
00950             <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"storing INCLUDE (%s) for later...\n"</span>, tmp_ptr);
00951 
00952             <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> == NULL)
00953             {
00954               p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(tmp_ptr, <a class="code" href="spf_8h.html#a5">SPF_MAX_STR</a>);
00955             }
00956             <span class="keywordflow">else</span>
00957             {
00958               <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Got include=%s, but include already set. Ignoring.\n"</span>,
00959                 tmp_ptr);
00960             }
00961           }
00962         }
00963         <span class="keywordflow">else</span>
00964         {
00965           <span class="comment">/* 'include' with no options returns unknown */</span>
00966           POLICY_MATCH = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
00967           <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>, token_ptr);
00968 
00969           <a class="code" href="util_8h.html#a6">xfree</a>(token);
00970           <a class="code" href="util_8h.html#a6">xfree</a>(copy);
00971 
00972           <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>);
00973         }
00974         <span class="keywordflow">break</span>;
00975 
00976        <span class="comment">/*</span>
00977 <span class="comment">       *  'a' mechanism</span>
00978 <span class="comment">      */</span>
00979       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a67">A</a>:
00980         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is A (%s)\n"</span>, token_ptr);
00981 
00982         <span class="keywordflow">if</span> ((tmp_ptr = strstr(token_ptr, <span class="stringliteral">"/"</span>)) != NULL)
00983         {
00984           tmp_ptr++;
00985           POLICY_MATCH = <a class="code" href="util_8h.html#a43">UTIL_a_cmp</a>(p, token_ptr, atoi(tmp_ptr));
00986         }
00987         <span class="keywordflow">else</span>
00988         {
00989           POLICY_MATCH = <a class="code" href="util_8h.html#a43">UTIL_a_cmp</a>(p, token_ptr, 32);
00990         }
00991 
00992         <span class="comment">/* mechanism was supplied with a - indicating a failure on */</span>
00993         <span class="keywordflow">if</span> ((PREFIX_TYPE == <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>) &amp;&amp; (POLICY_MATCH == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>))
00994         {
00995           <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"Found a match on a negative prefix.  Halting parse.\n"</span>);
00996           <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>, token_ptr);
00997 
00998           <a class="code" href="util_8h.html#a6">xfree</a>(token);
00999           <a class="code" href="util_8h.html#a6">xfree</a>(copy);
01000 
01001           <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
01002         }
01003 
01004         <span class="keywordflow">break</span>;
01005 
01006        <span class="comment">/*</span>
01007 <span class="comment">       *  'mx' mechanism</span>
01008 <span class="comment">      */</span>
01009       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a68">MX</a>:
01010         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is mx (%s)\n"</span>, token_ptr);
01011 
01012         <span class="comment">/* we've been supplied an MX to use instead.. grab it */</span>
01013         <span class="comment">/* use tmp_ptr2 so we can use tmp_ptr again */</span>
01014         <span class="keywordflow">if</span> ((tmp_ptr = strstr(token_ptr, <span class="stringliteral">":"</span>)) != NULL)
01015         {
01016           tmp_ptr++;
01017           tmp_ptr2 = tmp_ptr;
01018         }
01019         <span class="keywordflow">else</span>
01020         {
01021           tmp_ptr2 = p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>;
01022         }
01023 
01024         <span class="keywordflow">if</span> ((tmp_ptr = strstr(token_ptr, <span class="stringliteral">"/"</span>)) != NULL)
01025         {
01026           tmp_ptr++;
01027           POLICY_MATCH = <a class="code" href="util_8h.html#a42">UTIL_mx_cmp</a>(p, tmp_ptr2, atoi(tmp_ptr));
01028         }
01029         <span class="keywordflow">else</span>
01030         {
01031           POLICY_MATCH = <a class="code" href="util_8h.html#a42">UTIL_mx_cmp</a>(p, tmp_ptr2, 32);
01032         }
01033 
01034         <span class="comment">/* mechanism was supplied with a - indicating a failure on */</span>
01035         <span class="keywordflow">if</span> ((PREFIX_TYPE == <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>) &amp;&amp; (POLICY_MATCH == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>))
01036         {
01037           <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"Found a match on a negative prefix.  Halting parse.\n"</span>);
01038 
01039           <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>, token_ptr);
01040 
01041           <a class="code" href="util_8h.html#a6">xfree</a>(token);
01042           <a class="code" href="util_8h.html#a6">xfree</a>(copy);
01043 
01044           <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
01045         }
01046 
01047         <span class="keywordflow">break</span>;
01048  
01049        <span class="comment">/*</span>
01050 <span class="comment">       *  'ptr' mechanism</span>
01051 <span class="comment">      */</span>
01052       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a69">PTR</a>:
01053         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is ptr (%s)\n"</span>, token_ptr);
01054 
01055         POLICY_MATCH = <a class="code" href="util_8h.html#a44">UTIL_ptr_cmp</a>(p, token_ptr);
01056 
01057         <span class="comment">/* mechanism was supplied with a - indicating a failure on */</span>
01058         <span class="keywordflow">if</span> ((PREFIX_TYPE == <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>) &amp;&amp; (POLICY_MATCH == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>))
01059         {
01060           <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"Found a match on a negative prefix.  Halting parse.\n"</span>);
01061 
01062           <span class="keywordflow">break</span>;
01063         }
01064 
01065         <span class="keywordflow">break</span>;
01066 
01067 
01068        <span class="comment">/*</span>
01069 <span class="comment">       *  'ip4' mechanism </span>
01070 <span class="comment">      */</span>
01071       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a70">IP4</a>:
01072         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is ip4 (%s)\n"</span>, token_ptr);
01073 
01074         <span class="keywordflow">if</span> ((policy_ip = <a class="code" href="util_8h.html#a48">UTIL_expand_ip</a>(token_ptr)) == NULL)
01075         {
01076           <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"ERROR: inet_pton unable to convert ip to binary\n"</span>);
01077 
01078           <span class="keywordflow">break</span>;
01079         }
01080 
01081         <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"POL: %lu (%s) PEER: %lu (%s)\n"</span>,
01082           policy_ip-&gt;<a class="code" href="structpolicy__addr__s.html#o2">addr</a>.s_addr, token_ptr, p-&gt;<a class="code" href="structpeer__info__s.html#o26">addr</a>.s_addr, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>);
01083 
01084         POLICY_MATCH = <a class="code" href="util_8h.html#a52">UTIL_cidr_cmp</a>(policy_ip, &amp;p-&gt;<a class="code" href="structpeer__info__s.html#o26">addr</a>);
01085         <a class="code" href="util_8h.html#a6">xfree</a>(policy_ip);
01086 
01087         <span class="comment">/* mechanism was supplied with a - indicating a failure on */</span>
01088         <span class="keywordflow">if</span> ((PREFIX_TYPE == <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>) &amp;&amp; (POLICY_MATCH == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>))
01089         {
01090           <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"Found a match on a negative prefix.  Halting parse.\n"</span>);
01091           <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>, token_ptr);
01092 
01093           <a class="code" href="util_8h.html#a6">xfree</a>(token);
01094           <a class="code" href="util_8h.html#a6">xfree</a>(copy);
01095 
01096           <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
01097         }
01098 
01099         <span class="keywordflow">break</span>;
01100 
01101        <span class="comment">/* </span>
01102 <span class="comment">       *  'ip6' mechanism</span>
01103 <span class="comment">      */</span>
01104       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a71">IP6</a>:
01105         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is ip6 (%s)\n"</span>, token_ptr);
01106 
01107         <span class="keywordflow">break</span>;
01108 
01109        <span class="comment">/*</span>
01110 <span class="comment">       *  'exists' mechanism</span>
01111 <span class="comment">      */</span>
01112       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a72">EXISTS</a>:
01113         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is exists (%s)\n"</span>, token_ptr);
01114 
01115         <span class="keywordflow">if</span> ((tmp_ptr = strstr(token_ptr, <span class="stringliteral">":"</span>)) != NULL)
01116         {
01117           tmp_ptr++;
01118 
01119           <span class="keywordflow">if</span> ((macro = <a class="code" href="macro_8h.html#a1">MACRO_expand</a>(p, tmp_ptr)) == NULL)
01120           {
01121             <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Unable to expand macro (%s). Aborting.\n"</span>, tmp_ptr);
01122 
01123             <span class="keywordflow">break</span>;
01124           }
01125 
01126           <span class="keywordflow">if</span> (<a class="code" href="dns_8h.html#a8">DNS_query</a>(p, macro, T_A, NULL) == (<span class="keywordtype">char</span> *)<a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>)
01127           {
01128             POLICY_MATCH = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
01129           }
01130 
01131           <a class="code" href="util_8h.html#a6">xfree</a>(macro);
01132         }
01133         <span class="keywordflow">break</span>;
01134 
01135        <span class="comment">/*</span>
01136 <span class="comment">       *  'redirect' modifier</span>
01137 <span class="comment">      */</span>
01138       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a73">REDIRECT</a>:
01139         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"modifier is redirect (%s)\n"</span>, token_ptr);
01140 
01141         <span class="keywordflow">if</span> ((tmp_ptr = strstr(token_ptr, <span class="stringliteral">"="</span>)) != NULL)
01142         {
01143           tmp_ptr++;
01144 
01145           <span class="keywordflow">if</span> (<a class="code" href="util_8h.html#a41">UTIL_is_macro</a>(tmp_ptr) == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>)
01146           {
01147             <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a> == NULL)
01148             {
01149               <span class="keywordflow">if</span> ((macro = <a class="code" href="macro_8h.html#a1">MACRO_expand</a>(p, tmp_ptr)) != NULL)
01150               {
01151                 p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(macro, <a class="code" href="spf_8h.html#a5">SPF_MAX_STR</a>);
01152                 <a class="code" href="util_8h.html#a6">xfree</a>(macro);
01153               }
01154             }
01155             <span class="keywordflow">else</span>
01156             {
01157               <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Got redir=%s, but redirect already set. Ignoring.\n"</span>,
01158                 tmp_ptr);
01159             }
01160           }
01161           <span class="keywordflow">else</span>
01162           {
01163             <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a> == NULL)
01164             {
01165               <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"setting redirect_buf to %s\n"</span>, tmp_ptr);
01166               p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(tmp_ptr, <a class="code" href="spf_8h.html#a5">SPF_MAX_STR</a>);
01167             }
01168             <span class="keywordflow">else</span>
01169             {
01170               <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Got redir=%s, but redirect already set. Ignoring.\n"</span>,
01171                 tmp_ptr);
01172             }
01173           }
01174         }
01175         <span class="keywordflow">break</span>;
01176 
01177        <span class="comment">/*</span>
01178 <span class="comment">       *  'explain' mechanism </span>
01179 <span class="comment">      */</span>
01180       <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a90a74">EXPLAIN</a>:
01181         <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"policy mechanism is explain (%s)\n"</span>, token_ptr);
01182 
01183         <span class="keywordflow">if</span> ((tmp_ptr = strstr(token_ptr, <span class="stringliteral">"="</span>)) != NULL)
01184         {
01185           tmp_ptr++;
01186 
01187           <span class="keywordflow">if</span> ((macro = <a class="code" href="macro_8h.html#a1">MACRO_expand</a>(p, tmp_ptr)) == NULL)
01188           {
01189             <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Unable to expand macro (%s). Aborting.\n"</span>, tmp_ptr);
01190 
01191             <span class="keywordflow">break</span>;
01192           }
01193 
01194           p-&gt;<a class="code" href="structpeer__info__s.html#o11">explain</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(macro, (strlen(macro) + 1));
01195           <a class="code" href="util_8h.html#a6">xfree</a>(macro);
01196         }
01197         <span class="keywordflow">else</span>
01198         {
01199           <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"EXPLAIN modifier must be accompanied "</span> \
01200             <span class="stringliteral">"by arguments and I found none."</span>);
01201 
01202           <span class="comment">/* 'include' with no options returns unknown */</span>
01203           POLICY_MATCH = <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>;
01204           <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, <a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>, token_ptr);
01205 
01206           <a class="code" href="util_8h.html#a6">xfree</a>(token);
01207           <a class="code" href="util_8h.html#a6">xfree</a>(copy);
01208 
01209           <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>);
01210         }
01211 
01212         <span class="keywordflow">break</span>;
01213     } <span class="comment">/* switch */</span>
01214 
01215     <a class="code" href="util_8h.html#a6">xfree</a>(token);
01216     cp += pos + 1;  <span class="comment">/* move over to the next mechanism */</span>
01217 
01218     <span class="keywordflow">if</span> ((POLICY_MATCH == <a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>) &amp;&amp; (p-&gt;<a class="code" href="structpeer__info__s.html#o5">spf_ver</a> &gt; 0))
01219     {
01220       <span class="comment">/*p-&gt;RES = SPF_PASS;*/</span>
01221       <a class="code" href="util_8h.html#a47">UTIL_assoc_prefix</a>(p, PREFIX_TYPE, p-&gt;<a class="code" href="structpeer__info__s.html#o23">last_m</a>);
01222       p-&gt;<a class="code" href="structpeer__info__s.html#o2">RES_P</a> = p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>;
01223 
01224       <a class="code" href="util_8h.html#a11">xpprintf</a>(<span class="stringliteral">"returning SPF_TRUE\n"</span>);
01225       <a class="code" href="util_8h.html#a6">xfree</a>(copy);
01226 
01227       <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>);
01228     }
01229   } <span class="comment">/* while parsing policy */</span>
01230 
01231   <a class="code" href="util_8h.html#a6">xfree</a>(copy);
01232 
01233   <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
01234 }
01235 
01236 
01237 <span class="comment">/* SPF_result</span>
01238 <span class="comment">*</span>
01239 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
01240 <span class="comment">*</span>
01241 <span class="comment">*  Date:   02/02/04</span>
01242 <span class="comment">*</span>
01243 <span class="comment">*  Desc:</span>
01244 <span class="comment">*         Returns a string of allocated memory detailing a response</span>
01245 <span class="comment">*  that the MTA will return to the client based on the result</span>
01246 <span class="comment">*  received from an SPF query.</span>
01247 <span class="comment">*</span>
01248 <span class="comment">*/</span>
<a name="l01249"></a><a class="code" href="spf_8h.html#a82">01249</a> <span class="keywordtype">char</span> *<a class="code" href="spf_8h.html#a82">SPF_result</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p)
01250 {
01251   <span class="keywordtype">char</span>  *buf;    <span class="comment">/* return buffer */</span>
01252 
01253 
01254   buf = <a class="code" href="util_8h.html#a4">xmalloc</a>(<a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>);
01255 
01256   <span class="keywordflow">switch</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>)
01257   {
01258     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>:
01259       snprintf(buf, <a class="code" href="spf_8h.html#a22">SPF_MAX_SMTP_RES</a>, <a class="code" href="main_8h.html#a9">RES_PASS</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>);
01260       <span class="keywordflow">break</span>;
01261 
01262     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a52">SPF_NONE</a>:
01263       snprintf(buf, <a class="code" href="spf_8h.html#a22">SPF_MAX_SMTP_RES</a>, <a class="code" href="main_8h.html#a10">RES_NONE</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01264       <span class="keywordflow">break</span>;
01265 
01266     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a53">SPF_S_FAIL</a>:
01267       snprintf(buf, <a class="code" href="spf_8h.html#a22">SPF_MAX_SMTP_RES</a>, <a class="code" href="main_8h.html#a11">RES_S_FAIL</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>);
01268       <span class="keywordflow">break</span>;
01269 
01270     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>:
01271       snprintf(buf, <a class="code" href="spf_8h.html#a22">SPF_MAX_SMTP_RES</a>, <a class="code" href="main_8h.html#a12">RES_H_FAIL</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>);
01272       <span class="keywordflow">break</span>;
01273 
01274     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a55">SPF_ERROR</a>:
01275       snprintf(buf, <a class="code" href="spf_8h.html#a22">SPF_MAX_SMTP_RES</a>, <a class="code" href="main_8h.html#a13">RES_ERROR</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01276       <span class="keywordflow">break</span>;
01277 
01278     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a56">SPF_NEUTRAL</a>:
01279       snprintf(buf, <a class="code" href="spf_8h.html#a22">SPF_MAX_SMTP_RES</a>, <a class="code" href="main_8h.html#a14">RES_NEUTRAL</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01280       <span class="keywordflow">break</span>;
01281 
01282     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>:
01283       snprintf(buf, <a class="code" href="spf_8h.html#a22">SPF_MAX_SMTP_RES</a>, <a class="code" href="main_8h.html#a15">RES_UNKNOWN</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01284       <span class="keywordflow">break</span>;
01285 
01286     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a58">SPF_UNMECH</a>:
01287       snprintf(buf, <a class="code" href="spf_8h.html#a22">SPF_MAX_SMTP_RES</a>, <a class="code" href="main_8h.html#a16">RES_UNMECH</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01288       <span class="keywordflow">break</span>;
01289   }
01290 
01291   <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"response: (%s)\n"</span>, buf);
01292 
01293   <span class="keywordflow">return</span>(buf);
01294 }
01295 
01296 
01297 <span class="comment">/*  SPF_get_explain</span>
01298 <span class="comment">*</span>
01299 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
01300 <span class="comment">*</span>
01301 <span class="comment">*  Date:   01/25/04</span>
01302 <span class="comment">*</span>
01303 <span class="comment">*  Desc:</span>
01304 <span class="comment">*         Takes the contents of a returned explain parse (if any),</span>
01305 <span class="comment">*  allocates memory for it and returns that memory with the contents of</span>
01306 <span class="comment">*  that string.  Calling function is required to free this memory.</span>
01307 <span class="comment">*</span>
01308 <span class="comment">*</span>
01309 <span class="comment">*/</span>
<a name="l01310"></a><a class="code" href="spf_8h.html#a86">01310</a> <span class="keywordtype">char</span> *<a class="code" href="spf_8h.html#a86">SPF_get_explain</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p)
01311 {
01312   <span class="keywordtype">char</span> *buf = NULL;    <span class="comment">/* return buffer */</span>
01313 
01314 
01315   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o11">explain</a> != NULL)
01316   {
01317     <span class="keywordflow">if</span> ((buf = <a class="code" href="macro_8h.html#a1">MACRO_expand</a>(p, <a class="code" href="spf_8h.html#a32">SPF_EXPLAIN</a>)) != NULL)
01318     {
01319       <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"Prepending explain: (%s)\n"</span>, buf);
01320 
01321       <span class="keywordflow">return</span>(buf);
01322     }
01323   }
01324 
01325   <span class="keywordflow">return</span>(NULL);
01326 }
01327 
01328 
01329 <span class="comment">/*  SPF_build_header</span>
01330 <span class="comment">*</span>
01331 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
01332 <span class="comment">*</span>
01333 <span class="comment">*  Date:   01/25/04</span>
01334 <span class="comment">*</span>
01335 <span class="comment">*  Desc:</span>
01336 <span class="comment">*         Allocates memory and builds a string which contains a</span>
01337 <span class="comment">*  Received-SPF header.  The calling function is responsible to free</span>
01338 <span class="comment">*  this memory.</span>
01339 <span class="comment">*</span>
01340 <span class="comment">*</span>
01341 <span class="comment">*/</span>
<a name="l01342"></a><a class="code" href="spf_8h.html#a85">01342</a> <span class="keywordtype">char</span> *<a class="code" href="spf_8h.html#a85">SPF_build_header</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p)
01343 {
01344   <span class="keywordtype">char</span>  *buf;    <span class="comment">/* return buffer */</span>
01345 
01346   buf = <a class="code" href="util_8h.html#a4">xmalloc</a>(<a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>);
01347 
01348   <span class="keywordflow">switch</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o1">RES</a>)
01349   {
01350     <span class="comment">/* */</span>
01351     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>:
01352       snprintf(buf, <a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[<a class="code" href="spf_8h.html#a88a51">SPF_PASS</a>].h,
01353         p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>,
01354         p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01355       <span class="keywordflow">break</span>;
01356 
01357     <span class="comment">/* */</span>
01358     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a52">SPF_NONE</a>:
01359       snprintf(buf, <a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[<a class="code" href="spf_8h.html#a88a52">SPF_NONE</a>].h,
01360         p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01361       <span class="keywordflow">break</span>;
01362 
01363     <span class="comment">/* */</span>
01364     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a53">SPF_S_FAIL</a>:
01365       snprintf(buf, <a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[<a class="code" href="spf_8h.html#a88a53">SPF_S_FAIL</a>].h,
01366         p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>,
01367         p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01368       <span class="keywordflow">break</span>;
01369 
01370     <span class="comment">/* */</span>
01371     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>:
01372       snprintf(buf, <a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[<a class="code" href="spf_8h.html#a88a54">SPF_H_FAIL</a>].h,
01373         p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>,
01374         p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01375       <span class="keywordflow">break</span>;
01376 
01377     <span class="comment">/* */</span>
01378     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a55">SPF_ERROR</a>:
01379       snprintf(buf, <a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[<a class="code" href="spf_8h.html#a88a55">SPF_ERROR</a>].h,
01380         p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o24">error</a>);
01381       <span class="keywordflow">break</span>;
01382 
01383     <span class="comment">/* */</span>
01384     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a56">SPF_NEUTRAL</a>:
01385       snprintf(buf, <a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[<a class="code" href="spf_8h.html#a88a56">SPF_NEUTRAL</a>].h,
01386         p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o17">r_ip</a>);
01387       <span class="keywordflow">break</span>;
01388 
01389     <span class="comment">/* */</span>
01390     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>:
01391       snprintf(buf, <a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[<a class="code" href="spf_8h.html#a88a57">SPF_UNKNOWN</a>].h,
01392         p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o23">last_m</a>);
01393       <span class="keywordflow">break</span>;
01394 
01395     <span class="comment">/* */</span>
01396     <span class="keywordflow">case</span> <a class="code" href="spf_8h.html#a88a58">SPF_UNMECH</a>:
01397       snprintf(buf, <a class="code" href="spf_8h.html#a21">SPF_MAX_HEADER</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o25">spf_result</a>[<a class="code" href="spf_8h.html#a88a58">SPF_UNMECH</a>].h,
01398         p-&gt;<a class="code" href="structpeer__info__s.html#o23">last_m</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o16">mta_hname</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01399       <span class="keywordflow">break</span>;
01400   }
01401 
01402   <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"Prepending header string: (%s)\n"</span>, buf);
01403 
01404   <span class="keywordflow">return</span>(buf);
01405 }
01406 
01407 
01408 <span class="comment">/* SPF_smtp_helo</span>
01409 <span class="comment">*</span>
01410 <span class="comment">*  Author: Sean Comeau &lt;scomeau@obscurity.org&gt;</span>
01411 <span class="comment">*          James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
01412 <span class="comment">*          Patrick Earl (http://patearl.net/)</span>
01413 <span class="comment">*</span>
01414 <span class="comment">*  Date:   12/10/03</span>
01415 <span class="comment">*          12/25/03 (modified / renamed)</span>
01416 <span class="comment">*          02/04/04 (modified)</span>
01417 <span class="comment">*</span>
01418 <span class="comment">*  Desc:</span>
01419 <span class="comment">*          Fetches the HELO from MTA and places into the global</span>
01420 <span class="comment">*  p structure.</span>
01421 <span class="comment">*</span>
01422 <span class="comment">*/</span>
<a name="l01423"></a><a class="code" href="spf_8h.html#a84">01423</a> <a class="code" href="spf_8h.html#a35">SPF_BOOL</a> <a class="code" href="spf_8h.html#a84">SPF_smtp_helo</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p, <span class="keyword">const</span> <span class="keywordtype">char</span> *s)
01424 {
01425 
01426   <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"called with (%s)\n"</span>, s);
01427 
01428   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>)
01429   {
01430     <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>);
01431   }
01432 
01433   p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a> = <a class="code" href="util_8h.html#a7">xstrdup</a>(s);
01434   p-&gt;<a class="code" href="structpeer__info__s.html#o9">ehlo</a> = p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>;
01435 
01436   <span class="keywordflow">return</span> (strlen(p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>) &gt; 0);
01437 }
01438 
01439 
01440 <span class="comment">/* SPF_smtp_from</span>
01441 <span class="comment">*</span>
01442 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
01443 <span class="comment">*          Patrick Earl (http://patearl.net/)</span>
01444 <span class="comment">*</span>
01445 <span class="comment">*  Date:   12/10/03</span>
01446 <span class="comment">*  Date:   12/25/03 James Couzens &lt;jcouzens@codeshare.ca&gt; (rewrite)</span>
01447 <span class="comment">*  Date:   02/04/04 Patrick Earl (http://patearl.net) (modified)</span>
01448 <span class="comment">*  Date:   02/05/04 Teddy &lt;teddy@teddy.ch&gt;</span>
01449 <span class="comment">*</span>
01450 <span class="comment">*  Desc:</span>
01451 <span class="comment">*          Fetches the FROM from MTA and places into the global</span>
01452 <span class="comment">*  peer_info_t structure.</span>
01453 <span class="comment">*</span>
01454 <span class="comment">*</span>
01455 <span class="comment">*/</span>
<a name="l01456"></a><a class="code" href="spf_8h.html#a83">01456</a> <a class="code" href="spf_8h.html#a35">SPF_BOOL</a> <a class="code" href="spf_8h.html#a83">SPF_smtp_from</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p, <span class="keyword">const</span> <span class="keywordtype">char</span> *s)
01457 {
01458   <span class="keywordtype">int</span> len;      <span class="comment">/* utility */</span>
01459 
01460   <span class="keywordtype">char</span> *pos;    <span class="comment">/* position in string */</span>
01461 
01462 
01463   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01464   <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>);
01465 
01466   <span class="keywordflow">if</span> (s == NULL)
01467   {
01468     <span class="keywordflow">if</span> (*(p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>) == <span class="charliteral">'\0'</span>)
01469     {
01470       p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(<span class="stringliteral">"unknown"</span>, 7);
01471     } 
01472     <span class="keywordflow">else</span>
01473     {
01474       p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>, <a class="code" href="spf_8h.html#a13">SPF_MAX_ENV_HELO</a>);
01475     }
01476 
01477     <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"NULL or invalid MAIL FROM rcvd.  Using %s from now on.\n"</span>,
01478       p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> ? p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> : p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>);
01479 
01480     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
01481   }
01482 
01483   p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(s, <a class="code" href="spf_8h.html#a5">SPF_MAX_STR</a>);
01484 
01485   <span class="comment">/* strips &lt; and &gt; from E-Mail-Address */</span>
01486   <span class="keywordflow">if</span> (*p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> == 60)
01487   {
01488     pos = p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>;
01489     (*(p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> + strlen(p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>) - 1)) = <span class="charliteral">'\0'</span>;
01490     p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>++;
01491     p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, <a class="code" href="spf_8h.html#a5">SPF_MAX_STR</a>);
01492 
01493     <a class="code" href="util_8h.html#a6">xfree</a>(pos);
01494   }
01495 
01496   <span class="keywordflow">if</span> (*p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> == <span class="charliteral">'\0'</span>)
01497   {
01498     <span class="keywordflow">if</span> (*(p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>) == <span class="charliteral">'\0'</span>)
01499     {
01500       p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(<span class="stringliteral">"unknown"</span>, 7);
01501     }
01502     <span class="keywordflow">else</span>
01503     {
01504       p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o8">helo</a>, <a class="code" href="spf_8h.html#a13">SPF_MAX_ENV_HELO</a>);
01505     }
01506   }
01507 
01508   pos = p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>;
01509 
01510   <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"MAIL-FROM: (%s) (called with: %s)\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, s);
01511 
01512   <span class="keywordflow">if</span> ((pos = strstr(pos, <span class="stringliteral">"@"</span>)) != NULL)
01513   {
01514     len = (pos - p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01515 
01516     <span class="keywordflow">if</span> (len &gt;= <a class="code" href="spf_8h.html#a7">SPF_MAX_LOCAL_PART</a>)
01517     {
01518       <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"%i is &gt;= %i causing data overrun\n"</span>, len, <a class="code" href="spf_8h.html#a7">SPF_MAX_LOCAL_PART</a>);
01519     }
01520 
01521     <span class="comment">/* Copy everything up to the @ into local_part.  Do not include the @. */</span>
01522     memcpy(p-&gt;<a class="code" href="structpeer__info__s.html#o21">local_part</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, len);
01523     p-&gt;<a class="code" href="structpeer__info__s.html#o21">local_part</a>[len] = <span class="charliteral">'\0'</span>;
01524 
01525     pos++;    <span class="comment">/* skip past the @ */</span>
01526     p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(pos, <a class="code" href="spf_8h.html#a5">SPF_MAX_STR</a>);
01527 
01528     <a class="code" href="util_8h.html#a9">xprintf</a>(<span class="stringliteral">"Current domain: (%s)\n"</span>, p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>);
01529 
01530   }
01531   <span class="keywordflow">else</span>
01532   {
01533     snprintf(p-&gt;<a class="code" href="structpeer__info__s.html#o21">local_part</a>, 11, <span class="stringliteral">"postmaster"</span>);
01534     p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a> = <a class="code" href="util_8h.html#a8">xstrndup</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>, <a class="code" href="spf_8h.html#a5">SPF_MAX_STR</a>);
01535   }
01536 
01537   <a class="code" href="util_8h.html#a10">xvprintf</a>(<span class="stringliteral">"local-part: (%s); domain: (%s); sender: (%s)\n"</span>,
01538     p-&gt;<a class="code" href="structpeer__info__s.html#o21">local_part</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o15">current_domain</a>, p-&gt;<a class="code" href="structpeer__info__s.html#o10">from</a>);
01539 
01540   <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>);
01541 }
01542 
01543 
01544 <span class="comment">/* _SPF_clear_holdbufs</span>
01545 <span class="comment">*</span>
01546 <span class="comment">*  Author: Travis Anderson &lt;tanderson@codeshare.ca&gt;</span>
01547 <span class="comment">*  Author: James Couzens &lt;jcouzens@codeshare.ca&gt;</span>
01548 <span class="comment">*</span>
01549 <span class="comment">*  Date:   09/11/04 </span>
01550 <span class="comment">*</span>
01551 <span class="comment">*  Desc:</span>
01552 <span class="comment">*          There are three possible 'holding' buffers that are used</span>
01553 <span class="comment">*  only after an original parse comes back negative (ie anything other</span>
01554 <span class="comment">*  that SPF_PASS), and this function simply goes through and free's</span>
01555 <span class="comment">*  any memory they might have associated and assigns them a NULL</span>
01556 <span class="comment">*  pointer.</span>
01557 <span class="comment">*</span>
01558 <span class="comment">*  This function is *PRIVATE* and you will never need to call it, </span>
01559 <span class="comment">*  nor can it be referenced outside of this file, its purely</span>
01560 <span class="comment">*  written for the benefit for SPF_parse_policy when dealing with</span>
01561 <span class="comment">*  recursion for INCLUDE, REDIRECT, and CNAME.</span>
01562 <span class="comment">*</span>
01563 <span class="comment">*/</span>
<a name="l01564"></a><a class="code" href="main_8c.html#a2">01564</a> <span class="keyword">static</span> <a class="code" href="spf_8h.html#a35">SPF_BOOL</a> <a class="code" href="main_8c.html#a2">_SPF_clear_holdbufs</a>(<a class="code" href="structpeer__info__s.html">peer_info_t</a> *p)
01565 {
01566   <span class="keywordflow">if</span> (p == NULL)
01567   {
01568     <a class="code" href="util_8h.html#a13">xepprintf</a>(<span class="stringliteral">"peer_info_t structure was NULL!  Aborting!\n"</span>);
01569 
01570     <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a49">SPF_FALSE</a>);
01571   }
01572   
01573   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o28">cname_buf</a> != NULL)
01574   { 
01575     <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o28">cname_buf</a>);
01576     p-&gt;<a class="code" href="structpeer__info__s.html#o28">cname_buf</a> = NULL;
01577   }
01578   
01579   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> != NULL)
01580   {
01581     <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a>);
01582     p-&gt;<a class="code" href="structpeer__info__s.html#o29">include_buf</a> = NULL;
01583   }
01584   
01585   <span class="keywordflow">if</span> (p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>)
01586   {
01587     <a class="code" href="util_8h.html#a6">xfree</a>(p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a>);
01588     p-&gt;<a class="code" href="structpeer__info__s.html#o30">redirect_buf</a> = NULL;
01589   }
01590   
01591   <span class="keywordflow">return</span>(<a class="code" href="spf_8h.html#a87a50">SPF_TRUE</a>);
01592 }
01593 
01594 <span class="comment">/* end spf.c */</span>
</div></pre><hr size="1"><address style="align: right;"><small>Generated on Thu Sep 16 18:10:46 2004 for libSPF v1.0 by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border=0 ></a> 1.3.8 </small></address>
</body>
</html>
Revision:	1.1
Committed:	Tue Nov 13 00:51:28 2007 UTC (18 years, 10 months ago) by root
Content type:	text/html
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	initial import of libspf-1.0.0-p5 from freebsd ports