*/
#include "config.h"
-#include "wine/port.h"
-
+#define NONAMELESSUNION
+#include "ws2tcpip.h"
#include <stdarg.h>
#include <stdio.h>
-#include <errno.h>
#include <assert.h>
-#include <sys/types.h>
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_SYS_IOCTL_H
-# include <sys/ioctl.h>
-#endif
-#ifdef HAVE_SYS_FILIO_H
-# include <sys/filio.h>
-#endif
-#ifdef HAVE_POLL_H
-# include <poll.h>
-#endif
-
-#define NONAMELESSUNION
-
-#include "wine/debug.h"
-#include "wine/library.h"
-
#include "windef.h"
#include "winbase.h"
#include "winhttp.h"
-#include "wincrypt.h"
#include "schannel.h"
+#include "wine/debug.h"
+#include "wine/library.h"
#include "winhttp_private.h"
-/* to avoid conflicts with the Unix socket headers */
-#define USE_WS_PREFIX
-#include "winsock2.h"
-
WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
-#ifndef HAVE_GETADDRINFO
-
-/* critical section to protect non-reentrant gethostbyname() */
-static CRITICAL_SECTION cs_gethostbyname;
-static CRITICAL_SECTION_DEBUG critsect_debug =
-{
- 0, 0, &cs_gethostbyname,
- { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
- 0, 0, { (DWORD_PTR)(__FILE__ ": cs_gethostbyname") }
-};
-static CRITICAL_SECTION cs_gethostbyname = { &critsect_debug, -1, 0, 0, 0, 0 };
-
-#endif
-
-/* translate a unix error code into a winsock error code */
-#ifndef __REACTOS__
-static int sock_get_error( int err )
-{
-#if !defined(__MINGW32__) && !defined (_MSC_VER)
- switch (err)
- {
- case EINTR: return WSAEINTR;
- case EBADF: return WSAEBADF;
- case EPERM:
- case EACCES: return WSAEACCES;
- case EFAULT: return WSAEFAULT;
- case EINVAL: return WSAEINVAL;
- case EMFILE: return WSAEMFILE;
- case EWOULDBLOCK: return WSAEWOULDBLOCK;
- case EINPROGRESS: return WSAEINPROGRESS;
- case EALREADY: return WSAEALREADY;
- case ENOTSOCK: return WSAENOTSOCK;
- case EDESTADDRREQ: return WSAEDESTADDRREQ;
- case EMSGSIZE: return WSAEMSGSIZE;
- case EPROTOTYPE: return WSAEPROTOTYPE;
- case ENOPROTOOPT: return WSAENOPROTOOPT;
- case EPROTONOSUPPORT: return WSAEPROTONOSUPPORT;
- case ESOCKTNOSUPPORT: return WSAESOCKTNOSUPPORT;
- case EOPNOTSUPP: return WSAEOPNOTSUPP;
- case EPFNOSUPPORT: return WSAEPFNOSUPPORT;
- case EAFNOSUPPORT: return WSAEAFNOSUPPORT;
- case EADDRINUSE: return WSAEADDRINUSE;
- case EADDRNOTAVAIL: return WSAEADDRNOTAVAIL;
- case ENETDOWN: return WSAENETDOWN;
- case ENETUNREACH: return WSAENETUNREACH;
- case ENETRESET: return WSAENETRESET;
- case ECONNABORTED: return WSAECONNABORTED;
- case EPIPE:
- case ECONNRESET: return WSAECONNRESET;
- case ENOBUFS: return WSAENOBUFS;
- case EISCONN: return WSAEISCONN;
- case ENOTCONN: return WSAENOTCONN;
- case ESHUTDOWN: return WSAESHUTDOWN;
- case ETOOMANYREFS: return WSAETOOMANYREFS;
- case ETIMEDOUT: return WSAETIMEDOUT;
- case ECONNREFUSED: return WSAECONNREFUSED;
- case ELOOP: return WSAELOOP;
- case ENAMETOOLONG: return WSAENAMETOOLONG;
- case EHOSTDOWN: return WSAEHOSTDOWN;
- case EHOSTUNREACH: return WSAEHOSTUNREACH;
- case ENOTEMPTY: return WSAENOTEMPTY;
-#ifdef EPROCLIM
- case EPROCLIM: return WSAEPROCLIM;
-#endif
-#ifdef EUSERS
- case EUSERS: return WSAEUSERS;
-#endif
-#ifdef EDQUOT
- case EDQUOT: return WSAEDQUOT;
-#endif
-#ifdef ESTALE
- case ESTALE: return WSAESTALE;
-#endif
-#ifdef EREMOTE
- case EREMOTE: return WSAEREMOTE;
-#endif
- default: errno = err; perror( "sock_set_error" ); return WSAEFAULT;
- }
-#endif
- return err;
-}
-#else
-#define sock_get_error(x) WSAGetLastError()
-
-static inline int unix_ioctl(int filedes, long request, void *arg)
-{
- return ioctlsocket(filedes, request, arg);
-}
-#define ioctlsocket unix_ioctl
-#endif
-
static int sock_send(int fd, const void *msg, size_t len, int flags)
{
int ret;
do
{
- if ((ret = send(fd, msg, len, flags)) == -1) WARN("send error %s\n", strerror(errno));
+ if ((ret = send(fd, msg, len, flags)) == -1) WARN("send error %u\n", WSAGetLastError());
}
- while(ret == -1 && errno == EINTR);
+ while(ret == -1 && WSAGetLastError() == WSAEINTR);
return ret;
}
int ret;
do
{
- if ((ret = recv(fd, msg, len, flags)) == -1) WARN("recv error %s\n", strerror(errno));
+ if ((ret = recv(fd, msg, len, flags)) == -1) WARN("recv error %u\n", WSAGetLastError());
}
- while(ret == -1 && errno == EINTR);
+ while(ret == -1 && WSAGetLastError() == WSAEINTR);
return ret;
}
-static DWORD netconn_verify_cert( PCCERT_CONTEXT cert, WCHAR *server, DWORD security_flags )
+static DWORD netconn_verify_cert( PCCERT_CONTEXT cert, WCHAR *server, DWORD security_flags, BOOL check_revocation )
{
HCERTSTORE store = cert->hCertStore;
BOOL ret;
TRACE("verifying %s\n", debugstr_w( server ));
chainPara.RequestedUsage.Usage.cUsageIdentifier = 1;
chainPara.RequestedUsage.Usage.rgpszUsageIdentifier = server_auth;
- if ((ret = CertGetCertificateChain( NULL, cert, NULL, store, &chainPara,
- CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT,
- NULL, &chain )))
+ ret = CertGetCertificateChain( NULL, cert, NULL, store, &chainPara,
+ check_revocation ? CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT : 0,
+ NULL, &chain );
+ if (ret)
{
if (chain->TrustStatus.dwErrorStatus)
{
return err;
}
-#ifdef __REACTOS__
-static BOOL winsock_initialized = FALSE;
-BOOL netconn_init_winsock()
+static BOOL winsock_loaded;
+
+void netconn_unload( void )
{
- WSADATA wsaData;
- int error;
- if (!winsock_initialized)
- {
- error = WSAStartup(MAKEWORD(1, 1), &wsaData);
- if (error)
- {
- ERR("WSAStartup failed: %d\n", error);
- return FALSE;
- }
- else
- winsock_initialized = TRUE;
- }
- return winsock_initialized;
+ if (winsock_loaded) WSACleanup();
+}
+
+static BOOL WINAPI winsock_startup( INIT_ONCE *once, void *param, void **ctx )
+{
+ int ret;
+ WSADATA data;
+ if (!(ret = WSAStartup( MAKEWORD(1,1), &data ))) winsock_loaded = TRUE;
+ else ERR( "WSAStartup failed: %d\n", ret );
+ return TRUE;
}
-#endif
+static void winsock_init(void)
+{
+ static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
+ InitOnceExecuteOnce( &once, winsock_startup, NULL, NULL );
+}
-void netconn_unload( void )
+static void set_blocking( struct netconn *conn, BOOL blocking )
{
-#ifndef HAVE_GETADDRINFO
- DeleteCriticalSection(&cs_gethostbyname);
-#endif
-#ifdef __REACTOS__
- if(winsock_initialized)
- WSACleanup();
-#endif
+ ULONG state = !blocking;
+ ioctlsocket( conn->socket, FIONBIO, &state );
}
-netconn_t *netconn_create( hostdata_t *host, const struct sockaddr_storage *sockaddr, int timeout )
+struct netconn *netconn_create( struct hostdata *host, const struct sockaddr_storage *sockaddr, int timeout )
{
- netconn_t *conn;
+ struct netconn *conn;
unsigned int addr_len;
BOOL ret = FALSE;
- int res;
- ULONG state;
+
+ winsock_init();
conn = heap_alloc_zero(sizeof(*conn));
if (!conn) return NULL;
conn->sockaddr = *sockaddr;
if ((conn->socket = socket( sockaddr->ss_family, SOCK_STREAM, 0 )) == -1)
{
- WARN("unable to create socket (%s)\n", strerror(errno));
- set_last_error( sock_get_error( errno ) );
+ WARN("unable to create socket (%u)\n", WSAGetLastError());
heap_free(conn);
return NULL;
}
assert(0);
}
- if (timeout > 0)
- {
- state = 1;
- ioctlsocket( conn->socket, FIONBIO, &state );
- }
+ if (timeout > 0) set_blocking( conn, FALSE );
- for (;;)
+ if (!connect( conn->socket, (const struct sockaddr *)&conn->sockaddr, addr_len )) ret = TRUE;
+ else
{
- res = 0;
- if (connect( conn->socket, (const struct sockaddr *)&conn->sockaddr, addr_len ) < 0)
- {
- res = sock_get_error( errno );
- if (res == WSAEWOULDBLOCK || res == WSAEINPROGRESS)
- {
-#ifdef __REACTOS__
- /* ReactOS: use select instead of poll */
- fd_set outfd;
- struct timeval tv;
-
- FD_ZERO(&outfd);
- FD_SET(conn->socket, &outfd);
-
- tv.tv_sec = 0;
- tv.tv_usec = timeout * 1000;
- for (;;)
- {
- res = 0;
-
- if (select( 0, NULL, &outfd, NULL, &tv ) > 0)
-#else
- struct pollfd pfd;
-
- pfd.fd = conn->socket;
- pfd.events = POLLOUT;
- for (;;)
- {
- res = 0;
- if (poll( &pfd, 1, timeout ) > 0)
-#endif
- {
- ret = TRUE;
- break;
- }
- else
- {
- res = sock_get_error( errno );
- if (res != WSAEINTR) break;
- }
- }
- }
- if (res != WSAEINTR) break;
- }
- else
+ DWORD err = WSAGetLastError();
+ if (err == WSAEWOULDBLOCK || err == WSAEINPROGRESS)
{
- ret = TRUE;
- break;
+ FD_SET set;
+ TIMEVAL timeval = { 0, timeout * 1000 };
+ int res;
+
+ FD_ZERO( &set );
+ FD_SET( conn->socket, &set );
+ if ((res = select( conn->socket + 1, NULL, &set, NULL, &timeval )) > 0) ret = TRUE;
+ else if (!res) SetLastError( ERROR_WINHTTP_TIMEOUT );
}
}
- if (timeout > 0)
- {
- state = 0;
- ioctlsocket( conn->socket, FIONBIO, &state );
- }
+
+ if (timeout > 0) set_blocking( conn, TRUE );
+
if (!ret)
{
- WARN("unable to connect to host (%d)\n", res);
- set_last_error( res );
- netconn_close( conn );
+ WARN("unable to connect to host (%u)\n", GetLastError());
+ closesocket( conn->socket );
+ heap_free( conn );
return NULL;
}
return conn;
}
-BOOL netconn_close( netconn_t *conn )
+void netconn_close( struct netconn *conn )
{
- int res;
-
if (conn->secure)
{
heap_free( conn->peek_msg_mem );
heap_free(conn->extra_buf);
DeleteSecurityContext(&conn->ssl_ctx);
}
- res = closesocket( conn->socket );
+ closesocket( conn->socket );
release_host( conn->host );
heap_free(conn);
- if (res == -1)
- {
- set_last_error( sock_get_error( errno ) );
- return FALSE;
- }
- return TRUE;
}
-BOOL netconn_secure_connect( netconn_t *conn, WCHAR *hostname, DWORD security_flags, CredHandle *cred_handle )
+BOOL netconn_secure_connect( struct netconn *conn, WCHAR *hostname, DWORD security_flags, CredHandle *cred_handle,
+ BOOL check_revocation)
{
SecBuffer out_buf = {0, SECBUFFER_TOKEN, NULL}, in_bufs[2] = {{0, SECBUFFER_TOKEN}, {0, SECBUFFER_EMPTY}};
SecBufferDesc out_desc = {SECBUFFER_VERSION, 1, &out_buf}, in_desc = {SECBUFFER_VERSION, 2, in_bufs};
status = QueryContextAttributesW(&ctx, SECPKG_ATTR_REMOTE_CERT_CONTEXT, (void*)&cert);
if(status == SEC_E_OK) {
- res = netconn_verify_cert(cert, hostname, security_flags);
+ res = netconn_verify_cert(cert, hostname, security_flags, check_revocation);
CertFreeCertificateContext(cert);
if(res != ERROR_SUCCESS) {
WARN("cert verify failed: %u\n", res);
heap_free(conn->ssl_buf);
conn->ssl_buf = NULL;
DeleteSecurityContext(&ctx);
- set_last_error(res ? res : ERROR_WINHTTP_SECURE_CHANNEL_ERROR);
+ SetLastError(res ? res : ERROR_WINHTTP_SECURE_CHANNEL_ERROR);
return FALSE;
}
return TRUE;
}
-static BOOL send_ssl_chunk(netconn_t *conn, const void *msg, size_t size)
+static BOOL send_ssl_chunk(struct netconn *conn, const void *msg, size_t size)
{
SecBuffer bufs[4] = {
{conn->ssl_sizes.cbHeader, SECBUFFER_STREAM_HEADER, conn->ssl_buf},
{conn->ssl_sizes.cbTrailer, SECBUFFER_STREAM_TRAILER, conn->ssl_buf+conn->ssl_sizes.cbHeader+size},
{0, SECBUFFER_EMPTY, NULL}
};
- SecBufferDesc buf_desc = {SECBUFFER_VERSION, sizeof(bufs)/sizeof(*bufs), bufs};
+ SecBufferDesc buf_desc = {SECBUFFER_VERSION, ARRAY_SIZE(bufs), bufs};
SECURITY_STATUS res;
memcpy(bufs[1].pvBuffer, msg, size);
return TRUE;
}
-BOOL netconn_send( netconn_t *conn, const void *msg, size_t len, int *sent )
+BOOL netconn_send( struct netconn *conn, const void *msg, size_t len, int *sent )
{
if (conn->secure)
{
return TRUE;
}
- if ((*sent = sock_send( conn->socket, msg, len, 0 )) == -1)
- {
- set_last_error( sock_get_error( errno ) );
- return FALSE;
- }
- return TRUE;
+ return ((*sent = sock_send( conn->socket, msg, len, 0 )) != -1);
}
-static BOOL read_ssl_chunk(netconn_t *conn, void *buf, SIZE_T buf_size, SIZE_T *ret_size, BOOL *eof)
+static BOOL read_ssl_chunk(struct netconn *conn, void *buf, SIZE_T buf_size, SIZE_T *ret_size, BOOL *eof)
{
const SIZE_T ssl_buf_size = conn->ssl_sizes.cbHeader+conn->ssl_sizes.cbMaximumMessage+conn->ssl_sizes.cbTrailer;
SecBuffer bufs[4];
- SecBufferDesc buf_desc = {SECBUFFER_VERSION, sizeof(bufs)/sizeof(*bufs), bufs};
+ SecBufferDesc buf_desc = {SECBUFFER_VERSION, ARRAY_SIZE(bufs), bufs};
SSIZE_T size, buf_len;
unsigned int i;
SECURITY_STATUS res;
}
} while(res != SEC_E_OK);
- for(i=0; i < sizeof(bufs)/sizeof(*bufs); i++) {
+ for(i = 0; i < ARRAY_SIZE(bufs); i++) {
if(bufs[i].BufferType == SECBUFFER_DATA) {
size = min(buf_size, bufs[i].cbBuffer);
memcpy(buf, bufs[i].pvBuffer, size);
}
}
- for(i=0; i < sizeof(bufs)/sizeof(*bufs); i++) {
+ for(i = 0; i < ARRAY_SIZE(bufs); i++) {
if(bufs[i].BufferType == SECBUFFER_EXTRA) {
conn->extra_buf = heap_alloc(bufs[i].cbBuffer);
if(!conn->extra_buf)
return TRUE;
}
-BOOL netconn_recv( netconn_t *conn, void *buf, size_t len, int flags, int *recvd )
+BOOL netconn_recv( struct netconn *conn, void *buf, size_t len, int flags, int *recvd )
{
*recvd = 0;
if (!len) return TRUE;
*recvd = size;
return TRUE;
}
- if ((*recvd = sock_recv( conn->socket, buf, len, flags )) == -1)
- {
- set_last_error( sock_get_error( errno ) );
- return FALSE;
- }
- return TRUE;
+ return ((*recvd = sock_recv( conn->socket, buf, len, flags )) != -1);
}
-ULONG netconn_query_data_available( netconn_t *conn )
+ULONG netconn_query_data_available( struct netconn *conn )
{
return conn->secure ? conn->peek_len : 0;
}
-DWORD netconn_set_timeout( netconn_t *netconn, BOOL send, int value )
+DWORD netconn_set_timeout( struct netconn *netconn, BOOL send, int value )
{
- struct timeval tv;
-
- /* value is in milliseconds, convert to struct timeval */
- tv.tv_sec = value / 1000;
- tv.tv_usec = (value % 1000) * 1000;
-
- if (setsockopt( netconn->socket, SOL_SOCKET, send ? SO_SNDTIMEO : SO_RCVTIMEO, (void*)&tv, sizeof(tv) ) == -1)
+ int opt = send ? SO_SNDTIMEO : SO_RCVTIMEO;
+ if (setsockopt( netconn->socket, SOL_SOCKET, opt, (void *)&value, sizeof(value) ) == -1)
{
- WARN("setsockopt failed (%s)\n", strerror( errno ));
- return sock_get_error( errno );
+ DWORD err = WSAGetLastError();
+ WARN("setsockopt failed (%u)\n", err );
+ return err;
}
return ERROR_SUCCESS;
}
-BOOL netconn_is_alive( netconn_t *netconn )
+BOOL netconn_is_alive( struct netconn *netconn )
{
-#ifdef MSG_DONTWAIT
- ssize_t len;
- BYTE b;
-
- len = recv( netconn->socket, &b, 1, MSG_PEEK | MSG_DONTWAIT );
- return len == 1 || (len == -1 && errno == EWOULDBLOCK);
-#elif defined(__MINGW32__) || defined(_MSC_VER)
- ULONG mode;
int len;
char b;
+ DWORD err;
- mode = 1;
- if(!ioctlsocket(netconn->socket, FIONBIO, &mode))
- return FALSE;
-
- len = recv(netconn->socket, &b, 1, MSG_PEEK);
+ set_blocking( netconn, FALSE );
+ len = sock_recv( netconn->socket, &b, 1, MSG_PEEK );
+ err = WSAGetLastError();
+ set_blocking( netconn, TRUE );
- mode = 0;
- if(!ioctlsocket(netconn->socket, FIONBIO, &mode))
- return FALSE;
-
- return len == 1 || (len == -1 && WSAGetLastError() == WSAEWOULDBLOCK);
-#else
- FIXME("not supported on this platform\n");
- return TRUE;
-#endif
+ return len == 1 || (len == -1 && err == WSAEWOULDBLOCK);
}
-static DWORD resolve_hostname( const WCHAR *hostnameW, INTERNET_PORT port, struct sockaddr_storage *sa )
+static DWORD resolve_hostname( const WCHAR *name, INTERNET_PORT port, struct sockaddr_storage *sa )
{
- char *hostname;
-#ifdef HAVE_GETADDRINFO
- struct addrinfo *res, hints;
+ ADDRINFOW *res, hints;
int ret;
-#else
- struct hostent *he;
- struct sockaddr_in *sin = (struct sockaddr_in *)sa;
-#endif
-
- if (!(hostname = strdupWA( hostnameW ))) return ERROR_OUTOFMEMORY;
-#ifdef HAVE_GETADDRINFO
- memset( &hints, 0, sizeof(struct addrinfo) );
+ memset( &hints, 0, sizeof(hints) );
/* Prefer IPv4 to IPv6 addresses, since some web servers do not listen on
* their IPv6 addresses even though they have IPv6 addresses in the DNS.
*/
hints.ai_family = AF_INET;
- ret = getaddrinfo( hostname, NULL, &hints, &res );
+ ret = GetAddrInfoW( name, NULL, &hints, &res );
if (ret != 0)
{
- TRACE("failed to get IPv4 address of %s (%s), retrying with IPv6\n", debugstr_w(hostnameW), gai_strerror(ret));
+ TRACE("failed to get IPv4 address of %s, retrying with IPv6\n", debugstr_w(name));
hints.ai_family = AF_INET6;
- ret = getaddrinfo( hostname, NULL, &hints, &res );
+ ret = GetAddrInfoW( name, NULL, &hints, &res );
if (ret != 0)
{
- TRACE("failed to get address of %s (%s)\n", debugstr_w(hostnameW), gai_strerror(ret));
- heap_free( hostname );
+ TRACE("failed to get address of %s\n", debugstr_w(name));
return ERROR_WINHTTP_NAME_NOT_RESOLVED;
}
}
- heap_free( hostname );
memcpy( sa, res->ai_addr, res->ai_addrlen );
- /* Copy port */
switch (res->ai_family)
{
case AF_INET:
break;
}
- freeaddrinfo( res );
+ FreeAddrInfoW( res );
return ERROR_SUCCESS;
-#else
- EnterCriticalSection( &cs_gethostbyname );
-
- he = gethostbyname( hostname );
- heap_free( hostname );
- if (!he)
- {
- TRACE("failed to get address of %s (%d)\n", debugstr_w(hostnameW), h_errno);
- LeaveCriticalSection( &cs_gethostbyname );
- return ERROR_WINHTTP_NAME_NOT_RESOLVED;
- }
- memset( sa, 0, sizeof(struct sockaddr_in) );
- memcpy( &sin->sin_addr, he->h_addr, he->h_length );
- sin->sin_family = he->h_addrtype;
- sin->sin_port = htons( port );
-
- LeaveCriticalSection( &cs_gethostbyname );
- return ERROR_SUCCESS;
-#endif
}
+#ifdef __REACTOS__
+
struct resolve_args
{
const WCHAR *hostname;
if (ret)
{
- set_last_error( ret );
+ SetLastError( ret );
return FALSE;
}
return TRUE;
}
-const void *netconn_get_certificate( netconn_t *conn )
+#else /* __REACTOS__ */
+
+struct async_resolve
+{
+ const WCHAR *hostname;
+ INTERNET_PORT port;
+ struct sockaddr_storage *addr;
+ DWORD result;
+ HANDLE done;
+};
+
+static void CALLBACK resolve_proc( TP_CALLBACK_INSTANCE *instance, void *ctx )
+{
+ struct async_resolve *async = ctx;
+ async->result = resolve_hostname( async->hostname, async->port, async->addr );
+ SetEvent( async->done );
+}
+
+BOOL netconn_resolve( WCHAR *hostname, INTERNET_PORT port, struct sockaddr_storage *addr, int timeout )
+{
+ DWORD ret;
+
+ if (!timeout) ret = resolve_hostname( hostname, port, addr );
+ else
+ {
+ struct async_resolve async;
+
+ async.hostname = hostname;
+ async.port = port;
+ async.addr = addr;
+ if (!(async.done = CreateEventW( NULL, FALSE, FALSE, NULL ))) return FALSE;
+ if (!TrySubmitThreadpoolCallback( resolve_proc, &async, NULL ))
+ {
+ CloseHandle( async.done );
+ return FALSE;
+ }
+ if (WaitForSingleObject( async.done, timeout ) != WAIT_OBJECT_0) ret = ERROR_WINHTTP_TIMEOUT;
+ else ret = async.result;
+ CloseHandle( async.done );
+ }
+
+ if (ret)
+ {
+ SetLastError( ret );
+ return FALSE;
+ }
+ return TRUE;
+}
+
+#endif /* __REACTOS__ */
+
+const void *netconn_get_certificate( struct netconn *conn )
{
const CERT_CONTEXT *ret;
SECURITY_STATUS res;
return res == SEC_E_OK ? ret : NULL;
}
-int netconn_get_cipher_strength( netconn_t *conn )
+int netconn_get_cipher_strength( struct netconn *conn )
{
SecPkgContext_ConnectionInfo conn_info;
SECURITY_STATUS res;
projects / reactos.git / blobdiff