src/main/tls_listen.c

   1 /*
   2  * tls.c
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Copyright 2001  hereUare Communications, Inc. <raghud@hereuare.com>
  21  * Copyright 2003  Alan DeKok <aland@freeradius.org>
  22  * Copyright 2006  The FreeRADIUS server project
  23  */
  24
  25 RCSID("$Id$")
  26 USES_APPLE_DEPRECATED_API       /* OpenSSL API has been deprecated by Apple */
  27
  28 #include <freeradius-devel/radiusd.h>
  29 #include <freeradius-devel/process.h>
  30 #include <freeradius-devel/rad_assert.h>
  31
  32 #ifdef HAVE_SYS_STAT_H
  33 #include <sys/stat.h>
  34 #endif
  35
  36 #ifdef WITH_TCP
  37 #ifdef WITH_TLS
  38 #ifdef HAVE_OPENSSL_RAND_H
  39 #include <openssl/rand.h>
  40 #endif
  41
  42 #ifdef HAVE_OPENSSL_OCSP_H
  43 #include <openssl/ocsp.h>
  44 #endif
  45
  46 #ifdef HAVE_PTHREAD_H
  47 #define PTHREAD_MUTEX_LOCK pthread_mutex_lock
  48 #define PTHREAD_MUTEX_UNLOCK pthread_mutex_unlock
  49 #else
  50 #define PTHREAD_MUTEX_LOCK(_x)
  51 #define PTHREAD_MUTEX_UNLOCK(_x)
  52 #endif
  53
  54 static void dump_hex(char const *msg, uint8_t const *data, size_t data_len)
  55 {
  56         size_t i;
  57
  58         if (rad_debug_lvl < 3) return;
  59
  60         printf("%s %d\n", msg, (int) data_len);
  61         if (data_len > 256) data_len = 256;
  62
  63         for (i = 0; i < data_len; i++) {
  64                 if ((i & 0x0f) == 0x00) printf ("%02x: ", (unsigned int) i);
  65                 printf("%02x ", data[i]);
  66                 if ((i & 0x0f) == 0x0f) printf ("\n");
  67         }
  68         printf("\n");
  69         fflush(stdout);
  70 }
  71
  72 static void tls_socket_close(rad_listen_t *listener)
  73 {
  74         listen_socket_t *sock = listener->data;
  75
  76         SSL_shutdown(sock->ssn->ssl);
  77
  78         listener->status = RAD_LISTEN_STATUS_EOL;
  79         listener->tls = NULL; /* parent owns this! */
  80
  81         /*
  82          *      Tell the event handler that an FD has disappeared.
  83          */
  84         DEBUG("Client has closed connection");
  85         radius_update_listener(listener);
  86
  87         /*
  88          *      Do NOT free the listener here.  It's in use by
  89          *      a request, and will need to hang around until
  90          *      all of the requests are done.
  91          *
  92          *      It is instead free'd in remove_from_request_hash()
  93          */
  94 }
  95
  96 static int CC_HINT(nonnull) tls_socket_write(rad_listen_t *listener, REQUEST *request)
  97 {
  98         uint8_t *p;
  99         ssize_t rcode;
 100         listen_socket_t *sock = listener->data;
 101
 102         p = sock->ssn->dirty_out.data;
 103
 104         while (p < (sock->ssn->dirty_out.data + sock->ssn->dirty_out.used)) {
 105                 RDEBUG3("Writing to socket %d", request->packet->sockfd);
 106                 rcode = write(request->packet->sockfd, p,
 107                               (sock->ssn->dirty_out.data + sock->ssn->dirty_out.used) - p);
 108                 if (rcode <= 0) {
 109                         RDEBUG("Error writing to TLS socket: %s", fr_syserror(errno));
 110
 111                         tls_socket_close(listener);
 112                         return 0;
 113                 }
 114                 p += rcode;
 115         }
 116
 117         sock->ssn->dirty_out.used = 0;
 118
 119         return 1;
 120 }
 121
 122
 123 static int tls_socket_recv(rad_listen_t *listener)
 124 {
 125         bool doing_init = false;
 126         ssize_t rcode;
 127         RADIUS_PACKET *packet;
 128         REQUEST *request;
 129         listen_socket_t *sock = listener->data;
 130         fr_tls_status_t status;
 131         RADCLIENT *client = sock->client;
 132
 133         if (!sock->packet) {
 134                 sock->packet = rad_alloc(sock, false);
 135                 if (!sock->packet) return 0;
 136
 137                 sock->packet->sockfd = listener->fd;
 138                 sock->packet->src_ipaddr = sock->other_ipaddr;
 139                 sock->packet->src_port = sock->other_port;
 140                 sock->packet->dst_ipaddr = sock->my_ipaddr;
 141                 sock->packet->dst_port = sock->my_port;
 142
 143                 if (sock->request) sock->request->packet = talloc_steal(sock->request, sock->packet);
 144         }
 145
 146         /*
 147          *      Allocate a REQUEST for debugging, and initialize the TLS session.
 148          */
 149         if (!sock->request) {
 150                 sock->request = request = request_alloc(sock);
 151                 if (!sock->request) {
 152                         ERROR("Out of memory");
 153                         return 0;
 154                 }
 155
 156                 rad_assert(request->packet == NULL);
 157                 rad_assert(sock->packet != NULL);
 158                 request->packet = talloc_steal(request, sock->packet);
 159
 160                 request->component = "<core>";
 161                 request->component = "<tls-connect>";
 162
 163                 request->reply = rad_alloc(request, false);
 164                 if (!request->reply) return 0;
 165
 166                 rad_assert(sock->ssn == NULL);
 167
 168                 sock->ssn = tls_new_session(sock, listener->tls, sock->request,
 169                                             listener->tls->require_client_cert);
 170                 if (!sock->ssn) {
 171                         TALLOC_FREE(sock->request);
 172                         sock->packet = NULL;
 173                         return 0;
 174                 }
 175
 176                 SSL_set_ex_data(sock->ssn->ssl, FR_TLS_EX_INDEX_REQUEST, (void *)request);
 177                 SSL_set_ex_data(sock->ssn->ssl, fr_tls_ex_index_certs, (void *) &sock->certs);
 178                 SSL_set_ex_data(sock->ssn->ssl, FR_TLS_EX_INDEX_TALLOC, sock->parent);
 179
 180                 doing_init = true;
 181         }
 182
 183         rad_assert(sock->request != NULL);
 184         rad_assert(sock->request->packet != NULL);
 185         rad_assert(sock->packet != NULL);
 186         rad_assert(sock->ssn != NULL);
 187
 188         request = sock->request;
 189
 190         RDEBUG3("Reading from socket %d", request->packet->sockfd);
 191         PTHREAD_MUTEX_LOCK(&sock->mutex);
 192         rcode = read(request->packet->sockfd,
 193                      sock->ssn->dirty_in.data,
 194                      sizeof(sock->ssn->dirty_in.data));
 195         if ((rcode < 0) && (errno == ECONNRESET)) {
 196         do_close:
 197                 DEBUG("Closing TLS socket from client port %u", sock->other_port);
 198                 tls_socket_close(listener);
 199                 PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 200                 return 0;
 201         }
 202
 203         if (rcode < 0) {
 204                 RDEBUG("Error reading TLS socket: %s", fr_syserror(errno));
 205                 goto do_close;
 206         }
 207
 208         /*
 209          *      Normal socket close.
 210          */
 211         if (rcode == 0) goto do_close;
 212
 213         sock->ssn->dirty_in.used = rcode;
 214
 215         dump_hex("READ FROM SSL", sock->ssn->dirty_in.data, sock->ssn->dirty_in.used);
 216
 217         /*
 218          *      Catch attempts to use non-SSL.
 219          */
 220         if (doing_init && (sock->ssn->dirty_in.data[0] != handshake)) {
 221                 RDEBUG("Non-TLS data sent to TLS socket: closing");
 222                 goto do_close;
 223         }
 224
 225         /*
 226          *      If we need to do more initialization, do that here.
 227          */
 228         if (!SSL_is_init_finished(sock->ssn->ssl)) {
 229                 if (!tls_handshake_recv(request, sock->ssn)) {
 230                         RDEBUG("FAILED in TLS handshake receive");
 231                         goto do_close;
 232                 }
 233
 234                 /*
 235                  *      More ACK data to send.  Do so.
 236                  */
 237                 if (sock->ssn->dirty_out.used > 0) {
 238                         tls_socket_write(listener, request);
 239                         PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 240                         return 0;
 241                 }
 242
 243                 /*
 244                  *      FIXME: Run the request through a virtual
 245                  *      server in order to see if we like the
 246                  *      certificate presented by the client.
 247                  */
 248         }
 249
 250         /*
 251          *      Try to get application data.
 252          */
 253         status = tls_application_data(sock->ssn, request);
 254         RDEBUG("Application data status %d", status);
 255
 256         if (status == FR_TLS_MORE_FRAGMENTS) {
 257                 PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 258                 return 0;
 259         }
 260
 261         if (sock->ssn->clean_out.used == 0) {
 262                 PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 263                 return 0;
 264         }
 265
 266         /*
 267          *      We now have a bunch of application data.
 268          */
 269         dump_hex("TUNNELED DATA > ", sock->ssn->clean_out.data, sock->ssn->clean_out.used);
 270
 271         /*
 272          *      If the packet is a complete RADIUS packet, return it to
 273          *      the caller.  Otherwise...
 274          */
 275         if ((sock->ssn->clean_out.used < 20) ||
 276             (((sock->ssn->clean_out.data[2] << 8) | sock->ssn->clean_out.data[3]) != (int) sock->ssn->clean_out.used)) {
 277                 RDEBUG("Received bad packet: Length %zd contents %d",
 278                        sock->ssn->clean_out.used,
 279                        (sock->ssn->clean_out.data[2] << 8) | sock->ssn->clean_out.data[3]);
 280                 goto do_close;
 281         }
 282
 283         packet = sock->packet;
 284         packet->data = talloc_array(packet, uint8_t, sock->ssn->clean_out.used);
 285         packet->data_len = sock->ssn->clean_out.used;
 286         sock->ssn->record_minus(&sock->ssn->clean_out, packet->data, packet->data_len);
 287         packet->vps = NULL;
 288         PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 289
 290         if (!rad_packet_ok(packet, 0, NULL)) {
 291                 if (DEBUG_ENABLED) ERROR("Receive - %s", fr_strerror());
 292                 DEBUG("Closing TLS socket from client");
 293                 PTHREAD_MUTEX_LOCK(&sock->mutex);
 294                 tls_socket_close(listener);
 295                 PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 296                 return 0;       /* do_close unlocks the mutex */
 297         }
 298
 299         /*
 300          *      Copied from src/lib/radius.c, rad_recv();
 301          */
 302         if (fr_debug_lvl) {
 303                 char host_ipaddr[128];
 304
 305                 if (is_radius_code(packet->code)) {
 306                         RDEBUG("tls_recv: %s packet from host %s port %d, id=%d, length=%d",
 307                                fr_packet_codes[packet->code],
 308                                inet_ntop(packet->src_ipaddr.af,
 309                                          &packet->src_ipaddr.ipaddr,
 310                                          host_ipaddr, sizeof(host_ipaddr)),
 311                                packet->src_port,
 312                                packet->id, (int) packet->data_len);
 313                 } else {
 314                         RDEBUG("tls_recv: Packet from host %s port %d code=%d, id=%d, length=%d",
 315                                inet_ntop(packet->src_ipaddr.af,
 316                                          &packet->src_ipaddr.ipaddr,
 317                                          host_ipaddr, sizeof(host_ipaddr)),
 318                                packet->src_port,
 319                                packet->code,
 320                                packet->id, (int) packet->data_len);
 321                 }
 322         }
 323
 324         FR_STATS_INC(auth, total_requests);
 325
 326         return 1;
 327 }
 328
 329
 330 int dual_tls_recv(rad_listen_t *listener)
 331 {
 332         RADIUS_PACKET *packet;
 333         RAD_REQUEST_FUNP fun = NULL;
 334         listen_socket_t *sock = listener->data;
 335         RADCLIENT       *client = sock->client;
 336
 337         if (listener->status != RAD_LISTEN_STATUS_KNOWN) return 0;
 338
 339         if (!tls_socket_recv(listener)) {
 340                 return 0;
 341         }
 342
 343         rad_assert(sock->packet != NULL);
 344         rad_assert(sock->ssn != NULL);
 345         rad_assert(client != NULL);
 346
 347         packet = talloc_steal(NULL, sock->packet);
 348         sock->packet = NULL;
 349
 350         /*
 351          *      Some sanity checks, based on the packet code.
 352          *
 353          *      "auth+acct" are marked as "auth", with the "dual" flag
 354          *      set.
 355          */
 356         switch (packet->code) {
 357         case PW_CODE_ACCESS_REQUEST:
 358                 if (listener->type != RAD_LISTEN_AUTH) goto bad_packet;
 359                 FR_STATS_INC(auth, total_requests);
 360                 fun = rad_authenticate;
 361                 break;
 362
 363 #ifdef WITH_ACCOUNTING
 364         case PW_CODE_ACCOUNTING_REQUEST:
 365                 if (listener->type != RAD_LISTEN_ACCT) {
 366                         /*
 367                          *      Allow auth + dual.  Disallow
 368                          *      everything else.
 369                          */
 370                         if (!((listener->type == RAD_LISTEN_AUTH) &&
 371                               (listener->dual))) {
 372                                     goto bad_packet;
 373                         }
 374                 }
 375                 FR_STATS_INC(acct, total_requests);
 376                 fun = rad_accounting;
 377                 break;
 378 #endif
 379
 380         case PW_CODE_STATUS_SERVER:
 381                 if (!main_config.status_server) {
 382                         FR_STATS_INC(auth, total_unknown_types);
 383                         WARN("Ignoring Status-Server request due to security configuration");
 384                         rad_free(&packet);
 385                         return 0;
 386                 }
 387                 fun = rad_status_server;
 388                 break;
 389
 390         default:
 391         bad_packet:
 392                 FR_STATS_INC(auth, total_unknown_types);
 393
 394                 DEBUG("Invalid packet code %d sent from client %s port %d : IGNORED",
 395                       packet->code, client->shortname, packet->src_port);
 396                 rad_free(&packet);
 397                 return 0;
 398         } /* switch over packet types */
 399
 400         if (!request_receive(NULL, listener, packet, client, fun)) {
 401                 FR_STATS_INC(auth, total_packets_dropped);
 402                 rad_free(&packet);
 403                 return 0;
 404         }
 405
 406         return 1;
 407 }
 408
 409
 410 /*
 411  *      Send a response packet
 412  */
 413 int dual_tls_send(rad_listen_t *listener, REQUEST *request)
 414 {
 415         listen_socket_t *sock = listener->data;
 416
 417         VERIFY_REQUEST(request);
 418
 419         rad_assert(request->listener == listener);
 420         rad_assert(listener->send == dual_tls_send);
 421
 422         if (listener->status != RAD_LISTEN_STATUS_KNOWN) return 0;
 423
 424         /*
 425          *      Accounting reject's are silently dropped.
 426          *
 427          *      We do it here to avoid polluting the rest of the
 428          *      code with this knowledge
 429          */
 430         if (request->reply->code == 0) return 0;
 431
 432         /*
 433          *      Pack the VPs
 434          */
 435         if (rad_encode(request->reply, request->packet,
 436                        request->client->secret) < 0) {
 437                 RERROR("Failed encoding packet: %s", fr_strerror());
 438                 return 0;
 439         }
 440
 441         if (request->reply->data_len > (MAX_PACKET_LEN - 100)) {
 442                 RWARN("Packet is large, and possibly truncated - %zd vs max %d",
 443                       request->reply->data_len, MAX_PACKET_LEN);
 444         }
 445
 446         /*
 447          *      Sign the packet.
 448          */
 449         if (rad_sign(request->reply, request->packet,
 450                        request->client->secret) < 0) {
 451                 RERROR("Failed signing packet: %s", fr_strerror());
 452                 return 0;
 453         }
 454
 455         PTHREAD_MUTEX_LOCK(&sock->mutex);
 456
 457         /*
 458          *      Write the packet to the SSL buffers.
 459          */
 460         sock->ssn->record_plus(&sock->ssn->clean_in,
 461                                request->reply->data, request->reply->data_len);
 462
 463         dump_hex("TUNNELED DATA < ", sock->ssn->clean_in.data, sock->ssn->clean_in.used);
 464
 465         /*
 466          *      Do SSL magic to get encrypted data.
 467          */
 468         tls_handshake_send(request, sock->ssn);
 469
 470         /*
 471          *      And finally write the data to the socket.
 472          */
 473         if (sock->ssn->dirty_out.used > 0) {
 474                 dump_hex("WRITE TO SSL", sock->ssn->dirty_out.data, sock->ssn->dirty_out.used);
 475
 476                 tls_socket_write(listener, request);
 477         }
 478         PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 479
 480         return 0;
 481 }
 482
 483
 484 #ifdef WITH_PROXY
 485 /*
 486  *      Read from the SSL socket.  Safe with either blocking or
 487  *      non-blocking IO.  This level of complexity is probably not
 488  *      necessary, as each packet gets put into one SSL application
 489  *      record.  When SSL has a full record, we should be able to read
 490  *      the entire packet via one SSL_read().
 491  *
 492  *      When SSL has a partial record, SSL_read() will return
 493  *      WANT_READ or WANT_WRITE, and zero application data.
 494  *
 495  *      Called with the mutex held.
 496  */
 497 static ssize_t proxy_tls_read(rad_listen_t *listener)
 498 {
 499         int rcode;
 500         size_t length;
 501         uint8_t *data;
 502         listen_socket_t *sock = listener->data;
 503
 504         /*
 505          *      Get the maximum size of data to receive.
 506          */
 507         if (!sock->data) sock->data = talloc_array(sock, uint8_t,
 508                                                    sock->ssn->mtu);
 509
 510         data = sock->data;
 511
 512         if (sock->partial < 4) {
 513                 rcode = SSL_read(sock->ssn->ssl, data + sock->partial,
 514                                  4 - sock->partial);
 515                 if (rcode <= 0) {
 516                         int err = SSL_get_error(sock->ssn->ssl, rcode);
 517                         switch (err) {
 518                         case SSL_ERROR_WANT_READ:
 519                         case SSL_ERROR_WANT_WRITE:
 520                                 return 0; /* do some more work later */
 521
 522                         case SSL_ERROR_ZERO_RETURN:
 523                                 /* remote end sent close_notify, send one back */
 524                                 SSL_shutdown(sock->ssn->ssl);
 525
 526                         case SSL_ERROR_SYSCALL:
 527                         do_close:
 528                                 return -1;
 529
 530                         default:
 531                                 tls_error_log(NULL, "Failed in proxy receive");
 532
 533                                 goto do_close;
 534                         }
 535                 }
 536
 537                 sock->partial = rcode;
 538         } /* try reading the packet header */
 539
 540         if (sock->partial < 4) return 0; /* read more data */
 541
 542         length = (data[2] << 8) | data[3];
 543
 544         /*
 545          *      Do these checks only once, when we read the header.
 546          */
 547         if (sock->partial == 4) {
 548                 DEBUG3("Proxy received header saying we have a packet of %u bytes",
 549                        (unsigned int) length);
 550
 551                 /*
 552                  *      FIXME: allocate a RADIUS_PACKET, and set
 553                  *      "data" to be as large as necessary.
 554                  */
 555                 if (length > sock->ssn->mtu) {
 556                         INFO("Received packet will be too large! Set \"fragment_size = %u\"",
 557                              (data[2] << 8) | data[3]);
 558                         goto do_close;
 559                 }
 560         }
 561
 562         /*
 563          *      Try to read some more.
 564          */
 565         if (sock->partial < length) {
 566                 rcode = SSL_read(sock->ssn->ssl, data + sock->partial,
 567                                  length - sock->partial);
 568                 if (rcode <= 0) {
 569                         switch (SSL_get_error(sock->ssn->ssl, rcode)) {
 570                         case SSL_ERROR_WANT_READ:
 571                         case SSL_ERROR_WANT_WRITE:
 572                                 return 0;
 573
 574                         case SSL_ERROR_ZERO_RETURN:
 575                                 /* remote end sent close_notify, send one back */
 576                                 SSL_shutdown(sock->ssn->ssl);
 577                                 goto do_close;
 578                         default:
 579                                 goto do_close;
 580                         }
 581                 }
 582
 583                 sock->partial += rcode;
 584         }
 585
 586         /*
 587          *      If we're not done, say so.
 588          *
 589          *      Otherwise, reset the partially read data flag, and say
 590          *      we have a packet.
 591          */
 592         if (sock->partial < length) {
 593                 return 0;
 594         }
 595
 596         sock->partial = 0;      /* we've now read the packet */
 597         return length;
 598 }
 599
 600
 601 int proxy_tls_recv(rad_listen_t *listener)
 602 {
 603         listen_socket_t *sock = listener->data;
 604         char buffer[256];
 605         RADIUS_PACKET *packet;
 606         uint8_t *data;
 607         ssize_t data_len;
 608
 609         if (listener->status != RAD_LISTEN_STATUS_KNOWN) return 0;
 610
 611         DEBUG3("Proxy SSL socket has data to read");
 612         PTHREAD_MUTEX_LOCK(&sock->mutex);
 613         data_len = proxy_tls_read(listener);
 614         PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 615
 616         if (data_len < 0) {
 617                 DEBUG("Closing TLS socket to home server");
 618                 PTHREAD_MUTEX_LOCK(&sock->mutex);
 619                 tls_socket_close(listener);
 620                 PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 621                 return 0;
 622         }
 623
 624         if (data_len == 0) return 0; /* not done yet */
 625
 626         data = sock->data;
 627
 628         packet = rad_alloc(sock, false);
 629         packet->sockfd = listener->fd;
 630         packet->src_ipaddr = sock->other_ipaddr;
 631         packet->src_port = sock->other_port;
 632         packet->dst_ipaddr = sock->my_ipaddr;
 633         packet->dst_port = sock->my_port;
 634         packet->code = data[0];
 635         packet->id = data[1];
 636         packet->data_len = data_len;
 637         packet->data = talloc_array(packet, uint8_t, packet->data_len);
 638         memcpy(packet->data, data, packet->data_len);
 639         memcpy(packet->vector, packet->data + 4, 16);
 640
 641         /*
 642          *      FIXME: Client MIB updates?
 643          */
 644         switch (packet->code) {
 645         case PW_CODE_ACCESS_ACCEPT:
 646         case PW_CODE_ACCESS_CHALLENGE:
 647         case PW_CODE_ACCESS_REJECT:
 648                 break;
 649
 650 #ifdef WITH_ACCOUNTING
 651         case PW_CODE_ACCOUNTING_RESPONSE:
 652                 break;
 653 #endif
 654
 655         default:
 656                 /*
 657                  *      FIXME: Update MIB for packet types?
 658                  */
 659                 ERROR("Invalid packet code %d sent to a proxy port "
 660                        "from home server %s port %d - ID %d : IGNORED",
 661                        packet->code,
 662                        ip_ntoh(&packet->src_ipaddr, buffer, sizeof(buffer)),
 663                        packet->src_port, packet->id);
 664                 rad_free(&packet);
 665                 return 0;
 666         }
 667
 668         if (!request_proxy_reply(packet)) {
 669                 rad_free(&packet);
 670                 return 0;
 671         }
 672
 673         return 1;
 674 }
 675
 676
 677 int proxy_tls_send(rad_listen_t *listener, REQUEST *request)
 678 {
 679         int rcode;
 680         listen_socket_t *sock = listener->data;
 681
 682         VERIFY_REQUEST(request);
 683
 684         if ((listener->status != RAD_LISTEN_STATUS_INIT) &&
 685             (listener->status != RAD_LISTEN_STATUS_KNOWN)) return 0;
 686
 687         /*
 688          *      Normal proxying calls us with the data already
 689          *      encoded.  The "ping home server" code does not.  So,
 690          *      if there's no packet, encode it here.
 691          */
 692         if (!request->proxy->data) {
 693                 request->proxy_listener->encode(request->proxy_listener,
 694                                                 request);
 695         }
 696
 697         DEBUG3("Proxy is writing %u bytes to SSL",
 698                (unsigned int) request->proxy->data_len);
 699         PTHREAD_MUTEX_LOCK(&sock->mutex);
 700         rcode = SSL_write(sock->ssn->ssl, request->proxy->data,
 701                           request->proxy->data_len);
 702         if (rcode < 0) {
 703                 int err;
 704
 705                 err = ERR_get_error();
 706                 switch (err) {
 707                 case SSL_ERROR_NONE:
 708                 case SSL_ERROR_WANT_READ:
 709                 case SSL_ERROR_WANT_WRITE:
 710                         break;  /* let someone else retry */
 711
 712                 default:
 713                         tls_error_log(NULL, "Failed in proxy send");
 714                         DEBUG("Closing TLS socket to home server");
 715                         tls_socket_close(listener);
 716                         PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 717                         return 0;
 718                 }
 719         }
 720         PTHREAD_MUTEX_UNLOCK(&sock->mutex);
 721
 722         return 1;
 723 }
 724 #endif  /* WITH_PROXY */
 725
 726 #endif  /* WITH_TLS */
 727 #endif  /* WITH_TCP */