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"
52 /* to avoid conflicts with the Unix socket headers */
56 #include "winhttp_private.h"
58 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
60 #define DEFAULT_SEND_TIMEOUT 30
61 #define DEFAULT_RECEIVE_TIMEOUT 30
63 #ifndef HAVE_GETADDRINFO
65 /* critical section to protect non-reentrant gethostbyname() */
66 static CRITICAL_SECTION cs_gethostbyname;
67 static CRITICAL_SECTION_DEBUG critsect_debug =
69 0, 0, &cs_gethostbyname,
70 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
71 0, 0, { (DWORD_PTR)(__FILE__ ": cs_gethostbyname") }
73 static CRITICAL_SECTION cs_gethostbyname = { &critsect_debug, -1, 0, 0, 0, 0 };
79 #include <openssl/err.h>
81 static void *libssl_handle;
82 static void *libcrypto_handle;
84 static SSL_METHOD *method;
86 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
88 MAKE_FUNCPTR( SSL_library_init );
89 MAKE_FUNCPTR( SSL_load_error_strings );
90 MAKE_FUNCPTR( SSLv23_method );
91 MAKE_FUNCPTR( SSL_CTX_new );
92 MAKE_FUNCPTR( SSL_CTX_free );
93 MAKE_FUNCPTR( SSL_new );
94 MAKE_FUNCPTR( SSL_free );
95 MAKE_FUNCPTR( SSL_set_fd );
96 MAKE_FUNCPTR( SSL_connect );
97 MAKE_FUNCPTR( SSL_shutdown );
98 MAKE_FUNCPTR( SSL_write );
99 MAKE_FUNCPTR( SSL_read );
100 MAKE_FUNCPTR( SSL_get_verify_result );
101 MAKE_FUNCPTR( SSL_get_peer_certificate );
102 MAKE_FUNCPTR( SSL_CTX_get_timeout );
103 MAKE_FUNCPTR( SSL_CTX_set_timeout );
104 MAKE_FUNCPTR( SSL_CTX_set_default_verify_paths );
106 MAKE_FUNCPTR( BIO_new_fp );
107 MAKE_FUNCPTR( ERR_get_error );
108 MAKE_FUNCPTR( ERR_error_string );
113 /* translate a unix error code into a winsock error code */
114 static int sock_get_error( int err )
118 case EINTR: return WSAEINTR;
119 case EBADF: return WSAEBADF;
121 case EACCES: return WSAEACCES;
122 case EFAULT: return WSAEFAULT;
123 case EINVAL: return WSAEINVAL;
124 case EMFILE: return WSAEMFILE;
125 case EWOULDBLOCK: return WSAEWOULDBLOCK;
126 case EINPROGRESS: return WSAEINPROGRESS;
127 case EALREADY: return WSAEALREADY;
128 case ENOTSOCK: return WSAENOTSOCK;
129 case EDESTADDRREQ: return WSAEDESTADDRREQ;
130 case EMSGSIZE: return WSAEMSGSIZE;
131 case EPROTOTYPE: return WSAEPROTOTYPE;
132 case ENOPROTOOPT: return WSAENOPROTOOPT;
133 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
134 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
135 case EOPNOTSUPP: return WSAEOPNOTSUPP;
136 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
137 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
138 case EADDRINUSE: return WSAEADDRINUSE;
139 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
140 case ENETDOWN: return WSAENETDOWN;
141 case ENETUNREACH: return WSAENETUNREACH;
142 case ENETRESET: return WSAENETRESET;
143 case ECONNABORTED: return WSAECONNABORTED;
145 case ECONNRESET: return WSAECONNRESET;
146 case ENOBUFS: return WSAENOBUFS;
147 case EISCONN: return WSAEISCONN;
148 case ENOTCONN: return WSAENOTCONN;
149 case ESHUTDOWN: return WSAESHUTDOWN;
150 case ETOOMANYREFS: return WSAETOOMANYREFS;
151 case ETIMEDOUT: return WSAETIMEDOUT;
152 case ECONNREFUSED: return WSAECONNREFUSED;
153 case ELOOP: return WSAELOOP;
154 case ENAMETOOLONG: return WSAENAMETOOLONG;
155 case EHOSTDOWN: return WSAEHOSTDOWN;
156 case EHOSTUNREACH: return WSAEHOSTUNREACH;
157 case ENOTEMPTY: return WSAENOTEMPTY;
159 case EPROCLIM: return WSAEPROCLIM;
162 case EUSERS: return WSAEUSERS;
165 case EDQUOT: return WSAEDQUOT;
168 case ESTALE: return WSAESTALE;
171 case EREMOTE: return WSAEREMOTE;
173 default: errno = err; perror( "sock_set_error" ); return WSAEFAULT;
178 BOOL netconn_init( netconn_t *conn, BOOL secure )
181 if (!secure) return TRUE;
183 #if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO)
184 if (libssl_handle) return TRUE;
185 if (!(libssl_handle = wine_dlopen( SONAME_LIBSSL, RTLD_NOW, NULL, 0 )))
187 ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBSSL);
188 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
191 if (!(libcrypto_handle = wine_dlopen( SONAME_LIBCRYPTO, RTLD_NOW, NULL, 0 )))
193 ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBCRYPTO);
194 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
197 #define LOAD_FUNCPTR(x) \
198 if (!(p##x = wine_dlsym( libssl_handle, #x, NULL, 0 ))) \
200 ERR("Failed to load symbol %s\n", #x); \
201 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \
204 LOAD_FUNCPTR( SSL_library_init );
205 LOAD_FUNCPTR( SSL_load_error_strings );
206 LOAD_FUNCPTR( SSLv23_method );
207 LOAD_FUNCPTR( SSL_CTX_new );
208 LOAD_FUNCPTR( SSL_CTX_free );
209 LOAD_FUNCPTR( SSL_new );
210 LOAD_FUNCPTR( SSL_free );
211 LOAD_FUNCPTR( SSL_set_fd );
212 LOAD_FUNCPTR( SSL_connect );
213 LOAD_FUNCPTR( SSL_shutdown );
214 LOAD_FUNCPTR( SSL_write );
215 LOAD_FUNCPTR( SSL_read );
216 LOAD_FUNCPTR( SSL_get_verify_result );
217 LOAD_FUNCPTR( SSL_get_peer_certificate );
218 LOAD_FUNCPTR( SSL_CTX_get_timeout );
219 LOAD_FUNCPTR( SSL_CTX_set_timeout );
220 LOAD_FUNCPTR( SSL_CTX_set_default_verify_paths );
223 #define LOAD_FUNCPTR(x) \
224 if (!(p##x = wine_dlsym( libcrypto_handle, #x, NULL, 0 ))) \
226 ERR("Failed to load symbol %s\n", #x); \
227 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \
230 LOAD_FUNCPTR( BIO_new_fp );
231 LOAD_FUNCPTR( ERR_get_error );
232 LOAD_FUNCPTR( ERR_error_string );
236 pSSL_load_error_strings();
237 pBIO_new_fp( stderr, BIO_NOCLOSE );
239 method = pSSLv23_method();
240 conn->ssl_ctx = pSSL_CTX_new( 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 if (!pSSL_CTX_set_default_verify_paths( conn->ssl_ctx ))
314 ERR("SSL_CTX_set_default_verify_paths failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
315 set_last_error( ERROR_OUTOFMEMORY );
318 if (!(conn->ssl_conn = pSSL_new( conn->ssl_ctx )))
320 ERR("SSL_new failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
321 set_last_error( ERROR_OUTOFMEMORY );
324 if (!pSSL_set_fd( conn->ssl_conn, conn->socket ))
326 ERR("SSL_set_fd failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
327 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
330 if (pSSL_connect( conn->ssl_conn ) <= 0)
332 ERR("SSL_connect failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
333 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
336 if (!(cert = pSSL_get_peer_certificate( conn->ssl_conn )))
338 ERR("No certificate for server: %s\n", pERR_error_string( pERR_get_error(), 0 ));
339 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
342 if ((res = pSSL_get_verify_result( conn->ssl_conn )) != X509_V_OK)
344 /* FIXME: we should set an error and return, but we only print an error at the moment */
345 ERR("couldn't verify server certificate (%ld)\n", res);
347 TRACE("established SSL connection\n");
354 pSSL_shutdown( conn->ssl_conn );
355 pSSL_free( conn->ssl_conn );
356 conn->ssl_conn = NULL;
362 BOOL netconn_send( netconn_t *conn, const void *msg, size_t len, int flags, int *sent )
364 if (!netconn_connected( conn )) return FALSE;
368 if (flags) FIXME("SSL_write doesn't support any flags (%08x)\n", flags);
369 *sent = pSSL_write( conn->ssl_conn, msg, len );
370 if (*sent < 1 && len) return FALSE;
376 if ((*sent = send( conn->socket, msg, len, flags )) == -1)
378 set_last_error( sock_get_error( errno ) );
384 BOOL netconn_recv( netconn_t *conn, void *buf, size_t len, int flags, int *recvd )
387 if (!netconn_connected( conn )) return FALSE;
388 if (!len) return TRUE;
393 if (flags & ~(MSG_PEEK | MSG_WAITALL))
394 FIXME("SSL_read does not support the following flags: %08x\n", flags);
396 /* this ugly hack is all for MSG_PEEK */
397 if (flags & MSG_PEEK && !conn->peek_msg)
399 if (!(conn->peek_msg = conn->peek_msg_mem = heap_alloc( len + 1 ))) return FALSE;
401 else if (flags & MSG_PEEK && conn->peek_msg)
403 if (len < conn->peek_len) FIXME("buffer isn't big enough, should we wrap?\n");
404 *recvd = min( len, conn->peek_len );
405 memcpy( buf, conn->peek_msg, *recvd );
408 else if (conn->peek_msg)
410 *recvd = min( len, conn->peek_len );
411 memcpy( buf, conn->peek_msg, *recvd );
412 conn->peek_len -= *recvd;
413 conn->peek_msg += *recvd;
415 if (conn->peek_len == 0)
417 heap_free( conn->peek_msg_mem );
418 conn->peek_msg_mem = NULL;
419 conn->peek_msg = NULL;
421 /* check if we have enough data from the peek buffer */
422 if (!(flags & MSG_WAITALL) || (*recvd == len)) return TRUE;
424 *recvd += pSSL_read( conn->ssl_conn, (char *)buf + *recvd, len - *recvd );
425 if (flags & MSG_PEEK) /* must copy into buffer */
427 conn->peek_len = *recvd;
430 heap_free( conn->peek_msg_mem );
431 conn->peek_msg_mem = NULL;
432 conn->peek_msg = NULL;
434 else memcpy( conn->peek_msg, buf, *recvd );
436 if (*recvd < 1 && len) return FALSE;
442 if ((*recvd = recv( conn->socket, buf, len, flags )) == -1)
444 set_last_error( sock_get_error( errno ) );
450 BOOL netconn_query_data_available( netconn_t *conn, DWORD *available )
456 if (!netconn_connected( conn )) return FALSE;
461 if (conn->peek_msg) *available = conn->peek_len;
466 if (!(ret = ioctl( conn->socket, FIONREAD, &unread )))
468 TRACE("%d bytes of queued, but unread data\n", unread);
469 *available += unread;
475 BOOL netconn_get_next_line( netconn_t *conn, char *buffer, DWORD *buflen )
481 if (!netconn_connected( conn )) return FALSE;
488 timeout = pSSL_CTX_get_timeout( conn->ssl_ctx );
489 pSSL_CTX_set_timeout( conn->ssl_ctx, DEFAULT_RECEIVE_TIMEOUT );
491 while (recvd < *buflen)
494 if (!netconn_recv( conn, &buffer[recvd], 1, 0, &dummy ))
496 set_last_error( ERROR_CONNECTION_ABORTED );
499 if (buffer[recvd] == '\n')
504 if (buffer[recvd] != '\r') recvd++;
506 pSSL_CTX_set_timeout( conn->ssl_ctx, timeout );
511 TRACE("received line %s\n", debugstr_a(buffer));
519 pfd.fd = conn->socket;
521 while (recvd < *buflen)
523 if (poll( &pfd, 1, DEFAULT_RECEIVE_TIMEOUT * 1000 ) > 0)
526 if ((res = recv( conn->socket, &buffer[recvd], 1, 0 )) <= 0)
528 if (res == -1) set_last_error( sock_get_error( errno ) );
531 if (buffer[recvd] == '\n')
536 if (buffer[recvd] != '\r') recvd++;
540 set_last_error( ERROR_WINHTTP_TIMEOUT );
548 TRACE("received line %s\n", debugstr_a(buffer));
553 DWORD netconn_set_timeout( netconn_t *netconn, BOOL send, int value )
558 /* value is in milliseconds, convert to struct timeval */
559 tv.tv_sec = value / 1000;
560 tv.tv_usec = (value % 1000) * 1000;
562 if ((res = setsockopt( netconn->socket, SOL_SOCKET, send ? SO_SNDTIMEO : SO_RCVTIMEO, &tv, sizeof(tv) ) == -1))
564 WARN("setsockopt failed (%s)\n", strerror( errno ));
565 return sock_get_error( errno );
567 return ERROR_SUCCESS;
570 BOOL netconn_resolve( WCHAR *hostnameW, INTERNET_PORT port, struct sockaddr_in *sa )
573 #ifdef HAVE_GETADDRINFO
574 struct addrinfo *res, hints;
580 if (!(hostname = strdupWA( hostnameW ))) return FALSE;
582 #ifdef HAVE_GETADDRINFO
583 memset( &hints, 0, sizeof(struct addrinfo) );
584 hints.ai_family = AF_INET;
586 ret = getaddrinfo( hostname, NULL, &hints, &res );
587 heap_free( hostname );
590 TRACE("failed to get address of %s (%s)\n", debugstr_a(hostname), gai_strerror(ret));
593 memset( sa, 0, sizeof(struct sockaddr_in) );
594 memcpy( &sa->sin_addr, &((struct sockaddr_in *)res->ai_addr)->sin_addr, sizeof(struct in_addr) );
595 sa->sin_family = res->ai_family;
596 sa->sin_port = htons( port );
600 EnterCriticalSection( &cs_gethostbyname );
602 he = gethostbyname( hostname );
603 heap_free( hostname );
606 TRACE("failed to get address of %s (%d)\n", debugstr_a(hostname), h_errno);
607 LeaveCriticalSection( &cs_gethostbyname );
610 memset( sa, 0, sizeof(struct sockaddr_in) );
611 memcpy( (char *)&sa->sin_addr, he->h_addr, he->h_length );
612 sa->sin_family = he->h_addrtype;
613 sa->sin_port = htons( port );
615 LeaveCriticalSection( &cs_gethostbyname );