File: utils_8c-source.html

package info (click to toggle)
klone 1.1.1.dfsg1-1
links: PTS
area: main
in suites: etch, etch-m68k
size: 6,480 kB
ctags: 4,238
sloc: ansic: 16,288; makefile: 384; sh: 351
file content (963 lines) | stat: -rw-r--r-- 52,062 bytes
<!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>KLone: utils.c Source File</title>
<link href="kl.css" rel="stylesheet" type="text/css">
</head><body>
<!-- Generated by Doxygen 1.3.9.1 -->
<div class="qindex"><a class="qindex" href="index.html">Main&nbsp;Page</a> | <a class="qindex" href="modules.html">Modules</a> | <a class="qindex" href="annotated.html">Data&nbsp;Structures</a> | <a class="qindex" href="dirs.html">Directories</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></div>
<div class="nav">
<a class="el" href="dir_000000.html">src</a>&nbsp;/&nbsp;<a class="el" href="dir_000001.html">libutils</a></div>
<h1>utils.c</h1><a href="utils_8c.html">Go to the documentation of this file.</a><div class="fragment"><pre class="fragment">00001 <span class="comment">/*</span>
00002 <span class="comment"> * Copyright (c) 2005, 2006 by KoanLogic s.r.l. &lt;http://www.koanlogic.com&gt;</span>
00003 <span class="comment"> * All rights reserved.</span>
00004 <span class="comment"> *</span>
00005 <span class="comment"> * This file is part of KLone, and as such it is subject to the license stated</span>
00006 <span class="comment"> * in the LICENSE file which you have received as part of this distribution.</span>
00007 <span class="comment"> *</span>
00008 <span class="comment"> * $Id: utils.c,v 1.38 2006/04/22 13:14:46 tat Exp $</span>
00009 <span class="comment"> */</span>
00010 
00011 <span class="preprocessor">#include &lt;stdlib.h&gt;</span>
00012 <span class="preprocessor">#include &lt;stdio.h&gt;</span>
00013 <span class="preprocessor">#include &lt;signal.h&gt;</span>
00014 <span class="preprocessor">#include &lt;time.h&gt;</span>
00015 <span class="preprocessor">#include &lt;string.h&gt;</span>
00016 <span class="preprocessor">#include &lt;ctype.h&gt;</span>
00017 <span class="preprocessor">#include &lt;fcntl.h&gt;</span>
00018 <span class="preprocessor">#include &lt;unistd.h&gt;</span>
00019 <span class="preprocessor">#include &lt;dirent.h&gt;</span>
00020 <span class="preprocessor">#include &lt;sys/stat.h&gt;</span>
00021 <span class="preprocessor">#include "klone_conf.h"</span>
00022 <span class="preprocessor">#include &lt;<a class="code" href="klone_8h.html">klone/klone.h</a>&gt;</span>
00023 <span class="preprocessor">#include &lt;<a class="code" href="os_8h.html">klone/os.h</a>&gt;</span>
00024 <span class="preprocessor">#include &lt;<a class="code" href="io_8h.html">klone/io.h</a>&gt;</span>
00025 <span class="preprocessor">#include &lt;<a class="code" href="codecs_8h.html">klone/codecs.h</a>&gt;</span>
00026 <span class="preprocessor">#include &lt;<a class="code" href="emb_8h.html">klone/emb.h</a>&gt;</span>
00027 <span class="preprocessor">#include &lt;<a class="code" href="mime__map_8h.html">klone/mime_map.h</a>&gt;</span>
00028 <span class="preprocessor">#include &lt;<a class="code" href="version_8h.html">klone/version.h</a>&gt;</span>
00029 <span class="preprocessor">#include &lt;<a class="code" href="utils_8h.html">klone/utils.h</a>&gt;</span>
00030 <span class="preprocessor">#ifdef HAVE_STRINGS</span>
00031 <span class="preprocessor"></span><span class="preprocessor">#include &lt;strings.h&gt;</span>
00032 <span class="preprocessor">#endif</span>
00033 <span class="preprocessor"></span><span class="preprocessor">#include &lt;u/libu.h&gt;</span>
00034 
00040 <span class="keyword">enum</span> { <a class="code" href="parser_8c.html#a23a11">LF</a> = 0xA, <a class="code" href="parser_8c.html#a23a12">CR</a> = 0xD };
00041 
00042 <span class="keyword">static</span> <span class="keyword">struct </span>html_entities_s
00043 {
00044     <span class="keywordtype">int</span> s_char;
00045     <span class="keyword">const</span> <span class="keywordtype">char</span> *entity; 
00046 } entities[] = {
00047     { <span class="charliteral">'"'</span>,  <span class="stringliteral">"&amp;quot;"</span> },
00048     { <span class="charliteral">'\''</span>, <span class="stringliteral">"&amp;#39;"</span>  }, 
00049     { <span class="charliteral">'&lt;'</span>,  <span class="stringliteral">"&amp;lt;"</span>   },
00050     { <span class="charliteral">'&gt;'</span>,  <span class="stringliteral">"&amp;gt;"</span>   },
00051     { 0, NULL     }
00052 };
00053 
00054 <span class="preprocessor">#ifdef OS_UNIX</span>
00055 <span class="preprocessor"></span><span class="keyword">inline</span> <span class="keywordtype">int</span> <a class="code" href="utils_8h.html#a39">u_sig_block</a>(<span class="keywordtype">int</span> sig)
00056 {
00057     sigset_t sset;
00058 
00059     sigemptyset(&amp;sset);
00060     sigaddset(&amp;sset, sig);
00061     dbg_err_if(sigprocmask(SIG_BLOCK, &amp;sset, NULL));
00062 
00063     <span class="keywordflow">return</span> 0;
00064 err:
00065     <span class="keywordflow">return</span> ~0;
00066 }
00067 
00068 <span class="keyword">inline</span> <span class="keywordtype">int</span> <a class="code" href="utils_8h.html#a40">u_sig_unblock</a>(<span class="keywordtype">int</span> sig)
00069 {
00070     sigset_t sset;
00071 
00072     sigemptyset(&amp;sset);
00073     sigaddset(&amp;sset, sig);
00074     dbg_err_if(sigprocmask(SIG_UNBLOCK, &amp;sset, NULL));
00075 
00076     <span class="keywordflow">return</span> 0;
00077 err:
00078     <span class="keywordflow">return</span> ~0;
00079 }
00080 <span class="preprocessor">#endif </span><span class="comment">/* OS_UNIX */</span>
00081 
00082 
<a name="l00097"></a><a class="code" href="group__u__t.html#ga10">00097</a> <span class="keywordtype">char</span> *<a class="code" href="group__u__t.html#ga10">u_strnstr</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *buf, <span class="keyword">const</span> <span class="keywordtype">char</span> *sub, size_t buflen)
00098 {
00099     ssize_t len = strlen(sub);
00100     ssize_t plen;
00101     <span class="keywordtype">char</span> *p;
00102 
00103     <span class="keywordflow">if</span> (*sub == 0)
00104         <span class="keywordflow">return</span> (<span class="keywordtype">char</span> *)buf;
00105 
00106     plen = buflen;
00107     <span class="keywordflow">for</span> (p = (<span class="keywordtype">char</span> *)buf; p != NULL; p = memchr(p + 1, *sub, plen - 1))
00108     {
00109         plen = buflen - (p - buf);
00110 
00111         <span class="keywordflow">if</span> (plen &lt; len)
00112             <span class="keywordflow">return</span> NULL;
00113 
00114         <span class="keywordflow">if</span> (strncmp(p, sub, len) == 0)
00115             <span class="keywordflow">return</span> (p);
00116     }
00117 
00118     <span class="keywordflow">return</span> NULL;
00119 }
00120 
<a name="l00136"></a><a class="code" href="group__u__t.html#ga11">00136</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga11">u_foreach_dir_item</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *path, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> mask,
00137     <span class="keywordtype">int</span> (*cb)(<span class="keyword">struct</span> dirent*, <span class="keyword">const</span> <span class="keywordtype">char</span> *, <span class="keywordtype">void</span>*), <span class="keywordtype">void</span>* arg)
00138 {
00139     <span class="keyword">struct </span>dirent *de;
00140     <span class="keyword">struct </span>stat st;
00141     DIR *dir = NULL;
00142     <span class="keywordtype">char</span> buf[U_FILENAME_MAX];
00143     <span class="keywordtype">int</span> rc;
00144 
00145     dbg_return_if (path == NULL, ~0);
00146     dbg_return_if (cb == NULL, ~0);
00147     
00148     <span class="comment">/* open the given directory */</span>
00149     dir = opendir(path);
00150     dbg_err_if(dir == NULL);
00151 
00152     <span class="keywordflow">while</span>((de = readdir(dir)) != NULL)
00153     {
00154         <span class="comment">/* skip . and .. dirs */</span>
00155         <span class="keywordflow">if</span>(!strcmp(de-&gt;d_name, <span class="stringliteral">"."</span>) || !strcmp(de-&gt;d_name, <span class="stringliteral">".."</span>))
00156             <span class="keywordflow">continue</span>;
00157 
00158         <span class="comment">/* build fully qualified name of this item */</span>
00159         dbg_err_if(u_snprintf(buf, U_FILENAME_MAX, <span class="stringliteral">"%s/%s"</span>, path, de-&gt;d_name));
00160 
00161         dbg_err_if( (rc = stat(buf, &amp;st)) == -1);
00162 
00163         <span class="comment">/* skip if its type is not in the requested mask */</span>
00164         <span class="keywordflow">if</span>(((st.st_mode &amp; S_IFMT) &amp; mask) != 0 &amp;&amp; cb(de, path, arg))
00165             <span class="keywordflow">break</span>;
00166     }
00167 
00168     closedir(dir);
00169 
00170     <span class="keywordflow">return</span> 0;
00171 err:
00172     <span class="keywordflow">return</span> ~0;
00173 }
00174 
<a name="l00188"></a><a class="code" href="group__u__t.html#ga12">00188</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga12">u_match_ext</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *filename, <span class="keyword">const</span> <span class="keywordtype">char</span> *extension)
00189 {
00190     <span class="keyword">const</span> <span class="keywordtype">char</span> *fn, *ext;
00191     size_t flen, elen;
00192 
00193     <span class="keywordflow">if</span>(filename == NULL || extension == NULL)
00194         <span class="keywordflow">return</span> 0;
00195 
00196     flen = strlen(filename);
00197     elen = strlen(extension);
00198     <span class="keywordflow">if</span>(elen &gt; flen)
00199         <span class="keywordflow">return</span> 0;
00200 
00201     fn = filename + flen - 1;
00202     ext = extension + elen - 1;
00203     <span class="keywordflow">for</span>( ; elen; --fn, --ext, --elen)
00204     {
00205         <span class="keywordflow">if</span>(tolower(*fn) != tolower(*ext))
00206             <span class="keywordflow">return</span> 0;
00207     }
00208     <span class="keywordflow">return</span> 1;
00209 }
00210 
00211 <span class="comment">/* hex char to int */</span>
00212 <span class="keyword">static</span> <span class="keywordtype">short</span> htoi(<span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> c)
00213 {
00214     c = tolower(c);
00215 
00216     <span class="keywordflow">if</span>(c &gt;= <span class="charliteral">'0'</span> &amp;&amp; c &lt;= <span class="charliteral">'9'</span>)
00217         <span class="keywordflow">return</span> c - <span class="charliteral">'0'</span>;
00218     <span class="keywordflow">else</span> <span class="keywordflow">if</span>(c &gt;= <span class="charliteral">'a'</span> &amp;&amp; c &lt;= <span class="charliteral">'z'</span>)
00219         <span class="keywordflow">return</span> c - <span class="charliteral">'a'</span> + 10;
00220     <span class="keywordflow">else</span>
00221         <span class="keywordflow">return</span> 0;
00222 }
00223 
00224 
00225 <span class="keyword">static</span> ssize_t u_sqlncpy_encode(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen)
00226 {
00227     ssize_t wr = 0;
00228     <span class="keywordtype">int</span> c;
00229 
00230     dbg_return_if (d == NULL, -1);
00231     dbg_return_if (s == NULL, -1);
00232 
00233     <span class="keywordflow">for</span>(; slen; --slen)
00234     {
00235         c = *d++ = *s++;
00236         wr++;
00237         <span class="keywordflow">if</span>(c == <span class="charliteral">'\''</span>) 
00238         {
00239             dbg_err_if(slen &lt; 2);
00240             *d++ = <span class="charliteral">'\''</span>;
00241             wr++;
00242             --slen;
00243         } 
00244     }
00245     *d = 0;
00246 
00247     <span class="keywordflow">return</span> ++wr;
00248 err:
00249     <span class="keywordflow">return</span> -1;
00250 }
00251 
00252 <span class="keyword">static</span> ssize_t u_sqlncpy_decode(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen)
00253 {
00254     <span class="keywordtype">int</span> c, last = 0;
00255     ssize_t wr = 0;
00256     
00257     dbg_return_if (d == NULL, -1);
00258     dbg_return_if (s == NULL, -1);
00259 
00260     <span class="keywordflow">for</span>(; slen; --slen)
00261     {
00262         c = *s++;
00263         <span class="keywordflow">if</span>(c == <span class="charliteral">'\''</span> &amp;&amp; last == c) 
00264         {
00265             last = 0; 
00266             ; <span class="comment">/* skip */</span>
00267         } <span class="keywordflow">else</span> {
00268             *d++ = c;
00269             last = c;
00270             wr++;
00271         }
00272     }
00273     *d = 0;
00274 
00275     <span class="keywordflow">return</span> ++wr;
00276 }
00277 
<a name="l00292"></a><a class="code" href="group__u__t.html#ga16">00292</a> ssize_t <a class="code" href="group__u__t.html#ga16">u_sqlncpy</a>(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen, <span class="keywordtype">int</span> flags)
00293 {
00294     dbg_return_if (d == NULL, -1);
00295     dbg_return_if (s == NULL, -1);
00296 
00297     <span class="keywordflow">switch</span>(flags)
00298     {
00299     <span class="keywordflow">case</span> <a class="code" href="utils_8h.html#a53a16">SQLCPY_ENCODE</a>:
00300         <span class="keywordflow">return</span> u_sqlncpy_encode(d, s, slen);
00301     <span class="keywordflow">case</span> <a class="code" href="utils_8h.html#a53a17">SQLCPY_DECODE</a>:
00302         <span class="keywordflow">return</span> u_sqlncpy_decode(d, s, slen);
00303     <span class="keywordflow">default</span>:
00304         strncpy(d, s, slen);
00305         d[slen] = 0;
00306         <span class="keywordflow">return</span> slen + 1;
00307     }
00308 
00309     <span class="keywordflow">return</span> -1;
00310 }
00311 
00312 <span class="keyword">static</span> ssize_t u_urlncpy_encode(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen)
00313 {
00314     <span class="keyword">const</span> <span class="keywordtype">char</span> hexc[] = <span class="stringliteral">"0123456789ABCDEF"</span>;
00315     ssize_t wr = 0;
00316     <span class="keywordtype">int</span> c;
00317 
00318     dbg_return_if (d == NULL, -1);
00319     dbg_return_if (s == NULL, -1);
00320 
00321     <span class="keywordflow">for</span>(; slen; --slen)
00322     {
00323         c = *s++;
00324         <span class="keywordflow">if</span>(c == <span class="charliteral">' '</span>) {
00325             *d++ = <span class="charliteral">'+'</span>;
00326             wr++;
00327         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(isalnum(c) || c == <span class="charliteral">'_'</span> || c == <span class="charliteral">'-'</span> || c == <span class="charliteral">'.'</span>) {
00328             *d++ = c;
00329             wr++;
00330         } <span class="keywordflow">else</span> {
00331             *d++ = <span class="charliteral">'%'</span>;                                        
00332             *d++ = hexc[(c &gt;&gt; 4) &amp; 0xF];             
00333             *d++ = hexc[c &amp; 0xF];  
00334             wr += 3;
00335         }
00336     }
00337     *d = 0;
00338 
00339     <span class="keywordflow">return</span> ++wr;
00340 }
00341 
00342 <span class="keyword">static</span> ssize_t u_urlncpy_decode(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen)
00343 {
00344     <span class="keywordtype">short</span> c;
00345     ssize_t wr = 0;
00346 
00347     dbg_return_if (d == NULL, -1);
00348     dbg_return_if (s == NULL, -1);
00349 
00350     <span class="keywordflow">for</span>(; slen; --slen, ++wr)
00351     {
00352         c = *s++;
00353         <span class="keywordflow">if</span>(c == <span class="charliteral">'%'</span>)
00354         {
00355             dbg_err_if(slen &lt; 2 || !isxdigit(s[0]) || !isxdigit(s[1]));
00356             c = htoi(s[0]) &lt;&lt; 4 | htoi(s[1]);
00357             <span class="comment">//dbg_err_if(c == 0);</span>
00358             *d++ = (char)c;
00359             s += 2;
00360             slen -= 2;
00361         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(c == <span class="charliteral">'+'</span>) {
00362             *d++ = <span class="charliteral">' '</span>;
00363         } <span class="keywordflow">else</span> {
00364             *d++ = c;
00365         }
00366     }
00367     *d = 0;
00368 
00369     <span class="keywordflow">return</span> ++wr;
00370 err:
00371     <span class="keywordflow">return</span> -1;
00372 
00373 }
00374 
<a name="l00389"></a><a class="code" href="group__u__t.html#ga19">00389</a> ssize_t <a class="code" href="group__u__t.html#ga19">u_urlncpy</a>(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen, <span class="keywordtype">int</span> flags)
00390 {
00391     dbg_return_if (d == NULL, -1);
00392     dbg_return_if (s == NULL, -1);
00393 
00394     <span class="keywordflow">switch</span>(flags)
00395     {
00396     <span class="keywordflow">case</span> <a class="code" href="utils_8h.html#a50a7">URLCPY_ENCODE</a>:
00397         <span class="keywordflow">return</span> u_urlncpy_encode(d, s, slen);
00398     <span class="keywordflow">case</span> <a class="code" href="utils_8h.html#a50a8">URLCPY_DECODE</a>:
00399         <span class="keywordflow">return</span> u_urlncpy_decode(d, s, slen);
00400     <span class="keywordflow">default</span>:
00401         strncpy(d, s, slen);
00402         d[slen] = 0; <span class="comment">/* zero-term the string */</span>
00403         <span class="keywordflow">return</span> slen + 1;
00404     }
00405 
00406     <span class="keywordflow">return</span> -1;
00407 }
00408 
<a name="l00409"></a><a class="code" href="group__u__t.html#ga20">00409</a> <span class="keyword">inline</span> <span class="keywordtype">char</span> <a class="code" href="group__u__t.html#ga20">u_tochex</a>(<span class="keywordtype">int</span> n)
00410 {
00411         <span class="keywordflow">if</span>(n &gt; 15)
00412                 <span class="keywordflow">return</span> <span class="charliteral">'?'</span>;
00413         <span class="keywordflow">return</span> ( n &lt; 10 ? n + <span class="charliteral">'0'</span> : n-10 + <span class="charliteral">'a'</span>);
00414 }
00415 
00416 <span class="keyword">static</span> <span class="keywordtype">int</span> u_hex2ch(<span class="keywordtype">char</span> c)
00417 {
00418     <span class="keywordflow">if</span>(c &gt;= <span class="charliteral">'a'</span> &amp;&amp; c &lt;= <span class="charliteral">'z'</span>) 
00419         <span class="keywordflow">return</span> c - <span class="charliteral">'a'</span> + 10;
00420     <span class="keywordflow">else</span> <span class="keywordflow">if</span>(c &gt;= <span class="charliteral">'A'</span> &amp;&amp; c &lt;= <span class="charliteral">'Z'</span>)
00421         <span class="keywordflow">return</span> c - <span class="charliteral">'A'</span> + 10;
00422     <span class="keywordflow">else</span> <span class="keywordflow">if</span>(c &gt;= <span class="charliteral">'0'</span> &amp;&amp; c &lt;= <span class="charliteral">'9'</span>) 
00423         <span class="keywordflow">return</span> c - <span class="charliteral">'0'</span>;
00424     <span class="keywordflow">else</span>
00425         <span class="keywordflow">return</span> -1; <span class="comment">/* error */</span>
00426 }
00427 
<a name="l00428"></a><a class="code" href="group__u__t.html#ga22">00428</a> <span class="keywordtype">void</span> <a class="code" href="group__u__t.html#ga22">u_print_version_and_exit</a>(<span class="keywordtype">void</span>)
00429 {
00430     <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span> *vv = 
00431     <span class="stringliteral">"KLone %s - Copyright (c) 2005, 2006 KoanLogic s.r.l. - "</span>
00432     <span class="stringliteral">"All rights reserved. \n\n"</span>;
00433 
00434     fprintf(stderr, vv, <a class="code" href="group__u__t.html#ga43">klone_version</a>());
00435 
00436     exit(EXIT_FAILURE);
00437 }
00438 
00439 <span class="keyword">static</span> ssize_t u_hexncpy_decode(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen)
00440 {
00441         size_t i, t;
00442 
00443     dbg_return_if (d == NULL, -1);
00444     dbg_return_if (s == NULL, -1);
00445 
00446     <span class="comment">/* slen must be multiple of 2 */</span>
00447     dbg_err_if((slen % 2) != 0);
00448 
00449         <span class="keywordflow">for</span>(i = 0, t = 0; i &lt; slen; ++t, i += 2)
00450         d[t] = (u_hex2ch(s[i]) &lt;&lt; 4) | u_hex2ch(s[i+1]); 
00451 
00452     d[t] = 0; <span class="comment">/* zero-term */</span>
00453 
00454     <span class="keywordflow">return</span> ++t;
00455 err:
00456     <span class="keywordflow">return</span> -1;
00457 }
00458 
00459 <span class="keyword">static</span> ssize_t u_hexncpy_encode(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen)
00460 {
00461         size_t c, i, t;
00462 
00463     dbg_return_if (d == NULL, -1);
00464     dbg_return_if (s == NULL, -1);
00465 
00466         <span class="keywordflow">for</span>(i = 0, t = 0; i &lt; slen; ++i, t += 2)
00467         {
00468                 c = s[i];
00469         d[t]   = <a class="code" href="group__u__t.html#ga20">u_tochex</a>((c &gt;&gt; 4) &amp; 0x0F);
00470         d[t+1] = <a class="code" href="group__u__t.html#ga20">u_tochex</a>(c &amp; 0x0F);
00471         }
00472     d[t] = 0; <span class="comment">/* zero-term */</span>
00473 
00474     <span class="keywordflow">return</span> ++t;
00475 }
00476 
<a name="l00491"></a><a class="code" href="group__u__t.html#ga25">00491</a> ssize_t <a class="code" href="group__u__t.html#ga25">u_hexncpy</a>(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen, <span class="keywordtype">int</span> flags)
00492 {
00493     dbg_err_if (d == NULL);
00494     dbg_err_if (s == NULL);
00495 
00496     <span class="keywordflow">switch</span>(flags)
00497     {
00498     <span class="keywordflow">case</span> <a class="code" href="utils_8h.html#a51a10">HEXCPY_ENCODE</a>:
00499         <span class="keywordflow">return</span> u_hexncpy_encode(d, s, slen);
00500     <span class="keywordflow">case</span> <a class="code" href="utils_8h.html#a51a11">HEXCPY_DECODE</a>:
00501         <span class="keywordflow">return</span> u_hexncpy_decode(d, s, slen);
00502     <span class="keywordflow">default</span>:
00503         strncpy(d, s, slen);
00504         d[slen] = 0; <span class="comment">/* zero-term the string */</span>
00505         <span class="keywordflow">return</span> slen + 1;
00506     }
00507 
00508 err:
00509     <span class="keywordflow">return</span> -1;
00510 }
00511 
00512 <span class="keyword">static</span> ssize_t u_htmlncpy_encode(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen)
00513 {
00514     <span class="keyword">struct </span>html_entities_s *p;
00515     <span class="keyword">const</span> <span class="keywordtype">char</span> *map[256];
00516     size_t elen;
00517     <span class="keywordtype">int</span> c;
00518     ssize_t wr = 0;
00519 
00520     dbg_return_if (d == NULL, -1);
00521     dbg_return_if (s == NULL, -1);
00522 
00523     <span class="comment">/* build the map table (could be static but it wouldn't be thread-safe) */</span>
00524     memset(map, 0, <span class="keyword">sizeof</span>(map));
00525     <span class="keywordflow">for</span>(p = entities; p-&gt;s_char; ++p)
00526         map[p-&gt;s_char] = p-&gt;entity;
00527 
00528     <span class="keywordflow">while</span>(slen)
00529     {
00530         c = *s++;
00531         <span class="keywordflow">if</span>(map[c] == NULL)
00532         {
00533             *d++ = c;   <span class="comment">/* this char doesn't need encoding */</span>
00534             wr++;
00535             --slen;
00536         } <span class="keywordflow">else</span> {
00537             elen = strlen(map[c]);
00538             <span class="keywordflow">if</span>(slen &lt; elen)
00539                 <span class="keywordflow">break</span>; <span class="comment">/* there's not enough space to fit the entity */</span>
00540             strncpy(d, map[c], slen); <span class="comment">/* append the entity */</span>
00541             slen -= elen;
00542             d += elen;
00543             wr += elen;
00544         }
00545     }
00546     *d = 0;
00547 
00548     <span class="keywordflow">return</span> ++wr;
00549 }
00550 
00551 <span class="keyword">static</span> ssize_t u_htmlncpy_decode(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen)
00552 {
00553     <span class="keyword">struct </span>html_entities_s *p;
00554     <span class="keywordtype">char</span> *found, *after;
00555 
00556     dbg_return_if (d == NULL, -1);
00557     dbg_return_if (s == NULL, -1);
00558 
00559     strncpy(d, s, slen);
00560     d[slen] = 0;
00561 
00562     <span class="keywordflow">for</span>(p = entities; p-&gt;s_char; ++p)
00563     {
00564         <span class="keywordflow">while</span>((found = <a class="code" href="group__u__t.html#ga29">u_stristr</a>(d, p-&gt;entity)) != NULL)
00565         {
00566             *found = p-&gt;s_char;
00567             after = found + strlen(p-&gt;entity);
00568             memmove(++found, after, 1 + strlen(after));
00569         }
00570     }
00571 
00572     <span class="keywordflow">return</span> 1 + strlen(d);
00573 }
00574 
<a name="l00589"></a><a class="code" href="group__u__t.html#ga28">00589</a> ssize_t <a class="code" href="group__u__t.html#ga28">u_htmlncpy</a>(<span class="keywordtype">char</span> *d, <span class="keyword">const</span> <span class="keywordtype">char</span> *s, size_t slen, <span class="keywordtype">int</span> flags)
00590 {
00591     dbg_err_if (d == NULL);
00592     dbg_err_if (s == NULL);
00593 
00594     <span class="keywordflow">switch</span>(flags)
00595     {
00596     <span class="keywordflow">case</span> <a class="code" href="utils_8h.html#a52a13">HTMLCPY_ENCODE</a>:
00597         <span class="keywordflow">return</span> u_htmlncpy_encode(d, s, slen);
00598     <span class="keywordflow">case</span> <a class="code" href="utils_8h.html#a52a14">HTMLCPY_DECODE</a>:
00599         <span class="keywordflow">return</span> u_htmlncpy_decode(d, s, slen);
00600     <span class="keywordflow">default</span>:
00601         strncpy(d, s, slen);
00602         d[slen] = 0; <span class="comment">/* zero-term */</span>
00603         <span class="keywordflow">return</span> slen + 1;
00604     }
00605 err:
00606     <span class="keywordflow">return</span> -1;
00607 }
00608 
<a name="l00621"></a><a class="code" href="group__u__t.html#ga29">00621</a> <span class="keywordtype">char</span> *<a class="code" href="group__u__t.html#ga29">u_stristr</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *string, <span class="keyword">const</span> <span class="keywordtype">char</span> *sub)
00622 {
00623     <span class="keyword">const</span> <span class="keywordtype">char</span> *p;
00624     size_t len;
00625 
00626     dbg_err_if (sub == NULL);
00627     dbg_err_if (string == NULL);
00628 
00629     len = strlen(sub);
00630     <span class="keywordflow">for</span>(p = string; *p; ++p)
00631     {
00632         <span class="keywordflow">if</span>(strncasecmp(p, sub, len) == 0)
00633             <span class="keywordflow">return</span> (<span class="keywordtype">char</span>*)p;
00634     }
00635 
00636 err: <span class="comment">/* fall through */</span>
00637     <span class="keywordflow">return</span> NULL;
00638 }
00639 
<a name="l00652"></a><a class="code" href="group__u__t.html#ga30">00652</a> <span class="keywordtype">char</span>* <a class="code" href="group__u__t.html#ga30">u_strnrchr</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *s, <span class="keywordtype">char</span> c, size_t len)
00653 {
00654     <span class="keyword">register</span> <span class="keywordtype">int</span> i = len - 1;
00655 
00656     dbg_err_if (s == NULL);
00657     dbg_err_if (c == NULL);
00658     
00659     <span class="keywordflow">for</span>(; i &gt;= 0; --i)
00660         <span class="keywordflow">if</span>(s[i] == c)
00661             <span class="keywordflow">return</span> (<span class="keywordtype">char</span>*)s + i; <span class="comment">/* found */</span>
00662 err:
00663     <span class="keywordflow">return</span> NULL;
00664 }
00665 
<a name="l00677"></a><a class="code" href="group__u__t.html#ga31">00677</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga31">u_tmpfile_open</a>(<a class="code" href="structio__s.html">io_t</a> **pio)
00678 {
00679     <span class="keywordtype">char</span> tmp[U_FILENAME_MAX];
00680     <a class="code" href="structio__s.html">io_t</a> *io = NULL;
00681 
00682     dbg_return_if (pio == NULL, ~0);
00683     
00684     <span class="keywordflow">if</span>(tmpnam(tmp) != NULL)
00685     {
00686         dbg_err_if(<a class="code" href="group__u__t.html#ga32">u_file_open</a>(tmp, O_CREAT | O_EXCL | O_RDWR, &amp;io));
00687 
00688         dbg_err_if(<a class="code" href="group__io__t.html#ga25">io_name_set</a>(io, tmp));
00689 
00690         *pio = io;
00691 
00692         <span class="keywordflow">return</span> 0;
00693     }
00694 
00695 err:
00696     <span class="keywordflow">if</span>(io)
00697         <a class="code" href="group__io__t.html#ga12">io_free</a>(io);
00698     <span class="keywordflow">return</span> ~0;
00699 }
00700 
<a name="l00715"></a><a class="code" href="group__u__t.html#ga32">00715</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga32">u_file_open</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *file, <span class="keywordtype">int</span> flags, <a class="code" href="structio__s.html">io_t</a> **pio)
00716 {
00717     <span class="keywordtype">int</span> fmod = 0; <span class="comment">/* flags modifier */</span>
00718     <span class="keywordtype">int</span> fd;
00719 
00720 <span class="preprocessor">#ifdef OS_WIN</span>
00721 <span class="preprocessor"></span>    fmod = _O_BINARY;
00722 <span class="preprocessor">#endif</span>
00723 <span class="preprocessor"></span>    
00724     dbg_return_if (file == NULL, ~0);
00725     dbg_return_if (pio == NULL, ~0);
00726     
00727     fd = open(file, fmod | flags, 0600);
00728     dbg_err_if(fd &lt; 0);
00729 
00730     dbg_err_if(<a class="code" href="io_8h.html#a5">io_fd_create</a>(fd, <a class="code" href="io_8h.html#a27a2">IO_FD_CLOSE</a>, pio));
00731 
00732     <span class="comment">/* name the stream */</span>
00733     dbg_err_if(<a class="code" href="group__io__t.html#ga25">io_name_set</a>(*pio, file));
00734 
00735     <span class="keywordflow">return</span> 0;
00736 err:
00737     <span class="keywordflow">if</span>(fd &lt; 0)
00738         dbg_strerror(errno);
00739     <span class="keywordflow">else</span>
00740         close(fd);
00741     <span class="keywordflow">return</span> ~0;
00742 }
00743 
<a name="l00756"></a><a class="code" href="group__u__t.html#ga33">00756</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga33">u_getline</a>(<a class="code" href="structio__s.html">io_t</a> *io, u_string_t *ln)
00757 {
00758     <span class="keyword">enum</span> { BUFSZ = 1024 };
00759     <span class="keywordtype">char</span> buf[BUFSZ];
00760     ssize_t len, rc;
00761 
00762     dbg_return_if (io == NULL, ~0);
00763     dbg_return_if (ln == NULL, ~0);
00764     
00765     u_string_clear(ln);
00766 
00767     <span class="keywordflow">while</span>((rc = len = <a class="code" href="group__io__t.html#ga21">io_gets</a>(io, buf, BUFSZ)) &gt; 0)
00768     {
00769         dbg_err_if(u_string_append(ln, buf, --len));
00770         <span class="keywordflow">if</span>(!u_isnl(buf[len]))
00771             <span class="keywordflow">continue</span>; <span class="comment">/* line's longer the bufsz (or eof);get next line chunk */</span>
00772         <span class="keywordflow">else</span>
00773             <span class="keywordflow">break</span>;
00774     }
00775 
00776     dbg_if(rc &lt; 0); <span class="comment">/* io_gets error */</span>
00777 
00778 err:
00779     <span class="keywordflow">return</span> (rc &lt;= 0 ? ~0 : 0);
00780 }
00781 
<a name="l00794"></a><a class="code" href="group__u__t.html#ga34">00794</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga34">u_fgetline</a>(FILE *in, u_string_t *ln)
00795 {
00796     <span class="keyword">enum</span> { BUFSZ = 256 };
00797     <span class="keywordtype">char</span> buf[BUFSZ];
00798     size_t len;
00799 
00800     dbg_return_if (in == NULL, ~0);
00801     dbg_return_if (ln == NULL, ~0);
00802     
00803     u_string_clear(ln);
00804 
00805     <span class="keywordflow">while</span>(!ferror(in) &amp;&amp; !feof(in) &amp;&amp; fgets(buf, BUFSZ, in))
00806     {
00807         len = strlen(buf);
00808         dbg_err_if(u_string_append(ln, buf, len));
00809         <span class="keywordflow">if</span>(!u_isnl(buf[len-1]))
00810             <span class="keywordflow">continue</span>; <span class="comment">/* line's longer the bufsz, get next line chunk */</span>
00811         <span class="keywordflow">else</span>
00812             <span class="keywordflow">break</span>;
00813     }
00814 
00815     <span class="keywordflow">if</span>(ferror(in))
00816         dbg_strerror(errno);
00817 err:
00818     <span class="keywordflow">return</span> (u_string_len(ln) ? 0 : ~0);
00819 }
00820 
<a name="l00821"></a><a class="code" href="group__u__t.html#ga35">00821</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga35">u_printf_ccstr</a>(<a class="code" href="structio__s.html">io_t</a> *o, <span class="keyword">const</span> <span class="keywordtype">char</span> *buf, size_t sz)
00822 {
00823     <span class="keywordtype">char</span> prev, c = 0;
00824     <span class="keywordtype">int</span> pos = 0;
00825     size_t i;
00826 
00827     dbg_return_if (o == NULL, ~0);
00828     dbg_return_if (buf == NULL, ~0);
00829     
00830     <span class="keywordflow">for</span>(i = 0; i &lt; sz; ++i)
00831     {
00832         prev = c;
00833         c = buf[i];
00834         <span class="keywordflow">if</span>(pos++ == 0) <span class="comment">// first line char</span>
00835             <a class="code" href="group__io__t.html#ga18">io_putc</a>(o, <span class="charliteral">'"'</span>);
00836         <span class="keywordflow">switch</span>(c)
00837         {
00838         <span class="keywordflow">case</span> <a class="code" href="parser_8c.html#a23a12">CR</a>:
00839             <span class="keywordflow">if</span>(prev != LF) 
00840             <a class="code" href="group__io__t.html#ga15">io_printf</a>(o, <span class="stringliteral">"\\n\"\n"</span>);
00841             pos = 0;
00842             <span class="keywordflow">break</span>;
00843         <span class="keywordflow">case</span> <a class="code" href="parser_8c.html#a23a11">LF</a>:
00844             <span class="keywordflow">if</span>(prev != CR) 
00845             <a class="code" href="group__io__t.html#ga15">io_printf</a>(o, <span class="stringliteral">"\\n\"\n"</span>);
00846             pos = 0;
00847             <span class="keywordflow">break</span>;
00848         <span class="keywordflow">case</span> <span class="charliteral">'"'</span>:
00849             <a class="code" href="group__io__t.html#ga15">io_printf</a>(o, <span class="stringliteral">"\\\""</span>);
00850             <span class="keywordflow">break</span>;
00851         <span class="keywordflow">case</span> <span class="charliteral">'\\'</span>:
00852             <a class="code" href="group__io__t.html#ga15">io_printf</a>(o, <span class="stringliteral">"\\\\"</span>);
00853             <span class="keywordflow">break</span>;
00854         <span class="keywordflow">default</span>:
00855             <span class="keywordflow">if</span>(isprint(c))
00856                 <a class="code" href="group__io__t.html#ga18">io_putc</a>(o, c);
00857             <span class="keywordflow">else</span> {
00858                 <a class="code" href="group__io__t.html#ga15">io_printf</a>(o, <span class="stringliteral">"\\x%c%c"</span>, <a class="code" href="group__u__t.html#ga20">u_tochex</a>((c &gt;&gt; 4) &amp; 0x0F),
00859                 <a class="code" href="group__u__t.html#ga20">u_tochex</a>(c &amp; 0x0F));
00860             }
00861         }
00862     }
00863     <span class="keywordflow">if</span>(pos)
00864         <a class="code" href="group__io__t.html#ga18">io_putc</a>(o, <span class="charliteral">'"'</span>);
00865 
00866     <span class="keywordflow">return</span> 0;
00867 }
00868 
<a name="l00878"></a><a class="code" href="group__u__t.html#ga36">00878</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga36">u_file_exists</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *fqn)
00879 {
00880     <span class="keyword">struct </span>stat st;
00881 
00882     dbg_return_if (fqn == NULL, 0);
00883     
00884     <span class="keywordflow">return</span> stat(fqn, &amp;st) == 0 &amp;&amp; S_ISREG(st.st_mode);
00885 }
00886 
<a name="l00900"></a><a class="code" href="group__u__t.html#ga37">00900</a> <span class="keywordtype">void</span> <a class="code" href="group__u__t.html#ga37">u_tohex</a>(<span class="keywordtype">char</span> *hex, <span class="keyword">const</span> <span class="keywordtype">char</span> *src, size_t sz)
00901 {
00902     size_t c, i, t;
00903 
00904     dbg_ifb (hex == NULL) <span class="keywordflow">return</span>;
00905     dbg_ifb (src == NULL) <span class="keywordflow">return</span>;
00906     
00907     <span class="keywordflow">for</span>(i = 0, t = 0; i &lt; sz; ++i, t += 2)
00908     {
00909         c = src[i];
00910         hex[t]   = <a class="code" href="group__u__t.html#ga20">u_tochex</a>((c &gt;&gt; 4) &amp; 0x0F);
00911         hex[t+1] = <a class="code" href="group__u__t.html#ga20">u_tochex</a>(c &amp; 0x0F);
00912     }
00913 
00914     hex[t] = 0; <span class="comment">/* zero-term */</span>
00915 }
00916 
<a name="l00930"></a><a class="code" href="group__u__t.html#ga38">00930</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga38">u_md5</a>(<span class="keywordtype">char</span> *buf, size_t sz, <span class="keywordtype">char</span> out[MD5_DIGEST_BUFSZ])
00931 {
00932     <a class="code" href="structmd5__state__s.html">md5_state_t</a> md5ctx;
00933     <a class="code" href="md5_8h.html#a2">md5_byte_t</a> md5_digest[16]; <span class="comment">/* binary digest */</span>
00934 
00935     dbg_return_if (buf == NULL, ~0);
00936     dbg_return_if (out == NULL, ~0);
00937     
00938     <a class="code" href="md5_8h.html#a5">md5_init</a>(&amp;md5ctx);
00939     <a class="code" href="md5_8h.html#a6">md5_append</a>(&amp;md5ctx, (<a class="code" href="md5_8h.html#a2">md5_byte_t</a>*)buf, sz);
00940     <a class="code" href="md5_8h.html#a7">md5_finish</a>(&amp;md5ctx, md5_digest);
00941 
00942     <a class="code" href="group__u__t.html#ga37">u_tohex</a>(out, (<span class="keyword">const</span> <span class="keywordtype">char</span>*)md5_digest, 16);
00943 
00944     out[MD5_DIGEST_LEN] = 0;
00945 
00946     <span class="keywordflow">return</span> 0;
00947 }
00948 
<a name="l00962"></a><a class="code" href="group__u__t.html#ga39">00962</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga39">u_md5io</a>(<a class="code" href="structio__s.html">io_t</a> *io, <span class="keywordtype">char</span> out[MD5_DIGEST_BUFSZ])
00963 {
00964     <span class="keyword">enum</span> { page_sz = 4096 };
00965     <a class="code" href="structmd5__state__s.html">md5_state_t</a> md5ctx;
00966     <a class="code" href="md5_8h.html#a2">md5_byte_t</a> md5_digest[16]; <span class="comment">/* binary digest */</span>
00967     <span class="keywordtype">char</span> buf[page_sz];
00968     size_t cnt;
00969 
00970     dbg_err_if (io == NULL);
00971     dbg_err_if (out == NULL);
00972 
00973     <a class="code" href="md5_8h.html#a5">md5_init</a>(&amp;md5ctx);
00974 
00975     <span class="keywordflow">while</span>((cnt = <a class="code" href="group__io__t.html#ga14">io_read</a>(io, buf, page_sz)) &gt; 0)
00976         <a class="code" href="md5_8h.html#a6">md5_append</a>(&amp;md5ctx, (<a class="code" href="md5_8h.html#a2">md5_byte_t</a>*)buf, cnt);
00977 
00978     <a class="code" href="md5_8h.html#a7">md5_finish</a>(&amp;md5ctx, md5_digest);
00979 
00980     <a class="code" href="group__u__t.html#ga37">u_tohex</a>(out, (<span class="keyword">const</span> <span class="keywordtype">char</span>*)md5_digest, 16);
00981 
00982     out[MD5_DIGEST_LEN] = 0;
00983 
00984     <span class="keywordflow">return</span> 0;
00985 err:
00986     <span class="keywordflow">return</span> ~0;
00987 }
00988 
<a name="l00989"></a><a class="code" href="group__u__t.html#ga40">00989</a> <span class="keywordtype">int</span> <a class="code" href="group__u__t.html#ga40">u_signal</a>(<span class="keywordtype">int</span> sig, u_sig_t handler)
00990 {
00991 <span class="preprocessor">#ifdef OS_WIN</span>
00992 <span class="preprocessor"></span>    dbg_err_if(signal(sig, handler) == SIG_ERR);
00993 <span class="preprocessor">#else</span>
00994 <span class="preprocessor"></span>    <span class="keyword">struct </span>sigaction action;
00995     sigset_t all;
00996 
00997     sigfillset(&amp;all); 
00998     action.sa_mask = all;
00999     action.sa_handler = handler;
01000 
01001     <span class="comment">/* disable child shell jobs notification */</span>
01002     action.sa_flags = sig == SIGCHLD ? SA_NOCLDSTOP : 0;      
01003     dbg_err_if(sigaction(sig, &amp;action, (<span class="keyword">struct</span> sigaction *) 0));
01004 <span class="preprocessor">#endif</span>
01005 <span class="preprocessor"></span>
01006     <span class="keywordflow">return</span> 0;
01007 err:
01008     <span class="keywordflow">return</span> ~0;
01009 }                                                             
01010 
<a name="l01020"></a><a class="code" href="group__u__t.html#ga41">01020</a> <span class="keyword">const</span> <a class="code" href="structmime__map__s.html">mime_map_t</a> *<a class="code" href="group__u__t.html#ga41">u_get_mime_map</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *file_name)
01021 {
01022     <span class="keywordtype">char</span> *ext;
01023     <a class="code" href="structmime__map__s.html">mime_map_t</a> *mm;
01024 
01025     dbg_goto_if (file_name == NULL, notfound);
01026 
01027     <span class="keywordflow">if</span>((ext = strrchr(file_name, <span class="charliteral">'.'</span>)) != NULL)
01028     {
01029         ++ext; <span class="comment">/* skip '.' */</span>
01030         <span class="comment">/* FIXME binary search here */</span>
01031         <span class="keywordflow">for</span>(mm = mime_map; mm-&gt;<a class="code" href="structmime__map__s.html#o0">ext</a> &amp;&amp; mm-&gt;<a class="code" href="structmime__map__s.html#o1">mime_type</a>; ++mm)
01032         {
01033             <span class="keywordflow">if</span>(strcasecmp(mm-&gt;<a class="code" href="structmime__map__s.html#o0">ext</a>, ext) == 0)
01034                 <span class="keywordflow">return</span> mm;
01035         }
01036     }
01037 
01038 notfound:
01039     <span class="keywordflow">return</span> mime_map; <span class="comment">/* the first item is the default */</span>
01040 }
01041 
<a name="l01052"></a><a class="code" href="group__u__t.html#ga42">01052</a> <span class="keyword">const</span> <span class="keywordtype">char</span> *<a class="code" href="group__u__t.html#ga42">u_guess_mime_type</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> *file_name)
01053 {
01054     <span class="keywordtype">char</span> *ext;
01055     <a class="code" href="structmime__map__s.html">mime_map_t</a> *mm;
01056 
01057     dbg_goto_if (file_name == NULL, notfound);
01058     
01059     <span class="keywordflow">if</span>((ext = strrchr(file_name, <span class="charliteral">'.'</span>)) != NULL)
01060     {
01061         ++ext; <span class="comment">/* skip '.' */</span>
01062         <span class="keywordflow">for</span>(mm = mime_map; mm-&gt;<a class="code" href="structmime__map__s.html#o0">ext</a> &amp;&amp; mm-&gt;<a class="code" href="structmime__map__s.html#o1">mime_type</a>; ++mm)
01063             <span class="keywordflow">if</span>(strcmp(mm-&gt;<a class="code" href="structmime__map__s.html#o0">ext</a>, ext) == 0)
01064                 <span class="keywordflow">return</span> mm-&gt;<a class="code" href="structmime__map__s.html#o1">mime_type</a>;
01065     }
01066 
01067 notfound:
01068     <span class="keywordflow">return</span> <span class="stringliteral">"application/octet-stream"</span>;
01069 }
01070 
01071 <span class="preprocessor">#ifdef HAVE_LIBZ</span>
01072 <span class="preprocessor"></span>
01086 <span class="keywordtype">int</span> <a class="code" href="utils_8h.html#a33">u_io_unzip_copy</a>(<a class="code" href="structio__s.html">io_t</a> *out, <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *data, size_t sz)
01087 {
01088     <a class="code" href="structcodec__s.html">codec_t</a> *zip = NULL;
01089     <a class="code" href="structio__s.html">io_t</a> *ios = NULL;
01090 
01091     dbg_return_if (out == NULL, ~0);
01092     dbg_return_if (data == NULL, ~0);
01093     
01094     <span class="comment">/* create an io_t around the HTML block */</span>
01095     dbg_err_if(<a class="code" href="io_8h.html#a6">io_mem_create</a>(data, sz, 0, &amp;ios));
01096 
01097     <span class="comment">/* apply a gzip codec */</span>
01098     dbg_err_if(<a class="code" href="group__codec__t.html#ga7">codec_gzip_create</a>(GZIP_UNCOMPRESS, &amp;zip));
01099     dbg_err_if(<a class="code" href="group__io__t.html#ga23">io_codec_add_tail</a>(ios, zip));
01100     zip = NULL; <span class="comment">/* io_free() will free the codec */</span>
01101 
01102     <span class="comment">/* pipe ios to out */</span>
01103     dbg_err_if(<a class="code" href="group__io__t.html#ga0">io_pipe</a>(out, ios) &lt; 0);
01104 
01105     <a class="code" href="group__io__t.html#ga12">io_free</a>(ios);
01106 
01107     <span class="keywordflow">return</span> 0;
01108 err:
01109     <span class="keywordflow">if</span>(zip)
01110         <a class="code" href="group__codec__t.html#ga3">codec_free</a>(zip);
01111     <span class="keywordflow">if</span>(ios)
01112         <a class="code" href="group__io__t.html#ga12">io_free</a>(ios);
01113     <span class="keywordflow">return</span> ~0;
01114 }
01115 <span class="preprocessor">#endif</span>
01116 <span class="preprocessor"></span>
01117 <span class="preprocessor">#ifdef HAVE_LIBOPENSSL</span>
01118 <span class="preprocessor"></span>
01139 <span class="keywordtype">int</span> u_cipher_encrypt(<span class="keyword">const</span> EVP_CIPHER *cipher, <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *key, 
01140     <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *iv, <span class="keywordtype">char</span> *dst, size_t *dcount, <span class="keyword">const</span> <span class="keywordtype">char</span> *src, size_t ssz)
01141 {
01142     EVP_CIPHER_CTX ctx;
01143     ssize_t dlen = 0;  <span class="comment">/* dst buffer length */</span>
01144     <span class="keywordtype">int</span> wr;
01145 
01146     dbg_return_if (cipher == NULL, ~0);
01147     dbg_return_if (key == NULL, ~0);
01148     dbg_return_if (iv == NULL, ~0);
01149     dbg_return_if (dcount == NULL, ~0);
01150     dbg_return_if (src == NULL, ~0);
01151     dbg_return_if (dst == NULL, ~0);
01152     
01153     <span class="comment">/* init the context */</span>
01154     EVP_CIPHER_CTX_init(&amp;ctx);
01155 
01156     <span class="comment">/* be sure that the cipher has been loaded */</span>
01157     EVP_add_cipher(cipher);
01158     
01159     dbg_err_if(!EVP_EncryptInit_ex(&amp;ctx, cipher, NULL, key, iv));
01160 
01161     dbg_err_if(!EVP_EncryptUpdate(&amp;ctx, dst, &amp;wr, src, ssz));
01162     dlen += wr;
01163     dst += wr;
01164 
01165     dbg_err_if(!EVP_EncryptFinal_ex(&amp;ctx, dst, &amp;wr));
01166     dlen += wr;
01167 
01168     *dcount = dlen; <span class="comment">/* # of bytes written to dst */</span>
01169 
01170     EVP_CIPHER_CTX_cleanup(&amp;ctx);
01171 
01172     <span class="keywordflow">return</span> 0;
01173 err:
01174     EVP_CIPHER_CTX_cleanup(&amp;ctx);
01175     <span class="keywordflow">return</span> ~0;
01176 }
01177 
01197 <span class="keywordtype">int</span> u_cipher_decrypt(<span class="keyword">const</span> EVP_CIPHER *cipher, <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *key, 
01198     <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> *iv, <span class="keywordtype">char</span> *dst, size_t *dcount, <span class="keyword">const</span> <span class="keywordtype">char</span> *src, size_t ssz)
01199 {
01200     EVP_CIPHER_CTX ctx;
01201     ssize_t dlen = 0;  <span class="comment">/* dst buffer length */</span>
01202     <span class="keywordtype">int</span> wr;
01203 
01204     dbg_return_if (cipher == NULL, ~0);
01205     dbg_return_if (key == NULL, ~0);
01206     dbg_return_if (iv == NULL, ~0);
01207     dbg_return_if (dcount == NULL, ~0);
01208     dbg_return_if (src == NULL, ~0);
01209     dbg_return_if (dst == NULL, ~0);
01210 
01211     <span class="comment">/* init the context */</span>
01212     EVP_CIPHER_CTX_init(&amp;ctx);
01213 
01214     <span class="comment">/* be sure that the cipher has been loaded */</span>
01215     EVP_add_cipher(cipher);
01216     
01217     dbg_err_if(!EVP_DecryptInit_ex(&amp;ctx, cipher, NULL, key, iv));
01218 
01219     dbg_err_if(!EVP_DecryptUpdate(&amp;ctx, dst, &amp;wr, src, ssz));
01220     dlen += wr;
01221     dst += wr;
01222 
01223     dbg_err_if(!EVP_DecryptFinal_ex(&amp;ctx, dst, &amp;wr));
01224     dlen += wr;
01225 
01226     *dcount = dlen; <span class="comment">/* # of bytes written to dst */</span>
01227 
01228     EVP_CIPHER_CTX_cleanup(&amp;ctx);
01229 
01230     <span class="keywordflow">return</span> 0;
01231 err:
01232     EVP_CIPHER_CTX_cleanup(&amp;ctx);
01233     <span class="keywordflow">return</span> ~0;
01234 }
01235 
01236 <span class="preprocessor">#endif</span>
01237 <span class="preprocessor"></span>
</pre></div><hr>
<div> 
  <div style="text-align:left">
    <a href="http://www.koanlogic.com/kl/cont/gb/html/products.html">&larr;Products</a>
  </div>
  <div style="text-align:center;">
    &copy; 2005-2006 - <a href="http://www.koanlogic.com">KoanLogic S.r.l.</a> - All rights reserved
  </div>
</div>

</body>
</html>