Context Navigation

source: skype/skype.c @ fbb15f2

Last change on this file since fbb15f2 was fbb15f2, checked in by Miklos Vajna <vmiklos@…>, at 2011-01-02T02:41:04Z
checkpatch fixes
Property mode set to `100644`
File size: 37.2 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: