git.cworth.org Git - loudgame/blob - loudgame.c

   1 /*
   2  * Copyright (C) 2003-2004 Imendio AB
   3  * Copyright (C) 2008 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 3 of the License, or
   8  * (at your option) 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, see http://www.gnu.org/licenses/ .
  17  *
  18  * Authors: Imendio AB
  19  *          Carl Worth <cworth@cworth.org>
  20  */
  21
  22 #include "loudgame.h"
  23
  24 #include <glib.h>
  25 #include <string.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 void
  30 loudgame_quit (loudgame_t *lg, int return_value)
  31 {
  32     GError *error = NULL;
  33
  34     lg->return_value = return_value;
  35
  36     if (lg->connection)
  37     {
  38         if (! lm_connection_close (lg->connection, &error))
  39         {
  40             g_print ("An error occurred during lm_connection_close: %s\n",
  41                      error->message);
  42         }
  43         lm_connection_unref (lg->connection);
  44         lg->connection = NULL;
  45     }
  46
  47     g_main_loop_quit (lg->main_loop);
  48 }
  49
  50 static void
  51 authentication_cb (LmConnection *connection, gboolean result, gpointer closure)
  52 {
  53     LmMessage *m;
  54     loudgame_t *lg = closure;
  55
  56     if (! result) {
  57         g_print ("Authentication for %s failed\n", lg->name);
  58         loudgame_quit (lg, 1);
  59         return;
  60     }
  61
  62     m = lm_message_new_with_sub_type (NULL,
  63                                       LM_MESSAGE_TYPE_PRESENCE,
  64                                       LM_MESSAGE_SUB_TYPE_AVAILABLE);
  65
  66     lm_connection_send (connection, m, NULL);
  67     lm_message_unref (m);
  68 }
  69
  70 static void
  71 connection_open_cb (LmConnection *connection, gboolean result, loudgame_t *lg)
  72 {
  73     lm_connection_authenticate (connection,
  74                                 lg->name, lg->passwd, "TestLM",
  75                                 authentication_cb, lg, FALSE,  NULL);
  76 }
  77
  78 void
  79 loudgame_send (loudgame_t       *lg,
  80                const char       *peer,
  81                const char       *message)
  82 {
  83     LmMessage *reply;
  84     gboolean result;
  85     GError *error = NULL;
  86
  87     reply = lm_message_new (peer, LM_MESSAGE_TYPE_MESSAGE);
  88
  89     lm_message_node_add_child (reply->node, "body", message);
  90
  91     result = lm_connection_send (lg->connection, reply, &error);
  92     lm_message_unref (reply);
  93
  94     if (! result) {
  95         g_error ("lm_connection_send failed: %s\n",
  96                  error->message);
  97         loudgame_quit (lg, 1);
  98     }
  99 }
 100
 101 void
 102 loudgame_vsendf (loudgame_t     *lg,
 103                  const char     *peer,
 104                  const char     *format,
 105                  va_list         va)
 106 {
 107     char *str;
 108
 109     str = g_strdup_vprintf (format, va);
 110
 111     loudgame_send (lg, peer, str);
 112
 113     free (str);
 114 }
 115
 116 void
 117 loudgame_sendf (loudgame_t      *lg,
 118                 const char      *peer,
 119                 const char      *format,
 120                 ...)
 121 {
 122     va_list va;
 123
 124     va_start (va, format);
 125
 126     loudgame_vsendf (lg, peer, format, va);
 127
 128     va_end (va);
 129 }
 130
 131 typedef struct _loudgame_broadcast_data
 132 {
 133     loudgame_t *lg;
 134     const char *message;
 135 } loudgame_broadcast_data_t;
 136
 137 static void
 138 loudgame_broadcast_cb (void *key,
 139                        void *data,
 140                        void *closure)
 141 {
 142     loudgame_broadcast_data_t *lbd = closure;
 143     char *peer = key;
 144
 145     loudgame_send (lbd->lg, peer, lbd->message);
 146 }
 147
 148 void
 149 loudgame_broadcast (loudgame_t *lg,
 150                     const char *message)
 151 {
 152     loudgame_broadcast_data_t lbd;
 153
 154     lbd.lg = lg;
 155     lbd.message = message;
 156
 157     g_hash_table_foreach (lg->players,
 158                           loudgame_broadcast_cb, &lbd);
 159 }
 160
 161 void
 162 loudgame_vbroadcastf (loudgame_t *lg,
 163                       const char *format,
 164                       va_list     va)
 165 {
 166     char *str;
 167
 168     str = g_strdup_vprintf (format, va);
 169
 170     loudgame_broadcast (lg, str);
 171
 172     free (str);
 173 }
 174
 175 void
 176 loudgame_broadcastf (loudgame_t *lg,
 177                      const char *format,
 178                      ...)
 179 {
 180     va_list va;
 181
 182     va_start (va,format);
 183
 184     loudgame_vbroadcastf (lg, format, va);
 185
 186     va_end (va);
 187 }
 188
 189 static void
 190 handle_command (LmConnection    *connection,
 191                 const char      *peer,
 192                 const char      *command,
 193                 loudgame_t      *lg)
 194 {
 195     char *error;
 196
 197     if (strcmp (command, "quit") == 0) {
 198         loudgame_quit (lg, 0);
 199         return;
 200     }
 201
 202     error = g_strdup_printf ("Unknown command: '%s'", command);
 203     loudgame_send (lg, peer, error);
 204     free (error);
 205 }
 206
 207 static LmHandlerResult
 208 handle_messages (LmMessageHandler *handler,
 209                  LmConnection     *connection,
 210                  LmMessage        *m,
 211                  gpointer          closure)
 212 {
 213     loudgame_t *lg = closure;
 214     LmMessageNode *body;
 215     const char *peer;
 216     const char *body_str;
 217
 218     peer = lm_message_node_get_attribute (m->node, "from");
 219
 220     body = lm_message_node_get_child (m->node, "body");
 221     if (! body)
 222         return LM_HANDLER_RESULT_REMOVE_MESSAGE;
 223
 224     if (! g_hash_table_lookup_extended (lg->players, peer,
 225                                         NULL, NULL))
 226     {
 227         char *peer_copy = g_strdup (peer);
 228         g_hash_table_insert (lg->players, peer_copy, NULL);
 229         loudgame_broadcastf (lg, "%s has joined the game", peer);
 230     }
 231
 232     body_str = lm_message_node_get_value (body);
 233
 234     if (body_str && body_str[0] == '%')
 235         handle_command (connection, peer, body_str + 1, lg);
 236     else if (lg->handle_message)
 237         (lg->handle_message) (lg, peer, body_str);
 238
 239     return LM_HANDLER_RESULT_REMOVE_MESSAGE;
 240 }
 241
 242 static gboolean
 243 make_connection (gpointer closure)
 244 {
 245     loudgame_t       *lg;
 246     LmMessageHandler *handler;
 247     gchar            *jid;
 248     GError           *error = NULL;
 249
 250     lg = closure;
 251
 252     lg->connection = lm_connection_new (lg->server);
 253
 254     jid = g_strdup_printf ("%s@%s", lg->name, lg->server);
 255     lm_connection_set_jid (lg->connection, jid);
 256     g_free (jid);
 257
 258     handler = lm_message_handler_new (handle_messages, lg, NULL);
 259     lm_connection_register_message_handler (lg->connection,
 260                                             handler,
 261                                             LM_MESSAGE_TYPE_MESSAGE,
 262                                             LM_HANDLER_PRIORITY_NORMAL);
 263
 264     lm_message_handler_unref (handler);
 265
 266     if (! lm_connection_open (lg->connection,
 267                               (LmResultFunction) connection_open_cb,
 268                               lg, NULL, &error))
 269     {
 270         g_print ("Failed to open connection to %s: %s.\n",
 271                  lg->server, error->message);
 272         loudgame_quit (lg, 1);
 273     }
 274
 275     /* It seems to be necessary to explicitly tell the server we're
 276      * still here. Let's see if one keep-alive every 60 seconds is
 277      * sufficient. */
 278     lm_connection_set_keep_alive_rate (lg->connection, 60);
 279
 280     /* Return false to not schedule another call. */
 281     return 0;
 282 }
 283
 284 int
 285 loudgame_init (loudgame_t *lg, int argc, char **argv)
 286 {
 287     if (argc != 4) {
 288         g_print ("Usage: %s <server> <username> <password>\n", argv[0]);
 289         return 1;
 290     }
 291
 292     lg->server = argv[1];
 293     lg->name = argv[2];
 294     lg->passwd = argv[3];
 295
 296     lg->connection = NULL;
 297
 298     lg->main_loop = g_main_loop_new (NULL, FALSE);
 299     lg->players = g_hash_table_new_full (g_str_hash, g_str_equal,
 300                                          g_free, /* key_destroy */
 301                                          NULL    /*value_destroy */);
 302
 303     lg->return_value = 0;
 304
 305     lg->handle_message = NULL;
 306
 307     return 0;
 308 }
 309
 310 static void
 311 loudgame_fini (loudgame_t *lg)
 312 {
 313     g_main_loop_unref (lg->main_loop);
 314     g_hash_table_destroy (lg->players);
 315 }
 316
 317 int
 318 loudgame_run (loudgame_t *lg)
 319 {
 320     g_idle_add (make_connection, lg);
 321
 322     g_main_loop_run (lg->main_loop);
 323
 324     loudgame_fini (lg);
 325
 326     return lg->return_value;
 327 }