2 * Wininet - networking layer. Uses unix sockets or OpenSSL.
4 * Copyright 2002 TransGaming Technologies Inc.
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wine/port.h"
26 #ifdef HAVE_SYS_TIME_H
27 # include <sys/time.h>
29 #include <sys/types.h>
30 #ifdef HAVE_SYS_SOCKET_H
31 # include <sys/socket.h>
36 #ifdef HAVE_SYS_IOCTL_H
37 # include <sys/ioctl.h>
45 #include "wine/library.h"
52 #include "wine/debug.h"
55 /* To avoid conflicts with the Unix socket headers. we only need it for
56 * the error codes anyway. */
60 #define RESPONSE_TIMEOUT 30 /* FROM internet.c */
63 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
66 * This should use winsock - To use winsock the functions will have to change a bit
67 * as they are designed for unix sockets.
68 * SSL stuff should use crypt32.dll
73 #include <openssl/err.h>
75 static void *OpenSSL_ssl_handle;
76 static void *OpenSSL_crypto_handle;
78 static SSL_METHOD *meth;
81 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
83 /* OpenSSL functions that we use */
84 MAKE_FUNCPTR(SSL_library_init);
85 MAKE_FUNCPTR(SSL_load_error_strings);
86 MAKE_FUNCPTR(SSLv23_method);
87 MAKE_FUNCPTR(SSL_CTX_new);
88 MAKE_FUNCPTR(SSL_new);
89 MAKE_FUNCPTR(SSL_free);
90 MAKE_FUNCPTR(SSL_set_fd);
91 MAKE_FUNCPTR(SSL_connect);
92 MAKE_FUNCPTR(SSL_shutdown);
93 MAKE_FUNCPTR(SSL_write);
94 MAKE_FUNCPTR(SSL_read);
95 MAKE_FUNCPTR(SSL_get_verify_result);
96 MAKE_FUNCPTR(SSL_get_peer_certificate);
97 MAKE_FUNCPTR(SSL_CTX_get_timeout);
98 MAKE_FUNCPTR(SSL_CTX_set_timeout);
99 MAKE_FUNCPTR(SSL_CTX_set_default_verify_paths);
100 MAKE_FUNCPTR(i2d_X509);
102 /* OpenSSL's libcrypto functions that we use */
103 MAKE_FUNCPTR(BIO_new_fp);
104 MAKE_FUNCPTR(ERR_get_error);
105 MAKE_FUNCPTR(ERR_error_string);
110 BOOL NETCON_init(WININET_NETCONNECTION *connection, BOOL useSSL)
112 connection->useSSL = FALSE;
113 connection->socketFD = -1;
117 TRACE("using SSL connection\n");
118 if (OpenSSL_ssl_handle) /* already initialized everything */
120 OpenSSL_ssl_handle = wine_dlopen(SONAME_LIBSSL, RTLD_NOW, NULL, 0);
121 if (!OpenSSL_ssl_handle)
123 ERR("trying to use a SSL connection, but couldn't load %s. Expect trouble.\n",
125 INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR);
128 OpenSSL_crypto_handle = wine_dlopen(SONAME_LIBCRYPTO, RTLD_NOW, NULL, 0);
129 if (!OpenSSL_crypto_handle)
131 ERR("trying to use a SSL connection, but couldn't load %s. Expect trouble.\n",
133 INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR);
137 /* mmm nice ugly macroness */
139 p##x = wine_dlsym(OpenSSL_ssl_handle, #x, NULL, 0); \
142 ERR("failed to load symbol %s\n", #x); \
143 INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR); \
147 DYNSSL(SSL_library_init);
148 DYNSSL(SSL_load_error_strings);
149 DYNSSL(SSLv23_method);
155 DYNSSL(SSL_shutdown);
158 DYNSSL(SSL_get_verify_result);
159 DYNSSL(SSL_get_peer_certificate);
160 DYNSSL(SSL_CTX_get_timeout);
161 DYNSSL(SSL_CTX_set_timeout);
162 DYNSSL(SSL_CTX_set_default_verify_paths);
166 #define DYNCRYPTO(x) \
167 p##x = wine_dlsym(OpenSSL_crypto_handle, #x, NULL, 0); \
170 ERR("failed to load symbol %s\n", #x); \
171 INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR); \
174 DYNCRYPTO(BIO_new_fp);
175 DYNCRYPTO(ERR_get_error);
176 DYNCRYPTO(ERR_error_string);
180 pSSL_load_error_strings();
181 pBIO_new_fp(stderr, BIO_NOCLOSE); /* FIXME: should use winedebug stuff */
183 meth = pSSLv23_method();
184 connection->peek_msg = NULL;
185 connection->peek_msg_mem = NULL;
187 FIXME("can't use SSL, not compiled in.\n");
188 INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR);
195 BOOL NETCON_connected(WININET_NETCONNECTION *connection)
197 if (connection->socketFD == -1)
203 /* translate a unix error code into a winsock one */
204 static int sock_get_error( int err )
206 #if !defined(__MINGW32__) && !defined (_MSC_VER)
209 case EINTR: return WSAEINTR;
210 case EBADF: return WSAEBADF;
212 case EACCES: return WSAEACCES;
213 case EFAULT: return WSAEFAULT;
214 case EINVAL: return WSAEINVAL;
215 case EMFILE: return WSAEMFILE;
216 case EWOULDBLOCK: return WSAEWOULDBLOCK;
217 case EINPROGRESS: return WSAEINPROGRESS;
218 case EALREADY: return WSAEALREADY;
219 case ENOTSOCK: return WSAENOTSOCK;
220 case EDESTADDRREQ: return WSAEDESTADDRREQ;
221 case EMSGSIZE: return WSAEMSGSIZE;
222 case EPROTOTYPE: return WSAEPROTOTYPE;
223 case ENOPROTOOPT: return WSAENOPROTOOPT;
224 case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
225 case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
226 case EOPNOTSUPP: return WSAEOPNOTSUPP;
227 case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
228 case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
229 case EADDRINUSE: return WSAEADDRINUSE;
230 case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
231 case ENETDOWN: return WSAENETDOWN;
232 case ENETUNREACH: return WSAENETUNREACH;
233 case ENETRESET: return WSAENETRESET;
234 case ECONNABORTED: return WSAECONNABORTED;
236 case ECONNRESET: return WSAECONNRESET;
237 case ENOBUFS: return WSAENOBUFS;
238 case EISCONN: return WSAEISCONN;
239 case ENOTCONN: return WSAENOTCONN;
240 case ESHUTDOWN: return WSAESHUTDOWN;
241 case ETOOMANYREFS: return WSAETOOMANYREFS;
242 case ETIMEDOUT: return WSAETIMEDOUT;
243 case ECONNREFUSED: return WSAECONNREFUSED;
244 case ELOOP: return WSAELOOP;
245 case ENAMETOOLONG: return WSAENAMETOOLONG;
246 case EHOSTDOWN: return WSAEHOSTDOWN;
247 case EHOSTUNREACH: return WSAEHOSTUNREACH;
248 case ENOTEMPTY: return WSAENOTEMPTY;
250 case EPROCLIM: return WSAEPROCLIM;
253 case EUSERS: return WSAEUSERS;
256 case EDQUOT: return WSAEDQUOT;
259 case ESTALE: return WSAESTALE;
262 case EREMOTE: return WSAEREMOTE;
264 default: errno=err; perror("sock_set_error"); return WSAEFAULT;
270 /******************************************************************************
272 * Basically calls 'socket()'
274 BOOL NETCON_create(WININET_NETCONNECTION *connection, int domain,
275 int type, int protocol)
278 if (connection->useSSL)
282 connection->socketFD = socket(domain, type, protocol);
283 if (connection->socketFD == -1)
285 INTERNET_SetLastError(sock_get_error(errno));
291 /******************************************************************************
293 * Basically calls 'close()' unless we should use SSL
295 BOOL NETCON_close(WININET_NETCONNECTION *connection)
299 if (!NETCON_connected(connection)) return FALSE;
302 if (connection->useSSL)
304 HeapFree(GetProcessHeap(),0,connection->peek_msg_mem);
305 connection->peek_msg = NULL;
306 connection->peek_msg_mem = NULL;
307 connection->peek_len = 0;
309 pSSL_shutdown(connection->ssl_s);
310 pSSL_free(connection->ssl_s);
311 connection->ssl_s = NULL;
313 connection->useSSL = FALSE;
317 result = closesocket(connection->socketFD);
318 connection->socketFD = -1;
322 INTERNET_SetLastError(sock_get_error(errno));
328 static BOOL check_hostname(X509 *cert, char *hostname)
330 /* FIXME: implement */
334 /******************************************************************************
335 * NETCON_secure_connect
336 * Initiates a secure connection over an existing plaintext connection.
338 BOOL NETCON_secure_connect(WININET_NETCONNECTION *connection, LPCWSTR hostname)
346 /* can't connect if we are already connected */
347 if (connection->useSSL)
349 ERR("already connected\n");
353 ctx = pSSL_CTX_new(meth);
354 if (!pSSL_CTX_set_default_verify_paths(ctx))
356 ERR("SSL_CTX_set_default_verify_paths failed: %s\n",
357 pERR_error_string(pERR_get_error(), 0));
358 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
361 connection->ssl_s = pSSL_new(ctx);
362 if (!connection->ssl_s)
364 ERR("SSL_new failed: %s\n",
365 pERR_error_string(pERR_get_error(), 0));
366 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
370 if (!pSSL_set_fd(connection->ssl_s, connection->socketFD))
372 ERR("SSL_set_fd failed: %s\n",
373 pERR_error_string(pERR_get_error(), 0));
374 INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR);
378 if (pSSL_connect(connection->ssl_s) <= 0)
380 ERR("SSL_connect failed: %s\n",
381 pERR_error_string(pERR_get_error(), 0));
382 INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR);
385 cert = pSSL_get_peer_certificate(connection->ssl_s);
388 ERR("no certificate for server %s\n", debugstr_w(hostname));
389 /* FIXME: is this the best error? */
390 INTERNET_SetLastError(ERROR_INTERNET_INVALID_CA);
393 verify_res = pSSL_get_verify_result(connection->ssl_s);
394 if (verify_res != X509_V_OK)
396 ERR("couldn't verify the security of the connection, %ld\n", verify_res);
397 /* FIXME: we should set an error and return, but we only warn at
401 len = WideCharToMultiByte(CP_UNIXCP, 0, hostname, -1, NULL, 0, NULL, NULL);
402 hostname_unix = HeapAlloc(GetProcessHeap(), 0, len);
405 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
408 WideCharToMultiByte(CP_UNIXCP, 0, hostname, -1, hostname_unix, len, NULL, NULL);
410 if (!check_hostname(cert, hostname_unix))
412 HeapFree(GetProcessHeap(), 0, hostname_unix);
413 INTERNET_SetLastError(ERROR_INTERNET_SEC_CERT_CN_INVALID);
417 HeapFree(GetProcessHeap(), 0, hostname_unix);
418 connection->useSSL = TRUE;
422 if (connection->ssl_s)
424 pSSL_shutdown(connection->ssl_s);
425 pSSL_free(connection->ssl_s);
426 connection->ssl_s = NULL;
432 /******************************************************************************
434 * Connects to the specified address.
436 BOOL NETCON_connect(WININET_NETCONNECTION *connection, const struct sockaddr *serv_addr,
437 unsigned int addrlen)
441 if (!NETCON_connected(connection)) return FALSE;
443 result = connect(connection->socketFD, serv_addr, addrlen);
446 WARN("Unable to connect to host (%s)\n", strerror(errno));
447 INTERNET_SetLastError(sock_get_error(errno));
449 closesocket(connection->socketFD);
450 connection->socketFD = -1;
457 /******************************************************************************
459 * Basically calls 'send()' unless we should use SSL
460 * number of chars send is put in *sent
462 BOOL NETCON_send(WININET_NETCONNECTION *connection, const void *msg, size_t len, int flags,
465 if (!NETCON_connected(connection)) return FALSE;
466 if (!connection->useSSL)
468 *sent = send(connection->socketFD, msg, len, flags);
471 INTERNET_SetLastError(sock_get_error(errno));
480 FIXME("SSL_write doesn't support any flags (%08x)\n", flags);
481 *sent = pSSL_write(connection->ssl_s, msg, len);
482 if (*sent < 1 && len)
491 /******************************************************************************
493 * Basically calls 'recv()' unless we should use SSL
494 * number of chars received is put in *recvd
496 BOOL NETCON_recv(WININET_NETCONNECTION *connection, void *buf, size_t len, int flags,
497 int *recvd /* out */)
500 if (!NETCON_connected(connection)) return FALSE;
503 if (!connection->useSSL)
505 *recvd = recv(connection->socketFD, buf, len, flags);
508 INTERNET_SetLastError(sock_get_error(errno));
516 if (flags & ~(MSG_PEEK|MSG_WAITALL))
517 FIXME("SSL_read does not support the following flag: %08x\n", flags);
519 /* this ugly hack is all for MSG_PEEK. eww gross */
520 if (flags & MSG_PEEK && !connection->peek_msg)
522 connection->peek_msg = connection->peek_msg_mem = HeapAlloc(GetProcessHeap(), 0, (sizeof(char) * len) + 1);
524 else if (flags & MSG_PEEK && connection->peek_msg)
526 if (len < connection->peek_len)
527 FIXME("buffer isn't big enough. Do the expect us to wrap?\n");
528 *recvd = min(len, connection->peek_len);
529 memcpy(buf, connection->peek_msg, *recvd);
532 else if (connection->peek_msg)
534 *recvd = min(len, connection->peek_len);
535 memcpy(buf, connection->peek_msg, *recvd);
536 connection->peek_len -= *recvd;
537 connection->peek_msg += *recvd;
538 if (connection->peek_len == 0)
540 HeapFree(GetProcessHeap(), 0, connection->peek_msg_mem);
541 connection->peek_msg_mem = NULL;
542 connection->peek_msg = NULL;
544 /* check if we got enough data from the peek buffer */
545 if (!(flags & MSG_WAITALL) || (*recvd == len))
547 /* otherwise, fall through */
549 *recvd += pSSL_read(connection->ssl_s, (char*)buf + *recvd, len - *recvd);
550 if (flags & MSG_PEEK) /* must copy stuff into buffer */
552 connection->peek_len = *recvd;
555 HeapFree(GetProcessHeap(), 0, connection->peek_msg_mem);
556 connection->peek_msg_mem = NULL;
557 connection->peek_msg = NULL;
560 memcpy(connection->peek_msg, buf, *recvd);
562 if (*recvd < 1 && len)
571 /******************************************************************************
572 * NETCON_query_data_available
573 * Returns the number of bytes of peeked data plus the number of bytes of
574 * queued, but unread data.
576 BOOL NETCON_query_data_available(WININET_NETCONNECTION *connection, DWORD *available)
579 if (!NETCON_connected(connection))
583 if (connection->peek_msg) *available = connection->peek_len;
587 if (!connection->useSSL)
590 int retval = ioctlsocket(connection->socketFD, FIONREAD, &unread);
593 TRACE("%d bytes of queued, but unread data\n", unread);
594 *available += unread;
601 /******************************************************************************
604 BOOL NETCON_getNextLine(WININET_NETCONNECTION *connection, LPSTR lpszBuffer, LPDWORD dwBuffer)
609 if (!NETCON_connected(connection)) return FALSE;
611 if (!connection->useSSL)
615 BOOL bSuccess = FALSE;
619 FD_SET(connection->socketFD, &infd);
620 tv.tv_sec=RESPONSE_TIMEOUT;
623 while (nRecv < *dwBuffer)
625 if (select(connection->socketFD+1,&infd,NULL,NULL,&tv) > 0)
627 if (recv(connection->socketFD, &lpszBuffer[nRecv], 1, 0) <= 0)
629 INTERNET_SetLastError(sock_get_error(errno));
633 if (lpszBuffer[nRecv] == '\n')
638 if (lpszBuffer[nRecv] != '\r')
643 INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT);
648 lend: /* FIXME: don't use labels */
651 lpszBuffer[nRecv++] = '\0';
653 TRACE(":%u %s\n", nRecv, lpszBuffer);
668 prev_timeout = pSSL_CTX_get_timeout(ctx);
669 pSSL_CTX_set_timeout(ctx, RESPONSE_TIMEOUT);
671 while (nRecv < *dwBuffer)
674 if (!NETCON_recv(connection, &lpszBuffer[nRecv], 1, 0, &recv))
676 INTERNET_SetLastError(ERROR_CONNECTION_ABORTED);
680 if (lpszBuffer[nRecv] == '\n')
685 if (lpszBuffer[nRecv] != '\r')
689 pSSL_CTX_set_timeout(ctx, prev_timeout);
692 lpszBuffer[nRecv++] = '\0';
694 TRACE("_SSL:%u %s\n", nRecv, lpszBuffer);
705 LPCVOID NETCON_GetCert(WININET_NETCONNECTION *connection)
709 unsigned char* buffer,*p;
711 BOOL malloced = FALSE;
714 if (!connection->useSSL)
717 cert = pSSL_get_peer_certificate(connection->ssl_s);
719 len = pi2d_X509(cert,&p);
721 * SSL 0.9.7 and above malloc the buffer if it is null.
722 * however earlier version do not and so we would need to alloc the buffer.
724 * see the i2d_X509 man page for more details.
728 buffer = HeapAlloc(GetProcessHeap(),0,len);
730 len = pi2d_X509(cert,&p);
738 r = CertCreateCertificateContext(X509_ASN_ENCODING,buffer,len);
743 HeapFree(GetProcessHeap(),0,buffer);
751 DWORD NETCON_set_timeout(WININET_NETCONNECTION *connection, BOOL send, int value)
756 /* FIXME: we should probably store the timeout in the connection to set
757 * when we do connect */
758 if (!NETCON_connected(connection))
759 return ERROR_SUCCESS;
761 /* value is in milliseconds, convert to struct timeval */
762 tv.tv_sec = value / 1000;
763 tv.tv_usec = (value % 1000) * 1000;
765 result = setsockopt(connection->socketFD, SOL_SOCKET,
766 send ? SO_SNDTIMEO : SO_RCVTIMEO, &tv,
771 WARN("setsockopt failed (%s)\n", strerror(errno));
772 return sock_get_error(errno);
775 return ERROR_SUCCESS;