-/*
- * Copyright (C) 1995-2006, Index Data ApS
+/* This file is part of the YAZ toolkit.
+ * Copyright (C) 1995-2008 Index Data
* See the file LICENSE for details.
- *
- * $Id: tcpip.c,v 1.29 2006-09-06 16:03:52 adam Exp $
*/
/**
* \file tcpip.c
#endif
#ifdef WIN32
+
+/* VS 2003 or later has getaddrinfo; older versions do not */
#include <winsock2.h>
+#if _MSC_VER >= 1300
#include <ws2tcpip.h>
#define HAVE_GETADDRINFO 1
#else
+#define HAVE_GETADDRINFO 0
+#endif
+
+#else
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
-#if HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
#if HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
+#if HAVE_GNUTLS_H
+#include <gnutls/openssl.h>
+#include <gnutls/x509.h>
+#define ENABLE_SSL 1
+#endif
+
#if HAVE_OPENSSL_SSL_H
#include <openssl/ssl.h>
#include <openssl/err.h>
+#define ENABLE_SSL 1
#endif
#include <yaz/comstack.h>
static int tcpip_close(COMSTACK h);
static int tcpip_put(COMSTACK h, char *buf, int size);
static int tcpip_get(COMSTACK h, char **buf, int *bufsize);
+static int tcpip_put_connect(COMSTACK h, char *buf, int size);
+static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize);
static int tcpip_connect(COMSTACK h, void *address);
static int tcpip_more(COMSTACK h);
static int tcpip_rcvconnect(COMSTACK h);
void *cd);
static int tcpip_set_blocking(COMSTACK p, int blocking);
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
static int ssl_get(COMSTACK h, char **buf, int *bufsize);
static int ssl_put(COMSTACK h, char *buf, int size);
#endif
int written; /* -1 if we aren't writing */
int towrite; /* to verify against user input */
- int (*complete)(const unsigned char *buf, int len); /* length/comple. */
+ int (*complete)(const char *buf, int len); /* length/complete. */
#if HAVE_GETADDRINFO
struct addrinfo *ai;
#else
struct sockaddr_in addr; /* returned by cs_straddr */
#endif
char buf[128]; /* returned by cs_addrstr */
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
SSL_CTX *ctx; /* current CTX. */
SSL_CTX *ctx_alloc; /* If =ctx it is owned by CS. If 0 it is not owned */
SSL *ssl;
char cert_fname[256];
#endif
+ char *connect_request_buf;
+ int connect_request_len;
+ char *connect_response_buf;
+ int connect_response_len;
} tcpip_state;
#ifdef WIN32
-static int tcpip_init (void)
+static int tcpip_init(void)
{
static int initialized = 0;
if (!initialized)
return 1;
}
#else
-static int tcpip_init (void)
+static int tcpip_init(void)
{
return 1;
}
COMSTACK p;
tcpip_state *sp;
- if (!tcpip_init ())
+ if (!tcpip_init())
return 0;
if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack))))
return 0;
p->stackerr = 0;
p->user = 0;
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
sp->ctx = sp->ctx_alloc = 0;
sp->ssl = 0;
strcpy(sp->cert_fname, "yaz.pem");
else
sp->complete = cs_complete_auto;
+ sp->connect_request_buf = 0;
+ sp->connect_request_len = 0;
+ sp->connect_response_buf = 0;
+ sp->connect_response_len = 0;
+
p->timeout = COMSTACK_DEFAULT_TIMEOUT;
TRC(fprintf(stderr, "Created new TCPIP comstack\n"));
return p;
}
-#if HAVE_OPENSSL_SSL_H
+COMSTACK yaz_tcpip_create(int s, int flags, int protocol,
+ const char *connect_host)
+{
+ COMSTACK p = tcpip_type(s, flags, protocol, 0);
+ if (!p)
+ return 0;
+ if (connect_host)
+ {
+ tcpip_state *sp = (tcpip_state *) p->cprivate;
+ sp->connect_request_buf = (char *) xmalloc(strlen(connect_host) + 30);
+ sprintf(sp->connect_request_buf, "CONNECT %s HTTP/1.0\r\n\r\n",
+ connect_host);
+ sp->connect_request_len = strlen(sp->connect_request_buf);
+ p->f_put = tcpip_put_connect;
+ p->f_get = tcpip_get_connect;
+ sp->complete = cs_complete_auto_head; /* only want HTTP header */
+ }
+ return p;
+}
+
COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
{
+#if !ENABLE_SSL
+ return 0;
+#else
tcpip_state *sp;
COMSTACK p;
- p = tcpip_type (s, flags, protocol, 0);
+ p = tcpip_type(s, flags, protocol, 0);
if (!p)
return 0;
p->f_get = ssl_get;
/* note: we don't handle already opened socket in SSL mode - yet */
return p;
+#endif
+}
+
+#if ENABLE_SSL
+static int ssl_check_error(COMSTACK h, tcpip_state *sp, int res)
+{
+#if HAVE_OPENSSL_SSL_H
+ int err = SSL_get_error(sp->ssl, res);
+ TRC(fprintf(stderr, "got err=%d\n", err));
+ if (err == SSL_ERROR_WANT_READ)
+ {
+ TRC(fprintf(stderr, " -> SSL_ERROR_WANT_READ\n"));
+ h->io_pending = CS_WANT_READ;
+ return 1;
+ }
+ if (err == SSL_ERROR_WANT_WRITE)
+ {
+ TRC(fprintf(stderr, " -> SSL_ERROR_WANT_WRITE\n"));
+ h->io_pending = CS_WANT_WRITE;
+ return 1;
+ }
+#else
+ int tls_error = sp->ssl->last_error;
+ TRC(fprintf(stderr, "ssl_check_error error=%d fatal=%d msg=%s\n",
+ sp->ssl->last_error,
+ gnutls_error_is_fatal(tls_error),
+ gnutls_strerror(tls_error)));
+ if (tls_error == GNUTLS_E_AGAIN || tls_error == GNUTLS_E_INTERRUPTED)
+ {
+ int dir = gnutls_record_get_direction(sp->ssl->gnutls_state);
+ TRC(fprintf(stderr, " -> incomplete dir=%d\n", dir));
+ h->io_pending = dir ? CS_WANT_WRITE : CS_WANT_READ;
+ return 1;
+ }
+#endif
+ h->cerrno = CSERRORSSL;
+ return 0;
}
#endif
const char *port = "210";
if (h->protocol == PROTO_HTTP)
port = "80";
- if (!tcpip_init ())
+ if (!tcpip_init())
return 0;
if (sp->ai)
sp->ai = tcpip_getaddrinfo(str, port);
if (sp->ai && h->state == CS_ST_UNBND)
{
- int s;
+ int s = -1;
struct addrinfo *ai = sp->ai;
- s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
- if (s < 0)
+ for (; ai; ai = ai->ai_next)
+ {
+ s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+ if (s != -1)
+ break;
+ }
+ if (s == -1)
return 0;
h->iofile = s;
if (h->protocol == PROTO_HTTP)
port = 80;
- if (!tcpip_init ())
+ if (!tcpip_init())
return 0;
- if (!tcpip_strtoaddr_ex (str, &sp->addr, port))
+ if (!tcpip_strtoaddr_ex(str, &sp->addr, port))
return 0;
if (h->state == CS_ST_UNBND)
{
{
tcpip_state *sp = (tcpip_state *)h->cprivate;
- return sp->altlen && (*sp->complete)((unsigned char *) sp->altbuf,
- sp->altlen);
+ return sp->altlen && (*sp->complete)(sp->altbuf, sp->altlen);
}
/*
* This gives the connect a chance to negotiate with the other side
* (see 'man tcp')
*/
- if ( getsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, &rbufsize ) < 0 )
+ if (getsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, &rbufsize ) < 0 )
{
h->cerrno = CSYSERR;
return -1;
TRC(fprintf( stderr, "Current Size of TCP Receive Buffer= %d\n",
recbuflen ));
recbuflen *= 10; /* lets be optimistic */
- if ( setsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, rbufsize ) < 0 )
+ if (setsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, rbufsize ) < 0 )
{
h->cerrno = CSYSERR;
return -1;
}
- if ( getsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, &rbufsize ) )
+ if (getsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, &rbufsize ) )
{
h->cerrno = CSYSERR;
return -1;
}
- TRC(fprintf( stderr, "New Size of TCP Receive Buffer = %d\n",
- recbuflen ));
+ TRC(fprintf(stderr, "New Size of TCP Receive Buffer = %d\n",
+ recbuflen ));
#endif
#if HAVE_GETADDRINFO
h->event = CS_CONNECT;
h->state = CS_ST_CONNECTING;
- return tcpip_rcvconnect (h);
+ return tcpip_rcvconnect(h);
}
/*
*/
int tcpip_rcvconnect(COMSTACK h)
{
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
tcpip_state *sp = (tcpip_state *)h->cprivate;
#endif
TRC(fprintf(stderr, "tcpip_rcvconnect\n"));
h->cerrno = CSOUTSTATE;
return -1;
}
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
if (h->type == ssl_type && !sp->ctx)
{
+ SSL_library_init();
SSL_load_error_strings();
- SSLeay_add_all_algorithms();
- sp->ctx = sp->ctx_alloc = SSL_CTX_new (SSLv23_method());
+ sp->ctx = sp->ctx_alloc = SSL_CTX_new(SSLv23_client_method());
if (!sp->ctx)
{
h->cerrno = CSERRORSSL;
if (!sp->ssl)
{
- sp->ssl = SSL_new (sp->ctx);
- SSL_set_fd (sp->ssl, h->iofile);
+ sp->ssl = SSL_new(sp->ctx);
+ SSL_set_fd(sp->ssl, h->iofile);
}
- res = SSL_connect (sp->ssl);
+ res = SSL_connect(sp->ssl);
if (res <= 0)
{
- int err = SSL_get_error(sp->ssl, res);
- if (err == SSL_ERROR_WANT_READ)
- {
- h->io_pending = CS_WANT_READ;
- return 1;
- }
- if (err == SSL_ERROR_WANT_WRITE)
- {
- h->io_pending = CS_WANT_WRITE;
+ if (ssl_check_error(h, sp, res))
return 1;
- }
- h->cerrno = CSERRORSSL;
return -1;
}
}
#define CERTF "ztest.pem"
#define KEYF "ztest.pem"
-static void tcpip_setsockopt (int fd)
+static void tcpip_setsockopt(int fd)
{
#if 0
int len = 4096;
#ifdef WIN32
BOOL one = 1;
#else
- unsigned long one = 1;
+ int one = 1;
#endif
#if HAVE_GETADDRINFO
}
#endif
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
if (h->type == ssl_type && !sp->ctx)
{
+ SSL_library_init();
SSL_load_error_strings();
- SSLeay_add_all_algorithms();
- sp->ctx = sp->ctx_alloc = SSL_CTX_new (SSLv23_method());
+ sp->ctx = sp->ctx_alloc = SSL_CTX_new(SSLv23_server_method());
if (!sp->ctx)
{
h->cerrno = CSERRORSSL;
if (sp->ctx_alloc)
{
int res;
- res = SSL_CTX_use_certificate_chain_file(sp->ctx, sp->cert_fname);
+ res = SSL_CTX_use_certificate_file(sp->ctx, sp->cert_fname,
+ SSL_FILETYPE_PEM);
if (res <= 0)
{
+#if HAVE_OPENSSL_SSL_H
ERR_print_errors_fp(stderr);
- exit (2);
+#else
+ fprintf(stderr, " SSL_CTX_use_certificate_file %s failed\n",
+ sp->cert_fname);
+#endif
+ exit(2);
}
- res = SSL_CTX_use_PrivateKey_file (sp->ctx, sp->cert_fname,
+ res = SSL_CTX_use_PrivateKey_file(sp->ctx, sp->cert_fname,
SSL_FILETYPE_PEM);
if (res <= 0)
{
+#if HAVE_OPENSSL_SSL_H
ERR_print_errors_fp(stderr);
- exit (3);
+#else
+ fprintf(stderr, " SSL_CTX_use_certificate_file %s failed\n",
+ sp->cert_fname);
+#endif
+ exit(3);
}
- res = SSL_CTX_check_private_key (sp->ctx);
+#if HAVE_OPENSSL_SSL_H
+ res = SSL_CTX_check_private_key(sp->ctx);
if (res <= 0)
{
ERR_print_errors_fp(stderr);
exit(5);
}
+#endif
}
- TRC (fprintf (stderr, "ssl_bind\n"));
+ TRC(fprintf(stderr, "ssl_bind\n"));
}
else
{
- TRC (fprintf (stderr, "tcpip_bind\n"));
+ TRC(fprintf(stderr, "tcpip_bind\n"));
}
#else
- TRC (fprintf (stderr, "tcpip_bind\n"));
+ TRC(fprintf(stderr, "tcpip_bind\n"));
#endif
#ifndef WIN32
if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, (char*)
)
h->cerrno = CSNODATA;
else
+ {
+#ifdef WIN32
+ shutdown(h->iofile, SD_RECEIVE);
+#else
+ shutdown(h->iofile, SHUT_RD);
+#endif
+ listen(h->iofile, SOMAXCONN);
h->cerrno = CSYSERR;
+ }
return -1;
}
if (addrlen && (size_t) (*addrlen) >= sizeof(struct sockaddr_in))
return -1;
}
h->state = CS_ST_INCON;
- tcpip_setsockopt (h->newfd);
+ tcpip_setsockopt(h->newfd);
return 0;
}
#endif
h->newfd = -1;
}
- xfree (cnew);
- xfree (state);
+ xfree(cnew);
+ xfree(state);
return 0;
}
h->newfd = -1;
cnew->state = CS_ST_ACCEPT;
h->state = CS_ST_IDLE;
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
state->ctx = st->ctx;
state->ctx_alloc = 0;
state->ssl = st->ssl;
if (state->ctx)
{
- state->ssl = SSL_new (state->ctx);
- SSL_set_fd (state->ssl, cnew->iofile);
+ state->ssl = SSL_new(state->ctx);
+ SSL_set_fd(state->ssl, cnew->iofile);
}
#endif
+ state->connect_request_buf = 0;
+ state->connect_response_buf = 0;
h = cnew;
}
if (h->state == CS_ST_ACCEPT)
{
-#if HAVE_OPENSSL_SSL_H
+
+#if ENABLE_SSL
tcpip_state *state = (tcpip_state *)h->cprivate;
if (state->ctx)
{
- int res = SSL_accept (state->ssl);
- TRC(fprintf(stderr, "SSL_accept\n"));
+ int res;
+ errno = 0;
+ res = SSL_accept(state->ssl);
+ TRC(fprintf(stderr, "SSL_accept res=%d\n", res));
if (res <= 0)
{
- int err = SSL_get_error(state->ssl, res);
- if (err == SSL_ERROR_WANT_READ)
+ if (ssl_check_error(h, state, res))
{
- h->io_pending = CS_WANT_READ;
return h;
}
- if (err == SSL_ERROR_WANT_WRITE)
- {
- h->io_pending = CS_WANT_WRITE;
- return h;
- }
- cs_close (h);
+ cs_close(h);
return 0;
}
+ TRC(fprintf(stderr, "SSL_accept complete\n"));
}
#endif
}
sp->altsize = tmpi;
}
h->io_pending = 0;
- while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread)))
+ while (!(berlen = (*sp->complete)(*buf, hasread)))
{
if (!*bufsize)
{
return -1;
}
}
- TRC (fprintf (stderr, " Out of read loop with hasread=%d, berlen=%d\n",
- hasread, berlen));
+ TRC(fprintf(stderr, " Out of read loop with hasread=%d, berlen=%d\n",
+ hasread, berlen));
/* move surplus buffer (or everything if we didn't get a BER rec.) */
if (hasread > berlen)
{
}
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
/*
* Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
* 0=connection closed.
sp->altsize = tmpi;
}
h->io_pending = 0;
- while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread)))
+ while (!(berlen = (*sp->complete)(*buf, hasread)))
{
if (!*bufsize)
{
else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
return -1;
- res = SSL_read (sp->ssl, *buf + hasread, CS_TCPIP_BUFCHUNK);
+ res = SSL_read(sp->ssl, *buf + hasread, CS_TCPIP_BUFCHUNK);
TRC(fprintf(stderr, " SSL_read res=%d, hasread=%d\n", res, hasread));
if (res <= 0)
{
- int ssl_err = SSL_get_error(sp->ssl, res);
- if (ssl_err == SSL_ERROR_WANT_READ)
- {
- h->io_pending = CS_WANT_READ;
+ if (ssl_check_error(h, sp, res))
break;
- }
- if (ssl_err == SSL_ERROR_WANT_WRITE)
- {
- h->io_pending = CS_WANT_WRITE;
- break;
- }
- if (res == 0)
- return 0;
- h->cerrno = CSERRORSSL;
return -1;
}
hasread += res;
}
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
/*
* Returns 1, 0 or -1
* In nonblocking mode, you must call again with same buffer while
}
while (state->towrite > state->written)
{
- res = SSL_write (state->ssl, buf + state->written,
- size - state->written);
+ res = SSL_write(state->ssl, buf + state->written,
+ size - state->written);
if (res <= 0)
{
- int ssl_err = SSL_get_error(state->ssl, res);
- if (ssl_err == SSL_ERROR_WANT_READ)
- {
- h->io_pending = CS_WANT_READ;
- return 1;
- }
- if (ssl_err == SSL_ERROR_WANT_WRITE)
- {
- h->io_pending = CS_WANT_WRITE;
+ if (ssl_check_error(h, state, res))
return 1;
- }
- h->cerrno = CSERRORSSL;
return -1;
}
state->written += res;
TRC(fprintf(stderr, "tcpip_close\n"));
if (h->iofile != -1)
{
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
if (sp->ssl)
{
- SSL_shutdown (sp->ssl);
+ SSL_shutdown(sp->ssl);
}
#endif
#ifdef WIN32
}
if (sp->altbuf)
xfree(sp->altbuf);
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
if (sp->ssl)
{
- TRC (fprintf(stderr, "SSL_free\n"));
- SSL_free (sp->ssl);
+ TRC(fprintf(stderr, "SSL_free\n"));
+ SSL_free(sp->ssl);
}
sp->ssl = 0;
if (sp->ctx_alloc)
- SSL_CTX_free (sp->ctx_alloc);
+ SSL_CTX_free(sp->ctx_alloc);
#endif
#if HAVE_GETADDRINFO
if (sp->ai)
freeaddrinfo(sp->ai);
#endif
+ xfree(sp->connect_request_buf);
+ xfree(sp->connect_response_buf);
xfree(sp);
xfree(h);
return 0;
sprintf(buf, "http:%s", r);
else
sprintf(buf, "tcp:%s", r);
-#if HAVE_OPENSSL_SSL_H
+#if ENABLE_SSL
if (sp->ctx)
{
if (h->protocol == PROTO_HTTP)
return 1;
}
+void cs_print_session_info(COMSTACK cs)
+{
+#if HAVE_GNUTLS_H
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ SSL *ssl = (SSL *) sp->ssl;
+ if (ssl)
+ {
+ gnutls_session_t session = ssl->gnutls_state;
+ if (gnutls_certificate_type_get(session) != GNUTLS_CRT_X509)
+ return;
+ printf("X509 certificate\n");
+ }
+#endif
#if HAVE_OPENSSL_SSL_H
-int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ SSL *ssl = (SSL *) sp->ssl;
+ if (ssl)
+ {
+ X509 *server_cert = SSL_get_peer_certificate(ssl);
+
+ if (server_cert)
+ {
+ char *pem_buf;
+ int pem_len;
+ BIO *bio = BIO_new(BIO_s_mem());
+
+ /* get PEM buffer in memory */
+ PEM_write_bio_X509(bio, server_cert);
+ pem_len = BIO_get_mem_data(bio, &pem_buf);
+ fwrite(pem_buf, pem_len, 1, stdout);
+
+ /* print all info on screen .. */
+ X509_print_fp(stdout, server_cert);
+ BIO_free(bio);
+
+ X509_free(server_cert);
+ }
+ }
+#endif
+}
+
+void *cs_get_ssl(COMSTACK cs)
{
+#if HAVE_OPENSSL_SSL_H
struct tcpip_state *sp;
if (!cs || cs->type != ssl_type)
return 0;
sp = (struct tcpip_state *) cs->cprivate;
- if (sp->ctx_alloc)
- return 0;
- sp->ctx = (SSL_CTX *) ctx;
- return 1;
+ return sp->ssl;
+#else
+ return 0;
+#endif
}
-void *cs_get_ssl(COMSTACK cs)
+#if ENABLE_SSL
+int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
{
struct tcpip_state *sp;
if (!cs || cs->type != ssl_type)
return 0;
sp = (struct tcpip_state *) cs->cprivate;
- return sp->ssl;
+ if (sp->ctx_alloc)
+ return 0;
+ sp->ctx = (SSL_CTX *) ctx;
+ return 1;
}
int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
SSL *ssl = (SSL *) cs_get_ssl(cs);
if (ssl)
{
- X509 *server_cert = SSL_get_peer_certificate (ssl);
+#if HAVE_OPENSSL_SSL_H
+ X509 *server_cert = SSL_get_peer_certificate(ssl);
if (server_cert)
{
BIO *bio = BIO_new(BIO_s_mem());
BIO_free(bio);
return 1;
}
+#endif
}
return 0;
}
return 0;
}
-void *cs_get_ssl(COMSTACK cs)
-{
- return 0;
-}
-
int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
{
return 0;
}
#endif
+
+static int tcpip_put_connect(COMSTACK h, char *buf, int size)
+{
+ struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
+
+ int r = tcpip_put(h, state->connect_request_buf,
+ state->connect_request_len);
+ if (r == 0)
+ {
+ /* it's sent */
+ h->f_put = tcpip_put; /* switch to normal tcpip put */
+ r = tcpip_put(h, buf, size);
+ }
+ return r;
+}
+
+static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize)
+{
+ struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
+ int r;
+
+ r = tcpip_get(h, &state->connect_response_buf,
+ &state->connect_response_len);
+ if (r < 1)
+ return r;
+ /* got the connect response completely */
+ state->complete = cs_complete_auto; /* switch to normal tcpip get */
+ h->f_get = tcpip_get;
+ return tcpip_get(h, buf, bufsize);
+}
+
+
/*
* Local variables:
* c-basic-offset: 4