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 #define NONAMELESSUNION
47 #include "wine/debug.h"
48 #include "wine/library.h"
55 #include "winhttp_private.h"
57 /* to avoid conflicts with the Unix socket headers */
61 WINE_DEFAULT_DEBUG_CHANNEL(winhttp
);
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 CRITICAL_SECTION init_ssl_cs
;
82 static CRITICAL_SECTION_DEBUG init_ssl_cs_debug
=
85 { &init_ssl_cs_debug
.ProcessLocksList
,
86 &init_ssl_cs_debug
.ProcessLocksList
},
87 0, 0, { (DWORD_PTR
)(__FILE__
": init_ssl_cs") }
89 static CRITICAL_SECTION init_ssl_cs
= { &init_ssl_cs_debug
, -1, 0, 0, 0, 0 };
91 static void *libssl_handle
;
92 static void *libcrypto_handle
;
94 static SSL_METHOD
*method
;
96 static int hostname_idx
;
98 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
100 MAKE_FUNCPTR( SSL_library_init
);
101 MAKE_FUNCPTR( SSL_load_error_strings
);
102 MAKE_FUNCPTR( SSLv23_method
);
103 MAKE_FUNCPTR( SSL_CTX_free
);
104 MAKE_FUNCPTR( SSL_CTX_new
);
105 MAKE_FUNCPTR( SSL_new
);
106 MAKE_FUNCPTR( SSL_free
);
107 MAKE_FUNCPTR( SSL_set_fd
);
108 MAKE_FUNCPTR( SSL_connect
);
109 MAKE_FUNCPTR( SSL_shutdown
);
110 MAKE_FUNCPTR( SSL_write
);
111 MAKE_FUNCPTR( SSL_read
);
112 MAKE_FUNCPTR( SSL_get_ex_new_index
);
113 MAKE_FUNCPTR( SSL_get_ex_data
);
114 MAKE_FUNCPTR( SSL_set_ex_data
);
115 MAKE_FUNCPTR( SSL_get_ex_data_X509_STORE_CTX_idx
);
116 MAKE_FUNCPTR( SSL_get_verify_result
);
117 MAKE_FUNCPTR( SSL_get_peer_certificate
);
118 MAKE_FUNCPTR( SSL_CTX_set_default_verify_paths
);
119 MAKE_FUNCPTR( SSL_CTX_set_verify
);
121 MAKE_FUNCPTR( CRYPTO_num_locks
);
122 MAKE_FUNCPTR( CRYPTO_set_id_callback
);
123 MAKE_FUNCPTR( CRYPTO_set_locking_callback
);
124 MAKE_FUNCPTR( ERR_free_strings
);
125 MAKE_FUNCPTR( ERR_get_error
);
126 MAKE_FUNCPTR( ERR_error_string
);
127 MAKE_FUNCPTR( X509_STORE_CTX_get_ex_data
);
128 MAKE_FUNCPTR( i2d_X509
);
129 MAKE_FUNCPTR( sk_value
);
130 MAKE_FUNCPTR( sk_num
);
133 static CRITICAL_SECTION
*ssl_locks
;
134 static unsigned int num_ssl_locks
;
136 static unsigned long ssl_thread_id(void)
138 return GetCurrentThreadId();
141 static void ssl_lock_callback(int mode
, int type
, const char *file
, int line
)
143 if (mode
& CRYPTO_LOCK
)
144 EnterCriticalSection( &ssl_locks
[type
] );
146 LeaveCriticalSection( &ssl_locks
[type
] );
151 /* translate a unix error code into a winsock error code */
152 static int sock_get_error( int err
)
154 #if !defined(__MINGW32__) && !defined (_MSC_VER)
157 case EINTR
: return WSAEINTR
;
158 case EBADF
: return WSAEBADF
;
160 case EACCES
: return WSAEACCES
;
161 case EFAULT
: return WSAEFAULT
;
162 case EINVAL
: return WSAEINVAL
;
163 case EMFILE
: return WSAEMFILE
;
164 case EWOULDBLOCK
: return WSAEWOULDBLOCK
;
165 case EINPROGRESS
: return WSAEINPROGRESS
;
166 case EALREADY
: return WSAEALREADY
;
167 case ENOTSOCK
: return WSAENOTSOCK
;
168 case EDESTADDRREQ
: return WSAEDESTADDRREQ
;
169 case EMSGSIZE
: return WSAEMSGSIZE
;
170 case EPROTOTYPE
: return WSAEPROTOTYPE
;
171 case ENOPROTOOPT
: return WSAENOPROTOOPT
;
172 case EPROTONOSUPPORT
: return WSAEPROTONOSUPPORT
;
173 case ESOCKTNOSUPPORT
: return WSAESOCKTNOSUPPORT
;
174 case EOPNOTSUPP
: return WSAEOPNOTSUPP
;
175 case EPFNOSUPPORT
: return WSAEPFNOSUPPORT
;
176 case EAFNOSUPPORT
: return WSAEAFNOSUPPORT
;
177 case EADDRINUSE
: return WSAEADDRINUSE
;
178 case EADDRNOTAVAIL
: return WSAEADDRNOTAVAIL
;
179 case ENETDOWN
: return WSAENETDOWN
;
180 case ENETUNREACH
: return WSAENETUNREACH
;
181 case ENETRESET
: return WSAENETRESET
;
182 case ECONNABORTED
: return WSAECONNABORTED
;
184 case ECONNRESET
: return WSAECONNRESET
;
185 case ENOBUFS
: return WSAENOBUFS
;
186 case EISCONN
: return WSAEISCONN
;
187 case ENOTCONN
: return WSAENOTCONN
;
188 case ESHUTDOWN
: return WSAESHUTDOWN
;
189 case ETOOMANYREFS
: return WSAETOOMANYREFS
;
190 case ETIMEDOUT
: return WSAETIMEDOUT
;
191 case ECONNREFUSED
: return WSAECONNREFUSED
;
192 case ELOOP
: return WSAELOOP
;
193 case ENAMETOOLONG
: return WSAENAMETOOLONG
;
194 case EHOSTDOWN
: return WSAEHOSTDOWN
;
195 case EHOSTUNREACH
: return WSAEHOSTUNREACH
;
196 case ENOTEMPTY
: return WSAENOTEMPTY
;
198 case EPROCLIM
: return WSAEPROCLIM
;
201 case EUSERS
: return WSAEUSERS
;
204 case EDQUOT
: return WSAEDQUOT
;
207 case ESTALE
: return WSAESTALE
;
210 case EREMOTE
: return WSAEREMOTE
;
212 default: errno
= err
; perror( "sock_set_error" ); return WSAEFAULT
;
219 static PCCERT_CONTEXT
X509_to_cert_context(X509
*cert
)
221 unsigned char *buffer
, *p
;
227 if ((len
= pi2d_X509( cert
, &p
)) < 0) return NULL
;
229 * SSL 0.9.7 and above malloc the buffer if it is null.
230 * however earlier version do not and so we would need to alloc the buffer.
232 * see the i2d_X509 man page for more details.
236 if (!(buffer
= heap_alloc( len
))) return NULL
;
238 len
= pi2d_X509( cert
, &p
);
246 ret
= CertCreateCertificateContext( X509_ASN_ENCODING
, buffer
, len
);
248 if (malloc
) free( buffer
);
249 else heap_free( buffer
);
254 static DWORD
netconn_verify_cert( PCCERT_CONTEXT cert
, HCERTSTORE store
,
258 CERT_CHAIN_PARA chainPara
= { sizeof(chainPara
), { 0 } };
259 PCCERT_CHAIN_CONTEXT chain
;
260 char oid_server_auth
[] = szOID_PKIX_KP_SERVER_AUTH
;
261 char *server_auth
[] = { oid_server_auth
};
262 DWORD err
= ERROR_SUCCESS
;
264 TRACE("verifying %s\n", debugstr_w( server
));
265 chainPara
.RequestedUsage
.Usage
.cUsageIdentifier
= 1;
266 chainPara
.RequestedUsage
.Usage
.rgpszUsageIdentifier
= server_auth
;
267 if ((ret
= CertGetCertificateChain( NULL
, cert
, NULL
, store
, &chainPara
, 0,
270 if (chain
->TrustStatus
.dwErrorStatus
)
272 if (chain
->TrustStatus
.dwErrorStatus
& CERT_TRUST_IS_NOT_TIME_VALID
)
273 err
= ERROR_WINHTTP_SECURE_CERT_DATE_INVALID
;
274 else if (chain
->TrustStatus
.dwErrorStatus
&
275 CERT_TRUST_IS_UNTRUSTED_ROOT
)
276 err
= ERROR_WINHTTP_SECURE_INVALID_CA
;
277 else if ((chain
->TrustStatus
.dwErrorStatus
&
278 CERT_TRUST_IS_OFFLINE_REVOCATION
) ||
279 (chain
->TrustStatus
.dwErrorStatus
&
280 CERT_TRUST_REVOCATION_STATUS_UNKNOWN
))
281 err
= ERROR_WINHTTP_SECURE_CERT_REV_FAILED
;
282 else if (chain
->TrustStatus
.dwErrorStatus
& CERT_TRUST_IS_REVOKED
)
283 err
= ERROR_WINHTTP_SECURE_CERT_REVOKED
;
284 else if (chain
->TrustStatus
.dwErrorStatus
&
285 CERT_TRUST_IS_NOT_VALID_FOR_USAGE
)
286 err
= ERROR_WINHTTP_SECURE_CERT_WRONG_USAGE
;
288 err
= ERROR_WINHTTP_SECURE_INVALID_CERT
;
292 CERT_CHAIN_POLICY_PARA policyPara
;
293 SSL_EXTRA_CERT_CHAIN_POLICY_PARA sslExtraPolicyPara
;
294 CERT_CHAIN_POLICY_STATUS policyStatus
;
296 sslExtraPolicyPara
.u
.cbSize
= sizeof(sslExtraPolicyPara
);
297 sslExtraPolicyPara
.dwAuthType
= AUTHTYPE_SERVER
;
298 sslExtraPolicyPara
.pwszServerName
= server
;
299 policyPara
.cbSize
= sizeof(policyPara
);
300 policyPara
.dwFlags
= 0;
301 policyPara
.pvExtraPolicyPara
= &sslExtraPolicyPara
;
302 ret
= CertVerifyCertificateChainPolicy( CERT_CHAIN_POLICY_SSL
,
305 /* Any error in the policy status indicates that the
306 * policy couldn't be verified.
308 if (ret
&& policyStatus
.dwError
)
310 if (policyStatus
.dwError
== CERT_E_CN_NO_MATCH
)
311 err
= ERROR_WINHTTP_SECURE_CERT_CN_INVALID
;
313 err
= ERROR_WINHTTP_SECURE_INVALID_CERT
;
316 CertFreeCertificateChain( chain
);
319 err
= ERROR_WINHTTP_SECURE_CHANNEL_ERROR
;
320 TRACE("returning %08x\n", err
);
324 static int netconn_secure_verify( int preverify_ok
, X509_STORE_CTX
*ctx
)
330 ssl
= pX509_STORE_CTX_get_ex_data( ctx
, pSSL_get_ex_data_X509_STORE_CTX_idx() );
331 server
= pSSL_get_ex_data( ssl
, hostname_idx
);
334 HCERTSTORE store
= CertOpenStore( CERT_STORE_PROV_MEMORY
, 0, 0,
335 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
341 PCCERT_CONTEXT endCert
= NULL
;
344 for (i
= 0; ret
&& i
< psk_num((struct stack_st
*)ctx
->chain
); i
++)
346 PCCERT_CONTEXT context
;
348 cert
= (X509
*)psk_value((struct stack_st
*)ctx
->chain
, i
);
349 if ((context
= X509_to_cert_context( cert
)))
352 ret
= CertAddCertificateContextToStore( store
, context
,
353 CERT_STORE_ADD_ALWAYS
, &endCert
);
355 ret
= CertAddCertificateContextToStore( store
, context
,
356 CERT_STORE_ADD_ALWAYS
, NULL
);
357 CertFreeCertificateContext( context
);
360 if (!endCert
) ret
= FALSE
;
363 DWORD err
= netconn_verify_cert( endCert
, store
, server
);
367 set_last_error( err
);
371 CertFreeCertificateContext( endCert
);
372 CertCloseStore( store
, 0 );
379 BOOL
netconn_init( netconn_t
*conn
, BOOL secure
)
381 #if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO)
386 if (!secure
) return TRUE
;
388 #if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO)
389 EnterCriticalSection( &init_ssl_cs
);
392 LeaveCriticalSection( &init_ssl_cs
);
395 if (!(libssl_handle
= wine_dlopen( SONAME_LIBSSL
, RTLD_NOW
, NULL
, 0 )))
397 ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBSSL
);
398 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR
);
399 LeaveCriticalSection( &init_ssl_cs
);
402 if (!(libcrypto_handle
= wine_dlopen( SONAME_LIBCRYPTO
, RTLD_NOW
, NULL
, 0 )))
404 ERR("Trying to use SSL but couldn't load %s. Expect trouble.\n", SONAME_LIBCRYPTO
);
405 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR
);
406 LeaveCriticalSection( &init_ssl_cs
);
409 #define LOAD_FUNCPTR(x) \
410 if (!(p##x = wine_dlsym( libssl_handle, #x, NULL, 0 ))) \
412 ERR("Failed to load symbol %s\n", #x); \
413 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \
414 LeaveCriticalSection( &init_ssl_cs ); \
417 LOAD_FUNCPTR( SSL_library_init
);
418 LOAD_FUNCPTR( SSL_load_error_strings
);
419 LOAD_FUNCPTR( SSLv23_method
);
420 LOAD_FUNCPTR( SSL_CTX_free
);
421 LOAD_FUNCPTR( SSL_CTX_new
);
422 LOAD_FUNCPTR( SSL_new
);
423 LOAD_FUNCPTR( SSL_free
);
424 LOAD_FUNCPTR( SSL_set_fd
);
425 LOAD_FUNCPTR( SSL_connect
);
426 LOAD_FUNCPTR( SSL_shutdown
);
427 LOAD_FUNCPTR( SSL_write
);
428 LOAD_FUNCPTR( SSL_read
);
429 LOAD_FUNCPTR( SSL_get_ex_new_index
);
430 LOAD_FUNCPTR( SSL_get_ex_data
);
431 LOAD_FUNCPTR( SSL_set_ex_data
);
432 LOAD_FUNCPTR( SSL_get_ex_data_X509_STORE_CTX_idx
);
433 LOAD_FUNCPTR( SSL_get_verify_result
);
434 LOAD_FUNCPTR( SSL_get_peer_certificate
);
435 LOAD_FUNCPTR( SSL_CTX_set_default_verify_paths
);
436 LOAD_FUNCPTR( SSL_CTX_set_verify
);
439 #define LOAD_FUNCPTR(x) \
440 if (!(p##x = wine_dlsym( libcrypto_handle, #x, NULL, 0 ))) \
442 ERR("Failed to load symbol %s\n", #x); \
443 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR ); \
444 LeaveCriticalSection( &init_ssl_cs ); \
447 LOAD_FUNCPTR( CRYPTO_num_locks
);
448 LOAD_FUNCPTR( CRYPTO_set_id_callback
);
449 LOAD_FUNCPTR( CRYPTO_set_locking_callback
);
450 LOAD_FUNCPTR( ERR_free_strings
);
451 LOAD_FUNCPTR( ERR_get_error
);
452 LOAD_FUNCPTR( ERR_error_string
);
453 LOAD_FUNCPTR( X509_STORE_CTX_get_ex_data
);
454 LOAD_FUNCPTR( i2d_X509
);
455 LOAD_FUNCPTR( sk_value
);
456 LOAD_FUNCPTR( sk_num
);
460 pSSL_load_error_strings();
462 method
= pSSLv23_method();
463 ctx
= pSSL_CTX_new( method
);
464 if (!pSSL_CTX_set_default_verify_paths( ctx
))
466 ERR("SSL_CTX_set_default_verify_paths failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
467 set_last_error( ERROR_OUTOFMEMORY
);
468 LeaveCriticalSection( &init_ssl_cs
);
471 hostname_idx
= pSSL_get_ex_new_index( 0, (void *)"hostname index", NULL
, NULL
, NULL
);
472 if (hostname_idx
== -1)
474 ERR("SSL_get_ex_new_index failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
475 set_last_error( ERROR_OUTOFMEMORY
);
476 LeaveCriticalSection( &init_ssl_cs
);
479 pSSL_CTX_set_verify( ctx
, SSL_VERIFY_PEER
, netconn_secure_verify
);
481 pCRYPTO_set_id_callback(ssl_thread_id
);
482 num_ssl_locks
= pCRYPTO_num_locks();
483 ssl_locks
= HeapAlloc(GetProcessHeap(), 0, num_ssl_locks
* sizeof(CRITICAL_SECTION
));
486 set_last_error( ERROR_OUTOFMEMORY
);
487 LeaveCriticalSection( &init_ssl_cs
);
490 for (i
= 0; i
< num_ssl_locks
; i
++) InitializeCriticalSection( &ssl_locks
[i
] );
491 pCRYPTO_set_locking_callback(ssl_lock_callback
);
493 LeaveCriticalSection( &init_ssl_cs
);
495 WARN("SSL support not compiled in.\n");
496 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR
);
502 void netconn_unload( void )
504 #if defined(SONAME_LIBSSL) && defined(SONAME_LIBCRYPTO)
505 if (libcrypto_handle
)
508 wine_dlclose( libcrypto_handle
, NULL
, 0 );
513 pSSL_CTX_free( ctx
);
514 wine_dlclose( libssl_handle
, NULL
, 0 );
519 for (i
= 0; i
< num_ssl_locks
; i
++) DeleteCriticalSection( &ssl_locks
[i
] );
520 HeapFree( GetProcessHeap(), 0, ssl_locks
);
525 BOOL
netconn_connected( netconn_t
*conn
)
527 return (conn
->socket
!= -1);
530 BOOL
netconn_create( netconn_t
*conn
, int domain
, int type
, int protocol
)
532 if ((conn
->socket
= socket( domain
, type
, protocol
)) == -1)
534 WARN("unable to create socket (%s)\n", strerror(errno
));
535 set_last_error( sock_get_error( errno
) );
541 BOOL
netconn_close( netconn_t
*conn
)
548 heap_free( conn
->peek_msg_mem
);
549 conn
->peek_msg_mem
= NULL
;
550 conn
->peek_msg
= NULL
;
553 pSSL_shutdown( conn
->ssl_conn
);
554 pSSL_free( conn
->ssl_conn
);
556 conn
->ssl_conn
= NULL
;
557 conn
->secure
= FALSE
;
560 res
= closesocket( conn
->socket
);
564 set_last_error( sock_get_error( errno
) );
570 BOOL
netconn_connect( netconn_t
*conn
, const struct sockaddr
*sockaddr
, unsigned int addr_len
, int timeout
)
578 ioctlsocket( conn
->socket
, FIONBIO
, &state
);
580 if (connect( conn
->socket
, sockaddr
, addr_len
) < 0)
582 res
= sock_get_error( errno
);
583 if (res
== WSAEWOULDBLOCK
|| res
== WSAEINPROGRESS
)
587 pfd
.fd
= conn
->socket
;
588 pfd
.events
= POLLOUT
;
589 if (poll( &pfd
, 1, timeout
) > 0)
592 res
= sock_get_error( errno
);
600 ioctlsocket( conn
->socket
, FIONBIO
, &state
);
604 WARN("unable to connect to host (%d)\n", res
);
605 set_last_error( res
);
610 BOOL
netconn_secure_connect( netconn_t
*conn
, WCHAR
*hostname
)
615 if (!(conn
->ssl_conn
= pSSL_new( ctx
)))
617 ERR("SSL_new failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
618 set_last_error( ERROR_OUTOFMEMORY
);
621 if (!pSSL_set_ex_data( conn
->ssl_conn
, hostname_idx
, hostname
))
623 ERR("SSL_set_ex_data failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
624 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR
);
627 if (!pSSL_set_fd( conn
->ssl_conn
, conn
->socket
))
629 ERR("SSL_set_fd failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
630 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR
);
633 if (pSSL_connect( conn
->ssl_conn
) <= 0)
635 ERR("SSL_connect failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
636 set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR
);
639 if ((res
= pSSL_get_verify_result( conn
->ssl_conn
)) != X509_V_OK
)
641 /* FIXME: we should set an error and return, but we only print an error at the moment */
642 ERR("couldn't verify server certificate (%ld)\n", res
);
644 TRACE("established SSL connection\n");
651 pSSL_shutdown( conn
->ssl_conn
);
652 pSSL_free( conn
->ssl_conn
);
653 conn
->ssl_conn
= NULL
;
659 BOOL
netconn_send( netconn_t
*conn
, const void *msg
, size_t len
, int flags
, int *sent
)
661 if (!netconn_connected( conn
)) return FALSE
;
665 if (flags
) FIXME("SSL_write doesn't support any flags (%08x)\n", flags
);
666 *sent
= pSSL_write( conn
->ssl_conn
, msg
, len
);
667 if (*sent
< 1 && len
) return FALSE
;
673 if ((*sent
= send( conn
->socket
, msg
, len
, flags
)) == -1)
675 set_last_error( sock_get_error( errno
) );
681 BOOL
netconn_recv( netconn_t
*conn
, void *buf
, size_t len
, int flags
, int *recvd
)
684 if (!netconn_connected( conn
)) return FALSE
;
685 if (!len
) return TRUE
;
690 if (flags
& ~(MSG_PEEK
| MSG_WAITALL
))
691 FIXME("SSL_read does not support the following flags: %08x\n", flags
);
693 /* this ugly hack is all for MSG_PEEK */
694 if (flags
& MSG_PEEK
&& !conn
->peek_msg
)
696 if (!(conn
->peek_msg
= conn
->peek_msg_mem
= heap_alloc( len
+ 1 ))) return FALSE
;
698 else if (flags
& MSG_PEEK
&& conn
->peek_msg
)
700 if (len
< conn
->peek_len
) FIXME("buffer isn't big enough, should we wrap?\n");
701 *recvd
= min( len
, conn
->peek_len
);
702 memcpy( buf
, conn
->peek_msg
, *recvd
);
705 else if (conn
->peek_msg
)
707 *recvd
= min( len
, conn
->peek_len
);
708 memcpy( buf
, conn
->peek_msg
, *recvd
);
709 conn
->peek_len
-= *recvd
;
710 conn
->peek_msg
+= *recvd
;
712 if (conn
->peek_len
== 0)
714 heap_free( conn
->peek_msg_mem
);
715 conn
->peek_msg_mem
= NULL
;
716 conn
->peek_msg
= NULL
;
718 /* check if we have enough data from the peek buffer */
719 if (!(flags
& MSG_WAITALL
) || (*recvd
== len
)) return TRUE
;
721 *recvd
+= pSSL_read( conn
->ssl_conn
, (char *)buf
+ *recvd
, len
- *recvd
);
722 if (flags
& MSG_PEEK
) /* must copy into buffer */
724 conn
->peek_len
= *recvd
;
727 heap_free( conn
->peek_msg_mem
);
728 conn
->peek_msg_mem
= NULL
;
729 conn
->peek_msg
= NULL
;
731 else memcpy( conn
->peek_msg
, buf
, *recvd
);
733 if (*recvd
< 1 && len
) return FALSE
;
739 if ((*recvd
= recv( conn
->socket
, buf
, len
, flags
)) == -1)
741 set_last_error( sock_get_error( errno
) );
747 BOOL
netconn_query_data_available( netconn_t
*conn
, DWORD
*available
)
753 if (!netconn_connected( conn
)) return FALSE
;
758 if (conn
->peek_msg
) *available
= conn
->peek_len
;
763 if (!(ret
= ioctlsocket( conn
->socket
, FIONREAD
, &unread
))) *available
= unread
;
768 BOOL
netconn_get_next_line( netconn_t
*conn
, char *buffer
, DWORD
*buflen
)
774 if (!netconn_connected( conn
)) return FALSE
;
779 while (recvd
< *buflen
)
782 if (!netconn_recv( conn
, &buffer
[recvd
], 1, 0, &dummy
))
784 set_last_error( ERROR_CONNECTION_ABORTED
);
787 if (buffer
[recvd
] == '\n')
792 if (buffer
[recvd
] != '\r') recvd
++;
798 TRACE("received line %s\n", debugstr_a(buffer
));
806 pfd
.fd
= conn
->socket
;
808 while (recvd
< *buflen
)
812 socklen_t len
= sizeof(tv
);
814 if ((res
= getsockopt( conn
->socket
, SOL_SOCKET
, SO_RCVTIMEO
, (void*)&tv
, &len
) != -1))
815 timeout
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
818 if (poll( &pfd
, 1, timeout
) > 0)
820 if ((res
= recv( conn
->socket
, &buffer
[recvd
], 1, 0 )) <= 0)
822 if (res
== -1) set_last_error( sock_get_error( errno
) );
825 if (buffer
[recvd
] == '\n')
830 if (buffer
[recvd
] != '\r') recvd
++;
834 set_last_error( ERROR_WINHTTP_TIMEOUT
);
842 TRACE("received line %s\n", debugstr_a(buffer
));
847 DWORD
netconn_set_timeout( netconn_t
*netconn
, BOOL send
, int value
)
852 /* value is in milliseconds, convert to struct timeval */
853 tv
.tv_sec
= value
/ 1000;
854 tv
.tv_usec
= (value
% 1000) * 1000;
856 if ((res
= setsockopt( netconn
->socket
, SOL_SOCKET
, send
? SO_SNDTIMEO
: SO_RCVTIMEO
, (void*)&tv
, sizeof(tv
) ) == -1))
858 WARN("setsockopt failed (%s)\n", strerror( errno
));
859 return sock_get_error( errno
);
861 return ERROR_SUCCESS
;
864 BOOL
netconn_resolve( WCHAR
*hostnameW
, INTERNET_PORT port
, struct sockaddr
*sa
, socklen_t
*sa_len
)
867 #ifdef HAVE_GETADDRINFO
868 struct addrinfo
*res
, hints
;
872 struct sockaddr_in
*sin
= (struct sockaddr_in
*)sa
;
875 if (!(hostname
= strdupWA( hostnameW
))) return FALSE
;
877 #ifdef HAVE_GETADDRINFO
878 memset( &hints
, 0, sizeof(struct addrinfo
) );
879 /* Prefer IPv4 to IPv6 addresses, since some web servers do not listen on
880 * their IPv6 addresses even though they have IPv6 addresses in the DNS.
882 hints
.ai_family
= AF_INET
;
884 ret
= getaddrinfo( hostname
, NULL
, &hints
, &res
);
887 TRACE("failed to get IPv4 address of %s (%s), retrying with IPv6\n", debugstr_w(hostnameW
), gai_strerror(ret
));
888 hints
.ai_family
= AF_INET6
;
889 ret
= getaddrinfo( hostname
, NULL
, &hints
, &res
);
892 TRACE("failed to get address of %s (%s)\n", debugstr_w(hostnameW
), gai_strerror(ret
));
893 heap_free( hostname
);
897 heap_free( hostname
);
898 if (*sa_len
< res
->ai_addrlen
)
900 WARN("address too small\n");
904 *sa_len
= res
->ai_addrlen
;
905 memcpy( sa
, res
->ai_addr
, res
->ai_addrlen
);
907 switch (res
->ai_family
)
910 ((struct sockaddr_in
*)sa
)->sin_port
= htons( port
);
913 ((struct sockaddr_in6
*)sa
)->sin6_port
= htons( port
);
920 EnterCriticalSection( &cs_gethostbyname
);
922 he
= gethostbyname( hostname
);
923 heap_free( hostname
);
926 TRACE("failed to get address of %s (%d)\n", debugstr_w(hostnameW
), h_errno
);
927 LeaveCriticalSection( &cs_gethostbyname
);
930 if (*sa_len
< sizeof(struct sockaddr_in
))
932 WARN("address too small\n");
933 LeaveCriticalSection( &cs_gethostbyname
);
936 *sa_len
= sizeof(struct sockaddr_in
);
937 memset( sa
, 0, sizeof(struct sockaddr_in
) );
938 memcpy( &sin
->sin_addr
, he
->h_addr
, he
->h_length
);
939 sin
->sin_family
= he
->h_addrtype
;
940 sin
->sin_port
= htons( port
);
942 LeaveCriticalSection( &cs_gethostbyname
);
947 const void *netconn_get_certificate( netconn_t
*conn
)
951 const CERT_CONTEXT
*ret
;
953 if (!conn
->secure
) return NULL
;
955 if (!(cert
= pSSL_get_peer_certificate( conn
->ssl_conn
))) return NULL
;
956 ret
= X509_to_cert_context( cert
);