libpurple/e2ee.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  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
  20  */
  21
  22 #include "e2ee.h"
  23
  24 #include "debug.h"
  25
  26 struct _PurpleE2eeState
  27 {
  28         PurpleE2eeProvider *provider;
  29
  30         gchar *name;
  31         gchar *stock_icon;
  32
  33         guint ref_count;
  34 };
  35
  36 struct _PurpleE2eeProvider
  37 {
  38         gchar *name;
  39         PurpleE2eeConvMenuCallback conv_menu_cb;
  40 };
  41
  42 static PurpleE2eeProvider *main_provider = NULL;
  43
  44 /*** Encryption states for conversations. *************************************/
  45
  46 PurpleE2eeState *
  47 purple_e2ee_state_new(PurpleE2eeProvider *provider)
  48 {
  49         PurpleE2eeState *state;
  50
  51         g_return_val_if_fail(provider != NULL, NULL);
  52
  53         state = g_new0(PurpleE2eeState, 1);
  54         state->provider = provider;
  55         state->ref_count = 1;
  56
  57         return state;
  58 }
  59
  60 void
  61 purple_e2ee_state_ref(PurpleE2eeState *state)
  62 {
  63         g_return_if_fail(state != NULL);
  64
  65         state->ref_count++;
  66 }
  67
  68 PurpleE2eeState *
  69 purple_e2ee_state_unref(PurpleE2eeState *state)
  70 {
  71         if (state == NULL)
  72                 return NULL;
  73
  74         state->ref_count--;
  75         if (state->ref_count > 0)
  76                 return state;
  77
  78         g_free(state->name);
  79         g_free(state->stock_icon);
  80         g_free(state);
  81
  82         return NULL;
  83 }
  84
  85 PurpleE2eeProvider *
  86 purple_e2ee_state_get_provider(PurpleE2eeState *state)
  87 {
  88         g_return_val_if_fail(state != NULL, NULL);
  89
  90         return state->provider;
  91 }
  92
  93 void
  94 purple_e2ee_state_set_name(PurpleE2eeState *state, const gchar *name)
  95 {
  96         g_return_if_fail(state != NULL);
  97         g_return_if_fail(name != NULL);
  98
  99         g_free(state->name);
 100         state->name = g_strdup(name);
 101 }
 102
 103 const gchar *
 104 purple_e2ee_state_get_name(PurpleE2eeState *state)
 105 {
 106         g_return_val_if_fail(state != NULL, NULL);
 107
 108         return state->name;
 109 }
 110
 111 void
 112 purple_e2ee_state_set_stock_icon(PurpleE2eeState *state,
 113         const gchar *stock_icon)
 114 {
 115         g_return_if_fail(state != NULL);
 116         g_return_if_fail(stock_icon != NULL);
 117
 118         g_free(state->stock_icon);
 119         state->stock_icon = g_strdup(stock_icon);
 120 }
 121
 122 const gchar *
 123 purple_e2ee_state_get_stock_icon(PurpleE2eeState *state)
 124 {
 125         g_return_val_if_fail(state, NULL);
 126
 127         return state->stock_icon;
 128 }
 129
 130 /*** Encryption providers API. ************************************************/
 131
 132 PurpleE2eeProvider *
 133 purple_e2ee_provider_new(void)
 134 {
 135         PurpleE2eeProvider *provider;
 136
 137         provider = g_new0(PurpleE2eeProvider, 1);
 138
 139         return provider;
 140 }
 141
 142 void
 143 purple_e2ee_provider_free(PurpleE2eeProvider *provider)
 144 {
 145         g_return_if_fail(provider != NULL);
 146
 147         if (provider == main_provider) {
 148                 purple_debug_error("e2ee", "This provider is still registered");
 149                 return;
 150         }
 151
 152         g_free(provider->name);
 153         g_free(provider);
 154 }
 155
 156 gboolean
 157 purple_e2ee_provider_register(PurpleE2eeProvider *provider)
 158 {
 159         g_return_val_if_fail(provider != NULL, FALSE);
 160
 161         if (main_provider != NULL)
 162                 return FALSE;
 163
 164         main_provider = provider;
 165         return TRUE;
 166 }
 167
 168 void
 169 purple_e2ee_provider_unregister(PurpleE2eeProvider *provider)
 170 {
 171         GList *it, *clear_states = NULL;
 172         g_return_if_fail(provider != NULL);
 173
 174         if (main_provider != provider) {
 175                 purple_debug_warning("e2ee", "This provider is not registered");
 176                 return;
 177         }
 178
 179         for (it = purple_conversations_get_all(); it; it = g_list_next(it)) {
 180                 PurpleConversation *conv = it->data;
 181                 PurpleE2eeState *state;
 182
 183                 state = purple_conversation_get_e2ee_state(conv);
 184                 if (!state)
 185                         continue;
 186                 if (provider == purple_e2ee_state_get_provider(state))
 187                         clear_states = g_list_prepend(clear_states, conv);
 188         }
 189
 190         main_provider = NULL;
 191
 192         for (it = clear_states; it; it = g_list_next(it))
 193                 purple_conversation_set_e2ee_state(it->data, NULL);
 194         g_list_free(clear_states);
 195 }
 196
 197 PurpleE2eeProvider *
 198 purple_e2ee_provider_get_main(void)
 199 {
 200         return main_provider;
 201 }
 202
 203 void
 204 purple_e2ee_provider_set_name(PurpleE2eeProvider *provider, const gchar *name)
 205 {
 206         g_return_if_fail(provider != NULL);
 207         g_return_if_fail(name != NULL);
 208
 209         g_free(provider->name);
 210         provider->name = g_strdup(name);
 211 }
 212
 213 const gchar *
 214 purple_e2ee_provider_get_name(PurpleE2eeProvider *provider)
 215 {
 216         g_return_val_if_fail(provider != NULL, NULL);
 217
 218         return provider->name;
 219 }
 220
 221 void
 222 purple_e2ee_provider_set_conv_menu_cb(PurpleE2eeProvider *provider,
 223         PurpleE2eeConvMenuCallback conv_menu_cb)
 224 {
 225         g_return_if_fail(provider != NULL);
 226
 227         provider->conv_menu_cb = conv_menu_cb;
 228 }
 229
 230 PurpleE2eeConvMenuCallback
 231 purple_e2ee_provider_get_conv_menu_cb(PurpleE2eeProvider *provider)
 232 {
 233         g_return_val_if_fail(provider != NULL, NULL);
 234
 235         return provider->conv_menu_cb;
 236 }
 237
 238 GList *
 239 purple_e2ee_provider_get_conv_menu_actions(PurpleE2eeProvider *provider,
 240         PurpleConversation *conv)
 241 {
 242         PurpleE2eeConvMenuCallback cb;
 243
 244         g_return_val_if_fail(provider, NULL);
 245         g_return_val_if_fail(conv, NULL);
 246
 247         cb = purple_e2ee_provider_get_conv_menu_cb(provider);
 248         if (cb == NULL)
 249                 return NULL;
 250
 251         return cb(conv);
 252 }