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