libpurple/protocols/jabber/xdata.c

   1 /*
   2  * purple - Jabber Protocol Plugin
   3  *
   4  * Purple is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   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 #include "internal.h"
  24 #include "request.h"
  25 #include "server.h"
  26
  27 #include "xdata.h"
  28
  29 typedef enum {
  30         JABBER_X_DATA_IGNORE = 0,
  31         JABBER_X_DATA_TEXT_SINGLE,
  32         JABBER_X_DATA_TEXT_MULTI,
  33         JABBER_X_DATA_LIST_SINGLE,
  34         JABBER_X_DATA_LIST_MULTI,
  35         JABBER_X_DATA_BOOLEAN,
  36         JABBER_X_DATA_JID_SINGLE
  37 } jabber_x_data_field_type;
  38
  39 struct jabber_x_data_data {
  40         GHashTable *fields;
  41         GSList *values;
  42         jabber_x_data_action_cb cb;
  43         gpointer user_data;
  44         JabberStream *js;
  45         GList *actions;
  46         PurpleRequestFieldGroup *actiongroup;
  47 };
  48
  49 static void jabber_x_data_ok_cb(struct jabber_x_data_data *data, PurpleRequestFields *fields) {
  50         PurpleXmlNode *result = purple_xmlnode_new("x");
  51         jabber_x_data_action_cb cb = data->cb;
  52         gpointer user_data = data->user_data;
  53         JabberStream *js = data->js;
  54         GList *groups, *flds;
  55         char *actionhandle = NULL;
  56         gboolean hasActions = (data->actions != NULL);
  57
  58         purple_xmlnode_set_namespace(result, "jabber:x:data");
  59         purple_xmlnode_set_attrib(result, "type", "submit");
  60
  61         for(groups = purple_request_fields_get_groups(fields); groups; groups = groups->next) {
  62                 if(groups->data == data->actiongroup) {
  63                         for(flds = purple_request_field_group_get_fields(groups->data); flds; flds = flds->next) {
  64                                 PurpleRequestField *field = flds->data;
  65                                 const char *id = purple_request_field_get_id(field);
  66                                 int handleindex;
  67                                 if(!purple_strequal(id, "libpurple:jabber:xdata:actions"))
  68                                         continue;
  69                                 handleindex = GPOINTER_TO_INT(purple_request_field_choice_get_value(field));
  70                                 actionhandle = g_strdup(g_list_nth_data(data->actions, handleindex));
  71                                 break;
  72                         }
  73                         continue;
  74                 }
  75                 for(flds = purple_request_field_group_get_fields(groups->data); flds; flds = flds->next) {
  76                         PurpleXmlNode *fieldnode, *valuenode;
  77                         PurpleRequestField *field = flds->data;
  78                         const char *id = purple_request_field_get_id(field);
  79                         jabber_x_data_field_type type = GPOINTER_TO_INT(g_hash_table_lookup(data->fields, id));
  80
  81                         switch(type) {
  82                                 case JABBER_X_DATA_TEXT_SINGLE:
  83                                 case JABBER_X_DATA_JID_SINGLE:
  84                                         {
  85                                         const char *value = purple_request_field_string_get_value(field);
  86                                         if (value == NULL)
  87                                                 break;
  88                                         fieldnode = purple_xmlnode_new_child(result, "field");
  89                                         purple_xmlnode_set_attrib(fieldnode, "var", id);
  90                                         valuenode = purple_xmlnode_new_child(fieldnode, "value");
  91                                         purple_xmlnode_insert_data(valuenode, value, -1);
  92                                         break;
  93                                         }
  94                                 case JABBER_X_DATA_TEXT_MULTI:
  95                                         {
  96                                         char **pieces, **p;
  97                                         const char *value = purple_request_field_string_get_value(field);
  98                                         if (value == NULL)
  99                                                 break;
 100                                         fieldnode = purple_xmlnode_new_child(result, "field");
 101                                         purple_xmlnode_set_attrib(fieldnode, "var", id);
 102
 103                                         pieces = g_strsplit(value, "\n", -1);
 104                                         for(p = pieces; *p != NULL; p++) {
 105                                                 valuenode = purple_xmlnode_new_child(fieldnode, "value");
 106                                                 purple_xmlnode_insert_data(valuenode, *p, -1);
 107                                         }
 108                                         g_strfreev(pieces);
 109                                         }
 110                                         break;
 111                                 case JABBER_X_DATA_LIST_SINGLE:
 112                                 case JABBER_X_DATA_LIST_MULTI:
 113                                         {
 114                                         GList *selected = purple_request_field_list_get_selected(field);
 115                                         char *value;
 116                                         fieldnode = purple_xmlnode_new_child(result, "field");
 117                                         purple_xmlnode_set_attrib(fieldnode, "var", id);
 118
 119                                         while(selected) {
 120                                                 value = purple_request_field_list_get_data(field, selected->data);
 121                                                 valuenode = purple_xmlnode_new_child(fieldnode, "value");
 122                                                 if(value)
 123                                                         purple_xmlnode_insert_data(valuenode, value, -1);
 124                                                 selected = selected->next;
 125                                         }
 126                                         }
 127                                         break;
 128                                 case JABBER_X_DATA_BOOLEAN:
 129                                         fieldnode = purple_xmlnode_new_child(result, "field");
 130                                         purple_xmlnode_set_attrib(fieldnode, "var", id);
 131                                         valuenode = purple_xmlnode_new_child(fieldnode, "value");
 132                                         if(purple_request_field_bool_get_value(field))
 133                                                 purple_xmlnode_insert_data(valuenode, "1", -1);
 134                                         else
 135                                                 purple_xmlnode_insert_data(valuenode, "0", -1);
 136                                         break;
 137                                 case JABBER_X_DATA_IGNORE:
 138                                         break;
 139                         }
 140                 }
 141         }
 142
 143         g_hash_table_destroy(data->fields);
 144         while(data->values) {
 145                 g_free(data->values->data);
 146                 data->values = g_slist_delete_link(data->values, data->values);
 147         }
 148         if (data->actions) {
 149                 GList *action;
 150                 for(action = data->actions; action; action = g_list_next(action)) {
 151                         g_free(action->data);
 152                 }
 153                 g_list_free(data->actions);
 154         }
 155         g_free(data);
 156
 157         if (hasActions)
 158                 cb(js, result, actionhandle, user_data);
 159         else
 160                 ((jabber_x_data_cb)cb)(js, result, user_data);
 161
 162         g_free(actionhandle);
 163 }
 164
 165 static void jabber_x_data_cancel_cb(struct jabber_x_data_data *data, PurpleRequestFields *fields) {
 166         PurpleXmlNode *result = purple_xmlnode_new("x");
 167         jabber_x_data_action_cb cb = data->cb;
 168         gpointer user_data = data->user_data;
 169         JabberStream *js = data->js;
 170         gboolean hasActions = FALSE;
 171         g_hash_table_destroy(data->fields);
 172         while(data->values) {
 173                 g_free(data->values->data);
 174                 data->values = g_slist_delete_link(data->values, data->values);
 175         }
 176         if (data->actions) {
 177                 GList *action;
 178                 hasActions = TRUE;
 179                 for(action = data->actions; action; action = g_list_next(action)) {
 180                         g_free(action->data);
 181                 }
 182                 g_list_free(data->actions);
 183         }
 184         g_free(data);
 185
 186         purple_xmlnode_set_namespace(result, "jabber:x:data");
 187         purple_xmlnode_set_attrib(result, "type", "cancel");
 188
 189         if (hasActions)
 190                 cb(js, result, NULL, user_data);
 191         else
 192                 ((jabber_x_data_cb)cb)(js, result, user_data);
 193 }
 194
 195 void *jabber_x_data_request(JabberStream *js, PurpleXmlNode *packet, jabber_x_data_cb cb, gpointer user_data)
 196 {
 197         return jabber_x_data_request_with_actions(js, packet, NULL, 0, (jabber_x_data_action_cb)cb, user_data);
 198 }
 199
 200 void *jabber_x_data_request_with_actions(JabberStream *js, PurpleXmlNode *packet, GList *actions, int defaultaction, jabber_x_data_action_cb cb, gpointer user_data)
 201 {
 202         void *handle;
 203         PurpleXmlNode *fn, *x;
 204         PurpleRequestFields *fields;
 205         PurpleRequestFieldGroup *group;
 206         PurpleRequestField *field = NULL;
 207
 208         char *title = NULL;
 209         char *instructions = NULL;
 210
 211         struct jabber_x_data_data *data = g_new0(struct jabber_x_data_data, 1);
 212
 213         data->fields = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 214         data->user_data = user_data;
 215         data->cb = cb;
 216         data->js = js;
 217
 218         fields = purple_request_fields_new();
 219         group = purple_request_field_group_new(NULL);
 220         purple_request_fields_add_group(fields, group);
 221
 222         for(fn = purple_xmlnode_get_child(packet, "field"); fn; fn = purple_xmlnode_get_next_twin(fn)) {
 223                 PurpleXmlNode *valuenode;
 224                 const char *type = purple_xmlnode_get_attrib(fn, "type");
 225                 const char *label = purple_xmlnode_get_attrib(fn, "label");
 226                 const char *var = purple_xmlnode_get_attrib(fn, "var");
 227                 char *value = NULL;
 228
 229                 if(!type)
 230                         type = "text-single";
 231
 232                 if(!var && !purple_strequal(type, "fixed"))
 233                         continue;
 234                 if(!label)
 235                         label = var;
 236
 237                 if(purple_strequal(type, "text-private")) {
 238                         if((valuenode = purple_xmlnode_get_child(fn, "value")))
 239                                 value = purple_xmlnode_get_data(valuenode);
 240
 241                         field = purple_request_field_string_new(var, label,
 242                                         value ? value : "", FALSE);
 243                         purple_request_field_string_set_masked(field, TRUE);
 244                         purple_request_field_group_add_field(group, field);
 245
 246                         g_hash_table_replace(data->fields, g_strdup(var), GINT_TO_POINTER(JABBER_X_DATA_TEXT_SINGLE));
 247
 248                         g_free(value);
 249                 } else if(purple_strequal(type, "text-multi") || purple_strequal(type, "jid-multi")) {
 250                         GString *str = g_string_new("");
 251
 252                         for(valuenode = purple_xmlnode_get_child(fn, "value"); valuenode;
 253                                         valuenode = purple_xmlnode_get_next_twin(valuenode)) {
 254
 255                                 if(!(value = purple_xmlnode_get_data(valuenode)))
 256                                         continue;
 257
 258                                 g_string_append_printf(str, "%s\n", value);
 259                                 g_free(value);
 260                         }
 261
 262                         field = purple_request_field_string_new(var, label,
 263                                         str->str, TRUE);
 264                         purple_request_field_group_add_field(group, field);
 265
 266                         g_hash_table_replace(data->fields, g_strdup(var), GINT_TO_POINTER(JABBER_X_DATA_TEXT_MULTI));
 267
 268                         g_string_free(str, TRUE);
 269                 } else if(purple_strequal(type, "list-single") || purple_strequal(type, "list-multi")) {
 270                         PurpleXmlNode *optnode;
 271                         GList *selected = NULL;
 272
 273                         field = purple_request_field_list_new(var, label);
 274
 275                         if(purple_strequal(type, "list-multi")) {
 276                                 purple_request_field_list_set_multi_select(field, TRUE);
 277                                 g_hash_table_replace(data->fields, g_strdup(var),
 278                                                 GINT_TO_POINTER(JABBER_X_DATA_LIST_MULTI));
 279                         } else {
 280                                 g_hash_table_replace(data->fields, g_strdup(var),
 281                                                 GINT_TO_POINTER(JABBER_X_DATA_LIST_SINGLE));
 282                         }
 283
 284                         for(valuenode = purple_xmlnode_get_child(fn, "value"); valuenode;
 285                                         valuenode = purple_xmlnode_get_next_twin(valuenode)) {
 286                                 char *data = purple_xmlnode_get_data(valuenode);
 287                                 if (data != NULL) {
 288                                         selected = g_list_prepend(selected, data);
 289                                 }
 290                         }
 291
 292                         for(optnode = purple_xmlnode_get_child(fn, "option"); optnode;
 293                                         optnode = purple_xmlnode_get_next_twin(optnode)) {
 294                                 const char *lbl;
 295
 296                                 if(!(valuenode = purple_xmlnode_get_child(optnode, "value")))
 297                                         continue;
 298
 299                                 if(!(value = purple_xmlnode_get_data(valuenode)))
 300                                         continue;
 301
 302                                 if(!(lbl = purple_xmlnode_get_attrib(optnode, "label")))
 303                                         lbl = value;
 304
 305                                 data->values = g_slist_prepend(data->values, value);
 306
 307                                 purple_request_field_list_add_icon(field, lbl, NULL, value);
 308                                 if(g_list_find_custom(selected, value, (GCompareFunc)strcmp))
 309                                         purple_request_field_list_add_selected(field, lbl);
 310                         }
 311                         purple_request_field_group_add_field(group, field);
 312
 313                         while(selected) {
 314                                 g_free(selected->data);
 315                                 selected = g_list_delete_link(selected, selected);
 316                         }
 317
 318                 } else if(purple_strequal(type, "boolean")) {
 319                         gboolean def = FALSE;
 320
 321                         if((valuenode = purple_xmlnode_get_child(fn, "value")))
 322                                 value = purple_xmlnode_get_data(valuenode);
 323
 324                         if(value && (!g_ascii_strcasecmp(value, "yes") ||
 325                                                 !g_ascii_strcasecmp(value, "true") || !g_ascii_strcasecmp(value, "1")))
 326                                 def = TRUE;
 327
 328                         field = purple_request_field_bool_new(var, label, def);
 329                         purple_request_field_group_add_field(group, field);
 330
 331                         g_hash_table_replace(data->fields, g_strdup(var), GINT_TO_POINTER(JABBER_X_DATA_BOOLEAN));
 332
 333                         g_free(value);
 334                 } else if(purple_strequal(type, "fixed")) {
 335                         if((valuenode = purple_xmlnode_get_child(fn, "value")))
 336                                 value = purple_xmlnode_get_data(valuenode);
 337
 338                         if(value != NULL) {
 339                                 field = purple_request_field_label_new("", value);
 340                                 purple_request_field_group_add_field(group, field);
 341
 342                                 g_free(value);
 343                         }
 344                 } else if(purple_strequal(type, "hidden")) {
 345                         if((valuenode = purple_xmlnode_get_child(fn, "value")))
 346                                 value = purple_xmlnode_get_data(valuenode);
 347
 348                         field = purple_request_field_string_new(var, "", value ? value : "",
 349                                         FALSE);
 350                         purple_request_field_set_visible(field, FALSE);
 351                         purple_request_field_group_add_field(group, field);
 352
 353                         g_hash_table_replace(data->fields, g_strdup(var), GINT_TO_POINTER(JABBER_X_DATA_TEXT_SINGLE));
 354
 355                         g_free(value);
 356                 } else { /* text-single, jid-single, and the default */
 357                         if((valuenode = purple_xmlnode_get_child(fn, "value")))
 358                                 value = purple_xmlnode_get_data(valuenode);
 359
 360                         field = purple_request_field_string_new(var, label,
 361                                         value ? value : "", FALSE);
 362                         purple_request_field_group_add_field(group, field);
 363
 364                         if(purple_strequal(type, "jid-single")) {
 365                                 purple_request_field_set_type_hint(field, "screenname");
 366                                 g_hash_table_replace(data->fields, g_strdup(var), GINT_TO_POINTER(JABBER_X_DATA_JID_SINGLE));
 367                         } else {
 368                                 g_hash_table_replace(data->fields, g_strdup(var), GINT_TO_POINTER(JABBER_X_DATA_TEXT_SINGLE));
 369                         }
 370
 371                         g_free(value);
 372                 }
 373
 374                 if(field && purple_xmlnode_get_child(fn, "required"))
 375                         purple_request_field_set_required(field,TRUE);
 376         }
 377
 378         if(actions != NULL) {
 379                 PurpleRequestField *actionfield;
 380                 GList *action;
 381                 int i;
 382
 383                 data->actiongroup = group = purple_request_field_group_new(_("Actions"));
 384                 purple_request_fields_add_group(fields, group);
 385                 actionfield = purple_request_field_choice_new("libpurple:jabber:xdata:actions", _("Select an action"), GINT_TO_POINTER(defaultaction));
 386                 purple_request_field_choice_set_data_destructor(actionfield, g_free);
 387
 388                 for(i = 0, action = actions; action; action = g_list_next(action), i++) {
 389                         JabberXDataAction *a = action->data;
 390
 391                         purple_request_field_choice_add(actionfield, a->name, GINT_TO_POINTER(i));
 392                         data->actions = g_list_append(data->actions, g_strdup(a->handle));
 393                 }
 394                 purple_request_field_set_required(actionfield,TRUE);
 395                 purple_request_field_group_add_field(group, actionfield);
 396         }
 397
 398         if((x = purple_xmlnode_get_child(packet, "title")))
 399                 title = purple_xmlnode_get_data(x);
 400
 401         if((x = purple_xmlnode_get_child(packet, "instructions")))
 402                 instructions = purple_xmlnode_get_data(x);
 403
 404         handle = purple_request_fields(js->gc, title, title, instructions, fields,
 405                         _("OK"), G_CALLBACK(jabber_x_data_ok_cb),
 406                         _("Cancel"), G_CALLBACK(jabber_x_data_cancel_cb),
 407                         purple_request_cpar_from_connection(js->gc),
 408                         data);
 409
 410         g_free(title);
 411         g_free(instructions);
 412
 413         return handle;
 414 }
 415
 416 gchar *
 417 jabber_x_data_get_formtype(const PurpleXmlNode *form)
 418 {
 419         PurpleXmlNode *field;
 420
 421         g_return_val_if_fail(form != NULL, NULL);
 422
 423         for (field = purple_xmlnode_get_child((PurpleXmlNode *)form, "field"); field;
 424                         field = purple_xmlnode_get_next_twin(field)) {
 425                 const char *var = purple_xmlnode_get_attrib(field, "var");
 426                 if (purple_strequal(var, "FORM_TYPE")) {
 427                         PurpleXmlNode *value = purple_xmlnode_get_child(field, "value");
 428                         if (value)
 429                                 return purple_xmlnode_get_data(value);
 430                         else
 431                                 /* An interesting corner case... Looking for a second
 432                                  * FORM_TYPE would be more considerate, but I'm in favor
 433                                  * of not helping broken clients.
 434                                  */
 435                                 return NULL;
 436                 }
 437         }
 438
 439         /* Erm, none found :( */
 440         return NULL;
 441 }
 442