libpurple/protocols/gg/multilogon.c

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * Rewritten from scratch during Google Summer of Code 2012
   8  * by Tomek Wasilczyk (http://www.wasilczyk.pl).
   9  *
  10  * Previously implemented by:
  11  *  - Arkadiusz Miskiewicz <misiek@pld.org.pl> - first implementation (2001);
  12  *  - Bartosz Oler <bartosz@bzimage.us> - reimplemented during GSoC 2005;
  13  *  - Krzysztof Klinikowski <grommasher@gmail.com> - some parts (2009-2011).
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301 USA
  28  */
  29
  30 #include "multilogon.h"
  31
  32 #include <debug.h>
  33
  34 #include "gg.h"
  35 #include "keymapper.h"
  36 #include "utils.h"
  37 #include "message-prpl.h"
  38
  39 typedef struct
  40 {
  41         uint64_t id;
  42         uint32_t remote_addr;
  43         gchar *name;
  44         time_t logon_time;
  45 } ggp_multilogon_session_info;
  46
  47 struct _ggp_multilogon_session_data
  48 {
  49         int session_count;
  50         ggp_multilogon_session_info *sessions;
  51         PurpleRequestDatasheet *sheet_handle;
  52         gpointer dialog_handle;
  53         ggp_keymapper *sid_mapper;
  54 };
  55
  56 static inline ggp_multilogon_session_data *
  57 ggp_multilogon_get_mldata(PurpleConnection *gc);
  58
  59
  60 static inline ggp_multilogon_session_data *
  61 ggp_multilogon_get_mldata(PurpleConnection *gc)
  62 {
  63         GGPInfo *accdata = purple_connection_get_protocol_data(gc);
  64         return accdata->multilogon_data;
  65 }
  66
  67 void
  68 ggp_multilogon_setup(PurpleConnection *gc)
  69 {
  70         GGPInfo *accdata = purple_connection_get_protocol_data(gc);
  71
  72         ggp_multilogon_session_data *mldata =
  73                 g_new0(ggp_multilogon_session_data, 1);
  74         accdata->multilogon_data = mldata;
  75
  76         mldata->sid_mapper = ggp_keymapper_new();
  77 }
  78
  79 static void
  80 ggp_multilogon_free_sessions(PurpleConnection *gc)
  81 {
  82         ggp_multilogon_session_data *mldata = ggp_multilogon_get_mldata(gc);
  83         int i;
  84
  85         for (i = 0; i < mldata->session_count; i++)
  86                 g_free(mldata->sessions[i].name);
  87         g_free(mldata->sessions);
  88
  89         mldata->sessions = NULL;
  90         mldata->session_count = 0;
  91 }
  92
  93 void
  94 ggp_multilogon_cleanup(PurpleConnection *gc)
  95 {
  96         ggp_multilogon_session_data *mldata = ggp_multilogon_get_mldata(gc);
  97
  98         if (mldata->dialog_handle) {
  99                 purple_request_close(PURPLE_REQUEST_FIELDS,
 100                         mldata->dialog_handle);
 101                 mldata->dialog_handle = NULL;
 102         }
 103
 104         ggp_multilogon_free_sessions(gc);
 105         ggp_keymapper_free(mldata->sid_mapper);
 106         g_free(mldata);
 107 }
 108
 109 static uint64_t
 110 ggp_multilogon_sid_from_libgadu(gg_multilogon_id_t lsid)
 111 {
 112         uint64_t sid;
 113
 114         memcpy(&sid, lsid.id, sizeof(uint64_t));
 115
 116         return sid;
 117 }
 118
 119 static void
 120 ggp_multilogon_sid_to_libgadu(uint64_t sid, gg_multilogon_id_t *lsid)
 121 {
 122         g_return_if_fail(lsid != NULL);
 123
 124         memcpy(lsid->id, &sid, sizeof(uint64_t));
 125 }
 126
 127 static void
 128 ggp_multilogon_fill_sessions(PurpleRequestDatasheet *sheet,
 129         PurpleConnection *gc)
 130 {
 131         ggp_multilogon_session_data *mldata = ggp_multilogon_get_mldata(gc);
 132         ggp_keymapper *km = mldata->sid_mapper;
 133         int i;
 134
 135         purple_request_datasheet_record_mark_all_for_rem(sheet);
 136
 137         for (i = 0; i < mldata->session_count; i++) {
 138                 ggp_multilogon_session_info *sess = &mldata->sessions[i];
 139                 PurpleRequestDatasheetRecord *rec;
 140
 141                 rec = purple_request_datasheet_record_add(sheet,
 142                         ggp_keymapper_to_key(km, sess->id));
 143
 144                 purple_request_datasheet_record_set_string_data(rec, 0,
 145                         ggp_ipv4_to_str(sess->remote_addr));
 146                 purple_request_datasheet_record_set_string_data(rec, 1,
 147                         purple_date_format_full(localtime(&sess->logon_time)));
 148                 purple_request_datasheet_record_set_string_data(rec, 2,
 149                         sess->name);
 150         }
 151
 152         purple_request_datasheet_record_remove_marked(sheet);
 153 }
 154
 155 void
 156 ggp_multilogon_info(PurpleConnection *gc, struct gg_event_multilogon_info *info)
 157 {
 158         ggp_multilogon_session_data *mldata = ggp_multilogon_get_mldata(gc);
 159         int i;
 160
 161         ggp_multilogon_free_sessions(gc);
 162
 163         purple_debug_info("gg", "ggp_multilogon_info: session list changed "
 164                 "(count now: %d)\n", info->count);
 165
 166         mldata->sessions = g_new(ggp_multilogon_session_info, info->count);
 167         for (i = 0; i < info->count; i++) {
 168                 struct gg_multilogon_session *lsess = &info->sessions[i];
 169                 ggp_multilogon_session_info *psess = &mldata->sessions[i];
 170
 171                 psess->id = ggp_multilogon_sid_from_libgadu(lsess->id);
 172                 psess->remote_addr = lsess->remote_addr;
 173                 psess->name = g_strdup(lsess->name);
 174                 psess->logon_time = lsess->logon_time;
 175         }
 176
 177         mldata->session_count = info->count;
 178
 179         if (mldata->sheet_handle != NULL)
 180                 ggp_multilogon_fill_sessions(mldata->sheet_handle, gc);
 181 }
 182
 183 static void
 184 ggp_multilogon_disconnect(PurpleRequestDatasheetRecord *rec, gpointer _gc)
 185 {
 186         PurpleConnection *gc = _gc;
 187         ggp_multilogon_session_data *mldata = ggp_multilogon_get_mldata(gc);
 188         GGPInfo *accdata = purple_connection_get_protocol_data(gc);
 189         uint64_t sid;
 190         gpointer key;
 191         gg_multilogon_id_t lsid;
 192
 193         key = purple_request_datasheet_record_get_key(rec);
 194         sid = ggp_keymapper_from_key(mldata->sid_mapper, key);
 195
 196         ggp_multilogon_sid_to_libgadu(sid, &lsid);
 197         gg_multilogon_disconnect(accdata->session, lsid);
 198
 199         purple_request_datasheet_record_remove(
 200                 purple_request_datasheet_record_get_datasheet(rec), key);
 201 }
 202
 203 void
 204 ggp_multilogon_dialog(PurpleConnection *gc)
 205 {
 206         ggp_multilogon_session_data *mldata = ggp_multilogon_get_mldata(gc);
 207         PurpleRequestField *field;
 208         PurpleRequestFields *fields;
 209         PurpleRequestFieldGroup *group;
 210         PurpleRequestCommonParameters *cpar;
 211         PurpleRequestDatasheet *sheet;
 212         PurpleRequestDatasheetAction *action;
 213         gpointer dialog_handle;
 214
 215         if (mldata->dialog_handle != NULL)
 216                 return;
 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         sheet = purple_request_datasheet_new();
 223         purple_request_datasheet_add_column(sheet,
 224                 PURPLE_REQUEST_DATASHEET_COLUMN_STRING, _("IP"));
 225         purple_request_datasheet_add_column(sheet,
 226                 PURPLE_REQUEST_DATASHEET_COLUMN_STRING, _("Logon time"));
 227         purple_request_datasheet_add_column(sheet,
 228                 PURPLE_REQUEST_DATASHEET_COLUMN_STRING, _("Session"));
 229
 230         action = purple_request_datasheet_action_new();
 231         purple_request_datasheet_action_set_label(action, _("Disconnect"));
 232         purple_request_datasheet_action_set_cb(action,
 233                 ggp_multilogon_disconnect, gc);
 234         purple_request_datasheet_add_action(sheet, action);
 235         ggp_multilogon_fill_sessions(sheet, gc);
 236
 237         field = purple_request_field_datasheet_new("sessions", NULL, sheet);
 238         purple_request_field_group_add_field(group, field);
 239
 240         cpar = purple_request_cpar_new();
 241         purple_request_cpar_set_icon(cpar, PURPLE_REQUEST_ICON_DIALOG);
 242
 243         dialog_handle = purple_request_fields(gc,
 244                 _("Other Gadu-Gadu sessions"), NULL, NULL, fields,
 245                 NULL, NULL, _("Close"), NULL,
 246                 cpar, NULL);
 247         mldata->sheet_handle = sheet;
 248         mldata->dialog_handle = dialog_handle;
 249
 250         purple_request_add_close_notify(dialog_handle,
 251                 purple_callback_set_zero, &mldata->sheet_handle);
 252         purple_request_add_close_notify(dialog_handle,
 253                 purple_callback_set_zero, &mldata->dialog_handle);
 254 }