8849
|
1 /*
|
|
2
|
|
3 silcgaim_chat.c
|
|
4
|
|
5 Author: Pekka Riikonen <priikone@silcnet.org>
|
|
6
|
|
7 Copyright (C) 2004 Pekka Riikonen
|
|
8
|
|
9 This program is free software; you can redistribute it and/or modify
|
|
10 it under the terms of the GNU General Public License as published by
|
|
11 the Free Software Foundation; version 2 of the License.
|
|
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 */
|
|
19
|
|
20 #include "silcincludes.h"
|
|
21 #include "silcclient.h"
|
|
22 #include "silcgaim.h"
|
|
23
|
|
24 /***************************** Channel Routines ******************************/
|
|
25
|
|
26 GList *silcgaim_chat_info(GaimConnection *gc)
|
|
27 {
|
|
28 GList *ci = NULL;
|
|
29 struct proto_chat_entry *pce;
|
|
30
|
|
31 pce = g_new0(struct proto_chat_entry, 1);
|
|
32 pce->label = _("_Channel:");
|
|
33 pce->identifier = "channel";
|
|
34 ci = g_list_append(ci, pce);
|
|
35
|
|
36 pce = g_new0(struct proto_chat_entry, 1);
|
|
37 pce->label = _("_Passphrase:");
|
|
38 pce->identifier = "passphrase";
|
|
39 pce->secret = TRUE;
|
|
40 ci = g_list_append(ci, pce);
|
|
41
|
|
42 return ci;
|
|
43 }
|
|
44
|
|
45 static void
|
|
46 silcgaim_chat_getinfo(GaimConnection *gc, GHashTable *components);
|
|
47
|
|
48 static void
|
|
49 silcgaim_chat_getinfo_res(SilcClient client,
|
|
50 SilcClientConnection conn,
|
|
51 SilcChannelEntry *channels,
|
|
52 SilcUInt32 channels_count,
|
|
53 void *context)
|
|
54 {
|
|
55 GHashTable *components = context;
|
|
56 GaimConnection *gc = client->application;
|
|
57 const char *chname;
|
|
58 char tmp[256];
|
|
59
|
|
60 chname = g_hash_table_lookup(components, "channel");
|
|
61 if (!chname)
|
|
62 return;
|
|
63
|
|
64 if (!channels) {
|
|
65 g_snprintf(tmp, sizeof(tmp),
|
|
66 _("Channel %s does not exist in the network"), chname);
|
|
67 gaim_notify_error(gc, _("Channel Information"),
|
|
68 _("Cannot get channel information"), tmp);
|
|
69 return;
|
|
70 }
|
|
71
|
|
72 silcgaim_chat_getinfo(gc, components);
|
|
73 }
|
|
74
|
|
75 static void
|
|
76 silcgaim_chat_getinfo(GaimConnection *gc, GHashTable *components)
|
|
77 {
|
|
78 SilcGaim sg = gc->proto_data;
|
|
79 const char *chname;
|
|
80 char *buf, tmp[256];
|
|
81 GString *s;
|
|
82 SilcChannelEntry channel;
|
|
83 SilcHashTableList htl;
|
|
84 SilcChannelUser chu;
|
|
85
|
|
86 if (!components)
|
|
87 return;
|
|
88
|
|
89 chname = g_hash_table_lookup(components, "channel");
|
|
90 if (!chname)
|
|
91 return;
|
|
92 channel = silc_client_get_channel(sg->client, sg->conn,
|
|
93 (char *)chname);
|
|
94 if (!channel) {
|
|
95 silc_client_get_channel_resolve(sg->client, sg->conn,
|
|
96 (char *)chname,
|
|
97 silcgaim_chat_getinfo_res,
|
|
98 components);
|
|
99 return;
|
|
100 }
|
|
101
|
|
102 s = g_string_new("");
|
|
103 g_string_append_printf(s, "Channel Name:\t\t%s\n", channel->channel_name);
|
|
104 if (channel->user_list && silc_hash_table_count(channel->user_list))
|
|
105 g_string_append_printf(s, "User Count:\t\t%d\n",
|
|
106 (int)silc_hash_table_count(channel->user_list));
|
|
107
|
|
108 silc_hash_table_list(channel->user_list, &htl);
|
|
109 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
|
|
110 if (chu->mode & SILC_CHANNEL_UMODE_CHANFO) {
|
|
111 g_string_append_printf(s, "Channel Founder:\t%s\n",
|
|
112 chu->client->nickname);
|
|
113 break;
|
|
114 }
|
|
115 }
|
|
116 silc_hash_table_list_reset(&htl);
|
|
117
|
|
118 if (channel->channel_key)
|
|
119 g_string_append_printf(s, "Channel Cipher:\t\t%s\n",
|
|
120 silc_cipher_get_name(channel->channel_key));
|
|
121 if (channel->hmac)
|
|
122 g_string_append_printf(s, "Channel HMAC:\t\t%s\n",
|
|
123 silc_hmac_get_name(channel->hmac));
|
|
124
|
|
125 if (channel->topic)
|
|
126 g_string_append_printf(s, "\nChannel Topic:\n\%s\n", channel->topic);
|
|
127
|
|
128 if (channel->mode) {
|
|
129 g_string_append_printf(s, "\nChannel Modes:\n");
|
|
130 silcgaim_get_chmode_string(channel->mode, tmp, sizeof(tmp));
|
|
131 g_string_append_printf(s, tmp);
|
|
132 g_string_append_printf(s, "\n");
|
|
133 }
|
|
134
|
|
135 if (channel->founder_key) {
|
|
136 char *fingerprint, *babbleprint;
|
|
137 unsigned char *pk;
|
|
138 SilcUInt32 pk_len;
|
|
139 pk = silc_pkcs_public_key_encode(channel->founder_key, &pk_len);
|
|
140 fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
|
|
141 babbleprint = silc_hash_babbleprint(NULL, pk, pk_len);
|
|
142
|
|
143 g_string_append_printf(s, "\nFounder Key Fingerprint:\n%s\n\n", fingerprint);
|
|
144 g_string_append_printf(s, "Founder Key Babbleprint:\n%s", babbleprint);
|
|
145
|
|
146 silc_free(fingerprint);
|
|
147 silc_free(babbleprint);
|
|
148 silc_free(pk);
|
|
149 }
|
|
150
|
|
151 buf = g_string_free(s, FALSE);
|
|
152 gaim_notify_message(NULL, GAIM_NOTIFY_MSG_INFO,
|
|
153 _("Channel Information"),
|
|
154 _("Channel Information"),
|
|
155 buf, NULL, NULL);
|
|
156 g_free(buf);
|
|
157 }
|
|
158
|
|
159
|
|
160 #if 0 /* XXX For now these are not implemented. We need better
|
|
161 listview dialog from Gaim for these. */
|
|
162 /************************** Channel Invite List ******************************/
|
|
163
|
|
164 static void
|
|
165 silcgaim_chat_invitelist(GaimConnection *gc, GHashTable *components)
|
|
166 {
|
|
167
|
|
168 }
|
|
169
|
|
170
|
|
171 /**************************** Channel Ban List *******************************/
|
|
172
|
|
173 static void
|
|
174 silcgaim_chat_banlist(GaimConnection *gc, GHashTable *components)
|
|
175 {
|
|
176
|
|
177 }
|
|
178 #endif
|
|
179
|
|
180
|
|
181 /************************* Channel Authentication ****************************/
|
|
182
|
|
183 typedef struct {
|
|
184 SilcGaim sg;
|
|
185 SilcChannelEntry channel;
|
|
186 GaimChat *c;
|
|
187 SilcBuffer pubkeys;
|
|
188 } *SilcGaimChauth;
|
|
189
|
|
190 static void
|
|
191 silcgaim_chat_chpk_add(void *user_data, const char *name)
|
|
192 {
|
|
193 SilcGaimChauth sgc = (SilcGaimChauth)user_data;
|
|
194 SilcGaim sg = sgc->sg;
|
|
195 SilcClient client = sg->client;
|
|
196 SilcClientConnection conn = sg->conn;
|
|
197 SilcPublicKey public_key;
|
|
198 SilcBuffer chpks, pk, chidp;
|
|
199 unsigned char mode[4];
|
|
200 SilcUInt32 m;
|
|
201
|
|
202 /* Load the public key */
|
|
203 if (!silc_pkcs_load_public_key(name, &public_key, SILC_PKCS_FILE_PEM) &&
|
|
204 !silc_pkcs_load_public_key(name, &public_key, SILC_PKCS_FILE_BIN)) {
|
|
205 silcgaim_chat_chauth_show(sgc->sg, sgc->channel, sgc->pubkeys);
|
|
206 silc_buffer_free(sgc->pubkeys);
|
|
207 silc_free(sgc);
|
|
208 gaim_notify_error(client->application,
|
|
209 _("Add Channel Public Key"),
|
|
210 _("Could not load public key"), NULL);
|
|
211 return;
|
|
212 }
|
|
213
|
|
214 pk = silc_pkcs_public_key_payload_encode(public_key);
|
|
215 chpks = silc_buffer_alloc_size(2);
|
|
216 SILC_PUT16_MSB(1, chpks->head);
|
|
217 chpks = silc_argument_payload_encode_one(chpks, pk->data,
|
|
218 pk->len, 0x00);
|
|
219 silc_buffer_free(pk);
|
|
220
|
|
221 m = sgc->channel->mode;
|
|
222 m |= SILC_CHANNEL_MODE_CHANNEL_AUTH;
|
|
223
|
|
224 /* Send CMODE */
|
|
225 SILC_PUT32_MSB(m, mode);
|
|
226 chidp = silc_id_payload_encode(sgc->channel->id, SILC_ID_CHANNEL);
|
|
227 silc_client_command_send(client, conn, SILC_COMMAND_CMODE,
|
|
228 ++conn->cmd_ident, 3,
|
|
229 1, chidp->data, chidp->len,
|
|
230 2, mode, sizeof(mode),
|
|
231 9, chpks->data, chpks->len);
|
|
232 silc_buffer_free(chpks);
|
|
233 silc_buffer_free(chidp);
|
|
234 silc_buffer_free(sgc->pubkeys);
|
|
235 silc_free(sgc);
|
|
236 }
|
|
237
|
|
238 static void
|
|
239 silcgaim_chat_chpk_cancel(void *user_data, const char *name)
|
|
240 {
|
|
241 SilcGaimChauth sgc = (SilcGaimChauth)user_data;
|
|
242 silcgaim_chat_chauth_show(sgc->sg, sgc->channel, sgc->pubkeys);
|
|
243 silc_buffer_free(sgc->pubkeys);
|
|
244 silc_free(sgc);
|
|
245 }
|
|
246
|
|
247 static void
|
|
248 silcgaim_chat_chpk_cb(SilcGaimChauth sgc, GaimRequestFields *fields)
|
|
249 {
|
|
250 SilcGaim sg = sgc->sg;
|
|
251 SilcClient client = sg->client;
|
|
252 SilcClientConnection conn = sg->conn;
|
|
253 GaimRequestField *f;
|
|
254 const GList *list;
|
|
255 SilcPublicKey public_key;
|
|
256 SilcBuffer chpks, pk, chidp;
|
|
257 SilcUInt16 c = 0, ct;
|
|
258 unsigned char mode[4];
|
|
259 SilcUInt32 m;
|
|
260
|
|
261 f = gaim_request_fields_get_field(fields, "list");
|
|
262 if (!gaim_request_field_list_get_selected(f)) {
|
|
263 /* Add new public key */
|
|
264 gaim_request_file(NULL, _("Open Public Key..."), _(""),
|
|
265 G_CALLBACK(silcgaim_chat_chpk_add),
|
|
266 G_CALLBACK(silcgaim_chat_chpk_cancel), sgc);
|
|
267 return;
|
|
268 }
|
|
269
|
|
270 list = gaim_request_field_list_get_items(f);
|
|
271 chpks = silc_buffer_alloc_size(2);
|
|
272
|
|
273 for (ct = 0; list; list = list->next, ct++) {
|
|
274 public_key = gaim_request_field_list_get_data(f, list->data);
|
|
275 if (gaim_request_field_list_is_selected(f, list->data)) {
|
|
276 /* Delete this public key */
|
|
277 pk = silc_pkcs_public_key_payload_encode(public_key);
|
|
278 chpks = silc_argument_payload_encode_one(chpks, pk->data,
|
|
279 pk->len, 0x01);
|
|
280 silc_buffer_free(pk);
|
|
281 c++;
|
|
282 }
|
|
283 silc_pkcs_public_key_free(public_key);
|
|
284 }
|
|
285 if (!c) {
|
|
286 silc_buffer_free(chpks);
|
|
287 return;
|
|
288 }
|
|
289 SILC_PUT16_MSB(c, chpks->head);
|
|
290
|
|
291 m = sgc->channel->mode;
|
|
292 if (ct == c)
|
|
293 m &= ~SILC_CHANNEL_MODE_CHANNEL_AUTH;
|
|
294
|
|
295 /* Send CMODE */
|
|
296 SILC_PUT32_MSB(m, mode);
|
|
297 chidp = silc_id_payload_encode(sgc->channel->id, SILC_ID_CHANNEL);
|
|
298 silc_client_command_send(client, conn, SILC_COMMAND_CMODE,
|
|
299 ++conn->cmd_ident, 3,
|
|
300 1, chidp->data, chidp->len,
|
|
301 2, mode, sizeof(mode),
|
|
302 9, chpks->data, chpks->len);
|
|
303 silc_buffer_free(chpks);
|
|
304 silc_buffer_free(chidp);
|
|
305 silc_buffer_free(sgc->pubkeys);
|
|
306 silc_free(sgc);
|
|
307 }
|
|
308
|
|
309 static void
|
|
310 silcgaim_chat_chauth_ok(SilcGaimChauth sgc, GaimRequestFields *fields)
|
|
311 {
|
|
312 SilcGaim sg = sgc->sg;
|
|
313 GaimRequestField *f;
|
|
314 const char *curpass, *val;
|
|
315 int set;
|
|
316
|
|
317 f = gaim_request_fields_get_field(fields, "passphrase");
|
|
318 val = gaim_request_field_string_get_value(f);
|
|
319 curpass = gaim_blist_node_get_string((GaimBlistNode *)sgc->c, "passphrase");
|
|
320
|
|
321 if (!val && curpass)
|
|
322 set = 0;
|
|
323 else if (val && !curpass)
|
|
324 set = 1;
|
|
325 else if (val && curpass && strcmp(val, curpass))
|
|
326 set = 1;
|
|
327 else
|
|
328 set = -1;
|
|
329
|
|
330 if (set == 1) {
|
|
331 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
332 sgc->channel->channel_name, "+a", val, NULL);
|
|
333 gaim_blist_node_set_string((GaimBlistNode *)sgc->c, "passphrase", val);
|
|
334 gaim_blist_save();
|
|
335 } else if (set == 0) {
|
|
336 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
337 sgc->channel->channel_name, "-a", NULL);
|
|
338 gaim_blist_node_remove_setting((GaimBlistNode *)sgc->c, "passphrase");
|
|
339 gaim_blist_save();
|
|
340 }
|
|
341
|
|
342 silc_buffer_free(sgc->pubkeys);
|
|
343 silc_free(sgc);
|
|
344 }
|
|
345
|
|
346 void silcgaim_chat_chauth_show(SilcGaim sg, SilcChannelEntry channel,
|
|
347 SilcBuffer channel_pubkeys)
|
|
348 {
|
|
349 SilcUInt16 argc;
|
|
350 SilcArgumentPayload chpks;
|
|
351 unsigned char *pk;
|
|
352 SilcUInt32 pk_len, type;
|
|
353 char *fingerprint, *babbleprint;
|
|
354 SilcPublicKey pubkey;
|
|
355 SilcPublicKeyIdentifier ident;
|
|
356 char tmp2[1024], t[512];
|
|
357 GaimRequestFields *fields;
|
|
358 GaimRequestFieldGroup *g;
|
|
359 GaimRequestField *f;
|
|
360 SilcGaimChauth sgc;
|
|
361 const char *curpass = NULL;
|
|
362
|
|
363 sgc = silc_calloc(1, sizeof(*sgc));
|
|
364 if (!sgc)
|
|
365 return;
|
|
366 sgc->sg = sg;
|
|
367 sgc->channel = channel;
|
|
368
|
|
369 fields = gaim_request_fields_new();
|
|
370
|
|
371 if (sgc->c)
|
|
372 curpass = gaim_blist_node_get_string((GaimBlistNode *)sgc->c, "passphrase");
|
|
373
|
|
374 g = gaim_request_field_group_new(NULL);
|
|
375 f = gaim_request_field_string_new("passphrase", _("Channel Passphrase"),
|
|
376 curpass, FALSE);
|
|
377 gaim_request_field_string_set_masked(f, TRUE);
|
|
378 gaim_request_field_group_add_field(g, f);
|
|
379 gaim_request_fields_add_group(fields, g);
|
|
380
|
|
381 g = gaim_request_field_group_new(NULL);
|
|
382 f = gaim_request_field_label_new("l1", _("Channel Public Keys List"));
|
|
383 gaim_request_field_group_add_field(g, f);
|
|
384 gaim_request_fields_add_group(fields, g);
|
|
385
|
|
386 g_snprintf(t, sizeof(t),
|
|
387 _("Channel authentication is used to secure the channel from "
|
|
388 "unauthorized access. The authentication may be based on "
|
|
389 "passphrase and digital signatures. If passphrase is set, it "
|
|
390 "is required to be able to join. If channel public keys are set "
|
|
391 "then only users whose public keys are listed are able to join."));
|
|
392
|
|
393 if (!channel_pubkeys) {
|
|
394 f = gaim_request_field_list_new("list", NULL);
|
|
395 gaim_request_field_group_add_field(g, f);
|
|
396 gaim_request_fields(NULL, _("Channel Authentication"),
|
|
397 _("Channel Authentication"), t, fields,
|
|
398 "Add / Remove", G_CALLBACK(silcgaim_chat_chpk_cb),
|
|
399 "OK", G_CALLBACK(silcgaim_chat_chauth_ok), sgc);
|
|
400 return;
|
|
401 }
|
|
402 sgc->pubkeys = silc_buffer_copy(channel_pubkeys);
|
|
403
|
|
404 g = gaim_request_field_group_new(NULL);
|
|
405 f = gaim_request_field_list_new("list", NULL);
|
|
406 gaim_request_field_group_add_field(g, f);
|
|
407 gaim_request_fields_add_group(fields, g);
|
|
408
|
|
409 SILC_GET16_MSB(argc, channel_pubkeys->data);
|
|
410 chpks = silc_argument_payload_parse(channel_pubkeys->data + 2,
|
|
411 channel_pubkeys->len - 2, argc);
|
|
412 if (!chpks)
|
|
413 return;
|
|
414
|
|
415 pk = silc_argument_get_first_arg(chpks, &type, &pk_len);
|
|
416 while (pk) {
|
|
417 fingerprint = silc_hash_fingerprint(NULL, pk + 4, pk_len - 4);
|
|
418 babbleprint = silc_hash_babbleprint(NULL, pk + 4, pk_len - 4);
|
|
419 silc_pkcs_public_key_payload_decode(pk, pk_len, &pubkey);
|
|
420 ident = silc_pkcs_decode_identifier(pubkey->identifier);
|
|
421
|
|
422 g_snprintf(tmp2, sizeof(tmp2), "%s\n %s\n %s",
|
|
423 ident->realname ? ident->realname : ident->username ?
|
|
424 ident->username : "", fingerprint, babbleprint);
|
|
425 gaim_request_field_list_add(f, tmp2, pubkey);
|
|
426
|
|
427 silc_free(fingerprint);
|
|
428 silc_free(babbleprint);
|
|
429 silc_pkcs_free_identifier(ident);
|
|
430 pk = silc_argument_get_next_arg(chpks, &type, &pk_len);
|
|
431 }
|
|
432
|
|
433 gaim_request_field_list_set_multi_select(f, FALSE);
|
|
434 gaim_request_fields(NULL, _("Channel Authentication"),
|
|
435 _("Channel Authentication"), t, fields,
|
|
436 "Add / Remove", G_CALLBACK(silcgaim_chat_chpk_cb),
|
|
437 "OK", G_CALLBACK(silcgaim_chat_chauth_ok), sgc);
|
|
438
|
|
439 silc_argument_payload_free(chpks);
|
|
440 }
|
|
441
|
|
442 static void
|
|
443 silcgaim_chat_chauth(GaimConnection *gc, GHashTable *components)
|
|
444 {
|
|
445 SilcGaim sg = gc->proto_data;
|
|
446 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
447 g_hash_table_lookup(components, "channel"),
|
|
448 "+C", NULL);
|
|
449 }
|
|
450
|
|
451
|
|
452 /************************** Channel Private Groups **************************/
|
|
453
|
|
454 /* Private groups are "virtual" channels. They are groups inside a channel.
|
|
455 This is implemented by using channel private keys. By knowing a channel
|
|
456 private key user becomes part of that group and is able to talk on that
|
|
457 group. Other users, on the same channel, won't be able to see the
|
|
458 messages of that group. It is possible to have multiple groups inside
|
|
459 a channel - and thus having multiple private keys on the channel. */
|
|
460
|
|
461 typedef struct {
|
|
462 SilcGaim sg;
|
|
463 GaimChat *c;
|
|
464 const char *channel;
|
|
465 } *SilcGaimCharPrv;
|
|
466
|
|
467 static void
|
|
468 silcgaim_chat_prv_add(SilcGaimCharPrv p, GaimRequestFields *fields)
|
|
469 {
|
|
470 SilcGaim sg = p->sg;
|
|
471 char tmp[512];
|
|
472 GaimRequestField *f;
|
|
473 const char *name, *passphrase, *alias;
|
|
474 GHashTable *comp;
|
|
475 GaimGroup *g;
|
|
476 GaimChat *cn;
|
|
477
|
|
478 f = gaim_request_fields_get_field(fields, "name");
|
|
479 name = gaim_request_field_string_get_value(f);
|
|
480 if (!name) {
|
|
481 silc_free(p);
|
|
482 return;
|
|
483 }
|
|
484 f = gaim_request_fields_get_field(fields, "passphrase");
|
|
485 passphrase = gaim_request_field_string_get_value(f);
|
|
486 f = gaim_request_fields_get_field(fields, "alias");
|
|
487 alias = gaim_request_field_string_get_value(f);
|
|
488
|
|
489 /* Add private group to buddy list */
|
|
490 g_snprintf(tmp, sizeof(tmp), "%s [Private Group]", name);
|
|
491 comp = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
|
|
492 g_hash_table_replace(comp, g_strdup("channel"), g_strdup(tmp));
|
|
493 g_hash_table_replace(comp, g_strdup("passphrase"), g_strdup(passphrase));
|
|
494
|
|
495 cn = gaim_chat_new(sg->account, alias, comp);
|
|
496 g = (GaimGroup *)p->c->node.parent;
|
|
497 gaim_blist_add_chat(cn, g, (GaimBlistNode *)p->c);
|
|
498
|
|
499 /* Associate to a real channel */
|
|
500 gaim_blist_node_set_string((GaimBlistNode *)cn, "parentch", p->channel);
|
|
501 gaim_blist_save();
|
|
502
|
|
503 /* Join the group */
|
|
504 silcgaim_chat_join(sg->gc, comp);
|
|
505
|
|
506 silc_free(p);
|
|
507 }
|
|
508
|
|
509 static void
|
|
510 silcgaim_chat_prv_cancel(SilcGaimCharPrv p, GaimRequestFields *fields)
|
|
511 {
|
|
512 silc_free(p);
|
|
513 }
|
|
514
|
|
515 static void
|
|
516 silcgaim_chat_prv(GaimConnection *gc, GHashTable *components)
|
|
517 {
|
|
518 SilcGaim sg = gc->proto_data;
|
|
519 SilcGaimCharPrv p;
|
|
520 GaimRequestFields *fields;
|
|
521 GaimRequestFieldGroup *g;
|
|
522 GaimRequestField *f;
|
|
523 char tmp[512];
|
|
524
|
|
525 p = silc_calloc(1, sizeof(*p));
|
|
526 if (!p)
|
|
527 return;
|
|
528 p->sg = sg;
|
|
529
|
|
530 p->channel = g_hash_table_lookup(components, "channel");
|
|
531 p->c = gaim_blist_find_chat(sg->account, p->channel);
|
|
532
|
|
533 fields = gaim_request_fields_new();
|
|
534
|
|
535 g = gaim_request_field_group_new(NULL);
|
|
536 f = gaim_request_field_string_new("name", _("Group Name"),
|
|
537 NULL, FALSE);
|
|
538 gaim_request_field_group_add_field(g, f);
|
|
539
|
|
540 f = gaim_request_field_string_new("passphrase", _("Passphrase"),
|
|
541 NULL, FALSE);
|
|
542 gaim_request_field_string_set_masked(f, TRUE);
|
|
543 gaim_request_field_group_add_field(g, f);
|
|
544
|
|
545 f = gaim_request_field_string_new("alias", _("Alias"),
|
|
546 NULL, FALSE);
|
|
547 gaim_request_field_group_add_field(g, f);
|
|
548 gaim_request_fields_add_group(fields, g);
|
|
549
|
|
550 g_snprintf(tmp, sizeof(tmp),
|
|
551 _("Please enter the %s channel private group name and passphrase."),
|
|
552 p->channel);
|
|
553 gaim_request_fields(NULL, _("Add Channel Private Group"), NULL, tmp, fields,
|
|
554 "Add", G_CALLBACK(silcgaim_chat_prv_add),
|
|
555 "Cancel", G_CALLBACK(silcgaim_chat_prv_cancel), p);
|
|
556 }
|
|
557
|
|
558
|
|
559 /****************************** Channel Modes ********************************/
|
|
560
|
|
561 static void
|
|
562 silcgaim_chat_permanent_reset(GaimConnection *gc, GHashTable *components)
|
|
563 {
|
|
564 SilcGaim sg = gc->proto_data;
|
|
565 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
566 g_hash_table_lookup(components, "channel"),
|
|
567 "-f", NULL);
|
|
568 }
|
|
569
|
|
570 static void
|
|
571 silcgaim_chat_permanent(GaimConnection *gc, GHashTable *components)
|
|
572 {
|
|
573 SilcGaim sg = gc->proto_data;
|
|
574 const char *channel;
|
|
575
|
|
576 if (!sg->conn)
|
|
577 return;
|
|
578
|
|
579 /* XXX we should have ability to define which founder
|
|
580 key to use. Now we use the user's own public key
|
|
581 (default key). */
|
|
582
|
|
583 /* Call CMODE */
|
|
584 channel = g_hash_table_lookup(components, "channel");
|
|
585 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE", channel,
|
|
586 "+f", NULL);
|
|
587 }
|
|
588
|
|
589 typedef struct {
|
|
590 SilcGaim sg;
|
|
591 const char *channel;
|
|
592 } *SilcGaimChatInput;
|
|
593
|
|
594 static void
|
|
595 silcgaim_chat_ulimit_cb(SilcGaimChatInput s, const char *limit)
|
|
596 {
|
|
597 SilcChannelEntry channel;
|
|
598 int ulimit = 0;
|
|
599
|
|
600 channel = silc_client_get_channel(s->sg->client, s->sg->conn,
|
|
601 (char *)s->channel);
|
|
602 if (!channel)
|
|
603 return;
|
|
604 if (limit)
|
|
605 ulimit = atoi(limit);
|
|
606
|
|
607 if (!limit || !(*limit) || *limit == '0') {
|
|
608 if (limit && ulimit == channel->user_limit) {
|
|
609 silc_free(s);
|
|
610 return;
|
|
611 }
|
|
612 silc_client_command_call(s->sg->client, s->sg->conn, NULL, "CMODE",
|
|
613 s->channel, "-l", NULL);
|
|
614
|
|
615 silc_free(s);
|
|
616 return;
|
|
617 }
|
|
618
|
|
619 if (ulimit == channel->user_limit) {
|
|
620 silc_free(s);
|
|
621 return;
|
|
622 }
|
|
623
|
|
624 /* Call CMODE */
|
|
625 silc_client_command_call(s->sg->client, s->sg->conn, NULL, "CMODE",
|
|
626 s->channel, "+l", limit, NULL);
|
|
627
|
|
628 silc_free(s);
|
|
629 }
|
|
630
|
|
631 static void
|
|
632 silcgaim_chat_ulimit(GaimConnection *gc, GHashTable *components)
|
|
633 {
|
|
634 SilcGaim sg = gc->proto_data;
|
|
635 SilcGaimChatInput s;
|
|
636 SilcChannelEntry channel;
|
|
637 const char *ch;
|
|
638 char tmp[32];
|
|
639
|
|
640 if (!sg->conn)
|
|
641 return;
|
|
642
|
|
643 ch = g_strdup(g_hash_table_lookup(components, "channel"));
|
|
644 channel = silc_client_get_channel(sg->client, sg->conn, (char *)ch);
|
|
645 if (!channel)
|
|
646 return;
|
|
647
|
|
648 s = silc_calloc(1, sizeof(*s));
|
|
649 if (!s)
|
|
650 return;
|
|
651 s->channel = ch;
|
|
652 s->sg = sg;
|
|
653 g_snprintf(tmp, sizeof(tmp), "%d", (int)channel->user_limit);
|
|
654 gaim_request_input(NULL, _("User Limit"), NULL,
|
|
655 _("Set user limit on channel. Set to zero to reset user limit."),
|
|
656 tmp, FALSE, FALSE, NULL,
|
|
657 _("OK"), G_CALLBACK(silcgaim_chat_ulimit_cb),
|
|
658 _("Cancel"), G_CALLBACK(silcgaim_chat_ulimit_cb), s);
|
|
659 }
|
|
660
|
|
661 static void
|
|
662 silcgaim_chat_resettopic(GaimConnection *gc, GHashTable *components)
|
|
663 {
|
|
664 SilcGaim sg = gc->proto_data;
|
|
665 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
666 g_hash_table_lookup(components, "channel"),
|
|
667 "-t", NULL);
|
|
668 }
|
|
669
|
|
670 static void
|
|
671 silcgaim_chat_settopic(GaimConnection *gc, GHashTable *components)
|
|
672 {
|
|
673 SilcGaim sg = gc->proto_data;
|
|
674 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
675 g_hash_table_lookup(components, "channel"),
|
|
676 "+t", NULL);
|
|
677 }
|
|
678
|
|
679 static void
|
|
680 silcgaim_chat_resetprivate(GaimConnection *gc, GHashTable *components)
|
|
681 {
|
|
682 SilcGaim sg = gc->proto_data;
|
|
683 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
684 g_hash_table_lookup(components, "channel"),
|
|
685 "-p", NULL);
|
|
686 }
|
|
687
|
|
688 static void
|
|
689 silcgaim_chat_setprivate(GaimConnection *gc, GHashTable *components)
|
|
690 {
|
|
691 SilcGaim sg = gc->proto_data;
|
|
692 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
693 g_hash_table_lookup(components, "channel"),
|
|
694 "+p", NULL);
|
|
695 }
|
|
696
|
|
697 static void
|
|
698 silcgaim_chat_resetsecret(GaimConnection *gc, GHashTable *components)
|
|
699 {
|
|
700 SilcGaim sg = gc->proto_data;
|
|
701 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
702 g_hash_table_lookup(components, "channel"),
|
|
703 "-s", NULL);
|
|
704 }
|
|
705
|
|
706 static void
|
|
707 silcgaim_chat_setsecret(GaimConnection *gc, GHashTable *components)
|
|
708 {
|
|
709 SilcGaim sg = gc->proto_data;
|
|
710 silc_client_command_call(sg->client, sg->conn, NULL, "CMODE",
|
|
711 g_hash_table_lookup(components, "channel"),
|
|
712 "+s", NULL);
|
|
713 }
|
|
714
|
|
715 GList *silcgaim_chat_menu(GaimConnection *gc, GHashTable *components)
|
|
716 {
|
|
717 SilcGaim sg = gc->proto_data;
|
|
718 SilcClientConnection conn = sg->conn;
|
|
719 GList *m = NULL;
|
|
720 struct proto_chat_menu *pcm;
|
|
721 const char *chname = NULL;
|
|
722 SilcChannelEntry channel = NULL;
|
|
723 SilcChannelUser chu = NULL;
|
|
724 SilcUInt32 mode = 0;
|
|
725
|
|
726 if (components)
|
|
727 chname = g_hash_table_lookup(components, "channel");
|
|
728 if (chname)
|
|
729 channel = silc_client_get_channel(sg->client, sg->conn,
|
|
730 (char *)chname);
|
|
731 if (channel) {
|
|
732 chu = silc_client_on_channel(channel, conn->local_entry);
|
|
733 if (chu)
|
|
734 mode = chu->mode;
|
|
735 }
|
|
736
|
|
737 if (strstr(chname, "[Private Group]"))
|
|
738 return NULL;
|
|
739
|
|
740 pcm = g_new0(struct proto_chat_menu, 1);
|
|
741 pcm->label = _("Get Info");
|
|
742 pcm->callback = silcgaim_chat_getinfo;
|
|
743 pcm->gc = gc;
|
|
744 m = g_list_append(m, pcm);
|
|
745
|
|
746 #if 0 /* XXX For now these are not implemented. We need better
|
|
747 listview dialog from Gaim for these. */
|
|
748 if (mode & SILC_CHANNEL_UMODE_CHANOP) {
|
|
749 pcm = g_new0(struct proto_chat_menu, 1);
|
|
750 pcm->label = _("Invite List");
|
|
751 pcm->callback = silcgaim_chat_invitelist;
|
|
752 pcm->gc = gc;
|
|
753 m = g_list_append(m, pcm);
|
|
754
|
|
755 pcm = g_new0(struct proto_chat_menu, 1);
|
|
756 pcm->label = _("Ban List");
|
|
757 pcm->callback = silcgaim_chat_banlist;
|
|
758 pcm->gc = gc;
|
|
759 m = g_list_append(m, pcm);
|
|
760 }
|
|
761 #endif
|
|
762
|
|
763 if (chu) {
|
|
764 pcm = g_new0(struct proto_chat_menu, 1);
|
|
765 pcm->label = _("Add Private Group");
|
|
766 pcm->callback = silcgaim_chat_prv;
|
|
767 pcm->gc = gc;
|
|
768 m = g_list_append(m, pcm);
|
|
769 }
|
|
770
|
|
771 if (mode & SILC_CHANNEL_UMODE_CHANFO) {
|
|
772 pcm = g_new0(struct proto_chat_menu, 1);
|
|
773 pcm->label = _("Channel Authentication");
|
|
774 pcm->callback = silcgaim_chat_chauth;
|
|
775 pcm->gc = gc;
|
|
776 m = g_list_append(m, pcm);
|
|
777
|
|
778 if (channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
|
|
779 pcm = g_new0(struct proto_chat_menu, 1);
|
|
780 pcm->label = _("Reset Permanent");
|
|
781 pcm->callback = silcgaim_chat_permanent_reset;
|
|
782 pcm->gc = gc;
|
|
783 m = g_list_append(m, pcm);
|
|
784 } else {
|
|
785 pcm = g_new0(struct proto_chat_menu, 1);
|
|
786 pcm->label = _("Set Permanent");
|
|
787 pcm->callback = silcgaim_chat_permanent;
|
|
788 pcm->gc = gc;
|
|
789 m = g_list_append(m, pcm);
|
|
790 }
|
|
791 }
|
|
792
|
|
793 if (mode & SILC_CHANNEL_UMODE_CHANOP) {
|
|
794 pcm = g_new0(struct proto_chat_menu, 1);
|
|
795 pcm->label = _("Set User Limit");
|
|
796 pcm->callback = silcgaim_chat_ulimit;
|
|
797 pcm->gc = gc;
|
|
798 m = g_list_append(m, pcm);
|
|
799
|
|
800 if (channel->mode & SILC_CHANNEL_MODE_TOPIC) {
|
|
801 pcm = g_new0(struct proto_chat_menu, 1);
|
|
802 pcm->label = _("Reset Topic Restriction");
|
|
803 pcm->callback = silcgaim_chat_resettopic;
|
|
804 pcm->gc = gc;
|
|
805 m = g_list_append(m, pcm);
|
|
806 } else {
|
|
807 pcm = g_new0(struct proto_chat_menu, 1);
|
|
808 pcm->label = _("Set Topic Restriction");
|
|
809 pcm->callback = silcgaim_chat_settopic;
|
|
810 pcm->gc = gc;
|
|
811 m = g_list_append(m, pcm);
|
|
812 }
|
|
813
|
|
814 if (channel->mode & SILC_CHANNEL_MODE_PRIVATE) {
|
|
815 pcm = g_new0(struct proto_chat_menu, 1);
|
|
816 pcm->label = _("Reset Private Channel");
|
|
817 pcm->callback = silcgaim_chat_resetprivate;
|
|
818 pcm->gc = gc;
|
|
819 m = g_list_append(m, pcm);
|
|
820 } else {
|
|
821 pcm = g_new0(struct proto_chat_menu, 1);
|
|
822 pcm->label = _("Set Private Channel");
|
|
823 pcm->callback = silcgaim_chat_setprivate;
|
|
824 pcm->gc = gc;
|
|
825 m = g_list_append(m, pcm);
|
|
826 }
|
|
827
|
|
828 if (channel->mode & SILC_CHANNEL_MODE_SECRET) {
|
|
829 pcm = g_new0(struct proto_chat_menu, 1);
|
|
830 pcm->label = _("Reset Secret Channel");
|
|
831 pcm->callback = silcgaim_chat_resetsecret;
|
|
832 pcm->gc = gc;
|
|
833 m = g_list_append(m, pcm);
|
|
834 } else {
|
|
835 pcm = g_new0(struct proto_chat_menu, 1);
|
|
836 pcm->label = _("Set Secret Channel");
|
|
837 pcm->callback = silcgaim_chat_setsecret;
|
|
838 pcm->gc = gc;
|
|
839 m = g_list_append(m, pcm);
|
|
840 }
|
|
841 }
|
|
842
|
|
843 return m;
|
|
844 }
|
|
845
|
|
846
|
|
847 /******************************* Joining Etc. ********************************/
|
|
848
|
|
849 void silcgaim_chat_join_done(SilcClient client,
|
|
850 SilcClientConnection conn,
|
|
851 SilcClientEntry *clients,
|
|
852 SilcUInt32 clients_count,
|
|
853 void *context)
|
|
854 {
|
|
855 GaimConnection *gc = client->application;
|
|
856 SilcGaim sg = gc->proto_data;
|
|
857 SilcChannelEntry channel = context;
|
|
858 GaimConversation *convo;
|
|
859 SilcUInt32 retry = SILC_PTR_TO_32(channel->context);
|
|
860 SilcHashTableList htl;
|
|
861 SilcChannelUser chu;
|
|
862 GList *users = NULL;
|
|
863 char tmp[256];
|
|
864
|
|
865 if (!clients && retry < 1) {
|
|
866 /* Resolving users failed, try again. */
|
|
867 channel->context = SILC_32_TO_PTR(retry + 1);
|
|
868 silc_client_get_clients_by_channel(client, conn, channel,
|
|
869 silcgaim_chat_join_done, channel);
|
|
870 return;
|
|
871 }
|
|
872
|
|
873 /* Add channel to Gaim */
|
|
874 channel->context = SILC_32_TO_PTR(++sg->channel_ids);
|
|
875 serv_got_joined_chat(gc, sg->channel_ids, channel->channel_name);
|
|
876 convo = gaim_find_conversation_with_account(channel->channel_name,
|
|
877 sg->account);
|
|
878 if (!convo)
|
|
879 return;
|
|
880
|
|
881 /* Add all users to channel */
|
|
882 silc_hash_table_list(channel->user_list, &htl);
|
|
883 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
|
|
884 if (!chu->client->nickname)
|
|
885 continue;
|
|
886 chu->context = SILC_32_TO_PTR(sg->channel_ids);
|
|
887
|
|
888 #if 0 /* XXX don't append mode char to nick because Gaim doesn't
|
|
889 give a way to change it afterwards when mode changes. */
|
|
890 tmp2 = silc_client_chumode_char(chu->mode);
|
|
891 if (tmp2)
|
|
892 g_snprintf(tmp, sizeof(tmp), _("%s%s"), tmp2,
|
|
893 chu->client->nickname);
|
|
894 else
|
|
895 g_snprintf(tmp, sizeof(tmp), _("%s"),
|
|
896 chu->client->nickname);
|
|
897 silc_free(tmp2);
|
|
898
|
|
899 users = g_list_append(users, g_strdup(tmp));
|
|
900 #else
|
|
901 users = g_list_append(users, g_strdup(chu->client->nickname));
|
|
902 #endif
|
|
903
|
|
904 if (chu->mode & SILC_CHANNEL_UMODE_CHANFO) {
|
|
905 if (chu->client == conn->local_entry)
|
|
906 g_snprintf(tmp, sizeof(tmp),
|
|
907 _("You are channel founder on <I>%s</I>"),
|
|
908 channel->channel_name);
|
|
909 else
|
|
910 g_snprintf(tmp, sizeof(tmp),
|
|
911 _("Channel founder on <I>%s</I> is <I>%s</I>"),
|
|
912 channel->channel_name, chu->client->nickname);
|
|
913
|
|
914 gaim_conversation_write(convo, NULL, tmp,
|
|
915 GAIM_MESSAGE_SYSTEM, time(NULL));
|
|
916
|
|
917 }
|
|
918 }
|
|
919 silc_hash_table_list_reset(&htl);
|
|
920
|
|
921 gaim_conv_chat_add_users(GAIM_CONV_CHAT(convo), users);
|
|
922 g_list_free(users);
|
|
923
|
|
924 /* Set topic */
|
|
925 if (channel->topic)
|
|
926 gaim_conv_chat_set_topic(GAIM_CONV_CHAT(convo), NULL, channel->topic);
|
|
927 }
|
|
928
|
|
929 void silcgaim_chat_join(GaimConnection *gc, GHashTable *data)
|
|
930 {
|
|
931 SilcGaim sg = gc->proto_data;
|
|
932 SilcClient client = sg->client;
|
|
933 SilcClientConnection conn = sg->conn;
|
|
934 const char *channel, *passphrase, *parentch;
|
|
935
|
|
936 if (!conn)
|
|
937 return;
|
|
938
|
|
939 channel = g_hash_table_lookup(data, "channel");
|
|
940 passphrase = g_hash_table_lookup(data, "passphrase");
|
|
941
|
|
942 /* Check if we are joining a private group. Handle it
|
|
943 purely locally as it's not a real channel */
|
|
944 if (strstr(channel, "[Private Group]")) {
|
|
945 SilcChannelEntry channel_entry;
|
|
946 SilcChannelPrivateKey key;
|
|
947 GaimChat *c;
|
|
948 SilcGaimPrvgrp grp;
|
|
949
|
|
950 c = gaim_blist_find_chat(sg->account, channel);
|
|
951 parentch = gaim_blist_node_get_string((GaimBlistNode *)c, "parentch");
|
|
952 if (!parentch)
|
|
953 return;
|
|
954
|
|
955 channel_entry = silc_client_get_channel(sg->client, sg->conn,
|
|
956 (char *)parentch);
|
|
957 if (!channel_entry ||
|
|
958 !silc_client_on_channel(channel_entry, sg->conn->local_entry)) {
|
|
959 char tmp[512];
|
|
960 g_snprintf(tmp, sizeof(tmp),
|
|
961 _("You have to join the %s channel before you are "
|
|
962 "able to join the private group"), parentch);
|
|
963 gaim_notify_error(gc, _("Join Private Group"),
|
|
964 _("Cannot join private group"), tmp);
|
|
965 return;
|
|
966 }
|
|
967
|
|
968 /* Add channel private key */
|
|
969 if (!silc_client_add_channel_private_key(client, conn,
|
|
970 channel_entry, channel,
|
|
971 NULL, NULL,
|
|
972 (unsigned char *)passphrase,
|
|
973 strlen(passphrase), &key))
|
|
974 return;
|
|
975
|
|
976 /* Join the group */
|
|
977 grp = silc_calloc(1, sizeof(*grp));
|
|
978 if (!grp)
|
|
979 return;
|
|
980 grp->id = ++sg->channel_ids + SILCGAIM_PRVGRP;
|
|
981 grp->chid = SILC_PTR_TO_32(channel_entry->context);
|
|
982 grp->parentch = parentch;
|
|
983 grp->channel = channel;
|
|
984 grp->key = key;
|
|
985 sg->grps = g_list_append(sg->grps, grp);
|
|
986 serv_got_joined_chat(gc, grp->id, channel);
|
|
987 return;
|
|
988 }
|
|
989
|
|
990 /* XXX We should have other properties here as well:
|
|
991 1. whether to try to authenticate to the channel
|
|
992 1a. with default key,
|
|
993 1b. with specific key.
|
|
994 2. whether to try to authenticate to become founder.
|
|
995 2a. with default key,
|
|
996 2b. with specific key.
|
|
997
|
|
998 Since now such variety is not possible in the join dialog
|
|
999 we always use -founder and -auth options, which try to
|
|
1000 do both 1 and 2 with default keys. */
|
|
1001
|
|
1002 /* Call JOIN */
|
|
1003 if (passphrase)
|
|
1004 silc_client_command_call(client, conn, NULL, "JOIN",
|
|
1005 channel, passphrase, "-auth", "-founder", NULL);
|
|
1006 else
|
|
1007 silc_client_command_call(client, conn, NULL, "JOIN",
|
|
1008 channel, "-auth", "-founder", NULL);
|
|
1009 }
|
|
1010
|
|
1011 void silcgaim_chat_invite(GaimConnection *gc, int id, const char *msg,
|
|
1012 const char *name)
|
|
1013 {
|
|
1014 SilcGaim sg = gc->proto_data;
|
|
1015 SilcClient client = sg->client;
|
|
1016 SilcClientConnection conn = sg->conn;
|
|
1017 SilcHashTableList htl;
|
|
1018 SilcChannelUser chu;
|
|
1019 gboolean found = FALSE;
|
|
1020
|
|
1021 if (!conn)
|
|
1022 return;
|
|
1023
|
|
1024 /* See if we are inviting on a private group. Invite
|
|
1025 to the actual channel */
|
|
1026 if (id > SILCGAIM_PRVGRP) {
|
|
1027 GList *l;
|
|
1028 SilcGaimPrvgrp prv;
|
|
1029
|
|
1030 for (l = sg->grps; l; l = l->next)
|
|
1031 if (((SilcGaimPrvgrp)l->data)->id == id)
|
|
1032 break;
|
|
1033 if (!l)
|
|
1034 return;
|
|
1035 prv = l->data;
|
|
1036 id = prv->chid;
|
|
1037 }
|
|
1038
|
|
1039 /* Find channel by id */
|
|
1040 silc_hash_table_list(conn->local_entry->channels, &htl);
|
|
1041 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
|
|
1042 if (SILC_PTR_TO_32(chu->channel->context) == id ) {
|
|
1043 found = TRUE;
|
|
1044 break;
|
|
1045 }
|
|
1046 }
|
|
1047 silc_hash_table_list_reset(&htl);
|
|
1048 if (!found)
|
|
1049 return;
|
|
1050
|
|
1051 /* Call INVITE */
|
|
1052 silc_client_command_call(client, conn, NULL, "INVITE",
|
|
1053 chu->channel->channel_name,
|
|
1054 name);
|
|
1055 }
|
|
1056
|
|
1057 void silcgaim_chat_leave(GaimConnection *gc, int id)
|
|
1058 {
|
|
1059 SilcGaim sg = gc->proto_data;
|
|
1060 SilcClient client = sg->client;
|
|
1061 SilcClientConnection conn = sg->conn;
|
|
1062 SilcHashTableList htl;
|
|
1063 SilcChannelUser chu;
|
|
1064 gboolean found = FALSE;
|
|
1065 GList *l;
|
|
1066 SilcGaimPrvgrp prv;
|
|
1067
|
|
1068 if (!conn)
|
|
1069 return;
|
|
1070
|
|
1071 /* See if we are leaving a private group */
|
|
1072 if (id > SILCGAIM_PRVGRP) {
|
|
1073 SilcChannelEntry channel;
|
|
1074
|
|
1075 for (l = sg->grps; l; l = l->next)
|
|
1076 if (((SilcGaimPrvgrp)l->data)->id == id)
|
|
1077 break;
|
|
1078 if (!l)
|
|
1079 return;
|
|
1080 prv = l->data;
|
|
1081 channel = silc_client_get_channel(sg->client, sg->conn,
|
|
1082 (char *)prv->parentch);
|
|
1083 if (!channel)
|
|
1084 return;
|
|
1085 silc_client_del_channel_private_key(client, conn,
|
|
1086 channel, prv->key);
|
|
1087 silc_free(prv);
|
|
1088 sg->grps = g_list_remove(sg->grps, prv);
|
|
1089 serv_got_chat_left(gc, id);
|
|
1090 return;
|
|
1091 }
|
|
1092
|
|
1093 /* Find channel by id */
|
|
1094 silc_hash_table_list(conn->local_entry->channels, &htl);
|
|
1095 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
|
|
1096 if (SILC_PTR_TO_32(chu->channel->context) == id ) {
|
|
1097 found = TRUE;
|
|
1098 break;
|
|
1099 }
|
|
1100 }
|
|
1101 silc_hash_table_list_reset(&htl);
|
|
1102 if (!found)
|
|
1103 return;
|
|
1104
|
|
1105 /* Call LEAVE */
|
|
1106 silc_client_command_call(client, conn, NULL, "LEAVE",
|
|
1107 chu->channel->channel_name, NULL);
|
|
1108
|
|
1109 serv_got_chat_left(gc, id);
|
|
1110
|
|
1111 /* Leave from private groups on this channel as well */
|
|
1112 for (l = sg->grps; l; l = l->next)
|
|
1113 if (((SilcGaimPrvgrp)l->data)->chid == id) {
|
|
1114 prv = l->data;
|
|
1115 silc_client_del_channel_private_key(client, conn,
|
|
1116 chu->channel,
|
|
1117 prv->key);
|
|
1118 serv_got_chat_left(gc, prv->id);
|
|
1119 silc_free(prv);
|
|
1120 sg->grps = g_list_remove(sg->grps, prv);
|
|
1121 if (!sg->grps)
|
|
1122 break;
|
|
1123 }
|
|
1124 }
|
|
1125
|
|
1126 int silcgaim_chat_send(GaimConnection *gc, int id, const char *msg)
|
|
1127 {
|
|
1128 SilcGaim sg = gc->proto_data;
|
|
1129 SilcClient client = sg->client;
|
|
1130 SilcClientConnection conn = sg->conn;
|
|
1131 SilcHashTableList htl;
|
|
1132 SilcChannelUser chu;
|
|
1133 SilcChannelEntry channel = NULL;
|
|
1134 SilcChannelPrivateKey key = NULL;
|
|
1135 SilcUInt32 flags;
|
|
1136 int ret;
|
|
1137 gboolean found = FALSE;
|
|
1138 gboolean sign = gaim_prefs_get_bool("/plugins/prpl/silc/sign_chat");
|
|
1139
|
|
1140 if (!msg || !conn)
|
|
1141 return 0;
|
|
1142
|
|
1143 /* See if command */
|
|
1144 if (strlen(msg) > 1 && msg[0] == '/') {
|
|
1145 if (!silc_client_command_call(client, conn, msg + 1))
|
|
1146 gaim_notify_error(gc, ("Call Command"), _("Cannot call command"),
|
|
1147 _("Unknown command"));
|
|
1148 return 0;
|
|
1149 }
|
|
1150
|
|
1151 flags = SILC_MESSAGE_FLAG_UTF8;
|
|
1152 if (sign)
|
|
1153 flags |= SILC_MESSAGE_FLAG_SIGNED;
|
|
1154
|
|
1155 /* Get the channel private key if we are sending on
|
|
1156 private group */
|
|
1157 if (id > SILCGAIM_PRVGRP) {
|
|
1158 GList *l;
|
|
1159 SilcGaimPrvgrp prv;
|
|
1160
|
|
1161 for (l = sg->grps; l; l = l->next)
|
|
1162 if (((SilcGaimPrvgrp)l->data)->id == id)
|
|
1163 break;
|
|
1164 if (!l)
|
|
1165 return 0;
|
|
1166 prv = l->data;
|
|
1167 channel = silc_client_get_channel(sg->client, sg->conn,
|
|
1168 (char *)prv->parentch);
|
|
1169 if (!channel)
|
|
1170 return 0;
|
|
1171 key = prv->key;
|
|
1172 }
|
|
1173
|
|
1174 if (!channel) {
|
|
1175 /* Find channel by id */
|
|
1176 silc_hash_table_list(conn->local_entry->channels, &htl);
|
|
1177 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
|
|
1178 if (SILC_PTR_TO_32(chu->channel->context) == id ) {
|
|
1179 found = TRUE;
|
|
1180 break;
|
|
1181 }
|
|
1182 }
|
|
1183 silc_hash_table_list_reset(&htl);
|
|
1184 if (!found)
|
|
1185 return 0;
|
|
1186 channel = chu->channel;
|
|
1187 }
|
|
1188
|
|
1189 /* Send channel message */
|
|
1190 ret = silc_client_send_channel_message(client, conn, channel, key,
|
|
1191 flags, (unsigned char *)msg,
|
|
1192 strlen(msg), TRUE);
|
|
1193 if (ret)
|
|
1194 serv_got_chat_in(gc, id, gaim_connection_get_display_name(gc), 0, msg,
|
|
1195 time(NULL));
|
|
1196
|
|
1197 return ret;
|
|
1198 }
|
|
1199
|
|
1200 void silcgaim_chat_set_topic(GaimConnection *gc, int id, const char *topic)
|
|
1201 {
|
|
1202 SilcGaim sg = gc->proto_data;
|
|
1203 SilcClient client = sg->client;
|
|
1204 SilcClientConnection conn = sg->conn;
|
|
1205 SilcHashTableList htl;
|
|
1206 SilcChannelUser chu;
|
|
1207 gboolean found = FALSE;
|
|
1208
|
|
1209 if (!topic || !conn)
|
|
1210 return;
|
|
1211
|
|
1212 /* See if setting topic on private group. Set it
|
|
1213 on the actual channel */
|
|
1214 if (id > SILCGAIM_PRVGRP) {
|
|
1215 GList *l;
|
|
1216 SilcGaimPrvgrp prv;
|
|
1217
|
|
1218 for (l = sg->grps; l; l = l->next)
|
|
1219 if (((SilcGaimPrvgrp)l->data)->id == id)
|
|
1220 break;
|
|
1221 if (!l)
|
|
1222 return;
|
|
1223 prv = l->data;
|
|
1224 id = prv->chid;
|
|
1225 }
|
|
1226
|
|
1227 /* Find channel by id */
|
|
1228 silc_hash_table_list(conn->local_entry->channels, &htl);
|
|
1229 while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
|
|
1230 if (SILC_PTR_TO_32(chu->channel->context) == id ) {
|
|
1231 found = TRUE;
|
|
1232 break;
|
|
1233 }
|
|
1234 }
|
|
1235 silc_hash_table_list_reset(&htl);
|
|
1236 if (!found)
|
|
1237 return;
|
|
1238
|
|
1239 /* Call TOPIC */
|
|
1240 silc_client_command_call(client, conn, NULL, "TOPIC",
|
|
1241 chu->channel->channel_name, topic, NULL);
|
|
1242 }
|
|
1243
|
|
1244 GaimRoomlist *silcgaim_roomlist_get_list(GaimConnection *gc)
|
|
1245 {
|
|
1246 SilcGaim sg = gc->proto_data;
|
|
1247 SilcClient client = sg->client;
|
|
1248 SilcClientConnection conn = sg->conn;
|
|
1249 GList *fields = NULL;
|
|
1250 GaimRoomlistField *f;
|
|
1251
|
|
1252 if (!conn)
|
|
1253 return NULL;
|
|
1254
|
|
1255 if (sg->roomlist)
|
|
1256 gaim_roomlist_unref(sg->roomlist);
|
|
1257
|
|
1258 sg->roomlist_canceled = FALSE;
|
|
1259
|
|
1260 sg->roomlist = gaim_roomlist_new(gaim_connection_get_account(gc));
|
|
1261 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_STRING, "", "channel", TRUE);
|
|
1262 fields = g_list_append(fields, f);
|
|
1263 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_INT,
|
|
1264 _("Users"), "users", FALSE);
|
|
1265 fields = g_list_append(fields, f);
|
|
1266 f = gaim_roomlist_field_new(GAIM_ROOMLIST_FIELD_STRING,
|
|
1267 _("Topic"), "topic", FALSE);
|
|
1268 fields = g_list_append(fields, f);
|
|
1269 gaim_roomlist_set_fields(sg->roomlist, fields);
|
|
1270
|
|
1271 /* Call LIST */
|
|
1272 silc_client_command_call(client, conn, "LIST");
|
|
1273
|
|
1274 gaim_roomlist_set_in_progress(sg->roomlist, TRUE);
|
|
1275
|
|
1276 return sg->roomlist;
|
|
1277 }
|
|
1278
|
|
1279 void silcgaim_roomlist_cancel(GaimRoomlist *list)
|
|
1280 {
|
|
1281 GaimConnection *gc = gaim_account_get_connection(list->account);
|
|
1282 SilcGaim sg;
|
|
1283
|
|
1284 if (!gc)
|
|
1285 return;
|
|
1286 sg = gc->proto_data;
|
|
1287
|
|
1288 gaim_roomlist_set_in_progress(list, FALSE);
|
|
1289 if (sg->roomlist == list) {
|
|
1290 gaim_roomlist_unref(sg->roomlist);
|
|
1291 sg->roomlist = NULL;
|
|
1292 sg->roomlist_canceled = TRUE;
|
|
1293 }
|
|
1294 }
|