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 (! lm_connection_close (lg->connection, &error))
  37         g_print ("An error occurred during lm_connection_close: %s\n",
  38                  error->message);
  39
  40     lm_connection_unref (lg->connection);
  41
  42     g_main_loop_quit (lg->main_loop);
  43 }
  44
  45 static void
  46 authentication_cb (LmConnection *connection, gboolean result, gpointer closure)
  47 {
  48     LmMessage *m;
  49     loudgame_t *lg = closure;
  50
  51     if (! result) {
  52         g_print ("Authentication for %s failed\n", lg->name);
  53         loudgame_quit (lg, 1);
  54         return;
  55     }
  56
  57     m = lm_message_new_with_sub_type (NULL,
  58                                       LM_MESSAGE_TYPE_PRESENCE,
  59                                       LM_MESSAGE_SUB_TYPE_AVAILABLE);
  60
  61     lm_connection_send (connection, m, NULL);
  62     lm_message_unref (m);
  63 }
  64
  65 static void
  66 connection_open_cb (LmConnection *connection, gboolean result, loudgame_t *lg)
  67 {
  68     lm_connection_authenticate (connection,
  69                                 lg->name, lg->passwd, "TestLM",
  70                                 authentication_cb, lg, FALSE,  NULL);
  71 }
  72
  73 void
  74 loudgame_send (loudgame_t       *lg,
  75                const char       *peer,
  76                const char       *message)
  77 {
  78     LmMessage *reply;
  79     gboolean result;
  80     GError *error = NULL;
  81
  82     reply = lm_message_new (peer, LM_MESSAGE_TYPE_MESSAGE);
  83
  84     lm_message_node_add_child (reply->node, "body", message);
  85
  86     result = lm_connection_send (lg->connection, reply, &error);
  87     lm_message_unref (reply);
  88
  89     if (! result) {
  90         g_error ("lm_connection_send failed: %s\n",
  91                  error->message);
  92         loudgame_quit (lg, 1);
  93     }
  94 }
  95
  96 static void
  97 handle_command (LmConnection    *connection,
  98                 const char      *peer,
  99                 const char      *command,
 100                 loudgame_t      *lg)
 101 {
 102     char *error;
 103
 104     if (strcmp (command, "quit") == 0) {
 105         loudgame_quit (lg, 0);
 106         return;
 107     }
 108
 109     error = g_strdup_printf ("Unknown command: '%s'", command);
 110     loudgame_send (lg, peer, error);
 111     free (error);
 112 }
 113
 114 static LmHandlerResult
 115 handle_messages (LmMessageHandler *handler,
 116                  LmConnection     *connection,
 117                  LmMessage        *m,
 118                  gpointer          closure)
 119 {
 120     loudgame_t *lg = closure;
 121     LmMessageNode *body;
 122     const char *peer;
 123     const char *body_str;
 124
 125     peer = lm_message_node_get_attribute (m->node, "from");
 126
 127     body = lm_message_node_get_child (m->node, "body");
 128     if (body) {
 129         body_str = lm_message_node_get_value (body);
 130
 131         if (body_str && body_str[0] == '%')
 132             handle_command (connection, peer, body_str + 1, lg);
 133         else if (lg->handle_message)
 134             (lg->handle_message) (lg, peer, body_str);
 135     }
 136
 137     return LM_HANDLER_RESULT_REMOVE_MESSAGE;
 138 }
 139
 140 static gboolean
 141 make_connection (gpointer closure)
 142 {
 143     loudgame_t       *lg;
 144     LmMessageHandler *handler;
 145     gchar            *jid;
 146     GError           *error = NULL;
 147
 148     lg = closure;
 149
 150     lg->connection = lm_connection_new (lg->server);
 151
 152     jid = g_strdup_printf ("%s@%s", lg->name, lg->server);
 153     lm_connection_set_jid (lg->connection, jid);
 154     g_free (jid);
 155
 156     handler = lm_message_handler_new (handle_messages, lg, NULL);
 157     lm_connection_register_message_handler (lg->connection,
 158                                             handler,
 159                                             LM_MESSAGE_TYPE_MESSAGE,
 160                                             LM_HANDLER_PRIORITY_NORMAL);
 161
 162     lm_message_handler_unref (handler);
 163
 164     if (! lm_connection_open (lg->connection,
 165                               (LmResultFunction) connection_open_cb,
 166                               lg, NULL, &error))
 167     {
 168         g_print ("Failed to open connection to %s: %s.\n",
 169                  lg->server, error->message);
 170         loudgame_quit (lg, 1);
 171     }
 172
 173     /* Return false to not schedule another call. */
 174     return 0;
 175 }
 176
 177 int
 178 loudgame_init (loudgame_t *lg, int argc, char **argv)
 179 {
 180     if (argc != 4) {
 181         g_print ("Usage: %s <server> <username> <password>\n", argv[0]);
 182         return 1;
 183     }
 184
 185     lg->server = argv[1];
 186     lg->name = argv[2];
 187     lg->passwd = argv[3];
 188
 189     lg->connection = NULL;
 190
 191     lg->main_loop = g_main_loop_new (NULL, FALSE);
 192
 193     lg->return_value = 0;
 194
 195     lg->handle_message = NULL;
 196
 197     return 0;
 198 }
 199
 200 int
 201 loudgame_run (loudgame_t *lg)
 202 {
 203     g_idle_add (make_connection, lg);
 204
 205     g_main_loop_run (lg->main_loop);
 206
 207     g_main_loop_unref (lg->main_loop);
 208
 209     return lg->return_value;
 210 }