git.cworth.org Git - ttt/blob - src/ttt-server.c

   1 /* ttt-server.c - tic-tac-toe game server
   2  *
   3  * Copyright © 2005 Carl Worth
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  *
  19  * Author: Carl Worth <cworth@cworth.org>
  20  */
  21
  22 #include "ttt-server.h"
  23
  24 #include "ttt-args.h"
  25 #include "ttt-client.h"
  26 #include "ttt-error.h"
  27 #include "ttt-socket.h"
  28
  29 struct _ttt_server {
  30     pthread_mutex_t mutex;
  31
  32     const char *host;
  33     const char *port;
  34
  35     ttt_client_t **clients;
  36     int clients_size;
  37     int num_clients;
  38 };
  39
  40 static void
  41 ttt_server_init (ttt_server_t *server, const char *host, const char *port)
  42 {
  43     pthread_mutex_init (&server->mutex, NULL);
  44
  45     server->host = host;
  46     server->port = port;
  47
  48     server->clients = NULL;
  49     server->clients_size = 0;
  50     server->num_clients = 0;
  51 }
  52
  53 /* Exported: See ttt-server.h for documentation. */
  54 ttt_error_t
  55 ttt_server_register_client (ttt_server_t *server, ttt_client_t *client)
  56 {
  57     int i;
  58     ttt_error_t error = TTT_ERROR_NONE;
  59     const char *username;
  60
  61     pthread_mutex_lock (&server->mutex);
  62
  63     username = ttt_client_get_username (client);
  64
  65     assert (username != NULL);
  66
  67     if (username[0] == '\0')
  68         return TTT_ERROR_INVALID_NAME;
  69
  70     for (i = 0; i < server->num_clients; i++) {
  71         if (strcmp (ttt_client_get_username (server->clients[i]), username) == 0) {
  72             error = TTT_ERROR_INVALID_NAME;
  73             goto CLEANUP_LOCK;
  74         }
  75     }
  76
  77     printf ("Client %s has joined.\r\n", username);
  78
  79     server->num_clients++;
  80
  81     if (server->num_clients > server->clients_size) {
  82         if (server->clients_size == 0)
  83             server->clients_size = 1;
  84         else
  85             server->clients_size *= 2;
  86
  87         server->clients = xrealloc (server->clients,
  88                                     server->clients_size * sizeof (ttt_client_t *));
  89     }
  90
  91     server->clients [server->num_clients - 1] = client;
  92
  93  CLEANUP_LOCK:
  94     pthread_mutex_unlock (&server->mutex);
  95
  96     return error;
  97 }
  98
  99 /* Exported: See ttt-server.h for documentation. */
 100 void
 101 ttt_server_unregister_client (ttt_server_t *server, ttt_client_t *client)
 102 {
 103     int i;
 104
 105     pthread_mutex_lock (&server->mutex);
 106
 107     for (i = 0; i < server->num_clients; i++)
 108         if (server->clients[i] == client)
 109             break;
 110
 111     assert (i < server->num_clients);
 112
 113     printf ("Client %s has left.\r\n", ttt_client_get_username (client));
 114
 115     memmove (&server->clients[i], &server->clients[i+1],
 116              (server->num_clients - i - 1) * sizeof (ttt_client_t *));
 117
 118     server->num_clients--;
 119
 120     pthread_mutex_unlock (&server->mutex);
 121 }
 122
 123 /* Exported: See ttt-server.h for documentation. */
 124 void
 125 ttt_server_broadcast (ttt_server_t *server, const char *message)
 126 {
 127     int i;
 128
 129     pthread_mutex_lock (&server->mutex);
 130
 131     for (i = 0; i < server->num_clients; i++)
 132         ttt_client_send (server->clients[i], message);
 133
 134     pthread_mutex_unlock (&server->mutex);
 135 }
 136
 137 /* Exported: See ttt-server.h for documentation. */
 138 const char*
 139 ttt_server_who (ttt_server_t *server)
 140 {
 141     int i;
 142     char *response;
 143
 144     pthread_mutex_lock (&server->mutex);
 145
 146     xasprintf (&response, "WHO");
 147
 148     for (i = 0; i < server->num_clients; i++)
 149         xasprintf (&response, "%s %s",
 150                    response,
 151                    ttt_client_get_username (server->clients[i]));
 152
 153     xasprintf (&response, "%s\r\n", response);
 154
 155     pthread_mutex_unlock (&server->mutex);
 156
 157     return response;
 158 }
 159
 160 /* Exported: See ttt-server.h for documentation. */
 161 ttt_error_t
 162 ttt_server_statistics (ttt_server_t *server, const char *username, char **response)
 163 {
 164     ttt_bool_t usernamefound = FALSE;
 165     char *client_username;
 166     int client_num_wins;
 167     int i;
 168
 169     pthread_mutex_lock (&server->mutex);
 170
 171     for (i = 0; i < server->num_clients; i++) {
 172         client_username = ttt_client_get_username (server->clients[i]);
 173         if (strcasecmp (username, client_username) == 0) {
 174             usernamefound = TRUE;
 175             client_num_wins = ttt_client_get_num_wins (server->clients[i]);
 176             xasprintf (response, "STATISTICS %s \"\r\n"
 177                        "TICTACTOE WINS %d\r\n\"\r\n",
 178                        client_username,
 179                        client_num_wins);
 180         }
 181     }
 182
 183     pthread_mutex_unlock (&server->mutex);
 184
 185     if (!usernamefound)
 186         return TTT_ERROR_NO_USER;
 187
 188     return TTT_ERROR_NONE;
 189 }
 190
 191 /* Exported: See ttt-server.h for documentation. */
 192 const char*
 193 ttt_server_get_host (ttt_server_t *server)
 194 {
 195     return server->host;
 196 }
 197
 198 /* Exported: See ttt-server.h for documentation. */
 199 const char*
 200 ttt_server_get_port (ttt_server_t *server)
 201 {
 202     return server->port;
 203 }
 204
 205 static const char *WELCOME_MESSAGE =
 206 "Welcome to ttt-server. The server is currently listening on:\r\n"
 207 "\r\n"
 208 "       %s:%s\r\n"
 209 "\r\n"
 210 "To test this, simply connect one or more clients to that host and port.\r\n"
 211 "For example:\r\n"
 212 "\r\n"
 213 "       telnet %s %s\r\n"
 214 "\r\n"
 215 "The TTTP (tic-tac-toe protocol) has been partially implemented.\r\n"
 216 "The following commands should work: HELO, HELP, MESSAGE, VERSION, QUIT, WHO.\r\n"
 217 "\r\n";
 218
 219 static void
 220 _ttt_server_accept (void *closure, int client_socket)
 221 {
 222     ttt_server_t *server = closure;
 223
 224     ttt_client_new (server, client_socket);
 225 }
 226
 227 int
 228 main (int argc, char **argv)
 229 {
 230     ttt_args_t args;
 231     ttt_server_t server;
 232     int socket;
 233
 234     ttt_args_parse (&args, argc, argv);
 235
 236     if (args.log_file)
 237         xfreopen (args.log_file, "a", stderr);
 238
 239     socket = ttt_socket_create_server (args.host, args.port);
 240
 241     printf (WELCOME_MESSAGE, args.host, args.port, args.host, args.port);
 242
 243     ttt_server_init (&server, args.host, args.port);
 244
 245     while (1)
 246         ttt_socket_accept (socket, _ttt_server_accept, &server);
 247
 248     /* We only reach here if something bad happened. */
 249     return 1;
 250 }