src/tcpip.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2008 Index Data
   3  * See the file LICENSE for details.
   4  */
   5 /**
   6  * \file tcpip.c
   7  * \brief Implements TCP/IP + SSL COMSTACK.
   8  */
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <errno.h>
  14 #include <fcntl.h>
  15 #include <signal.h>
  16 #if HAVE_SYS_TYPES_H
  17 #include <sys/types.h>
  18 #endif
  19 #if HAVE_SYS_TIME_H
  20 #include <sys/time.h>
  21 #endif
  22 #if HAVE_UNISTD_H
  23 #include <unistd.h>
  24 #endif
  25
  26 #ifdef WIN32
  27
  28 /* VS 2003 or later has getaddrinfo; older versions do not */
  29 #include <winsock2.h>
  30 #if _MSC_VER >= 1300
  31 #include <ws2tcpip.h>
  32 #define HAVE_GETADDRINFO 1
  33 #else
  34 #define HAVE_GETADDRINFO 0
  35 #endif
  36
  37 #else
  38 #include <netinet/in.h>
  39 #include <netdb.h>
  40 #include <arpa/inet.h>
  41 #include <netinet/tcp.h>
  42 #endif
  43
  44 #if HAVE_SYS_SOCKET_H
  45 #include <sys/socket.h>
  46 #endif
  47 #if HAVE_SYS_WAIT_H
  48 #include <sys/wait.h>
  49 #endif
  50
  51 #if HAVE_OPENSSL_SSL_H
  52 #include <openssl/ssl.h>
  53 #include <openssl/err.h>
  54 #endif
  55
  56 #include <yaz/comstack.h>
  57 #include <yaz/tcpip.h>
  58 #include <yaz/nmem.h>
  59
  60 static int tcpip_close(COMSTACK h);
  61 static int tcpip_put(COMSTACK h, char *buf, int size);
  62 static int tcpip_get(COMSTACK h, char **buf, int *bufsize);
  63 static int tcpip_put_connect(COMSTACK h, char *buf, int size);
  64 static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize);
  65 static int tcpip_connect(COMSTACK h, void *address);
  66 static int tcpip_more(COMSTACK h);
  67 static int tcpip_rcvconnect(COMSTACK h);
  68 static int tcpip_bind(COMSTACK h, void *address, int mode);
  69 static int tcpip_listen(COMSTACK h, char *raddr, int *addrlen,
  70                  int (*check_ip)(void *cd, const char *a, int len, int type),
  71                  void *cd);
  72 static int tcpip_set_blocking(COMSTACK p, int blocking);
  73
  74 #if HAVE_OPENSSL_SSL_H
  75 static int ssl_get(COMSTACK h, char **buf, int *bufsize);
  76 static int ssl_put(COMSTACK h, char *buf, int size);
  77 #endif
  78
  79 static COMSTACK tcpip_accept(COMSTACK h);
  80 static char *tcpip_addrstr(COMSTACK h);
  81 static void *tcpip_straddr(COMSTACK h, const char *str);
  82
  83 #if 0
  84 #define TRC(x) x
  85 #else
  86 #define TRC(X)
  87 #endif
  88
  89 #ifndef YAZ_SOCKLEN_T
  90 #define YAZ_SOCKLEN_T int
  91 #endif
  92
  93 /* this state is used for both SSL and straight TCP/IP */
  94 typedef struct tcpip_state
  95 {
  96     char *altbuf; /* alternate buffer for surplus data */
  97     int altsize;  /* size as xmalloced */
  98     int altlen;   /* length of data or 0 if none */
  99
 100     int written;  /* -1 if we aren't writing */
 101     int towrite;  /* to verify against user input */
 102     int (*complete)(const char *buf, int len); /* length/complete. */
 103 #if HAVE_GETADDRINFO
 104     struct addrinfo *ai;
 105 #else
 106     struct sockaddr_in addr;  /* returned by cs_straddr */
 107 #endif
 108     char buf[128]; /* returned by cs_addrstr */
 109 #if HAVE_OPENSSL_SSL_H
 110     SSL_CTX *ctx;       /* current CTX. */
 111     SSL_CTX *ctx_alloc; /* If =ctx it is owned by CS. If 0 it is not owned */
 112     SSL *ssl;
 113     char cert_fname[256];
 114 #endif
 115     char *connect_request_buf;
 116     int connect_request_len;
 117     char *connect_response_buf;
 118     int connect_response_len;
 119 } tcpip_state;
 120
 121 #ifdef WIN32
 122 static int tcpip_init (void)
 123 {
 124     static int initialized = 0;
 125     if (!initialized)
 126     {
 127         WORD requested;
 128         WSADATA wd;
 129
 130         requested = MAKEWORD(1, 1);
 131         if (WSAStartup(requested, &wd))
 132             return 0;
 133         initialized = 1;
 134     }
 135     return 1;
 136 }
 137 #else
 138 static int tcpip_init (void)
 139 {
 140     return 1;
 141 }
 142 #endif
 143
 144 /*
 145  * This function is always called through the cs_create() macro.
 146  * s >= 0: socket has already been established for us.
 147  */
 148 COMSTACK tcpip_type(int s, int flags, int protocol, void *vp)
 149 {
 150     COMSTACK p;
 151     tcpip_state *sp;
 152
 153     if (!tcpip_init ())
 154         return 0;
 155     if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack))))
 156         return 0;
 157     if (!(sp = (struct tcpip_state *)(p->cprivate =
 158                                          xmalloc(sizeof(tcpip_state)))))
 159         return 0;
 160
 161     p->flags = flags;
 162
 163     p->io_pending = 0;
 164     p->iofile = s;
 165     p->type = tcpip_type;
 166     p->protocol = (enum oid_proto) protocol;
 167
 168     p->f_connect = tcpip_connect;
 169     p->f_rcvconnect = tcpip_rcvconnect;
 170     p->f_get = tcpip_get;
 171     p->f_put = tcpip_put;
 172     p->f_close = tcpip_close;
 173     p->f_more = tcpip_more;
 174     p->f_bind = tcpip_bind;
 175     p->f_listen = tcpip_listen;
 176     p->f_accept = tcpip_accept;
 177     p->f_addrstr = tcpip_addrstr;
 178     p->f_straddr = tcpip_straddr;
 179     p->f_set_blocking = tcpip_set_blocking;
 180     p->max_recv_bytes = 5000000;
 181
 182     p->state = s < 0 ? CS_ST_UNBND : CS_ST_IDLE; /* state of line */
 183     p->event = CS_NONE;
 184     p->cerrno = 0;
 185     p->stackerr = 0;
 186     p->user = 0;
 187
 188 #if HAVE_OPENSSL_SSL_H
 189     sp->ctx = sp->ctx_alloc = 0;
 190     sp->ssl = 0;
 191     strcpy(sp->cert_fname, "yaz.pem");
 192 #endif
 193
 194 #if HAVE_GETADDRINFO
 195     sp->ai = 0;
 196 #endif
 197     sp->altbuf = 0;
 198     sp->altsize = sp->altlen = 0;
 199     sp->towrite = sp->written = -1;
 200     if (protocol == PROTO_WAIS)
 201         sp->complete = completeWAIS;
 202     else
 203         sp->complete = cs_complete_auto;
 204
 205     sp->connect_request_buf = 0;
 206     sp->connect_request_len = 0;
 207     sp->connect_response_buf = 0;
 208     sp->connect_response_len = 0;
 209
 210     p->timeout = COMSTACK_DEFAULT_TIMEOUT;
 211     TRC(fprintf(stderr, "Created new TCPIP comstack\n"));
 212
 213     return p;
 214 }
 215
 216 COMSTACK yaz_tcpip_create(int s, int flags, int protocol,
 217                           const char *connect_host)
 218 {
 219     COMSTACK p = tcpip_type(s, flags, protocol, 0);
 220     if (!p)
 221         return 0;
 222     if (connect_host)
 223     {
 224         tcpip_state *sp = (tcpip_state *) p->cprivate;
 225         sp->connect_request_buf = (char *) xmalloc(strlen(connect_host) + 30);
 226         sprintf(sp->connect_request_buf, "CONNECT %s HTTP/1.0\r\n\r\n",
 227                 connect_host);
 228         sp->connect_request_len = strlen(sp->connect_request_buf);
 229         p->f_put = tcpip_put_connect;
 230         p->f_get = tcpip_get_connect;
 231         sp->complete = cs_complete_auto_head; /* only want HTTP header */
 232     }
 233     return p;
 234 }
 235
 236
 237 #if HAVE_OPENSSL_SSL_H
 238
 239 COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
 240 {
 241     tcpip_state *sp;
 242     COMSTACK p;
 243
 244     p = tcpip_type (s, flags, protocol, 0);
 245     if (!p)
 246         return 0;
 247     p->f_get = ssl_get;
 248     p->f_put = ssl_put;
 249     p->type = ssl_type;
 250     sp = (tcpip_state *) p->cprivate;
 251
 252     sp->ctx = (SSL_CTX *) vp;  /* may be NULL */
 253
 254     /* note: we don't handle already opened socket in SSL mode - yet */
 255     return p;
 256 }
 257 #endif
 258
 259 #if HAVE_GETADDRINFO
 260 /* resolve using getaddrinfo */
 261 struct addrinfo *tcpip_getaddrinfo(const char *str, const char *port)
 262 {
 263     struct addrinfo hints, *res;
 264     int error;
 265     char host[512], *p;
 266
 267     hints.ai_flags = 0;
 268     hints.ai_family = AF_UNSPEC;
 269     hints.ai_socktype = SOCK_STREAM;
 270     hints.ai_protocol = 0;
 271     hints.ai_addrlen        = 0;
 272     hints.ai_addr           = NULL;
 273     hints.ai_canonname      = NULL;
 274     hints.ai_next           = NULL;
 275
 276     strncpy(host, str, sizeof(host)-1);
 277     host[sizeof(host)-1] = 0;
 278     if ((p = strchr(host, '/')))
 279         *p = 0;
 280     if ((p = strrchr(host, ':')))
 281     {
 282         *p = '\0';
 283         port = p+1;
 284     }
 285
 286     if (!strcmp("@", host))
 287     {
 288         hints.ai_flags = AI_PASSIVE;
 289         error = getaddrinfo(0, port, &hints, &res);
 290     }
 291     else
 292     {
 293         error = getaddrinfo(host, port, &hints, &res);
 294     }
 295     if (error)
 296         return 0;
 297     return res;
 298 }
 299
 300 #endif
 301 /* gethostbyname .. old systems */
 302 int tcpip_strtoaddr_ex(const char *str, struct sockaddr_in *add,
 303                        int default_port)
 304 {
 305     struct hostent *hp;
 306     char *p, buf[512];
 307     short int port = default_port;
 308 #ifdef WIN32
 309     unsigned long tmpadd;
 310 #else
 311     in_addr_t tmpadd;
 312 #endif
 313     TRC(fprintf(stderr, "tcpip_strtoaddress: %s\n", str ? str : "NULL"));
 314     add->sin_family = AF_INET;
 315     strncpy(buf, str, sizeof(buf)-1);
 316     buf[sizeof(buf)-1] = 0;
 317     if ((p = strchr(buf, '/')))
 318         *p = 0;
 319     if ((p = strrchr(buf, ':')))
 320     {
 321         *p = 0;
 322         port = atoi(p + 1);
 323     }
 324     add->sin_port = htons(port);
 325     if (!strcmp("@", buf))
 326     {
 327         add->sin_addr.s_addr = INADDR_ANY;
 328     }
 329     else if ((tmpadd = inet_addr(buf)) != -1)
 330     {
 331         memcpy(&add->sin_addr.s_addr, &tmpadd, sizeof(struct in_addr));
 332     }
 333     else if ((hp = gethostbyname(buf)))
 334     {
 335         memcpy(&add->sin_addr.s_addr, *hp->h_addr_list,
 336                sizeof(struct in_addr));
 337     }
 338     else
 339         return 0;
 340     return 1;
 341 }
 342
 343
 344 #if HAVE_GETADDRINFO
 345 void *tcpip_straddr(COMSTACK h, const char *str)
 346 {
 347     tcpip_state *sp = (tcpip_state *)h->cprivate;
 348     const char *port = "210";
 349     if (h->protocol == PROTO_HTTP)
 350         port = "80";
 351     if (!tcpip_init ())
 352         return 0;
 353
 354     if (sp->ai)
 355         freeaddrinfo(sp->ai);
 356     sp->ai = tcpip_getaddrinfo(str, port);
 357     if (sp->ai && h->state == CS_ST_UNBND)
 358     {
 359         int s = -1;
 360         struct addrinfo *ai = sp->ai;
 361         for (; ai; ai = ai->ai_next)
 362         {
 363             s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
 364             if (s != -1)
 365                 break;
 366         }
 367         if (s == -1)
 368             return 0;
 369         h->iofile = s;
 370
 371         if (!tcpip_set_blocking(h, h->flags))
 372             return 0;
 373     }
 374     return sp->ai;
 375 }
 376 #else
 377 void *tcpip_straddr(COMSTACK h, const char *str)
 378 {
 379     tcpip_state *sp = (tcpip_state *)h->cprivate;
 380     int port = 210;
 381     if (h->protocol == PROTO_HTTP)
 382         port = 80;
 383
 384     if (!tcpip_init ())
 385         return 0;
 386     if (!tcpip_strtoaddr_ex (str, &sp->addr, port))
 387         return 0;
 388     if (h->state == CS_ST_UNBND)
 389     {
 390         int s;
 391         s = socket(AF_INET, SOCK_STREAM, 0);
 392         if (s < 0)
 393             return 0;
 394         h->iofile = s;
 395
 396         if (!tcpip_set_blocking(h, h->flags))
 397             return 0;
 398     }
 399     return &sp->addr;
 400 }
 401 #endif
 402
 403 int tcpip_more(COMSTACK h)
 404 {
 405     tcpip_state *sp = (tcpip_state *)h->cprivate;
 406
 407     return sp->altlen && (*sp->complete)(sp->altbuf, sp->altlen);
 408 }
 409
 410 /*
 411  * connect(2) will block (sometimes) - nothing we can do short of doing
 412  * weird things like spawning subprocesses or threading or some weird junk
 413  * like that.
 414  */
 415 int tcpip_connect(COMSTACK h, void *address)
 416 {
 417 #if HAVE_GETADDRINFO
 418     tcpip_state *sp = (tcpip_state *)h->cprivate;
 419 #else
 420     struct sockaddr_in *add = (struct sockaddr_in *) address;
 421 #endif
 422     int r;
 423 #ifdef __sun__
 424     int recbuflen;
 425     YAZ_SOCKLEN_T rbufsize = sizeof(recbuflen);
 426 #endif
 427     TRC(fprintf(stderr, "tcpip_connect\n"));
 428     h->io_pending = 0;
 429     if (h->state != CS_ST_UNBND)
 430     {
 431         h->cerrno = CSOUTSTATE;
 432         return -1;
 433     }
 434 #if HAVE_GETADDRINFO
 435     if (sp->ai != (struct addrinfo *) address)
 436     {
 437         h->cerrno = CSOUTSTATE;
 438         return -1;
 439     }
 440 #endif
 441 #ifdef __sun__
 442     /* On Suns, you must set a bigger Receive Buffer BEFORE a call to connect
 443      * This gives the connect a chance to negotiate with the other side
 444      * (see 'man tcp')
 445      */
 446     if ( getsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, &rbufsize ) < 0 )
 447     {
 448         h->cerrno = CSYSERR;
 449         return -1;
 450     }
 451     TRC(fprintf( stderr, "Current Size of TCP Receive Buffer= %d\n",
 452                  recbuflen ));
 453     recbuflen *= 10; /* lets be optimistic */
 454     if ( setsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, rbufsize ) < 0 )
 455     {
 456         h->cerrno = CSYSERR;
 457         return -1;
 458     }
 459     if ( getsockopt(h->iofile, SOL_SOCKET, SO_RCVBUF, (void *)&recbuflen, &rbufsize ) )
 460     {
 461         h->cerrno = CSYSERR;
 462         return -1;
 463     }
 464     TRC(fprintf( stderr, "New Size of TCP Receive Buffer = %d\n",
 465                  recbuflen ));
 466 #endif
 467
 468 #if HAVE_GETADDRINFO
 469     r = connect(h->iofile, sp->ai->ai_addr, sp->ai->ai_addrlen);
 470     freeaddrinfo(sp->ai);
 471     sp->ai = 0;
 472 #else
 473     r = connect(h->iofile, (struct sockaddr *) add, sizeof(*add));
 474 #endif
 475     if (r < 0)
 476     {
 477 #ifdef WIN32
 478         if (WSAGetLastError() == WSAEWOULDBLOCK)
 479         {
 480             h->event = CS_CONNECT;
 481             h->state = CS_ST_CONNECTING;
 482             h->io_pending = CS_WANT_WRITE;
 483             return 1;
 484         }
 485 #else
 486         if (yaz_errno() == EINPROGRESS)
 487         {
 488             h->event = CS_CONNECT;
 489             h->state = CS_ST_CONNECTING;
 490             h->io_pending = CS_WANT_WRITE|CS_WANT_READ;
 491             return 1;
 492         }
 493 #endif
 494         h->cerrno = CSYSERR;
 495         return -1;
 496     }
 497     h->event = CS_CONNECT;
 498     h->state = CS_ST_CONNECTING;
 499
 500     return tcpip_rcvconnect (h);
 501 }
 502
 503 /*
 504  * nop
 505  */
 506 int tcpip_rcvconnect(COMSTACK h)
 507 {
 508 #if HAVE_OPENSSL_SSL_H
 509     tcpip_state *sp = (tcpip_state *)h->cprivate;
 510 #endif
 511     TRC(fprintf(stderr, "tcpip_rcvconnect\n"));
 512
 513     if (h->state == CS_ST_DATAXFER)
 514         return 0;
 515     if (h->state != CS_ST_CONNECTING)
 516     {
 517         h->cerrno = CSOUTSTATE;
 518         return -1;
 519     }
 520 #if HAVE_OPENSSL_SSL_H
 521     if (h->type == ssl_type && !sp->ctx)
 522     {
 523         SSL_library_init();
 524         SSL_load_error_strings();
 525
 526         sp->ctx = sp->ctx_alloc = SSL_CTX_new (SSLv23_method());
 527         if (!sp->ctx)
 528         {
 529             h->cerrno = CSERRORSSL;
 530             return -1;
 531         }
 532     }
 533     if (sp->ctx)
 534     {
 535         int res;
 536
 537         if (!sp->ssl)
 538         {
 539             sp->ssl = SSL_new (sp->ctx);
 540             SSL_set_fd (sp->ssl, h->iofile);
 541         }
 542         res = SSL_connect (sp->ssl);
 543         if (res <= 0)
 544         {
 545             int err = SSL_get_error(sp->ssl, res);
 546             if (err == SSL_ERROR_WANT_READ)
 547             {
 548                 h->io_pending = CS_WANT_READ;
 549                 return 1;
 550             }
 551             if (err == SSL_ERROR_WANT_WRITE)
 552             {
 553                 h->io_pending = CS_WANT_WRITE;
 554                 return 1;
 555             }
 556             h->cerrno = CSERRORSSL;
 557             return -1;
 558         }
 559     }
 560 #endif
 561     h->event = CS_DATA;
 562     h->state = CS_ST_DATAXFER;
 563     return 0;
 564 }
 565
 566 #define CERTF "ztest.pem"
 567 #define KEYF "ztest.pem"
 568
 569 static void tcpip_setsockopt (int fd)
 570 {
 571 #if 0
 572     int len = 4096;
 573     int set = 1;
 574
 575     if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&set, sizeof(int)))
 576     {
 577         yaz_log(LOG_WARN|LOG_ERRNO, "setsockopt TCP_NODELAY");
 578     }
 579     if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, sizeof(int)))
 580     {
 581         yaz_log(LOG_WARN|LOG_ERRNO, "setsockopt SNDBUF");
 582     }
 583     if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int)))
 584     {
 585         yaz_log(LOG_WARN|LOG_ERRNO, "setsockopt RCVBUF");
 586     }
 587 #endif
 588 }
 589
 590 static int tcpip_bind(COMSTACK h, void *address, int mode)
 591 {
 592     int r;
 593     tcpip_state *sp = (tcpip_state *)h->cprivate;
 594 #if HAVE_GETADDRINFO
 595 #else
 596     struct sockaddr *addr = (struct sockaddr *)address;
 597 #endif
 598 #ifdef WIN32
 599     BOOL one = 1;
 600 #else
 601     int one = 1;
 602 #endif
 603
 604 #if HAVE_GETADDRINFO
 605     if (sp->ai != (struct addrinfo *) address)
 606     {
 607         h->cerrno = CSOUTSTATE;
 608         return -1;
 609     }
 610 #endif
 611
 612 #if HAVE_OPENSSL_SSL_H
 613     if (h->type == ssl_type && !sp->ctx)
 614     {
 615         SSL_library_init();
 616         SSL_load_error_strings();
 617
 618         sp->ctx = sp->ctx_alloc = SSL_CTX_new (SSLv23_method());
 619         if (!sp->ctx)
 620         {
 621             h->cerrno = CSERRORSSL;
 622             return -1;
 623         }
 624     }
 625     if (sp->ctx)
 626     {
 627         if (sp->ctx_alloc)
 628         {
 629             int res;
 630             res = SSL_CTX_use_certificate_chain_file(sp->ctx, sp->cert_fname);
 631             if (res <= 0)
 632             {
 633                 ERR_print_errors_fp(stderr);
 634                 exit (2);
 635             }
 636             res = SSL_CTX_use_PrivateKey_file (sp->ctx, sp->cert_fname,
 637                                                SSL_FILETYPE_PEM);
 638             if (res <= 0)
 639             {
 640                 ERR_print_errors_fp(stderr);
 641                 exit (3);
 642             }
 643             res = SSL_CTX_check_private_key (sp->ctx);
 644             if (res <= 0)
 645             {
 646                 ERR_print_errors_fp(stderr);
 647                 exit(5);
 648             }
 649         }
 650         TRC (fprintf (stderr, "ssl_bind\n"));
 651     }
 652     else
 653     {
 654         TRC (fprintf (stderr, "tcpip_bind\n"));
 655     }
 656 #else
 657     TRC (fprintf (stderr, "tcpip_bind\n"));
 658 #endif
 659 #ifndef WIN32
 660     if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, (char*)
 661         &one, sizeof(one)) < 0)
 662     {
 663         h->cerrno = CSYSERR;
 664         return -1;
 665     }
 666 #endif
 667     tcpip_setsockopt(h->iofile);
 668 #if HAVE_GETADDRINFO
 669     r = bind(h->iofile, sp->ai->ai_addr, sp->ai->ai_addrlen);
 670     freeaddrinfo(sp->ai);
 671     sp->ai = 0;
 672 #else
 673     r = bind(h->iofile, addr, sizeof(struct sockaddr_in));
 674 #endif
 675     if (r)
 676     {
 677         h->cerrno = CSYSERR;
 678         return -1;
 679     }
 680     /* Allow a maximum-sized backlog of waiting-to-connect clients */
 681     if (mode == CS_SERVER && listen(h->iofile, SOMAXCONN) < 0)
 682     {
 683         h->cerrno = CSYSERR;
 684         return -1;
 685     }
 686     h->state = CS_ST_IDLE;
 687     h->event = CS_LISTEN;
 688     return 0;
 689 }
 690
 691 int tcpip_listen(COMSTACK h, char *raddr, int *addrlen,
 692                  int (*check_ip)(void *cd, const char *a, int len, int t),
 693                  void *cd)
 694 {
 695     struct sockaddr_in addr;
 696     YAZ_SOCKLEN_T len = sizeof(addr);
 697
 698     TRC(fprintf(stderr, "tcpip_listen pid=%d\n", getpid()));
 699     if (h->state != CS_ST_IDLE)
 700     {
 701         h->cerrno = CSOUTSTATE;
 702         return -1;
 703     }
 704     h->newfd = accept(h->iofile, (struct sockaddr*)&addr, &len);
 705     if (h->newfd < 0)
 706     {
 707         if (
 708 #ifdef WIN32
 709             WSAGetLastError() == WSAEWOULDBLOCK
 710 #else
 711             yaz_errno() == EWOULDBLOCK
 712 #ifdef EAGAIN
 713 #if EAGAIN != EWOULDBLOCK
 714             || yaz_errno() == EAGAIN
 715 #endif
 716 #endif
 717 #endif
 718             )
 719             h->cerrno = CSNODATA;
 720         else
 721         {
 722 #ifdef WIN32
 723             shutdown(h->iofile, SD_RECEIVE);
 724 #else
 725             shutdown(h->iofile, SHUT_RD);
 726 #endif
 727             listen(h->iofile, SOMAXCONN);
 728             h->cerrno = CSYSERR;
 729         }
 730         return -1;
 731     }
 732     if (addrlen && (size_t) (*addrlen) >= sizeof(struct sockaddr_in))
 733         memcpy(raddr, &addr, *addrlen = sizeof(struct sockaddr_in));
 734     else if (addrlen)
 735         *addrlen = 0;
 736     if (check_ip && (*check_ip)(cd, (const char *) &addr,
 737         sizeof(addr), AF_INET))
 738     {
 739         h->cerrno = CSDENY;
 740 #ifdef WIN32
 741         closesocket(h->newfd);
 742 #else
 743         close(h->newfd);
 744 #endif
 745         h->newfd = -1;
 746         return -1;
 747     }
 748     h->state = CS_ST_INCON;
 749     tcpip_setsockopt (h->newfd);
 750     return 0;
 751 }
 752
 753 COMSTACK tcpip_accept(COMSTACK h)
 754 {
 755     COMSTACK cnew;
 756     tcpip_state *state, *st = (tcpip_state *)h->cprivate;
 757 #ifdef WIN32
 758     unsigned long tru = 1;
 759 #endif
 760
 761     TRC(fprintf(stderr, "tcpip_accept\n"));
 762     if (h->state == CS_ST_INCON)
 763     {
 764         if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew))))
 765         {
 766             h->cerrno = CSYSERR;
 767 #ifdef WIN32
 768             closesocket(h->newfd);
 769 #else
 770             close(h->newfd);
 771 #endif
 772             h->newfd = -1;
 773             return 0;
 774         }
 775         memcpy(cnew, h, sizeof(*h));
 776         cnew->iofile = h->newfd;
 777         cnew->io_pending = 0;
 778         if (!(state = (tcpip_state *)
 779               (cnew->cprivate = xmalloc(sizeof(tcpip_state)))))
 780         {
 781             h->cerrno = CSYSERR;
 782             if (h->newfd != -1)
 783             {
 784 #ifdef WIN32
 785                 closesocket(h->newfd);
 786 #else
 787                 close(h->newfd);
 788 #endif
 789                 h->newfd = -1;
 790             }
 791             return 0;
 792         }
 793         if (!tcpip_set_blocking(cnew, cnew->flags))
 794         {
 795             h->cerrno = CSYSERR;
 796             if (h->newfd != -1)
 797             {
 798 #ifdef WIN32
 799                 closesocket(h->newfd);
 800 #else
 801                 close(h->newfd);
 802 #endif
 803                 h->newfd = -1;
 804             }
 805             xfree (cnew);
 806             xfree (state);
 807             return 0;
 808         }
 809         h->newfd = -1;
 810         state->altbuf = 0;
 811         state->altsize = state->altlen = 0;
 812         state->towrite = state->written = -1;
 813         state->complete = st->complete;
 814 #if HAVE_GETADDRINFO
 815         state->ai = 0;
 816 #endif
 817         cnew->state = CS_ST_ACCEPT;
 818         h->state = CS_ST_IDLE;
 819
 820 #if HAVE_OPENSSL_SSL_H
 821         state->ctx = st->ctx;
 822         state->ctx_alloc = 0;
 823         state->ssl = st->ssl;
 824         if (state->ctx)
 825         {
 826             state->ssl = SSL_new (state->ctx);
 827             SSL_set_fd (state->ssl, cnew->iofile);
 828         }
 829 #endif
 830         state->connect_request_buf = 0;
 831         state->connect_response_buf = 0;
 832         h = cnew;
 833     }
 834     if (h->state == CS_ST_ACCEPT)
 835     {
 836 #if HAVE_OPENSSL_SSL_H
 837         tcpip_state *state = (tcpip_state *)h->cprivate;
 838         if (state->ctx)
 839         {
 840             int res = SSL_accept (state->ssl);
 841             TRC(fprintf(stderr, "SSL_accept\n"));
 842             if (res <= 0)
 843             {
 844                 int err = SSL_get_error(state->ssl, res);
 845                 if (err == SSL_ERROR_WANT_READ)
 846                 {
 847                     h->io_pending = CS_WANT_READ;
 848                     return h;
 849                 }
 850                 if (err == SSL_ERROR_WANT_WRITE)
 851                 {
 852                     h->io_pending = CS_WANT_WRITE;
 853                     return h;
 854                 }
 855                 cs_close (h);
 856                 return 0;
 857             }
 858         }
 859 #endif
 860     }
 861     else
 862     {
 863         h->cerrno = CSOUTSTATE;
 864         return 0;
 865     }
 866     h->io_pending = 0;
 867     h->state = CS_ST_DATAXFER;
 868     h->event = CS_DATA;
 869     return h;
 870 }
 871
 872 #define CS_TCPIP_BUFCHUNK 4096
 873
 874 /*
 875  * Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
 876  * 0=connection closed.
 877  */
 878 int tcpip_get(COMSTACK h, char **buf, int *bufsize)
 879 {
 880     tcpip_state *sp = (tcpip_state *)h->cprivate;
 881     char *tmpc;
 882     int tmpi, berlen, rest, req, tomove;
 883     int hasread = 0, res;
 884
 885     TRC(fprintf(stderr, "tcpip_get: bufsize=%d\n", *bufsize));
 886     if (sp->altlen) /* switch buffers */
 887     {
 888         TRC(fprintf(stderr, "  %d bytes in altbuf (0x%x)\n", sp->altlen,
 889             (unsigned) sp->altbuf));
 890         tmpc = *buf;
 891         tmpi = *bufsize;
 892         *buf = sp->altbuf;
 893         *bufsize = sp->altsize;
 894         hasread = sp->altlen;
 895         sp->altlen = 0;
 896         sp->altbuf = tmpc;
 897         sp->altsize = tmpi;
 898     }
 899     h->io_pending = 0;
 900     while (!(berlen = (*sp->complete)(*buf, hasread)))
 901     {
 902         if (!*bufsize)
 903         {
 904             if (!(*buf = (char *)xmalloc(*bufsize = CS_TCPIP_BUFCHUNK)))
 905             {
 906                 h->cerrno = CSYSERR;
 907                 return -1;
 908             }
 909         }
 910         else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
 911             if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
 912             {
 913                 h->cerrno = CSYSERR;
 914                 return -1;
 915             }
 916 #ifdef __sun__
 917         yaz_set_errno( 0 );
 918         /* unfortunatly, sun sometimes forgets to set errno in recv
 919            when EWOULDBLOCK etc. would be required (res = -1) */
 920 #endif
 921         res = recv(h->iofile, *buf + hasread, CS_TCPIP_BUFCHUNK, 0);
 922         TRC(fprintf(stderr, "  recv res=%d, hasread=%d\n", res, hasread));
 923         if (res < 0)
 924         {
 925             TRC(fprintf(stderr, "  recv errno=%d, (%s)\n", yaz_errno(),
 926                       strerror(yaz_errno())));
 927 #ifdef WIN32
 928             if (WSAGetLastError() == WSAEWOULDBLOCK)
 929             {
 930                 h->io_pending = CS_WANT_READ;
 931                 break;
 932             }
 933             else
 934             {
 935                 h->cerrno = CSYSERR;
 936                 return -1;
 937             }
 938 #else
 939             if (yaz_errno() == EWOULDBLOCK
 940 #ifdef EAGAIN
 941 #if EAGAIN != EWOULDBLOCK
 942                 || yaz_errno() == EAGAIN
 943 #endif
 944 #endif
 945                 || yaz_errno() == EINPROGRESS
 946 #ifdef __sun__
 947                 || yaz_errno() == ENOENT /* Sun's sometimes set errno to this */
 948 #endif
 949                 )
 950             {
 951                 h->io_pending = CS_WANT_READ;
 952                 break;
 953             }
 954             else if (yaz_errno() == 0)
 955                 continue;
 956             else
 957             {
 958                 h->cerrno = CSYSERR;
 959                 return -1;
 960             }
 961 #endif
 962         }
 963         else if (!res)
 964             return hasread;
 965         hasread += res;
 966         if (hasread > h->max_recv_bytes)
 967         {
 968             h->cerrno = CSBUFSIZE;
 969             return -1;
 970         }
 971     }
 972     TRC (fprintf (stderr, "  Out of read loop with hasread=%d, berlen=%d\n",
 973                   hasread, berlen));
 974     /* move surplus buffer (or everything if we didn't get a BER rec.) */
 975     if (hasread > berlen)
 976     {
 977         tomove = req = hasread - berlen;
 978         rest = tomove % CS_TCPIP_BUFCHUNK;
 979         if (rest)
 980             req += CS_TCPIP_BUFCHUNK - rest;
 981         if (!sp->altbuf)
 982         {
 983             if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req)))
 984             {
 985                 h->cerrno = CSYSERR;
 986                 return -1;
 987             }
 988         } else if (sp->altsize < req)
 989             if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
 990             {
 991                 h->cerrno = CSYSERR;
 992                 return -1;
 993             }
 994         TRC(fprintf(stderr, "  Moving %d bytes to altbuf(0x%x)\n", tomove,
 995             (unsigned) sp->altbuf));
 996         memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
 997     }
 998     if (berlen < CS_TCPIP_BUFCHUNK - 1)
 999         *(*buf + berlen) = '\0';
1000     return berlen ? berlen : 1;
1001 }
1002
1003
1004 #if HAVE_OPENSSL_SSL_H
1005 /*
1006  * Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
1007  * 0=connection closed.
1008  */
1009 int ssl_get(COMSTACK h, char **buf, int *bufsize)
1010 {
1011     tcpip_state *sp = (tcpip_state *)h->cprivate;
1012     char *tmpc;
1013     int tmpi, berlen, rest, req, tomove;
1014     int hasread = 0, res;
1015
1016     TRC(fprintf(stderr, "ssl_get: bufsize=%d\n", *bufsize));
1017     if (sp->altlen) /* switch buffers */
1018     {
1019         TRC(fprintf(stderr, "  %d bytes in altbuf (0x%x)\n", sp->altlen,
1020             (unsigned) sp->altbuf));
1021         tmpc = *buf;
1022         tmpi = *bufsize;
1023         *buf = sp->altbuf;
1024         *bufsize = sp->altsize;
1025         hasread = sp->altlen;
1026         sp->altlen = 0;
1027         sp->altbuf = tmpc;
1028         sp->altsize = tmpi;
1029     }
1030     h->io_pending = 0;
1031     while (!(berlen = (*sp->complete)(*buf, hasread)))
1032     {
1033         if (!*bufsize)
1034         {
1035             if (!(*buf = (char *)xmalloc(*bufsize = CS_TCPIP_BUFCHUNK)))
1036                 return -1;
1037         }
1038         else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
1039             if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
1040                 return -1;
1041         res = SSL_read (sp->ssl, *buf + hasread, CS_TCPIP_BUFCHUNK);
1042         TRC(fprintf(stderr, "  SSL_read res=%d, hasread=%d\n", res, hasread));
1043         if (res <= 0)
1044         {
1045             int ssl_err = SSL_get_error(sp->ssl, res);
1046             if (ssl_err == SSL_ERROR_WANT_READ)
1047             {
1048                 h->io_pending = CS_WANT_READ;
1049                 break;
1050             }
1051             if (ssl_err == SSL_ERROR_WANT_WRITE)
1052             {
1053                 h->io_pending = CS_WANT_WRITE;
1054                 break;
1055             }
1056             if (res == 0)
1057                 return 0;
1058             h->cerrno = CSERRORSSL;
1059             return -1;
1060         }
1061         hasread += res;
1062     }
1063     TRC (fprintf (stderr, "  Out of read loop with hasread=%d, berlen=%d\n",
1064         hasread, berlen));
1065     /* move surplus buffer (or everything if we didn't get a BER rec.) */
1066     if (hasread > berlen)
1067     {
1068         tomove = req = hasread - berlen;
1069         rest = tomove % CS_TCPIP_BUFCHUNK;
1070         if (rest)
1071             req += CS_TCPIP_BUFCHUNK - rest;
1072         if (!sp->altbuf)
1073         {
1074             if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req)))
1075                 return -1;
1076         } else if (sp->altsize < req)
1077             if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
1078                 return -1;
1079         TRC(fprintf(stderr, "  Moving %d bytes to altbuf(0x%x)\n", tomove,
1080             (unsigned) sp->altbuf));
1081         memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
1082     }
1083     if (berlen < CS_TCPIP_BUFCHUNK - 1)
1084         *(*buf + berlen) = '\0';
1085     return berlen ? berlen : 1;
1086 }
1087 #endif
1088
1089 /*
1090  * Returns 1, 0 or -1
1091  * In nonblocking mode, you must call again with same buffer while
1092  * return value is 1.
1093  */
1094 int tcpip_put(COMSTACK h, char *buf, int size)
1095 {
1096     int res;
1097     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
1098
1099     TRC(fprintf(stderr, "tcpip_put: size=%d\n", size));
1100     h->io_pending = 0;
1101     h->event = CS_DATA;
1102     if (state->towrite < 0)
1103     {
1104         state->towrite = size;
1105         state->written = 0;
1106     }
1107     else if (state->towrite != size)
1108     {
1109         h->cerrno = CSWRONGBUF;
1110         return -1;
1111     }
1112     while (state->towrite > state->written)
1113     {
1114         if ((res =
1115              send(h->iofile, buf + state->written, size -
1116                   state->written,
1117 #ifdef MSG_NOSIGNAL
1118                   MSG_NOSIGNAL
1119 #else
1120                   0
1121 #endif
1122                  )) < 0)
1123         {
1124             if (
1125 #ifdef WIN32
1126                 WSAGetLastError() == WSAEWOULDBLOCK
1127 #else
1128                 yaz_errno() == EWOULDBLOCK
1129 #ifdef EAGAIN
1130 #if EAGAIN != EWOULDBLOCK
1131              || yaz_errno() == EAGAIN
1132 #endif
1133 #endif
1134 #ifdef __sun__
1135                 || yaz_errno() == ENOENT /* Sun's sometimes set errno to this value! */
1136 #endif
1137                 || yaz_errno() == EINPROGRESS
1138 #endif
1139                 )
1140             {
1141                 TRC(fprintf(stderr, "  Flow control stop\n"));
1142                 h->io_pending = CS_WANT_WRITE;
1143                 return 1;
1144             }
1145             h->cerrno = CSYSERR;
1146             return -1;
1147         }
1148         state->written += res;
1149         TRC(fprintf(stderr, "  Wrote %d, written=%d, nbytes=%d\n",
1150                     res, state->written, size));
1151     }
1152     state->towrite = state->written = -1;
1153     TRC(fprintf(stderr, "  Ok\n"));
1154     return 0;
1155 }
1156
1157
1158 #if HAVE_OPENSSL_SSL_H
1159 /*
1160  * Returns 1, 0 or -1
1161  * In nonblocking mode, you must call again with same buffer while
1162  * return value is 1.
1163  */
1164 int ssl_put(COMSTACK h, char *buf, int size)
1165 {
1166     int res;
1167     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
1168
1169     TRC(fprintf(stderr, "ssl_put: size=%d\n", size));
1170     h->io_pending = 0;
1171     h->event = CS_DATA;
1172     if (state->towrite < 0)
1173     {
1174         state->towrite = size;
1175         state->written = 0;
1176     }
1177     else if (state->towrite != size)
1178     {
1179         h->cerrno = CSWRONGBUF;
1180         return -1;
1181     }
1182     while (state->towrite > state->written)
1183     {
1184         res = SSL_write (state->ssl, buf + state->written,
1185                          size - state->written);
1186         if (res <= 0)
1187         {
1188             int ssl_err = SSL_get_error(state->ssl, res);
1189             if (ssl_err == SSL_ERROR_WANT_READ)
1190             {
1191                 h->io_pending = CS_WANT_READ;
1192                 return 1;
1193             }
1194             if (ssl_err == SSL_ERROR_WANT_WRITE)
1195             {
1196                 h->io_pending = CS_WANT_WRITE;
1197                 return 1;
1198             }
1199             h->cerrno = CSERRORSSL;
1200             return -1;
1201         }
1202         state->written += res;
1203         TRC(fprintf(stderr, "  Wrote %d, written=%d, nbytes=%d\n",
1204                     res, state->written, size));
1205     }
1206     state->towrite = state->written = -1;
1207     TRC(fprintf(stderr, "  Ok\n"));
1208     return 0;
1209 }
1210 #endif
1211
1212 int tcpip_close(COMSTACK h)
1213 {
1214     tcpip_state *sp = (struct tcpip_state *)h->cprivate;
1215
1216     TRC(fprintf(stderr, "tcpip_close\n"));
1217     if (h->iofile != -1)
1218     {
1219 #if HAVE_OPENSSL_SSL_H
1220         if (sp->ssl)
1221         {
1222             SSL_shutdown (sp->ssl);
1223         }
1224 #endif
1225 #ifdef WIN32
1226         closesocket(h->iofile);
1227 #else
1228         close(h->iofile);
1229 #endif
1230     }
1231     if (sp->altbuf)
1232         xfree(sp->altbuf);
1233 #if HAVE_OPENSSL_SSL_H
1234     if (sp->ssl)
1235     {
1236         TRC (fprintf(stderr, "SSL_free\n"));
1237         SSL_free (sp->ssl);
1238     }
1239     sp->ssl = 0;
1240     if (sp->ctx_alloc)
1241         SSL_CTX_free (sp->ctx_alloc);
1242 #endif
1243 #if HAVE_GETADDRINFO
1244     if (sp->ai)
1245         freeaddrinfo(sp->ai);
1246 #endif
1247     xfree(sp->connect_request_buf);
1248     xfree(sp->connect_response_buf);
1249     xfree(sp);
1250     xfree(h);
1251     return 0;
1252 }
1253
1254 char *tcpip_addrstr(COMSTACK h)
1255 {
1256     tcpip_state *sp = (struct tcpip_state *)h->cprivate;
1257     char *r = 0, *buf = sp->buf;
1258
1259 #if HAVE_GETADDRINFO
1260     char host[120];
1261     struct sockaddr_storage addr;
1262     YAZ_SOCKLEN_T len = sizeof(addr);
1263
1264     if (getpeername(h->iofile, (struct sockaddr *)&addr, &len) < 0)
1265     {
1266         h->cerrno = CSYSERR;
1267         return 0;
1268     }
1269     if (getnameinfo((struct sockaddr *) &addr, len, host, sizeof(host)-1,
1270                     0, 0,
1271                     (h->flags & CS_FLAGS_NUMERICHOST) ? NI_NUMERICHOST : 0))
1272     {
1273         r = "unknown";
1274     }
1275     else
1276         r = host;
1277
1278 #else
1279
1280     struct sockaddr_in addr;
1281     YAZ_SOCKLEN_T len = sizeof(addr);
1282     struct hostent *host;
1283
1284     if (getpeername(h->iofile, (struct sockaddr*) &addr, &len) < 0)
1285     {
1286         h->cerrno = CSYSERR;
1287         return 0;
1288     }
1289     if (!(h->flags & CS_FLAGS_NUMERICHOST))
1290     {
1291         if ((host = gethostbyaddr((char*)&addr.sin_addr,
1292                                   sizeof(addr.sin_addr),
1293                                   AF_INET)))
1294             r = (char*) host->h_name;
1295     }
1296     if (!r)
1297         r = inet_ntoa(addr.sin_addr);
1298 #endif
1299
1300     if (h->protocol == PROTO_HTTP)
1301         sprintf(buf, "http:%s", r);
1302     else
1303         sprintf(buf, "tcp:%s", r);
1304 #if HAVE_OPENSSL_SSL_H
1305     if (sp->ctx)
1306     {
1307         if (h->protocol == PROTO_HTTP)
1308             sprintf(buf, "https:%s", r);
1309         else
1310             sprintf(buf, "ssl:%s", r);
1311     }
1312 #endif
1313     return buf;
1314 }
1315
1316 int static tcpip_set_blocking(COMSTACK p, int flags)
1317 {
1318     unsigned long flag;
1319
1320 #ifdef WIN32
1321     flag = (flags & CS_FLAGS_BLOCKING) ? 0 : 1;
1322     if (ioctlsocket(p->iofile, FIONBIO, &flag) < 0)
1323         return 0;
1324 #else
1325     flag = fcntl(p->iofile, F_GETFL, 0);
1326     if (flags & CS_FLAGS_BLOCKING)
1327         flag = flag & ~O_NONBLOCK;  /* blocking */
1328     else
1329     {
1330         flag = flag | O_NONBLOCK;   /* non-blocking */
1331         signal(SIGPIPE, SIG_IGN);
1332     }
1333     if (fcntl(p->iofile, F_SETFL, flag) < 0)
1334         return 0;
1335 #endif
1336     p->flags = flags;
1337     return 1;
1338 }
1339
1340 #if HAVE_OPENSSL_SSL_H
1341 int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
1342 {
1343     struct tcpip_state *sp;
1344     if (!cs || cs->type != ssl_type)
1345         return 0;
1346     sp = (struct tcpip_state *) cs->cprivate;
1347     if (sp->ctx_alloc)
1348         return 0;
1349     sp->ctx = (SSL_CTX *) ctx;
1350     return 1;
1351 }
1352
1353 void *cs_get_ssl(COMSTACK cs)
1354 {
1355     struct tcpip_state *sp;
1356     if (!cs || cs->type != ssl_type)
1357         return 0;
1358     sp = (struct tcpip_state *) cs->cprivate;
1359     return sp->ssl;
1360 }
1361
1362 int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
1363 {
1364     struct tcpip_state *sp;
1365     if (!cs || cs->type != ssl_type)
1366         return 0;
1367     sp = (struct tcpip_state *) cs->cprivate;
1368     strncpy(sp->cert_fname, fname, sizeof(sp->cert_fname)-1);
1369     sp->cert_fname[sizeof(sp->cert_fname)-1] = '\0';
1370     return 1;
1371 }
1372
1373 int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
1374 {
1375     SSL *ssl = (SSL *) cs_get_ssl(cs);
1376     if (ssl)
1377     {
1378         X509 *server_cert = SSL_get_peer_certificate (ssl);
1379         if (server_cert)
1380         {
1381             BIO *bio = BIO_new(BIO_s_mem());
1382             char *pem_buf;
1383             /* get PEM buffer in memory */
1384             PEM_write_bio_X509(bio, server_cert);
1385             *len = BIO_get_mem_data(bio, &pem_buf);
1386             *buf = (char *) xmalloc(*len);
1387             memcpy(*buf, pem_buf, *len);
1388             BIO_free(bio);
1389             return 1;
1390         }
1391     }
1392     return 0;
1393 }
1394 #else
1395 int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
1396 {
1397     return 0;
1398 }
1399
1400 void *cs_get_ssl(COMSTACK cs)
1401 {
1402     return 0;
1403 }
1404
1405 int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
1406 {
1407     return 0;
1408 }
1409
1410 int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
1411 {
1412     return 0;
1413 }
1414 #endif
1415
1416
1417 static int tcpip_put_connect(COMSTACK h, char *buf, int size)
1418 {
1419     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
1420
1421     int r = tcpip_put(h, state->connect_request_buf,
1422                       state->connect_request_len);
1423     if (r == 0)
1424     {
1425         /* it's sent */
1426         h->f_put = tcpip_put; /* switch to normal tcpip put */
1427         r = tcpip_put(h, buf, size);
1428     }
1429     return r;
1430 }
1431
1432 static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize)
1433 {
1434     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
1435     int r;
1436
1437     r = tcpip_get(h, &state->connect_response_buf,
1438                   &state->connect_response_len);
1439     if (r < 1)
1440         return r;
1441     /* got the connect response completely */
1442     state->complete = cs_complete_auto; /* switch to normal tcpip get */
1443     h->f_get = tcpip_get;
1444     return tcpip_get(h, buf, bufsize);
1445 }
1446
1447
1448 /*
1449  * Local variables:
1450  * c-basic-offset: 4
1451  * indent-tabs-mode: nil
1452  * End:
1453  * vim: shiftwidth=4 tabstop=8 expandtab
1454  */
1455