libpurple/cmds.c

   1 /**
   2  * @file cmds.c Commands API
   3  * @ingroup core
   4  */
   5
   6 /* Copyright (C) 2003-2004 Timothy Ringenbach <omarvo@hotmail.com
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  *
  22  */
  23
  24 #include "internal.h"
  25
  26 #include "account.h"
  27 #include "util.h"
  28 #include "cmds.h"
  29
  30 static PurpleCommandsUiOps *cmds_ui_ops = NULL;
  31 static GList *cmds = NULL;
  32 static guint next_id = 1;
  33
  34 struct _PurpleCmd {
  35         PurpleCmdId id;
  36         gchar *cmd;
  37         gchar *args;
  38         PurpleCmdPriority priority;
  39         PurpleCmdFlag flags;
  40         gchar *prpl_id;
  41         PurpleCmdFunc func;
  42         gchar *help;
  43         void *data;
  44 };
  45
  46
  47 static gint cmds_compare_func(const PurpleCmd *a, const PurpleCmd *b)
  48 {
  49         if (a->priority > b->priority)
  50                 return -1;
  51         else if (a->priority < b->priority)
  52                 return 1;
  53         else return 0;
  54 }
  55
  56 PurpleCmdId purple_cmd_register(const gchar *cmd, const gchar *args,
  57                             PurpleCmdPriority p, PurpleCmdFlag f,
  58                             const gchar *prpl_id, PurpleCmdFunc func,
  59                             const gchar *helpstr, void *data)
  60 {
  61         PurpleCmdId id;
  62         PurpleCmd *c;
  63         PurpleCommandsUiOps *ops;
  64
  65         g_return_val_if_fail(cmd != NULL && *cmd != '\0', 0);
  66         g_return_val_if_fail(args != NULL, 0);
  67         g_return_val_if_fail(func != NULL, 0);
  68
  69         id = next_id++;
  70
  71         c = g_new0(PurpleCmd, 1);
  72         c->id = id;
  73         c->cmd = g_strdup(cmd);
  74         c->args = g_strdup(args);
  75         c->priority = p;
  76         c->flags = f;
  77         c->prpl_id = g_strdup(prpl_id);
  78         c->func = func;
  79         c->help = g_strdup(helpstr);
  80         c->data = data;
  81
  82         cmds = g_list_insert_sorted(cmds, c, (GCompareFunc)cmds_compare_func);
  83
  84         ops = purple_cmds_get_ui_ops();
  85         if (ops && ops->register_command)
  86                 ops->register_command(cmd, p, f, prpl_id, helpstr, c);
  87
  88         purple_signal_emit(purple_cmds_get_handle(), "cmd-added", cmd, p, f);
  89
  90         return id;
  91 }
  92
  93 static void purple_cmd_free(PurpleCmd *c)
  94 {
  95         g_free(c->cmd);
  96         g_free(c->args);
  97         g_free(c->prpl_id);
  98         g_free(c->help);
  99         g_free(c);
 100 }
 101
 102 void purple_cmd_unregister(PurpleCmdId id)
 103 {
 104         PurpleCmd *c;
 105         GList *l;
 106
 107         for (l = cmds; l; l = l->next) {
 108                 c = l->data;
 109
 110                 if (c->id == id) {
 111                         PurpleCommandsUiOps *ops = purple_cmds_get_ui_ops();
 112                         if (ops && ops->unregister_command)
 113                                 ops->unregister_command(c->cmd, c->prpl_id);
 114
 115                         cmds = g_list_remove(cmds, c);
 116                         purple_signal_emit(purple_cmds_get_handle(), "cmd-removed", c->cmd);
 117                         purple_cmd_free(c);
 118                         return;
 119                 }
 120         }
 121 }
 122
 123 /**
 124  * This sets args to a NULL-terminated array of strings.  It should
 125  * be freed using g_strfreev().
 126  */
 127 static gboolean purple_cmd_parse_args(PurpleCmd *cmd, const gchar *s, const gchar *m, gchar ***args)
 128 {
 129         int i;
 130         const char *end, *cur;
 131
 132         *args = g_new0(char *, strlen(cmd->args) + 1);
 133
 134         cur = s;
 135
 136         for (i = 0; cmd->args[i]; i++) {
 137                 if (!*cur)
 138                         return (cmd->flags & PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS);
 139
 140                 switch (cmd->args[i]) {
 141                 case 'w':
 142                         if (!(end = strchr(cur, ' '))) {
 143                           end = cur + strlen(cur);
 144                           (*args)[i] = g_strndup(cur, end - cur);
 145                           cur = end;
 146                         } else {
 147                           (*args)[i] = g_strndup(cur, end - cur);
 148                           cur = end + 1;
 149                         }
 150                         break;
 151                 case 'W':
 152                         if (!(end = strchr(cur, ' '))) {
 153                           end = cur + strlen(cur);
 154                           (*args)[i] = purple_markup_slice(m, g_utf8_pointer_to_offset(s, cur), g_utf8_pointer_to_offset(s, end));
 155                           cur = end;
 156                         } else {
 157                           (*args)[i] = purple_markup_slice(m, g_utf8_pointer_to_offset(s, cur), g_utf8_pointer_to_offset(s, end));
 158                           cur = end +1;
 159                         }
 160                         break;
 161                 case 's':
 162                         (*args)[i] = g_strdup(cur);
 163                         cur = cur + strlen(cur);
 164                         break;
 165                 case 'S':
 166                         (*args)[i] = purple_markup_slice(m, g_utf8_pointer_to_offset(s, cur), g_utf8_strlen(cur, -1) + 1);
 167                         cur = cur + strlen(cur);
 168                         break;
 169                 }
 170         }
 171
 172         if (*cur)
 173                 return (cmd->flags & PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS);
 174
 175         return TRUE;
 176 }
 177
 178 static void purple_cmd_strip_current_char(gunichar c, char *s, guint len)
 179 {
 180         int bytes;
 181
 182         bytes = g_unichar_to_utf8(c, NULL);
 183         memmove(s, s + bytes, len + 1 - bytes);
 184 }
 185
 186 static void purple_cmd_strip_cmd_from_markup(char *markup)
 187 {
 188         guint len = strlen(markup);
 189         char *s = markup;
 190
 191         while (*s) {
 192                 gunichar c = g_utf8_get_char(s);
 193
 194                 if (c == '<') {
 195                         s = strchr(s, '>');
 196                         if (!s)
 197                                 return;
 198                 } else if (g_unichar_isspace(c)) {
 199                         purple_cmd_strip_current_char(c, s, len - (s - markup));
 200                         return;
 201                 } else {
 202                         purple_cmd_strip_current_char(c, s, len - (s - markup));
 203                         continue;
 204                 }
 205                 s = g_utf8_next_char(s);
 206         }
 207 }
 208
 209 PurpleCmdStatus purple_cmd_do_command(PurpleConversation *conv, const gchar *cmdline,
 210                                   const gchar *markup, gchar **error)
 211 {
 212         PurpleCmd *c;
 213         GList *l;
 214         gchar *err = NULL;
 215         gboolean is_im;
 216         gboolean found = FALSE, tried_cmd = FALSE, right_type = FALSE, right_prpl = FALSE;
 217         const gchar *prpl_id;
 218         gchar **args = NULL;
 219         gchar *cmd, *rest, *mrest;
 220         PurpleCmdRet ret = PURPLE_CMD_RET_CONTINUE;
 221
 222         *error = NULL;
 223         prpl_id = purple_account_get_protocol_id(purple_conversation_get_account(conv));
 224
 225         if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM)
 226                 is_im = TRUE;
 227         else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT)
 228                 is_im = FALSE;
 229         else
 230                 return PURPLE_CMD_STATUS_FAILED;
 231
 232         rest = strchr(cmdline, ' ');
 233         if (rest) {
 234                 cmd = g_strndup(cmdline, rest - cmdline);
 235                 rest++;
 236         } else {
 237                 cmd = g_strdup(cmdline);
 238                 rest = "";
 239         }
 240
 241         mrest = g_strdup(markup);
 242         purple_cmd_strip_cmd_from_markup(mrest);
 243
 244         for (l = cmds; l; l = l->next) {
 245                 c = l->data;
 246
 247                 if (!purple_strequal(c->cmd, cmd))
 248                         continue;
 249
 250                 found = TRUE;
 251
 252                 if (is_im)
 253                         if (!(c->flags & PURPLE_CMD_FLAG_IM))
 254                                 continue;
 255                 if (!is_im)
 256                         if (!(c->flags & PURPLE_CMD_FLAG_CHAT))
 257                                 continue;
 258
 259                 right_type = TRUE;
 260
 261                 if ((c->flags & PURPLE_CMD_FLAG_PRPL_ONLY) &&
 262                     !purple_strequal(c->prpl_id, prpl_id))
 263                         continue;
 264
 265                 right_prpl = TRUE;
 266
 267                 /* this checks the allow bad args flag for us */
 268                 if (!purple_cmd_parse_args(c, rest, mrest, &args)) {
 269                         g_strfreev(args);
 270                         args = NULL;
 271                         continue;
 272                 }
 273
 274                 tried_cmd = TRUE;
 275                 ret = c->func(conv, cmd, args, &err, c->data);
 276                 if (ret == PURPLE_CMD_RET_CONTINUE) {
 277                         g_free(err);
 278                         err = NULL;
 279                         g_strfreev(args);
 280                         args = NULL;
 281                         continue;
 282                 } else {
 283                         break;
 284                 }
 285
 286         }
 287
 288         g_strfreev(args);
 289         g_free(cmd);
 290         g_free(mrest);
 291
 292         if (!found)
 293                 return PURPLE_CMD_STATUS_NOT_FOUND;
 294
 295         if (!right_type)
 296                 return PURPLE_CMD_STATUS_WRONG_TYPE;
 297         if (!right_prpl)
 298                 return PURPLE_CMD_STATUS_WRONG_PRPL;
 299         if (!tried_cmd)
 300                 return PURPLE_CMD_STATUS_WRONG_ARGS;
 301
 302         if (ret == PURPLE_CMD_RET_OK) {
 303                 return PURPLE_CMD_STATUS_OK;
 304         } else {
 305                 *error = err;
 306                 if (ret == PURPLE_CMD_RET_CONTINUE)
 307                         return PURPLE_CMD_STATUS_NOT_FOUND;
 308                 else
 309                         return PURPLE_CMD_STATUS_FAILED;
 310         }
 311
 312 }
 313
 314 gboolean purple_cmd_execute(PurpleCmd *c, PurpleConversation *conv,
 315                             const gchar *cmdline)
 316 {
 317         gchar *err = NULL;
 318         gchar **args = NULL;
 319         PurpleCmdRet ret = PURPLE_CMD_RET_CONTINUE;
 320
 321         if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 322                 if (!(c->flags & PURPLE_CMD_FLAG_IM))
 323                         return FALSE;
 324         }
 325         else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
 326                 if (!(c->flags & PURPLE_CMD_FLAG_CHAT))
 327                         return FALSE;
 328         }
 329         else
 330                 return FALSE;
 331
 332         /* XXX: Don't worry much about the markup version of the command
 333            line, there's not a single use case... */
 334         /* this checks the allow bad args flag for us */
 335         if (!purple_cmd_parse_args(c, cmdline, cmdline, &args)) {
 336                 g_strfreev(args);
 337                 return FALSE;
 338         }
 339
 340         ret = c->func(conv, c->cmd, args, &err, c->data);
 341
 342         g_free(err);
 343         g_strfreev(args);
 344
 345         return ret == PURPLE_CMD_RET_OK;
 346 }
 347
 348 GList *purple_cmd_list(PurpleConversation *conv)
 349 {
 350         GList *ret = NULL;
 351         PurpleCmd *c;
 352         GList *l;
 353
 354         for (l = cmds; l; l = l->next) {
 355                 c = l->data;
 356
 357                 if (conv && (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM))
 358                         if (!(c->flags & PURPLE_CMD_FLAG_IM))
 359                                 continue;
 360                 if (conv && (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT))
 361                         if (!(c->flags & PURPLE_CMD_FLAG_CHAT))
 362                                 continue;
 363
 364                 if (conv && (c->flags & PURPLE_CMD_FLAG_PRPL_ONLY) &&
 365                     !purple_strequal(c->prpl_id, purple_account_get_protocol_id(purple_conversation_get_account(conv))))
 366                         continue;
 367
 368                 ret = g_list_append(ret, c->cmd);
 369         }
 370
 371         ret = g_list_sort(ret, (GCompareFunc)strcmp);
 372
 373         return ret;
 374 }
 375
 376
 377 GList *purple_cmd_help(PurpleConversation *conv, const gchar *cmd)
 378 {
 379         GList *ret = NULL;
 380         PurpleCmd *c;
 381         GList *l;
 382
 383         for (l = cmds; l; l = l->next) {
 384                 c = l->data;
 385
 386                 if (cmd && !purple_strequal(cmd, c->cmd))
 387                         continue;
 388
 389                 if (conv && (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM))
 390                         if (!(c->flags & PURPLE_CMD_FLAG_IM))
 391                                 continue;
 392                 if (conv && (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT))
 393                         if (!(c->flags & PURPLE_CMD_FLAG_CHAT))
 394                                 continue;
 395
 396                 if (conv && (c->flags & PURPLE_CMD_FLAG_PRPL_ONLY) &&
 397                     !purple_strequal(c->prpl_id, purple_account_get_protocol_id(purple_conversation_get_account(conv))))
 398                         continue;
 399
 400                 ret = g_list_append(ret, c->help);
 401         }
 402
 403         ret = g_list_sort(ret, (GCompareFunc)strcmp);
 404
 405         return ret;
 406 }
 407
 408 gpointer purple_cmds_get_handle(void)
 409 {
 410         static int handle;
 411         return &handle;
 412 }
 413
 414 void
 415 purple_cmds_set_ui_ops(PurpleCommandsUiOps *ops)
 416 {
 417         cmds_ui_ops = ops;
 418 }
 419
 420 PurpleCommandsUiOps *
 421 purple_cmds_get_ui_ops(void)
 422 {
 423         /* It is perfectly acceptable for cmds_ui_ops to be NULL; this just
 424          * means that the default libpurple implementation will be used.
 425          */
 426         return cmds_ui_ops;
 427 }
 428
 429 void purple_cmds_init(void)
 430 {
 431         gpointer handle = purple_cmds_get_handle();
 432
 433         purple_signal_register(handle, "cmd-added",
 434                         purple_marshal_VOID__POINTER_INT_INT, NULL, 3,
 435                         purple_value_new(PURPLE_TYPE_STRING),
 436                         purple_value_new(PURPLE_TYPE_INT),
 437                         purple_value_new(PURPLE_TYPE_INT));
 438         purple_signal_register(handle, "cmd-removed",
 439                         purple_marshal_VOID__POINTER, NULL, 1,
 440                         purple_value_new(PURPLE_TYPE_STRING));
 441 }
 442
 443 void purple_cmds_uninit(void)
 444 {
 445         purple_signals_unregister_by_instance(purple_cmds_get_handle());
 446 }
 447