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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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>
42 #include "wine/library.h"
48 /* To avoid conflicts with the Unix socket headers. we only need it for
49 * the error codes anyway. */
53 #include "wine/debug.h"
57 #define RESPONSE_TIMEOUT 30 /* FROM internet.c */
60 WINE_DEFAULT_DEBUG_CHANNEL(wininet
);
63 * This should use winsock - To use winsock the functions will have to change a bit
64 * as they are designed for unix sockets.
65 * SSL stuff should use crypt32.dll
68 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
70 #include <openssl/err.h>
73 #define SONAME_LIBSSL "libssl.so"
75 #ifndef SONAME_LIBCRYPTO
76 #define SONAME_LIBCRYPTO "libcrypto.so"
79 static void *OpenSSL_ssl_handle
;
80 static void *OpenSSL_crypto_handle
;
82 static SSL_METHOD
*meth
;
85 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
87 /* OpenSSL functions that we use */
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_new
);
93 MAKE_FUNCPTR(SSL_free
);
94 MAKE_FUNCPTR(SSL_set_fd
);
95 MAKE_FUNCPTR(SSL_connect
);
96 MAKE_FUNCPTR(SSL_shutdown
);
97 MAKE_FUNCPTR(SSL_write
);
98 MAKE_FUNCPTR(SSL_read
);
99 MAKE_FUNCPTR(SSL_get_verify_result
);
100 MAKE_FUNCPTR(SSL_get_peer_certificate
);
101 MAKE_FUNCPTR(SSL_CTX_get_timeout
);
102 MAKE_FUNCPTR(SSL_CTX_set_timeout
);
103 MAKE_FUNCPTR(SSL_CTX_set_default_verify_paths
);
104 MAKE_FUNCPTR(i2d_X509
);
106 /* OpenSSL's libcrypto functions that we use */
107 MAKE_FUNCPTR(BIO_new_fp
);
108 MAKE_FUNCPTR(ERR_get_error
);
109 MAKE_FUNCPTR(ERR_error_string
);
114 void NETCON_init(WININET_NETCONNECTION
*connection
, BOOL useSSL
)
116 connection
->useSSL
= FALSE
;
117 connection
->socketFD
= -1;
120 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
121 TRACE("using SSL connection\n");
122 if (OpenSSL_ssl_handle
) /* already initilzed everything */
124 OpenSSL_ssl_handle
= wine_dlopen(SONAME_LIBSSL
, RTLD_NOW
, NULL
, 0);
125 if (!OpenSSL_ssl_handle
)
127 ERR("trying to use a SSL connection, but couldn't load %s. Expect trouble.\n",
129 connection
->useSSL
= FALSE
;
132 OpenSSL_crypto_handle
= wine_dlopen(SONAME_LIBCRYPTO
, RTLD_NOW
, NULL
, 0);
133 if (!OpenSSL_crypto_handle
)
135 ERR("trying to use a SSL connection, but couldn't load %s. Expect trouble.\n",
137 connection
->useSSL
= FALSE
;
141 /* mmm nice ugly macroness */
143 p##x = wine_dlsym(OpenSSL_ssl_handle, #x, NULL, 0); \
146 ERR("failed to load symbol %s\n", #x); \
147 connection->useSSL = FALSE; \
151 DYNSSL(SSL_library_init
);
152 DYNSSL(SSL_load_error_strings
);
153 DYNSSL(SSLv23_method
);
159 DYNSSL(SSL_shutdown
);
162 DYNSSL(SSL_get_verify_result
);
163 DYNSSL(SSL_get_peer_certificate
);
164 DYNSSL(SSL_CTX_get_timeout
);
165 DYNSSL(SSL_CTX_set_timeout
);
166 DYNSSL(SSL_CTX_set_default_verify_paths
);
170 #define DYNCRYPTO(x) \
171 p##x = wine_dlsym(OpenSSL_crypto_handle, #x, NULL, 0); \
174 ERR("failed to load symbol %s\n", #x); \
175 connection->useSSL = FALSE; \
178 DYNCRYPTO(BIO_new_fp
);
179 DYNCRYPTO(ERR_get_error
);
180 DYNCRYPTO(ERR_error_string
);
184 pSSL_load_error_strings();
185 pBIO_new_fp(stderr
, BIO_NOCLOSE
); /* FIXME: should use winedebug stuff */
187 meth
= pSSLv23_method();
188 connection
->peek_msg
= NULL
;
189 connection
->peek_msg_mem
= NULL
;
191 FIXME("can't use SSL, not compiled in.\n");
192 connection
->useSSL
= FALSE
;
197 BOOL
NETCON_connected(WININET_NETCONNECTION
*connection
)
199 if (connection
->socketFD
== -1)
205 /* translate a unix error code into a winsock one */
206 static int sock_get_error( int err
)
210 case EINTR
: return WSAEINTR
;
211 case EBADF
: return WSAEBADF
;
213 case EACCES
: return WSAEACCES
;
214 case EFAULT
: return WSAEFAULT
;
215 case EINVAL
: return WSAEINVAL
;
216 case EMFILE
: return WSAEMFILE
;
217 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
218 case EINPROGRESS
: return WSAEINPROGRESS
;
219 case EALREADY
: return WSAEALREADY
;
220 case ENOTSOCK
: return WSAENOTSOCK
;
221 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
222 case EMSGSIZE
: return WSAEMSGSIZE
;
223 case EPROTOTYPE
: return WSAEPROTOTYPE
;
224 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
225 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
226 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
227 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
228 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
229 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
230 case EADDRINUSE
: return WSAEADDRINUSE
;
231 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
232 case ENETDOWN
: return WSAENETDOWN
;
233 case ENETUNREACH
: return WSAENETUNREACH
;
234 case ENETRESET
: return WSAENETRESET
;
235 case ECONNABORTED
: return WSAECONNABORTED
;
237 case ECONNRESET
: return WSAECONNRESET
;
238 case ENOBUFS
: return WSAENOBUFS
;
239 case EISCONN
: return WSAEISCONN
;
240 case ENOTCONN
: return WSAENOTCONN
;
241 case ESHUTDOWN
: return WSAESHUTDOWN
;
242 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
243 case ETIMEDOUT
: return WSAETIMEDOUT
;
244 case ECONNREFUSED
: return WSAECONNREFUSED
;
245 case ELOOP
: return WSAELOOP
;
246 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
247 case EHOSTDOWN
: return WSAEHOSTDOWN
;
248 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
249 case ENOTEMPTY
: return WSAENOTEMPTY
;
251 case EPROCLIM
: return WSAEPROCLIM
;
254 case EUSERS
: return WSAEUSERS
;
257 case EDQUOT
: return WSAEDQUOT
;
260 case ESTALE
: return WSAESTALE
;
263 case EREMOTE
: return WSAEREMOTE
;
265 default: errno
=err
; perror("sock_set_error"); return WSAEFAULT
;
269 /******************************************************************************
271 * Basically calls 'socket()'
273 BOOL
NETCON_create(WININET_NETCONNECTION
*connection
, int domain
,
274 int type
, int protocol
)
276 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
277 if (connection
->useSSL
)
281 connection
->socketFD
= socket(domain
, type
, protocol
);
282 if (connection
->socketFD
== -1)
284 INTERNET_SetLastError(sock_get_error(errno
));
290 /******************************************************************************
292 * Basically calls 'close()' unless we should use SSL
294 BOOL
NETCON_close(WININET_NETCONNECTION
*connection
)
298 if (!NETCON_connected(connection
)) return FALSE
;
300 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
301 if (connection
->useSSL
)
303 HeapFree(GetProcessHeap(),0,connection
->peek_msg_mem
);
304 connection
->peek_msg
= NULL
;
305 connection
->peek_msg_mem
= NULL
;
307 pSSL_shutdown(connection
->ssl_s
);
308 pSSL_free(connection
->ssl_s
);
309 connection
->ssl_s
= NULL
;
311 connection
->useSSL
= FALSE
;
315 result
= closesocket(connection
->socketFD
);
316 connection
->socketFD
= -1;
320 INTERNET_SetLastError(sock_get_error(errno
));
325 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
326 static BOOL
check_hostname(X509
*cert
, char *hostname
)
328 /* FIXME: implement */
332 /******************************************************************************
333 * NETCON_secure_connect
334 * Initiates a secure connection over an existing plaintext connection.
336 BOOL
NETCON_secure_connect(WININET_NETCONNECTION
*connection
, LPCWSTR hostname
)
338 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
344 /* can't connect if we are already connected */
345 if (connection
->useSSL
)
347 ERR("already connected\n");
351 ctx
= pSSL_CTX_new(meth
);
352 if (!pSSL_CTX_set_default_verify_paths(ctx
))
354 ERR("SSL_CTX_set_default_verify_paths failed: %s\n",
355 pERR_error_string(pERR_get_error(), 0));
358 connection
->ssl_s
= pSSL_new(ctx
);
359 if (!connection
->ssl_s
)
361 ERR("SSL_new failed: %s\n",
362 pERR_error_string(pERR_get_error(), 0));
366 if (!pSSL_set_fd(connection
->ssl_s
, connection
->socketFD
))
368 ERR("SSL_set_fd failed: %s\n",
369 pERR_error_string(pERR_get_error(), 0));
373 if (pSSL_connect(connection
->ssl_s
) <= 0)
375 ERR("SSL_connect failed: %s\n",
376 pERR_error_string(pERR_get_error(), 0));
377 INTERNET_SetLastError(ERROR_INTERNET_SECURITY_CHANNEL_ERROR
);
380 cert
= pSSL_get_peer_certificate(connection
->ssl_s
);
383 ERR("no certificate for server %s\n", debugstr_w(hostname
));
384 /* FIXME: is this the best error? */
385 INTERNET_SetLastError(ERROR_INTERNET_INVALID_CA
);
388 verify_res
= pSSL_get_verify_result(connection
->ssl_s
);
389 if (verify_res
!= X509_V_OK
)
391 ERR("couldn't verify the security of the connection, %ld\n", verify_res
);
392 /* FIXME: we should set an error and return, but we only warn at
396 len
= WideCharToMultiByte(CP_UNIXCP
, 0, hostname
, -1, NULL
, 0, NULL
, NULL
);
397 hostname_unix
= HeapAlloc(GetProcessHeap(), 0, len
);
400 INTERNET_SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
403 WideCharToMultiByte(CP_UNIXCP
, 0, hostname
, -1, hostname_unix
, len
, NULL
, NULL
);
405 if (!check_hostname(cert
, hostname_unix
))
407 HeapFree(GetProcessHeap(), 0, hostname_unix
);
408 INTERNET_SetLastError(ERROR_INTERNET_SEC_CERT_CN_INVALID
);
412 HeapFree(GetProcessHeap(), 0, hostname_unix
);
413 connection
->useSSL
= TRUE
;
417 if (connection
->ssl_s
)
419 pSSL_shutdown(connection
->ssl_s
);
420 pSSL_free(connection
->ssl_s
);
421 connection
->ssl_s
= NULL
;
427 /******************************************************************************
429 * Connects to the specified address.
431 BOOL
NETCON_connect(WININET_NETCONNECTION
*connection
, const struct sockaddr
*serv_addr
,
432 unsigned int addrlen
)
436 if (!NETCON_connected(connection
)) return FALSE
;
438 result
= connect(connection
->socketFD
, serv_addr
, addrlen
);
441 WARN("Unable to connect to host (%s)\n", strerror(errno
));
442 INTERNET_SetLastError(sock_get_error(errno
));
444 closesocket(connection
->socketFD
);
445 connection
->socketFD
= -1;
452 /******************************************************************************
454 * Basically calls 'send()' unless we should use SSL
455 * number of chars send is put in *sent
457 BOOL
NETCON_send(WININET_NETCONNECTION
*connection
, const void *msg
, size_t len
, int flags
,
460 if (!NETCON_connected(connection
)) return FALSE
;
461 if (!connection
->useSSL
)
463 *sent
= send(connection
->socketFD
, msg
, len
, flags
);
466 INTERNET_SetLastError(sock_get_error(errno
));
473 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
475 FIXME("SSL_write doesn't support any flags (%08x)\n", flags
);
476 *sent
= pSSL_write(connection
->ssl_s
, msg
, len
);
477 if (*sent
< 1 && len
)
486 /******************************************************************************
488 * Basically calls 'recv()' unless we should use SSL
489 * number of chars received is put in *recvd
491 BOOL
NETCON_recv(WININET_NETCONNECTION
*connection
, void *buf
, size_t len
, int flags
,
492 int *recvd
/* out */)
494 if (!NETCON_connected(connection
)) return FALSE
;
495 if (!connection
->useSSL
)
497 *recvd
= recv(connection
->socketFD
, buf
, len
, flags
);
500 INTERNET_SetLastError(sock_get_error(errno
));
507 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
508 if (flags
& (~MSG_PEEK
))
509 FIXME("SSL_read does not support the following flag: %08x\n", flags
);
511 /* this ugly hack is all for MSG_PEEK. eww gross */
512 if (flags
& MSG_PEEK
&& !connection
->peek_msg
)
514 connection
->peek_msg
= connection
->peek_msg_mem
= HeapAlloc(GetProcessHeap(), 0, (sizeof(char) * len
) + 1);
516 else if (flags
& MSG_PEEK
&& connection
->peek_msg
)
518 size_t peek_msg_len
= strlen(connection
->peek_msg
);
519 if (len
< peek_msg_len
)
520 FIXME("buffer isn't big enough. Do the expect us to wrap?\n");
521 memcpy(buf
, connection
->peek_msg
, min(len
,peek_msg_len
+1));
522 *recvd
= min(len
, peek_msg_len
);
525 else if (connection
->peek_msg
)
527 size_t peek_msg_len
= strlen(connection
->peek_msg
);
528 memcpy(buf
, connection
->peek_msg
, min(len
,peek_msg_len
+1));
529 connection
->peek_msg
+= *recvd
= min(len
, peek_msg_len
);
530 if (*connection
->peek_msg
== '\0' || *(connection
->peek_msg
- 1) == '\0')
532 HeapFree(GetProcessHeap(), 0, connection
->peek_msg_mem
);
533 connection
->peek_msg_mem
= NULL
;
534 connection
->peek_msg
= NULL
;
538 *recvd
= pSSL_read(connection
->ssl_s
, buf
, len
);
539 if (flags
& MSG_PEEK
) /* must copy stuff into buffer */
543 HeapFree(GetProcessHeap(), 0, connection
->peek_msg_mem
);
544 connection
->peek_msg_mem
= NULL
;
545 connection
->peek_msg
= NULL
;
549 memcpy(connection
->peek_msg
, buf
, *recvd
);
550 connection
->peek_msg
[*recvd
] = '\0';
553 if (*recvd
< 1 && len
)
562 /******************************************************************************
565 BOOL
NETCON_getNextLine(WININET_NETCONNECTION
*connection
, LPSTR lpszBuffer
, LPDWORD dwBuffer
)
570 if (!NETCON_connected(connection
)) return FALSE
;
572 if (!connection
->useSSL
)
576 BOOL bSuccess
= FALSE
;
580 FD_SET(connection
->socketFD
, &infd
);
581 tv
.tv_sec
=RESPONSE_TIMEOUT
;
584 while (nRecv
< *dwBuffer
)
586 if (select(connection
->socketFD
+1,&infd
,NULL
,NULL
,&tv
) > 0)
588 if (recv(connection
->socketFD
, &lpszBuffer
[nRecv
], 1, 0) <= 0)
590 INTERNET_SetLastError(sock_get_error(errno
));
594 if (lpszBuffer
[nRecv
] == '\n')
599 if (lpszBuffer
[nRecv
] != '\r')
604 INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT
);
609 lend
: /* FIXME: don't use labels */
612 lpszBuffer
[nRecv
++] = '\0';
614 TRACE(":%lu %s\n", nRecv
, lpszBuffer
);
624 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
629 prev_timeout
= pSSL_CTX_get_timeout(ctx
);
630 pSSL_CTX_set_timeout(ctx
, RESPONSE_TIMEOUT
);
632 while (nRecv
< *dwBuffer
)
635 if (!NETCON_recv(connection
, &lpszBuffer
[nRecv
], 1, 0, &recv
))
637 INTERNET_SetLastError(ERROR_CONNECTION_ABORTED
);
641 if (lpszBuffer
[nRecv
] == '\n')
646 if (lpszBuffer
[nRecv
] != '\r')
650 pSSL_CTX_set_timeout(ctx
, prev_timeout
);
653 lpszBuffer
[nRecv
++] = '\0';
655 TRACE("_SSL:%lu %s\n", nRecv
, lpszBuffer
);
666 LPCVOID
NETCON_GetCert(WININET_NETCONNECTION
*connection
)
669 #if defined HAVE_OPENSSL_SSL_H && defined HAVE_OPENSSL_ERR_H
671 unsigned char* buffer
,*p
;
673 BOOL malloced
= FALSE
;
676 if (!connection
->useSSL
)
679 cert
= pSSL_get_peer_certificate(connection
->ssl_s
);
681 len
= pi2d_X509(cert
,&p
);
683 * SSL 0.9.7 and above malloc the buffer if it is null.
684 * however earlier version do not and so we would need to alloc the buffer.
686 * see the i2d_X509 man page for more details.
690 buffer
= HeapAlloc(GetProcessHeap(),0,len
);
692 len
= pi2d_X509(cert
,&p
);
700 r
= CertCreateCertificateContext(X509_ASN_ENCODING
,buffer
,len
);
705 HeapFree(GetProcessHeap(),0,buffer
);