server/handchat.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 <stdarg.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21
  22 /* utility */
  23 #include "fcintl.h"
  24 #include "log.h"
  25 #include "shared.h"
  26 #include "support.h"
  27
  28 /* common */
  29 #include "chat.h"
  30 #include "game.h"
  31 #include "packets.h"
  32 #include "player.h"
  33
  34 /* server */
  35 #include "console.h"
  36 #include "notify.h"
  37 #include "stdinhand.h"
  38
  39 #include "handchat.h"
  40
  41 #define MAX_LEN_CHAT_NAME (2*MAX_LEN_NAME+10)   /* for form_chat_name() names */
  42
  43 static void send_chat_msg(struct connection *pconn,
  44                           const struct connection *sender,
  45                           const struct ft_color color,
  46                           const char *format, ...)
  47                           fc__attribute((__format__ (__printf__, 4, 5)));
  48
  49 /****************************************************************************
  50   Returns whether 'dest' is ignoring the 'sender' connection.
  51 ****************************************************************************/
  52 static inline bool conn_is_ignored(const struct connection *sender,
  53                                    const struct connection *dest)
  54 {
  55   if (NULL != sender && NULL != dest) {
  56     return conn_pattern_list_match(dest->server.ignore_list, sender);
  57   } else {
  58     return FALSE;
  59   }
  60 }
  61
  62 /**************************************************************************
  63   Formulate a name for this connection, prefering the player name when
  64   available and unambiguous (since this is the "standard" case), else
  65   use the username.
  66 **************************************************************************/
  67 static void form_chat_name(struct connection *pconn, char *buffer, size_t len)
  68 {
  69   struct player *pplayer = pconn->playing;
  70
  71   if (!pplayer
  72       || pconn->observer
  73       || strcmp(player_name(pplayer), ANON_PLAYER_NAME) == 0) {
  74     fc_snprintf(buffer, len, "(%s)", pconn->username);
  75   } else {
  76     fc_snprintf(buffer, len, "%s", player_name(pplayer));
  77   }
  78 }
  79
  80 /**************************************************************************
  81   Send a chat message packet.
  82 **************************************************************************/
  83 static void send_chat_msg(struct connection *pconn,
  84                           const struct connection *sender,
  85                           const struct ft_color color,
  86                           const char *format, ...)
  87 {
  88   struct packet_chat_msg packet;
  89   va_list args;
  90
  91   va_start(args, format);
  92   vpackage_chat_msg(&packet, sender, color, format, args);
  93   va_end(args);
  94
  95   send_packet_chat_msg(pconn, &packet);
  96 }
  97
  98 /**************************************************************************
  99   Complain to sender that name was ambiguous.
 100   'player_conn' is 0 for player names, 1 for connection names,
 101   2 for attempt to send to an anonymous player.
 102 **************************************************************************/
 103 static void complain_ambiguous(struct connection *pconn, const char *name,
 104                                int player_conn)
 105 {
 106   switch(player_conn) {
 107   case 0:
 108     notify_conn(pconn->self, NULL, E_CHAT_ERROR, ftc_server,
 109                 _("%s is an ambiguous player name-prefix."), name);
 110     break;
 111   case 1:
 112     notify_conn(pconn->self, NULL, E_CHAT_ERROR, ftc_server,
 113                 _("%s is an ambiguous connection name-prefix."), name);
 114     break;
 115   case 2:
 116     notify_conn(pconn->self, NULL, E_CHAT_ERROR, ftc_server,
 117                 _("%s is an anonymous name. Use connection name."), name);
 118     break;
 119   default:
 120     log_error("Unknown variant in %s(): %d.", __FUNCTION__, player_conn);
 121   }
 122 }
 123
 124 /**************************************************************************
 125   Send private message to single connection.
 126 **************************************************************************/
 127 static void chat_msg_to_conn(struct connection *sender,
 128                              struct connection *dest, char *msg)
 129 {
 130   char sender_name[MAX_LEN_CHAT_NAME], dest_name[MAX_LEN_CHAT_NAME];
 131
 132   form_chat_name(dest, dest_name, sizeof(dest_name));
 133
 134   if (conn_is_ignored(sender, dest)) {
 135     send_chat_msg(sender, NULL, ftc_warning,
 136                   _("You cannot send messages to %s; you are ignored."),
 137                   dest_name);
 138     return;
 139   }
 140
 141   msg = skip_leading_spaces(msg);
 142   form_chat_name(sender, sender_name, sizeof(sender_name));
 143
 144   send_chat_msg(sender, sender, ftc_chat_private,
 145                 "->*%s* %s", dest_name, msg);
 146
 147   if (sender != dest) {
 148     send_chat_msg(dest, sender, ftc_chat_private,
 149                   "*%s* %s", sender_name, msg);
 150   }
 151 }
 152
 153 /**************************************************************************
 154   Send private message to multi-connected player.
 155 **************************************************************************/
 156 static void chat_msg_to_player(struct connection *sender,
 157                                struct player *pdest, char *msg)
 158 {
 159   struct packet_chat_msg packet;
 160   char sender_name[MAX_LEN_CHAT_NAME];
 161   struct connection *dest = NULL;       /* The 'pdest' user. */
 162   struct event_cache_players *players = event_cache_player_add(NULL, pdest);
 163
 164   msg = skip_leading_spaces(msg);
 165   form_chat_name(sender, sender_name, sizeof(sender_name));
 166
 167   /* Find the user of the player 'pdest'. */
 168   conn_list_iterate(pdest->connections, pconn) {
 169     if (!pconn->observer) {
 170       /* Found it! */
 171       if (conn_is_ignored(sender, pconn)) {
 172         send_chat_msg(sender, NULL, ftc_warning,
 173                       _("You cannot send messages to %s; you are ignored."),
 174                       player_name(pdest));
 175         return;         /* NB: stop here, don't send to observers. */
 176       }
 177       dest = pconn;
 178       break;
 179     }
 180   } conn_list_iterate_end;
 181
 182   /* Repeat the message for the sender. */
 183   send_chat_msg(sender, sender, ftc_chat_private,
 184                 "->{%s} %s", player_name(pdest), msg);
 185
 186   /* Send the message to destination. */
 187   if (NULL != dest && dest != sender) {
 188     send_chat_msg(dest, sender, ftc_chat_private,
 189                   "{%s} %s", sender_name, msg);
 190   }
 191
 192   /* Send the message to player observers. */
 193   package_chat_msg(&packet, sender, ftc_chat_private,
 194                    "{%s -> %s} %s", sender_name, player_name(pdest), msg);
 195   conn_list_iterate(pdest->connections, pconn) {
 196     if (pconn != dest
 197         && pconn != sender
 198         && !conn_is_ignored(sender, pconn)) {
 199       send_packet_chat_msg(pconn, &packet);
 200     }
 201   } conn_list_iterate_end;
 202   if (NULL != sender->playing
 203       && !sender->observer
 204       && sender->playing != pdest) {
 205     /* The sender is another player. */
 206     conn_list_iterate(sender->playing->connections, pconn) {
 207       if (pconn != sender && !conn_is_ignored(sender, pconn)) {
 208         send_packet_chat_msg(pconn, &packet);
 209       }
 210     } conn_list_iterate_end;
 211
 212     /* Add player to event cache. */
 213     players = event_cache_player_add(players, sender->playing);
 214   }
 215
 216   event_cache_add_for_players(&packet, players);
 217 }
 218
 219 /**************************************************************************
 220   Send private message to player allies.
 221 **************************************************************************/
 222 static void chat_msg_to_allies(struct connection *sender, char *msg)
 223 {
 224   struct packet_chat_msg packet;
 225   struct event_cache_players *players = NULL;
 226   char sender_name[MAX_LEN_CHAT_NAME];
 227
 228   msg = skip_leading_spaces(msg);
 229   form_chat_name(sender, sender_name, sizeof(sender_name));
 230
 231   package_chat_msg(&packet, sender, ftc_chat_ally,
 232                    _("%s to allies: %s"), sender_name, msg);
 233
 234   players_iterate(aplayer) {
 235     if (!pplayers_allied(sender->playing, aplayer)) {
 236       continue;
 237     }
 238
 239     conn_list_iterate(aplayer->connections, pconn) {
 240       if (!conn_is_ignored(sender, pconn)) {
 241         send_packet_chat_msg(pconn, &packet);
 242       }
 243     } conn_list_iterate_end;
 244     players = event_cache_player_add(players, aplayer);
 245   } players_iterate_end;
 246
 247   /* Add to the event cache. */
 248   event_cache_add_for_players(&packet, players);
 249 }
 250
 251 /**************************************************************************
 252   Send private message to all global observers.
 253 **************************************************************************/
 254 static void chat_msg_to_global_observers(struct connection *sender,
 255                                          char *msg)
 256 {
 257   struct packet_chat_msg packet;
 258   char sender_name[MAX_LEN_CHAT_NAME];
 259
 260   msg = skip_leading_spaces(msg);
 261   form_chat_name(sender, sender_name, sizeof(sender_name));
 262
 263   package_chat_msg(&packet, sender, ftc_chat_ally,
 264                    _("%s to global observers: %s"), sender_name, msg);
 265
 266   conn_list_iterate(game.est_connections, dest_conn) {
 267     if (conn_is_global_observer(dest_conn)
 268         && !conn_is_ignored(sender, dest_conn)) {
 269       send_packet_chat_msg(dest_conn, &packet);
 270     }
 271   } conn_list_iterate_end;
 272
 273   /* Add to the event cache. */
 274   event_cache_add_for_global_observers(&packet);
 275 }
 276
 277 /**************************************************************************
 278   Send private message to all connections.
 279 **************************************************************************/
 280 static void chat_msg_to_all(struct connection *sender, char *msg)
 281 {
 282   struct packet_chat_msg packet;
 283   char sender_name[MAX_LEN_CHAT_NAME];
 284
 285   msg = skip_leading_spaces(msg);
 286   form_chat_name(sender, sender_name, sizeof(sender_name));
 287
 288   package_chat_msg(&packet, sender, ftc_chat_public,
 289                    "<%s> %s", sender_name, msg);
 290   con_write(C_COMMENT, "%s", packet.message);
 291   lsend_packet_chat_msg(game.est_connections, &packet);
 292
 293   /* Add to the event cache. */
 294   event_cache_add_for_all(&packet);
 295 }
 296
 297 /**************************************************************************
 298   Handle a chat message packet from client:
 299   1. Work out whether it is a server command and if so run it;
 300   2. Otherwise work out whether it is directed to a single player, or
 301      to a single connection, and send there.  (For a player, send to
 302      all clients connected as that player, in multi-connect case);
 303   3. Or it may be intended for all allied players.
 304   4. Else send to all connections (game.est_connections).
 305
 306   In case 2, there can sometimes be ambiguity between player and
 307   connection names.  By default this tries to match player name first,
 308   and only if that fails tries to match connection name.  User can
 309   override this and specify connection only by using two colons ("::")
 310   after the destination name/prefix, instead of one.
 311
 312   The message sent will name the sender, and via format differences
 313   also indicates whether the recipient is either all connections, a
 314   single connection, or multiple connections to a single player.
 315
 316   Message is also echoed back to sender (with different format),
 317   avoiding sending both original and echo if sender is in destination
 318   set.
 319 **************************************************************************/
 320 void handle_chat_msg_req(struct connection *pconn, const char *message)
 321 {
 322   char real_message[MAX_LEN_MSG], *cp;
 323   bool double_colon;
 324
 325   sz_strlcpy(real_message, message);
 326
 327   /* This loop to prevent players from sending multiple lines which can
 328    * be abused */
 329   for (cp = real_message; *cp != '\0'; cp++) {
 330     if (*cp == '\n' || *cp == '\r') {
 331       *cp = '\0';
 332       break;
 333     }
 334   }
 335
 336   /* Server commands are prefixed with '/', which is an obvious
 337      but confusing choice: even before this feature existed,
 338      novice players were trying /who, /nick etc.
 339      So consider this an incentive for IRC support,
 340      or change it in chat.h - rp
 341   */
 342   if (real_message[0] == SERVER_COMMAND_PREFIX) {
 343     /* pass it to the command parser, which will chop the prefix off */
 344     (void) handle_stdin_input(pconn, real_message);
 345     return;
 346   }
 347
 348   /* Send to allies command */
 349   if (real_message[0] == CHAT_ALLIES_PREFIX) {
 350     /* this won't work if we aren't attached to a player */
 351     if (NULL == pconn->playing && !pconn->observer) {
 352       notify_conn(pconn->self, NULL, E_CHAT_ERROR, ftc_server,
 353                   _("You are not attached to a player."));
 354       return;
 355     }
 356
 357     if (NULL != pconn->playing) {
 358       chat_msg_to_allies(pconn, real_message + 1);
 359     } else {
 360       chat_msg_to_global_observers(pconn, real_message + 1);
 361     }
 362     return;
 363   }
 364
 365   /* Want to allow private messages with "player_name: message",
 366      (or "connection_name: message"), including unambiguously
 367      abbreviated player/connection name, but also want to allow
 368      sensible use of ':' within messages, and _also_ want to
 369      notice intended private messages with (eg) mis-spelt name.
 370
 371      Approach:
 372
 373      If there is no ':', or ':' is first on line,
 374           message is global (send to all players)
 375      else if the ':' is double, try matching part before "::" against
 376           connection names: for single match send to that connection,
 377           for multiple matches complain, else goto heuristics below.
 378      else try matching part before (single) ':' against player names:
 379           for single match send to that player, for multiple matches
 380           complain
 381      else try matching against connection names: for single match send
 382           to that connection, for multiple matches complain
 383      else if some heuristics apply (a space anywhere before first ':')
 384           then treat as global message,
 385      else complain (might be a typo-ed intended private message)
 386   */
 387
 388   cp = strchr(real_message, CHAT_DIRECT_PREFIX);
 389
 390   if (cp && (cp != &real_message[0])) {
 391     enum m_pre_result match_result_player, match_result_conn;
 392     struct player *pdest = NULL;
 393     struct connection *conn_dest = NULL;
 394     char name[MAX_LEN_NAME];
 395     char *cpblank;
 396
 397     (void) fc_strlcpy(name, real_message, MIN(sizeof(name),
 398                                               cp - real_message + 1));
 399
 400     double_colon = (*(cp+1) == CHAT_DIRECT_PREFIX);
 401     if (double_colon) {
 402       conn_dest = conn_by_user_prefix(name, &match_result_conn);
 403       if (match_result_conn == M_PRE_AMBIGUOUS) {
 404         complain_ambiguous(pconn, name, 1);
 405         return;
 406       }
 407       if (conn_dest && match_result_conn < M_PRE_AMBIGUOUS) {
 408         chat_msg_to_conn(pconn, conn_dest, cp+2);
 409         return;
 410       }
 411     } else {
 412       /* single colon */
 413       pdest = player_by_name_prefix(name, &match_result_player);
 414       if (match_result_player == M_PRE_AMBIGUOUS) {
 415         complain_ambiguous(pconn, name, 0);
 416         return;
 417       }
 418       if (pdest && strcmp(player_name(pdest), ANON_PLAYER_NAME) == 0) {
 419         complain_ambiguous(pconn, name, 2);
 420         return;
 421       }
 422       if (pdest && match_result_player < M_PRE_AMBIGUOUS) {
 423         chat_msg_to_player(pconn, pdest, cp + 1);
 424         return;
 425         /* else try for connection name match before complaining */
 426       }
 427       conn_dest = conn_by_user_prefix(name, &match_result_conn);
 428       if (match_result_conn == M_PRE_AMBIGUOUS) {
 429         complain_ambiguous(pconn, name, 1);
 430         return;
 431       }
 432       if (conn_dest && match_result_conn < M_PRE_AMBIGUOUS) {
 433         chat_msg_to_conn(pconn, conn_dest, cp+1);
 434         return;
 435       }
 436       if (pdest && match_result_player < M_PRE_AMBIGUOUS) {
 437         /* Would have done something above if connected */
 438         notify_conn(pconn->self, NULL, E_CHAT_ERROR, ftc_server,
 439                     _("%s is not connected."), player_name(pdest));
 440         return;
 441       }
 442     }
 443     /* Didn't match; check heuristics to see if this is likely
 444      * to be a global message
 445      */
 446     cpblank = strchr(real_message, ' ');
 447     if (!cpblank || (cp < cpblank)) {
 448       if (double_colon) {
 449         notify_conn(pconn->self, NULL, E_CHAT_ERROR, ftc_server,
 450                     _("There is no connection by the name %s."), name);
 451       } else {
 452         notify_conn(pconn->self, NULL, E_CHAT_ERROR, ftc_server,
 453                     _("There is no player nor connection by the name %s."),
 454                     name);
 455       }
 456       return;
 457     }
 458   }
 459   /* global message: */
 460   chat_msg_to_all(pconn, real_message);
 461 }