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 static void
 132 handle_command (LmConnection    *connection,
 133                 const char      *peer,
 134                 const char      *command,
 135                 loudgame_t      *lg)
 136 {
 137     char *error;
 138
 139     if (strcmp (command, "quit") == 0) {
 140         loudgame_quit (lg, 0);
 141         return;
 142     }
 143
 144     error = g_strdup_printf ("Unknown command: '%s'", command);
 145     loudgame_send (lg, peer, error);
 146     free (error);
 147 }
 148
 149 static LmHandlerResult
 150 handle_messages (LmMessageHandler *handler,
 151                  LmConnection     *connection,
 152                  LmMessage        *m,
 153                  gpointer          closure)
 154 {
 155     loudgame_t *lg = closure;
 156     LmMessageNode *body;
 157     const char *peer;
 158     const char *body_str;
 159
 160     peer = lm_message_node_get_attribute (m->node, "from");
 161
 162     body = lm_message_node_get_child (m->node, "body");
 163     if (body) {
 164         body_str = lm_message_node_get_value (body);
 165
 166         if (body_str && body_str[0] == '%')
 167             handle_command (connection, peer, body_str + 1, lg);
 168         else if (lg->handle_message)
 169             (lg->handle_message) (lg, peer, body_str);
 170     }
 171
 172     return LM_HANDLER_RESULT_REMOVE_MESSAGE;
 173 }
 174
 175 static gboolean
 176 make_connection (gpointer closure)
 177 {
 178     loudgame_t       *lg;
 179     LmMessageHandler *handler;
 180     gchar            *jid;
 181     GError           *error = NULL;
 182
 183     lg = closure;
 184
 185     lg->connection = lm_connection_new (lg->server);
 186
 187     jid = g_strdup_printf ("%s@%s", lg->name, lg->server);
 188     lm_connection_set_jid (lg->connection, jid);
 189     g_free (jid);
 190
 191     handler = lm_message_handler_new (handle_messages, lg, NULL);
 192     lm_connection_register_message_handler (lg->connection,
 193                                             handler,
 194                                             LM_MESSAGE_TYPE_MESSAGE,
 195                                             LM_HANDLER_PRIORITY_NORMAL);
 196
 197     lm_message_handler_unref (handler);
 198
 199     if (! lm_connection_open (lg->connection,
 200                               (LmResultFunction) connection_open_cb,
 201                               lg, NULL, &error))
 202     {
 203         g_print ("Failed to open connection to %s: %s.\n",
 204                  lg->server, error->message);
 205         loudgame_quit (lg, 1);
 206     }
 207
 208     /* It seems to be necessary to explicitly tell the server we're
 209      * still here. Let's see if one keep-alive every 60 seconds is
 210      * sufficient. */
 211     lm_connection_set_keep_alive_rate (lg->connection, 60);
 212
 213     /* Return false to not schedule another call. */
 214     return 0;
 215 }
 216
 217 int
 218 loudgame_init (loudgame_t *lg, int argc, char **argv)
 219 {
 220     if (argc != 4) {
 221         g_print ("Usage: %s <server> <username> <password>\n", argv[0]);
 222         return 1;
 223     }
 224
 225     lg->server = argv[1];
 226     lg->name = argv[2];
 227     lg->passwd = argv[3];
 228
 229     lg->connection = NULL;
 230
 231     lg->main_loop = g_main_loop_new (NULL, FALSE);
 232
 233     lg->return_value = 0;
 234
 235     lg->handle_message = NULL;
 236
 237     return 0;
 238 }
 239
 240 int
 241 loudgame_run (loudgame_t *lg)
 242 {
 243     g_idle_add (make_connection, lg);
 244
 245     g_main_loop_run (lg->main_loop);
 246
 247     g_main_loop_unref (lg->main_loop);
 248
 249     return lg->return_value;
 250 }