src/tcpip.c

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