Context Navigation

source: skype/skype.c @ c213d6b

Last change on this file since c213d6b was c213d6b, checked in by Miklos Vajna <vmiklos@…>, at 2009-12-12T00:19:02Z
1024 -> IRC_LINE_SIZE
Property mode set to `100644`
File size: 34.1 KB

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

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

Download in other formats: