src/tcpip.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) Index Data
   3  * See the file LICENSE for details.
   4  */
   5 /**
   6  * \file tcpip.c
   7  * \brief Implements TCP/IP + SSL COMSTACK.
   8  */
   9 #if HAVE_CONFIG_H
  10 #include <config.h>
  11 #endif
  12
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <assert.h>
  16 #include <stdlib.h>
  17 #include <errno.h>
  18 #include <fcntl.h>
  19 #include <signal.h>
  20 #if HAVE_SYS_TYPES_H
  21 #include <sys/types.h>
  22 #endif
  23 #if HAVE_SYS_TIME_H
  24 #include <sys/time.h>
  25 #endif
  26 #if HAVE_UNISTD_H
  27 #include <unistd.h>
  28 #endif
  29
  30 #ifdef WIN32
  31 /* VS 2003 or later has getaddrinfo; older versions do not */
  32 #include <winsock2.h>
  33 #if _MSC_VER >= 1300
  34 #include <ws2tcpip.h>
  35 #define HAVE_GETADDRINFO 1
  36 #else
  37 #define HAVE_GETADDRINFO 0
  38 #endif
  39 #endif
  40
  41 #if HAVE_NETINET_IN_H
  42 #include <netinet/in.h>
  43 #endif
  44 #if HAVE_NETDB_H
  45 #include <netdb.h>
  46 #endif
  47 #if HAVE_ARPA_INET_H
  48 #include <arpa/inet.h>
  49 #endif
  50 #if HAVE_NETINET_TCP_H
  51 #include <netinet/tcp.h>
  52 #endif
  53 #if HAVE_SYS_SOCKET_H
  54 #include <sys/socket.h>
  55 #endif
  56 #if HAVE_SYS_WAIT_H
  57 #include <sys/wait.h>
  58 #endif
  59
  60 #if HAVE_GNUTLS_H
  61 #include <gnutls/x509.h>
  62 #include <gnutls/gnutls.h>
  63 #define ENABLE_SSL 1
  64 #endif
  65
  66 #if HAVE_OPENSSL_SSL_H
  67 #include <openssl/ssl.h>
  68 #include <openssl/err.h>
  69 #define ENABLE_SSL 1
  70 #endif
  71
  72 #include <yaz/comstack.h>
  73 #include <yaz/tcpip.h>
  74 #include <yaz/errno.h>
  75
  76 static void tcpip_close(COMSTACK h);
  77 static int tcpip_put(COMSTACK h, char *buf, int size);
  78 static int tcpip_get(COMSTACK h, char **buf, int *bufsize);
  79 static int tcpip_put_connect(COMSTACK h, char *buf, int size);
  80 static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize);
  81 static int tcpip_connect(COMSTACK h, void *address);
  82 static int tcpip_more(COMSTACK h);
  83 static int tcpip_rcvconnect(COMSTACK h);
  84 static int tcpip_bind(COMSTACK h, void *address, int mode);
  85 static int tcpip_listen(COMSTACK h, char *raddr, int *addrlen,
  86                  int (*check_ip)(void *cd, const char *a, int len, int type),
  87                  void *cd);
  88 static int tcpip_set_blocking(COMSTACK p, int blocking);
  89
  90 #if ENABLE_SSL
  91 static int ssl_get(COMSTACK h, char **buf, int *bufsize);
  92 static int ssl_put(COMSTACK h, char *buf, int size);
  93 #endif
  94
  95 static COMSTACK tcpip_accept(COMSTACK h);
  96 static const char *tcpip_addrstr(COMSTACK h);
  97 static void *tcpip_straddr(COMSTACK h, const char *str);
  98
  99 #if 0
 100 #define TRC(x) x
 101 #else
 102 #define TRC(X)
 103 #endif
 104
 105 #ifndef YAZ_SOCKLEN_T
 106 #define YAZ_SOCKLEN_T int
 107 #endif
 108
 109 #if HAVE_GNUTLS_H
 110 struct tcpip_cred_ptr {
 111     gnutls_certificate_credentials_t xcred;
 112     int ref;
 113 };
 114
 115 #endif
 116 /* this state is used for both SSL and straight TCP/IP */
 117 typedef struct tcpip_state
 118 {
 119     char *altbuf; /* alternate buffer for surplus data */
 120     int altsize;  /* size as xmalloced */
 121     int altlen;   /* length of data or 0 if none */
 122
 123     int written;  /* -1 if we aren't writing */
 124     int towrite;  /* to verify against user input */
 125     int (*complete)(const char *buf, int len); /* length/complete. */
 126 #if HAVE_GETADDRINFO
 127     struct addrinfo *ai;
 128 #else
 129     struct sockaddr_in addr;  /* returned by cs_straddr */
 130 #endif
 131     char buf[128]; /* returned by cs_addrstr */
 132 #if HAVE_GNUTLS_H
 133     struct tcpip_cred_ptr *cred_ptr;
 134     gnutls_session_t session;
 135     char cert_fname[256];
 136 #elif HAVE_OPENSSL_SSL_H
 137     SSL_CTX *ctx;       /* current CTX. */
 138     SSL_CTX *ctx_alloc; /* If =ctx it is owned by CS. If 0 it is not owned */
 139     SSL *ssl;
 140     char cert_fname[256];
 141 #endif
 142     char *connect_request_buf;
 143     int connect_request_len;
 144     char *connect_response_buf;
 145     int connect_response_len;
 146 } tcpip_state;
 147
 148 #ifdef WIN32
 149 static int tcpip_init(void)
 150 {
 151     static int initialized = 0;
 152     if (!initialized)
 153     {
 154         WORD requested;
 155         WSADATA wd;
 156
 157         requested = MAKEWORD(1, 1);
 158         if (WSAStartup(requested, &wd))
 159             return 0;
 160         initialized = 1;
 161     }
 162     return 1;
 163 }
 164 #else
 165 static int tcpip_init(void)
 166 {
 167     return 1;
 168 }
 169 #endif
 170
 171 /*
 172  * This function is always called through the cs_create() macro.
 173  * s >= 0: socket has already been established for us.
 174  */
 175 COMSTACK tcpip_type(int s, int flags, int protocol, void *vp)
 176 {
 177     COMSTACK p;
 178     tcpip_state *sp;
 179
 180     if (!tcpip_init())
 181         return 0;
 182     if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack))))
 183         return 0;
 184     if (!(sp = (struct tcpip_state *)(p->cprivate =
 185                                          xmalloc(sizeof(tcpip_state)))))
 186         return 0;
 187
 188     p->flags = flags;
 189
 190     p->io_pending = 0;
 191     p->iofile = s;
 192     p->type = tcpip_type;
 193     p->protocol = (enum oid_proto) protocol;
 194
 195     p->f_connect = tcpip_connect;
 196     p->f_rcvconnect = tcpip_rcvconnect;
 197     p->f_get = tcpip_get;
 198     p->f_put = tcpip_put;
 199     p->f_close = tcpip_close;
 200     p->f_more = tcpip_more;
 201     p->f_bind = tcpip_bind;
 202     p->f_listen = tcpip_listen;
 203     p->f_accept = tcpip_accept;
 204     p->f_addrstr = tcpip_addrstr;
 205     p->f_straddr = tcpip_straddr;
 206     p->f_set_blocking = tcpip_set_blocking;
 207     p->max_recv_bytes = 128 * 1024 * 1024;
 208
 209     p->state = s < 0 ? CS_ST_UNBND : CS_ST_IDLE; /* state of line */
 210     p->event = CS_NONE;
 211     p->cerrno = 0;
 212     p->user = 0;
 213
 214 #if HAVE_GNUTLS_H
 215     sp->cred_ptr = 0;
 216     sp->session = 0;
 217     strcpy(sp->cert_fname, "yaz.pem");
 218 #elif HAVE_OPENSSL_SSL_H
 219     sp->ctx = sp->ctx_alloc = 0;
 220     sp->ssl = 0;
 221     strcpy(sp->cert_fname, "yaz.pem");
 222 #endif
 223
 224 #if HAVE_GETADDRINFO
 225     sp->ai = 0;
 226 #endif
 227     sp->altbuf = 0;
 228     sp->altsize = sp->altlen = 0;
 229     sp->towrite = sp->written = -1;
 230     sp->complete = cs_complete_auto;
 231
 232     sp->connect_request_buf = 0;
 233     sp->connect_request_len = 0;
 234     sp->connect_response_buf = 0;
 235     sp->connect_response_len = 0;
 236
 237     TRC(fprintf(stderr, "Created new TCPIP comstack h=%p\n", p));
 238
 239     return p;
 240 }
 241
 242 COMSTACK yaz_tcpip_create(int s, int flags, int protocol,
 243                           const char *connect_host)
 244 {
 245     COMSTACK p = tcpip_type(s, flags, protocol, 0);
 246     if (!p)
 247         return 0;
 248     if (connect_host)
 249     {
 250         tcpip_state *sp = (tcpip_state *) p->cprivate;
 251         sp->connect_request_buf = (char *) xmalloc(strlen(connect_host) + 30);
 252         sprintf(sp->connect_request_buf, "CONNECT %s HTTP/1.0\r\n\r\n",
 253                 connect_host);
 254         sp->connect_request_len = strlen(sp->connect_request_buf);
 255         p->f_put = tcpip_put_connect;
 256         p->f_get = tcpip_get_connect;
 257         sp->complete = cs_complete_auto_head; /* only want HTTP header */
 258     }
 259     return p;
 260 }
 261
 262 #if HAVE_GNUTLS_H
 263 static void tcpip_create_cred(COMSTACK cs)
 264 {
 265     tcpip_state *sp = (tcpip_state *) cs->cprivate;
 266     sp->cred_ptr = (struct tcpip_cred_ptr *) xmalloc(sizeof(*sp->cred_ptr));
 267     sp->cred_ptr->ref = 1;
 268     gnutls_certificate_allocate_credentials(&sp->cred_ptr->xcred);
 269 }
 270
 271 #endif
 272
 273 COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
 274 {
 275 #if !ENABLE_SSL
 276     return 0;
 277 #else
 278     tcpip_state *sp;
 279     COMSTACK p;
 280
 281     p = tcpip_type(s, flags, protocol, 0);
 282     if (!p)
 283         return 0;
 284     p->f_get = ssl_get;
 285     p->f_put = ssl_put;
 286     p->type = ssl_type;
 287     sp = (tcpip_state *) p->cprivate;
 288
 289 #if HAVE_GNUTLS_H
 290     sp->session = (gnutls_session_t) vp;
 291 #elif HAVE_OPENSSL_SSL_H
 292     sp->ctx = (SSL_CTX *) vp;  /* may be NULL */
 293 #endif
 294     /* note: we don't handle already opened socket in SSL mode - yet */
 295     return p;
 296 #endif
 297 }
 298
 299 #if ENABLE_SSL
 300 static int ssl_check_error(COMSTACK h, tcpip_state *sp, int res)
 301 {
 302 #if HAVE_OPENSSL_SSL_H
 303     int err = SSL_get_error(sp->ssl, res);
 304     TRC(fprintf(stderr, "got err=%d\n", err));
 305     if (err == SSL_ERROR_WANT_READ)
 306     {
 307         TRC(fprintf(stderr, " -> SSL_ERROR_WANT_READ\n"));
 308         h->io_pending = CS_WANT_READ;
 309         return 1;
 310     }
 311     if (err == SSL_ERROR_WANT_WRITE)
 312     {
 313         TRC(fprintf(stderr, " -> SSL_ERROR_WANT_WRITE\n"));
 314         h->io_pending = CS_WANT_WRITE;
 315         return 1;
 316     }
 317 #elif HAVE_GNUTLS_H
 318     TRC(fprintf(stderr, "ssl_check_error error=%d fatal=%d msg=%s\n",
 319                 res,
 320                 gnutls_error_is_fatal(res),
 321                 gnutls_strerror(res)));
 322     if (res == GNUTLS_E_AGAIN || res == GNUTLS_E_INTERRUPTED)
 323     {
 324         int dir = gnutls_record_get_direction(sp->session);
 325         TRC(fprintf(stderr, " -> incomplete dir=%d\n", dir));
 326         h->io_pending = dir ? CS_WANT_WRITE : CS_WANT_READ;
 327         return 1;
 328     }
 329 #endif
 330     h->cerrno = CSERRORSSL;
 331     return 0;
 332 }
 333 #endif
 334
 335 #if HAVE_GETADDRINFO
 336 /* resolve using getaddrinfo */
 337 struct addrinfo *tcpip_getaddrinfo(const char *str, const char *port,
 338                                    int *ipv6_only)
 339 {
 340     struct addrinfo hints, *res;
 341     int error;
 342     char host[512], *p;
 343
 344     hints.ai_flags = 0;
 345     hints.ai_family = AF_UNSPEC;
 346     hints.ai_socktype = SOCK_STREAM;
 347     hints.ai_protocol = 0;
 348     hints.ai_addrlen        = 0;
 349     hints.ai_addr           = NULL;
 350     hints.ai_canonname      = NULL;
 351     hints.ai_next           = NULL;
 352
 353     strncpy(host, str, sizeof(host)-1);
 354     host[sizeof(host)-1] = 0;
 355     if ((p = strchr(host, '/')))
 356         *p = 0;
 357     if ((p = strrchr(host, ':')))
 358     {
 359         *p = '\0';
 360         port = p+1;
 361     }
 362
 363     if (!strcmp("@", host))
 364     {
 365         hints.ai_flags = AI_PASSIVE;
 366         hints.ai_family = AF_UNSPEC;
 367         error = getaddrinfo(0, port, &hints, &res);
 368         *ipv6_only = 0;
 369     }
 370     else if (!strcmp("@4", host))
 371     {
 372         hints.ai_flags = AI_PASSIVE;
 373         hints.ai_family = AF_INET;
 374         error = getaddrinfo(0, port, &hints, &res);
 375         *ipv6_only = -1;
 376     }
 377     else if (!strcmp("@6", host))
 378     {
 379         hints.ai_flags = AI_PASSIVE;
 380         hints.ai_family = AF_INET6;
 381         error = getaddrinfo(0, port, &hints, &res);
 382         *ipv6_only = 1;
 383     }
 384     else
 385     {
 386         error = getaddrinfo(host, port, &hints, &res);
 387         *ipv6_only = -1;
 388     }
 389     if (error)
 390         return 0;
 391     return res;
 392 }
 393
 394 #endif
 395 /* gethostbyname .. old systems */
 396 int tcpip_strtoaddr_ex(const char *str, struct sockaddr_in *add,
 397                        int default_port)
 398 {
 399     struct hostent *hp;
 400     char *p, buf[512];
 401     short int port = default_port;
 402 #ifdef WIN32
 403     unsigned long tmpadd;
 404 #else
 405     in_addr_t tmpadd;
 406 #endif
 407     TRC(fprintf(stderr, "tcpip_strtoaddress: %s\n", str ? str : "NULL"));
 408     add->sin_family = AF_INET;
 409     strncpy(buf, str, sizeof(buf)-1);
 410     buf[sizeof(buf)-1] = 0;
 411     if ((p = strchr(buf, '/')))
 412         *p = 0;
 413     if ((p = strrchr(buf, ':')))
 414     {
 415         *p = 0;
 416         port = atoi(p + 1);
 417     }
 418     add->sin_port = htons(port);
 419     if (!strcmp("@", buf))
 420     {
 421         add->sin_addr.s_addr = INADDR_ANY;
 422     }
 423     else if ((tmpadd = inet_addr(buf)) != -1)
 424     {
 425         memcpy(&add->sin_addr.s_addr, &tmpadd, sizeof(struct in_addr));
 426     }
 427     else if ((hp = gethostbyname(buf)))
 428     {
 429         memcpy(&add->sin_addr.s_addr, *hp->h_addr_list,
 430                sizeof(struct in_addr));
 431     }
 432     else
 433         return 0;
 434     return 1;
 435 }
 436
 437 #if HAVE_GETADDRINFO
 438 void *tcpip_straddr(COMSTACK h, const char *str)
 439 {
 440     tcpip_state *sp = (tcpip_state *)h->cprivate;
 441     const char *port = "210";
 442     struct addrinfo *ai = 0;
 443     int ipv6_only = 0;
 444     if (h->protocol == PROTO_HTTP)
 445     {
 446         if (h->type == ssl_type)
 447             port = "443";
 448         else
 449             port = "80";
 450     }
 451     if (!tcpip_init())
 452         return 0;
 453
 454     if (sp->ai)
 455         freeaddrinfo(sp->ai);
 456     sp->ai = tcpip_getaddrinfo(str, port, &ipv6_only);
 457     if (sp->ai && h->state == CS_ST_UNBND)
 458     {
 459         int s = -1;
 460         for (ai = sp->ai; ai; ai = ai->ai_next)
 461         {
 462             if (ai->ai_family == AF_INET6)
 463             {
 464                 s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
 465                 if (s != -1)
 466                     break;
 467             }
 468         }
 469         if (s == -1)
 470         {
 471             for (ai = sp->ai; ai; ai = ai->ai_next)
 472             {
 473                 s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
 474                 if (s != -1)
 475                      break;
 476             }
 477         }
 478         if (s == -1)
 479             return 0;
 480         assert(ai);
 481         h->iofile = s;
 482         if (ai->ai_family == AF_INET6 && ipv6_only >= 0 &&
 483             setsockopt(h->iofile,
 484                        IPPROTO_IPV6,
 485                        IPV6_V6ONLY, &ipv6_only, sizeof(ipv6_only)))
 486                 return 0;
 487         if (!tcpip_set_blocking(h, h->flags))
 488             return 0;
 489     }
 490     return ai;
 491 }
 492 #else
 493 void *tcpip_straddr(COMSTACK h, const char *str)
 494 {
 495     tcpip_state *sp = (tcpip_state *)h->cprivate;
 496     int port = 210;
 497     if (h->protocol == PROTO_HTTP)
 498     {
 499         if (h->type == ssl_type)
 500             port = 443;
 501         else
 502             port = 80;
 503     }
 504
 505     if (!tcpip_init())
 506         return 0;
 507     if (!tcpip_strtoaddr_ex(str, &sp->addr, port))
 508         return 0;
 509     if (h->state == CS_ST_UNBND)
 510     {
 511         int s;
 512         s = socket(AF_INET, SOCK_STREAM, 0);
 513         if (s < 0)
 514             return 0;
 515         h->iofile = s;
 516
 517         if (!tcpip_set_blocking(h, h->flags))
 518             return 0;
 519     }
 520     return &sp->addr;
 521 }
 522 #endif
 523
 524 int tcpip_more(COMSTACK h)
 525 {
 526     tcpip_state *sp = (tcpip_state *)h->cprivate;
 527
 528     return sp->altlen && (*sp->complete)(sp->altbuf, sp->altlen);
 529 }
 530
 531 /*
 532  * connect(2) will block (sometimes) - nothing we can do short of doing
 533  * weird things like spawning subprocesses or threading or some weird junk
 534  * like that.
 535  */
 536 int tcpip_connect(COMSTACK h, void *address)
 537 {
 538 #if HAVE_GETADDRINFO
 539     struct addrinfo *ai = (struct addrinfo *) address;
 540     tcpip_state *sp = (tcpip_state *)h->cprivate;
 541 #else
 542     struct sockaddr_in *add = (struct sockaddr_in *) address;
 543 #endif
 544     int r;
 545     TRC(fprintf(stderr, "tcpip_connect h=%p\n", h));
 546     h->io_pending = 0;
 547     if (h->state != CS_ST_UNBND)
 548     {
 549         h->cerrno = CSOUTSTATE;
 550         return -1;
 551     }
 552 #if HAVE_GETADDRINFO
 553     r = connect(h->iofile, ai->ai_addr, ai->ai_addrlen);
 554     freeaddrinfo(sp->ai);
 555     sp->ai = 0;
 556 #else
 557     r = connect(h->iofile, (struct sockaddr *) add, sizeof(*add));
 558 #endif
 559     if (r < 0)
 560     {
 561 #ifdef WIN32
 562         if (WSAGetLastError() == WSAEWOULDBLOCK)
 563         {
 564             h->event = CS_CONNECT;
 565             h->state = CS_ST_CONNECTING;
 566             h->io_pending = CS_WANT_WRITE;
 567             return 1;
 568         }
 569 #else
 570         if (yaz_errno() == EINPROGRESS)
 571         {
 572             h->event = CS_CONNECT;
 573             h->state = CS_ST_CONNECTING;
 574             h->io_pending = CS_WANT_WRITE|CS_WANT_READ;
 575             return 1;
 576         }
 577 #endif
 578         h->cerrno = CSYSERR;
 579         return -1;
 580     }
 581     h->event = CS_CONNECT;
 582     h->state = CS_ST_CONNECTING;
 583
 584     return tcpip_rcvconnect(h);
 585 }
 586
 587 /*
 588  * nop
 589  */
 590 int tcpip_rcvconnect(COMSTACK h)
 591 {
 592 #if ENABLE_SSL
 593     tcpip_state *sp = (tcpip_state *)h->cprivate;
 594 #endif
 595     TRC(fprintf(stderr, "tcpip_rcvconnect\n"));
 596
 597     if (h->state == CS_ST_DATAXFER)
 598         return 0;
 599     if (h->state != CS_ST_CONNECTING)
 600     {
 601         h->cerrno = CSOUTSTATE;
 602         return -1;
 603     }
 604 #if HAVE_GNUTLS_H
 605     if (h->type == ssl_type && !sp->session)
 606     {
 607         gnutls_global_init();
 608         tcpip_create_cred(h);
 609         gnutls_init(&sp->session, GNUTLS_CLIENT);
 610         gnutls_set_default_priority(sp->session);
 611         gnutls_credentials_set (sp->session, GNUTLS_CRD_CERTIFICATE,
 612                                 sp->cred_ptr->xcred);
 613         /* cast to intermediate size_t to avoid GCC warning. */
 614         gnutls_transport_set_ptr(sp->session,
 615                                  (gnutls_transport_ptr_t)
 616                                  (size_t) h->iofile);
 617     }
 618     if (sp->session)
 619     {
 620         int res = gnutls_handshake(sp->session);
 621         if (res < 0)
 622         {
 623             if (ssl_check_error(h, sp, res))
 624                 return 1;
 625             return -1;
 626         }
 627     }
 628 #elif HAVE_OPENSSL_SSL_H
 629     if (h->type == ssl_type && !sp->ctx)
 630     {
 631         SSL_library_init();
 632         SSL_load_error_strings();
 633
 634         sp->ctx = sp->ctx_alloc = SSL_CTX_new(SSLv23_client_method());
 635         if (!sp->ctx)
 636         {
 637             h->cerrno = CSERRORSSL;
 638             return -1;
 639         }
 640     }
 641     if (sp->ctx)
 642     {
 643         int res;
 644
 645         if (!sp->ssl)
 646         {
 647             sp->ssl = SSL_new(sp->ctx);
 648             SSL_set_fd(sp->ssl, h->iofile);
 649         }
 650         res = SSL_connect(sp->ssl);
 651         if (res <= 0)
 652         {
 653             if (ssl_check_error(h, sp, res))
 654                 return 1;
 655             return -1;
 656         }
 657     }
 658 #endif
 659     h->event = CS_DATA;
 660     h->state = CS_ST_DATAXFER;
 661     return 0;
 662 }
 663
 664 #define CERTF "ztest.pem"
 665 #define KEYF "ztest.pem"
 666
 667 static int tcpip_bind(COMSTACK h, void *address, int mode)
 668 {
 669     int r;
 670     tcpip_state *sp = (tcpip_state *)h->cprivate;
 671 #if HAVE_GETADDRINFO
 672     struct addrinfo *ai = (struct addrinfo *) address;
 673 #else
 674     struct sockaddr *addr = (struct sockaddr *)address;
 675 #endif
 676 #ifdef WIN32
 677     BOOL one = 1;
 678 #else
 679     int one = 1;
 680 #endif
 681
 682 #if HAVE_GNUTLS_H
 683     if (h->type == ssl_type && !sp->session)
 684     {
 685         int res;
 686         gnutls_global_init();
 687
 688         tcpip_create_cred(h);
 689
 690         res = gnutls_certificate_set_x509_key_file(sp->cred_ptr->xcred,
 691                                                    sp->cert_fname,
 692                                                    sp->cert_fname,
 693                                                    GNUTLS_X509_FMT_PEM);
 694         if (res != GNUTLS_E_SUCCESS)
 695         {
 696             h->cerrno = CSERRORSSL;
 697             return -1;
 698         }
 699     }
 700 #elif HAVE_OPENSSL_SSL_H
 701     if (h->type == ssl_type && !sp->ctx)
 702     {
 703         SSL_library_init();
 704         SSL_load_error_strings();
 705
 706         sp->ctx = sp->ctx_alloc = SSL_CTX_new(SSLv23_server_method());
 707         if (!sp->ctx)
 708         {
 709             h->cerrno = CSERRORSSL;
 710             return -1;
 711         }
 712     }
 713     if (sp->ctx)
 714     {
 715         if (sp->ctx_alloc)
 716         {
 717             int res;
 718             res = SSL_CTX_use_certificate_file(sp->ctx, sp->cert_fname,
 719                                                SSL_FILETYPE_PEM);
 720             if (res <= 0)
 721             {
 722                 ERR_print_errors_fp(stderr);
 723                 exit(2);
 724             }
 725             res = SSL_CTX_use_PrivateKey_file(sp->ctx, sp->cert_fname,
 726                                                SSL_FILETYPE_PEM);
 727             if (res <= 0)
 728             {
 729                 ERR_print_errors_fp(stderr);
 730                 exit(3);
 731             }
 732             res = SSL_CTX_check_private_key(sp->ctx);
 733             if (res <= 0)
 734             {
 735                 ERR_print_errors_fp(stderr);
 736                 exit(5);
 737             }
 738         }
 739         TRC(fprintf(stderr, "ssl_bind\n"));
 740     }
 741     else
 742     {
 743         TRC(fprintf(stderr, "tcpip_bind\n"));
 744     }
 745 #else
 746     TRC(fprintf(stderr, "tcpip_bind\n"));
 747 #endif
 748 #ifndef WIN32
 749     if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, (char*)
 750         &one, sizeof(one)) < 0)
 751     {
 752         h->cerrno = CSYSERR;
 753         return -1;
 754     }
 755 #endif
 756 #if HAVE_GETADDRINFO
 757     r = bind(h->iofile, ai->ai_addr, ai->ai_addrlen);
 758     freeaddrinfo(sp->ai);
 759     sp->ai = 0;
 760 #else
 761     r = bind(h->iofile, addr, sizeof(struct sockaddr_in));
 762 #endif
 763     if (r)
 764     {
 765         h->cerrno = CSYSERR;
 766         return -1;
 767     }
 768     /* Allow a maximum-sized backlog of waiting-to-connect clients */
 769     if (mode == CS_SERVER && listen(h->iofile, SOMAXCONN) < 0)
 770     {
 771         h->cerrno = CSYSERR;
 772         return -1;
 773     }
 774     h->state = CS_ST_IDLE;
 775     h->event = CS_LISTEN;
 776     return 0;
 777 }
 778
 779 int tcpip_listen(COMSTACK h, char *raddr, int *addrlen,
 780                  int (*check_ip)(void *cd, const char *a, int len, int t),
 781                  void *cd)
 782 {
 783 #ifdef WIN32
 784     /* we don't get peer address on Windows (via accept) */
 785 #else
 786     struct sockaddr_in addr;
 787     YAZ_SOCKLEN_T len = sizeof(addr);
 788 #endif
 789
 790     TRC(fprintf(stderr, "tcpip_listen pid=%d\n", getpid()));
 791     if (h->state != CS_ST_IDLE)
 792     {
 793         h->cerrno = CSOUTSTATE;
 794         return -1;
 795     }
 796 #ifdef WIN32
 797     h->newfd = accept(h->iofile, 0, 0);
 798 #else
 799     h->newfd = accept(h->iofile, (struct sockaddr*)&addr, &len);
 800 #endif
 801     if (h->newfd < 0)
 802     {
 803         if (
 804 #ifdef WIN32
 805             WSAGetLastError() == WSAEWOULDBLOCK
 806 #else
 807             yaz_errno() == EWOULDBLOCK
 808 #ifdef EAGAIN
 809 #if EAGAIN != EWOULDBLOCK
 810             || yaz_errno() == EAGAIN
 811 #endif
 812 #endif
 813 #endif
 814             )
 815             h->cerrno = CSNODATA;
 816         else
 817         {
 818 #ifdef WIN32
 819             shutdown(h->iofile, SD_RECEIVE);
 820 #else
 821             shutdown(h->iofile, SHUT_RD);
 822 #endif
 823             listen(h->iofile, SOMAXCONN);
 824             h->cerrno = CSYSERR;
 825         }
 826         return -1;
 827     }
 828 #ifdef WIN32
 829     if (addrlen)
 830         *addrlen = 0;
 831 #else
 832     if (addrlen && (size_t) (*addrlen) >= sizeof(struct sockaddr_in))
 833         memcpy(raddr, &addr, *addrlen = sizeof(struct sockaddr_in));
 834     else if (addrlen)
 835         *addrlen = 0;
 836     if (check_ip && (*check_ip)(cd, (const char *) &addr,
 837         sizeof(addr), AF_INET))
 838     {
 839         h->cerrno = CSDENY;
 840 #ifdef WIN32
 841         closesocket(h->newfd);
 842 #else
 843         close(h->newfd);
 844 #endif
 845         h->newfd = -1;
 846         return -1;
 847     }
 848 #endif
 849     h->state = CS_ST_INCON;
 850     return 0;
 851 }
 852
 853 COMSTACK tcpip_accept(COMSTACK h)
 854 {
 855     COMSTACK cnew;
 856 #ifdef WIN32
 857     unsigned long tru = 1;
 858 #endif
 859
 860     TRC(fprintf(stderr, "tcpip_accept h=%p pid=%d\n", h, getpid()));
 861     if (h->state == CS_ST_INCON)
 862     {
 863         tcpip_state *state, *st = (tcpip_state *)h->cprivate;
 864         if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew))))
 865         {
 866             h->cerrno = CSYSERR;
 867 #ifdef WIN32
 868             closesocket(h->newfd);
 869 #else
 870             close(h->newfd);
 871 #endif
 872             h->newfd = -1;
 873             return 0;
 874         }
 875         memcpy(cnew, h, sizeof(*h));
 876         cnew->iofile = h->newfd;
 877         cnew->io_pending = 0;
 878
 879         if (!(state = (tcpip_state *)
 880               (cnew->cprivate = xmalloc(sizeof(tcpip_state)))))
 881         {
 882             h->cerrno = CSYSERR;
 883             if (h->newfd != -1)
 884             {
 885 #ifdef WIN32
 886                 closesocket(h->newfd);
 887 #else
 888                 close(h->newfd);
 889 #endif
 890                 h->newfd = -1;
 891             }
 892             return 0;
 893         }
 894         if (!tcpip_set_blocking(cnew, cnew->flags))
 895         {
 896             h->cerrno = CSYSERR;
 897             if (h->newfd != -1)
 898             {
 899 #ifdef WIN32
 900                 closesocket(h->newfd);
 901 #else
 902                 close(h->newfd);
 903 #endif
 904                 h->newfd = -1;
 905             }
 906             xfree(cnew);
 907             xfree(state);
 908             return 0;
 909         }
 910         h->newfd = -1;
 911         state->altbuf = 0;
 912         state->altsize = state->altlen = 0;
 913         state->towrite = state->written = -1;
 914         state->complete = st->complete;
 915 #if HAVE_GETADDRINFO
 916         state->ai = 0;
 917 #endif
 918         cnew->state = CS_ST_ACCEPT;
 919         h->state = CS_ST_IDLE;
 920
 921 #if HAVE_GNUTLS_H
 922         state->cred_ptr = st->cred_ptr;
 923         state->session = 0;
 924         if (st->cred_ptr)
 925         {
 926             int res;
 927
 928             (state->cred_ptr->ref)++;
 929             gnutls_init(&state->session, GNUTLS_SERVER);
 930             if (!state->session)
 931             {
 932                 xfree(cnew);
 933                 xfree(state);
 934                 return 0;
 935             }
 936             res = gnutls_set_default_priority(state->session);
 937             if (res != GNUTLS_E_SUCCESS)
 938             {
 939                 xfree(cnew);
 940                 xfree(state);
 941                 return 0;
 942             }
 943             res = gnutls_credentials_set(state->session,
 944                                          GNUTLS_CRD_CERTIFICATE,
 945                                          st->cred_ptr->xcred);
 946             if (res != GNUTLS_E_SUCCESS)
 947             {
 948                 xfree(cnew);
 949                 xfree(state);
 950                 return 0;
 951             }
 952             /* cast to intermediate size_t to avoid GCC warning. */
 953             gnutls_transport_set_ptr(state->session,
 954                                      (gnutls_transport_ptr_t)
 955                                      (size_t) cnew->iofile);
 956         }
 957 #elif HAVE_OPENSSL_SSL_H
 958         state->ctx = st->ctx;
 959         state->ctx_alloc = 0;
 960         state->ssl = st->ssl;
 961         if (state->ctx)
 962         {
 963             state->ssl = SSL_new(state->ctx);
 964             SSL_set_fd(state->ssl, cnew->iofile);
 965         }
 966 #endif
 967         state->connect_request_buf = 0;
 968         state->connect_response_buf = 0;
 969         h = cnew;
 970     }
 971     if (h->state == CS_ST_ACCEPT)
 972     {
 973 #if HAVE_GNUTLS_H
 974         tcpip_state *state = (tcpip_state *)h->cprivate;
 975         if (state->session)
 976         {
 977             int res = gnutls_handshake(state->session);
 978             if (res < 0)
 979             {
 980                 if (ssl_check_error(h, state, res))
 981                 {
 982                     TRC(fprintf(stderr, "gnutls_handshake int in tcpip_accept\n"));
 983                     return h;
 984                 }
 985                 TRC(fprintf(stderr, "gnutls_handshake failed in tcpip_accept\n"));
 986                 cs_close(h);
 987                 return 0;
 988             }
 989             TRC(fprintf(stderr, "SSL_accept complete. gnutls\n"));
 990         }
 991 #elif HAVE_OPENSSL_SSL_H
 992         tcpip_state *state = (tcpip_state *)h->cprivate;
 993         if (state->ctx)
 994         {
 995             int res;
 996             errno = 0;
 997             res = SSL_accept(state->ssl);
 998             TRC(fprintf(stderr, "SSL_accept res=%d\n", res));
 999             if (res <= 0)
1000             {
1001                 if (ssl_check_error(h, state, res))
1002                 {
1003                     return h;
1004                 }
1005                 cs_close(h);
1006                 return 0;
1007             }
1008             TRC(fprintf(stderr, "SSL_accept complete\n"));
1009         }
1010 #endif
1011     }
1012     else
1013     {
1014         h->cerrno = CSOUTSTATE;
1015         return 0;
1016     }
1017     h->io_pending = 0;
1018     h->state = CS_ST_DATAXFER;
1019     h->event = CS_DATA;
1020     return h;
1021 }
1022
1023 #define CS_TCPIP_BUFCHUNK 4096
1024
1025 /*
1026  * Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
1027  * 0=connection closed.
1028  */
1029 int tcpip_get(COMSTACK h, char **buf, int *bufsize)
1030 {
1031     tcpip_state *sp = (tcpip_state *)h->cprivate;
1032     char *tmpc;
1033     int tmpi, berlen, rest, req, tomove;
1034     int hasread = 0, res;
1035
1036     TRC(fprintf(stderr, "tcpip_get: h=%p bufsize=%d\n", h, *bufsize));
1037     if (sp->altlen) /* switch buffers */
1038     {
1039         TRC(fprintf(stderr, "  %d bytes in altbuf (%p)\n", sp->altlen,
1040                     sp->altbuf));
1041         tmpc = *buf;
1042         tmpi = *bufsize;
1043         *buf = sp->altbuf;
1044         *bufsize = sp->altsize;
1045         hasread = sp->altlen;
1046         sp->altlen = 0;
1047         sp->altbuf = tmpc;
1048         sp->altsize = tmpi;
1049     }
1050     h->io_pending = 0;
1051     while (!(berlen = (*sp->complete)(*buf, hasread)))
1052     {
1053         if (!*bufsize)
1054         {
1055             if (!(*buf = (char *)xmalloc(*bufsize = CS_TCPIP_BUFCHUNK)))
1056             {
1057                 h->cerrno = CSYSERR;
1058                 return -1;
1059             }
1060         }
1061         else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
1062             if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
1063             {
1064                 h->cerrno = CSYSERR;
1065                 return -1;
1066             }
1067 #ifdef __sun__
1068         yaz_set_errno( 0 );
1069         /* unfortunatly, sun sometimes forgets to set errno in recv
1070            when EWOULDBLOCK etc. would be required (res = -1) */
1071 #endif
1072         res = recv(h->iofile, *buf + hasread, CS_TCPIP_BUFCHUNK, 0);
1073         TRC(fprintf(stderr, "  recv res=%d, hasread=%d\n", res, hasread));
1074         if (res < 0)
1075         {
1076             TRC(fprintf(stderr, "  recv errno=%d, (%s)\n", yaz_errno(),
1077                       strerror(yaz_errno())));
1078 #ifdef WIN32
1079             if (WSAGetLastError() == WSAEWOULDBLOCK)
1080             {
1081                 h->io_pending = CS_WANT_READ;
1082                 break;
1083             }
1084             else
1085             {
1086                 h->cerrno = CSYSERR;
1087                 return -1;
1088             }
1089 #else
1090             if (yaz_errno() == EWOULDBLOCK
1091 #ifdef EAGAIN
1092 #if EAGAIN != EWOULDBLOCK
1093                 || yaz_errno() == EAGAIN
1094 #endif
1095 #endif
1096                 || yaz_errno() == EINPROGRESS
1097 #ifdef __sun__
1098                 || yaz_errno() == ENOENT /* Sun's sometimes set errno to this */
1099 #endif
1100                 )
1101             {
1102                 h->io_pending = CS_WANT_READ;
1103                 break;
1104             }
1105             else if (yaz_errno() == 0)
1106                 continue;
1107             else
1108             {
1109                 h->cerrno = CSYSERR;
1110                 return -1;
1111             }
1112 #endif
1113         }
1114         else if (!res)
1115             return hasread;
1116         hasread += res;
1117         if (hasread > h->max_recv_bytes)
1118         {
1119             h->cerrno = CSBUFSIZE;
1120             return -1;
1121         }
1122     }
1123     TRC(fprintf(stderr, "  Out of read loop with hasread=%d, berlen=%d\n",
1124                 hasread, berlen));
1125     /* move surplus buffer (or everything if we didn't get a BER rec.) */
1126     if (hasread > berlen)
1127     {
1128         tomove = req = hasread - berlen;
1129         rest = tomove % CS_TCPIP_BUFCHUNK;
1130         if (rest)
1131             req += CS_TCPIP_BUFCHUNK - rest;
1132         if (!sp->altbuf)
1133         {
1134             if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req)))
1135             {
1136                 h->cerrno = CSYSERR;
1137                 return -1;
1138             }
1139         } else if (sp->altsize < req)
1140             if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
1141             {
1142                 h->cerrno = CSYSERR;
1143                 return -1;
1144             }
1145         TRC(fprintf(stderr, "  Moving %d bytes to altbuf(%p)\n", tomove,
1146                     sp->altbuf));
1147         memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
1148     }
1149     if (berlen < CS_TCPIP_BUFCHUNK - 1)
1150         *(*buf + berlen) = '\0';
1151     return berlen ? berlen : 1;
1152 }
1153
1154
1155 #if ENABLE_SSL
1156 /*
1157  * Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
1158  * 0=connection closed.
1159  */
1160 int ssl_get(COMSTACK h, char **buf, int *bufsize)
1161 {
1162     tcpip_state *sp = (tcpip_state *)h->cprivate;
1163     char *tmpc;
1164     int tmpi, berlen, rest, req, tomove;
1165     int hasread = 0, res;
1166
1167     TRC(fprintf(stderr, "ssl_get: bufsize=%d\n", *bufsize));
1168     if (sp->altlen) /* switch buffers */
1169     {
1170         TRC(fprintf(stderr, "  %d bytes in altbuf (%p)\n", sp->altlen,
1171                     sp->altbuf));
1172         tmpc = *buf;
1173         tmpi = *bufsize;
1174         *buf = sp->altbuf;
1175         *bufsize = sp->altsize;
1176         hasread = sp->altlen;
1177         sp->altlen = 0;
1178         sp->altbuf = tmpc;
1179         sp->altsize = tmpi;
1180     }
1181     h->io_pending = 0;
1182     while (!(berlen = (*sp->complete)(*buf, hasread)))
1183     {
1184         if (!*bufsize)
1185         {
1186             if (!(*buf = (char *)xmalloc(*bufsize = CS_TCPIP_BUFCHUNK)))
1187                 return -1;
1188         }
1189         else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
1190             if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
1191                 return -1;
1192 #if HAVE_GNUTLS_H
1193         res = gnutls_record_recv(sp->session, *buf + hasread,
1194                                  CS_TCPIP_BUFCHUNK);
1195         if (res == 0)
1196         {
1197             TRC(fprintf(stderr, "gnutls_record_recv returned 0\n"));
1198             return 0;
1199         }
1200         else if (res < 0)
1201         {
1202             if (ssl_check_error(h, sp, res))
1203                 break;
1204             return -1;
1205         }
1206 #else
1207         res = SSL_read(sp->ssl, *buf + hasread, CS_TCPIP_BUFCHUNK);
1208         TRC(fprintf(stderr, "  SSL_read res=%d, hasread=%d\n", res, hasread));
1209         if (res <= 0)
1210         {
1211             if (ssl_check_error(h, sp, res))
1212                 break;
1213             return -1;
1214         }
1215 #endif
1216         hasread += res;
1217     }
1218     TRC (fprintf (stderr, "  Out of read loop with hasread=%d, berlen=%d\n",
1219         hasread, berlen));
1220     /* move surplus buffer (or everything if we didn't get a BER rec.) */
1221     if (hasread > berlen)
1222     {
1223         tomove = req = hasread - berlen;
1224         rest = tomove % CS_TCPIP_BUFCHUNK;
1225         if (rest)
1226             req += CS_TCPIP_BUFCHUNK - rest;
1227         if (!sp->altbuf)
1228         {
1229             if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req)))
1230                 return -1;
1231         } else if (sp->altsize < req)
1232             if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
1233                 return -1;
1234         TRC(fprintf(stderr, "  Moving %d bytes to altbuf(%p)\n", tomove,
1235                     sp->altbuf));
1236         memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
1237     }
1238     if (berlen < CS_TCPIP_BUFCHUNK - 1)
1239         *(*buf + berlen) = '\0';
1240     return berlen ? berlen : 1;
1241 }
1242 #endif
1243
1244 /*
1245  * Returns 1, 0 or -1
1246  * In nonblocking mode, you must call again with same buffer while
1247  * return value is 1.
1248  */
1249 int tcpip_put(COMSTACK h, char *buf, int size)
1250 {
1251     int res;
1252     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
1253
1254     TRC(fprintf(stderr, "tcpip_put: h=%p size=%d\n", h, size));
1255     h->io_pending = 0;
1256     h->event = CS_DATA;
1257     if (state->towrite < 0)
1258     {
1259         state->towrite = size;
1260         state->written = 0;
1261     }
1262     else if (state->towrite != size)
1263     {
1264         h->cerrno = CSWRONGBUF;
1265         return -1;
1266     }
1267     while (state->towrite > state->written)
1268     {
1269         if ((res =
1270              send(h->iofile, buf + state->written, size -
1271                   state->written,
1272 #ifdef MSG_NOSIGNAL
1273                   MSG_NOSIGNAL
1274 #else
1275                   0
1276 #endif
1277                  )) < 0)
1278         {
1279             if (
1280 #ifdef WIN32
1281                 WSAGetLastError() == WSAEWOULDBLOCK
1282 #else
1283                 yaz_errno() == EWOULDBLOCK
1284 #ifdef EAGAIN
1285 #if EAGAIN != EWOULDBLOCK
1286              || yaz_errno() == EAGAIN
1287 #endif
1288 #endif
1289 #ifdef __sun__
1290                 || yaz_errno() == ENOENT /* Sun's sometimes set errno to this value! */
1291 #endif
1292                 || yaz_errno() == EINPROGRESS
1293 #endif
1294                 )
1295             {
1296                 TRC(fprintf(stderr, "  Flow control stop\n"));
1297                 h->io_pending = CS_WANT_WRITE;
1298                 return 1;
1299             }
1300             h->cerrno = CSYSERR;
1301             return -1;
1302         }
1303         state->written += res;
1304         TRC(fprintf(stderr, "  Wrote %d, written=%d, nbytes=%d\n",
1305                     res, state->written, size));
1306     }
1307     state->towrite = state->written = -1;
1308     TRC(fprintf(stderr, "  Ok\n"));
1309     return 0;
1310 }
1311
1312
1313 #if ENABLE_SSL
1314 /*
1315  * Returns 1, 0 or -1
1316  * In nonblocking mode, you must call again with same buffer while
1317  * return value is 1.
1318  */
1319 int ssl_put(COMSTACK h, char *buf, int size)
1320 {
1321     int res;
1322     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
1323
1324     TRC(fprintf(stderr, "ssl_put: size=%d\n", size));
1325     h->io_pending = 0;
1326     h->event = CS_DATA;
1327     if (state->towrite < 0)
1328     {
1329         state->towrite = size;
1330         state->written = 0;
1331     }
1332     else if (state->towrite != size)
1333     {
1334         h->cerrno = CSWRONGBUF;
1335         return -1;
1336     }
1337     while (state->towrite > state->written)
1338     {
1339 #if HAVE_GNUTLS_H
1340         res = gnutls_record_send(state->session, buf + state->written,
1341                                  size - state->written);
1342         if (res <= 0)
1343         {
1344             if (ssl_check_error(h, state, res))
1345                 return 1;
1346             return -1;
1347         }
1348 #else
1349         res = SSL_write(state->ssl, buf + state->written,
1350                         size - state->written);
1351         if (res <= 0)
1352         {
1353             if (ssl_check_error(h, state, res))
1354                 return 1;
1355             return -1;
1356         }
1357 #endif
1358         state->written += res;
1359         TRC(fprintf(stderr, "  Wrote %d, written=%d, nbytes=%d\n",
1360                     res, state->written, size));
1361     }
1362     state->towrite = state->written = -1;
1363     TRC(fprintf(stderr, "  Ok\n"));
1364     return 0;
1365 }
1366 #endif
1367
1368 void tcpip_close(COMSTACK h)
1369 {
1370     tcpip_state *sp = (struct tcpip_state *)h->cprivate;
1371
1372     TRC(fprintf(stderr, "tcpip_close: h=%p pid=%d\n", h, getpid()));
1373     if (h->iofile != -1)
1374     {
1375 #if HAVE_GNUTLS_H
1376         if (sp->session)
1377             gnutls_bye(sp->session, GNUTLS_SHUT_WR);
1378 #elif HAVE_OPENSSL_SSL_H
1379         if (sp->ssl)
1380         {
1381             SSL_shutdown(sp->ssl);
1382         }
1383 #endif
1384 #ifdef WIN32
1385         closesocket(h->iofile);
1386 #else
1387         close(h->iofile);
1388 #endif
1389     }
1390     if (sp->altbuf)
1391         xfree(sp->altbuf);
1392 #if HAVE_GNUTLS_H
1393     if (sp->session)
1394     {
1395         gnutls_deinit(sp->session);
1396     }
1397     if (sp->cred_ptr)
1398     {
1399         assert(sp->cred_ptr->ref > 0);
1400
1401         if (--(sp->cred_ptr->ref) == 0)
1402         {
1403             TRC(fprintf(stderr, "Removed credentials %p pid=%d\n",
1404                         sp->cred_ptr->xcred, getpid()));
1405             gnutls_certificate_free_credentials(sp->cred_ptr->xcred);
1406             xfree(sp->cred_ptr);
1407         }
1408         sp->cred_ptr = 0;
1409     }
1410 #elif HAVE_OPENSSL_SSL_H
1411     if (sp->ssl)
1412     {
1413         TRC(fprintf(stderr, "SSL_free\n"));
1414         SSL_free(sp->ssl);
1415     }
1416     sp->ssl = 0;
1417     if (sp->ctx_alloc)
1418         SSL_CTX_free(sp->ctx_alloc);
1419 #endif
1420 #if HAVE_GETADDRINFO
1421     if (sp->ai)
1422         freeaddrinfo(sp->ai);
1423 #endif
1424     xfree(sp->connect_request_buf);
1425     xfree(sp->connect_response_buf);
1426     xfree(sp);
1427     xfree(h);
1428 }
1429
1430 const char *tcpip_addrstr(COMSTACK h)
1431 {
1432     tcpip_state *sp = (struct tcpip_state *)h->cprivate;
1433     char *r = 0, *buf = sp->buf;
1434
1435 #if HAVE_GETADDRINFO
1436     char host[120];
1437     struct sockaddr_storage addr;
1438     YAZ_SOCKLEN_T len = sizeof(addr);
1439
1440     if (getpeername(h->iofile, (struct sockaddr *)&addr, &len) < 0)
1441     {
1442         h->cerrno = CSYSERR;
1443         return 0;
1444     }
1445     if (getnameinfo((struct sockaddr *) &addr, len, host, sizeof(host)-1,
1446                     0, 0,
1447                     (h->flags & CS_FLAGS_NUMERICHOST) ? NI_NUMERICHOST : 0))
1448     {
1449         r = "unknown";
1450     }
1451     else
1452         r = host;
1453
1454 #else
1455
1456     struct sockaddr_in addr;
1457     YAZ_SOCKLEN_T len = sizeof(addr);
1458     struct hostent *host;
1459
1460     if (getpeername(h->iofile, (struct sockaddr*) &addr, &len) < 0)
1461     {
1462         h->cerrno = CSYSERR;
1463         return 0;
1464     }
1465     if (!(h->flags & CS_FLAGS_NUMERICHOST))
1466     {
1467         if ((host = gethostbyaddr((char*)&addr.sin_addr,
1468                                   sizeof(addr.sin_addr),
1469                                   AF_INET)))
1470             r = (char*) host->h_name;
1471     }
1472     if (!r)
1473         r = inet_ntoa(addr.sin_addr);
1474 #endif
1475
1476     if (h->protocol == PROTO_HTTP)
1477         sprintf(buf, "http:%s", r);
1478     else
1479         sprintf(buf, "tcp:%s", r);
1480 #if HAVE_GNUTLS_H
1481     if (sp->session)
1482     {
1483         if (h->protocol == PROTO_HTTP)
1484             sprintf(buf, "https:%s", r);
1485         else
1486             sprintf(buf, "ssl:%s", r);
1487     }
1488 #elif HAVE_OPENSSL_SSL_H
1489     if (sp->ctx)
1490     {
1491         if (h->protocol == PROTO_HTTP)
1492             sprintf(buf, "https:%s", r);
1493         else
1494             sprintf(buf, "ssl:%s", r);
1495     }
1496 #endif
1497     return buf;
1498 }
1499
1500 static int tcpip_set_blocking(COMSTACK p, int flags)
1501 {
1502     unsigned long flag;
1503
1504 #ifdef WIN32
1505     flag = (flags & CS_FLAGS_BLOCKING) ? 0 : 1;
1506     if (ioctlsocket(p->iofile, FIONBIO, &flag) < 0)
1507         return 0;
1508 #else
1509     flag = fcntl(p->iofile, F_GETFL, 0);
1510     if (flags & CS_FLAGS_BLOCKING)
1511         flag = flag & ~O_NONBLOCK;  /* blocking */
1512     else
1513     {
1514         flag = flag | O_NONBLOCK;   /* non-blocking */
1515         signal(SIGPIPE, SIG_IGN);
1516     }
1517     if (fcntl(p->iofile, F_SETFL, flag) < 0)
1518         return 0;
1519 #endif
1520     p->flags = flags;
1521     return 1;
1522 }
1523
1524
1525 #if HAVE_GNUTLS_H
1526 /* gnutls_x509_crt_print appeared in 1.7.6. Memory leaks were fixed in 1.7.9.
1527    GNUTLS_CRT_PRINT_FULL appeared in 2.4.0. */
1528 #if GNUTLS_VERSION_NUMBER >= 0x020400
1529 #define USE_GNUTLS_X509_CRT_PRINT 1
1530 #else
1531 #define USE_GNUTLS_X509_CRT_PRINT 0
1532 #endif
1533
1534
1535 #if USE_GNUTLS_X509_CRT_PRINT
1536 #else
1537 static const char *bin2hex(const void *bin, size_t bin_size)
1538 {
1539     static char printable[110];
1540     const unsigned char *_bin = bin;
1541     char *print;
1542     size_t i;
1543     if (bin_size > 50)
1544         bin_size = 50;
1545     print = printable;
1546     for (i = 0; i < bin_size; i++)
1547     {
1548         sprintf(print, "%.2x ", _bin[i]);
1549         print += 2;
1550     }
1551     return printable;
1552 }
1553
1554 static void x509_crt_print(gnutls_x509_crt_t cert)
1555 {
1556     time_t expiration_time, activation_time;
1557     size_t size;
1558     char serial[40];
1559     char dn[256];
1560     unsigned int algo, bits;
1561
1562     expiration_time = gnutls_x509_crt_get_expiration_time(cert);
1563     activation_time = gnutls_x509_crt_get_activation_time(cert);
1564
1565     printf("\tCertificate is valid since: %s", ctime(&activation_time));
1566     printf("\tCertificate expires: %s", ctime(&expiration_time));
1567
1568     /* Print the serial number of the certificate. */
1569     size = sizeof(serial);
1570     gnutls_x509_crt_get_serial(cert, serial, &size);
1571
1572     printf("\tCertificate serial number: %s\n", bin2hex(serial, size));
1573
1574     /* Extract some of the public key algorithm's parameters
1575      */
1576     algo = gnutls_x509_crt_get_pk_algorithm(cert, &bits);
1577
1578     printf("Certificate public key: %s", gnutls_pk_algorithm_get_name(algo));
1579
1580     /* Print the version of the X.509 certificate. */
1581     printf("\tCertificate version: #%d\n", gnutls_x509_crt_get_version(cert));
1582
1583     size = sizeof(dn);
1584     gnutls_x509_crt_get_dn(cert, dn, &size);
1585     printf("\tDN: %s\n", dn);
1586
1587     size = sizeof(dn);
1588     gnutls_x509_crt_get_issuer_dn(cert, dn, &size);
1589     printf("\tIssuer's DN: %s\n", dn);
1590 }
1591 #endif
1592 #endif
1593
1594 void cs_print_session_info(COMSTACK cs)
1595 {
1596 #if HAVE_GNUTLS_H
1597     struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
1598     if (cs->type == ssl_type && sp->session)
1599     {
1600         const gnutls_datum_t *cert_list;
1601         unsigned i, cert_list_size;
1602         if (gnutls_certificate_type_get(sp->session) != GNUTLS_CRT_X509)
1603             return;
1604         printf("X509 certificate\n");
1605         cert_list = gnutls_certificate_get_peers(sp->session,
1606                                                  &cert_list_size);
1607         printf("Peer provided %u certificates\n", cert_list_size);
1608         for (i = 0; i < cert_list_size; i++)
1609         {
1610             gnutls_x509_crt_t cert;
1611 #if USE_GNUTLS_X509_CRT_PRINT
1612             int ret;
1613             gnutls_datum_t cinfo;
1614 #endif
1615             gnutls_x509_crt_init(&cert);
1616             gnutls_x509_crt_import(cert, &cert_list[i], GNUTLS_X509_FMT_DER);
1617             printf("Certificate info %d:\n", i + 1);
1618 #if USE_GNUTLS_X509_CRT_PRINT
1619             ret = gnutls_x509_crt_print(cert, GNUTLS_CRT_PRINT_FULL,
1620                                         &cinfo);
1621             if (ret == 0)
1622             {
1623                 printf("\t%s\n", cinfo.data);
1624                 gnutls_free(cinfo.data);
1625             }
1626 #else
1627             x509_crt_print(cert);
1628 #endif
1629             gnutls_x509_crt_deinit(cert);
1630
1631         }
1632     }
1633 #elif HAVE_OPENSSL_SSL_H
1634     if (cs->type == ssl_type)
1635     {
1636         struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
1637         SSL *ssl = (SSL *) sp->ssl;
1638         if (ssl)
1639         {
1640             X509 *server_cert = SSL_get_peer_certificate(ssl);
1641             if (server_cert)
1642             {
1643                 char *pem_buf;
1644                 int pem_len;
1645                 BIO *bio = BIO_new(BIO_s_mem());
1646
1647                 /* get PEM buffer in memory */
1648                 PEM_write_bio_X509(bio, server_cert);
1649                 pem_len = BIO_get_mem_data(bio, &pem_buf);
1650                 fwrite(pem_buf, pem_len, 1, stdout);
1651
1652                 /* print all info on screen .. */
1653                 X509_print_fp(stdout, server_cert);
1654                 BIO_free(bio);
1655
1656                 X509_free(server_cert);
1657             }
1658         }
1659     }
1660 #endif
1661 }
1662
1663 void *cs_get_ssl(COMSTACK cs)
1664 {
1665 #if HAVE_OPENSSL_SSL_H
1666     if (cs && cs->type == ssl_type)
1667     {
1668         struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
1669         return sp->ssl;
1670     }
1671 #endif
1672     return 0;
1673 }
1674
1675 int cs_set_ssl_ctx(COMSTACK cs, void *ctx)
1676 {
1677 #if ENABLE_SSL
1678     if (cs && cs->type == ssl_type)
1679     {
1680 #if HAVE_OPENSSL_SSL_H
1681         struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
1682         if (sp->ctx_alloc)
1683             return 0;
1684         sp->ctx = (SSL_CTX *) ctx;
1685 #endif
1686         return 1;
1687     }
1688 #endif
1689     return 0;
1690 }
1691
1692 int cs_set_ssl_certificate_file(COMSTACK cs, const char *fname)
1693 {
1694 #if ENABLE_SSL
1695     if (cs && cs->type == ssl_type)
1696     {
1697         struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
1698         strncpy(sp->cert_fname, fname, sizeof(sp->cert_fname)-1);
1699         sp->cert_fname[sizeof(sp->cert_fname)-1] = '\0';
1700         return 1;
1701     }
1702 #endif
1703     return 0;
1704 }
1705
1706 int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
1707 {
1708 #if HAVE_OPENSSL_SSL_H
1709     SSL *ssl = (SSL *) cs_get_ssl(cs);
1710     if (ssl)
1711     {
1712         X509 *server_cert = SSL_get_peer_certificate(ssl);
1713         if (server_cert)
1714         {
1715             BIO *bio = BIO_new(BIO_s_mem());
1716             char *pem_buf;
1717             /* get PEM buffer in memory */
1718             PEM_write_bio_X509(bio, server_cert);
1719             *len = BIO_get_mem_data(bio, &pem_buf);
1720             *buf = (char *) xmalloc(*len);
1721             memcpy(*buf, pem_buf, *len);
1722             BIO_free(bio);
1723             return 1;
1724         }
1725     }
1726 #endif
1727     return 0;
1728 }
1729
1730 static int tcpip_put_connect(COMSTACK h, char *buf, int size)
1731 {
1732     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
1733
1734     int r = tcpip_put(h, state->connect_request_buf,
1735                       state->connect_request_len);
1736     if (r == 0)
1737     {
1738         /* it's sent */
1739         h->f_put = tcpip_put; /* switch to normal tcpip put */
1740         r = tcpip_put(h, buf, size);
1741     }
1742     return r;
1743 }
1744
1745 static int tcpip_get_connect(COMSTACK h, char **buf, int *bufsize)
1746 {
1747     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
1748     int r;
1749
1750     r = tcpip_get(h, &state->connect_response_buf,
1751                   &state->connect_response_len);
1752     if (r < 1)
1753         return r;
1754     /* got the connect response completely */
1755     state->complete = cs_complete_auto; /* switch to normal tcpip get */
1756     h->f_get = tcpip_get;
1757     return tcpip_get(h, buf, bufsize);
1758 }
1759
1760
1761 /*
1762  * Local variables:
1763  * c-basic-offset: 4
1764  * c-file-style: "Stroustrup"
1765  * indent-tabs-mode: nil
1766  * End:
1767  * vim: shiftwidth=4 tabstop=8 expandtab
1768  */
1769