PageRenderTime 62ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 1ms

/opensource.apple.com/source/fetchmail/fetchmail-4.1/fetchmail/socket.c

#
C | 986 lines | 845 code | 91 blank | 50 comment | 72 complexity | 9a8ea29fe8d35d3046df74445a831221 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, GPL-2.0, BSD-3-Clause, GPL-3.0, MPL-2.0, LGPL-2.0, LGPL-2.1, CC-BY-SA-3.0, IPL-1.0, ISC, AGPL-1.0, AGPL-3.0, JSON, Apache-2.0, 0BSD

Large files files are truncated, but you can click here to view the full file

    

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    2. 

  2.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    3. 

  3. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
    4. 

  4. <head>
    5. 

  5. <title>socket.c</title>
    6. 

  6. <style type="text/css">
    7. 

  7. .enscript-comment { font-style: italic; color: rgb(178,34,34); }
    8. 

  8. .enscript-function-name { font-weight: bold; color: rgb(0,0,255); }
    9. 

  9. .enscript-variable-name { font-weight: bold; color: rgb(184,134,11); }
    10. 

  10. .enscript-keyword { font-weight: bold; color: rgb(160,32,240); }
    11. 

  11. .enscript-reference { font-weight: bold; color: rgb(95,158,160); }
    12. 

  12. .enscript-string { font-weight: bold; color: rgb(188,143,143); }
    13. 

  13. .enscript-builtin { font-weight: bold; color: rgb(218,112,214); }
    14. 

  14. .enscript-type { font-weight: bold; color: rgb(34,139,34); }
    15. 

  15. .enscript-highlight { text-decoration: underline; color: 0; }
    16. 

  16. </style>
    17. 

  17. </head>
    18. 

  18. <body id="top">
    19. 

  19. <h1 style="margin:8px;" id="f1">socket.c&nbsp;&nbsp;&nbsp;<span style="font-weight: normal; font-size: 0.5em;">[<a href="?txt">plain text</a>]</span></h1>
    20. 

  20. <hr/>
    21. 

  21. <div></div>
    22. 

  22. <pre>
    23. 

  23. <span class="enscript-comment">/*
    24. 

  24.  * socket.c -- socket library functions
    25. 

  25.  *
    26. 

  26.  * Copyright 1998 by Eric S. Raymond.
    27. 

  27.  * For license terms, see the file COPYING in this directory.
    28. 

  28.  */</span>
    29. 

  29. 

  30. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;config.h&quot;</span>
    31. 

  31. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;stdio.h&gt;</span>
    32. 

  32. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;errno.h&gt;</span>
    33. 

  33. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;string.h&gt;</span>
    34. 

  34. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;ctype.h&gt;</span> <span class="enscript-comment">/* isspace() */</span>
    35. 

  35. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_MEMORY_H</span>
    36. 

  36. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;memory.h&gt;</span>
    37. 

  37. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_MEMORY_H */</span>
    38. 

  38. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;sys/types.h&gt;</span>
    39. 

  39. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HAVE_NET_SOCKET_H</span>
    40. 

  40. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;sys/socket.h&gt;</span>
    41. 

  41. #<span class="enscript-reference">else</span>
    42. 

  42. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;net/socket.h&gt;</span>
    43. 

  43. #<span class="enscript-reference">endif</span>
    44. 

  44. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;sys/un.h&gt;</span>
    45. 

  45. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;netinet/in.h&gt;</span>
    46. 

  46. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_ARPA_INET_H</span>
    47. 

  47. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;arpa/inet.h&gt;</span>
    48. 

  48. #<span class="enscript-reference">endif</span>
    49. 

  49. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;netdb.h&gt;</span>
    50. 

  50. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">STDC_HEADERS</span>)
    51. 

  51. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;stdlib.h&gt;</span>
    52. 

  52. #<span class="enscript-reference">endif</span>
    53. 

  53. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HAVE_UNISTD_H</span>)
    54. 

  54. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;unistd.h&gt;</span>
    55. 

  55. #<span class="enscript-reference">endif</span>
    56. 

  56. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HAVE_STDARG_H</span>)
    57. 

  57. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;stdarg.h&gt;</span>
    58. 

  58. #<span class="enscript-reference">else</span>
    59. 

  59. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;varargs.h&gt;</span>
    60. 

  60. #<span class="enscript-reference">endif</span>
    61. 

  61. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;socket.h&quot;</span>
    62. 

  62. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;fetchmail.h&quot;</span>
    63. 

  63. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;i18n.h&quot;</span>
    64. 

  64. 

  65. <span class="enscript-comment">/* Defines to allow BeOS to play nice... */</span>
    66. 

  66. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">__BEOS__</span>
    67. 

  67. <span class="enscript-type">static</span> <span class="enscript-type">char</span> peeked;
    68. 

  68. #<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_close</span>(a)  closesocket(a)
    69. 

  69. #<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_write</span>(a,b,c)  send(a,b,c,0)
    70. 

  70. #<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_peek</span>(a,b,c)   recv(a,b,c,0)
    71. 

  71. #<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_read</span>(a,b,c)   recv(a,b,c,0)
    72. 

  72. #<span class="enscript-reference">else</span>
    73. 

  73. #<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_close</span>(a)  close(a)
    74. 

  74. #<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_write</span>(a,b,c)  write(a,b,c)
    75. 

  75. #<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_peek</span>(a,b,c)   recv(a,b,c, MSG_PEEK)
    76. 

  76. #<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_read</span>(a,b,c)   read(a,b,c)
    77. 

  77. #<span class="enscript-reference">endif</span>
    78. 

  78. 

  79. <span class="enscript-comment">/* We need to define h_errno only if it is not already */</span>
    80. 

  80. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">h_errno</span>
    81. 

  81. 

  82. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_RES_SEARCH</span>
    83. 

  83. <span class="enscript-comment">/* some versions of FreeBSD should declare this but don't */</span>
    84. 

  84. <span class="enscript-type">extern</span> <span class="enscript-type">int</span> h_errno;
    85. 

  85. #<span class="enscript-reference">else</span>
    86. 

  86. <span class="enscript-comment">/* pretend we have h_errno to avoid some #ifdef's later */</span>
    87. 

  87. <span class="enscript-type">static</span> <span class="enscript-type">int</span> h_errno;
    88. 

  88. #<span class="enscript-reference">endif</span>
    89. 

  89. 

  90. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* ndef h_errno */</span>
    91. 

  91. 

  92. #<span class="enscript-reference">if</span> <span class="enscript-variable-name">NET_SECURITY</span>
    93. 

  93. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;net/security.h&gt;</span>
    94. 

  94. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* NET_SECURITY */</span>
    95. 

  95. 

  96. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_SOCKETPAIR</span>
    97. 

  97. <span class="enscript-type">char</span> *<span class="enscript-type">const</span> *<span class="enscript-function-name">parse_plugin</span>(<span class="enscript-type">const</span> <span class="enscript-type">char</span> *plugin, <span class="enscript-type">const</span> <span class="enscript-type">char</span> *host, <span class="enscript-type">const</span> <span class="enscript-type">char</span> *service)
    98. 

  98. {	<span class="enscript-type">const</span> <span class="enscript-type">char</span> **argvec;
    99. 

  99. 	<span class="enscript-type">const</span> <span class="enscript-type">char</span> *c, *p;
    100. 

  100. 	<span class="enscript-type">char</span> *cp, *plugin_copy;
    101. 

  101. 	<span class="enscript-type">unsigned</span> <span class="enscript-type">int</span> plugin_copy_len;
    102. 

  102. 	<span class="enscript-type">unsigned</span> <span class="enscript-type">int</span> plugin_offset = 0, plugin_copy_offset = 0;
    103. 

  103. 	<span class="enscript-type">unsigned</span> <span class="enscript-type">int</span> i, s = 2 * <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">char</span>*), host_count = 0, service_count = 0;
    104. 

  104. 	<span class="enscript-type">unsigned</span> <span class="enscript-type">int</span> plugin_len = strlen(plugin);
    105. 

  105. 	<span class="enscript-type">unsigned</span> <span class="enscript-type">int</span> host_len = strlen(host);
    106. 

  106. 	<span class="enscript-type">unsigned</span> <span class="enscript-type">int</span> service_len = strlen(service);
    107. 

  107. 

  108. 	<span class="enscript-keyword">for</span> (c = p = plugin; *c; c++)
    109. 

  109. 	{	<span class="enscript-keyword">if</span> (isspace(*c) &amp;&amp; !isspace(*p))
    110. 

  110. 			s += <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">char</span>*);
    111. 

  111. 		<span class="enscript-keyword">if</span> (*p == <span class="enscript-string">'%'</span> &amp;&amp; *c == <span class="enscript-string">'h'</span>)
    112. 

  112. 			host_count++;
    113. 

  113. 		<span class="enscript-keyword">if</span> (*p == <span class="enscript-string">'%'</span> &amp;&amp; *c == <span class="enscript-string">'p'</span>)
    114. 

  114. 			service_count++;
    115. 

  115. 		p = c;
    116. 

  116. 	}
    117. 

  117. 

  118. 	plugin_copy_len = plugin_len + host_len * host_count + service_len * service_count;
    119. 

  119. 	plugin_copy = malloc(plugin_copy_len + 1);
    120. 

  120. 	<span class="enscript-keyword">if</span> (!plugin_copy)
    121. 

  121. 	{
    122. 

  122. 		report(stderr, _(<span class="enscript-string">&quot;fetchmail: malloc failed\n&quot;</span>));
    123. 

  123. 		<span class="enscript-keyword">return</span> NULL;
    124. 

  124. 	}
    125. 

  125. 

  126. 	<span class="enscript-keyword">while</span> (plugin_copy_offset &lt; plugin_copy_len)
    127. 

  127. 	{	<span class="enscript-keyword">if</span> ((plugin[plugin_offset] == <span class="enscript-string">'%'</span>) &amp;&amp; (plugin[plugin_offset + 1] == <span class="enscript-string">'h'</span>))
    128. 

  128. 		{	strcpy(plugin_copy + plugin_copy_offset, host);
    129. 

  129. 			plugin_offset += 2;
    130. 

  130. 			plugin_copy_offset += host_len;
    131. 

  131. 		}
    132. 

  132. 		<span class="enscript-keyword">else</span> <span class="enscript-keyword">if</span> ((plugin[plugin_offset] == <span class="enscript-string">'%'</span>) &amp;&amp; (plugin[plugin_offset + 1] == <span class="enscript-string">'p'</span>))
    133. 

  133. 		{	strcpy(plugin_copy + plugin_copy_offset, service);
    134. 

  134. 			plugin_offset += 2;
    135. 

  135. 			plugin_copy_offset += service_len;
    136. 

  136. 		}
    137. 

  137. 		<span class="enscript-keyword">else</span>
    138. 

  138. 		{	plugin_copy[plugin_copy_offset] = plugin[plugin_offset];
    139. 

  139. 			plugin_offset++;
    140. 

  140. 			plugin_copy_offset++;
    141. 

  141. 		}
    142. 

  142. 	}
    143. 

  143. 	plugin_copy[plugin_copy_len] = 0;
    144. 

  144. 

  145. 	argvec = malloc(s);
    146. 

  146. 	<span class="enscript-keyword">if</span> (!argvec)
    147. 

  147. 	{
    148. 

  148. 		report(stderr, _(<span class="enscript-string">&quot;fetchmail: malloc failed\n&quot;</span>));
    149. 

  149. 		<span class="enscript-keyword">return</span> NULL;
    150. 

  150. 	}
    151. 

  151. 	memset(argvec, 0, s);
    152. 

  152. 	<span class="enscript-keyword">for</span> (c = p = plugin_copy, i = 0; *c; c++)
    153. 

  153. 	{	<span class="enscript-keyword">if</span> ((!isspace(*c)) &amp;&amp; (c == p ? 1 : isspace(*p))) {
    154. 

  154. 			argvec[i] = c;
    155. 

  155. 			i++;
    156. 

  156. 		}
    157. 

  157. 		p = c;
    158. 

  158. 	}
    159. 

  159. 	<span class="enscript-keyword">for</span> (cp = plugin_copy; *cp; cp++)
    160. 

  160. 	{	<span class="enscript-keyword">if</span> (isspace(*cp))
    161. 

  161. 			*cp = 0;
    162. 

  162. 	}
    163. 

  163. 	<span class="enscript-keyword">return</span> (<span class="enscript-type">char</span> *<span class="enscript-type">const</span>*)argvec;
    164. 

  164. }
    165. 

  165. 

  166. <span class="enscript-type">static</span> <span class="enscript-type">int</span> <span class="enscript-function-name">handle_plugin</span>(<span class="enscript-type">const</span> <span class="enscript-type">char</span> *host,
    167. 

  167. 			 <span class="enscript-type">const</span> <span class="enscript-type">char</span> *service, <span class="enscript-type">const</span> <span class="enscript-type">char</span> *plugin)
    168. 

  168. <span class="enscript-comment">/* get a socket mediated through a given external command */</span>
    169. 

  169. {
    170. 

  170.     <span class="enscript-type">int</span> fds[2];
    171. 

  171.     <span class="enscript-type">char</span> *<span class="enscript-type">const</span> *argvec;
    172. 

  172. 

  173.     <span class="enscript-comment">/*
    174. 

  174.      * The author of this code, Felix von Leitner &lt;<a href="mailto:felix@convergence.de">felix@convergence.de</a>&gt;, says:
    175. 

  175.      * he chose socketpair() instead of pipe() because socketpair creates 
    176. 

  176.      * bidirectional sockets while allegedly some pipe() implementations don't.
    177. 

  177.      */</span>
    178. 

  178.     <span class="enscript-keyword">if</span> (socketpair(AF_UNIX,SOCK_STREAM,0,fds))
    179. 

  179.     {
    180. 

  180. 	report(stderr, _(<span class="enscript-string">&quot;fetchmail: socketpair failed\n&quot;</span>));
    181. 

  181. 	<span class="enscript-keyword">return</span> -1;
    182. 

  182.     }
    183. 

  183.     <span class="enscript-keyword">switch</span> (fork()) {
    184. 

  184. 	<span class="enscript-keyword">case</span> <span class="enscript-reference">-1</span>:
    185. 

  185. 		<span class="enscript-comment">/* error */</span>
    186. 

  186. 		report(stderr, _(<span class="enscript-string">&quot;fetchmail: fork failed\n&quot;</span>));
    187. 

  187. 		<span class="enscript-keyword">return</span> -1;
    188. 

  188. 		<span class="enscript-keyword">break</span>;
    189. 

  189. 	<span class="enscript-keyword">case</span> <span class="enscript-reference">0</span>:	<span class="enscript-comment">/* child */</span>
    190. 

  190. 		<span class="enscript-comment">/* fds[1] is the parent's end; close it for proper EOF
    191. 

  191. 		** detection */</span>
    192. 

  192. 		(<span class="enscript-type">void</span>) close(fds[1]);
    193. 

  193. 		<span class="enscript-keyword">if</span> ( (dup2(fds[0],0) == -1) || (dup2(fds[0],1) == -1) ) {
    194. 

  194. 			report(stderr, _(<span class="enscript-string">&quot;dup2 failed\n&quot;</span>));
    195. 

  195. 			exit(1);
    196. 

  196. 		}
    197. 

  197. 		<span class="enscript-comment">/* fds[0] is now connected to 0 and 1; close it */</span>
    198. 

  198. 		(<span class="enscript-type">void</span>) close(fds[0]);
    199. 

  199. 		<span class="enscript-keyword">if</span> (outlevel &gt;= O_VERBOSE)
    200. 

  200. 		    report(stderr, _(<span class="enscript-string">&quot;running %s (host %s service %s)\n&quot;</span>), plugin, host, service);
    201. 

  201. 		argvec = parse_plugin(plugin,host,service);
    202. 

  202. 		execvp(*argvec, argvec);
    203. 

  203. 		report(stderr, _(<span class="enscript-string">&quot;execvp(%s) failed\n&quot;</span>), *argvec);
    204. 

  204. 		exit(0);
    205. 

  205. 		<span class="enscript-keyword">break</span>;
    206. 

  206. 	<span class="enscript-reference">default</span>:	<span class="enscript-comment">/* parent */</span>
    207. 

  207. 		<span class="enscript-comment">/* NOP */</span>
    208. 

  208. 		<span class="enscript-keyword">break</span>;
    209. 

  209.     }
    210. 

  210.     <span class="enscript-comment">/* fds[0] is the child's end; close it for proper EOF detection */</span>
    211. 

  211.     (<span class="enscript-type">void</span>) close(fds[0]);
    212. 

  212.     <span class="enscript-keyword">return</span> fds[1];
    213. 

  213. }
    214. 

  214. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_SOCKETPAIR */</span>
    215. 

  215. 

  216. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">__UNUSED__</span>
    217. 

  217. #<span class="enscript-reference">include</span> <span class="enscript-string">&lt;sys/time.h&gt;</span>
    218. 

  218. 

  219. <span class="enscript-type">int</span> <span class="enscript-function-name">SockCheckOpen</span>(<span class="enscript-type">int</span> fd)
    220. 

  220. <span class="enscript-comment">/* poll given socket; is it selectable? */</span>
    221. 

  221. {
    222. 

  222.     fd_set r, w, e;
    223. 

  223.     <span class="enscript-type">int</span> rt;
    224. 

  224.     <span class="enscript-type">struct</span> timeval tv;
    225. 

  225.   
    226. 

  226.     <span class="enscript-keyword">for</span> (;;) 
    227. 

  227.     {
    228. 

  228. 	FD_ZERO(&amp;r); FD_ZERO(&amp;w); FD_ZERO(&amp;e);
    229. 

  229. 	FD_SET(fd, &amp;e);
    230. 

  230.     
    231. 

  231. 	tv.tv_sec = 0; tv.tv_usec = 0;
    232. 

  232. 	rt = select(fd+1, &amp;r, &amp;w, &amp;e, &amp;tv);
    233. 

  233. 	<span class="enscript-keyword">if</span> (rt == -1 &amp;&amp; (errno != EAGAIN &amp;&amp; errno != EINTR))
    234. 

  234. 	    <span class="enscript-keyword">return</span> 0;
    235. 

  235. 	<span class="enscript-keyword">if</span> (rt != -1)
    236. 

  236. 	    <span class="enscript-keyword">return</span> 1;
    237. 

  237.     }
    238. 

  238. }
    239. 

  239. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* __UNUSED__ */</span>
    240. 

  240. 

  241. <span class="enscript-type">int</span> <span class="enscript-function-name">UnixOpen</span>(<span class="enscript-type">const</span> <span class="enscript-type">char</span> *path)
    242. 

  242. {
    243. 

  243.     <span class="enscript-type">int</span> sock = -1;
    244. 

  244.     <span class="enscript-type">struct</span> sockaddr_un ad;
    245. 

  245.     memset(&amp;ad, 0, <span class="enscript-keyword">sizeof</span>(ad));
    246. 

  246.     ad.sun_family = AF_UNIX;
    247. 

  247.     strncpy(ad.sun_path, path, <span class="enscript-keyword">sizeof</span>(ad.sun_path)-1);
    248. 

  248. 

  249.     sock = socket( AF_UNIX, SOCK_STREAM, 0 );
    250. 

  250.     <span class="enscript-keyword">if</span> (sock &lt; 0)
    251. 

  251.     {
    252. 

  252. 	h_errno = 0;
    253. 

  253. 	<span class="enscript-keyword">return</span> -1;
    254. 

  254.     }
    255. 

  255.     <span class="enscript-keyword">if</span> (connect(sock, (<span class="enscript-type">struct</span> sockaddr *) &amp;ad, <span class="enscript-keyword">sizeof</span>(ad)) &lt; 0)
    256. 

  256.     {
    257. 

  257. 	<span class="enscript-type">int</span> olderr = errno;
    258. 

  258. 	fm_close(sock);	<span class="enscript-comment">/* don't use SockClose, no traffic yet */</span>
    259. 

  259. 	h_errno = 0;
    260. 

  260. 	errno = olderr;
    261. 

  261. 	<span class="enscript-keyword">return</span> -1;
    262. 

  262.     }
    263. 

  263.     <span class="enscript-keyword">return</span> sock;
    264. 

  264. }
    265. 

  265. 

  266. #<span class="enscript-reference">if</span> <span class="enscript-variable-name">INET6_ENABLE</span>
    267. 

  267. <span class="enscript-type">int</span> <span class="enscript-function-name">SockOpen</span>(<span class="enscript-type">const</span> <span class="enscript-type">char</span> *host, <span class="enscript-type">const</span> <span class="enscript-type">char</span> *service, <span class="enscript-type">const</span> <span class="enscript-type">char</span> *options,
    268. 

  268. 	     <span class="enscript-type">const</span> <span class="enscript-type">char</span> *plugin)
    269. 

  269. {
    270. 

  270.     <span class="enscript-type">struct</span> addrinfo *ai, *ai0, req;
    271. 

  271.     <span class="enscript-type">int</span> i;
    272. 

  272. #<span class="enscript-reference">if</span> <span class="enscript-variable-name">NET_SECURITY</span>
    273. 

  273.     <span class="enscript-type">void</span> *request = NULL;
    274. 

  274.     <span class="enscript-type">int</span> requestlen;
    275. 

  275. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* NET_SECURITY */</span>
    276. 

  276. 

  277. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_SOCKETPAIR</span>
    278. 

  278.     <span class="enscript-keyword">if</span> (plugin)
    279. 

  279. 	<span class="enscript-keyword">return</span> handle_plugin(host,service,plugin);
    280. 

  280. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_SOCKETPAIR */</span>
    281. 

  281.     memset(&amp;req, 0, <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">struct</span> addrinfo));
    282. 

  282.     req.ai_socktype = SOCK_STREAM;
    283. 

  283. 

  284.     <span class="enscript-keyword">if</span> (getaddrinfo(host, service, &amp;req, &amp;ai0)) {
    285. 

  285. 	report(stderr, _(<span class="enscript-string">&quot;fetchmail: getaddrinfo(%s.%s)\n&quot;</span>), host,service);
    286. 

  286. 	<span class="enscript-keyword">return</span> -1;
    287. 

  287.     }
    288. 

  288. 

  289. #<span class="enscript-reference">if</span> <span class="enscript-variable-name">NET_SECURITY</span>
    290. 

  290.     <span class="enscript-keyword">if</span> (!options)
    291. 

  291. 	requestlen = 0;
    292. 

  292.     <span class="enscript-keyword">else</span>
    293. 

  293. 	<span class="enscript-keyword">if</span> (net_security_strtorequest((<span class="enscript-type">char</span> *)options, &amp;request, &amp;requestlen))
    294. 

  294. 	    <span class="enscript-keyword">goto</span> <span class="enscript-reference">ret</span>;
    295. 

  295. 

  296.     i = inner_connect(ai0, request, requestlen, NULL, NULL, <span class="enscript-string">&quot;fetchmail&quot;</span>, NULL);
    297. 

  297.     <span class="enscript-keyword">if</span> (request)
    298. 

  298. 	free(request);
    299. 

  299. 

  300.  <span class="enscript-reference">ret</span>:
    301. 

  301. #<span class="enscript-reference">else</span> <span class="enscript-comment">/* NET_SECURITY */</span>
    302. 

  302. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_INNER_CONNECT</span>
    303. 

  303.     i = inner_connect(ai0, NULL, 0, NULL, NULL, <span class="enscript-string">&quot;fetchmail&quot;</span>, NULL);
    304. 

  304.     <span class="enscript-keyword">if</span> (i &gt;= 0)
    305. 

  305. 	<span class="enscript-keyword">break</span>;
    306. 

  306. #<span class="enscript-reference">else</span>
    307. 

  307.     i = -1;
    308. 

  308.     <span class="enscript-keyword">for</span> (ai = ai0; ai; ai = ai-&gt;ai_next) {
    309. 

  309. 	i = socket(ai-&gt;ai_family, ai-&gt;ai_socktype, 0);
    310. 

  310. 	<span class="enscript-keyword">if</span> (i &lt; 0)
    311. 

  311. 	    <span class="enscript-keyword">continue</span>;
    312. 

  312. 	<span class="enscript-keyword">if</span> (connect(i, (<span class="enscript-type">struct</span> sockaddr *) ai-&gt;ai_addr, ai-&gt;ai_addrlen) &lt; 0) {
    313. 

  313. 	    fm_close(i);
    314. 

  314. 	    i = -1;
    315. 

  315. 	    <span class="enscript-keyword">continue</span>;
    316. 

  316. 	}
    317. 

  317. 	<span class="enscript-keyword">break</span>;
    318. 

  318.     }
    319. 

  319. #<span class="enscript-reference">endif</span>
    320. 

  320. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* NET_SECURITY */</span>
    321. 

  321. 

  322.     freeaddrinfo(ai0);
    323. 

  323. 

  324.     <span class="enscript-keyword">return</span> i;
    325. 

  325. }
    326. 

  326. #<span class="enscript-reference">else</span> <span class="enscript-comment">/* INET6_ENABLE */</span>
    327. 

  327. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HAVE_INET_ATON</span>
    328. 

  328. #<span class="enscript-reference">ifndef</span>  <span class="enscript-variable-name">INADDR_NONE</span>
    329. 

  329. #<span class="enscript-reference">ifdef</span>   <span class="enscript-variable-name">INADDR_BROADCAST</span>
    330. 

  330. #<span class="enscript-reference">define</span>  <span class="enscript-variable-name">INADDR_NONE</span>	INADDR_BROADCAST
    331. 

  331. #<span class="enscript-reference">else</span>
    332. 

  332. #<span class="enscript-reference">define</span>	 <span class="enscript-variable-name">INADDR_NONE</span>	-1
    333. 

  333. #<span class="enscript-reference">endif</span>
    334. 

  334. #<span class="enscript-reference">endif</span>
    335. 

  335. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_INET_ATON */</span>
    336. 

  336. 

  337. <span class="enscript-type">int</span> <span class="enscript-function-name">SockOpen</span>(<span class="enscript-type">const</span> <span class="enscript-type">char</span> *host, <span class="enscript-type">int</span> clientPort, <span class="enscript-type">const</span> <span class="enscript-type">char</span> *options,
    338. 

  338. 	     <span class="enscript-type">const</span> <span class="enscript-type">char</span> *plugin)
    339. 

  339. {
    340. 

  340.     <span class="enscript-type">int</span> sock = -1;	<span class="enscript-comment">/* pacify -Wall */</span>
    341. 

  341. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HAVE_INET_ATON</span>
    342. 

  342.     <span class="enscript-type">unsigned</span> <span class="enscript-type">long</span> inaddr;
    343. 

  343. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_INET_ATON */</span>
    344. 

  344.     <span class="enscript-type">struct</span> sockaddr_in ad, **pptr;
    345. 

  345.     <span class="enscript-type">struct</span> hostent *hp;
    346. 

  346. 

  347. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_SOCKETPAIR</span>
    348. 

  348.     <span class="enscript-keyword">if</span> (plugin) {
    349. 

  349.       <span class="enscript-type">char</span> buf[10];
    350. 

  350. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_SNPRINTF</span>
    351. 

  351.       snprintf(buf, <span class="enscript-keyword">sizeof</span>(buf),  <span class="enscript-comment">/* Yeah, paranoic. So what? :P */</span>
    352. 

  352. #<span class="enscript-reference">else</span>
    353. 

  353.       sprintf(buf,
    354. 

  354. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_SNPRINTF */</span>
    355. 

  355. 	      <span class="enscript-string">&quot;%d&quot;</span>,clientPort);
    356. 

  356.       <span class="enscript-keyword">return</span> handle_plugin(host,buf,plugin);
    357. 

  357.     }
    358. 

  358. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_SOCKETPAIR */</span>
    359. 

  359. 

  360.     memset(&amp;ad, 0, <span class="enscript-keyword">sizeof</span>(ad));
    361. 

  361.     ad.sin_family = AF_INET;
    362. 

  362. 

  363.     <span class="enscript-comment">/* we'll accept a quad address */</span>
    364. 

  364. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HAVE_INET_ATON</span>
    365. 

  365.     inaddr = inet_addr(host);
    366. 

  366.     <span class="enscript-keyword">if</span> (inaddr != INADDR_NONE)
    367. 

  367.     {
    368. 

  368.         memcpy(&amp;ad.sin_addr, &amp;inaddr, <span class="enscript-keyword">sizeof</span>(inaddr));
    369. 

  369. #<span class="enscript-reference">else</span>
    370. 

  370.     <span class="enscript-keyword">if</span> (inet_aton(host, &amp;ad.sin_addr))
    371. 

  371.     {
    372. 

  372. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_INET_ATON */</span>
    373. 

  373.         ad.sin_port = htons(clientPort);
    374. 

  374. 

  375.         sock = socket(AF_INET, SOCK_STREAM, 0);
    376. 

  376.         <span class="enscript-keyword">if</span> (sock &lt; 0)
    377. 

  377.         {
    378. 

  378.             h_errno = 0;
    379. 

  379.             <span class="enscript-keyword">return</span> -1;
    380. 

  380.         }
    381. 

  381.         <span class="enscript-keyword">if</span> (connect(sock, (<span class="enscript-type">struct</span> sockaddr *) &amp;ad, <span class="enscript-keyword">sizeof</span>(ad)) &lt; 0)
    382. 

  382.         {
    383. 

  383.             <span class="enscript-type">int</span> olderr = errno;
    384. 

  384.             fm_close(sock);	<span class="enscript-comment">/* don't use SockClose, no traffic yet */</span>
    385. 

  385.             h_errno = 0;
    386. 

  386.             errno = olderr;
    387. 

  387.             <span class="enscript-keyword">return</span> -1;
    388. 

  388.         }
    389. 

  389. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">HAVE_INET_ATON</span>
    390. 

  390.     }
    391. 

  391. #<span class="enscript-reference">else</span>
    392. 

  392.     }
    393. 

  393. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* HAVE_INET_ATON */</span>
    394. 

  394.     <span class="enscript-keyword">else</span> {
    395. 

  395.         hp = gethostbyname(host);
    396. 

  396. 

  397.         <span class="enscript-keyword">if</span> (hp == NULL)
    398. 

  398. 	{
    399. 

  399. 	    errno = 0;
    400. 

  400. 	    <span class="enscript-keyword">return</span> -1;
    401. 

  401. 	}
    402. 

  402. 	<span class="enscript-comment">/*
    403. 

  403. 	 * Add a check to make sure the address has a valid IPv4 or IPv6
    404. 

  404. 	 * length.  This prevents buffer spamming by a broken DNS.
    405. 

  405. 	 */</span>
    406. 

  406. 	<span class="enscript-keyword">if</span>(hp-&gt;h_length != 4 &amp;&amp; hp-&gt;h_length != 8)
    407. 

  407. 	{
    408. 

  408. 	    h_errno = errno = 0;
    409. 

  409. 	    report(stderr, 
    410. 

  410. 		   _(<span class="enscript-string">&quot;fetchmail: illegal address length received for host %s\n&quot;</span>),host);
    411. 

  411. 	    <span class="enscript-keyword">return</span> -1;
    412. 

  412. 	}
    413. 

  413. 	<span class="enscript-comment">/*
    414. 

  414. 	 * Try all addresses of a possibly multihomed host until we get
    415. 

  415. 	 * a successful connect or until we run out of addresses.
    416. 

  416. 	 */</span>
    417. 

  417. 	pptr = (<span class="enscript-type">struct</span> sockaddr_in **)hp-&gt;h_addr_list;
    418. 

  418. 	<span class="enscript-keyword">for</span>(; *pptr != NULL; pptr++)
    419. 

  419. 	{
    420. 

  420. 	    sock = socket(AF_INET, SOCK_STREAM, 0);
    421. 

  421. 	    <span class="enscript-keyword">if</span> (sock &lt; 0)
    422. 

  422. 	    {
    423. 

  423. 		h_errno = 0;
    424. 

  424. 		<span class="enscript-keyword">return</span> -1;
    425. 

  425. 	    }
    426. 

  426. 	    ad.sin_port = htons(clientPort);
    427. 

  427. 	    memcpy(&amp;ad.sin_addr, *pptr, <span class="enscript-keyword">sizeof</span>(<span class="enscript-type">struct</span> in_addr));
    428. 

  428. 	    <span class="enscript-keyword">if</span> (connect(sock, (<span class="enscript-type">struct</span> sockaddr *) &amp;ad, <span class="enscript-keyword">sizeof</span>(ad)) == 0)
    429. 

  429. 		<span class="enscript-keyword">break</span>; <span class="enscript-comment">/* success */</span>
    430. 

  430. 	    fm_close(sock);	<span class="enscript-comment">/* don't use SockClose, no traffic yet */</span>
    431. 

  431. 	    memset(&amp;ad, 0, <span class="enscript-keyword">sizeof</span>(ad));
    432. 

  432. 	    ad.sin_family = AF_INET;
    433. 

  433. 	}
    434. 

  434. 	<span class="enscript-keyword">if</span>(*pptr == NULL)
    435. 

  435. 	{
    436. 

  436. 	    <span class="enscript-type">int</span> olderr = errno;
    437. 

  437. 	    fm_close(sock);	<span class="enscript-comment">/* don't use SockClose, no traffic yet */</span>
    438. 

  438. 	    h_errno = 0;
    439. 

  439. 	    errno = olderr;
    440. 

  440. 	    <span class="enscript-keyword">return</span> -1;
    441. 

  441. 	}
    442. 

  442.     }
    443. 

  443. 

  444.     <span class="enscript-keyword">return</span>(sock);
    445. 

  445. }
    446. 

  446. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* INET6_ENABLE */</span>
    447. 

  447. 

  448. 

  449. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HAVE_STDARG_H</span>)
    450. 

  450. <span class="enscript-type">int</span> <span class="enscript-function-name">SockPrintf</span>(<span class="enscript-type">int</span> sock, <span class="enscript-type">const</span> <span class="enscript-type">char</span>* format, ...)
    451. 

  451. {
    452. 

  452. #<span class="enscript-reference">else</span>
    453. 

  453. <span class="enscript-type">int</span> <span class="enscript-function-name">SockPrintf</span>(sock,format,va_alist)
    454. 

  454. <span class="enscript-type">int</span> sock;
    455. 

  455. <span class="enscript-type">char</span> *format;
    456. 

  456. va_dcl {
    457. 

  457. #<span class="enscript-reference">endif</span>
    458. 

  458. 

  459.     va_list ap;
    460. 

  460.     <span class="enscript-type">char</span> buf[8192];
    461. 

  461. 

  462. #<span class="enscript-reference">if</span> <span class="enscript-reference">defined</span>(<span class="enscript-variable-name">HAVE_STDARG_H</span>)
    463. 

  463.     va_start(ap, format) ;
    464. 

  464. #<span class="enscript-reference">else</span>
    465. 

  465.     va_start(ap);
    466. 

  466. #<span class="enscript-reference">endif</span>
    467. 

  467. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_VSNPRINTF</span>
    468. 

  468.     vsnprintf(buf, <span class="enscript-keyword">sizeof</span>(buf), format, ap);
    469. 

  469. #<span class="enscript-reference">else</span>
    470. 

  470.     vsprintf(buf, format, ap);
    471. 

  471. #<span class="enscript-reference">endif</span>
    472. 

  472.     va_end(ap);
    473. 

  473.     <span class="enscript-keyword">return</span> SockWrite(sock, buf, strlen(buf));
    474. 

  474. 

  475. }
    476. 

  476. 

  477. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">SSL_ENABLE</span>
    478. 

  478. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;openssl/ssl.h&quot;</span>
    479. 

  479. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;openssl/err.h&quot;</span>
    480. 

  480. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;openssl/pem.h&quot;</span>
    481. 

  481. #<span class="enscript-reference">include</span> <span class="enscript-string">&quot;openssl/x509.h&quot;</span>
    482. 

  482. 

  483. <span class="enscript-type">static</span>	SSL_CTX *_ctx = NULL;
    484. 

  484. <span class="enscript-type">static</span>	SSL *_ssl_context[FD_SETSIZE];
    485. 

  485. 

  486. SSL	*SSLGetContext( <span class="enscript-type">int</span> );
    487. 

  487. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* SSL_ENABLE */</span>
    488. 

  488. 

  489. <span class="enscript-type">int</span> <span class="enscript-function-name">SockWrite</span>(<span class="enscript-type">int</span> sock, <span class="enscript-type">char</span> *buf, <span class="enscript-type">int</span> len)
    490. 

  490. {
    491. 

  491.     <span class="enscript-type">int</span> n, wrlen = 0;
    492. 

  492. #<span class="enscript-reference">ifdef</span>	<span class="enscript-variable-name">SSL_ENABLE</span>
    493. 

  493.     SSL *ssl;
    494. 

  494. #<span class="enscript-reference">endif</span>
    495. 

  495. 

  496.     <span class="enscript-keyword">while</span> (len)
    497. 

  497.     {
    498. 

  498. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">SSL_ENABLE</span>
    499. 

  499. 	<span class="enscript-keyword">if</span>( NULL != ( ssl = SSLGetContext( sock ) ) )
    500. 

  500. 		n = SSL_write(ssl, buf, len);
    501. 

  501. 	<span class="enscript-keyword">else</span>
    502. 

  502.        	n = fm_write(sock, buf, len);
    503. 

  503. #<span class="enscript-reference">else</span>
    504. 

  504.         n = fm_write(sock, buf, len);
    505. 

  505. #<span class="enscript-reference">endif</span>
    506. 

  506.         <span class="enscript-keyword">if</span> (n &lt;= 0)
    507. 

  507.             <span class="enscript-keyword">return</span> -1;
    508. 

  508.         len -= n;
    509. 

  509. 	wrlen += n;
    510. 

  510. 	buf += n;
    511. 

  511.     }
    512. 

  512.     <span class="enscript-keyword">return</span> wrlen;
    513. 

  513. }
    514. 

  514. 

  515. <span class="enscript-type">int</span> <span class="enscript-function-name">SockRead</span>(<span class="enscript-type">int</span> sock, <span class="enscript-type">char</span> *buf, <span class="enscript-type">int</span> len)
    516. 

  516. {
    517. 

  517.     <span class="enscript-type">char</span> *newline, *bp = buf;
    518. 

  518.     <span class="enscript-type">int</span> n;
    519. 

  519. #<span class="enscript-reference">ifdef</span>	<span class="enscript-variable-name">SSL_ENABLE</span>
    520. 

  520.     SSL *ssl;
    521. 

  521. #<span class="enscript-reference">endif</span>
    522. 

  522. 

  523.     <span class="enscript-keyword">if</span> (--len &lt; 1)
    524. 

  524. 	<span class="enscript-keyword">return</span>(-1);
    525. 

  525. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">__BEOS__</span>
    526. 

  526.     <span class="enscript-keyword">if</span> (peeked != 0){
    527. 

  527.         (*bp) = peeked;
    528. 

  528.         bp++;
    529. 

  529.         len--;
    530. 

  530.         peeked = 0;
    531. 

  531.     }
    532. 

  532. #<span class="enscript-reference">endif</span>        
    533. 

  533.     <span class="enscript-keyword">do</span> {
    534. 

  534. 	<span class="enscript-comment">/* 
    535. 

  535. 	 * The reason for these gymnastics is that we want two things:
    536. 

  536. 	 * (1) to read \n-terminated lines,
    537. 

  537. 	 * (2) to return the true length of data read, even if the
    538. 

  538. 	 *     data coming in has embedded NULS.
    539. 

  539. 	 */</span>
    540. 

  540. #<span class="enscript-reference">ifdef</span>	<span class="enscript-variable-name">SSL_ENABLE</span>
    541. 

  541. 	<span class="enscript-keyword">if</span>( NULL != ( ssl = SSLGetContext( sock ) ) ) {
    542. 

  542. 		<span class="enscript-comment">/* Hack alert! */</span>
    543. 

  543. 		<span class="enscript-comment">/* OK...  SSL_peek works a little different from MSG_PEEK
    544. 

  544. 			Problem is that SSL_peek can return 0 if there
    545. 

  545. 			is no data currently available.  If, on the other
    546. 

  546. 			hand, we loose the socket, we also get a zero, but
    547. 

  547. 			the SSL_read then SEGFAULTS!  To deal with this,
    548. 

  548. 			we'll check the error code any time we get a return
    549. 

  549. 			of zero from SSL_peek.  If we have an error, we bail.
    550. 

  550. 			If we don't, we read one character in SSL_read and
    551. 

  551. 			loop.  This should continue to work even if they
    552. 

  552. 			later change the behavior of SSL_peek
    553. 

  553. 			to &quot;fix&quot; this problem...  :-(	*/</span>
    554. 

  554. 		<span class="enscript-keyword">if</span> ((n = SSL_peek(ssl, bp, len)) &lt; 0) {
    555. 

  555. 			<span class="enscript-keyword">return</span>(-1);
    556. 

  556. 		}
    557. 

  557. 		<span class="enscript-keyword">if</span>( 0 == n ) {
    558. 

  558. 			<span class="enscript-comment">/* SSL_peek says no data...  Does he mean no data
    559. 

  559. 			or did the connection blow up?  If we got an error
    560. 

  560. 			then bail! */</span>
    561. 

  561. 			<span class="enscript-keyword">if</span>( 0 != ( n = ERR_get_error() ) ) {
    562. 

  562. 				<span class="enscript-keyword">return</span> -1;
    563. 

  563. 			}
    564. 

  564. 			<span class="enscript-comment">/* We didn't get an error so read at least one
    565. 

  565. 				character at this point and loop */</span>
    566. 

  566. 			n = 1;
    567. 

  567. 			<span class="enscript-comment">/* Make sure newline start out NULL!
    568. 

  568. 			 * We don't have a string to pass through
    569. 

  569. 			 * the strchr at this point yet */</span>
    570. 

  570. 			newline = NULL;
    571. 

  571. 		} <span class="enscript-keyword">else</span> <span class="enscript-keyword">if</span> ((newline = memchr(bp, <span class="enscript-string">'\n'</span>, n)) != NULL)
    572. 

  572. 			n = newline - bp + 1;
    573. 

  573. 		<span class="enscript-keyword">if</span> ((n = SSL_read(ssl, bp, n)) == -1) {
    574. 

  574. 			<span class="enscript-keyword">return</span>(-1);
    575. 

  575. 		}
    576. 

  576. 		<span class="enscript-comment">/* Check for case where our single character turned out to
    577. 

  577. 		 * be a newline...  (It wasn't going to get caught by
    578. 

  578. 		 * the strchr above if it came from the hack...  ). */</span>
    579. 

  579. 		<span class="enscript-keyword">if</span>( NULL == newline &amp;&amp; 1 == n &amp;&amp; <span class="enscript-string">'\n'</span> == *bp ) {
    580. 

  580. 			<span class="enscript-comment">/* Got our newline - this will break
    581. 

  581. 				out of the loop now */</span>
    582. 

  582. 			newline = bp;
    583. 

  583. 		}
    584. 

  584. 	} <span class="enscript-keyword">else</span> {
    585. 

  585. 		<span class="enscript-keyword">if</span> ((n = fm_peek(sock, bp, len)) &lt;= 0)
    586. 

  586. 			<span class="enscript-keyword">return</span>(-1);
    587. 

  587. 		<span class="enscript-keyword">if</span> ((newline = memchr(bp, <span class="enscript-string">'\n'</span>, n)) != NULL)
    588. 

  588. 			n = newline - bp + 1;
    589. 

  589. 		<span class="enscript-keyword">if</span> ((n = fm_read(sock, bp, n)) == -1)
    590. 

  590. 			<span class="enscript-keyword">return</span>(-1);
    591. 

  591. 	}
    592. 

  592. #<span class="enscript-reference">else</span>
    593. 

  593. 

  594. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">__BEOS__</span>
    595. 

  595.     <span class="enscript-keyword">if</span> ((n = fm_read(sock, bp, 1)) &lt;= 0)
    596. 

  596. #<span class="enscript-reference">else</span>
    597. 

  597.     <span class="enscript-keyword">if</span> ((n = fm_peek(sock, bp, len)) &lt;= 0)
    598. 

  598. #<span class="enscript-reference">endif</span>
    599. 

  599.         <span class="enscript-keyword">return</span> (-1);
    600. 

  600. 	<span class="enscript-keyword">if</span> ((newline = memchr(bp, <span class="enscript-string">'\n'</span>, n)) != NULL)
    601. 

  601. 	    n = newline - bp + 1;
    602. 

  602. #<span class="enscript-reference">ifndef</span> <span class="enscript-variable-name">__BEOS__</span>
    603. 

  603. 	<span class="enscript-keyword">if</span> ((n = fm_read(sock, bp, n)) == -1)
    604. 

  604. 	    <span class="enscript-keyword">return</span>(-1);
    605. 

  605. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* __BEOS__ */</span>
    606. 

  606. #<span class="enscript-reference">endif</span>
    607. 

  607. 	bp += n;
    608. 

  608. 	len -= n;
    609. 

  609.     } <span class="enscript-keyword">while</span> 
    610. 

  610. 	    (!newline &amp;&amp; len);
    611. 

  611.     *bp = <span class="enscript-string">'\0'</span>;
    612. 

  612.     <span class="enscript-keyword">return</span> bp - buf;
    613. 

  613. }
    614. 

  614. 

  615. <span class="enscript-type">int</span> <span class="enscript-function-name">SockPeek</span>(<span class="enscript-type">int</span> sock)
    616. 

  616. <span class="enscript-comment">/* peek at the next socket character without actually reading it */</span>
    617. 

  617. {
    618. 

  618.     <span class="enscript-type">int</span> n;
    619. 

  619.     <span class="enscript-type">char</span> ch;
    620. 

  620. #<span class="enscript-reference">ifdef</span>	<span class="enscript-variable-name">SSL_ENABLE</span>
    621. 

  621.     SSL *ssl;
    622. 

  622. #<span class="enscript-reference">endif</span>
    623. 

  623. 

  624. #<span class="enscript-reference">ifdef</span>	<span class="enscript-variable-name">SSL_ENABLE</span>
    625. 

  625. 	<span class="enscript-keyword">if</span>( NULL != ( ssl = SSLGetContext( sock ) ) ) {
    626. 

  626. 		n = SSL_peek(ssl, &amp;ch, 1);
    627. 

  627. 		<span class="enscript-keyword">if</span>( 0 == n ) {
    628. 

  628. 			<span class="enscript-comment">/* This code really needs to implement a &quot;hold back&quot;
    629. 

  629. 			 * to simulate a functioning SSL_peek()...  sigh...
    630. 

  630. 			 * Has to be coordinated with the read code above.
    631. 

  631. 			 * Next on the list todo...	*/</span>
    632. 

  632. 

  633. 			<span class="enscript-comment">/* SSL_peek says no data...  Does he mean no data
    634. 

  634. 			or did the connection blow up?  If we got an error
    635. 

  635. 			then bail! */</span>
    636. 

  636. 			<span class="enscript-keyword">if</span>( 0 != ( n = ERR_get_error() ) ) {
    637. 

  637. 				<span class="enscript-keyword">return</span> -1;
    638. 

  638. 			}
    639. 

  639. 

  640. 			<span class="enscript-comment">/* Haven't seen this case actually occur, but...
    641. 

  641. 			   if the problem in SockRead can occur, this should
    642. 

  642. 			   be possible...  Just not sure what to do here.
    643. 

  643. 			   This should be a safe &quot;punt&quot; the &quot;peek&quot; but don't
    644. 

  644. 			   &quot;punt&quot; the &quot;session&quot;... */</span>
    645. 

  645. 

  646. 			<span class="enscript-keyword">return</span> 0;	<span class="enscript-comment">/* Give him a '\0' character */</span>
    647. 

  647. 		}
    648. 

  648. 	} <span class="enscript-keyword">else</span> {
    649. 

  649.     		n = fm_peek(sock, &amp;ch, 1);
    650. 

  650. 	}
    651. 

  651. #<span class="enscript-reference">else</span>
    652. 

  652. 

  653.         n = fm_peek(sock, &amp;ch, 1);
    654. 

  654. 

  655. #<span class="enscript-reference">endif</span> <span class="enscript-comment">/* SSL_ENABLE */</span>
    656. 

  656. 	<span class="enscript-keyword">if</span> (n == -1)
    657. 

  657. 		<span class="enscript-keyword">return</span> -1;
    658. 

  658. 

  659. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">__BEOS__</span>
    660. 

  660.     peeked = ch;
    661. 

  661. #<span class="enscript-reference">endif</span>
    662. 

  662.     <span class="enscript-keyword">return</span>(ch);
    663. 

  663. }
    664. 

  664. 

  665. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">SSL_ENABLE</span>
    666. 

  666. 

  667. <span class="enscript-type">static</span>	<span class="enscript-type">char</span> *_ssl_server_cname = NULL;
    668. 

  668. <span class="enscript-type">static</span>	<span class="enscript-type">int</span> _check_fp;
    669. 

  669. <span class="enscript-type">static</span>	<span class="enscript-type">char</span> *_check_digest;
    670. 

  670. <span class="enscript-type">static</span> 	<span class="enscript-type">char</span> *_server_label;
    671. 

  671. <span class="enscript-type">static</span>	<span class="enscript-type">int</span> _depth0ck;
    672. 

  672. 

  673. SSL *<span class="enscript-function-name">SSLGetContext</span>( <span class="enscript-type">int</span> sock )
    674. 

  674. {
    675. 

  675. 	<span class="enscript-comment">/* If SSLOpen has never initialized - just return NULL */</span>
    676. 

  676. 	<span class="enscript-keyword">if</span>( NULL == _ctx )
    677. 

  677. 		<span class="enscript-keyword">return</span> NULL;
    678. 

  678. 

  679. 	<span class="enscript-keyword">if</span>( sock &lt; 0 || sock &gt; FD_SETSIZE )
    680. 

  680. 		<span class="enscript-keyword">return</span> NULL;
    681. 

  681. 	<span class="enscript-keyword">return</span> _ssl_context[sock];
    682. 

  682. }
    683. 

  683. 

  684. 

  685. <span class="enscript-type">int</span> <span class="enscript-function-name">SSL_verify_callback</span>( <span class="enscript-type">int</span> ok_return, X509_STORE_CTX *ctx, <span class="enscript-type">int</span> strict )
    686. 

  686. {
    687. 

  687. 	<span class="enscript-type">char</span> buf[257];
    688. 

  688. 	X509 *x509_cert;
    689. 

  689. 	<span class="enscript-type">int</span> err, depth;
    690. 

  690. 	<span class="enscript-type">unsigned</span> <span class="enscript-type">char</span> digest[EVP_MAX_MD_SIZE];
    691. 

  691. 	<span class="enscript-type">char</span> text[EVP_MAX_MD_SIZE * 3 + 1], *tp, *te;
    692. 

  692. 	EVP_MD *digest_tp;
    693. 

  693. 	<span class="enscript-type">unsigned</span> <span class="enscript-type">int</span> dsz, i, esz;
    694. 

  694. 	X509_NAME *subj, *issuer;
    695. 

  695. 

  696. 	x509_cert = X509_STORE_CTX_get_current_cert(ctx);
    697. 

  697. 	err = X509_STORE_CTX_get_error(ctx);
    698. 

  698. 	depth = X509_STORE_CTX_get_error_depth(ctx);
    699. 

  699. 

  700. 	subj = X509_get_subject_name(x509_cert);
    701. 

  701. 	issuer = X509_get_issuer_name(x509_cert);
    702. 

  702. 

  703. 	<span class="enscript-keyword">if</span> (depth == 0) {
    704. 

  704. 		_depth0ck = 1;
    705. 

  705. 		
    706. 

  706. 		<span class="enscript-keyword">if</span> (outlevel == O_VERBOSE) {
    707. 

  707. 			<span class="enscript-keyword">if</span> ((i = X509_NAME_get_text_by_NID(issuer, NID_organizationName, buf, <span class="enscript-keyword">sizeof</span>(buf))) != -1) {
    708. 

  708. 				report(stdout, _(<span class="enscript-string">&quot;Issuer Organization: %s\n&quot;</span>), buf);
    709. 

  709. 				<span class="enscript-keyword">if</span> (i &gt;= <span class="enscript-keyword">sizeof</span>(buf) - 1)
    710. 

  710. 					report(stdout, _(<span class="enscript-string">&quot;Warning: Issuer Organization Name too long (possibly truncated).\n&quot;</span>));
    711. 

  711. 			} <span class="enscript-keyword">else</span>
    712. 

  712. 				report(stdout, _(<span class="enscript-string">&quot;Unknown Organization\n&quot;</span>));
    713. 

  713. 			<span class="enscript-keyword">if</span> ((i = X509_NAME_get_text_by_NID(issuer, NID_commonName, buf, <span class="enscript-keyword">sizeof</span>(buf))) != -1) {
    714. 

  714. 				report(stdout, _(<span class="enscript-string">&quot;Issuer CommonName: %s\n&quot;</span>), buf);
    715. 

  715. 				<span class="enscript-keyword">if</span> (i &gt;= <span class="enscript-keyword">sizeof</span>(buf) - 1)
    716. 

  716. 					report(stdout, _(<span class="enscript-string">&quot;Warning: Issuer CommonName too long (possibly truncated).\n&quot;</span>));
    717. 

  717. 			} <span class="enscript-keyword">else</span>
    718. 

  718. 				report(stdout, _(<span class="enscript-string">&quot;Unknown Issuer CommonName\n&quot;</span>));
    719. 

  719. 		}
    720. 

  720. 		<span class="enscript-keyword">if</span> ((i = X509_NAME_get_text_by_NID(subj, NID_commonName, buf, <span class="enscript-keyword">sizeof</span>(buf))) != -1) {
    721. 

  721. 			<span class="enscript-keyword">if</span> (outlevel == O_VERBOSE)
    722. 

  722. 				report(stdout, _(<span class="enscript-string">&quot;Server CommonName: %s\n&quot;</span>), buf);
    723. 

  723. 			<span class="enscript-keyword">if</span> (i &gt;= <span class="enscript-keyword">sizeof</span>(buf) - 1) {
    724. 

  724. 				<span class="enscript-comment">/* Possible truncation. In this case, this is a DNS name, so this
    725. 

  725. 				 * is really bad. We do not tolerate this even in the non-strict case. */</span>
    726. 

  726. 				report(stderr, _(<span class="enscript-string">&quot;Bad certificate: Subject CommonName too long!\n&quot;</span>));
    727. 

  727. 				<span class="enscript-keyword">return</span> (0);
    728. 

  728. 			}
    729. 

  729. 			<span class="enscript-keyword">if</span> (_ssl_server_cname != NULL) {
    730. 

  730. 				<span class="enscript-type">char</span> *p1 = buf;
    731. 

  731. 				<span class="enscript-type">char</span> *p2 = _ssl_server_cname;
    732. 

  732. 				<span class="enscript-type">int</span> n;
    733. 

  733. 				
    734. 

  734. 				<span class="enscript-keyword">if</span> (*p1 == <span class="enscript-string">'*'</span>) {
    735. 

  735. 					++p1;
    736. 

  736. 					n = strlen(p2) - strlen(p1);
    737. 

  737. 					<span class="enscript-keyword">if</span> (n &gt;= 0)
    738. 

  738. 						p2 += n;
    739. 

  739. 				}	
    740. 

  740. 				<span class="enscript-keyword">if</span> (0 != strcasecmp(p1, p2)) {
    741. 

  741. 					report(stderr,
    742. 

  742. 					    _(<span class="enscript-string">&quot;Server CommonName mismatch: %s != %s\n&quot;</span>),
    743. 

  743. 					    buf, _ssl_server_cname );
    744. 

  744. 					<span class="enscript-keyword">if</span> (ok_return &amp;&amp; strict)
    745. 

  745. 						<span class="enscript-keyword">return</span> (0);
    746. 

  746. 				}
    747. 

  747. 			} <span class="enscript-keyword">else</span> <span class="enscript-keyword">if</span> (ok_return &amp;&amp; strict) {
    748. 

  748. 				report(stderr, _(<span class="enscript-string">&quot;Server name not set, could not verify certificate!\n&quot;</span>));
    749. 

  749. 				<span class="enscript-keyword">return</span> (0);
    750. 

  750. 			}
    751. 

  751. 		} <span class="enscript-keyword">else</span> {
    752. 

  752. 			<span class="enscript-keyword">if</span> (outlevel == O_VERBOSE)
    753. 

  753. 				report(stdout, _(<span class="enscript-string">&quot;Unknown Server CommonName\n&quot;</span>));
    754. 

  754. 			<span class="enscript-keyword">if</span> (ok_return &amp;&amp; strict) {
    755. 

  755. 				report(stderr, _(<span class="enscript-string">&quot;Server name not specified in certificate!\n&quot;</span>));
    756. 

  756. 				<span class="enscript-keyword">return</span> (0);
    757. 

  757. 			}
    758. 

  758. 		}
    759. 

  759. 		<span class="enscript-comment">/* Print the finger print. Note that on errors, we might print it more than once
    760. 

  760. 		 * normally; we kluge around that by using a global variable. */</span>
    761. 

  761. 		<span class="enscript-keyword">if</span> (_check_fp) {
    762. 

  762. 			_check_fp = 0;
    763. 

  763. 			digest_tp = EVP_md5();
    764. 

  764. 			<span class="enscript-keyword">if</span> (digest_tp == NULL) {
    765. 

  765. 				report(stderr, _(<span class="enscript-string">&quot;EVP_md5() failed!\n&quot;</span>));
    766. 

  766. 				<span class="enscript-keyword">return</span> (0);
    767. 

  767. 			}
    768. 

  768. 			<span class="enscript-keyword">if</span> (!X509_digest(x509_cert, digest_tp, digest, &amp;dsz)) {
    769. 

  769. 				report(stderr, _(<span class="enscript-string">&quot;Out of memory!\n&quot;</span>));
    770. 

  770. 				<span class="enscript-keyword">return</span> (0);
    771. 

  771. 			}
    772. 

  772. 			tp = text;
    773. 

  773. 			te = text + <span class="enscript-keyword">sizeof</span>(text);
    774. 

  774. 			<span class="enscript-keyword">for</span> (i = 0; i &lt; dsz; i++) {
    775. 

  775. #<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">HAVE_SNPRINTF</span>
    776. 

  776. 				esz = snprintf(tp, te - tp, i &gt; 0 ? <span class="enscript-string">&quot;:%02X&quot;</span> : <span class="enscript-string">&quot;%02X&quot;</span>, digest[i]);
    777. 

  777. #<span class="enscript-reference">else</span>
    778. 

  778. 				esz = sprintf(tp, i &gt; 0 ? <span class="enscript-string">&quot;:%02X&quot;</span> : <span class="enscript-string">&quot;%02X&quot;</span>, digest[i]);
    779. 

  779. #<span class="enscript-reference">endif</span>
    780. 

  780. 				<span class="enscript-keyword">if</span> (esz &gt;= te - tp) {
    781. 

  781. 					report(stderr, _(<span class="enscript-string">&quot;Digest text buffer too small!\n&quot;</span>));
    782. 

  782. 					<span class="enscript-keyword">return</span> (0);
    783. 

  783. 				}
    784. 

  784. 				tp += esz;
    785. 

  785. 			}
    786. 

  786. 			report(stdout, _(<span class="enscript-string">&quot;%s key fingerprint: %s\n&quot;</span>), _server_label, text);
    787. 

  787. 			<span class="enscript-keyword">if</span> (_check_digest != NULL) {
    788. 

  788. 				<span class="enscript-keyword">if</span> (strcmp(text, _check_digest) == 0)
    789. 

  789. 					report(stdout, _(<span class="enscript-string">&quot;%s fingerprints match.\n&quot;</span>), _server_label);
    790. 

  790. 				<span class="enscript-keyword">else</span> {
    791. 

  791. 					report(stderr, _(<span class="enscript-string">&quot;%s fingerprints do not match!\n&quot;</span>), _server_label);
    792. 

  792. 					<span class="enscript-keyword">return</span> (0);
    793. 

  793. 				}
    794. 

  794. 			}
    795. 

  795. 		}
    796. 

  796. 	}
    797. 

  797. 

  798. 	<span class="enscript-keyword">if</span> (err != X509_V_OK &amp;&amp; (strict || outlevel == O_VERBOSE)) {
    799. 

  799. 		report(strict ? stderr : stdout, _(<span class="enscript-string">&quot;Warning: server certificate verification: %s\n&quot;</span>), X509_verify_cert_error_string(err));
    800. 

  800. 		<span class="enscript-comment">/* We gave the error code, but maybe we can add some more details for debugging */</span>
    801. 

  801. 		<span class="enscript-keyword">switch</span> (err) {
    802. 

  802. 		<span class="enscript-keyword">case</span> <span class="enscript-reference">X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT</span>:
    803. 

  803. 			X509_NAME_oneline(issuer, buf, <span class="enscript-keyword">sizeof</span>(buf));
    804. 

  804. 			buf[<span class="enscript-keyword">sizeof</span>(buf) - 1] = <span class="enscript-string">'\0'</span>;
    805. 

  805. 			report(stdout, _(<span class="enscript-string">&quot;unknown issuer (first %d characters): %s\n&quot;</span>), <span class="enscript-keyword">sizeof</span>(buf), buf);
    806. 

  806. 			<span class="enscript-keyword">break</span>;
    807. 

  807. 		}
    808. 

  808. 	}
    809. 

  809. 	<span class="enscript-keyword">if</span> (!strict)
    810. 

  810. 		ok_return = 1;
    811. 

  811. 	<span class="enscript-keyword">return</span> (ok_return);
    812. 

  812. }
    813. 

  813. 

  814. <span class="enscript-type">int</span> <span class="enscript-function-name">SSL_nock_verify_callback</span>( <span class="enscript-type">int</span> ok_return, X509_STORE_CTX *ctx )
    815. 

  815. {
    816. 

  816. 	<span class="enscript-keyword">return</span> SSL_verify_callback(ok_return, ctx, 0);
    817. 

  817. }
    818. 

  818. 

  819. <span class="enscript-type">int</span> <span class="enscript-function-name">SSL_ck_verify_callback</span>( <span class="enscript-type">int</span> ok_return, X509_STORE_CTX *ctx )
    820. 

  820. {
    821. 

  821. 	<span class="enscript-keyword">return</span> SSL_verify_callback(ok_return, ctx, 1);
    822. 

  822. }
    823. 

  823. 

  824. <span class="enscript-comment">/* performs initial SSL handshake over the connected socket
    825. 

  825.  * uses SSL *ssl global variable, which is currently defined
    826. 

  826.  * in this file
    827. 

  827.  */</span>
    828. 

  828. <span class="enscript-type">int</span> <span class="enscript-function-name">SSLOpen</span>(<span class="enscript-type">int</span> sock, <span class="enscript-type">char</span> *mycert, <span class="enscript-type">char</span> *mykey, <span class="enscript-type">char</span> *myproto, <span class="enscript-type">int</span> certck, <span class="enscript-type">char</span> *certpath,
    829. 

  829.     <span class="enscript-type">char</span> *fingerprint, <span class="enscript-type">char</span> *servercname, <span class="enscript-type">char</span> *label)
    830. 

  830. {
    831. 

  831. 	SSL *ssl;
    832. 

  832. 	
    833. 

  833. 	SSL_load_error_strings();
    834. 

  834. 	SSLeay_add_ssl_algorithms();
    835. 

  835. 	
    836. 

  836. 	<span class="enscript-keyword">if</span>( sock &lt; 0 || sock &gt; FD_SETSIZE ) {
    837. 

  837. 		report(stderr, _(<span class="enscript-string">&quot;File descriptor out of range for SSL&quot;</span>) );
    838. 

  838. 		<span class="enscript-keyword">return</span>( -1 );
    839. 

  839. 	}
    840. 

  840. 

  841. 	<span class="enscript-keyword">if</span>( ! _ctx ) {
    842. 

  842. 		<span class="enscript-comment">/* Be picky and make sure the memory is cleared */</span>
    843. 

  843. 		memset( _ssl_context, 0, <span class="enscript-keyword">sizeof</span>…
    844.

Large files files are truncated, but you can click here to view the full file