source: protocols/skype/skype.c @ fa41a75

Last change on this file since fa41a75 was 6ea8782, checked in by dequis <dx@…>, at 2015-10-13T04:23:49Z

skype: use g_vsnprintf() instead of vsnprintf()

More prefixes = better. The G stands for "good".

(it also fixes the warning about _BSD_SOURCE being deprecated)

  • Property mode set to 100644
File size: 44.3 KB
Line 
1/*
2 *  skype.c - Skype plugin for BitlBee
3 *
4 *  Copyright (c) 2007-2013 by Miklos Vajna <vmiklos@vmiklos.hu>
5 *
6 *  This program is free software; you can redistribute it and/or modify
7 *  it under the terms of the GNU General Public License as published by
8 *  the Free Software Foundation; either version 2 of the License, or
9 *  (at your option) any later version.
10 *
11 *  This program is distributed in the hope that it will be useful,
12 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 *  GNU General Public License for more details.
15 *
16 *  You should have received a copy of the GNU General Public License
17 *  along with this program; if not, write to the Free Software
18 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19 *  USA.
20 */
21
22#define _XOPEN_SOURCE
23#include <poll.h>
24#include <stdio.h>
25#include <bitlbee.h>
26#include <ssl_client.h>
27
28#define SKYPE_DEFAULT_SERVER "localhost"
29#define SKYPE_DEFAULT_PORT "2727"
30#define IRC_LINE_SIZE 16384
31#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
32
33/*
34 * Enumerations
35 */
36
37enum {
38        SKYPE_CALL_RINGING = 1,
39        SKYPE_CALL_MISSED,
40        SKYPE_CALL_CANCELLED,
41        SKYPE_CALL_FINISHED,
42        SKYPE_CALL_REFUSED
43};
44
45enum {
46        SKYPE_FILETRANSFER_NEW = 1,
47        SKYPE_FILETRANSFER_TRANSFERRING,
48        SKYPE_FILETRANSFER_COMPLETED,
49        SKYPE_FILETRANSFER_FAILED
50};
51
52/*
53 * Structures
54 */
55
56struct skype_data {
57        struct im_connection *ic;
58        char *username;
59        /* The effective file descriptor. We store it here so any function can
60         * write() to it. */
61        int fd;
62        /* File descriptor returned by bitlbee. we store it so we know when
63         * we're connected and when we aren't. */
64        int bfd;
65        /* ssl_getfd() uses this to get the file desciptor. */
66        void *ssl;
67        /* When we receive a new message id, we query the properties, finally
68         * the chatname. Store the properties here so that we can use
69         * imcb_buddy_msg() when we got the chatname. */
70        char *handle;
71        /* List, because of multiline messages. */
72        GList *body;
73        char *type;
74        /* This is necessary because we send a notification when we get the
75         * handle. So we store the state here and then we can send a
76         * notification about the handle is in a given status. */
77        int call_status;
78        char *call_id;
79        char *call_duration;
80        /* If the call is outgoing or not */
81        int call_out;
82        /* Same for file transfers. */
83        int filetransfer_status;
84        /* Path of the file being transferred. */
85        char *filetransfer_path;
86        /* Using /j #nick we want to have a groupchat with two people. Usually
87         * not (default). */
88        char *groupchat_with;
89        /* The user who invited us to the chat. */
90        char *adder;
91        /* If we are waiting for a confirmation about we changed the topic. */
92        int topic_wait;
93        /* These are used by the info command. */
94        char *info_fullname;
95        char *info_phonehome;
96        char *info_phoneoffice;
97        char *info_phonemobile;
98        char *info_nrbuddies;
99        char *info_tz;
100        char *info_seen;
101        char *info_birthday;
102        char *info_sex;
103        char *info_language;
104        char *info_country;
105        char *info_province;
106        char *info_city;
107        char *info_homepage;
108        char *info_about;
109        /* When a call fails, we get the reason and later we get the failure
110         * event, so store the failure code here till then */
111        int failurereason;
112        /* If this is just an update of an already received message. */
113        int is_edit;
114        /* List of struct skype_group* */
115        GList *groups;
116        /* Pending user which has to be added to the next group which is
117         * created. */
118        char *pending_user;
119        /* If the info command was used, to determine what to do with FULLNAME result. */
120        int is_info;
121};
122
123struct skype_away_state {
124        char *code;
125        char *full_name;
126};
127
128struct skype_buddy_ask_data {
129        struct im_connection *ic;
130        /* This is also used for call IDs for simplicity */
131        char *handle;
132};
133
134struct skype_group {
135        int id;
136        char *name;
137        GList *users;
138};
139
140/*
141 * Tables
142 */
143
144const struct skype_away_state skype_away_state_list[] = {
145        { "AWAY", "Away" },
146        { "NA", "Not available" },
147        { "DND", "Do Not Disturb" },
148        { "INVISIBLE", "Invisible" },
149        { "OFFLINE", "Offline" },
150        { "SKYPEME", "Skype Me" },
151        { "ONLINE", "Online" },
152        { NULL, NULL }
153};
154
155/*
156 * Functions
157 */
158
159int skype_write(struct im_connection *ic, char *buf, int len)
160{
161        struct skype_data *sd = ic->proto_data;
162        struct pollfd pfd[1];
163
164        if (!sd->ssl) {
165                return FALSE;
166        }
167
168        pfd[0].fd = sd->fd;
169        pfd[0].events = POLLOUT;
170
171        /* This poll is necessary or we'll get a SIGPIPE when we write() to
172         * sd->fd. */
173        poll(pfd, 1, 1000);
174        if (pfd[0].revents & POLLHUP) {
175                imc_logout(ic, TRUE);
176                return FALSE;
177        }
178        ssl_write(sd->ssl, buf, len);
179
180        return TRUE;
181}
182
183int skype_printf(struct im_connection *ic, char *fmt, ...)
184{
185        va_list args;
186        char str[IRC_LINE_SIZE];
187
188        va_start(args, fmt);
189        g_vsnprintf(str, IRC_LINE_SIZE, fmt, args);
190        va_end(args);
191
192        return skype_write(ic, str, strlen(str));
193}
194
195static void skype_buddy_ask_yes(void *data)
196{
197        struct skype_buddy_ask_data *bla = data;
198
199        skype_printf(bla->ic, "SET USER %s ISAUTHORIZED TRUE\n",
200                     bla->handle);
201        g_free(bla->handle);
202        g_free(bla);
203}
204
205static void skype_buddy_ask_no(void *data)
206{
207        struct skype_buddy_ask_data *bla = data;
208
209        skype_printf(bla->ic, "SET USER %s ISAUTHORIZED FALSE\n",
210                     bla->handle);
211        g_free(bla->handle);
212        g_free(bla);
213}
214
215void skype_buddy_ask(struct im_connection *ic, char *handle, char *message)
216{
217        struct skype_buddy_ask_data *bla = g_new0(struct skype_buddy_ask_data,
218                                                  1);
219        char *buf;
220
221        bla->ic = ic;
222        bla->handle = g_strdup(handle);
223
224        buf = g_strdup_printf("The user %s wants to add you to his/her buddy list, saying: '%s'.", handle, message);
225        imcb_ask(ic, buf, bla, skype_buddy_ask_yes, skype_buddy_ask_no);
226        g_free(buf);
227}
228
229static void skype_call_ask_yes(void *data)
230{
231        struct skype_buddy_ask_data *bla = data;
232
233        skype_printf(bla->ic, "SET CALL %s STATUS INPROGRESS\n",
234                     bla->handle);
235        g_free(bla->handle);
236        g_free(bla);
237}
238
239static void skype_call_ask_no(void *data)
240{
241        struct skype_buddy_ask_data *bla = data;
242
243        skype_printf(bla->ic, "SET CALL %s STATUS FINISHED\n",
244                     bla->handle);
245        g_free(bla->handle);
246        g_free(bla);
247}
248
249void skype_call_ask(struct im_connection *ic, char *call_id, char *message)
250{
251        struct skype_buddy_ask_data *bla = g_new0(struct skype_buddy_ask_data,
252                                                  1);
253
254        bla->ic = ic;
255        bla->handle = g_strdup(call_id);
256
257        imcb_ask(ic, message, bla, skype_call_ask_yes, skype_call_ask_no);
258}
259
260static char *skype_call_strerror(int err)
261{
262        switch (err) {
263        case 1:
264                return "Miscellaneous error";
265        case 2:
266                return "User or phone number does not exist.";
267        case 3:
268                return "User is offline";
269        case 4:
270                return "No proxy found";
271        case 5:
272                return "Session terminated.";
273        case 6:
274                return "No common codec found.";
275        case 7:
276                return "Sound I/O error.";
277        case 8:
278                return "Problem with remote sound device.";
279        case 9:
280                return "Call blocked by recipient.";
281        case 10:
282                return "Recipient not a friend.";
283        case 11:
284                return "Current user not authorized by recipient.";
285        case 12:
286                return "Sound recording error.";
287        default:
288                return "Unknown error";
289        }
290}
291
292static char *skype_group_by_username(struct im_connection *ic, char *username)
293{
294        struct skype_data *sd = ic->proto_data;
295        int i, j;
296
297        /* NEEDSWORK: we just search for the first group of the user, multiple
298         * groups / user is not yet supported by BitlBee. */
299
300        for (i = 0; i < g_list_length(sd->groups); i++) {
301                struct skype_group *sg = g_list_nth_data(sd->groups, i);
302                for (j = 0; j < g_list_length(sg->users); j++) {
303                        if (!strcmp(g_list_nth_data(sg->users, j), username)) {
304                                return sg->name;
305                        }
306                }
307        }
308        return NULL;
309}
310
311static struct skype_group *skype_group_by_name(struct im_connection *ic, char *name)
312{
313        struct skype_data *sd = ic->proto_data;
314        int i;
315
316        for (i = 0; i < g_list_length(sd->groups); i++) {
317                struct skype_group *sg = g_list_nth_data(sd->groups, i);
318                if (!strcmp(sg->name, name)) {
319                        return sg;
320                }
321        }
322        return NULL;
323}
324
325static void skype_parse_users(struct im_connection *ic, char *line)
326{
327        char **i, **nicks;
328
329        nicks = g_strsplit(line + 6, ", ", 0);
330        for (i = nicks; *i; i++) {
331                skype_printf(ic, "GET USER %s ONLINESTATUS\n", *i);
332                skype_printf(ic, "GET USER %s FULLNAME\n", *i);
333        }
334        g_strfreev(nicks);
335}
336
337static void skype_parse_user(struct im_connection *ic, char *line)
338{
339        int flags = 0;
340        char *ptr;
341        struct skype_data *sd = ic->proto_data;
342        char *user = strchr(line, ' ');
343        char *status = strrchr(line, ' ');
344
345        status++;
346        ptr = strchr(++user, ' ');
347        if (!ptr) {
348                return;
349        }
350        *ptr = '\0';
351        ptr++;
352        if (!strncmp(ptr, "ONLINESTATUS ", 13)) {
353                if (!strlen(user) || !strcmp(user, sd->username)) {
354                        return;
355                }
356                if (!set_getbool(&ic->acc->set, "test_join")
357                    && !strcmp(user, "echo123")) {
358                        return;
359                }
360                ptr = g_strdup_printf("%s@skype.com", user);
361                imcb_add_buddy(ic, ptr, skype_group_by_username(ic, user));
362                if (strcmp(status, "OFFLINE") && (strcmp(status, "SKYPEOUT") ||
363                                                  !set_getbool(&ic->acc->set, "skypeout_offline"))) {
364                        flags |= OPT_LOGGED_IN;
365                }
366                if (strcmp(status, "ONLINE") && strcmp(status, "SKYPEME")) {
367                        flags |= OPT_AWAY;
368                }
369                imcb_buddy_status(ic, ptr, flags, NULL, NULL);
370                g_free(ptr);
371        } else if (!strncmp(ptr, "RECEIVEDAUTHREQUEST ", 20)) {
372                char *message = ptr + 20;
373                if (strlen(message)) {
374                        skype_buddy_ask(ic, user, message);
375                }
376        } else if (!strncmp(ptr, "BUDDYSTATUS ", 12)) {
377                char *st = ptr + 12;
378                if (!strcmp(st, "3")) {
379                        char *buf = g_strdup_printf("%s@skype.com", user);
380                        imcb_add_buddy(ic, buf, skype_group_by_username(ic, user));
381                        g_free(buf);
382                }
383        } else if (!strncmp(ptr, "MOOD_TEXT ", 10)) {
384                char *buf = g_strdup_printf("%s@skype.com", user);
385                bee_user_t *bu = bee_user_by_handle(ic->bee, ic, buf);
386                g_free(buf);
387                buf = ptr + 10;
388                if (bu) {
389                        imcb_buddy_status(ic, bu->handle, bu->flags, NULL,
390                                          *buf ? buf : NULL);
391                }
392                if (set_getbool(&ic->acc->set, "show_moods")) {
393                        imcb_log(ic, "User `%s' changed mood text to `%s'", user, buf);
394                }
395        } else if (!strncmp(ptr, "FULLNAME ", 9)) {
396                char *name = ptr + 9;
397                if (sd->is_info) {
398                        sd->is_info = FALSE;
399                        sd->info_fullname = g_strdup(name);
400                } else {
401                        char *buf = g_strdup_printf("%s@skype.com", user);
402                        imcb_rename_buddy(ic, buf, name);
403                        g_free(buf);
404                }
405        } else if (!strncmp(ptr, "PHONE_HOME ", 11)) {
406                sd->info_phonehome = g_strdup(ptr + 11);
407        } else if (!strncmp(ptr, "PHONE_OFFICE ", 13)) {
408                sd->info_phoneoffice = g_strdup(ptr + 13);
409        } else if (!strncmp(ptr, "PHONE_MOBILE ", 13)) {
410                sd->info_phonemobile = g_strdup(ptr + 13);
411        } else if (!strncmp(ptr, "NROF_AUTHED_BUDDIES ", 20)) {
412                sd->info_nrbuddies = g_strdup(ptr + 20);
413        } else if (!strncmp(ptr, "TIMEZONE ", 9)) {
414                sd->info_tz = g_strdup(ptr + 9);
415        } else if (!strncmp(ptr, "LASTONLINETIMESTAMP ", 20)) {
416                sd->info_seen = g_strdup(ptr + 20);
417        } else if (!strncmp(ptr, "SEX ", 4)) {
418                sd->info_sex = g_strdup(ptr + 4);
419        } else if (!strncmp(ptr, "LANGUAGE ", 9)) {
420                sd->info_language = g_strdup(ptr + 9);
421        } else if (!strncmp(ptr, "COUNTRY ", 8)) {
422                sd->info_country = g_strdup(ptr + 8);
423        } else if (!strncmp(ptr, "PROVINCE ", 9)) {
424                sd->info_province = g_strdup(ptr + 9);
425        } else if (!strncmp(ptr, "CITY ", 5)) {
426                sd->info_city = g_strdup(ptr + 5);
427        } else if (!strncmp(ptr, "HOMEPAGE ", 9)) {
428                sd->info_homepage = g_strdup(ptr + 9);
429        } else if (!strncmp(ptr, "ABOUT ", 6)) {
430                /* Support multiple about lines. */
431                if (!sd->info_about) {
432                        sd->info_about = g_strdup(ptr + 6);
433                } else {
434                        GString *st = g_string_new(sd->info_about);
435                        g_string_append_printf(st, "\n%s", ptr + 6);
436                        g_free(sd->info_about);
437                        sd->info_about = g_strdup(st->str);
438                        g_string_free(st, TRUE);
439                }
440        } else if (!strncmp(ptr, "BIRTHDAY ", 9)) {
441                sd->info_birthday = g_strdup(ptr + 9);
442
443                GString *st = g_string_new("Contact Information\n");
444                g_string_append_printf(st, "Skype Name: %s\n", user);
445                if (sd->info_fullname) {
446                        if (strlen(sd->info_fullname)) {
447                                g_string_append_printf(st, "Full Name: %s\n",
448                                                       sd->info_fullname);
449                        }
450                        g_free(sd->info_fullname);
451                        sd->info_fullname = NULL;
452                }
453                if (sd->info_phonehome) {
454                        if (strlen(sd->info_phonehome)) {
455                                g_string_append_printf(st, "Home Phone: %s\n",
456                                                       sd->info_phonehome);
457                        }
458                        g_free(sd->info_phonehome);
459                        sd->info_phonehome = NULL;
460                }
461                if (sd->info_phoneoffice) {
462                        if (strlen(sd->info_phoneoffice)) {
463                                g_string_append_printf(st, "Office Phone: %s\n",
464                                                       sd->info_phoneoffice);
465                        }
466                        g_free(sd->info_phoneoffice);
467                        sd->info_phoneoffice = NULL;
468                }
469                if (sd->info_phonemobile) {
470                        if (strlen(sd->info_phonemobile)) {
471                                g_string_append_printf(st, "Mobile Phone: %s\n",
472                                                       sd->info_phonemobile);
473                        }
474                        g_free(sd->info_phonemobile);
475                        sd->info_phonemobile = NULL;
476                }
477                g_string_append_printf(st, "Personal Information\n");
478                if (sd->info_nrbuddies) {
479                        if (strlen(sd->info_nrbuddies)) {
480                                g_string_append_printf(st,
481                                                       "Contacts: %s\n", sd->info_nrbuddies);
482                        }
483                        g_free(sd->info_nrbuddies);
484                        sd->info_nrbuddies = NULL;
485                }
486                if (sd->info_tz) {
487                        if (strlen(sd->info_tz)) {
488                                char ib[256];
489                                time_t t = time(NULL);
490                                t += atoi(sd->info_tz) - (60 * 60 * 24);
491                                struct tm *gt = gmtime(&t);
492                                strftime(ib, 256, "%H:%M:%S", gt);
493                                g_string_append_printf(st,
494                                                       "Local Time: %s\n", ib);
495                        }
496                        g_free(sd->info_tz);
497                        sd->info_tz = NULL;
498                }
499                if (sd->info_seen) {
500                        if (strlen(sd->info_seen)) {
501                                char ib[256];
502                                time_t it = atoi(sd->info_seen);
503                                struct tm *tm = localtime(&it);
504                                strftime(ib, 256, ("%Y. %m. %d. %H:%M"), tm);
505                                g_string_append_printf(st,
506                                                       "Last Seen: %s\n", ib);
507                        }
508                        g_free(sd->info_seen);
509                        sd->info_seen = NULL;
510                }
511                if (sd->info_birthday) {
512                        if (strlen(sd->info_birthday) &&
513                            strcmp(sd->info_birthday, "0")) {
514                                char ib[256];
515                                struct tm tm;
516                                strptime(sd->info_birthday, "%Y%m%d", &tm);
517                                strftime(ib, 256, "%B %d, %Y", &tm);
518                                g_string_append_printf(st,
519                                                       "Birthday: %s\n", ib);
520
521                                strftime(ib, 256, "%Y", &tm);
522                                int year = atoi(ib);
523                                time_t t = time(NULL);
524                                struct tm *lt = localtime(&t);
525                                g_string_append_printf(st,
526                                                       "Age: %d\n", lt->tm_year + 1900 - year);
527                        }
528                        g_free(sd->info_birthday);
529                        sd->info_birthday = NULL;
530                }
531                if (sd->info_sex) {
532                        if (strlen(sd->info_sex)) {
533                                char *iptr = sd->info_sex;
534                                while (*iptr++) {
535                                        *iptr = g_ascii_tolower(*iptr);
536                                }
537                                g_string_append_printf(st,
538                                                       "Gender: %s\n", sd->info_sex);
539                        }
540                        g_free(sd->info_sex);
541                        sd->info_sex = NULL;
542                }
543                if (sd->info_language) {
544                        if (strlen(sd->info_language)) {
545                                char *iptr = strchr(sd->info_language, ' ');
546                                if (iptr) {
547                                        iptr++;
548                                } else {
549                                        iptr = sd->info_language;
550                                }
551                                g_string_append_printf(st,
552                                                       "Language: %s\n", iptr);
553                        }
554                        g_free(sd->info_language);
555                        sd->info_language = NULL;
556                }
557                if (sd->info_country) {
558                        if (strlen(sd->info_country)) {
559                                char *iptr = strchr(sd->info_country, ' ');
560                                if (iptr) {
561                                        iptr++;
562                                } else {
563                                        iptr = sd->info_country;
564                                }
565                                g_string_append_printf(st,
566                                                       "Country: %s\n", iptr);
567                        }
568                        g_free(sd->info_country);
569                        sd->info_country = NULL;
570                }
571                if (sd->info_province) {
572                        if (strlen(sd->info_province)) {
573                                g_string_append_printf(st,
574                                                       "Region: %s\n", sd->info_province);
575                        }
576                        g_free(sd->info_province);
577                        sd->info_province = NULL;
578                }
579                if (sd->info_city) {
580                        if (strlen(sd->info_city)) {
581                                g_string_append_printf(st,
582                                                       "City: %s\n", sd->info_city);
583                        }
584                        g_free(sd->info_city);
585                        sd->info_city = NULL;
586                }
587                if (sd->info_homepage) {
588                        if (strlen(sd->info_homepage)) {
589                                g_string_append_printf(st,
590                                                       "Homepage: %s\n", sd->info_homepage);
591                        }
592                        g_free(sd->info_homepage);
593                        sd->info_homepage = NULL;
594                }
595                if (sd->info_about) {
596                        if (strlen(sd->info_about)) {
597                                g_string_append_printf(st, "%s\n",
598                                                       sd->info_about);
599                        }
600                        g_free(sd->info_about);
601                        sd->info_about = NULL;
602                }
603                imcb_log(ic, "%s", st->str);
604                g_string_free(st, TRUE);
605        }
606}
607
608static void skype_parse_chatmessage_said_emoted(struct im_connection *ic, struct groupchat *gc, char *body)
609{
610        struct skype_data *sd = ic->proto_data;
611        char buf[IRC_LINE_SIZE];
612
613        if (!strcmp(sd->type, "SAID")) {
614                if (!sd->is_edit) {
615                        g_snprintf(buf, IRC_LINE_SIZE, "%s", body);
616                } else {
617                        g_snprintf(buf, IRC_LINE_SIZE, "%s %s", set_getstr(&ic->acc->set, "edit_prefix"), body);
618                        sd->is_edit = 0;
619                }
620        } else {
621                g_snprintf(buf, IRC_LINE_SIZE, "/me %s", body);
622        }
623        if (!gc) {
624                /* Private message */
625                imcb_buddy_msg(ic, sd->handle, buf, 0, 0);
626        } else {
627                /* Groupchat message */
628                imcb_chat_msg(gc, sd->handle, buf, 0, 0);
629        }
630}
631
632static void skype_parse_chatmessage(struct im_connection *ic, char *line)
633{
634        struct skype_data *sd = ic->proto_data;
635        char *id = strchr(line, ' ');
636
637        if (!++id) {
638                return;
639        }
640        char *info = strchr(id, ' ');
641
642        if (!info) {
643                return;
644        }
645        *info = '\0';
646        info++;
647        if (!strcmp(info, "STATUS RECEIVED") || !strncmp(info, "EDITED_TIMESTAMP", 16)) {
648                /* New message ID:
649                 * (1) Request its from field
650                 * (2) Request its body
651                 * (3) Request its type
652                 * (4) Query chatname
653                 */
654                skype_printf(ic, "GET CHATMESSAGE %s FROM_HANDLE\n", id);
655                if (!strcmp(info, "STATUS RECEIVED")) {
656                        skype_printf(ic, "GET CHATMESSAGE %s BODY\n", id);
657                } else {
658                        sd->is_edit = 1;
659                }
660                skype_printf(ic, "GET CHATMESSAGE %s TYPE\n", id);
661                skype_printf(ic, "GET CHATMESSAGE %s CHATNAME\n", id);
662        } else if (!strncmp(info, "FROM_HANDLE ", 12)) {
663                info += 12;
664                /* New from field value. Store
665                 * it, then we can later use it
666                 * when we got the message's
667                 * body. */
668                g_free(sd->handle);
669                sd->handle = g_strdup_printf("%s@skype.com", info);
670        } else if (!strncmp(info, "EDITED_BY ", 10)) {
671                info += 10;
672                /* This is the same as
673                 * FROM_HANDLE, except that we
674                 * never request these lines
675                 * from Skype, we just get
676                 * them. */
677                g_free(sd->handle);
678                sd->handle = g_strdup_printf("%s@skype.com", info);
679        } else if (!strncmp(info, "BODY ", 5)) {
680                info += 5;
681                sd->body = g_list_append(sd->body, g_strdup(info));
682        } else if (!strncmp(info, "TYPE ", 5)) {
683                info += 5;
684                g_free(sd->type);
685                sd->type = g_strdup(info);
686        } else if (!strncmp(info, "CHATNAME ", 9)) {
687                info += 9;
688                if (sd->handle && sd->body && sd->type) {
689                        struct groupchat *gc = bee_chat_by_title(ic->bee, ic, info);
690                        int i;
691                        for (i = 0; i < g_list_length(sd->body); i++) {
692                                char *body = g_list_nth_data(sd->body, i);
693                                if (!strcmp(sd->type, "SAID") ||
694                                    !strcmp(sd->type, "EMOTED")) {
695                                        skype_parse_chatmessage_said_emoted(ic, gc, body);
696                                } else if (!strcmp(sd->type, "SETTOPIC") && gc) {
697                                        imcb_chat_topic(gc,
698                                                        sd->handle, body, 0);
699                                } else if (!strcmp(sd->type, "LEFT") && gc) {
700                                        imcb_chat_remove_buddy(gc,
701                                                               sd->handle, NULL);
702                                }
703                        }
704                        g_list_free(sd->body);
705                        sd->body = NULL;
706                }
707        }
708}
709
710static void skype_parse_call(struct im_connection *ic, char *line)
711{
712        struct skype_data *sd = ic->proto_data;
713        char *id = strchr(line, ' ');
714        char buf[IRC_LINE_SIZE];
715
716        if (!++id) {
717                return;
718        }
719        char *info = strchr(id, ' ');
720
721        if (!info) {
722                return;
723        }
724        *info = '\0';
725        info++;
726        if (!strncmp(info, "FAILUREREASON ", 14)) {
727                sd->failurereason = atoi(strchr(info, ' '));
728        } else if (!strcmp(info, "STATUS RINGING")) {
729                if (sd->call_id) {
730                        g_free(sd->call_id);
731                }
732                sd->call_id = g_strdup(id);
733                skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
734                sd->call_status = SKYPE_CALL_RINGING;
735        } else if (!strcmp(info, "STATUS MISSED")) {
736                skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
737                sd->call_status = SKYPE_CALL_MISSED;
738        } else if (!strcmp(info, "STATUS CANCELLED")) {
739                skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
740                sd->call_status = SKYPE_CALL_CANCELLED;
741        } else if (!strcmp(info, "STATUS FINISHED")) {
742                skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
743                sd->call_status = SKYPE_CALL_FINISHED;
744        } else if (!strcmp(info, "STATUS REFUSED")) {
745                skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
746                sd->call_status = SKYPE_CALL_REFUSED;
747        } else if (!strcmp(info, "STATUS UNPLACED")) {
748                if (sd->call_id) {
749                        g_free(sd->call_id);
750                }
751                /* Save the ID for later usage (Cancel/Finish). */
752                sd->call_id = g_strdup(id);
753                sd->call_out = TRUE;
754        } else if (!strcmp(info, "STATUS FAILED")) {
755                imcb_error(ic, "Call failed: %s",
756                           skype_call_strerror(sd->failurereason));
757                sd->call_id = NULL;
758        } else if (!strncmp(info, "DURATION ", 9)) {
759                if (sd->call_duration) {
760                        g_free(sd->call_duration);
761                }
762                sd->call_duration = g_strdup(info + 9);
763        } else if (!strncmp(info, "PARTNER_HANDLE ", 15)) {
764                info += 15;
765                if (!sd->call_status) {
766                        return;
767                }
768                switch (sd->call_status) {
769                case SKYPE_CALL_RINGING:
770                        if (sd->call_out) {
771                                imcb_log(ic, "You are currently ringing the user %s.", info);
772                        } else {
773                                g_snprintf(buf, IRC_LINE_SIZE,
774                                           "The user %s is currently ringing you.",
775                                           info);
776                                skype_call_ask(ic, sd->call_id, buf);
777                        }
778                        break;
779                case SKYPE_CALL_MISSED:
780                        imcb_log(ic, "You have missed a call from user %s.",
781                                 info);
782                        break;
783                case SKYPE_CALL_CANCELLED:
784                        imcb_log(ic, "You cancelled the call to the user %s.",
785                                 info);
786                        sd->call_status = 0;
787                        sd->call_out = FALSE;
788                        break;
789                case SKYPE_CALL_REFUSED:
790                        if (sd->call_out) {
791                                imcb_log(ic, "The user %s refused the call.",
792                                         info);
793                        } else {
794                                imcb_log(ic,
795                                         "You refused the call from user %s.",
796                                         info);
797                        }
798                        sd->call_out = FALSE;
799                        break;
800                case SKYPE_CALL_FINISHED:
801                        if (sd->call_duration) {
802                                imcb_log(ic,
803                                         "You finished the call to the user %s "
804                                         "(duration: %s seconds).",
805                                         info, sd->call_duration);
806                        } else {
807                                imcb_log(ic,
808                                         "You finished the call to the user %s.",
809                                         info);
810                        }
811                        sd->call_out = FALSE;
812                        break;
813                default:
814                        /* Don't be noisy, ignore other statuses for now. */
815                        break;
816                }
817                sd->call_status = 0;
818        }
819}
820
821static void skype_parse_filetransfer(struct im_connection *ic, char *line)
822{
823        struct skype_data *sd = ic->proto_data;
824        char *id = strchr(line, ' ');
825
826        if (!++id) {
827                return;
828        }
829        char *info = strchr(id, ' ');
830
831        if (!info) {
832                return;
833        }
834        *info = '\0';
835        info++;
836        if (!strcmp(info, "STATUS NEW")) {
837                skype_printf(ic, "GET FILETRANSFER %s PARTNER_HANDLE\n",
838                             id);
839                sd->filetransfer_status = SKYPE_FILETRANSFER_NEW;
840        } else if (!strcmp(info, "STATUS FAILED")) {
841                skype_printf(ic, "GET FILETRANSFER %s PARTNER_HANDLE\n",
842                             id);
843                sd->filetransfer_status = SKYPE_FILETRANSFER_FAILED;
844        } else if (!strcmp(info, "STATUS COMPLETED")) {
845                skype_printf(ic, "GET FILETRANSFER %s PARTNER_HANDLE\n", id);
846                sd->filetransfer_status = SKYPE_FILETRANSFER_COMPLETED;
847        } else if (!strcmp(info, "STATUS TRANSFERRING")) {
848                skype_printf(ic, "GET FILETRANSFER %s PARTNER_HANDLE\n", id);
849                sd->filetransfer_status = SKYPE_FILETRANSFER_TRANSFERRING;
850        } else if (!strncmp(info, "FILEPATH ", 9)) {
851                info += 9;
852                sd->filetransfer_path = g_strdup(info);
853        } else if (!strncmp(info, "PARTNER_HANDLE ", 15)) {
854                info += 15;
855                if (!sd->filetransfer_status) {
856                        return;
857                }
858                switch (sd->filetransfer_status) {
859                case SKYPE_FILETRANSFER_NEW:
860                        imcb_log(ic, "The user %s offered a new file for you.",
861                                 info);
862                        break;
863                case SKYPE_FILETRANSFER_FAILED:
864                        imcb_log(ic, "Failed to transfer file from user %s.",
865                                 info);
866                        break;
867                case SKYPE_FILETRANSFER_COMPLETED:
868                        imcb_log(ic, "File transfer from user %s completed.", info);
869                        break;
870                case SKYPE_FILETRANSFER_TRANSFERRING:
871                        if (sd->filetransfer_path) {
872                                imcb_log(ic, "File transfer from user %s started, saving to %s.", info,
873                                         sd->filetransfer_path);
874                                g_free(sd->filetransfer_path);
875                                sd->filetransfer_path = NULL;
876                        }
877                        break;
878                }
879                sd->filetransfer_status = 0;
880        }
881}
882
883static struct skype_group *skype_group_by_id(struct im_connection *ic, int id)
884{
885        struct skype_data *sd = ic->proto_data;
886        int i;
887
888        for (i = 0; i < g_list_length(sd->groups); i++) {
889                struct skype_group *sg = (struct skype_group *) g_list_nth_data(sd->groups, i);
890
891                if (sg->id == id) {
892                        return sg;
893                }
894        }
895        return NULL;
896}
897
898static void skype_group_free(struct skype_group *sg, gboolean usersonly)
899{
900        int i;
901
902        for (i = 0; i < g_list_length(sg->users); i++) {
903                char *user = g_list_nth_data(sg->users, i);
904                g_free(user);
905        }
906        sg->users = NULL;
907        if (usersonly) {
908                return;
909        }
910        g_free(sg->name);
911        g_free(sg);
912}
913
914/* Update the group of each user in this group */
915static void skype_group_users(struct im_connection *ic, struct skype_group *sg)
916{
917        int i;
918
919        for (i = 0; i < g_list_length(sg->users); i++) {
920                char *user = g_list_nth_data(sg->users, i);
921                char *buf = g_strdup_printf("%s@skype.com", user);
922                imcb_add_buddy(ic, buf, sg->name);
923                g_free(buf);
924        }
925}
926
927static void skype_parse_group(struct im_connection *ic, char *line)
928{
929        struct skype_data *sd = ic->proto_data;
930        char *id = strchr(line, ' ');
931
932        if (!++id) {
933                return;
934        }
935
936        char *info = strchr(id, ' ');
937
938        if (!info) {
939                return;
940        }
941        *info = '\0';
942        info++;
943
944        if (!strncmp(info, "DISPLAYNAME ", 12)) {
945                info += 12;
946
947                /* Name given for a group ID: try to update it or insert a new
948                 * one if not found */
949                struct skype_group *sg = skype_group_by_id(ic, atoi(id));
950                if (sg) {
951                        g_free(sg->name);
952                        sg->name = g_strdup(info);
953                } else {
954                        sg = g_new0(struct skype_group, 1);
955                        sg->id = atoi(id);
956                        sg->name = g_strdup(info);
957                        sd->groups = g_list_append(sd->groups, sg);
958                }
959        } else if (!strncmp(info, "USERS ", 6)) {
960                struct skype_group *sg = skype_group_by_id(ic, atoi(id));
961
962                if (sg) {
963                        char **i;
964                        char **users = g_strsplit(info + 6, ", ", 0);
965
966                        skype_group_free(sg, TRUE);
967                        i = users;
968                        while (*i) {
969                                sg->users = g_list_append(sg->users, g_strdup(*i));
970                                i++;
971                        }
972                        g_strfreev(users);
973                        skype_group_users(ic, sg);
974                } else {
975                        log_message(LOGLVL_ERROR,
976                                    "No skype group with id %s. That's probably a bug.", id);
977                }
978        } else if (!strncmp(info, "NROFUSERS ", 10)) {
979                if (!sd->pending_user) {
980                        /* Number of users changed in this group, query its type to see
981                         * if it's a custom one we should care about. */
982                        skype_printf(ic, "GET GROUP %s TYPE\n", id);
983                        return;
984                }
985
986                /* This is a newly created group, we have a single user
987                 * to add. */
988                struct skype_group *sg = skype_group_by_id(ic, atoi(id));
989
990                if (sg) {
991                        skype_printf(ic, "ALTER GROUP %d ADDUSER %s\n", sg->id, sd->pending_user);
992                        g_free(sd->pending_user);
993                        sd->pending_user = NULL;
994                } else {
995                        log_message(LOGLVL_ERROR,
996                                    "No skype group with id %s. That's probably a bug.", id);
997                }
998        } else if (!strcmp(info, "TYPE CUSTOM_GROUP")) {
999                /* This one is interesting, query its users. */
1000                skype_printf(ic, "GET GROUP %s USERS\n", id);
1001        }
1002}
1003
1004static void skype_parse_chat(struct im_connection *ic, char *line)
1005{
1006        struct skype_data *sd = ic->proto_data;
1007        char buf[IRC_LINE_SIZE];
1008        char *id = strchr(line, ' ');
1009
1010        if (!++id) {
1011                return;
1012        }
1013        struct groupchat *gc;
1014        char *info = strchr(id, ' ');
1015
1016        if (!info) {
1017                return;
1018        }
1019        *info = '\0';
1020        info++;
1021        /* Remove fake chat if we created one in skype_chat_with() */
1022        gc = bee_chat_by_title(ic->bee, ic, "");
1023        if (gc) {
1024                imcb_chat_free(gc);
1025        }
1026        if (!strcmp(info, "STATUS MULTI_SUBSCRIBED")) {
1027                gc = bee_chat_by_title(ic->bee, ic, id);
1028                if (!gc) {
1029                        gc = imcb_chat_new(ic, id);
1030                        imcb_chat_name_hint(gc, id);
1031                }
1032                skype_printf(ic, "GET CHAT %s ADDER\n", id);
1033                skype_printf(ic, "GET CHAT %s TOPIC\n", id);
1034        } else if (!strcmp(info, "STATUS DIALOG") && sd->groupchat_with) {
1035                gc = imcb_chat_new(ic, id);
1036                imcb_chat_name_hint(gc, id);
1037                /* According to the docs this
1038                 * is necessary. However it
1039                 * does not seem the situation
1040                 * and it would open an extra
1041                 * window on our client, so
1042                 * just leave it out. */
1043                /*skype_printf(ic, "OPEN CHAT %s\n", id);*/
1044                g_snprintf(buf, IRC_LINE_SIZE, "%s@skype.com",
1045                           sd->groupchat_with);
1046                imcb_chat_add_buddy(gc, buf);
1047                imcb_chat_add_buddy(gc, sd->username);
1048                g_free(sd->groupchat_with);
1049                sd->groupchat_with = NULL;
1050                skype_printf(ic, "GET CHAT %s ADDER\n", id);
1051                skype_printf(ic, "GET CHAT %s TOPIC\n", id);
1052        } else if (!strcmp(info, "STATUS UNSUBSCRIBED")) {
1053                gc = bee_chat_by_title(ic->bee, ic, id);
1054                if (gc) {
1055                        gc->data = (void *) FALSE;
1056                }
1057        } else if (!strncmp(info, "ADDER ", 6)) {
1058                info += 6;
1059                g_free(sd->adder);
1060                sd->adder = g_strdup_printf("%s@skype.com", info);
1061        } else if (!strncmp(info, "TOPIC ", 6)) {
1062                info += 6;
1063                gc = bee_chat_by_title(ic->bee, ic, id);
1064                if (gc && (sd->adder || sd->topic_wait)) {
1065                        if (sd->topic_wait) {
1066                                sd->adder = g_strdup(sd->username);
1067                                sd->topic_wait = 0;
1068                        }
1069                        imcb_chat_topic(gc, sd->adder, info, 0);
1070                        g_free(sd->adder);
1071                        sd->adder = NULL;
1072                }
1073        } else if (!strncmp(info, "MEMBERS ", 8) || !strncmp(info, "ACTIVEMEMBERS ", 14)) {
1074                if (!strncmp(info, "MEMBERS ", 8)) {
1075                        info += 8;
1076                } else {
1077                        info += 14;
1078                }
1079                gc = bee_chat_by_title(ic->bee, ic, id);
1080                /* Hack! We set ->data to TRUE
1081                 * while we're on the channel
1082                 * so that we won't rejoin
1083                 * after a /part. */
1084                if (!gc || gc->data) {
1085                        return;
1086                }
1087                char **members = g_strsplit(info, " ", 0);
1088                int i;
1089                for (i = 0; members[i]; i++) {
1090                        if (!strcmp(members[i], sd->username)) {
1091                                continue;
1092                        }
1093                        g_snprintf(buf, IRC_LINE_SIZE, "%s@skype.com",
1094                                   members[i]);
1095                        if (!g_list_find_custom(gc->in_room, buf,
1096                                                (GCompareFunc) strcmp)) {
1097                                imcb_chat_add_buddy(gc, buf);
1098                        }
1099                }
1100                imcb_chat_add_buddy(gc, sd->username);
1101                g_strfreev(members);
1102        }
1103}
1104
1105static void skype_parse_password(struct im_connection *ic, char *line)
1106{
1107        if (!strncmp(line + 9, "OK", 2)) {
1108                imcb_connected(ic);
1109        } else {
1110                imcb_error(ic, "Authentication Failed");
1111                imc_logout(ic, TRUE);
1112        }
1113}
1114
1115static void skype_parse_profile(struct im_connection *ic, char *line)
1116{
1117        imcb_log(ic, "SkypeOut balance value is '%s'.", line + 21);
1118}
1119
1120static void skype_parse_ping(struct im_connection *ic, char *line)
1121{
1122        /* Unused parameter */
1123        line = line;
1124        skype_printf(ic, "PONG\n");
1125}
1126
1127static void skype_parse_chats(struct im_connection *ic, char *line)
1128{
1129        char **i;
1130        char **chats = g_strsplit(line + 6, ", ", 0);
1131
1132        i = chats;
1133        while (*i) {
1134                skype_printf(ic, "GET CHAT %s STATUS\n", *i);
1135                skype_printf(ic, "GET CHAT %s ACTIVEMEMBERS\n", *i);
1136                i++;
1137        }
1138        g_strfreev(chats);
1139}
1140
1141static void skype_parse_groups(struct im_connection *ic, char *line)
1142{
1143        if (!set_getbool(&ic->acc->set, "read_groups")) {
1144                return;
1145        }
1146
1147        char **i;
1148        char **groups = g_strsplit(line + 7, ", ", 0);
1149
1150        i = groups;
1151        while (*i) {
1152                skype_printf(ic, "GET GROUP %s DISPLAYNAME\n", *i);
1153                skype_printf(ic, "GET GROUP %s USERS\n", *i);
1154                i++;
1155        }
1156        g_strfreev(groups);
1157}
1158
1159static void skype_parse_alter_group(struct im_connection *ic, char *line)
1160{
1161        char *id = line + strlen("ALTER GROUP");
1162
1163        if (!++id) {
1164                return;
1165        }
1166
1167        char *info = strchr(id, ' ');
1168
1169        if (!info) {
1170                return;
1171        }
1172        *info = '\0';
1173        info++;
1174
1175        if (!strncmp(info, "ADDUSER ", 8)) {
1176                struct skype_group *sg = skype_group_by_id(ic, atoi(id));
1177
1178                info += 8;
1179                if (sg) {
1180                        char *buf = g_strdup_printf("%s@skype.com", info);
1181                        sg->users = g_list_append(sg->users, g_strdup(info));
1182                        imcb_add_buddy(ic, buf, sg->name);
1183                        g_free(buf);
1184                } else {
1185                        log_message(LOGLVL_ERROR,
1186                                    "No skype group with id %s. That's probably a bug.", id);
1187                }
1188        }
1189}
1190
1191typedef void (*skype_parser)(struct im_connection *ic, char *line);
1192
1193static gboolean skype_read_callback(gpointer data, gint fd,
1194                                    b_input_condition cond)
1195{
1196        struct im_connection *ic = data;
1197        struct skype_data *sd = ic->proto_data;
1198        char buf[IRC_LINE_SIZE];
1199        int st, i;
1200        char **lines, **lineptr, *line;
1201        static struct parse_map {
1202                char *k;
1203                skype_parser v;
1204        } parsers[] = {
1205                { "USERS ", skype_parse_users },
1206                { "USER ", skype_parse_user },
1207                { "CHATMESSAGE ", skype_parse_chatmessage },
1208                { "CALL ", skype_parse_call },
1209                { "FILETRANSFER ", skype_parse_filetransfer },
1210                { "CHAT ", skype_parse_chat },
1211                { "GROUP ", skype_parse_group },
1212                { "PASSWORD ", skype_parse_password },
1213                { "PROFILE PSTN_BALANCE ", skype_parse_profile },
1214                { "PING", skype_parse_ping },
1215                { "CHATS ", skype_parse_chats },
1216                { "GROUPS ", skype_parse_groups },
1217                { "ALTER GROUP ", skype_parse_alter_group },
1218        };
1219
1220        /* Unused parameters */
1221        fd = fd;
1222        cond = cond;
1223
1224        if (!sd || sd->fd == -1) {
1225                return FALSE;
1226        }
1227        /* Read the whole data. */
1228        st = ssl_read(sd->ssl, buf, sizeof(buf));
1229        if (st >= IRC_LINE_SIZE - 1) {
1230                /* As we don't buffer incoming data, if IRC_LINE_SIZE amount of bytes
1231                 * were received, there's a good chance last message was truncated
1232                 * and the next recv() will yield garbage. */
1233                imcb_error(ic, "Unable to handle incoming data from skyped");
1234                st = 0;
1235        }
1236        if (st > 0) {
1237                buf[st] = '\0';
1238                /* Then split it up to lines. */
1239                lines = g_strsplit(buf, "\n", 0);
1240                lineptr = lines;
1241                while ((line = *lineptr)) {
1242                        if (!strlen(line)) {
1243                                break;
1244                        }
1245                        if (set_getbool(&ic->acc->set, "skypeconsole_receive")) {
1246                                imcb_buddy_msg(ic, "skypeconsole", line, 0, 0);
1247                        }
1248                        for (i = 0; i < ARRAY_SIZE(parsers); i++) {
1249                                if (!strncmp(line, parsers[i].k,
1250                                             strlen(parsers[i].k))) {
1251                                        parsers[i].v(ic, line);
1252                                        break;
1253                                }
1254                        }
1255                        lineptr++;
1256                }
1257                g_strfreev(lines);
1258        } else if (st == 0 || (st < 0 && !ssl_sockerr_again(sd->ssl))) {
1259                ssl_disconnect(sd->ssl);
1260                sd->fd = -1;
1261                sd->ssl = NULL;
1262
1263                imcb_error(ic, "Error while reading from server");
1264                imc_logout(ic, TRUE);
1265                return FALSE;
1266        }
1267        return TRUE;
1268}
1269
1270gboolean skype_start_stream(struct im_connection *ic)
1271{
1272        struct skype_data *sd = ic->proto_data;
1273        int st;
1274
1275        if (!sd) {
1276                return FALSE;
1277        }
1278
1279        if (sd->bfd <= 0) {
1280                sd->bfd = b_input_add(sd->fd, B_EV_IO_READ,
1281                                      skype_read_callback, ic);
1282        }
1283
1284        /* Log in */
1285        skype_printf(ic, "USERNAME %s\n", ic->acc->user);
1286        skype_printf(ic, "PASSWORD %s\n", ic->acc->pass);
1287
1288        /* This will download all buddies and groups. */
1289        st = skype_printf(ic, "SEARCH GROUPS CUSTOM\n");
1290        skype_printf(ic, "SEARCH FRIENDS\n");
1291
1292        skype_printf(ic, "SET USERSTATUS ONLINE\n");
1293
1294        /* Auto join to bookmarked chats if requested.*/
1295        if (set_getbool(&ic->acc->set, "auto_join")) {
1296                skype_printf(ic, "SEARCH BOOKMARKEDCHATS\n");
1297                skype_printf(ic, "SEARCH ACTIVECHATS\n");
1298                skype_printf(ic, "SEARCH MISSEDCHATS\n");
1299                skype_printf(ic, "SEARCH RECENTCHATS\n");
1300        }
1301        return st;
1302}
1303
1304gboolean skype_connected(gpointer data, int returncode, void *source, b_input_condition cond)
1305{
1306        struct im_connection *ic = data;
1307        struct skype_data *sd = ic->proto_data;
1308
1309        /* Unused parameter */
1310        cond = cond;
1311
1312        if (!source) {
1313                sd->ssl = NULL;
1314                imcb_error(ic, "Could not connect to server");
1315                imc_logout(ic, TRUE);
1316                return FALSE;
1317        }
1318        imcb_log(ic, "Connected to server, logging in");
1319
1320        return skype_start_stream(ic);
1321}
1322
1323static void skype_login(account_t *acc)
1324{
1325        struct im_connection *ic = imcb_new(acc);
1326        struct skype_data *sd = g_new0(struct skype_data, 1);
1327
1328        ic->proto_data = sd;
1329
1330        imcb_log(ic, "Connecting");
1331        sd->ssl = ssl_connect(set_getstr(&acc->set, "server"),
1332                              set_getint(&acc->set, "port"), FALSE, skype_connected, ic);
1333        sd->fd = sd->ssl ? ssl_getfd(sd->ssl) : -1;
1334        sd->username = g_strdup(acc->user);
1335
1336        sd->ic = ic;
1337
1338        if (set_getbool(&acc->set, "skypeconsole")) {
1339                imcb_add_buddy(ic, "skypeconsole", NULL);
1340        }
1341}
1342
1343static void skype_logout(struct im_connection *ic)
1344{
1345        struct skype_data *sd = ic->proto_data;
1346        int i;
1347
1348        skype_printf(ic, "SET USERSTATUS OFFLINE\n");
1349
1350        while (ic->groupchats) {
1351                imcb_chat_free(ic->groupchats->data);
1352        }
1353
1354        for (i = 0; i < g_list_length(sd->groups); i++) {
1355                struct skype_group *sg = (struct skype_group *) g_list_nth_data(sd->groups, i);
1356                skype_group_free(sg, FALSE);
1357        }
1358
1359        if (sd->ssl) {
1360                ssl_disconnect(sd->ssl);
1361        }
1362
1363        g_free(sd->username);
1364        g_free(sd->handle);
1365        g_free(sd);
1366        ic->proto_data = NULL;
1367}
1368
1369static int skype_buddy_msg(struct im_connection *ic, char *who, char *message,
1370                           int flags)
1371{
1372        char *ptr, *nick;
1373        int st;
1374
1375        /* Unused parameter */
1376        flags = flags;
1377
1378        nick = g_strdup(who);
1379        ptr = strchr(nick, '@');
1380        if (ptr) {
1381                *ptr = '\0';
1382        }
1383
1384        if (!strncmp(who, "skypeconsole", 12)) {
1385                st = skype_printf(ic, "%s\n", message);
1386        } else {
1387                st = skype_printf(ic, "MESSAGE %s %s\n", nick, message);
1388        }
1389        g_free(nick);
1390
1391        return st;
1392}
1393
1394const struct skype_away_state *skype_away_state_by_name(char *name)
1395{
1396        int i;
1397
1398        for (i = 0; skype_away_state_list[i].full_name; i++) {
1399                if (g_strcasecmp(skype_away_state_list[i].full_name, name) == 0) {
1400                        return skype_away_state_list + i;
1401                }
1402        }
1403
1404        return NULL;
1405}
1406
1407static void skype_set_away(struct im_connection *ic, char *state_txt,
1408                           char *message)
1409{
1410        const struct skype_away_state *state;
1411
1412        /* Unused parameter */
1413        message = message;
1414
1415        if (state_txt == NULL) {
1416                state = skype_away_state_by_name("Online");
1417        } else {
1418                state = skype_away_state_by_name(state_txt);
1419        }
1420        skype_printf(ic, "SET USERSTATUS %s\n", state->code);
1421}
1422
1423static GList *skype_away_states(struct im_connection *ic)
1424{
1425        static GList *l;
1426        int i;
1427
1428        /* Unused parameter */
1429        ic = ic;
1430
1431        if (l == NULL) {
1432                for (i = 0; skype_away_state_list[i].full_name; i++) {
1433                        l = g_list_append(l,
1434                                          (void *) skype_away_state_list[i].full_name);
1435                }
1436        }
1437
1438        return l;
1439}
1440
1441static char *skype_set_display_name(set_t *set, char *value)
1442{
1443        account_t *acc = set->data;
1444        struct im_connection *ic = acc->ic;
1445
1446        skype_printf(ic, "SET PROFILE FULLNAME %s\n", value);
1447        return value;
1448}
1449
1450static char *skype_set_mood_text(set_t *set, char *value)
1451{
1452        account_t *acc = set->data;
1453        struct im_connection *ic = acc->ic;
1454
1455        skype_printf(ic, "SET PROFILE MOOD_TEXT %s\n", value);
1456        return value;
1457}
1458
1459static char *skype_set_balance(set_t *set, char *value)
1460{
1461        account_t *acc = set->data;
1462        struct im_connection *ic = acc->ic;
1463
1464        skype_printf(ic, "GET PROFILE PSTN_BALANCE\n");
1465        return value;
1466}
1467
1468static void skype_call(struct im_connection *ic, char *value)
1469{
1470        char *nick = g_strdup(value);
1471        char *ptr = strchr(nick, '@');
1472
1473        if (ptr) {
1474                *ptr = '\0';
1475        }
1476        skype_printf(ic, "CALL %s\n", nick);
1477        g_free(nick);
1478}
1479
1480static void skype_hangup(struct im_connection *ic)
1481{
1482        struct skype_data *sd = ic->proto_data;
1483
1484        if (sd->call_id) {
1485                skype_printf(ic, "SET CALL %s STATUS FINISHED\n",
1486                             sd->call_id);
1487                g_free(sd->call_id);
1488                sd->call_id = 0;
1489        } else {
1490                imcb_error(ic, "There are no active calls currently.");
1491        }
1492}
1493
1494static char *skype_set_call(set_t *set, char *value)
1495{
1496        account_t *acc = set->data;
1497        struct im_connection *ic = acc->ic;
1498
1499        if (value) {
1500                skype_call(ic, value);
1501        } else {
1502                skype_hangup(ic);
1503        }
1504        return value;
1505}
1506
1507static void skype_add_buddy(struct im_connection *ic, char *who, char *group)
1508{
1509        struct skype_data *sd = ic->proto_data;
1510        char *nick, *ptr;
1511
1512        nick = g_strdup(who);
1513        ptr = strchr(nick, '@');
1514        if (ptr) {
1515                *ptr = '\0';
1516        }
1517
1518        if (!group) {
1519                skype_printf(ic, "SET USER %s BUDDYSTATUS 2 Please authorize me\n",
1520                             nick);
1521                g_free(nick);
1522        } else {
1523                struct skype_group *sg = skype_group_by_name(ic, group);
1524
1525                if (!sg) {
1526                        /* No such group, we need to create it, then have to
1527                         * add the user once it's created. */
1528                        skype_printf(ic, "CREATE GROUP %s\n", group);
1529                        sd->pending_user = g_strdup(nick);
1530                } else {
1531                        skype_printf(ic, "ALTER GROUP %d ADDUSER %s\n", sg->id, nick);
1532                }
1533        }
1534}
1535
1536static void skype_remove_buddy(struct im_connection *ic, char *who, char *group)
1537{
1538        char *nick, *ptr;
1539
1540        /* Unused parameter */
1541        group = group;
1542
1543        nick = g_strdup(who);
1544        ptr = strchr(nick, '@');
1545        if (ptr) {
1546                *ptr = '\0';
1547        }
1548        skype_printf(ic, "SET USER %s BUDDYSTATUS 1\n", nick);
1549        g_free(nick);
1550}
1551
1552void skype_chat_msg(struct groupchat *gc, char *message, int flags)
1553{
1554        struct im_connection *ic = gc->ic;
1555
1556        /* Unused parameter */
1557        flags = flags;
1558
1559        skype_printf(ic, "CHATMESSAGE %s %s\n", gc->title, message);
1560}
1561
1562void skype_chat_leave(struct groupchat *gc)
1563{
1564        struct im_connection *ic = gc->ic;
1565
1566        skype_printf(ic, "ALTER CHAT %s LEAVE\n", gc->title);
1567        gc->data = (void *) TRUE;
1568}
1569
1570void skype_chat_invite(struct groupchat *gc, char *who, char *message)
1571{
1572        struct im_connection *ic = gc->ic;
1573        char *ptr, *nick;
1574
1575        nick = g_strdup(who);
1576        ptr = strchr(nick, '@');
1577        if (ptr) {
1578                *ptr = '\0';
1579        }
1580        skype_printf(ic, "ALTER CHAT %s ADDMEMBERS %s\n", gc->title, nick);
1581        g_free(nick);
1582}
1583
1584void skype_chat_topic(struct groupchat *gc, char *message)
1585{
1586        struct im_connection *ic = gc->ic;
1587        struct skype_data *sd = ic->proto_data;
1588
1589        skype_printf(ic, "ALTER CHAT %s SETTOPIC %s\n",
1590                     gc->title, message);
1591        sd->topic_wait = 1;
1592}
1593
1594struct groupchat *skype_chat_with(struct im_connection *ic, char *who)
1595{
1596        struct skype_data *sd = ic->proto_data;
1597        char *ptr, *nick;
1598
1599        nick = g_strdup(who);
1600        ptr = strchr(nick, '@');
1601        if (ptr) {
1602                *ptr = '\0';
1603        }
1604        skype_printf(ic, "CHAT CREATE %s\n", nick);
1605        sd->groupchat_with = g_strdup(nick);
1606        g_free(nick);
1607        /* We create a fake chat for now. We will replace it with a real one in
1608         * the real callback. */
1609        return imcb_chat_new(ic, "");
1610}
1611
1612static void skype_get_info(struct im_connection *ic, char *who)
1613{
1614        struct skype_data *sd = ic->proto_data;
1615        char *ptr, *nick;
1616
1617        nick = g_strdup(who);
1618        ptr = strchr(nick, '@');
1619        if (ptr) {
1620                *ptr = '\0';
1621        }
1622        sd->is_info = TRUE;
1623        skype_printf(ic, "GET USER %s FULLNAME\n", nick);
1624        skype_printf(ic, "GET USER %s PHONE_HOME\n", nick);
1625        skype_printf(ic, "GET USER %s PHONE_OFFICE\n", nick);
1626        skype_printf(ic, "GET USER %s PHONE_MOBILE\n", nick);
1627        skype_printf(ic, "GET USER %s NROF_AUTHED_BUDDIES\n", nick);
1628        skype_printf(ic, "GET USER %s TIMEZONE\n", nick);
1629        skype_printf(ic, "GET USER %s LASTONLINETIMESTAMP\n", nick);
1630        skype_printf(ic, "GET USER %s SEX\n", nick);
1631        skype_printf(ic, "GET USER %s LANGUAGE\n", nick);
1632        skype_printf(ic, "GET USER %s COUNTRY\n", nick);
1633        skype_printf(ic, "GET USER %s PROVINCE\n", nick);
1634        skype_printf(ic, "GET USER %s CITY\n", nick);
1635        skype_printf(ic, "GET USER %s HOMEPAGE\n", nick);
1636        skype_printf(ic, "GET USER %s ABOUT\n", nick);
1637        /*
1638         * Hack: we query the bithday property which is always a single line,
1639         * so we can send the collected properties to the user when we have
1640         * this one.
1641         */
1642        skype_printf(ic, "GET USER %s BIRTHDAY\n", nick);
1643}
1644
1645static void skype_init(account_t *acc)
1646{
1647        set_t *s;
1648
1649        s = set_add(&acc->set, "server", SKYPE_DEFAULT_SERVER, set_eval_account,
1650                    acc);
1651        s->flags |= ACC_SET_OFFLINE_ONLY;
1652
1653        s = set_add(&acc->set, "port", SKYPE_DEFAULT_PORT, set_eval_int, acc);
1654        s->flags |= ACC_SET_OFFLINE_ONLY;
1655
1656        s = set_add(&acc->set, "display_name", NULL, skype_set_display_name,
1657                    acc);
1658        s->flags |= SET_NOSAVE | ACC_SET_ONLINE_ONLY;
1659
1660        s = set_add(&acc->set, "mood_text", NULL, skype_set_mood_text, acc);
1661        s->flags |= SET_NOSAVE | ACC_SET_ONLINE_ONLY;
1662
1663        s = set_add(&acc->set, "call", NULL, skype_set_call, acc);
1664        s->flags |= SET_NOSAVE | ACC_SET_ONLINE_ONLY;
1665
1666        s = set_add(&acc->set, "balance", NULL, skype_set_balance, acc);
1667        s->flags |= SET_NOSAVE | ACC_SET_ONLINE_ONLY;
1668
1669        s = set_add(&acc->set, "skypeout_offline", "true", set_eval_bool, acc);
1670
1671        s = set_add(&acc->set, "skypeconsole", "false", set_eval_bool, acc);
1672        s->flags |= ACC_SET_OFFLINE_ONLY;
1673
1674        s = set_add(&acc->set, "skypeconsole_receive", "false", set_eval_bool,
1675                    acc);
1676        s->flags |= ACC_SET_OFFLINE_ONLY;
1677
1678        s = set_add(&acc->set, "auto_join", "false", set_eval_bool, acc);
1679        s->flags |= ACC_SET_OFFLINE_ONLY;
1680
1681        s = set_add(&acc->set, "test_join", "false", set_eval_bool, acc);
1682        s->flags |= ACC_SET_OFFLINE_ONLY;
1683
1684        s = set_add(&acc->set, "show_moods", "false", set_eval_bool, acc);
1685
1686        s = set_add(&acc->set, "edit_prefix", "EDIT:",
1687                    NULL, acc);
1688
1689        s = set_add(&acc->set, "read_groups", "false", set_eval_bool, acc);
1690}
1691
1692#if BITLBEE_VERSION_CODE > BITLBEE_VER(3, 0, 1)
1693GList *skype_buddy_action_list(bee_user_t *bu)
1694{
1695        static GList *ret;
1696
1697        /* Unused parameter */
1698        bu = bu;
1699
1700        if (ret == NULL) {
1701                static const struct buddy_action ba[2] = {
1702                        { "CALL", "Initiate a call" },
1703                        { "HANGUP", "Hang up a call" },
1704                };
1705                int i;
1706
1707                for (i = 0; i < ARRAY_SIZE(ba); i++) {
1708                        ret = g_list_prepend(ret, (void *) (ba + i));
1709                }
1710        }
1711
1712        return ret;
1713}
1714
1715void *skype_buddy_action(struct bee_user *bu, const char *action, char * const args[], void *data)
1716{
1717        /* Unused parameters */
1718        args = args;
1719        data = data;
1720
1721        if (!g_strcasecmp(action, "CALL")) {
1722                skype_call(bu->ic, bu->handle);
1723        } else if (!g_strcasecmp(action, "HANGUP")) {
1724                skype_hangup(bu->ic);
1725        }
1726
1727        return NULL;
1728}
1729#endif
1730
1731void init_plugin(void)
1732{
1733        struct prpl *ret = g_new0(struct prpl, 1);
1734
1735        ret->name = "skype";
1736        ret->login = skype_login;
1737        ret->init = skype_init;
1738        ret->logout = skype_logout;
1739        ret->buddy_msg = skype_buddy_msg;
1740        ret->get_info = skype_get_info;
1741        ret->away_states = skype_away_states;
1742        ret->set_away = skype_set_away;
1743        ret->add_buddy = skype_add_buddy;
1744        ret->remove_buddy = skype_remove_buddy;
1745        ret->chat_msg = skype_chat_msg;
1746        ret->chat_leave = skype_chat_leave;
1747        ret->chat_invite = skype_chat_invite;
1748        ret->chat_with = skype_chat_with;
1749        ret->handle_cmp = g_strcasecmp;
1750        ret->chat_topic = skype_chat_topic;
1751#if BITLBEE_VERSION_CODE > BITLBEE_VER(3, 0, 1)
1752        ret->buddy_action_list = skype_buddy_action_list;
1753        ret->buddy_action = skype_buddy_action;
1754#endif
1755        register_protocol(ret);
1756}
Note: See TracBrowser for help on using the repository browser.