common/networking/connection.c

   1 /***********************************************************************
   2  Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; either version 2, or (at your option)
   6    any later version.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12 ***********************************************************************/
  13
  14 #ifdef HAVE_CONFIG_H
  15 #include <fc_config.h>
  16 #endif
  17
  18 #include "fc_prehdrs.h"
  19
  20 #include <errno.h>
  21 #include <string.h>
  22 #include <time.h>
  23
  24 #ifdef FREECIV_HAVE_SYS_TYPES_H
  25 #include <sys/types.h>
  26 #endif
  27 #ifdef HAVE_SYS_SELECT_H
  28 /* For some platforms this must be below sys/types.h. */
  29 #include <sys/select.h>
  30 #endif
  31 #ifdef HAVE_UNISTD_H
  32 #include <unistd.h>
  33 #endif
  34
  35 /* utility */
  36 #include "fcintl.h"
  37 #include "genhash.h"
  38 #include "log.h"
  39 #include "mem.h"
  40 #include "netintf.h"
  41 #include "support.h"            /* fc_str(n)casecmp */
  42
  43 /* common */
  44 #include "game.h"               /* game.all_connections */
  45 #include "packets.h"
  46
  47 #include "connection.h"
  48
  49
  50 static void default_conn_close_callback(struct connection *pconn);
  51
  52 /* String used for connection.addr and related cases to indicate
  53  * blank/unknown/not-applicable address:
  54  */
  55 const char blank_addr_str[] = "---.---.---.---";
  56
  57 /****************************************************************************
  58   This callback is used when an error occurs trying to write to the
  59   connection. The effect of the callback should be to close the connection.
  60   This is here so that the server and client can take appropriate
  61   (different) actions: server lost a client, client lost connection to
  62   server. Never attempt to call this function directly, call
  63   connection_close() instead.
  64 ****************************************************************************/
  65 static conn_close_fn_t conn_close_callback = default_conn_close_callback;
  66
  67 /****************************************************************************
  68   Default 'conn_close_fn_t' to close a connection.
  69 ****************************************************************************/
  70 static void default_conn_close_callback(struct connection *pconn)
  71 {
  72   fc_assert_msg(conn_close_callback != default_conn_close_callback,
  73                 "Closing a socket (%s) before calling "
  74                 "close_socket_set_callback().", conn_description(pconn));
  75 }
  76
  77 /****************************************************************************
  78   Register the close_callback.
  79 ****************************************************************************/
  80 void connections_set_close_callback(conn_close_fn_t func)
  81 {
  82   conn_close_callback = func;
  83 }
  84
  85 /****************************************************************************
  86   Call the conn_close_callback.
  87 ****************************************************************************/
  88 void connection_close(struct connection *pconn, const char *reason)
  89 {
  90   fc_assert_ret(NULL != pconn);
  91
  92   if (NULL != reason && NULL == pconn->closing_reason) {
  93     /* NB: we don't overwrite the original reason. */
  94     pconn->closing_reason = fc_strdup(reason);
  95   }
  96
  97   (*conn_close_callback) (pconn);
  98 }
  99
 100 /**************************************************************************
 101   Make sure that there is at least extra_space bytes free space in buffer,
 102   allocating more memory if needed.
 103 **************************************************************************/
 104 static bool buffer_ensure_free_extra_space(struct socket_packet_buffer *buf,
 105                                            int extra_space)
 106 {
 107   /* room for more? */
 108   if (buf->nsize - buf->ndata < extra_space) {
 109     buf->nsize = buf->ndata + extra_space;
 110
 111     /* added this check so we don't gobble up too much mem */
 112     if (buf->nsize > MAX_LEN_BUFFER) {
 113       return FALSE;
 114     }
 115     buf->data = (unsigned char *) fc_realloc(buf->data, buf->nsize);
 116   }
 117   return TRUE;
 118 }
 119
 120 /**************************************************************************
 121   Read data from socket, and check if a packet is ready.
 122   Returns:
 123     -1  :  an error occurred - you should close the socket
 124     -2  :  the connection was closed
 125     >0  :  number of bytes read
 126     =0  :  non-blocking sockets only; no data read, would block
 127 **************************************************************************/
 128 int read_socket_data(int sock, struct socket_packet_buffer *buffer)
 129 {
 130   int didget;
 131
 132   if (!buffer_ensure_free_extra_space(buffer, MAX_LEN_PACKET)) {
 133     log_error("can't grow buffer");
 134     return -1;
 135   }
 136
 137   log_debug("try reading %d bytes", buffer->nsize - buffer->ndata);
 138   didget = fc_readsocket(sock, (char *) (buffer->data + buffer->ndata),
 139                          buffer->nsize - buffer->ndata);
 140
 141   if (didget > 0) {
 142     buffer->ndata+=didget;
 143     log_debug("didget:%d", didget);
 144     return didget;
 145   }
 146   else if (didget == 0) {
 147     log_debug("EOF on socket read");
 148     return -2;
 149   }
 150 #ifdef NONBLOCKING_SOCKETS
 151   else if (errno == EWOULDBLOCK || errno == EAGAIN) {
 152     log_debug("EGAIN on socket read");
 153     return 0;
 154   }
 155 #endif
 156   return -1;
 157 }
 158
 159 /**************************************************************************
 160   write wrapper function -vasc
 161 **************************************************************************/
 162 static int write_socket_data(struct connection *pc,
 163                              struct socket_packet_buffer *buf, int limit)
 164 {
 165   int start, nput, nblock;
 166
 167   if (is_server() && pc->server.is_closing) {
 168     return 0;
 169   }
 170
 171   for (start=0; buf->ndata-start>limit;) {
 172     fd_set writefs, exceptfs;
 173     fc_timeval tv;
 174
 175     FC_FD_ZERO(&writefs);
 176     FC_FD_ZERO(&exceptfs);
 177     FD_SET(pc->sock, &writefs);
 178     FD_SET(pc->sock, &exceptfs);
 179
 180     tv.tv_sec = 0; tv.tv_usec = 0;
 181
 182     if (fc_select(pc->sock+1, NULL, &writefs, &exceptfs, &tv) <= 0) {
 183       if (errno != EINTR) {
 184         break;
 185       } else {
 186         /* EINTR can happen sometimes, especially when compiling with -pg.
 187          * Generally we just want to run select again. */
 188         continue;
 189       }
 190     }
 191
 192     if (FD_ISSET(pc->sock, &exceptfs)) {
 193       connection_close(pc, _("network exception"));
 194       return -1;
 195     }
 196
 197     if (FD_ISSET(pc->sock, &writefs)) {
 198       nblock=MIN(buf->ndata-start, MAX_LEN_PACKET);
 199       log_debug("trying to write %d limit=%d", nblock, limit);
 200       if ((nput = fc_writesocket(pc->sock,
 201                                  (const char *)buf->data+start, nblock)) == -1) {
 202 #ifdef NONBLOCKING_SOCKETS
 203         if (errno == EWOULDBLOCK || errno == EAGAIN) {
 204           break;
 205         }
 206 #endif
 207         connection_close(pc, _("lagging connection"));
 208         return -1;
 209       }
 210       start += nput;
 211     }
 212   }
 213
 214   if (start > 0) {
 215     buf->ndata -= start;
 216     memmove(buf->data, buf->data+start, buf->ndata);
 217     pc->last_write = timer_renew(pc->last_write, TIMER_USER, TIMER_ACTIVE);
 218     timer_start(pc->last_write);
 219   }
 220   return 0;
 221 }
 222
 223
 224 /**************************************************************************
 225   flush'em
 226 **************************************************************************/
 227 void flush_connection_send_buffer_all(struct connection *pc)
 228 {
 229   if (pc && pc->used && pc->send_buffer->ndata > 0) {
 230     write_socket_data(pc, pc->send_buffer, 0);
 231     if (pc->notify_of_writable_data) {
 232       pc->notify_of_writable_data(pc, pc->send_buffer
 233                                   && pc->send_buffer->ndata > 0);
 234     }
 235   }
 236 }
 237
 238 /**************************************************************************
 239   flush'em
 240 **************************************************************************/
 241 #ifndef FREECIV_JSON_CONNECTION
 242 static void flush_connection_send_buffer_packets(struct connection *pc)
 243 {
 244   if (pc && pc->used && pc->send_buffer->ndata >= MAX_LEN_PACKET) {
 245     write_socket_data(pc, pc->send_buffer, MAX_LEN_PACKET-1);
 246     if (pc->notify_of_writable_data) {
 247       pc->notify_of_writable_data(pc, pc->send_buffer
 248                                   && pc->send_buffer->ndata > 0);
 249     }
 250   }
 251 }
 252 #endif /* FREECIV_JSON_CONNECTION */
 253
 254 /****************************************************************************
 255   Add data to send to the connection.
 256 ****************************************************************************/
 257 static bool add_connection_data(struct connection *pconn,
 258                                 const unsigned char *data, int len)
 259 {
 260   struct socket_packet_buffer *buf;
 261
 262   if (NULL == pconn
 263       || !pconn->used
 264       || (is_server() && pconn->server.is_closing)) {
 265     return TRUE;
 266   }
 267
 268   buf = pconn->send_buffer;
 269   log_debug("add %d bytes to %d (space =%d)", len, buf->ndata, buf->nsize);
 270   if (!buffer_ensure_free_extra_space(buf, len)) {
 271     connection_close(pconn, _("buffer overflow"));
 272     return FALSE;
 273   }
 274
 275   memcpy(buf->data + buf->ndata, data, len);
 276   buf->ndata += len;
 277   return TRUE;
 278 }
 279
 280 /****************************************************************************
 281   Write data to socket. Return TRUE on success.
 282 ****************************************************************************/
 283 bool connection_send_data(struct connection *pconn,
 284                           const unsigned char *data, int len)
 285 {
 286   if (NULL == pconn
 287       || !pconn->used
 288       || (is_server() && pconn->server.is_closing)) {
 289     return TRUE;
 290   }
 291
 292   pconn->statistics.bytes_send += len;
 293
 294 #ifndef FREECIV_JSON_CONNECTION
 295   if (0 < pconn->send_buffer->do_buffer_sends) {
 296     flush_connection_send_buffer_packets(pconn);
 297     if (!add_connection_data(pconn, data, len)) {
 298       log_verbose("cut connection %s due to huge send buffer (1)",
 299                   conn_description(pconn));
 300       return FALSE;
 301     }
 302     flush_connection_send_buffer_packets(pconn);
 303   } else
 304 #endif /* FREECIV_JSON_CONNECTION */
 305   {
 306     flush_connection_send_buffer_all(pconn);
 307     if (!add_connection_data(pconn, data, len)) {
 308       log_verbose("cut connection %s due to huge send buffer (2)",
 309                   conn_description(pconn));
 310       return FALSE;
 311     }
 312     flush_connection_send_buffer_all(pconn);
 313   }
 314   return TRUE;
 315 }
 316
 317 /**************************************************************************
 318   Turn on buffering, using a counter so that calls may be nested.
 319 **************************************************************************/
 320 void connection_do_buffer(struct connection *pc)
 321 {
 322   if (pc && pc->used) {
 323     pc->send_buffer->do_buffer_sends++;
 324   }
 325 }
 326
 327 /****************************************************************************
 328   Turn off buffering if internal counter of number of times buffering
 329   was turned on falls to zero, to handle nested buffer/unbuffer pairs.
 330   When counter is zero, flush any pending data.
 331 ***************************************************************************/
 332 void connection_do_unbuffer(struct connection *pc)
 333 {
 334   if (NULL == pc || !pc->used || (is_server() && pc->server.is_closing)) {
 335     return;
 336   }
 337
 338   pc->send_buffer->do_buffer_sends--;
 339   if (0 > pc->send_buffer->do_buffer_sends) {
 340     log_error("Too many calls to unbuffer %s!", pc->username);
 341     pc->send_buffer->do_buffer_sends = 0;
 342   }
 343
 344   if (0 == pc->send_buffer->do_buffer_sends) {
 345     flush_connection_send_buffer_all(pc);
 346   }
 347 }
 348
 349 /**************************************************************************
 350   Convenience functions to buffer/unbuffer a list of connections:
 351 **************************************************************************/
 352 void conn_list_do_buffer(struct conn_list *dest)
 353 {
 354   conn_list_iterate(dest, pconn)
 355     connection_do_buffer(pconn);
 356   conn_list_iterate_end;
 357 }
 358 void conn_list_do_unbuffer(struct conn_list *dest)
 359 {
 360   conn_list_iterate(dest, pconn)
 361     connection_do_unbuffer(pconn);
 362   conn_list_iterate_end;
 363 }
 364
 365 /***************************************************************
 366   Find connection by exact user name, from game.all_connections,
 367   case-insensitve.  Returns NULL if not found.
 368 ***************************************************************/
 369 struct connection *conn_by_user(const char *user_name)
 370 {
 371   conn_list_iterate(game.all_connections, pconn) {
 372     if (fc_strcasecmp(user_name, pconn->username) == 0) {
 373       return pconn;
 374     }
 375   } conn_list_iterate_end;
 376
 377   return NULL;
 378 }
 379
 380 /****************************************************************************
 381   Like conn_by_username(), but allow unambigous prefix (i.e. abbreviation).
 382   Returns NULL if could not match, or if ambiguous or other problem, and
 383   fills *result with characterisation of match/non-match (see
 384   "utility/shared.[ch]").
 385 ****************************************************************************/
 386 static const char *connection_accessor(int i) {
 387   return conn_list_get(game.all_connections, i)->username;
 388 }
 389
 390 struct connection *conn_by_user_prefix(const char *user_name,
 391                                        enum m_pre_result *result)
 392 {
 393   int ind;
 394
 395   *result = match_prefix(connection_accessor,
 396                          conn_list_size(game.all_connections),
 397                          MAX_LEN_NAME-1, fc_strncasequotecmp,
 398                          effectivestrlenquote, user_name, &ind);
 399
 400   if (*result < M_PRE_AMBIGUOUS) {
 401     return conn_list_get(game.all_connections, ind);
 402   } else {
 403     return NULL;
 404   }
 405 }
 406
 407 /***************************************************************
 408   Find connection by id, from game.all_connections.
 409   Returns NULL if not found.
 410   Number of connections will always be relatively small given
 411   current implementation, so linear search should be fine.
 412 ***************************************************************/
 413 struct connection *conn_by_number(int id)
 414 {
 415   conn_list_iterate(game.all_connections, pconn) {
 416     fc_assert_msg(pconn != NULL,
 417                   "Trying to look at the id of a non existing connection");
 418
 419     if (pconn->id == id) {
 420       return pconn;
 421     }
 422   }
 423   conn_list_iterate_end;
 424   return NULL;
 425 }
 426
 427 /**************************************************************************
 428   Return malloced struct, appropriately initialized.
 429 **************************************************************************/
 430 struct socket_packet_buffer *new_socket_packet_buffer(void)
 431 {
 432   struct socket_packet_buffer *buf;
 433
 434   buf = fc_malloc(sizeof(*buf));
 435   buf->ndata = 0;
 436   buf->do_buffer_sends = 0;
 437   buf->nsize = 10*MAX_LEN_PACKET;
 438   buf->data = (unsigned char *)fc_malloc(buf->nsize);
 439   return buf;
 440 }
 441
 442 /**************************************************************************
 443   Free malloced struct
 444 **************************************************************************/
 445 static void free_socket_packet_buffer(struct socket_packet_buffer *buf)
 446 {
 447   if (buf) {
 448     if (buf->data) {
 449       free(buf->data);
 450     }
 451     free(buf);
 452   }
 453 }
 454
 455 /**************************************************************************
 456   Return pointer to static string containing a description for this
 457   connection, based on pconn->name, pconn->addr, and (if applicable)
 458   pconn->playing->name.  (Also pconn->established and pconn->observer.)
 459
 460   Note that when pconn is client.conn (connection to server),
 461   pconn->name and pconn->addr contain empty string, and pconn->playing
 462   is NULL: in this case return string "server".
 463 **************************************************************************/
 464 const char *conn_description(const struct connection *pconn)
 465 {
 466   static char buffer[MAX_LEN_NAME*2 + MAX_LEN_ADDR + 128];
 467
 468   buffer[0] = '\0';
 469
 470   if (*pconn->username != '\0') {
 471     fc_snprintf(buffer, sizeof(buffer), _("%s from %s"),
 472                 pconn->username, pconn->addr);
 473   } else {
 474     sz_strlcpy(buffer, "server");
 475   }
 476   if (NULL != pconn->closing_reason) {
 477     /* TRANS: Appending the reason why a connection has closed. */
 478     cat_snprintf(buffer, sizeof(buffer), _(" (%s)"), pconn->closing_reason);
 479   } else if (!pconn->established) {
 480     sz_strlcat(buffer, _(" (connection incomplete)"));
 481     return buffer;
 482   }
 483   if (NULL != pconn->playing) {
 484     cat_snprintf(buffer, sizeof(buffer), _(" (player %s)"),
 485                  player_name(pconn->playing));
 486   }
 487   if (pconn->observer) {
 488     sz_strlcat(buffer, _(" (observer)"));
 489   }
 490   return buffer;
 491 }
 492
 493 /****************************************************************************
 494   Return TRUE iff the connection is currently allowed to edit.
 495 ****************************************************************************/
 496 bool can_conn_edit(const struct connection *pconn)
 497 {
 498   return (can_conn_enable_editing(pconn)
 499           && game.info.is_edit_mode
 500           && (NULL != pconn->playing || pconn->observer));
 501 }
 502
 503 /****************************************************************************
 504   Return TRUE iff the connection is allowed to start editing.
 505 ****************************************************************************/
 506 bool can_conn_enable_editing(const struct connection *pconn)
 507 {
 508   return pconn->access_level == ALLOW_HACK;
 509 }
 510
 511 /**************************************************************************
 512   Get next request id. Takes wrapping of the 16 bit wide unsigned int
 513   into account.
 514 **************************************************************************/
 515 int get_next_request_id(int old_request_id)
 516 {
 517   int result = old_request_id + 1;
 518
 519   if ((result & 0xffff) == 0) {
 520     log_packet("INFORMATION: request_id has wrapped around; "
 521                "setting from %d to 2", result);
 522     result = 2;
 523   }
 524   fc_assert(0 != result);
 525   return result;
 526 }
 527
 528 /**************************************************************************
 529   Free compression queue for given connection.
 530 **************************************************************************/
 531 void free_compression_queue(struct connection *pc)
 532 {
 533 #ifdef USE_COMPRESSION
 534   byte_vector_free(&pc->compression.queue);
 535 #endif
 536 }
 537
 538 /**************************************************************************
 539   Allocate and initialize packet hashs for given connection.
 540 **************************************************************************/
 541 static void init_packet_hashs(struct connection *pc)
 542 {
 543   enum packet_type i;
 544
 545   pc->phs.sent = fc_malloc(sizeof(*pc->phs.sent) * PACKET_LAST);
 546   pc->phs.received = fc_malloc(sizeof(*pc->phs.received) * PACKET_LAST);
 547   pc->phs.handlers = packet_handlers_initial();
 548
 549   for (i = 0; i < PACKET_LAST; i++) {
 550     pc->phs.sent[i] = NULL;
 551     pc->phs.received[i] = NULL;
 552   }
 553 }
 554
 555 /**************************************************************************
 556   Free packet hash resources from given connection.
 557 **************************************************************************/
 558 static void free_packet_hashes(struct connection *pc)
 559 {
 560   int i;
 561
 562   if (pc->phs.sent) {
 563     for (i = 0; i < PACKET_LAST; i++) {
 564       if (pc->phs.sent[i] != NULL) {
 565         genhash_destroy(pc->phs.sent[i]);
 566       }
 567     }
 568     free(pc->phs.sent);
 569     pc->phs.sent = NULL;
 570   }
 571
 572   if (pc->phs.received) {
 573     for (i = 0; i < PACKET_LAST; i++) {
 574       if (pc->phs.received[i] != NULL) {
 575         genhash_destroy(pc->phs.received[i]);
 576       }
 577     }
 578     free(pc->phs.received);
 579     pc->phs.received = NULL;
 580   }
 581 }
 582
 583 /**************************************************************************
 584   Initialize common part of connection structure. This is used by
 585   both server and client.
 586 **************************************************************************/
 587 void connection_common_init(struct connection *pconn)
 588 {
 589   pconn->established = FALSE;
 590   pconn->used = TRUE;
 591   packet_header_init(&pconn->packet_header);
 592   pconn->closing_reason = NULL;
 593   pconn->last_write = NULL;
 594   pconn->buffer = new_socket_packet_buffer();
 595   pconn->send_buffer = new_socket_packet_buffer();
 596   pconn->statistics.bytes_send = 0;
 597
 598   init_packet_hashs(pconn);
 599
 600 #ifdef USE_COMPRESSION
 601   byte_vector_init(&pconn->compression.queue);
 602   pconn->compression.frozen_level = 0;
 603 #endif
 604 }
 605
 606 /**************************************************************************
 607    Connection closing part common to server and client.
 608 **************************************************************************/
 609 void connection_common_close(struct connection *pconn)
 610 {
 611   if (!pconn->used) {
 612     log_error("WARNING: Trying to close already closed connection");
 613   } else {
 614     fc_closesocket(pconn->sock);
 615     pconn->used = FALSE;
 616     pconn->established = FALSE;
 617     if (NULL != pconn->closing_reason) {
 618       free(pconn->closing_reason);
 619     }
 620
 621     free_socket_packet_buffer(pconn->buffer);
 622     pconn->buffer = NULL;
 623
 624     free_socket_packet_buffer(pconn->send_buffer);
 625     pconn->send_buffer = NULL;
 626
 627     if (pconn->last_write) {
 628       timer_destroy(pconn->last_write);
 629       pconn->last_write = NULL;
 630     }
 631
 632     free_compression_queue(pconn);
 633     free_packet_hashes(pconn);
 634   }
 635 }
 636
 637 /****************************************************************************
 638   Set the network capability string for 'pconn'.
 639 ****************************************************************************/
 640 void conn_set_capability(struct connection *pconn, const char *capability)
 641 {
 642   fc_assert(strlen(capability) < sizeof(pconn->capability));
 643   sz_strlcpy(pconn->capability, capability);
 644   pconn->phs.handlers = packet_handlers_get(capability);
 645 }
 646
 647 /**************************************************************************
 648   Remove all is-game-info cached packets from the connection. This resets
 649   the delta-state partially.
 650 **************************************************************************/
 651 void conn_reset_delta_state(struct connection *pc)
 652 {
 653   int i;
 654
 655   for (i = 0; i < PACKET_LAST; i++) {
 656     if (packet_has_game_info_flag(i)) {
 657       if (NULL != pc->phs.sent && NULL != pc->phs.sent[i]) {
 658         genhash_clear(pc->phs.sent[i]);
 659       }
 660       if (NULL != pc->phs.received && NULL != pc->phs.received[i]) {
 661         genhash_clear(pc->phs.received[i]);
 662       }
 663     }
 664   }
 665 }
 666
 667 /****************************************************************************
 668   Freeze the connection. Then the packets sent to it won't be sent
 669   immediatly, but later, using a compression method. See futher details in
 670   common/packets.[ch].
 671 ****************************************************************************/
 672 void conn_compression_freeze(struct connection *pconn)
 673 {
 674 #ifdef USE_COMPRESSION
 675   if (0 == pconn->compression.frozen_level) {
 676     byte_vector_reserve(&pconn->compression.queue, 0);
 677   }
 678   pconn->compression.frozen_level++;
 679 #endif /* USE_COMPRESSION */
 680 }
 681
 682 /****************************************************************************
 683   Returns TRUE if the connection is frozen. See also
 684   conn_compression_freeze().
 685 ****************************************************************************/
 686 bool conn_compression_frozen(const struct connection *pconn)
 687 {
 688 #ifdef USE_COMPRESSION
 689   return 0 < pconn->compression.frozen_level;
 690 #else
 691   return FALSE;
 692 #endif /* USE_COMPRESSION */
 693 }
 694
 695 /****************************************************************************
 696   Freeze a connection list.
 697 ****************************************************************************/
 698 void conn_list_compression_freeze(const struct conn_list *pconn_list)
 699 {
 700 #ifdef USE_COMPRESSION
 701   conn_list_iterate(pconn_list, pconn) {
 702     conn_compression_freeze(pconn);
 703   } conn_list_iterate_end;
 704 #endif /* USE_COMPRESSION */
 705 }
 706
 707 /****************************************************************************
 708   Thaw a connection list.
 709 ****************************************************************************/
 710 void conn_list_compression_thaw(const struct conn_list *pconn_list)
 711 {
 712 #ifdef USE_COMPRESSION
 713   conn_list_iterate(pconn_list, pconn) {
 714     conn_compression_thaw(pconn);
 715   } conn_list_iterate_end;
 716 #endif /* USE_COMPRESSION */
 717 }
 718
 719 /**************************************************************************
 720   Returns TRUE if the given connection is attached to a player which it
 721   also controls (i.e. not a player observer).
 722 **************************************************************************/
 723 bool conn_controls_player(const struct connection *pconn)
 724 {
 725   return pconn && pconn->playing && !pconn->observer;
 726 }
 727
 728 /**************************************************************************
 729   Returns TRUE if the given connection is a global observer.
 730 **************************************************************************/
 731 bool conn_is_global_observer(const struct connection *pconn)
 732 {
 733   return pconn && !pconn->playing && pconn->observer;
 734 }
 735
 736 /**************************************************************************
 737   Returns the player that this connection is attached to, or NULL. Note
 738   that this will return the observed player for connections that are
 739   observing players.
 740 **************************************************************************/
 741 struct player *conn_get_player(const struct connection *pconn)
 742 {
 743   if (!pconn) {
 744     return NULL;
 745   }
 746   return pconn->playing;
 747 }
 748
 749 /**************************************************************************
 750   Returns the current access level of the given connection.
 751   NB: If 'pconn' is NULL, this function will return ALLOW_NONE.
 752 **************************************************************************/
 753 enum cmdlevel conn_get_access(const struct connection *pconn)
 754 {
 755   if (!pconn) {
 756     return ALLOW_NONE; /* Would not want to give hack on error... */
 757   }
 758   return pconn->access_level;
 759 }
 760
 761
 762 /****************************************************************************
 763   Connection patterns.
 764 ****************************************************************************/
 765 struct conn_pattern {
 766   enum conn_pattern_type type;
 767   char *wildcard;
 768 };
 769
 770 /****************************************************************************
 771   Creates a new connection pattern.
 772 ****************************************************************************/
 773 struct conn_pattern *conn_pattern_new(enum conn_pattern_type type,
 774                                       const char *wildcard)
 775 {
 776   struct conn_pattern *ppattern = fc_malloc(sizeof(*ppattern));
 777
 778   ppattern->type = type;
 779   ppattern->wildcard = fc_strdup(wildcard);
 780
 781   return ppattern;
 782 }
 783
 784 /****************************************************************************
 785   Free a connection pattern.
 786 ****************************************************************************/
 787 void conn_pattern_destroy(struct conn_pattern *ppattern)
 788 {
 789   fc_assert_ret(NULL != ppattern);
 790   free(ppattern->wildcard);
 791   free(ppattern);
 792 }
 793
 794 /****************************************************************************
 795   Returns TRUE whether the connection fits the connection pattern.
 796 ****************************************************************************/
 797 bool conn_pattern_match(const struct conn_pattern *ppattern,
 798                         const struct connection *pconn)
 799 {
 800   const char *test = NULL;
 801
 802   switch (ppattern->type) {
 803   case CPT_USER:
 804     test = pconn->username;
 805     break;
 806   case CPT_HOST:
 807     test =  pconn->addr;
 808     break;
 809   case CPT_IP:
 810     if (is_server()) {
 811       test =  pconn->server.ipaddr;
 812     }
 813     break;
 814   }
 815
 816   if (NULL != test) {
 817     return wildcard_fit_string(ppattern->wildcard, test);
 818   } else {
 819     log_error("%s(): Invalid pattern type (%d)",
 820               __FUNCTION__, ppattern->type);
 821     return FALSE;
 822   }
 823 }
 824
 825 /****************************************************************************
 826   Returns TRUE whether the connection fits one of the connection patterns.
 827 ****************************************************************************/
 828 bool conn_pattern_list_match(const struct conn_pattern_list *plist,
 829                              const struct connection *pconn)
 830 {
 831   conn_pattern_list_iterate(plist, ppattern) {
 832     if (conn_pattern_match(ppattern, pconn)) {
 833       return TRUE;
 834     }
 835   } conn_pattern_list_iterate_end;
 836   return FALSE;
 837 }
 838
 839 /****************************************************************************
 840   Put a string reprentation of the pattern in 'buf'.
 841 ****************************************************************************/
 842 size_t conn_pattern_to_string(const struct conn_pattern *ppattern,
 843                               char *buf, size_t buf_len)
 844 {
 845   return fc_snprintf(buf, buf_len, "<%s=%s>",
 846                      conn_pattern_type_name(ppattern->type),
 847                      ppattern->wildcard);
 848 }
 849
 850 /****************************************************************************
 851   Creates a new connection pattern from the string. If the type is not
 852   specified in 'pattern', then 'prefer' type will be used. If the type
 853   is needed, then pass conn_pattern_type_invalid() for 'prefer'.
 854 ****************************************************************************/
 855 struct conn_pattern *conn_pattern_from_string(const char *pattern,
 856                                               enum conn_pattern_type prefer,
 857                                               char *error_buf,
 858                                               size_t error_buf_len)
 859 {
 860   enum conn_pattern_type type = conn_pattern_type_invalid();
 861   const char *p;
 862
 863   /* Determine pattern type. */
 864   if ((p = strchr(pattern, '='))) {
 865     /* Special character to separate the type of the pattern. */
 866     const size_t pattern_type_len = ++p - pattern;
 867     char pattern_type[pattern_type_len];
 868
 869     fc_strlcpy(pattern_type, pattern, pattern_type_len);
 870     remove_leading_trailing_spaces(pattern_type);
 871     type = conn_pattern_type_by_name(pattern_type, fc_strcasecmp);
 872     if (!conn_pattern_type_is_valid(type)) {
 873       if (NULL != error_buf) {
 874         fc_snprintf(error_buf, error_buf_len,
 875                     _("\"%s\" is not a valid pattern type"),
 876                     pattern_type);
 877       }
 878       return NULL;
 879     }
 880   } else {
 881     /* Use 'prefer' type. */
 882     p = pattern;
 883     type = prefer;
 884     if (!conn_pattern_type_is_valid(type)) {
 885       if (NULL != error_buf) {
 886         fc_strlcpy(error_buf, _("Missing pattern type"), error_buf_len);
 887       }
 888       return NULL;
 889     }
 890   }
 891
 892   /* Remove leading spaces. */
 893   while (fc_isspace(*p)) {
 894     p++;
 895   }
 896
 897   if ('\0' == *p) {
 898     if (NULL != error_buf) {
 899       fc_strlcpy(error_buf, _("Missing pattern"), error_buf_len);
 900     }
 901     return NULL;
 902   }
 903
 904   return  conn_pattern_new(type, p);
 905 }
 906
 907 /**************************************************************************
 908   Returns TRUE if the connection is valid, i.e. not NULL, not closed, not
 909   closing, etc.
 910 **************************************************************************/
 911 bool conn_is_valid(const struct connection *pconn)
 912 {
 913   return (pconn && pconn->used && !pconn->server.is_closing);
 914 }