Mercurial > pidgin

comparison src/protocols/silc/chat.c @ 8849:50d0f76639e7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[gaim-migrate @ 9616] Let there be SILC. committer: Tailor Script <tailor@pidgin.im>
author Ethan Blanton <elb@pidgin.im>
date Sat, 01 May 2004 19:34:44 +0000
parents
children c8cd436b5840
comparison
equal deleted inserted replaced
8848:56e6b9bdcdbc 8849:50d0f76639e7
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 }