2 * Copyright 2008 Hans Leidekker for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 #include "wine/port.h"
26 #include <sys/types.h>
27 #ifdef HAVE_SYS_SOCKET_H
28 # include <sys/socket.h>
30 #ifdef HAVE_SYS_IOCTL_H
31 # include <sys/ioctl.h>
33 #ifdef HAVE_SYS_FILIO_H
34 # include <sys/filio.h>
39 #ifdef HAVE_OPENSSL_SSL_H
40 # include <openssl/ssl.h>
45 #include "wine/debug.h"
46 #include "wine/library.h"
53 /* to avoid conflicts with the Unix socket headers */
57 #include "winhttp_private.h"
59 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
61 #define DEFAULT_SEND_TIMEOUT 30
62 #define DEFAULT_RECEIVE_TIMEOUT 30
64 #ifndef HAVE_GETADDRINFO
66 /* critical section to protect non-reentrant gethostbyname() */
67 static CRITICAL_SECTION cs_gethostbyname;
68 static CRITICAL_SECTION_DEBUG critsect_debug =
70 0, 0, &cs_gethostbyname,
71 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
72 0, 0, { (DWORD_PTR)(__FILE__ ": cs_gethostbyname") }
74 static CRITICAL_SECTION cs_gethostbyname = { &critsect_debug, -1, 0, 0, 0, 0 };
80 #include <openssl/err.h>
82 static void *libssl_handle;
83 static void *libcrypto_handle;
85 static SSL_METHOD *method;
88 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
90 MAKE_FUNCPTR( SSL_library_init );
91 MAKE_FUNCPTR( SSL_load_error_strings );
92 MAKE_FUNCPTR( SSLv23_method );
93 MAKE_FUNCPTR( SSL_CTX_new );
94 MAKE_FUNCPTR( SSL_new );
95 MAKE_FUNCPTR( SSL_free );
96 MAKE_FUNCPTR( SSL_set_fd );
97 MAKE_FUNCPTR( SSL_connect );
98 MAKE_FUNCPTR( SSL_shutdown );
99 MAKE_FUNCPTR( SSL_write );
100 MAKE_FUNCPTR( SSL_read );
101 MAKE_FUNCPTR( SSL_get_verify_result );
102 MAKE_FUNCPTR( SSL_get_peer_certificate );
103 MAKE_FUNCPTR( SSL_CTX_get_timeout );
104 MAKE_FUNCPTR( SSL_CTX_set_timeout );
105 MAKE_FUNCPTR( SSL_CTX_set_default_verify_paths );
106 MAKE_FUNCPTR( i2d_X509 );
108 MAKE_FUNCPTR( BIO_new_fp );
109 MAKE_FUNCPTR( ERR_get_error );
110 MAKE_FUNCPTR( ERR_error_string );
115 /* translate a unix error code into a winsock error code */
116 static int sock_get_error( int err )
120 case EINTR: return WSAEINTR;
121 case EBADF: return WSAEBADF;
123 case EACCES: return WSAEACCES;
124 case EFAULT: return WSAEFAULT;
125 case EINVAL: return WSAEINVAL;
126 case EMFILE: return WSAEMFILE;
127 case EWOULDBLOCK: return WSAEWOULDBLOCK;
128 case EINPROGRESS: return WSAEINPROGRESS;
129 case EALREADY: return WSAEALREADY;
130 case ENOTSOCK: return WSAENOTSOCK;
131 case EDESTADDRREQ: return WSAEDESTADDRREQ;
132 case EMSGSIZE: return WSAEMSGSIZE;
133 case EPROTOTYPE: return WSAEPROTOTYPE;
134 case ENOPROTOOPT: return WSAENOPROTOOPT;
135 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
136 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
137 case EOPNOTSUPP: return WSAEOPNOTSUPP;
138 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
139 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
140 case EADDRINUSE: return WSAEADDRINUSE;
141 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
142 case ENETDOWN: return WSAENETDOWN;
143 case ENETUNREACH: return WSAENETUNREACH;
144 case ENETRESET: return WSAENETRESET;
145 case ECONNABORTED: return WSAECONNABORTED;
147 case ECONNRESET: return WSAECONNRESET;
148 case ENOBUFS: return WSAENOBUFS;
149 case EISCONN: return WSAEISCONN;
150 case ENOTCONN: return WSAENOTCONN;
151 case ESHUTDOWN: return WSAESHUTDOWN;
152 case ETOOMANYREFS: return WSAETOOMANYREFS;
153 case ETIMEDOUT: return WSAETIMEDOUT;
154 case ECONNREFUSED: return WSAECONNREFUSED;
155 case ELOOP: return WSAELOOP;
156 case ENAMETOOLONG: return WSAENAMETOOLONG;
157 case EHOSTDOWN: return WSAEHOSTDOWN;
158 case EHOSTUNREACH: return WSAEHOSTUNREACH;
159 case ENOTEMPTY: return WSAENOTEMPTY;
161 case EPROCLIM: return WSAEPROCLIM;
164 case EUSERS: return WSAEUSERS;
167 case EDQUOT: return WSAEDQUOT;
170 case ESTALE: return WSAESTALE;
173 case EREMOTE: return WSAEREMOTE;
175 default: errno = err; perror( "sock_set_error" ); return WSAEFAULT;
180 BOOL netconn_init( netconn_t *conn, BOOL secure )
183 if (!secure) return TRUE;
185 #if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO)
186 if (libssl_handle) return TRUE;
187 if (!(libssl_handle = wine_dlopen( SONAME_LIBSSL, RTLD_NOW, NULL, 0 )))
189 ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBSSL);
190 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
193 if (!(libcrypto_handle = wine_dlopen( SONAME_LIBCRYPTO, RTLD_NOW, NULL, 0 )))
195 ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBCRYPTO);
196 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
199 #define LOAD_FUNCPTR(x) \
200 if (!(p##x = wine_dlsym( libssl_handle, #x, NULL, 0 ))) \
202 ERR("Failed to load symbol %s\n", #x); \
203 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \
206 LOAD_FUNCPTR( SSL_library_init );
207 LOAD_FUNCPTR( SSL_load_error_strings );
208 LOAD_FUNCPTR( SSLv23_method );
209 LOAD_FUNCPTR( SSL_CTX_new );
210 LOAD_FUNCPTR( SSL_new );
211 LOAD_FUNCPTR( SSL_free );
212 LOAD_FUNCPTR( SSL_set_fd );
213 LOAD_FUNCPTR( SSL_connect );
214 LOAD_FUNCPTR( SSL_shutdown );
215 LOAD_FUNCPTR( SSL_write );
216 LOAD_FUNCPTR( SSL_read );
217 LOAD_FUNCPTR( SSL_get_verify_result );
218 LOAD_FUNCPTR( SSL_get_peer_certificate );
219 LOAD_FUNCPTR( SSL_CTX_get_timeout );
220 LOAD_FUNCPTR( SSL_CTX_set_timeout );
221 LOAD_FUNCPTR( SSL_CTX_set_default_verify_paths );
222 LOAD_FUNCPTR( i2d_X509 );
225 #define LOAD_FUNCPTR(x) \
226 if (!(p##x = wine_dlsym( libcrypto_handle, #x, NULL, 0 ))) \
228 ERR("Failed to load symbol %s\n", #x); \
229 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \
232 LOAD_FUNCPTR( BIO_new_fp );
233 LOAD_FUNCPTR( ERR_get_error );
234 LOAD_FUNCPTR( ERR_error_string );
238 pSSL_load_error_strings();
239 pBIO_new_fp( stderr, BIO_NOCLOSE );
241 method = pSSLv23_method();
243 WARN("SSL support not compiled in.\n");
244 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
250 BOOL netconn_connected( netconn_t *conn )
252 return (conn->socket != -1);
255 BOOL netconn_create( netconn_t *conn, int domain, int type, int protocol )
257 if ((conn->socket = socket( domain, type, protocol )) == -1)
259 WARN("unable to create socket (%s)\n", strerror(errno));
260 set_last_error( sock_get_error( errno ) );
266 BOOL netconn_close( netconn_t *conn )
273 heap_free( conn->peek_msg_mem );
274 conn->peek_msg_mem = NULL;
275 conn->peek_msg = NULL;
278 pSSL_shutdown( conn->ssl_conn );
279 pSSL_free( conn->ssl_conn );
281 conn->ssl_conn = NULL;
282 conn->secure = FALSE;
285 res = close( conn->socket );
289 set_last_error( sock_get_error( errno ) );
295 BOOL netconn_connect( netconn_t *conn, const struct sockaddr *sockaddr, unsigned int addr_len )
297 if (connect( conn->socket, sockaddr, addr_len ) == -1)
299 WARN("unable to connect to host (%s)\n", strerror(errno));
300 set_last_error( sock_get_error( errno ) );
306 BOOL netconn_secure_connect( netconn_t *conn )
312 ctx = pSSL_CTX_new( method );
313 if (!pSSL_CTX_set_default_verify_paths( ctx ))
315 ERR("SSL_CTX_set_default_verify_paths failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
316 set_last_error( ERROR_OUTOFMEMORY );
319 if (!(conn->ssl_conn = pSSL_new( ctx )))
321 ERR("SSL_new failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
322 set_last_error( ERROR_OUTOFMEMORY );
325 if (!pSSL_set_fd( conn->ssl_conn, conn->socket ))
327 ERR("SSL_set_fd failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
328 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
331 if (pSSL_connect( conn->ssl_conn ) <= 0)
333 ERR("SSL_connect failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
334 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
337 if (!(cert = pSSL_get_peer_certificate( conn->ssl_conn )))
339 ERR("No certificate for server: %s\n", pERR_error_string( pERR_get_error(), 0 ));
340 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
343 if ((res = pSSL_get_verify_result( conn->ssl_conn )) != X509_V_OK)
345 /* FIXME: we should set an error and return, but we only print an error at the moment */
346 ERR("couldn't verify server certificate (%ld)\n", res);
348 TRACE("established SSL connection\n");
355 pSSL_shutdown( conn->ssl_conn );
356 pSSL_free( conn->ssl_conn );
357 conn->ssl_conn = NULL;
363 BOOL netconn_send( netconn_t *conn, const void *msg, size_t len, int flags, int *sent )
365 if (!netconn_connected( conn )) return FALSE;
369 if (flags) FIXME("SSL_write doesn't support any flags (%08x)\n", flags);
370 *sent = pSSL_write( conn->ssl_conn, msg, len );
371 if (*sent < 1 && len) return FALSE;
377 if ((*sent = send( conn->socket, msg, len, flags )) == -1)
379 set_last_error( sock_get_error( errno ) );
385 BOOL netconn_recv( netconn_t *conn, void *buf, size_t len, int flags, int *recvd )
388 if (!netconn_connected( conn )) return FALSE;
389 if (!len) return TRUE;
394 if (flags & ~(MSG_PEEK | MSG_WAITALL))
395 FIXME("SSL_read does not support the following flags: %08x\n", flags);
397 /* this ugly hack is all for MSG_PEEK */
398 if (flags & MSG_PEEK && !conn->peek_msg)
400 if (!(conn->peek_msg = conn->peek_msg_mem = heap_alloc( len + 1 ))) return FALSE;
402 else if (flags & MSG_PEEK && conn->peek_msg)
404 if (len < conn->peek_len) FIXME("buffer isn't big enough, should we wrap?\n");
405 *recvd = min( len, conn->peek_len );
406 memcpy( buf, conn->peek_msg, *recvd );
409 else if (conn->peek_msg)
411 *recvd = min( len, conn->peek_len );
412 memcpy( buf, conn->peek_msg, *recvd );
413 conn->peek_len -= *recvd;
414 conn->peek_msg += *recvd;
416 if (conn->peek_len == 0)
418 heap_free( conn->peek_msg_mem );
419 conn->peek_msg_mem = NULL;
420 conn->peek_msg = NULL;
422 /* check if we have enough data from the peek buffer */
423 if (!(flags & MSG_WAITALL) || (*recvd == len)) return TRUE;
425 *recvd += pSSL_read( conn->ssl_conn, (char *)buf + *recvd, len - *recvd );
426 if (flags & MSG_PEEK) /* must copy into buffer */
428 conn->peek_len = *recvd;
431 heap_free( conn->peek_msg_mem );
432 conn->peek_msg_mem = NULL;
433 conn->peek_msg = NULL;
435 else memcpy( conn->peek_msg, buf, *recvd );
437 if (*recvd < 1 && len) return FALSE;
443 if ((*recvd = recv( conn->socket, buf, len, flags )) == -1)
445 set_last_error( sock_get_error( errno ) );
451 BOOL netconn_query_data_available( netconn_t *conn, DWORD *available )
457 if (!netconn_connected( conn )) return FALSE;
462 if (conn->peek_msg) *available = conn->peek_len;
467 if (!(ret = ioctl( conn->socket, FIONREAD, &unread ))) *available = unread;
472 BOOL netconn_get_next_line( netconn_t *conn, char *buffer, DWORD *buflen )
478 if (!netconn_connected( conn )) return FALSE;
485 timeout = pSSL_CTX_get_timeout( ctx );
486 pSSL_CTX_set_timeout( ctx, DEFAULT_RECEIVE_TIMEOUT );
488 while (recvd < *buflen)
491 if (!netconn_recv( conn, &buffer[recvd], 1, 0, &dummy ))
493 set_last_error( ERROR_CONNECTION_ABORTED );
496 if (buffer[recvd] == '\n')
501 if (buffer[recvd] != '\r') recvd++;
503 pSSL_CTX_set_timeout( ctx, timeout );
508 TRACE("received line %s\n", debugstr_a(buffer));
516 pfd.fd = conn->socket;
518 while (recvd < *buflen)
520 if (poll( &pfd, 1, DEFAULT_RECEIVE_TIMEOUT * 1000 ) > 0)
523 if ((res = recv( conn->socket, &buffer[recvd], 1, 0 )) <= 0)
525 if (res == -1) set_last_error( sock_get_error( errno ) );
528 if (buffer[recvd] == '\n')
533 if (buffer[recvd] != '\r') recvd++;
537 set_last_error( ERROR_WINHTTP_TIMEOUT );
545 TRACE("received line %s\n", debugstr_a(buffer));
550 DWORD netconn_set_timeout( netconn_t *netconn, BOOL send, int value )
555 /* value is in milliseconds, convert to struct timeval */
556 tv.tv_sec = value / 1000;
557 tv.tv_usec = (value % 1000) * 1000;
559 if ((res = setsockopt( netconn->socket, SOL_SOCKET, send ? SO_SNDTIMEO : SO_RCVTIMEO, &tv, sizeof(tv) ) == -1))
561 WARN("setsockopt failed (%s)\n", strerror( errno ));
562 return sock_get_error( errno );
564 return ERROR_SUCCESS;
567 BOOL netconn_resolve( WCHAR *hostnameW, INTERNET_PORT port, struct sockaddr_in *sa )
570 #ifdef HAVE_GETADDRINFO
571 struct addrinfo *res, hints;
577 if (!(hostname = strdupWA( hostnameW ))) return FALSE;
579 #ifdef HAVE_GETADDRINFO
580 memset( &hints, 0, sizeof(struct addrinfo) );
581 hints.ai_family = AF_INET;
583 ret = getaddrinfo( hostname, NULL, &hints, &res );
584 heap_free( hostname );
587 TRACE("failed to get address of %s (%s)\n", debugstr_a(hostname), gai_strerror(ret));
590 memset( sa, 0, sizeof(struct sockaddr_in) );
591 memcpy( &sa->sin_addr, &((struct sockaddr_in *)res->ai_addr)->sin_addr, sizeof(struct in_addr) );
592 sa->sin_family = res->ai_family;
593 sa->sin_port = htons( port );
597 EnterCriticalSection( &cs_gethostbyname );
599 he = gethostbyname( hostname );
600 heap_free( hostname );
603 TRACE("failed to get address of %s (%d)\n", debugstr_a(hostname), h_errno);
604 LeaveCriticalSection( &cs_gethostbyname );
607 memset( sa, 0, sizeof(struct sockaddr_in) );
608 memcpy( (char *)&sa->sin_addr, he->h_addr, he->h_length );
609 sa->sin_family = he->h_addrtype;
610 sa->sin_port = htons( port );
612 LeaveCriticalSection( &cs_gethostbyname );
617 const void *netconn_get_certificate( netconn_t *conn )
621 unsigned char *buffer, *p;
624 const CERT_CONTEXT *ret;
626 if (!conn->secure) return NULL;
628 if (!(cert = pSSL_get_peer_certificate( conn->ssl_conn ))) return NULL;
630 if ((len = pi2d_X509( cert, &p )) < 0) return NULL;
632 * SSL 0.9.7 and above malloc the buffer if it is null.
633 * however earlier version do not and so we would need to alloc the buffer.
635 * see the i2d_X509 man page for more details.
639 if (!(buffer = heap_alloc( len ))) return NULL;
641 len = pi2d_X509( cert, &p );
649 ret = CertCreateCertificateContext( X509_ASN_ENCODING, buffer, len );
651 if (malloc) free( buffer );
652 else heap_free( buffer );