Mercurial > pidgin
annotate libgaim/protocols/oscar/oscar.c @ 15085:f3573d941d66
[gaim-migrate @ 17871]
Minor cleanup. Mostly make some functions void instead of int where the
return value was always 0 and wasn't used
committer: Tailor Script <tailor@pidgin.im>
author | Mark Doliner <mark@kingant.net> |
---|---|
date | Sat, 02 Dec 2006 08:03:45 +0000 |
parents | d24de6319f87 |
children | 96c145316f34 |
rev | line source |
---|---|
14192 | 1 /* |
2 * gaim | |
3 * | |
4 * Some code copyright (C) 1998-1999, Mark Spencer <markster@marko.net> | |
5 * Some code copyright (C) 1999-2001, Eric Warmenhoven | |
6 * Some code copyright (C) 2001-2003, Sean Egan | |
7 * Some code copyright (C) 2001-2005, Mark Doliner <thekingant@users.sourceforge.net> | |
8 * Some code copyright (C) 2005, Jonathan Clark <ardentlygnarly@users.sourceforge.net> | |
9 * | |
10 * Most libfaim code copyright (C) 1998-2001 Adam Fritzler <afritz@auk.cx> | |
11 * Some libfaim code copyright (C) 2001-2004 Mark Doliner <thekingant@users.sourceforge.net> | |
12 * | |
13 * This program is free software; you can redistribute it and/or modify | |
14 * it under the terms of the GNU General Public License as published by | |
15 * the Free Software Foundation; either version 2 of the License, or | |
16 * (at your option) any later version. | |
17 * | |
18 * This program is distributed in the hope that it will be useful, | |
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 * GNU General Public License for more details. | |
22 * | |
23 * You should have received a copy of the GNU General Public License | |
24 * along with this program; if not, write to the Free Software | |
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
26 * | |
27 */ | |
14968 | 28 |
14192 | 29 #include "internal.h" |
30 | |
31 #include "account.h" | |
32 #include "accountopt.h" | |
33 #include "buddyicon.h" | |
34 #include "cipher.h" | |
35 #include "conversation.h" | |
36 #include "core.h" | |
37 #include "debug.h" | |
38 #include "imgstore.h" | |
39 #include "network.h" | |
40 #include "notify.h" | |
41 #include "privacy.h" | |
42 #include "prpl.h" | |
43 #include "proxy.h" | |
44 #include "request.h" | |
45 #include "util.h" | |
46 #include "version.h" | |
47 | |
14968 | 48 #include "oscarcommon.h" |
14192 | 49 #include "oscar.h" |
50 #include "peer.h" | |
51 | |
52 #define OSCAR_STATUS_ID_INVISIBLE "invisible" | |
53 #define OSCAR_STATUS_ID_OFFLINE "offline" | |
54 #define OSCAR_STATUS_ID_AVAILABLE "available" | |
55 #define OSCAR_STATUS_ID_AWAY "away" | |
56 #define OSCAR_STATUS_ID_DND "dnd" | |
57 #define OSCAR_STATUS_ID_NA "na" | |
58 #define OSCAR_STATUS_ID_OCCUPIED "occupied" | |
59 #define OSCAR_STATUS_ID_FREE4CHAT "free4chat" | |
60 #define OSCAR_STATUS_ID_CUSTOM "custom" | |
61 | |
62 #define AIMHASHDATA "http://gaim.sourceforge.net/aim_data.php3" | |
63 | |
64 #define OSCAR_CONNECT_STEPS 6 | |
65 | |
14557 | 66 static OscarCapability gaim_caps = OSCAR_CAPABILITY_CHAT | OSCAR_CAPABILITY_BUDDYICON | OSCAR_CAPABILITY_DIRECTIM | OSCAR_CAPABILITY_SENDFILE | OSCAR_CAPABILITY_UNICODE | OSCAR_CAPABILITY_INTEROPERATE | OSCAR_CAPABILITY_ICHAT; |
14192 | 67 |
68 static guint8 features_aim[] = {0x01, 0x01, 0x01, 0x02}; | |
69 static guint8 features_icq[] = {0x01, 0x06}; | |
70 static guint8 features_icq_offline[] = {0x01}; | |
71 static guint8 ck[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; | |
72 | |
73 struct create_room { | |
74 char *name; | |
75 int exchange; | |
76 }; | |
77 | |
78 struct oscar_ask_directim_data | |
79 { | |
80 OscarData *od; | |
81 char *who; | |
82 }; | |
83 | |
84 /* | |
85 * Various PRPL-specific buddy info that we want to keep track of | |
86 * Some other info is maintained by locate.c, and I'd like to move | |
87 * the rest of this to libfaim, mostly im.c | |
88 * | |
89 * TODO: More of this should use the status API. | |
90 */ | |
91 struct buddyinfo { | |
92 gboolean typingnot; | |
93 guint32 ipaddr; | |
94 | |
95 unsigned long ico_me_len; | |
96 unsigned long ico_me_csum; | |
97 time_t ico_me_time; | |
98 gboolean ico_informed; | |
99 | |
100 unsigned long ico_len; | |
101 unsigned long ico_csum; | |
102 time_t ico_time; | |
103 gboolean ico_need; | |
104 gboolean ico_sent; | |
105 }; | |
106 | |
107 struct name_data { | |
108 GaimConnection *gc; | |
109 gchar *name; | |
110 gchar *nick; | |
111 }; | |
112 | |
113 static char *msgerrreason[] = { | |
114 N_("Invalid error"), | |
115 N_("Invalid SNAC"), | |
116 N_("Rate to host"), | |
117 N_("Rate to client"), | |
118 N_("Not logged in"), | |
119 N_("Service unavailable"), | |
120 N_("Service not defined"), | |
121 N_("Obsolete SNAC"), | |
122 N_("Not supported by host"), | |
123 N_("Not supported by client"), | |
124 N_("Refused by client"), | |
125 N_("Reply too big"), | |
126 N_("Responses lost"), | |
127 N_("Request denied"), | |
128 N_("Busted SNAC payload"), | |
129 N_("Insufficient rights"), | |
130 N_("In local permit/deny"), | |
131 N_("Too evil (sender)"), | |
132 N_("Too evil (receiver)"), | |
133 N_("User temporarily unavailable"), | |
134 N_("No match"), | |
135 N_("List overflow"), | |
136 N_("Request ambiguous"), | |
137 N_("Queue full"), | |
138 N_("Not while on AOL") | |
139 }; | |
140 static int msgerrreasonlen = 25; | |
141 | |
142 /* All the libfaim->gaim callback functions */ | |
143 static int gaim_parse_auth_resp (OscarData *, FlapConnection *, FlapFrame *, ...); | |
144 static int gaim_parse_login (OscarData *, FlapConnection *, FlapFrame *, ...); | |
145 static int gaim_parse_auth_securid_request(OscarData *, FlapConnection *, FlapFrame *, ...); | |
146 static int gaim_handle_redirect (OscarData *, FlapConnection *, FlapFrame *, ...); | |
147 static int gaim_info_change (OscarData *, FlapConnection *, FlapFrame *, ...); | |
148 static int gaim_account_confirm (OscarData *, FlapConnection *, FlapFrame *, ...); | |
149 static int gaim_parse_oncoming (OscarData *, FlapConnection *, FlapFrame *, ...); | |
150 static int gaim_parse_offgoing (OscarData *, FlapConnection *, FlapFrame *, ...); | |
151 static int gaim_parse_incoming_im(OscarData *, FlapConnection *, FlapFrame *, ...); | |
152 static int gaim_parse_misses (OscarData *, FlapConnection *, FlapFrame *, ...); | |
153 static int gaim_parse_clientauto (OscarData *, FlapConnection *, FlapFrame *, ...); | |
154 static int gaim_parse_userinfo (OscarData *, FlapConnection *, FlapFrame *, ...); | |
155 static int gaim_got_infoblock (OscarData *, FlapConnection *, FlapFrame *, ...); | |
156 static int gaim_parse_motd (OscarData *, FlapConnection *, FlapFrame *, ...); | |
157 static int gaim_chatnav_info (OscarData *, FlapConnection *, FlapFrame *, ...); | |
158 static int gaim_conv_chat_join (OscarData *, FlapConnection *, FlapFrame *, ...); | |
159 static int gaim_conv_chat_leave (OscarData *, FlapConnection *, FlapFrame *, ...); | |
160 static int gaim_conv_chat_info_update (OscarData *, FlapConnection *, FlapFrame *, ...); | |
161 static int gaim_conv_chat_incoming_msg(OscarData *, FlapConnection *, FlapFrame *, ...); | |
162 static int gaim_email_parseupdate(OscarData *, FlapConnection *, FlapFrame *, ...); | |
163 static int gaim_icon_error (OscarData *, FlapConnection *, FlapFrame *, ...); | |
164 static int gaim_icon_parseicon (OscarData *, FlapConnection *, FlapFrame *, ...); | |
165 static int oscar_icon_req (OscarData *, FlapConnection *, FlapFrame *, ...); | |
166 static int gaim_parse_msgack (OscarData *, FlapConnection *, FlapFrame *, ...); | |
167 static int gaim_parse_ratechange (OscarData *, FlapConnection *, FlapFrame *, ...); | |
168 static int gaim_parse_evilnotify (OscarData *, FlapConnection *, FlapFrame *, ...); | |
169 static int gaim_parse_searcherror(OscarData *, FlapConnection *, FlapFrame *, ...); | |
170 static int gaim_parse_searchreply(OscarData *, FlapConnection *, FlapFrame *, ...); | |
171 static int gaim_bosrights (OscarData *, FlapConnection *, FlapFrame *, ...); | |
172 static int gaim_connerr (OscarData *, FlapConnection *, FlapFrame *, ...); | |
173 static int gaim_parse_msgerr (OscarData *, FlapConnection *, FlapFrame *, ...); | |
174 static int gaim_parse_mtn (OscarData *, FlapConnection *, FlapFrame *, ...); | |
175 static int gaim_parse_locaterights(OscarData *, FlapConnection *, FlapFrame *, ...); | |
176 static int gaim_parse_buddyrights(OscarData *, FlapConnection *, FlapFrame *, ...); | |
177 static int gaim_parse_locerr (OscarData *, FlapConnection *, FlapFrame *, ...); | |
178 static int gaim_icbm_param_info (OscarData *, FlapConnection *, FlapFrame *, ...); | |
179 static int gaim_parse_genericerr (OscarData *, FlapConnection *, FlapFrame *, ...); | |
180 static int gaim_memrequest (OscarData *, FlapConnection *, FlapFrame *, ...); | |
181 static int gaim_selfinfo (OscarData *, FlapConnection *, FlapFrame *, ...); | |
182 static int gaim_offlinemsg (OscarData *, FlapConnection *, FlapFrame *, ...); | |
183 static int gaim_offlinemsgdone (OscarData *, FlapConnection *, FlapFrame *, ...); | |
184 static int gaim_icqalias (OscarData *, FlapConnection *, FlapFrame *, ...); | |
185 static int gaim_icqinfo (OscarData *, FlapConnection *, FlapFrame *, ...); | |
186 static int gaim_popup (OscarData *, FlapConnection *, FlapFrame *, ...); | |
187 static int gaim_ssi_parseerr (OscarData *, FlapConnection *, FlapFrame *, ...); | |
188 static int gaim_ssi_parserights (OscarData *, FlapConnection *, FlapFrame *, ...); | |
189 static int gaim_ssi_parselist (OscarData *, FlapConnection *, FlapFrame *, ...); | |
190 static int gaim_ssi_parseack (OscarData *, FlapConnection *, FlapFrame *, ...); | |
191 static int gaim_ssi_parseadd (OscarData *, FlapConnection *, FlapFrame *, ...); | |
192 static int gaim_ssi_authgiven (OscarData *, FlapConnection *, FlapFrame *, ...); | |
193 static int gaim_ssi_authrequest (OscarData *, FlapConnection *, FlapFrame *, ...); | |
194 static int gaim_ssi_authreply (OscarData *, FlapConnection *, FlapFrame *, ...); | |
195 static int gaim_ssi_gotadded (OscarData *, FlapConnection *, FlapFrame *, ...); | |
196 | |
197 static gboolean gaim_icon_timerfunc(gpointer data); | |
198 | |
199 static void recent_buddies_cb(const char *name, GaimPrefType type, gconstpointer value, gpointer data); | |
14968 | 200 void oscar_set_info(GaimConnection *gc, const char *info); |
14192 | 201 static void oscar_set_info_and_status(GaimAccount *account, gboolean setinfo, const char *rawinfo, gboolean setstatus, GaimStatus *status); |
202 static void oscar_set_extendedstatus(GaimConnection *gc); | |
203 static gboolean gaim_ssi_rerequestdata(gpointer data); | |
204 | |
205 static void oscar_free_name_data(struct name_data *data) { | |
206 g_free(data->name); | |
207 g_free(data->nick); | |
208 g_free(data); | |
209 } | |
210 | |
15060
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
211 #ifdef _WIN32 |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
212 const char *oscar_get_locale_charset(void) { |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
213 static const char *charset = NULL; |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
214 if (charset == NULL) |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
215 g_get_charset(&charset); |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
216 return charset; |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
217 } |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
218 #endif |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
219 |
14192 | 220 /** |
221 * Determine how we can send this message. Per the warnings elsewhere | |
222 * in this file, these little checks determine the simplest encoding | |
223 * we can use for a given message send using it. | |
224 */ | |
225 static guint32 | |
226 oscar_charset_check(const char *utf8) | |
227 { | |
228 int i = 0; | |
229 int charset = AIM_CHARSET_ASCII; | |
230 | |
231 /* | |
232 * Can we get away with using our custom encoding? | |
233 */ | |
234 while (utf8[i]) | |
235 { | |
236 if ((unsigned char)utf8[i] > 0x7f) { | |
237 /* not ASCII! */ | |
238 charset = AIM_CHARSET_CUSTOM; | |
239 break; | |
240 } | |
241 i++; | |
242 } | |
243 | |
244 /* | |
245 * Must we send this message as UNICODE (in the UCS-2BE encoding)? | |
246 */ | |
247 while (utf8[i]) | |
248 { | |
249 /* ISO-8859-1 is 0x00-0xbf in the first byte | |
250 * followed by 0xc0-0xc3 in the second */ | |
251 if ((unsigned char)utf8[i] < 0x80) { | |
252 i++; | |
253 continue; | |
254 } else if (((unsigned char)utf8[i] & 0xfc) == 0xc0 && | |
255 ((unsigned char)utf8[i + 1] & 0xc0) == 0x80) { | |
256 i += 2; | |
257 continue; | |
258 } | |
259 charset = AIM_CHARSET_UNICODE; | |
260 break; | |
261 } | |
262 | |
263 return charset; | |
264 } | |
265 | |
266 /** | |
267 * Take a string of the form charset="bleh" where bleh is | |
268 * one of us-ascii, utf-8, iso-8859-1, or unicode-2-0, and | |
269 * return a newly allocated string containing bleh. | |
270 */ | |
271 static gchar * | |
272 oscar_encoding_extract(const char *encoding) | |
273 { | |
274 gchar *ret = NULL; | |
275 char *begin, *end; | |
276 | |
277 g_return_val_if_fail(encoding != NULL, NULL); | |
278 | |
279 /* Make sure encoding begins with charset= */ | |
280 if (strncmp(encoding, "text/aolrtf; charset=", 21) && | |
281 strncmp(encoding, "text/x-aolrtf; charset=", 23)) | |
282 { | |
283 return NULL; | |
284 } | |
285 | |
286 begin = strchr(encoding, '"'); | |
287 end = strrchr(encoding, '"'); | |
288 | |
289 if ((begin == NULL) || (end == NULL) || (begin >= end)) | |
290 return NULL; | |
291 | |
292 ret = g_strndup(begin+1, (end-1) - begin); | |
293 | |
294 return ret; | |
295 } | |
296 | |
297 gchar * | |
298 oscar_encoding_to_utf8(const char *encoding, const char *text, int textlen) | |
299 { | |
300 gchar *utf8 = NULL; | |
301 | |
302 if ((encoding == NULL) || encoding[0] == '\0') { | |
303 gaim_debug_info("oscar", "Empty encoding, assuming UTF-8\n"); | |
304 } else if (!strcasecmp(encoding, "iso-8859-1")) { | |
305 utf8 = g_convert(text, textlen, "UTF-8", "iso-8859-1", NULL, NULL, NULL); | |
306 } else if (!strcasecmp(encoding, "ISO-8859-1-Windows-3.1-Latin-1")) { | |
307 utf8 = g_convert(text, textlen, "UTF-8", "Windows-1252", NULL, NULL, NULL); | |
308 } else if (!strcasecmp(encoding, "unicode-2-0")) { | |
309 utf8 = g_convert(text, textlen, "UTF-8", "UCS-2BE", NULL, NULL, NULL); | |
310 } else if (strcasecmp(encoding, "us-ascii") && strcmp(encoding, "utf-8")) { | |
311 gaim_debug_warning("oscar", "Unrecognized character encoding \"%s\", " | |
312 "attempting to convert to UTF-8 anyway\n", encoding); | |
313 utf8 = g_convert(text, textlen, "UTF-8", encoding, NULL, NULL, NULL); | |
314 } | |
315 | |
316 /* | |
317 * If utf8 is still NULL then either the encoding is us-ascii/utf-8 or | |
318 * we have been unable to convert the text to utf-8 from the encoding | |
319 * that was specified. So we check if the text is valid utf-8 then | |
320 * just copy it. | |
321 */ | |
322 if (utf8 == NULL) { | |
323 if (textlen != 0 && *text != '\0' | |
324 && !g_utf8_validate(text, textlen, NULL)) | |
325 utf8 = g_strdup(_("(There was an error receiving this message. The buddy you are speaking with is probably using a different encoding than expected. If you know what encoding he is using, you can specify it in the advanced account options for your AIM/ICQ account.)")); | |
326 else | |
327 utf8 = g_strndup(text, textlen); | |
328 } | |
329 | |
330 return utf8; | |
331 } | |
332 | |
333 static gchar * | |
334 oscar_utf8_try_convert(GaimAccount *account, const gchar *msg) | |
335 { | |
336 const char *charset = NULL; | |
337 char *ret = NULL; | |
338 | |
339 if(aim_sn_is_icq(gaim_account_get_username(account))) | |
340 charset = gaim_account_get_string(account, "encoding", NULL); | |
341 | |
342 if(charset && *charset) | |
343 ret = g_convert(msg, -1, "UTF-8", charset, NULL, NULL, NULL); | |
344 | |
345 if(!ret) | |
346 ret = gaim_utf8_try_convert(msg); | |
347 | |
348 return ret; | |
349 } | |
350 | |
351 static gchar * | |
352 gaim_plugin_oscar_convert_to_utf8(const gchar *data, gsize datalen, const char *charsetstr, gboolean fallback) | |
353 { | |
354 gchar *ret = NULL; | |
355 GError *err = NULL; | |
356 | |
357 if ((charsetstr == NULL) || (*charsetstr == '\0')) | |
358 return NULL; | |
359 | |
360 if (strcasecmp("UTF-8", charsetstr)) { | |
361 if (fallback) | |
362 ret = g_convert_with_fallback(data, datalen, "UTF-8", charsetstr, "?", NULL, NULL, &err); | |
363 else | |
364 ret = g_convert(data, datalen, "UTF-8", charsetstr, NULL, NULL, &err); | |
365 if (err != NULL) { | |
366 gaim_debug_warning("oscar", "Conversion from %s failed: %s.\n", | |
367 charsetstr, err->message); | |
368 g_error_free(err); | |
369 } | |
370 } else { | |
371 if (g_utf8_validate(data, datalen, NULL)) | |
372 ret = g_strndup(data, datalen); | |
373 else | |
374 gaim_debug_warning("oscar", "String is not valid UTF-8.\n"); | |
375 } | |
376 | |
377 return ret; | |
378 } | |
379 | |
380 /** | |
381 * This attemps to decode an incoming IM into a UTF8 string. | |
382 * | |
383 * We try decoding using two different character sets. The charset | |
384 * specified in the IM determines the order in which we attempt to | |
385 * decode. We do this because there are lots of broken ICQ clients | |
386 * that don't correctly send non-ASCII messages. And if Gaim isn't | |
387 * able to deal with that crap, then people complain like banshees. | |
388 * charsetstr1 is always set to what the correct encoding should be. | |
389 */ | |
390 gchar * | |
391 gaim_plugin_oscar_decode_im_part(GaimAccount *account, const char *sourcesn, guint16 charset, guint16 charsubset, const gchar *data, gsize datalen) | |
392 { | |
393 gchar *ret = NULL; | |
394 const gchar *charsetstr1, *charsetstr2; | |
395 | |
396 gaim_debug_info("oscar", "Parsing IM part, charset=0x%04hx, charsubset=0x%04hx, datalen=%hd\n", charset, charsubset, datalen); | |
397 | |
398 if ((datalen == 0) || (data == NULL)) | |
399 return NULL; | |
400 | |
401 if (charset == AIM_CHARSET_UNICODE) { | |
402 charsetstr1 = "UCS-2BE"; | |
403 charsetstr2 = "UTF-8"; | |
404 } else if (charset == AIM_CHARSET_CUSTOM) { | |
405 if ((sourcesn != NULL) && isdigit(sourcesn[0])) | |
406 charsetstr1 = gaim_account_get_string(account, "encoding", OSCAR_DEFAULT_CUSTOM_ENCODING); | |
407 else | |
408 charsetstr1 = "ISO-8859-1"; | |
409 charsetstr2 = "UTF-8"; | |
410 } else if (charset == AIM_CHARSET_ASCII) { | |
411 /* Should just be "ASCII" */ | |
412 charsetstr1 = "ASCII"; | |
413 charsetstr2 = gaim_account_get_string(account, "encoding", OSCAR_DEFAULT_CUSTOM_ENCODING); | |
414 } else if (charset == 0x000d) { | |
415 /* Mobile AIM client on a Nokia 3100 and an LG VX6000 */ | |
416 charsetstr1 = "ISO-8859-1"; | |
417 charsetstr2 = gaim_account_get_string(account, "encoding", OSCAR_DEFAULT_CUSTOM_ENCODING); | |
418 } else { | |
419 /* Unknown, hope for valid UTF-8... */ | |
420 charsetstr1 = "UTF-8"; | |
421 charsetstr2 = gaim_account_get_string(account, "encoding", OSCAR_DEFAULT_CUSTOM_ENCODING); | |
422 } | |
423 | |
424 ret = gaim_plugin_oscar_convert_to_utf8(data, datalen, charsetstr1, FALSE); | |
425 if (ret == NULL) | |
426 ret = gaim_plugin_oscar_convert_to_utf8(data, datalen, charsetstr2, TRUE); | |
427 if (ret == NULL) | |
428 ret = g_strdup(_("(There was an error receiving this message. The buddy you are speaking to most likely has a buggy client.)")); | |
429 | |
430 return ret; | |
431 } | |
432 | |
433 /** | |
434 * Figure out what encoding to use when sending a given outgoing message. | |
435 */ | |
436 static void | |
437 gaim_plugin_oscar_convert_to_best_encoding(GaimConnection *gc, | |
438 const char *destsn, const gchar *from, | |
439 gchar **msg, int *msglen_int, | |
440 guint16 *charset, guint16 *charsubset) | |
441 { | |
442 OscarData *od = gc->proto_data; | |
443 GaimAccount *account = gaim_connection_get_account(gc); | |
444 GError *err = NULL; | |
445 aim_userinfo_t *userinfo = NULL; | |
446 const gchar *charsetstr; | |
447 gsize msglen; | |
448 | |
449 /* Attempt to send as ASCII */ | |
450 if (oscar_charset_check(from) == AIM_CHARSET_ASCII) { | |
451 *msg = g_convert(from, strlen(from), "ASCII", "UTF-8", NULL, &msglen, NULL); | |
452 *charset = AIM_CHARSET_ASCII; | |
453 *charsubset = 0x0000; | |
454 *msglen_int = msglen; | |
455 return; | |
456 } | |
457 | |
458 /* | |
459 * If we're sending to an ICQ user, and they are in our | |
460 * buddy list, and they are advertising the Unicode | |
461 * capability, and they are online, then attempt to send | |
462 * as UCS-2BE. | |
463 */ | |
464 if ((destsn != NULL) && aim_sn_is_icq(destsn)) | |
465 userinfo = aim_locate_finduserinfo(od, destsn); | |
466 | |
14557 | 467 if ((userinfo != NULL) && (userinfo->capabilities & OSCAR_CAPABILITY_UNICODE)) |
14192 | 468 { |
469 GaimBuddy *b; | |
470 b = gaim_find_buddy(account, destsn); | |
471 if ((b != NULL) && (GAIM_BUDDY_IS_ONLINE(b))) | |
472 { | |
473 *msg = g_convert(from, strlen(from), "UCS-2BE", "UTF-8", NULL, &msglen, NULL); | |
474 if (*msg != NULL) | |
475 { | |
476 *charset = AIM_CHARSET_UNICODE; | |
477 *charsubset = 0x0000; | |
478 *msglen_int = msglen; | |
479 return; | |
480 } | |
481 } | |
482 } | |
483 | |
484 /* | |
485 * If this is AIM then attempt to send as ISO-8859-1. If this is | |
486 * ICQ then attempt to send as the user specified character encoding. | |
487 */ | |
488 charsetstr = "ISO-8859-1"; | |
489 if ((destsn != NULL) && aim_sn_is_icq(destsn)) | |
490 charsetstr = gaim_account_get_string(account, "encoding", OSCAR_DEFAULT_CUSTOM_ENCODING); | |
491 | |
492 /* | |
493 * XXX - We need a way to only attempt to convert if we KNOW "from" | |
494 * can be converted to "charsetstr" | |
495 */ | |
496 *msg = g_convert(from, strlen(from), charsetstr, "UTF-8", NULL, &msglen, NULL); | |
497 if (*msg != NULL) { | |
498 *charset = AIM_CHARSET_CUSTOM; | |
499 *charsubset = 0x0000; | |
500 *msglen_int = msglen; | |
501 return; | |
502 } | |
503 | |
504 /* | |
505 * Nothing else worked, so send as UCS-2BE. | |
506 */ | |
507 *msg = g_convert(from, strlen(from), "UCS-2BE", "UTF-8", NULL, &msglen, &err); | |
508 if (*msg != NULL) { | |
509 *charset = AIM_CHARSET_UNICODE; | |
510 *charsubset = 0x0000; | |
511 *msglen_int = msglen; | |
512 return; | |
513 } | |
514 | |
515 gaim_debug_error("oscar", "Error converting a Unicode message: %s\n", err->message); | |
516 g_error_free(err); | |
517 | |
518 gaim_debug_error("oscar", "This should NEVER happen! Sending UTF-8 text flagged as ASCII.\n"); | |
519 *msg = g_strdup(from); | |
520 *msglen_int = strlen(*msg); | |
521 *charset = AIM_CHARSET_ASCII; | |
522 *charsubset = 0x0000; | |
523 return; | |
524 } | |
525 | |
526 /** | |
527 * Looks for %n, %d, or %t in a string, and replaces them with the | |
528 * specified name, date, and time, respectively. | |
529 * | |
530 * @param str The string that may contain the special variables. | |
531 * @param name The sender name. | |
532 * | |
533 * @return A newly allocated string where the special variables are | |
534 * expanded. This should be g_free'd by the caller. | |
535 */ | |
536 static gchar * | |
537 gaim_str_sub_away_formatters(const char *str, const char *name) | |
538 { | |
539 char *c; | |
540 GString *cpy; | |
541 time_t t; | |
542 struct tm *tme; | |
543 | |
544 g_return_val_if_fail(str != NULL, NULL); | |
545 g_return_val_if_fail(name != NULL, NULL); | |
546 | |
547 /* Create an empty GString that is hopefully big enough for most messages */ | |
548 cpy = g_string_sized_new(1024); | |
549 | |
550 t = time(NULL); | |
551 tme = localtime(&t); | |
552 | |
553 c = (char *)str; | |
554 while (*c) { | |
555 switch (*c) { | |
556 case '%': | |
557 if (*(c + 1)) { | |
558 switch (*(c + 1)) { | |
559 case 'n': | |
560 /* append name */ | |
561 g_string_append(cpy, name); | |
562 c++; | |
563 break; | |
564 case 'd': | |
565 /* append date */ | |
566 g_string_append(cpy, gaim_date_format_short(tme)); | |
567 c++; | |
568 break; | |
569 case 't': | |
570 /* append time */ | |
571 g_string_append(cpy, gaim_time_format(tme)); | |
572 c++; | |
573 break; | |
574 default: | |
575 g_string_append_c(cpy, *c); | |
576 } | |
577 } else { | |
578 g_string_append_c(cpy, *c); | |
579 } | |
580 break; | |
581 default: | |
582 g_string_append_c(cpy, *c); | |
583 } | |
584 c++; | |
585 } | |
586 | |
587 return g_string_free(cpy, FALSE); | |
588 } | |
589 | |
14552 | 590 static gchar *oscar_caps_to_string(OscarCapability caps) |
14192 | 591 { |
592 GString *str; | |
593 const gchar *tmp; | |
594 guint bit = 1; | |
595 | |
596 str = g_string_new(""); | |
597 | |
598 if (!caps) { | |
599 return NULL; | |
600 } else while (bit <= OSCAR_CAPABILITY_LAST) { | |
601 if (bit & caps) { | |
602 switch (bit) { | |
603 case OSCAR_CAPABILITY_BUDDYICON: | |
604 tmp = _("Buddy Icon"); | |
605 break; | |
606 case OSCAR_CAPABILITY_TALK: | |
607 tmp = _("Voice"); | |
608 break; | |
609 case OSCAR_CAPABILITY_DIRECTIM: | |
610 tmp = _("AIM Direct IM"); | |
611 break; | |
612 case OSCAR_CAPABILITY_CHAT: | |
613 tmp = _("Chat"); | |
614 break; | |
615 case OSCAR_CAPABILITY_GETFILE: | |
616 tmp = _("Get File"); | |
617 break; | |
618 case OSCAR_CAPABILITY_SENDFILE: | |
619 tmp = _("Send File"); | |
620 break; | |
621 case OSCAR_CAPABILITY_GAMES: | |
622 case OSCAR_CAPABILITY_GAMES2: | |
623 tmp = _("Games"); | |
624 break; | |
625 case OSCAR_CAPABILITY_ADDINS: | |
626 tmp = _("Add-Ins"); | |
627 break; | |
628 case OSCAR_CAPABILITY_SENDBUDDYLIST: | |
629 tmp = _("Send Buddy List"); | |
630 break; | |
631 case OSCAR_CAPABILITY_ICQ_DIRECT: | |
632 tmp = _("ICQ Direct Connect"); | |
633 break; | |
634 case OSCAR_CAPABILITY_APINFO: | |
635 tmp = _("AP User"); | |
636 break; | |
637 case OSCAR_CAPABILITY_ICQRTF: | |
638 tmp = _("ICQ RTF"); | |
639 break; | |
640 case OSCAR_CAPABILITY_EMPTY: | |
641 tmp = _("Nihilist"); | |
642 break; | |
643 case OSCAR_CAPABILITY_ICQSERVERRELAY: | |
644 tmp = _("ICQ Server Relay"); | |
645 break; | |
14557 | 646 case OSCAR_CAPABILITY_UNICODEOLD: |
14192 | 647 tmp = _("Old ICQ UTF8"); |
648 break; | |
649 case OSCAR_CAPABILITY_TRILLIANCRYPT: | |
650 tmp = _("Trillian Encryption"); | |
651 break; | |
14557 | 652 case OSCAR_CAPABILITY_UNICODE: |
14192 | 653 tmp = _("ICQ UTF8"); |
654 break; | |
655 case OSCAR_CAPABILITY_HIPTOP: | |
656 tmp = _("Hiptop"); | |
657 break; | |
658 case OSCAR_CAPABILITY_SECUREIM: | |
659 tmp = _("Security Enabled"); | |
660 break; | |
661 case OSCAR_CAPABILITY_VIDEO: | |
662 tmp = _("Video Chat"); | |
663 break; | |
664 /* Not actually sure about this one... WinAIM doesn't show anything */ | |
665 case OSCAR_CAPABILITY_ICHATAV: | |
666 tmp = _("iChat AV"); | |
667 break; | |
668 case OSCAR_CAPABILITY_LIVEVIDEO: | |
669 tmp = _("Live Video"); | |
670 break; | |
671 case OSCAR_CAPABILITY_CAMERA: | |
672 tmp = _("Camera"); | |
673 break; | |
674 default: | |
675 tmp = NULL; | |
676 break; | |
677 } | |
678 if (tmp) | |
679 g_string_append_printf(str, "%s%s", (*(str->str) == '\0' ? "" : ", "), tmp); | |
680 } | |
681 bit <<= 1; | |
682 } | |
683 | |
684 return g_string_free(str, FALSE); | |
685 } | |
686 | |
687 static char *oscar_icqstatus(int state) { | |
688 /* Make a cute little string that shows the status of the dude or dudet */ | |
689 if (state & AIM_ICQ_STATE_CHAT) | |
690 return g_strdup_printf(_("Free For Chat")); | |
691 else if (state & AIM_ICQ_STATE_DND) | |
692 return g_strdup_printf(_("Do Not Disturb")); | |
693 else if (state & AIM_ICQ_STATE_OUT) | |
694 return g_strdup_printf(_("Not Available")); | |
695 else if (state & AIM_ICQ_STATE_BUSY) | |
696 return g_strdup_printf(_("Occupied")); | |
697 else if (state & AIM_ICQ_STATE_AWAY) | |
698 return g_strdup_printf(_("Away")); | |
699 else if (state & AIM_ICQ_STATE_WEBAWARE) | |
700 return g_strdup_printf(_("Web Aware")); | |
701 else if (state & AIM_ICQ_STATE_INVISIBLE) | |
702 return g_strdup_printf(_("Invisible")); | |
703 else | |
704 return g_strdup_printf(_("Online")); | |
705 } | |
706 | |
707 static void | |
708 oscar_string_append(GString *str, const char *newline, | |
709 const char *name, const char *value) | |
710 { | |
711 if (value && value[0]) { | |
712 g_string_append_printf(str, "%s<b>%s:</b> %s", newline, name, value); | |
713 } | |
714 } | |
715 | |
716 static void | |
717 oscar_string_convert_and_append(GaimAccount *account, GString *str, const char *newline, | |
718 const char *name, const char *value) | |
719 { | |
720 gchar *utf8; | |
721 | |
722 if (value && value[0] && (utf8 = oscar_utf8_try_convert(account, value))) { | |
723 g_string_append_printf(str, "%s<b>%s:</b> %s", newline, name, utf8); | |
724 g_free(utf8); | |
725 } | |
726 } | |
727 | |
728 static void oscar_string_append_info(GaimConnection *gc, GString *str, const char *newline, GaimBuddy *b, aim_userinfo_t *userinfo) | |
729 { | |
730 OscarData *od; | |
731 GaimAccount *account; | |
732 GaimPresence *presence = NULL; | |
733 GaimStatus *status = NULL; | |
734 GaimGroup *g = NULL; | |
735 struct buddyinfo *bi = NULL; | |
736 char *tmp; | |
737 | |
738 od = gc->proto_data; | |
739 account = gaim_connection_get_account(gc); | |
740 | |
741 if ((str == NULL) || (newline == NULL) || ((b == NULL) && (userinfo == NULL))) | |
742 return; | |
743 | |
744 if (userinfo == NULL) | |
745 userinfo = aim_locate_finduserinfo(od, b->name); | |
746 | |
747 if (b == NULL) | |
748 b = gaim_find_buddy(account, userinfo->sn); | |
749 | |
750 if (b != NULL) { | |
751 g = gaim_buddy_get_group(b); | |
752 presence = gaim_buddy_get_presence(b); | |
753 status = gaim_presence_get_active_status(presence); | |
754 } | |
755 | |
756 if (userinfo != NULL) | |
757 bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(account, userinfo->sn)); | |
758 | |
759 if (b != NULL) { | |
760 if (gaim_presence_is_online(presence)) { | |
761 if (aim_sn_is_icq(b->name)) { | |
762 GaimStatus *status = gaim_presence_get_active_status(presence); | |
763 oscar_string_append(str, newline, _("Status"), | |
764 gaim_status_get_name(status)); | |
765 } | |
766 } else { | |
767 tmp = aim_ssi_itemlist_findparentname(od->ssi.local, b->name); | |
768 if (aim_ssi_waitingforauth(od->ssi.local, tmp, b->name)) | |
769 oscar_string_append(str, newline, _("Status"), | |
770 _("Not Authorized")); | |
771 else | |
772 oscar_string_append(str, newline, _("Status"), | |
773 _("Offline")); | |
774 } | |
775 } | |
776 | |
777 if ((bi != NULL) && (bi->ipaddr != 0)) { | |
778 tmp = g_strdup_printf("%hhu.%hhu.%hhu.%hhu", | |
779 (bi->ipaddr & 0xff000000) >> 24, | |
780 (bi->ipaddr & 0x00ff0000) >> 16, | |
781 (bi->ipaddr & 0x0000ff00) >> 8, | |
782 (bi->ipaddr & 0x000000ff)); | |
783 oscar_string_append(str, newline, _("IP Address"), tmp); | |
784 g_free(tmp); | |
785 } | |
786 | |
787 | |
788 if ((userinfo != NULL) && (userinfo->warnlevel != 0)) { | |
789 tmp = g_strdup_printf("%d", (int)(userinfo->warnlevel/10.0 + .5)); | |
790 oscar_string_append(str, newline, _("Warning Level"), tmp); | |
791 g_free(tmp); | |
792 } | |
793 | |
794 if ((b != NULL) && (b->name != NULL) && (g != NULL) && (g->name != NULL)) { | |
795 tmp = aim_ssi_getcomment(od->ssi.local, g->name, b->name); | |
796 if (tmp != NULL) { | |
797 char *tmp2 = g_markup_escape_text(tmp, strlen(tmp)); | |
798 g_free(tmp); | |
799 oscar_string_convert_and_append(account, str, newline, _("Buddy Comment"), tmp2); | |
800 g_free(tmp2); | |
801 } | |
802 } | |
803 } | |
804 | |
805 static char *extract_name(const char *name) { | |
806 char *tmp, *x; | |
807 int i, j; | |
808 | |
809 if (!name) | |
810 return NULL; | |
811 | |
812 x = strchr(name, '-'); | |
813 | |
814 if (!x) return NULL; | |
815 x = strchr(++x, '-'); | |
816 if (!x) return NULL; | |
817 tmp = g_strdup(++x); | |
818 | |
819 for (i = 0, j = 0; x[i]; i++) { | |
820 char hex[3]; | |
821 if (x[i] != '%') { | |
822 tmp[j++] = x[i]; | |
823 continue; | |
824 } | |
825 strncpy(hex, x + ++i, 2); hex[2] = 0; | |
826 i++; | |
827 tmp[j++] = strtol(hex, NULL, 16); | |
828 } | |
829 | |
830 tmp[j] = 0; | |
831 return tmp; | |
832 } | |
833 | |
834 static struct chat_connection * | |
835 find_oscar_chat(GaimConnection *gc, int id) | |
836 { | |
837 OscarData *od = (OscarData *)gc->proto_data; | |
838 GSList *cur; | |
839 struct chat_connection *cc; | |
840 | |
841 for (cur = od->oscar_chats; cur != NULL; cur = cur->next) | |
842 { | |
843 cc = (struct chat_connection *)cur->data; | |
844 if (cc->id == id) | |
845 return cc; | |
846 } | |
847 | |
848 return NULL; | |
849 } | |
850 | |
851 static struct chat_connection * | |
852 find_oscar_chat_by_conn(GaimConnection *gc, FlapConnection *conn) | |
853 { | |
854 OscarData *od = (OscarData *)gc->proto_data; | |
855 GSList *cur; | |
856 struct chat_connection *cc; | |
857 | |
858 for (cur = od->oscar_chats; cur != NULL; cur = cur->next) | |
859 { | |
860 cc = (struct chat_connection *)cur->data; | |
861 if (cc->conn == conn) | |
862 return cc; | |
863 } | |
864 | |
865 return NULL; | |
866 } | |
867 | |
868 static struct chat_connection * | |
869 find_oscar_chat_by_conv(GaimConnection *gc, GaimConversation *conv) | |
870 { | |
871 OscarData *od = (OscarData *)gc->proto_data; | |
872 GSList *cur; | |
873 struct chat_connection *cc; | |
874 | |
875 for (cur = od->oscar_chats; cur != NULL; cur = cur->next) | |
876 { | |
877 cc = (struct chat_connection *)cur->data; | |
878 if (cc->conv == conv) | |
879 return cc; | |
880 } | |
881 | |
882 return NULL; | |
883 } | |
884 | |
885 void | |
886 oscar_chat_destroy(struct chat_connection *cc) | |
887 { | |
888 g_free(cc->name); | |
889 g_free(cc->show); | |
890 g_free(cc); | |
891 } | |
892 | |
893 static void | |
894 oscar_chat_kill(GaimConnection *gc, struct chat_connection *cc) | |
895 { | |
896 OscarData *od = (OscarData *)gc->proto_data; | |
897 | |
898 /* Notify the conversation window that we've left the chat */ | |
899 serv_got_chat_left(gc, gaim_conv_chat_get_id(GAIM_CONV_CHAT(cc->conv))); | |
900 | |
901 /* Destroy the chat_connection */ | |
902 od->oscar_chats = g_slist_remove(od->oscar_chats, cc); | |
14392 | 903 flap_connection_schedule_destroy(cc->conn, OSCAR_DISCONNECT_DONE, NULL); |
14192 | 904 oscar_chat_destroy(cc); |
905 } | |
906 | |
907 /** | |
908 * This is the callback function anytime gaim_proxy_connect() | |
909 * establishes a new TCP connection with an oscar host. Depending | |
910 * on the type of host, we do a few different things here. | |
911 */ | |
912 static void | |
913 connection_established_cb(gpointer data, gint source, const gchar *error_message) | |
914 { | |
915 GaimConnection *gc; | |
916 OscarData *od; | |
917 GaimAccount *account; | |
918 FlapConnection *conn; | |
919 | |
920 conn = data; | |
921 od = conn->od; | |
922 gc = od->gc; | |
923 account = gaim_connection_get_account(gc); | |
924 | |
14262 | 925 conn->connect_data = NULL; |
14192 | 926 conn->fd = source; |
927 | |
928 if (source < 0) | |
929 { | |
930 gaim_debug_error("oscar", "unable to connect FLAP server " | |
931 "of type 0x%04hx\n", conn->type); | |
932 if (conn->type == SNAC_FAMILY_AUTH) | |
14392 | 933 { |
934 gchar *msg; | |
935 msg = g_strdup_printf(_("Could not connect to authentication server:\n%s"), | |
936 error_message); | |
937 gaim_connection_error(gc, msg); | |
938 g_free(msg); | |
939 } | |
940 else if (conn->type == SNAC_FAMILY_LOCATE) | |
941 { | |
942 gchar *msg; | |
943 msg = g_strdup_printf(_("Could not connect to BOS server:\n%s"), | |
944 error_message); | |
945 gaim_connection_error(gc, msg); | |
946 g_free(msg); | |
947 } | |
948 else | |
949 { | |
950 /* Maybe we should call this for BOS connections, too? */ | |
14192 | 951 flap_connection_schedule_destroy(conn, |
14392 | 952 OSCAR_DISCONNECT_COULD_NOT_CONNECT, error_message); |
953 } | |
14192 | 954 return; |
955 } | |
956 | |
957 gaim_debug_info("oscar", "connected to FLAP server of type 0x%04hx\n", | |
958 conn->type); | |
959 conn->watcher_incoming = gaim_input_add(conn->fd, | |
960 GAIM_INPUT_READ, flap_connection_recv_cb, conn); | |
961 if (conn->cookie == NULL) | |
962 { | |
963 if (!aim_sn_is_icq(gaim_account_get_username(account))) | |
964 /* | |
965 * We don't send this when authenticating an ICQ account | |
966 * because for some reason ICQ is still using the | |
967 * assy/insecure authentication procedure. | |
968 */ | |
969 flap_connection_send_version(od, conn); | |
970 } | |
971 else | |
972 { | |
973 flap_connection_send_version_with_cookie(od, conn, | |
974 conn->cookielen, conn->cookie); | |
975 g_free(conn->cookie); | |
976 conn->cookie = NULL; | |
977 } | |
978 | |
979 if (conn->type == SNAC_FAMILY_AUTH) | |
980 { | |
981 aim_request_login(od, conn, gaim_account_get_username(account)); | |
982 gaim_debug_info("oscar", "Screen name sent, waiting for response\n"); | |
983 gaim_connection_update_progress(gc, _("Screen name sent"), 1, OSCAR_CONNECT_STEPS); | |
984 ck[1] = 0x65; | |
985 } | |
986 else if (conn->type == SNAC_FAMILY_LOCATE) | |
987 { | |
988 gaim_connection_update_progress(gc, _("Connection established, cookie sent"), 4, OSCAR_CONNECT_STEPS); | |
989 ck[4] = 0x61; | |
990 } | |
991 else if (conn->type == SNAC_FAMILY_CHAT) | |
992 { | |
14348 | 993 od->oscar_chats = g_slist_prepend(od->oscar_chats, conn->new_conn_data); |
14262 | 994 conn->new_conn_data = NULL; |
14192 | 995 } |
996 } | |
997 | |
998 static void | |
999 flap_connection_established_bos(OscarData *od, FlapConnection *conn) | |
1000 { | |
1001 GaimConnection *gc = od->gc; | |
1002 | |
15085 | 1003 aim_srv_reqpersonalinfo(od, conn); |
14192 | 1004 |
1005 gaim_debug_info("oscar", "ssi: requesting rights and list\n"); | |
1006 aim_ssi_reqrights(od); | |
1007 aim_ssi_reqdata(od); | |
1008 if (od->getblisttimer > 0) | |
1009 gaim_timeout_remove(od->getblisttimer); | |
1010 od->getblisttimer = gaim_timeout_add(30000, gaim_ssi_rerequestdata, od); | |
1011 | |
1012 aim_locate_reqrights(od); | |
1013 aim_buddylist_reqrights(od, conn); | |
1014 aim_im_reqparams(od); | |
1015 aim_bos_reqrights(od, conn); /* TODO: Don't call this with ssi */ | |
1016 | |
1017 gaim_connection_update_progress(gc, _("Finalizing connection"), 5, OSCAR_CONNECT_STEPS); | |
1018 } | |
1019 | |
1020 static void | |
1021 flap_connection_established_admin(OscarData *od, FlapConnection *conn) | |
1022 { | |
1023 aim_clientready(od, conn); | |
1024 gaim_debug_info("oscar", "connected to admin\n"); | |
1025 | |
1026 if (od->chpass) { | |
1027 gaim_debug_info("oscar", "changing password\n"); | |
1028 aim_admin_changepasswd(od, conn, od->newp, od->oldp); | |
1029 g_free(od->oldp); | |
1030 od->oldp = NULL; | |
1031 g_free(od->newp); | |
1032 od->newp = NULL; | |
1033 od->chpass = FALSE; | |
1034 } | |
1035 if (od->setnick) { | |
1036 gaim_debug_info("oscar", "formatting screen name\n"); | |
1037 aim_admin_setnick(od, conn, od->newsn); | |
1038 g_free(od->newsn); | |
1039 od->newsn = NULL; | |
1040 od->setnick = FALSE; | |
1041 } | |
1042 if (od->conf) { | |
1043 gaim_debug_info("oscar", "confirming account\n"); | |
1044 aim_admin_reqconfirm(od, conn); | |
1045 od->conf = FALSE; | |
1046 } | |
1047 if (od->reqemail) { | |
1048 gaim_debug_info("oscar", "requesting e-mail address\n"); | |
1049 aim_admin_getinfo(od, conn, 0x0011); | |
1050 od->reqemail = FALSE; | |
1051 } | |
1052 if (od->setemail) { | |
1053 gaim_debug_info("oscar", "setting e-mail address\n"); | |
1054 aim_admin_setemail(od, conn, od->email); | |
1055 g_free(od->email); | |
1056 od->email = NULL; | |
1057 od->setemail = FALSE; | |
1058 } | |
1059 } | |
1060 | |
1061 static void | |
1062 flap_connection_established_chat(OscarData *od, FlapConnection *conn) | |
1063 { | |
1064 GaimConnection *gc = od->gc; | |
1065 struct chat_connection *chatcon; | |
1066 static int id = 1; | |
1067 | |
1068 aim_clientready(od, conn); | |
1069 | |
1070 chatcon = find_oscar_chat_by_conn(gc, conn); | |
1071 chatcon->id = id; | |
1072 chatcon->conv = serv_got_joined_chat(gc, id++, chatcon->show); | |
1073 } | |
1074 | |
1075 static void | |
1076 flap_connection_established_chatnav(OscarData *od, FlapConnection *conn) | |
1077 { | |
1078 aim_clientready(od, conn); | |
1079 aim_chatnav_reqrights(od, conn); | |
1080 } | |
1081 | |
1082 static void | |
1083 flap_connection_established_alert(OscarData *od, FlapConnection *conn) | |
1084 { | |
1085 aim_email_sendcookies(od); | |
1086 aim_email_activate(od); | |
1087 aim_clientready(od, conn); | |
1088 } | |
1089 | |
1090 static void | |
1091 flap_connection_established_bart(OscarData *od, FlapConnection *conn) | |
1092 { | |
1093 GaimConnection *gc = od->gc; | |
1094 | |
1095 aim_clientready(od, conn); | |
1096 | |
1097 od->iconconnecting = FALSE; | |
1098 | |
1099 if (od->icontimer == 0) | |
1100 od->icontimer = gaim_timeout_add(100, gaim_icon_timerfunc, gc); | |
1101 } | |
1102 | |
1103 static int | |
1104 flap_connection_established(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
1105 { | |
1106 gaim_debug_info("oscar", "FLAP connection of type 0x%04hx is " | |
1107 "now fully connected\n", conn->type); | |
1108 if (conn->type == SNAC_FAMILY_LOCATE) | |
1109 flap_connection_established_bos(od, conn); | |
1110 else if (conn->type == SNAC_FAMILY_ADMIN) | |
1111 flap_connection_established_admin(od, conn); | |
1112 else if (conn->type == SNAC_FAMILY_CHAT) | |
1113 flap_connection_established_chat(od, conn); | |
1114 else if (conn->type == SNAC_FAMILY_CHATNAV) | |
1115 flap_connection_established_chatnav(od, conn); | |
1116 else if (conn->type == SNAC_FAMILY_ALERT) | |
1117 flap_connection_established_alert(od, conn); | |
1118 else if (conn->type == SNAC_FAMILY_BART) | |
1119 flap_connection_established_bart(od, conn); | |
1120 | |
1121 return 1; | |
1122 } | |
1123 | |
14968 | 1124 void |
14192 | 1125 oscar_login(GaimAccount *account) |
1126 { | |
1127 GaimConnection *gc; | |
1128 OscarData *od; | |
1129 FlapConnection *newconn; | |
1130 | |
1131 gc = gaim_account_get_connection(account); | |
1132 od = gc->proto_data = oscar_data_new(); | |
1133 od->gc = gc; | |
1134 | |
1135 oscar_data_addhandler(od, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR, gaim_connerr, 0); | |
1136 oscar_data_addhandler(od, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, flap_connection_established, 0); | |
1137 | |
1138 oscar_data_addhandler(od, SNAC_FAMILY_ADMIN, 0x0003, gaim_info_change, 0); | |
1139 oscar_data_addhandler(od, SNAC_FAMILY_ADMIN, 0x0005, gaim_info_change, 0); | |
1140 oscar_data_addhandler(od, SNAC_FAMILY_ADMIN, 0x0007, gaim_account_confirm, 0); | |
1141 oscar_data_addhandler(od, SNAC_FAMILY_ALERT, 0x0001, gaim_parse_genericerr, 0); | |
1142 oscar_data_addhandler(od, SNAC_FAMILY_ALERT, SNAC_SUBTYPE_ALERT_MAILSTATUS, gaim_email_parseupdate, 0); | |
1143 oscar_data_addhandler(od, SNAC_FAMILY_AUTH, 0x0003, gaim_parse_auth_resp, 0); | |
1144 oscar_data_addhandler(od, SNAC_FAMILY_AUTH, 0x0007, gaim_parse_login, 0); | |
1145 oscar_data_addhandler(od, SNAC_FAMILY_AUTH, SNAC_SUBTYPE_AUTH_SECURID_REQUEST, gaim_parse_auth_securid_request, 0); | |
1146 oscar_data_addhandler(od, SNAC_FAMILY_BART, SNAC_SUBTYPE_BART_ERROR, gaim_icon_error, 0); | |
1147 oscar_data_addhandler(od, SNAC_FAMILY_BART, SNAC_SUBTYPE_BART_RESPONSE, gaim_icon_parseicon, 0); | |
1148 oscar_data_addhandler(od, SNAC_FAMILY_BOS, 0x0001, gaim_parse_genericerr, 0); | |
1149 oscar_data_addhandler(od, SNAC_FAMILY_BOS, 0x0003, gaim_bosrights, 0); | |
1150 oscar_data_addhandler(od, SNAC_FAMILY_BUDDY, 0x0001, gaim_parse_genericerr, 0); | |
1151 oscar_data_addhandler(od, SNAC_FAMILY_BUDDY, SNAC_SUBTYPE_BUDDY_RIGHTSINFO, gaim_parse_buddyrights, 0); | |
1152 oscar_data_addhandler(od, SNAC_FAMILY_BUDDY, SNAC_SUBTYPE_BUDDY_ONCOMING, gaim_parse_oncoming, 0); | |
1153 oscar_data_addhandler(od, SNAC_FAMILY_BUDDY, SNAC_SUBTYPE_BUDDY_OFFGOING, gaim_parse_offgoing, 0); | |
1154 oscar_data_addhandler(od, SNAC_FAMILY_CHAT, 0x0001, gaim_parse_genericerr, 0); | |
1155 oscar_data_addhandler(od, SNAC_FAMILY_CHAT, SNAC_SUBTYPE_CHAT_USERJOIN, gaim_conv_chat_join, 0); | |
1156 oscar_data_addhandler(od, SNAC_FAMILY_CHAT, SNAC_SUBTYPE_CHAT_USERLEAVE, gaim_conv_chat_leave, 0); | |
1157 oscar_data_addhandler(od, SNAC_FAMILY_CHAT, SNAC_SUBTYPE_CHAT_ROOMINFOUPDATE, gaim_conv_chat_info_update, 0); | |
1158 oscar_data_addhandler(od, SNAC_FAMILY_CHAT, SNAC_SUBTYPE_CHAT_INCOMINGMSG, gaim_conv_chat_incoming_msg, 0); | |
1159 oscar_data_addhandler(od, SNAC_FAMILY_CHATNAV, 0x0001, gaim_parse_genericerr, 0); | |
1160 oscar_data_addhandler(od, SNAC_FAMILY_CHATNAV, SNAC_SUBTYPE_CHATNAV_INFO, gaim_chatnav_info, 0); | |
1161 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_ERROR, gaim_ssi_parseerr, 0); | |
1162 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_RIGHTSINFO, gaim_ssi_parserights, 0); | |
1163 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_LIST, gaim_ssi_parselist, 0); | |
1164 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_SRVACK, gaim_ssi_parseack, 0); | |
1165 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_ADD, gaim_ssi_parseadd, 0); | |
1166 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_RECVAUTH, gaim_ssi_authgiven, 0); | |
1167 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_RECVAUTHREQ, gaim_ssi_authrequest, 0); | |
1168 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_RECVAUTHREP, gaim_ssi_authreply, 0); | |
1169 oscar_data_addhandler(od, SNAC_FAMILY_FEEDBAG, SNAC_SUBTYPE_FEEDBAG_ADDED, gaim_ssi_gotadded, 0); | |
1170 oscar_data_addhandler(od, SNAC_FAMILY_ICBM, 0x0005, gaim_icbm_param_info, 0); | |
1171 oscar_data_addhandler(od, SNAC_FAMILY_ICBM, SNAC_SUBTYPE_ICBM_INCOMING, gaim_parse_incoming_im, 0); | |
1172 oscar_data_addhandler(od, SNAC_FAMILY_ICBM, SNAC_SUBTYPE_ICBM_MISSEDCALL, gaim_parse_misses, 0); | |
1173 oscar_data_addhandler(od, SNAC_FAMILY_ICBM, SNAC_SUBTYPE_ICBM_CLIENTAUTORESP, gaim_parse_clientauto, 0); | |
1174 oscar_data_addhandler(od, SNAC_FAMILY_ICBM, SNAC_SUBTYPE_ICBM_ERROR, gaim_parse_msgerr, 0); | |
1175 oscar_data_addhandler(od, SNAC_FAMILY_ICBM, SNAC_SUBTYPE_ICBM_MTN, gaim_parse_mtn, 0); | |
1176 oscar_data_addhandler(od, SNAC_FAMILY_ICBM, SNAC_SUBTYPE_ICBM_ACK, gaim_parse_msgack, 0); | |
1177 oscar_data_addhandler(od, SNAC_FAMILY_ICQ, SNAC_SUBTYPE_ICQ_OFFLINEMSG, gaim_offlinemsg, 0); | |
1178 oscar_data_addhandler(od, SNAC_FAMILY_ICQ, SNAC_SUBTYPE_ICQ_OFFLINEMSGCOMPLETE, gaim_offlinemsgdone, 0); | |
1179 oscar_data_addhandler(od, SNAC_FAMILY_ICQ, SNAC_SUBTYPE_ICQ_ALIAS, gaim_icqalias, 0); | |
1180 oscar_data_addhandler(od, SNAC_FAMILY_ICQ, SNAC_SUBTYPE_ICQ_INFO, gaim_icqinfo, 0); | |
1181 oscar_data_addhandler(od, SNAC_FAMILY_LOCATE, SNAC_SUBTYPE_LOCATE_RIGHTSINFO, gaim_parse_locaterights, 0); | |
1182 oscar_data_addhandler(od, SNAC_FAMILY_LOCATE, SNAC_SUBTYPE_LOCATE_USERINFO, gaim_parse_userinfo, 0); | |
1183 oscar_data_addhandler(od, SNAC_FAMILY_LOCATE, SNAC_SUBTYPE_LOCATE_ERROR, gaim_parse_locerr, 0); | |
1184 oscar_data_addhandler(od, SNAC_FAMILY_LOCATE, SNAC_SUBTYPE_LOCATE_GOTINFOBLOCK, gaim_got_infoblock, 0); | |
1185 oscar_data_addhandler(od, SNAC_FAMILY_OSERVICE, 0x0001, gaim_parse_genericerr, 0); | |
1186 oscar_data_addhandler(od, SNAC_FAMILY_OSERVICE, 0x000f, gaim_selfinfo, 0); | |
1187 oscar_data_addhandler(od, SNAC_FAMILY_OSERVICE, 0x001f, gaim_memrequest, 0); | |
1188 oscar_data_addhandler(od, SNAC_FAMILY_OSERVICE, 0x0021, oscar_icon_req,0); | |
1189 oscar_data_addhandler(od, SNAC_FAMILY_OSERVICE, SNAC_SUBTYPE_OSERVICE_RATECHANGE, gaim_parse_ratechange, 0); | |
1190 oscar_data_addhandler(od, SNAC_FAMILY_OSERVICE, SNAC_SUBTYPE_OSERVICE_REDIRECT, gaim_handle_redirect, 0); | |
1191 oscar_data_addhandler(od, SNAC_FAMILY_OSERVICE, SNAC_SUBTYPE_OSERVICE_MOTD, gaim_parse_motd, 0); | |
1192 oscar_data_addhandler(od, SNAC_FAMILY_OSERVICE, SNAC_SUBTYPE_OSERVICE_EVIL, gaim_parse_evilnotify, 0); | |
1193 oscar_data_addhandler(od, SNAC_FAMILY_POPUP, 0x0002, gaim_popup, 0); | |
1194 oscar_data_addhandler(od, SNAC_FAMILY_USERLOOKUP, SNAC_SUBTYPE_USERLOOKUP_ERROR, gaim_parse_searcherror, 0); | |
1195 oscar_data_addhandler(od, SNAC_FAMILY_USERLOOKUP, 0x0003, gaim_parse_searchreply, 0); | |
1196 | |
1197 gaim_debug_misc("oscar", "oscar_login: gc = %p\n", gc); | |
1198 | |
1199 if (!aim_snvalid(gaim_account_get_username(account))) { | |
1200 gchar *buf; | |
1201 buf = g_strdup_printf(_("Unable to login: Could not sign on as %s because the screen name is invalid. Screen names must either start with a letter and contain only letters, numbers and spaces, or contain only numbers."), gaim_account_get_username(account)); | |
1202 gc->wants_to_die = TRUE; | |
1203 gaim_connection_error(gc, buf); | |
1204 g_free(buf); | |
1205 } | |
1206 | |
1207 if (aim_sn_is_icq((gaim_account_get_username(account)))) { | |
1208 od->icq = TRUE; | |
1209 } else { | |
1210 gc->flags |= GAIM_CONNECTION_HTML; | |
1211 gc->flags |= GAIM_CONNECTION_AUTO_RESP; | |
1212 } | |
1213 | |
1214 /* Connect to core Gaim signals */ | |
1215 gaim_prefs_connect_callback(gc, "/plugins/prpl/oscar/recent_buddies", recent_buddies_cb, gc); | |
1216 | |
1217 newconn = flap_connection_new(od, SNAC_FAMILY_AUTH); | |
14837 | 1218 newconn->connect_data = gaim_proxy_connect(NULL, account, |
14192 | 1219 gaim_account_get_string(account, "server", OSCAR_DEFAULT_LOGIN_SERVER), |
1220 gaim_account_get_int(account, "port", OSCAR_DEFAULT_LOGIN_PORT), | |
1221 connection_established_cb, newconn); | |
14262 | 1222 if (newconn->connect_data == NULL) |
14192 | 1223 { |
1224 gaim_connection_error(gc, _("Couldn't connect to host")); | |
1225 return; | |
1226 } | |
1227 | |
1228 gaim_connection_update_progress(gc, _("Connecting"), 0, OSCAR_CONNECT_STEPS); | |
1229 ck[0] = 0x5a; | |
1230 } | |
1231 | |
14968 | 1232 void |
14192 | 1233 oscar_close(GaimConnection *gc) |
1234 { | |
1235 OscarData *od; | |
1236 | |
1237 od = (OscarData *)gc->proto_data; | |
1238 | |
1239 while (od->oscar_chats) | |
1240 { | |
1241 struct chat_connection *cc = od->oscar_chats->data; | |
1242 od->oscar_chats = g_slist_remove(od->oscar_chats, cc); | |
1243 oscar_chat_destroy(cc); | |
1244 } | |
1245 while (od->create_rooms) | |
1246 { | |
1247 struct create_room *cr = od->create_rooms->data; | |
1248 g_free(cr->name); | |
1249 od->create_rooms = g_slist_remove(od->create_rooms, cr); | |
1250 g_free(cr); | |
1251 } | |
1252 oscar_data_destroy(od); | |
1253 gc->proto_data = NULL; | |
1254 | |
1255 gaim_prefs_disconnect_by_handle(gc); | |
1256 | |
1257 gaim_debug_info("oscar", "Signed off.\n"); | |
1258 } | |
1259 | |
1260 static int | |
1261 gaim_parse_auth_resp(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
1262 { | |
1263 GaimConnection *gc = od->gc; | |
1264 GaimAccount *account = gc->account; | |
1265 char *host; int port; | |
1266 int i; | |
1267 FlapConnection *newconn; | |
1268 va_list ap; | |
1269 struct aim_authresp_info *info; | |
1270 | |
1271 port = gaim_account_get_int(account, "port", OSCAR_DEFAULT_LOGIN_PORT); | |
1272 | |
1273 va_start(ap, fr); | |
1274 info = va_arg(ap, struct aim_authresp_info *); | |
1275 va_end(ap); | |
1276 | |
1277 gaim_debug_info("oscar", | |
1278 "inside auth_resp (Screen name: %s)\n", info->sn); | |
1279 | |
1280 if (info->errorcode || !info->bosip || !info->cookielen || !info->cookie) { | |
1281 char buf[256]; | |
1282 switch (info->errorcode) { | |
14642 | 1283 case 0x01: |
1284 /* Unregistered screen name */ | |
1285 gc->wants_to_die = TRUE; | |
14644 | 1286 gaim_connection_error(gc, _("Invalid screen name.")); |
14642 | 1287 break; |
14192 | 1288 case 0x05: |
14890 | 1289 /* Incorrect password */ |
14192 | 1290 gc->wants_to_die = TRUE; |
14902 | 1291 if (!gaim_account_get_remember_password(account)) |
1292 gaim_account_set_password(account, NULL); | |
14642 | 1293 gaim_connection_error(gc, _("Incorrect password.")); |
14192 | 1294 break; |
1295 case 0x11: | |
1296 /* Suspended account */ | |
1297 gc->wants_to_die = TRUE; | |
1298 gaim_connection_error(gc, _("Your account is currently suspended.")); | |
1299 break; | |
1300 case 0x14: | |
1301 /* service temporarily unavailable */ | |
1302 gaim_connection_error(gc, _("The AOL Instant Messenger service is temporarily unavailable.")); | |
1303 break; | |
1304 case 0x18: | |
1305 /* connecting too frequently */ | |
1306 gc->wants_to_die = TRUE; | |
1307 gaim_connection_error(gc, _("You have been connecting and disconnecting too frequently. Wait ten minutes and try again. If you continue to try, you will need to wait even longer.")); | |
1308 break; | |
1309 case 0x1c: | |
1310 /* client too old */ | |
1311 gc->wants_to_die = TRUE; | |
1312 g_snprintf(buf, sizeof(buf), _("The client version you are using is too old. Please upgrade at %s"), GAIM_WEBSITE); | |
1313 gaim_connection_error(gc, buf); | |
1314 break; | |
1315 default: | |
1316 gaim_connection_error(gc, _("Authentication failed")); | |
1317 break; | |
1318 } | |
1319 gaim_debug_error("oscar", "Login Error Code 0x%04hx\n", info->errorcode); | |
1320 gaim_debug_error("oscar", "Error URL: %s\n", info->errorurl); | |
1321 od->killme = TRUE; | |
1322 return 1; | |
1323 } | |
1324 | |
1325 gaim_debug_misc("oscar", "Reg status: %hu\n", info->regstatus); | |
1326 gaim_debug_misc("oscar", "E-mail: %s\n", | |
1327 (info->email != NULL) ? info->email : "null"); | |
1328 gaim_debug_misc("oscar", "BOSIP: %s\n", info->bosip); | |
1329 gaim_debug_info("oscar", "Closing auth connection...\n"); | |
14392 | 1330 flap_connection_schedule_destroy(conn, OSCAR_DISCONNECT_DONE, NULL); |
14192 | 1331 |
1332 for (i = 0; i < strlen(info->bosip); i++) { | |
1333 if (info->bosip[i] == ':') { | |
1334 port = atoi(&(info->bosip[i+1])); | |
1335 break; | |
1336 } | |
1337 } | |
1338 host = g_strndup(info->bosip, i); | |
1339 newconn = flap_connection_new(od, SNAC_FAMILY_LOCATE); | |
1340 newconn->cookielen = info->cookielen; | |
1341 newconn->cookie = g_memdup(info->cookie, info->cookielen); | |
14837 | 1342 newconn->connect_data = gaim_proxy_connect(NULL, account, host, port, |
14192 | 1343 connection_established_cb, newconn); |
1344 g_free(host); | |
14262 | 1345 if (newconn->connect_data == NULL) |
14192 | 1346 { |
1347 gaim_connection_error(gc, _("Could Not Connect")); | |
1348 od->killme = TRUE; | |
1349 return 0; | |
1350 } | |
1351 | |
1352 gaim_connection_update_progress(gc, _("Received authorization"), 3, OSCAR_CONNECT_STEPS); | |
1353 ck[3] = 0x64; | |
1354 | |
1355 return 1; | |
1356 } | |
1357 | |
1358 static void | |
1359 gaim_parse_auth_securid_request_yes_cb(gpointer user_data, const char *msg) | |
1360 { | |
1361 GaimConnection *gc = user_data; | |
1362 OscarData *od = gc->proto_data; | |
1363 | |
1364 aim_auth_securid_send(od, msg); | |
1365 } | |
1366 | |
1367 static void | |
1368 gaim_parse_auth_securid_request_no_cb(gpointer user_data, const char *value) | |
1369 { | |
1370 GaimConnection *gc = user_data; | |
1371 OscarData *od = gc->proto_data; | |
1372 | |
1373 /* Disconnect */ | |
1374 gc->wants_to_die = TRUE; | |
1375 gaim_connection_error(gc, _("The SecurID key entered is invalid.")); | |
1376 od->killme = TRUE; | |
1377 } | |
1378 | |
1379 static int | |
1380 gaim_parse_auth_securid_request(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
1381 { | |
1382 GaimConnection *gc = od->gc; | |
1383 GaimAccount *account = gaim_connection_get_account(gc); | |
1384 gchar *primary; | |
1385 | |
1386 gaim_debug_info("oscar", "Got SecurID request\n"); | |
1387 | |
1388 primary = g_strdup_printf("Enter the SecurID key for %s.", gaim_account_get_username(account)); | |
1389 gaim_request_input(gc, NULL, _("Enter SecurID"), primary, | |
1390 _("Enter the 6 digit number from the digital display."), | |
1391 FALSE, FALSE, NULL, | |
1392 _("OK"), G_CALLBACK(gaim_parse_auth_securid_request_yes_cb), | |
1393 _("Cancel"), G_CALLBACK(gaim_parse_auth_securid_request_no_cb), | |
1394 gc); | |
1395 g_free(primary); | |
1396 | |
1397 return 1; | |
1398 } | |
1399 | |
14354 | 1400 /* XXX - Should use gaim_util_fetch_url for the below stuff */ |
14192 | 1401 struct pieceofcrap { |
1402 GaimConnection *gc; | |
1403 unsigned long offset; | |
1404 unsigned long len; | |
1405 char *modname; | |
1406 int fd; | |
1407 FlapConnection *conn; | |
1408 unsigned int inpa; | |
1409 }; | |
1410 | |
1411 static void damn_you(gpointer data, gint source, GaimInputCondition c) | |
1412 { | |
1413 struct pieceofcrap *pos = data; | |
1414 OscarData *od = pos->gc->proto_data; | |
1415 char in = '\0'; | |
1416 int x = 0; | |
1417 unsigned char m[17]; | |
1418 | |
1419 while (read(pos->fd, &in, 1) == 1) { | |
1420 if (in == '\n') | |
1421 x++; | |
1422 else if (in != '\r') | |
1423 x = 0; | |
1424 if (x == 2) | |
1425 break; | |
1426 in = '\0'; | |
1427 } | |
1428 if (in != '\n') { | |
1429 char buf[256]; | |
1430 g_snprintf(buf, sizeof(buf), _("You may be disconnected shortly. You may want to use TOC until " | |
1431 "this is fixed. Check %s for updates."), GAIM_WEBSITE); | |
1432 gaim_notify_warning(pos->gc, NULL, | |
1433 _("Gaim was unable to get a valid AIM login hash."), | |
1434 buf); | |
1435 gaim_input_remove(pos->inpa); | |
1436 close(pos->fd); | |
1437 g_free(pos); | |
1438 return; | |
1439 } | |
1440 if (read(pos->fd, m, 16) != 16) | |
1441 { | |
1442 gaim_debug_warning("oscar", "Could not read full AIM login hash " | |
1443 "from " AIMHASHDATA "--that's bad.\n"); | |
1444 } | |
1445 m[16] = '\0'; | |
1446 gaim_debug_misc("oscar", "Sending hash: "); | |
1447 for (x = 0; x < 16; x++) | |
1448 gaim_debug_misc(NULL, "%02hhx ", (unsigned char)m[x]); | |
1449 | |
1450 gaim_debug_misc(NULL, "\n"); | |
1451 gaim_input_remove(pos->inpa); | |
1452 close(pos->fd); | |
1453 aim_sendmemblock(od, pos->conn, 0, 16, m, AIM_SENDMEMBLOCK_FLAG_ISHASH); | |
1454 g_free(pos); | |
1455 } | |
1456 | |
1457 static void | |
1458 straight_to_hell(gpointer data, gint source, const gchar *error_message) | |
1459 { | |
1460 struct pieceofcrap *pos = data; | |
1461 gchar *buf; | |
1462 | |
1463 if (!GAIM_CONNECTION_IS_VALID(pos->gc)) | |
1464 { | |
1465 g_free(pos->modname); | |
1466 g_free(pos); | |
1467 return; | |
1468 } | |
1469 | |
1470 pos->fd = source; | |
1471 | |
1472 if (source < 0) { | |
1473 buf = g_strdup_printf(_("You may be disconnected shortly. You may want to use TOC until " | |
1474 "this is fixed. Check %s for updates."), GAIM_WEBSITE); | |
1475 gaim_notify_warning(pos->gc, NULL, | |
1476 _("Gaim was unable to get a valid AIM login hash."), | |
1477 buf); | |
1478 g_free(buf); | |
1479 g_free(pos->modname); | |
1480 g_free(pos); | |
1481 return; | |
1482 } | |
1483 | |
1484 buf = g_strdup_printf("GET " AIMHASHDATA "?offset=%ld&len=%ld&modname=%s HTTP/1.0\n\n", | |
1485 pos->offset, pos->len, pos->modname ? pos->modname : ""); | |
1486 write(pos->fd, buf, strlen(buf)); | |
1487 g_free(buf); | |
1488 g_free(pos->modname); | |
1489 pos->inpa = gaim_input_add(pos->fd, GAIM_INPUT_READ, damn_you, pos); | |
1490 return; | |
1491 } | |
1492 | |
1493 /* size of icbmui.ocm, the largest module in AIM 3.5 */ | |
1494 #define AIM_MAX_FILE_SIZE 98304 | |
1495 | |
1496 int gaim_memrequest(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
1497 va_list ap; | |
1498 struct pieceofcrap *pos; | |
1499 guint32 offset, len; | |
1500 char *modname; | |
1501 | |
1502 va_start(ap, fr); | |
1503 offset = va_arg(ap, guint32); | |
1504 len = va_arg(ap, guint32); | |
1505 modname = va_arg(ap, char *); | |
1506 va_end(ap); | |
1507 | |
1508 gaim_debug_misc("oscar", "offset: %u, len: %u, file: %s\n", | |
1509 offset, len, (modname ? modname : "aim.exe")); | |
1510 | |
1511 if (len == 0) { | |
1512 gaim_debug_misc("oscar", "len is 0, hashing NULL\n"); | |
1513 aim_sendmemblock(od, conn, offset, len, NULL, | |
1514 AIM_SENDMEMBLOCK_FLAG_ISREQUEST); | |
1515 return 1; | |
1516 } | |
1517 /* uncomment this when you're convinced it's right. remember, it's been wrong before. */ | |
1518 #if 0 | |
1519 if (offset > AIM_MAX_FILE_SIZE || len > AIM_MAX_FILE_SIZE) { | |
1520 char *buf; | |
1521 int i = 8; | |
1522 if (modname) | |
1523 i += strlen(modname); | |
1524 buf = g_malloc(i); | |
1525 i = 0; | |
1526 if (modname) { | |
1527 memcpy(buf, modname, strlen(modname)); | |
1528 i += strlen(modname); | |
1529 } | |
1530 buf[i++] = offset & 0xff; | |
1531 buf[i++] = (offset >> 8) & 0xff; | |
1532 buf[i++] = (offset >> 16) & 0xff; | |
1533 buf[i++] = (offset >> 24) & 0xff; | |
1534 buf[i++] = len & 0xff; | |
1535 buf[i++] = (len >> 8) & 0xff; | |
1536 buf[i++] = (len >> 16) & 0xff; | |
1537 buf[i++] = (len >> 24) & 0xff; | |
1538 gaim_debug_misc("oscar", "len + offset is invalid, " | |
1539 "hashing request\n"); | |
1540 aim_sendmemblock(od, command->conn, offset, i, buf, AIM_SENDMEMBLOCK_FLAG_ISREQUEST); | |
1541 g_free(buf); | |
1542 return 1; | |
1543 } | |
1544 #endif | |
1545 | |
1546 pos = g_new0(struct pieceofcrap, 1); | |
1547 pos->gc = od->gc; | |
1548 pos->conn = conn; | |
1549 | |
1550 pos->offset = offset; | |
1551 pos->len = len; | |
1552 pos->modname = g_strdup(modname); | |
1553 | |
1554 /* TODO: Keep track of this return value. */ | |
14837 | 1555 if (gaim_proxy_connect(NULL, pos->gc->account, "gaim.sourceforge.net", 80, |
14192 | 1556 straight_to_hell, pos) == NULL) |
1557 { | |
1558 char buf[256]; | |
1559 if (pos->modname) | |
1560 g_free(pos->modname); | |
1561 g_free(pos); | |
1562 g_snprintf(buf, sizeof(buf), _("You may be disconnected shortly. " | |
1563 "Check %s for updates."), GAIM_WEBSITE); | |
1564 gaim_notify_warning(pos->gc, NULL, | |
1565 _("Gaim was unable to get a valid login hash."), | |
1566 buf); | |
1567 } | |
1568 | |
1569 return 1; | |
1570 } | |
1571 | |
1572 static int | |
1573 gaim_parse_login(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
1574 { | |
1575 GaimConnection *gc; | |
1576 GaimAccount *account; | |
1577 ClientInfo info = CLIENTINFO_GAIM; | |
1578 va_list ap; | |
1579 char *key; | |
1580 | |
1581 gc = od->gc; | |
1582 account = gaim_connection_get_account(gc); | |
1583 | |
1584 va_start(ap, fr); | |
1585 key = va_arg(ap, char *); | |
1586 va_end(ap); | |
1587 | |
1588 aim_send_login(od, conn, gaim_account_get_username(account), | |
1589 gaim_connection_get_password(gc), &info, key); | |
1590 | |
1591 gaim_connection_update_progress(gc, _("Password sent"), 2, OSCAR_CONNECT_STEPS); | |
1592 ck[2] = 0x6c; | |
1593 | |
1594 return 1; | |
1595 } | |
1596 | |
1597 static int | |
1598 gaim_handle_redirect(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
1599 { | |
1600 GaimConnection *gc = od->gc; | |
1601 GaimAccount *account = gaim_connection_get_account(gc); | |
1602 char *host, *separator; | |
1603 int port; | |
1604 FlapConnection *newconn; | |
1605 va_list ap; | |
1606 struct aim_redirect_data *redir; | |
1607 | |
1608 va_start(ap, fr); | |
1609 redir = va_arg(ap, struct aim_redirect_data *); | |
1610 va_end(ap); | |
1611 | |
1612 port = gaim_account_get_int(account, "port", OSCAR_DEFAULT_LOGIN_PORT); | |
1613 separator = strchr(redir->ip, ':'); | |
1614 if (separator != NULL) | |
1615 { | |
1616 host = g_strndup(redir->ip, separator - redir->ip); | |
1617 port = atoi(separator + 1); | |
1618 } | |
1619 else | |
1620 host = g_strdup(redir->ip); | |
1621 | |
1622 gaim_debug_info("oscar", "Connecting to FLAP server %s:%d of type 0x%04hx\n", | |
1623 host, port, redir->group); | |
1624 newconn = flap_connection_new(od, redir->group); | |
1625 newconn->cookielen = redir->cookielen; | |
1626 newconn->cookie = g_memdup(redir->cookie, redir->cookielen); | |
1627 if (newconn->type == SNAC_FAMILY_CHAT) | |
1628 { | |
1629 struct chat_connection *cc; | |
1630 cc = g_new0(struct chat_connection, 1); | |
1631 cc->conn = newconn; | |
1632 cc->gc = gc; | |
1633 cc->name = g_strdup(redir->chat.room); | |
1634 cc->exchange = redir->chat.exchange; | |
1635 cc->instance = redir->chat.instance; | |
1636 cc->show = extract_name(redir->chat.room); | |
14262 | 1637 newconn->new_conn_data = cc; |
14192 | 1638 gaim_debug_info("oscar", "Connecting to chat room %s exchange %hu\n", cc->name, cc->exchange); |
1639 } | |
1640 | |
14837 | 1641 newconn->connect_data = gaim_proxy_connect(NULL, account, host, port, |
14192 | 1642 connection_established_cb, newconn); |
14262 | 1643 if (newconn->connect_data == NULL) |
14192 | 1644 { |
14392 | 1645 flap_connection_schedule_destroy(newconn, |
1646 OSCAR_DISCONNECT_COULD_NOT_CONNECT, | |
14837 | 1647 _("Unable to initialize connection")); |
14192 | 1648 gaim_debug_error("oscar", "Unable to connect to FLAP server " |
1649 "of type 0x%04hx\n", redir->group); | |
1650 } | |
1651 g_free(host); | |
1652 | |
1653 return 1; | |
1654 } | |
1655 | |
1656 static int gaim_parse_oncoming(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
1657 { | |
1658 GaimConnection *gc; | |
1659 GaimAccount *account; | |
1660 GaimPresence *presence; | |
1661 struct buddyinfo *bi; | |
1662 time_t time_idle = 0, signon = 0; | |
1663 int type = 0; | |
1664 gboolean buddy_is_away = FALSE; | |
1665 const char *status_id; | |
1666 gboolean have_status_message = FALSE; | |
1667 char *message = NULL; | |
1668 va_list ap; | |
1669 aim_userinfo_t *info; | |
1670 | |
1671 gc = od->gc; | |
1672 account = gaim_connection_get_account(gc); | |
1673 presence = gaim_account_get_presence(account); | |
1674 | |
1675 va_start(ap, fr); | |
1676 info = va_arg(ap, aim_userinfo_t *); | |
1677 va_end(ap); | |
1678 | |
1679 g_return_val_if_fail(info != NULL, 1); | |
1680 g_return_val_if_fail(info->sn != NULL, 1); | |
1681 | |
1682 if (info->present & AIM_USERINFO_PRESENT_FLAGS) { | |
1683 if (info->flags & AIM_FLAG_AWAY) | |
1684 buddy_is_away = TRUE; | |
1685 } | |
1686 if (info->present & AIM_USERINFO_PRESENT_ICQEXTSTATUS) { | |
1687 type = info->icqinfo.status; | |
1688 if (!(info->icqinfo.status & AIM_ICQ_STATE_CHAT) && | |
1689 (info->icqinfo.status != AIM_ICQ_STATE_NORMAL)) { | |
1690 buddy_is_away = TRUE; | |
1691 } | |
1692 } | |
1693 | |
1694 if (aim_sn_is_icq(info->sn)) { | |
1695 if (type & AIM_ICQ_STATE_CHAT) | |
1696 status_id = OSCAR_STATUS_ID_FREE4CHAT; | |
1697 else if (type & AIM_ICQ_STATE_DND) | |
1698 status_id = OSCAR_STATUS_ID_DND; | |
1699 else if (type & AIM_ICQ_STATE_OUT) | |
1700 status_id = OSCAR_STATUS_ID_NA; | |
1701 else if (type & AIM_ICQ_STATE_BUSY) | |
1702 status_id = OSCAR_STATUS_ID_OCCUPIED; | |
1703 else if (type & AIM_ICQ_STATE_AWAY) | |
1704 status_id = OSCAR_STATUS_ID_AWAY; | |
1705 else if (type & AIM_ICQ_STATE_INVISIBLE) | |
1706 status_id = OSCAR_STATUS_ID_INVISIBLE; | |
1707 else | |
1708 status_id = OSCAR_STATUS_ID_AVAILABLE; | |
1709 } else { | |
1710 if (buddy_is_away) | |
1711 status_id = OSCAR_STATUS_ID_AWAY; | |
1712 else | |
1713 status_id = OSCAR_STATUS_ID_AVAILABLE; | |
1714 } | |
1715 | |
1716 /* | |
1717 * Handle the available message. If info->status is NULL then the user | |
1718 * may or may not have an available message, so don't do anything. If | |
1719 * info->status is set to the empty string, then the user's client DOES | |
1720 * support available messages and the user DOES NOT have one set. | |
1721 * Otherwise info->status contains the available message. | |
1722 */ | |
1723 if (info->status != NULL) | |
1724 { | |
1725 have_status_message = TRUE; | |
1726 if (info->status[0] != '\0') | |
1727 message = oscar_encoding_to_utf8(info->status_encoding, | |
1728 info->status, info->status_len); | |
1729 } | |
1730 | |
1731 if (have_status_message) | |
1732 { | |
1733 gaim_prpl_got_user_status(account, info->sn, status_id, | |
1734 "message", message, NULL); | |
1735 g_free(message); | |
1736 } | |
1737 else | |
1738 gaim_prpl_got_user_status(account, info->sn, status_id, NULL); | |
1739 | |
1740 /* Login time stuff */ | |
1741 if (info->present & AIM_USERINFO_PRESENT_ONLINESINCE) | |
1742 signon = info->onlinesince; | |
1743 else if (info->present & AIM_USERINFO_PRESENT_SESSIONLEN) | |
1744 signon = time(NULL) - info->sessionlen; | |
1745 if (!aim_sncmp(gaim_account_get_username(account), info->sn)) { | |
1746 gaim_connection_set_display_name(gc, info->sn); | |
1747 od->timeoffset = signon - gaim_presence_get_login_time(presence); | |
1748 } | |
1749 gaim_prpl_got_user_login_time(account, info->sn, signon - od->timeoffset); | |
1750 | |
1751 /* Idle time stuff */ | |
1752 /* info->idletime is the number of minutes that this user has been idle */ | |
1753 if (info->present & AIM_USERINFO_PRESENT_IDLE) | |
1754 time_idle = time(NULL) - info->idletime * 60; | |
1755 | |
1756 if (time_idle > 0) | |
1757 gaim_prpl_got_user_idle(account, info->sn, TRUE, time_idle); | |
1758 else | |
1759 gaim_prpl_got_user_idle(account, info->sn, FALSE, 0); | |
1760 | |
1761 /* Server stored icon stuff */ | |
1762 bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(account, info->sn)); | |
1763 if (!bi) { | |
1764 bi = g_new0(struct buddyinfo, 1); | |
1765 g_hash_table_insert(od->buddyinfo, g_strdup(gaim_normalize(account, info->sn)), bi); | |
1766 } | |
1767 bi->typingnot = FALSE; | |
1768 bi->ico_informed = FALSE; | |
1769 bi->ipaddr = info->icqinfo.ipaddr; | |
1770 | |
1771 if (info->iconcsumlen) { | |
1772 const char *filename, *saved_b16 = NULL; | |
1773 char *b16 = NULL, *filepath = NULL; | |
1774 GaimBuddy *b = NULL; | |
1775 | |
1776 b16 = gaim_base16_encode(info->iconcsum, info->iconcsumlen); | |
1777 b = gaim_find_buddy(account, info->sn); | |
1778 /* | |
1779 * If for some reason the checksum is valid, but cached file is not.. | |
1780 * we want to know. | |
1781 */ | |
1782 if (b != NULL) | |
1783 filename = gaim_blist_node_get_string((GaimBlistNode*)b, "buddy_icon"); | |
1784 else | |
1785 filename = NULL; | |
1786 if (filename != NULL) { | |
1787 if (g_file_test(filename, G_FILE_TEST_EXISTS)) | |
1788 saved_b16 = gaim_blist_node_get_string((GaimBlistNode*)b, | |
1789 "icon_checksum"); | |
1790 else { | |
1791 filepath = g_build_filename(gaim_buddy_icons_get_cache_dir(), | |
1792 filename, NULL); | |
1793 if (g_file_test(filepath, G_FILE_TEST_EXISTS)) | |
1794 saved_b16 = gaim_blist_node_get_string((GaimBlistNode*)b, | |
1795 "icon_checksum"); | |
1796 g_free(filepath); | |
1797 } | |
1798 } else | |
1799 saved_b16 = NULL; | |
1800 | |
1801 if (!b16 || !saved_b16 || strcmp(b16, saved_b16)) { | |
1802 GSList *cur = od->requesticon; | |
1803 while (cur && aim_sncmp((char *)cur->data, info->sn)) | |
1804 cur = cur->next; | |
1805 if (!cur) { | |
1806 od->requesticon = g_slist_append(od->requesticon, g_strdup(gaim_normalize(account, info->sn))); | |
1807 if (od->icontimer == 0) | |
1808 od->icontimer = gaim_timeout_add(500, gaim_icon_timerfunc, gc); | |
1809 } | |
1810 } | |
1811 g_free(b16); | |
1812 } | |
1813 | |
1814 return 1; | |
1815 } | |
1816 | |
1817 static void gaim_check_comment(OscarData *od, const char *str) { | |
1818 if ((str == NULL) || strcmp(str, (const char *)ck)) | |
14552 | 1819 aim_locate_setcaps(od, gaim_caps); |
14192 | 1820 else |
14552 | 1821 aim_locate_setcaps(od, gaim_caps | OSCAR_CAPABILITY_SECUREIM); |
14192 | 1822 } |
1823 | |
1824 static int gaim_parse_offgoing(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
1825 GaimConnection *gc = od->gc; | |
1826 GaimAccount *account = gaim_connection_get_account(gc); | |
1827 va_list ap; | |
1828 aim_userinfo_t *info; | |
1829 | |
1830 va_start(ap, fr); | |
1831 info = va_arg(ap, aim_userinfo_t *); | |
1832 va_end(ap); | |
1833 | |
1834 gaim_prpl_got_user_status(account, info->sn, OSCAR_STATUS_ID_OFFLINE, NULL); | |
1835 | |
1836 g_hash_table_remove(od->buddyinfo, gaim_normalize(gc->account, info->sn)); | |
1837 | |
1838 return 1; | |
1839 } | |
1840 | |
1841 static int incomingim_chan1(OscarData *od, FlapConnection *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch1_args *args) { | |
1842 GaimConnection *gc = od->gc; | |
1843 GaimAccount *account = gaim_connection_get_account(gc); | |
1844 GaimMessageFlags flags = 0; | |
1845 struct buddyinfo *bi; | |
1846 char *iconfile; | |
1847 GString *message; | |
1848 gchar *tmp; | |
1849 aim_mpmsg_section_t *curpart; | |
1850 const char *start, *end; | |
1851 GData *attribs; | |
1852 | |
1853 gaim_debug_misc("oscar", "Received IM from %s with %d parts\n", | |
1854 userinfo->sn, args->mpmsg.numparts); | |
1855 | |
1856 if (args->mpmsg.numparts == 0) | |
1857 return 1; | |
1858 | |
1859 bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(account, userinfo->sn)); | |
1860 if (!bi) { | |
1861 bi = g_new0(struct buddyinfo, 1); | |
1862 g_hash_table_insert(od->buddyinfo, g_strdup(gaim_normalize(account, userinfo->sn)), bi); | |
1863 } | |
1864 | |
1865 if (args->icbmflags & AIM_IMFLAGS_AWAY) | |
1866 flags |= GAIM_MESSAGE_AUTO_RESP; | |
1867 | |
1868 if (args->icbmflags & AIM_IMFLAGS_TYPINGNOT) | |
1869 bi->typingnot = TRUE; | |
1870 else | |
1871 bi->typingnot = FALSE; | |
1872 | |
1873 if ((args->icbmflags & AIM_IMFLAGS_HASICON) && (args->iconlen) && (args->iconsum) && (args->iconstamp)) { | |
1874 gaim_debug_misc("oscar", "%s has an icon\n", userinfo->sn); | |
1875 if ((args->iconlen != bi->ico_len) || (args->iconsum != bi->ico_csum) || (args->iconstamp != bi->ico_time)) { | |
1876 bi->ico_need = TRUE; | |
1877 bi->ico_len = args->iconlen; | |
1878 bi->ico_csum = args->iconsum; | |
1879 bi->ico_time = args->iconstamp; | |
1880 } | |
1881 } | |
1882 | |
1883 iconfile = gaim_buddy_icons_get_full_path(gaim_account_get_buddy_icon(account)); | |
1884 if ((iconfile != NULL) && | |
1885 (args->icbmflags & AIM_IMFLAGS_BUDDYREQ) && !bi->ico_sent && bi->ico_informed) { | |
1886 FILE *file; | |
1887 struct stat st; | |
1888 | |
1889 if (!g_stat(iconfile, &st)) { | |
1890 guchar *buf = g_malloc(st.st_size); | |
1891 file = g_fopen(iconfile, "rb"); | |
1892 if (file) { | |
1893 /* XXX - Use g_file_get_contents() */ | |
1894 /* g_file_get_contents(iconfile, &data, &len, NULL); */ | |
1895 int len = fread(buf, 1, st.st_size, file); | |
1896 gaim_debug_info("oscar", | |
1897 "Sending buddy icon to %s (%d bytes, " | |
1898 "%lu reported)\n", | |
1899 userinfo->sn, len, st.st_size); | |
1900 aim_im_sendch2_icon(od, userinfo->sn, buf, st.st_size, | |
1901 st.st_mtime, aimutil_iconsum(buf, st.st_size)); | |
1902 fclose(file); | |
1903 } else | |
1904 gaim_debug_error("oscar", "Can't open buddy icon file!\n"); | |
1905 g_free(buf); | |
1906 } else | |
1907 gaim_debug_error("oscar", "Can't stat buddy icon file!\n"); | |
1908 } | |
1909 g_free(iconfile); | |
1910 | |
1911 message = g_string_new(""); | |
1912 curpart = args->mpmsg.parts; | |
1913 while (curpart != NULL) { | |
1914 tmp = gaim_plugin_oscar_decode_im_part(account, userinfo->sn, curpart->charset, | |
1915 curpart->charsubset, curpart->data, curpart->datalen); | |
1916 if (tmp != NULL) { | |
1917 g_string_append(message, tmp); | |
1918 g_free(tmp); | |
1919 } | |
1920 | |
1921 curpart = curpart->next; | |
1922 } | |
1923 tmp = g_string_free(message, FALSE); | |
1924 | |
1925 /* | |
1926 * If the message is from an ICQ user and to an ICQ user then escape any HTML, | |
1927 * because HTML is not sent over ICQ as a means to format a message. | |
1928 * So any HTML we receive is intended to be displayed. Also, \r\n must be | |
1929 * replaced with <br> | |
1930 * | |
1931 * Note: There *may* be some clients which send messages as HTML formatted - | |
1932 * they need to be special-cased somehow. | |
1933 */ | |
1934 if (aim_sn_is_icq(gaim_account_get_username(account)) && aim_sn_is_icq(userinfo->sn)) { | |
1935 /* being recevied by ICQ from ICQ - escape HTML so it is displayed as sent */ | |
1936 gchar *tmp2 = g_markup_escape_text(tmp, -1); | |
1937 g_free(tmp); | |
1938 tmp = tmp2; | |
1939 tmp2 = gaim_strreplace(tmp, "\r\n", "<br>"); | |
1940 g_free(tmp); | |
1941 tmp = tmp2; | |
1942 } | |
1943 | |
1944 /* | |
1945 * Convert iChat color tags to normal font tags. | |
1946 */ | |
1947 if (gaim_markup_find_tag("body", tmp, &start, &end, &attribs)) | |
1948 { | |
1949 const char *ichattextcolor, *ichatballooncolor; | |
1950 | |
1951 ichattextcolor = g_datalist_get_data(&attribs, "ichattextcolor"); | |
1952 if (ichattextcolor != NULL) | |
1953 { | |
1954 gchar *tmp2; | |
1955 tmp2 = g_strdup_printf("<font color=\"%s\">%s</font>", ichattextcolor, tmp); | |
1956 g_free(tmp); | |
1957 tmp = tmp2; | |
1958 } | |
1959 | |
1960 ichatballooncolor = g_datalist_get_data(&attribs, "ichatballooncolor"); | |
1961 if (ichatballooncolor != NULL) | |
1962 { | |
1963 gchar *tmp2; | |
1964 tmp2 = g_strdup_printf("<font back=\"%s\">%s</font>", ichatballooncolor, tmp); | |
1965 g_free(tmp); | |
1966 tmp = tmp2; | |
1967 } | |
1968 | |
1969 g_datalist_clear(&attribs); | |
1970 } | |
1971 | |
1972 serv_got_im(gc, userinfo->sn, tmp, flags, time(NULL)); | |
1973 g_free(tmp); | |
1974 | |
1975 return 1; | |
1976 } | |
1977 | |
1978 static int | |
1979 incomingim_chan2(OscarData *od, FlapConnection *conn, aim_userinfo_t *userinfo, IcbmArgsCh2 *args) | |
1980 { | |
1981 GaimConnection *gc; | |
1982 GaimAccount *account; | |
1983 char *message = NULL; | |
1984 | |
1985 g_return_val_if_fail(od != NULL, 0); | |
1986 g_return_val_if_fail(od->gc != NULL, 0); | |
1987 | |
1988 gc = od->gc; | |
1989 account = gaim_connection_get_account(gc); | |
1990 od = gc->proto_data; | |
1991 | |
1992 if (args == NULL) | |
1993 return 0; | |
1994 | |
1995 gaim_debug_misc("oscar", "Incoming rendezvous message of type %u, " | |
1996 "user %s, status %hu\n", args->type, userinfo->sn, args->status); | |
1997 | |
1998 if (args->msg != NULL) | |
1999 { | |
2000 if (args->encoding != NULL) | |
2001 { | |
2002 char *encoding = NULL; | |
2003 encoding = oscar_encoding_extract(args->encoding); | |
2004 message = oscar_encoding_to_utf8(encoding, args->msg, args->msglen); | |
2005 g_free(encoding); | |
2006 } else { | |
2007 if (g_utf8_validate(args->msg, args->msglen, NULL)) | |
2008 message = g_strdup(args->msg); | |
2009 } | |
2010 } | |
2011 | |
2012 if (args->type & OSCAR_CAPABILITY_CHAT) | |
2013 { | |
2014 char *name; | |
2015 GHashTable *components; | |
2016 | |
2017 if (!args->info.chat.roominfo.name || !args->info.chat.roominfo.exchange) { | |
2018 g_free(message); | |
2019 return 1; | |
2020 } | |
2021 components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, | |
2022 g_free); | |
2023 name = extract_name(args->info.chat.roominfo.name); | |
2024 g_hash_table_replace(components, g_strdup("room"), | |
2025 g_strdup(name ? name : args->info.chat.roominfo.name)); | |
2026 g_hash_table_replace(components, g_strdup("exchange"), | |
2027 g_strdup_printf("%d", args->info.chat.roominfo.exchange)); | |
2028 serv_got_chat_invite(gc, | |
2029 name ? name : args->info.chat.roominfo.name, | |
2030 userinfo->sn, | |
2031 message, | |
2032 components); | |
2033 if (name) | |
2034 g_free(name); | |
2035 } | |
2036 | |
2037 else if ((args->type & OSCAR_CAPABILITY_SENDFILE) || | |
2038 (args->type & OSCAR_CAPABILITY_DIRECTIM)) | |
2039 { | |
2040 if (args->status == AIM_RENDEZVOUS_PROPOSE) | |
2041 { | |
2042 peer_connection_got_proposition(od, userinfo->sn, message, args); | |
2043 } | |
2044 else if (args->status == AIM_RENDEZVOUS_CANCEL) | |
2045 { | |
2046 /* The other user canceled a peer request */ | |
2047 PeerConnection *conn; | |
2048 | |
2049 conn = peer_connection_find_by_cookie(od, userinfo->sn, args->cookie); | |
2050 /* | |
2051 * If conn is NULL it means we haven't tried to create | |
2052 * a connection with that user. They may be trying to | |
2053 * do something malicious. | |
2054 */ | |
2055 if (conn != NULL) | |
2056 { | |
14402 | 2057 peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL); |
14192 | 2058 } |
2059 } | |
2060 else if (args->status == AIM_RENDEZVOUS_CONNECTED) | |
2061 { | |
2062 /* Remote user has accepted our peer request */ | |
2063 PeerConnection *conn; | |
2064 | |
2065 conn = peer_connection_find_by_cookie(od, userinfo->sn, args->cookie); | |
2066 /* | |
2067 * If conn is NULL it means we haven't tried to create | |
2068 * a connection with that user. They may be trying to | |
2069 * do something malicious. | |
2070 */ | |
2071 if (conn != NULL) | |
2072 { | |
2073 if (conn->listenerfd != -1) | |
2074 { | |
2075 /* | |
2076 * If they are connecting directly to us then | |
2077 * continue the peer negotiation by | |
2078 * accepting connections on our listener port. | |
2079 */ | |
2080 conn->watcher_incoming = gaim_input_add(conn->listenerfd, | |
2081 GAIM_INPUT_READ, peer_connection_listen_cb, conn); | |
2082 } | |
2083 } | |
2084 } | |
2085 } | |
2086 | |
2087 else if (args->type & OSCAR_CAPABILITY_GETFILE) | |
2088 { | |
2089 } | |
2090 | |
2091 else if (args->type & OSCAR_CAPABILITY_TALK) | |
2092 { | |
2093 } | |
2094 | |
2095 else if (args->type & OSCAR_CAPABILITY_BUDDYICON) | |
2096 { | |
2097 gaim_buddy_icons_set_for_user(account, userinfo->sn, | |
2098 args->info.icon.icon, | |
2099 args->info.icon.length); | |
2100 } | |
2101 | |
2102 else if (args->type & OSCAR_CAPABILITY_ICQSERVERRELAY) | |
2103 { | |
2104 gaim_debug_error("oscar", "Got an ICQ Server Relay message of " | |
2105 "type %d\n", args->info.rtfmsg.msgtype); | |
2106 } | |
2107 | |
2108 else | |
2109 { | |
2110 gaim_debug_error("oscar", "Unknown request class %hu\n", | |
2111 args->type); | |
2112 } | |
2113 | |
2114 g_free(message); | |
2115 | |
2116 return 1; | |
2117 } | |
2118 | |
2119 /* | |
2120 * Authorization Functions | |
2121 * Most of these are callbacks from dialogs. They're used by both | |
2122 * methods of authorization (SSI and old-school channel 4 ICBM) | |
2123 */ | |
2124 /* When you ask other people for authorization */ | |
2125 static void | |
2126 gaim_auth_request(struct name_data *data, char *msg) | |
2127 { | |
2128 GaimConnection *gc; | |
2129 OscarData *od; | |
2130 GaimBuddy *buddy; | |
2131 GaimGroup *group; | |
2132 | |
2133 gc = data->gc; | |
2134 od = gc->proto_data; | |
2135 buddy = gaim_find_buddy(gaim_connection_get_account(gc), data->name); | |
2136 if (buddy != NULL) | |
2137 group = gaim_buddy_get_group(buddy); | |
2138 else | |
2139 group = NULL; | |
2140 | |
2141 if (group != NULL) | |
2142 { | |
2143 gaim_debug_info("oscar", "ssi: adding buddy %s to group %s\n", | |
2144 buddy->name, group->name); | |
2145 aim_ssi_sendauthrequest(od, data->name, msg ? msg : _("Please authorize me so I can add you to my buddy list.")); | |
2146 if (!aim_ssi_itemlist_finditem(od->ssi.local, group->name, buddy->name, AIM_SSI_TYPE_BUDDY)) | |
2147 aim_ssi_addbuddy(od, buddy->name, group->name, gaim_buddy_get_alias_only(buddy), NULL, NULL, 1); | |
2148 } | |
2149 } | |
2150 | |
2151 static void | |
2152 gaim_auth_dontrequest(struct name_data *data) | |
2153 { | |
2154 GaimConnection *gc = data->gc; | |
2155 GaimBuddy *b = gaim_find_buddy(gaim_connection_get_account(gc), data->name); | |
2156 | |
2157 /* Remove from local list */ | |
2158 gaim_blist_remove_buddy(b); | |
2159 | |
2160 oscar_free_name_data(data); | |
2161 } | |
2162 | |
2163 | |
2164 static void | |
15053 | 2165 gaim_auth_sendrequest(GaimConnection *gc, const char *name) |
14192 | 2166 { |
15053 | 2167 struct name_data *data; |
2168 | |
2169 data = g_new0(struct name_data, 1); | |
14192 | 2170 data->gc = gc; |
2171 data->name = g_strdup(name); | |
15053 | 2172 |
2173 gaim_request_input(data->gc, NULL, _("Authorization Request Message:"), | |
2174 NULL, _("Please authorize me!"), TRUE, FALSE, NULL, | |
2175 _("OK"), G_CALLBACK(gaim_auth_request), | |
2176 _("Cancel"), G_CALLBACK(gaim_auth_dontrequest), | |
2177 data); | |
14192 | 2178 } |
2179 | |
2180 | |
2181 static void | |
2182 gaim_auth_sendrequest_menu(GaimBlistNode *node, gpointer ignored) | |
2183 { | |
2184 GaimBuddy *buddy; | |
2185 GaimConnection *gc; | |
2186 | |
2187 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node)); | |
2188 | |
2189 buddy = (GaimBuddy *) node; | |
2190 gc = gaim_account_get_connection(buddy->account); | |
2191 gaim_auth_sendrequest(gc, buddy->name); | |
2192 } | |
2193 | |
2194 /* When other people ask you for authorization */ | |
2195 static void | |
2196 gaim_auth_grant(struct name_data *data) | |
2197 { | |
2198 GaimConnection *gc = data->gc; | |
2199 OscarData *od = gc->proto_data; | |
2200 | |
2201 aim_ssi_sendauthreply(od, data->name, 0x01, NULL); | |
2202 | |
2203 oscar_free_name_data(data); | |
2204 } | |
2205 | |
2206 /* When other people ask you for authorization */ | |
2207 static void | |
2208 gaim_auth_dontgrant(struct name_data *data, char *msg) | |
2209 { | |
2210 GaimConnection *gc = data->gc; | |
2211 OscarData *od = gc->proto_data; | |
2212 | |
2213 aim_ssi_sendauthreply(od, data->name, 0x00, msg ? msg : _("No reason given.")); | |
2214 } | |
2215 | |
2216 static void | |
2217 gaim_auth_dontgrant_msgprompt(struct name_data *data) | |
2218 { | |
2219 gaim_request_input(data->gc, NULL, _("Authorization Denied Message:"), | |
2220 NULL, _("No reason given."), TRUE, FALSE, NULL, | |
2221 _("OK"), G_CALLBACK(gaim_auth_dontgrant), | |
2222 _("Cancel"), G_CALLBACK(oscar_free_name_data), | |
2223 data); | |
2224 } | |
2225 | |
2226 /* When someone sends you buddies */ | |
2227 static void | |
2228 gaim_icq_buddyadd(struct name_data *data) | |
2229 { | |
2230 GaimConnection *gc = data->gc; | |
2231 | |
2232 gaim_blist_request_add_buddy(gaim_connection_get_account(gc), data->name, NULL, data->nick); | |
2233 | |
2234 oscar_free_name_data(data); | |
2235 } | |
2236 | |
2237 static int | |
2238 incomingim_chan4(OscarData *od, FlapConnection *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch4_args *args, time_t t) | |
2239 { | |
2240 GaimConnection *gc = od->gc; | |
2241 GaimAccount *account = gaim_connection_get_account(gc); | |
2242 gchar **msg1, **msg2; | |
2243 int i, numtoks; | |
2244 | |
2245 if (!args->type || !args->msg || !args->uin) | |
2246 return 1; | |
2247 | |
2248 gaim_debug_info("oscar", | |
2249 "Received a channel 4 message of type 0x%02hx.\n", | |
2250 args->type); | |
2251 | |
2252 /* | |
2253 * Split up the message at the delimeter character, then convert each | |
2254 * string to UTF-8. Unless, of course, this is a type 1 message. If | |
2255 * this is a type 1 message, then the delimiter 0xfe could be a valid | |
2256 * character in whatever encoding the message was sent in. Type 1 | |
2257 * messages are always made up of only one part, so we can easily account | |
2258 * for this suck-ass part of the protocol by splitting the string into at | |
2259 * most 1 baby string. | |
2260 */ | |
2261 msg1 = g_strsplit(args->msg, "\376", (args->type == 0x01 ? 1 : 0)); | |
2262 for (numtoks=0; msg1[numtoks]; numtoks++); | |
2263 msg2 = (gchar **)g_malloc((numtoks+1)*sizeof(gchar *)); | |
2264 for (i=0; msg1[i]; i++) { | |
2265 gaim_str_strip_char(msg1[i], '\r'); | |
14402 | 2266 /* TODO: Should use an encoding other than ASCII? */ |
14192 | 2267 msg2[i] = gaim_plugin_oscar_decode_im_part(account, "1", AIM_CHARSET_ASCII, 0x0000, msg1[i], strlen(msg1[i])); |
2268 } | |
2269 msg2[i] = NULL; | |
2270 | |
2271 switch (args->type) { | |
2272 case 0x01: { /* MacICQ message or basic offline message */ | |
2273 if (i >= 1) { | |
2274 gchar *uin = g_strdup_printf("%u", args->uin); | |
2275 gchar *tmp; | |
2276 | |
2277 /* If the message came from an ICQ user then escape any HTML */ | |
2278 tmp = g_markup_escape_text(msg2[0], -1); | |
2279 | |
2280 if (t) { /* This is an offline message */ | |
2281 /* The timestamp is UTC-ish, so we need to get the offset */ | |
2282 #ifdef HAVE_TM_GMTOFF | |
2283 time_t now; | |
2284 struct tm *tm; | |
2285 now = time(NULL); | |
2286 tm = localtime(&now); | |
2287 t += tm->tm_gmtoff; | |
2288 #else | |
2289 # ifdef HAVE_TIMEZONE | |
2290 tzset(); | |
2291 t -= timezone; | |
2292 # endif | |
2293 #endif | |
2294 serv_got_im(gc, uin, tmp, 0, t); | |
2295 } else { /* This is a message from MacICQ/Miranda */ | |
2296 serv_got_im(gc, uin, tmp, 0, time(NULL)); | |
2297 } | |
2298 g_free(uin); | |
2299 g_free(tmp); | |
2300 } | |
2301 } break; | |
2302 | |
2303 case 0x04: { /* Someone sent you a URL */ | |
2304 if (i >= 2) { | |
2305 if (msg2[1] != NULL) { | |
2306 gchar *uin = g_strdup_printf("%u", args->uin); | |
2307 gchar *message = g_strdup_printf("<A HREF=\"%s\">%s</A>", | |
2308 msg2[1], | |
2309 (msg2[0] && msg2[0][0]) ? msg2[0] : msg2[1]); | |
2310 serv_got_im(gc, uin, message, 0, time(NULL)); | |
2311 g_free(uin); | |
2312 g_free(message); | |
2313 } | |
2314 } | |
2315 } break; | |
2316 | |
2317 case 0x06: { /* Someone requested authorization */ | |
2318 if (i >= 6) { | |
2319 struct name_data *data = g_new(struct name_data, 1); | |
2320 gchar *sn = g_strdup_printf("%u", args->uin); | |
15060
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
2321 gchar *reason = NULL; |
14192 | 2322 |
2323 if (msg2[5] != NULL) | |
2324 reason = gaim_plugin_oscar_decode_im_part(account, sn, AIM_CHARSET_CUSTOM, 0x0000, msg2[5], strlen(msg2[5])); | |
15057 | 2325 |
14192 | 2326 gaim_debug_info("oscar", |
2327 "Received an authorization request from UIN %u\n", | |
2328 args->uin); | |
2329 data->gc = gc; | |
2330 data->name = sn; | |
2331 data->nick = NULL; | |
15060
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
2332 |
15080 | 2333 gaim_account_request_authorization(account, sn, |
2334 NULL, NULL, reason, G_CALLBACK(gaim_auth_grant), | |
2335 G_CALLBACK(gaim_auth_dontgrant_msgprompt), data); | |
15057 | 2336 g_free(reason); |
14192 | 2337 } |
2338 } break; | |
2339 | |
2340 case 0x07: { /* Someone has denied you authorization */ | |
2341 if (i >= 1) { | |
2342 gchar *dialog_msg = g_strdup_printf(_("The user %u has denied your request to add them to your buddy list for the following reason:\n%s"), args->uin, msg2[0] ? msg2[0] : _("No reason given.")); | |
2343 gaim_notify_info(gc, NULL, _("ICQ authorization denied."), | |
2344 dialog_msg); | |
2345 g_free(dialog_msg); | |
2346 } | |
2347 } break; | |
2348 | |
2349 case 0x08: { /* Someone has granted you authorization */ | |
2350 gchar *dialog_msg = g_strdup_printf(_("The user %u has granted your request to add them to your buddy list."), args->uin); | |
2351 gaim_notify_info(gc, NULL, "ICQ authorization accepted.", | |
2352 dialog_msg); | |
2353 g_free(dialog_msg); | |
2354 } break; | |
2355 | |
2356 case 0x09: { /* Message from the Godly ICQ server itself, I think */ | |
2357 if (i >= 5) { | |
2358 gchar *dialog_msg = g_strdup_printf(_("You have received a special message\n\nFrom: %s [%s]\n%s"), msg2[0], msg2[3], msg2[5]); | |
2359 gaim_notify_info(gc, NULL, "ICQ Server Message", dialog_msg); | |
2360 g_free(dialog_msg); | |
2361 } | |
2362 } break; | |
2363 | |
2364 case 0x0d: { /* Someone has sent you a pager message from http://www.icq.com/your_uin */ | |
2365 if (i >= 6) { | |
2366 gchar *dialog_msg = g_strdup_printf(_("You have received an ICQ page\n\nFrom: %s [%s]\n%s"), msg2[0], msg2[3], msg2[5]); | |
2367 gaim_notify_info(gc, NULL, "ICQ Page", dialog_msg); | |
2368 g_free(dialog_msg); | |
2369 } | |
2370 } break; | |
2371 | |
2372 case 0x0e: { /* Someone has emailed you at your_uin@pager.icq.com */ | |
2373 if (i >= 6) { | |
2374 gchar *dialog_msg = g_strdup_printf(_("You have received an ICQ e-mail from %s [%s]\n\nMessage is:\n%s"), msg2[0], msg2[3], msg2[5]); | |
2375 gaim_notify_info(gc, NULL, "ICQ E-Mail", dialog_msg); | |
2376 g_free(dialog_msg); | |
2377 } | |
2378 } break; | |
2379 | |
2380 case 0x12: { | |
2381 /* Ack for authorizing/denying someone. Or possibly an ack for sending any system notice */ | |
2382 /* Someone added you to their buddy list? */ | |
2383 } break; | |
2384 | |
2385 case 0x13: { /* Someone has sent you some ICQ buddies */ | |
2386 guint i, num; | |
2387 gchar **text; | |
2388 text = g_strsplit(args->msg, "\376", 0); | |
2389 if (text) { | |
2390 num = 0; | |
2391 for (i=0; i<strlen(text[0]); i++) | |
2392 num = num*10 + text[0][i]-48; | |
2393 for (i=0; i<num; i++) { | |
2394 struct name_data *data = g_new(struct name_data, 1); | |
2395 gchar *message = g_strdup_printf(_("ICQ user %u has sent you a buddy: %s (%s)"), args->uin, text[i*2+2], text[i*2+1]); | |
2396 data->gc = gc; | |
2397 data->name = g_strdup(text[i*2+1]); | |
2398 data->nick = g_strdup(text[i*2+2]); | |
2399 | |
2400 gaim_request_action(gc, NULL, message, | |
2401 _("Do you want to add this buddy " | |
2402 "to your buddy list?"), | |
2403 GAIM_DEFAULT_ACTION_NONE, data, 2, | |
2404 _("Add"), G_CALLBACK(gaim_icq_buddyadd), | |
2405 _("_Decline"), G_CALLBACK(oscar_free_name_data)); | |
2406 g_free(message); | |
2407 } | |
2408 g_strfreev(text); | |
2409 } | |
2410 } break; | |
2411 | |
2412 case 0x1a: { /* Someone has sent you a greeting card or requested buddies? */ | |
2413 /* This is boring and silly. */ | |
2414 } break; | |
2415 | |
2416 default: { | |
2417 gaim_debug_info("oscar", | |
2418 "Received a channel 4 message of unknown type " | |
2419 "(type 0x%02hhx).\n", args->type); | |
2420 } break; | |
2421 } | |
2422 | |
2423 g_strfreev(msg1); | |
2424 g_strfreev(msg2); | |
2425 | |
2426 return 1; | |
2427 } | |
2428 | |
2429 static int gaim_parse_incoming_im(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2430 guint16 channel; | |
2431 int ret = 0; | |
2432 aim_userinfo_t *userinfo; | |
2433 va_list ap; | |
2434 | |
2435 va_start(ap, fr); | |
2436 channel = (guint16)va_arg(ap, unsigned int); | |
2437 userinfo = va_arg(ap, aim_userinfo_t *); | |
2438 | |
2439 switch (channel) { | |
2440 case 1: { /* standard message */ | |
2441 struct aim_incomingim_ch1_args *args; | |
2442 args = va_arg(ap, struct aim_incomingim_ch1_args *); | |
2443 ret = incomingim_chan1(od, conn, userinfo, args); | |
2444 } break; | |
2445 | |
2446 case 2: { /* rendezvous */ | |
2447 IcbmArgsCh2 *args; | |
2448 args = va_arg(ap, IcbmArgsCh2 *); | |
2449 ret = incomingim_chan2(od, conn, userinfo, args); | |
2450 } break; | |
2451 | |
2452 case 4: { /* ICQ */ | |
2453 struct aim_incomingim_ch4_args *args; | |
2454 args = va_arg(ap, struct aim_incomingim_ch4_args *); | |
2455 ret = incomingim_chan4(od, conn, userinfo, args, 0); | |
2456 } break; | |
2457 | |
2458 default: { | |
2459 gaim_debug_warning("oscar", | |
2460 "ICBM received on unsupported channel (channel " | |
2461 "0x%04hx).", channel); | |
2462 } break; | |
2463 } | |
2464 | |
2465 va_end(ap); | |
2466 | |
2467 return ret; | |
2468 } | |
2469 | |
2470 static int gaim_parse_misses(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2471 GaimConnection *gc = od->gc; | |
2472 GaimAccount *account = gaim_connection_get_account(gc); | |
2473 char *buf; | |
2474 va_list ap; | |
2475 guint16 chan, nummissed, reason; | |
2476 aim_userinfo_t *userinfo; | |
2477 | |
2478 va_start(ap, fr); | |
2479 chan = (guint16)va_arg(ap, unsigned int); | |
2480 userinfo = va_arg(ap, aim_userinfo_t *); | |
2481 nummissed = (guint16)va_arg(ap, unsigned int); | |
2482 reason = (guint16)va_arg(ap, unsigned int); | |
2483 va_end(ap); | |
2484 | |
2485 switch(reason) { | |
2486 case 0: /* Invalid (0) */ | |
2487 buf = g_strdup_printf( | |
2488 ngettext( | |
2489 "You missed %hu message from %s because it was invalid.", | |
2490 "You missed %hu messages from %s because they were invalid.", | |
2491 nummissed), | |
2492 nummissed, | |
2493 userinfo->sn); | |
2494 break; | |
2495 case 1: /* Message too large */ | |
2496 buf = g_strdup_printf( | |
2497 ngettext( | |
2498 "You missed %hu message from %s because it was too large.", | |
2499 "You missed %hu messages from %s because they were too large.", | |
2500 nummissed), | |
2501 nummissed, | |
2502 userinfo->sn); | |
2503 break; | |
2504 case 2: /* Rate exceeded */ | |
2505 buf = g_strdup_printf( | |
2506 ngettext( | |
2507 "You missed %hu message from %s because the rate limit has been exceeded.", | |
2508 "You missed %hu messages from %s because the rate limit has been exceeded.", | |
2509 nummissed), | |
2510 nummissed, | |
2511 userinfo->sn); | |
2512 break; | |
2513 case 3: /* Evil Sender */ | |
2514 buf = g_strdup_printf( | |
2515 ngettext( | |
2516 "You missed %hu message from %s because he/she was too evil.", | |
2517 "You missed %hu messages from %s because he/she was too evil.", | |
2518 nummissed), | |
2519 nummissed, | |
2520 userinfo->sn); | |
2521 break; | |
2522 case 4: /* Evil Receiver */ | |
2523 buf = g_strdup_printf( | |
2524 ngettext( | |
2525 "You missed %hu message from %s because you are too evil.", | |
2526 "You missed %hu messages from %s because you are too evil.", | |
2527 nummissed), | |
2528 nummissed, | |
2529 userinfo->sn); | |
2530 break; | |
2531 default: | |
2532 buf = g_strdup_printf( | |
2533 ngettext( | |
2534 "You missed %hu message from %s for an unknown reason.", | |
2535 "You missed %hu messages from %s for an unknown reason.", | |
2536 nummissed), | |
2537 nummissed, | |
2538 userinfo->sn); | |
2539 break; | |
2540 } | |
2541 | |
2542 if (!gaim_conv_present_error(userinfo->sn, account, buf)) | |
2543 gaim_notify_error(od->gc, NULL, buf, NULL); | |
2544 g_free(buf); | |
2545 | |
2546 return 1; | |
2547 } | |
2548 | |
2549 static int | |
2550 gaim_parse_clientauto_ch2(OscarData *od, const char *who, guint16 reason, const guchar *cookie) | |
2551 { | |
2552 if (reason == 0x0003) | |
2553 { | |
2554 /* Rendezvous was refused. */ | |
2555 PeerConnection *conn; | |
2556 | |
2557 conn = peer_connection_find_by_cookie(od, who, cookie); | |
2558 | |
2559 if (conn == NULL) | |
2560 { | |
2561 gaim_debug_info("oscar", "Received a rendezvous cancel message " | |
2562 "for a nonexistant connection from %s.\n", who); | |
2563 } | |
2564 else | |
2565 { | |
14402 | 2566 peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_REFUSED, NULL); |
14192 | 2567 } |
2568 } | |
2569 else | |
2570 { | |
2571 gaim_debug_warning("oscar", "Received an unknown rendezvous " | |
2572 "message from %s. Type 0x%04hx\n", who, reason); | |
2573 } | |
2574 | |
2575 return 0; | |
2576 } | |
2577 | |
2578 static int gaim_parse_clientauto_ch4(OscarData *od, char *who, guint16 reason, guint32 state, char *msg) { | |
2579 GaimConnection *gc = od->gc; | |
2580 | |
2581 switch(reason) { | |
2582 case 0x0003: { /* Reply from an ICQ status message request */ | |
2583 char *title, *statusmsg, **splitmsg, *dialogmsg; | |
2584 | |
2585 title = g_strdup_printf(_("Info for %s"), who); | |
2586 | |
2587 /* Split at (carriage return/newline)'s, then rejoin later with BRs between. */ | |
2588 statusmsg = oscar_icqstatus(state); | |
2589 splitmsg = g_strsplit(msg, "\r\n", 0); | |
2590 dialogmsg = g_strdup_printf(_("<B>UIN:</B> %s<BR><B>Status:</B> %s<HR>%s"), who, statusmsg, g_strjoinv("<BR>", splitmsg)); | |
2591 g_free(statusmsg); | |
2592 g_strfreev(splitmsg); | |
2593 | |
2594 gaim_notify_userinfo(gc, who, dialogmsg, NULL, NULL); | |
2595 | |
2596 g_free(title); | |
2597 g_free(dialogmsg); | |
2598 } break; | |
2599 | |
2600 default: { | |
2601 gaim_debug_warning("oscar", | |
2602 "Received an unknown client auto-response from %s. " | |
2603 "Type 0x%04hx\n", who, reason); | |
2604 } break; | |
2605 } /* end of switch */ | |
2606 | |
2607 return 0; | |
2608 } | |
2609 | |
2610 static int gaim_parse_clientauto(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2611 va_list ap; | |
2612 guint16 chan, reason; | |
2613 char *who; | |
2614 | |
2615 va_start(ap, fr); | |
2616 chan = (guint16)va_arg(ap, unsigned int); | |
2617 who = va_arg(ap, char *); | |
2618 reason = (guint16)va_arg(ap, unsigned int); | |
2619 | |
2620 if (chan == 0x0002) { /* File transfer declined */ | |
2621 guchar *cookie = va_arg(ap, guchar *); | |
2622 return gaim_parse_clientauto_ch2(od, who, reason, cookie); | |
2623 } else if (chan == 0x0004) { /* ICQ message */ | |
2624 guint32 state = 0; | |
2625 char *msg = NULL; | |
2626 if (reason == 0x0003) { | |
2627 state = va_arg(ap, guint32); | |
2628 msg = va_arg(ap, char *); | |
2629 } | |
2630 return gaim_parse_clientauto_ch4(od, who, reason, state, msg); | |
2631 } | |
2632 | |
2633 va_end(ap); | |
2634 | |
2635 return 1; | |
2636 } | |
2637 | |
2638 static int gaim_parse_genericerr(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2639 va_list ap; | |
2640 guint16 reason; | |
2641 char *m; | |
2642 | |
2643 va_start(ap, fr); | |
2644 reason = (guint16) va_arg(ap, unsigned int); | |
2645 va_end(ap); | |
2646 | |
2647 gaim_debug_error("oscar", | |
2648 "snac threw error (reason 0x%04hx: %s)\n", reason, | |
2649 (reason < msgerrreasonlen) ? msgerrreason[reason] : "unknown"); | |
2650 | |
2651 m = g_strdup_printf(_("SNAC threw error: %s\n"), | |
2652 reason < msgerrreasonlen ? _(msgerrreason[reason]) : _("Unknown error")); | |
2653 gaim_notify_error(od->gc, NULL, m, NULL); | |
2654 g_free(m); | |
2655 | |
2656 return 1; | |
2657 } | |
2658 | |
2659 static int gaim_parse_msgerr(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2660 GaimConnection *gc = od->gc; | |
2661 #ifdef TODOFT | |
2662 OscarData *od = gc->proto_data; | |
2663 GaimXfer *xfer; | |
2664 #endif | |
2665 va_list ap; | |
2666 guint16 reason; | |
2667 char *data, *buf; | |
2668 | |
2669 va_start(ap, fr); | |
2670 reason = (guint16)va_arg(ap, unsigned int); | |
2671 data = va_arg(ap, char *); | |
2672 va_end(ap); | |
2673 | |
2674 gaim_debug_error("oscar", | |
2675 "Message error with data %s and reason %hu\n", | |
2676 (data != NULL ? data : ""), reason); | |
2677 | |
2678 #ifdef TODOFT | |
2679 /* If this was a file transfer request, data is a cookie */ | |
2680 if ((xfer = oscar_find_xfer_by_cookie(od->file_transfers, data))) { | |
2681 gaim_xfer_cancel_remote(xfer); | |
2682 return 1; | |
2683 } | |
2684 #endif | |
2685 | |
2686 /* Data is assumed to be the destination sn */ | |
2687 buf = g_strdup_printf(_("Unable to send message: %s"), (reason < msgerrreasonlen) ? msgerrreason[reason] : _("Unknown reason.")); | |
2688 if (!gaim_conv_present_error(data, gaim_connection_get_account(gc), buf)) { | |
2689 g_free(buf); | |
2690 buf = g_strdup_printf(_("Unable to send message to %s:"), data ? data : "(unknown)"); | |
2691 gaim_notify_error(od->gc, NULL, buf, | |
2692 (reason < msgerrreasonlen) ? _(msgerrreason[reason]) : _("Unknown reason.")); | |
2693 } | |
2694 g_free(buf); | |
2695 | |
2696 return 1; | |
2697 } | |
2698 | |
2699 static int gaim_parse_mtn(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2700 GaimConnection *gc = od->gc; | |
2701 va_list ap; | |
2702 guint16 type1, type2; | |
2703 char *sn; | |
2704 | |
2705 va_start(ap, fr); | |
2706 type1 = (guint16) va_arg(ap, unsigned int); | |
2707 sn = va_arg(ap, char *); | |
2708 type2 = (guint16) va_arg(ap, unsigned int); | |
2709 va_end(ap); | |
2710 | |
2711 switch (type2) { | |
2712 case 0x0000: { /* Text has been cleared */ | |
2713 serv_got_typing_stopped(gc, sn); | |
2714 } break; | |
2715 | |
2716 case 0x0001: { /* Paused typing */ | |
2717 serv_got_typing(gc, sn, 0, GAIM_TYPED); | |
2718 } break; | |
2719 | |
2720 case 0x0002: { /* Typing */ | |
2721 serv_got_typing(gc, sn, 0, GAIM_TYPING); | |
2722 } break; | |
2723 | |
2724 default: { | |
2725 /* | |
2726 * It looks like iChat sometimes sends typing notification | |
2727 * with type1=0x0001 and type2=0x000f. Not sure why. | |
2728 */ | |
2729 gaim_debug_info("oscar", "Received unknown typing notification message from %s. Type1 is 0x%04x and type2 is 0x%04hx.\n", sn, type1, type2); | |
2730 } break; | |
2731 } | |
2732 | |
2733 return 1; | |
2734 } | |
2735 | |
2736 /* | |
2737 * We get this error when there was an error in the locate family. This | |
2738 * happens when you request info of someone who is offline. | |
2739 */ | |
2740 static int gaim_parse_locerr(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2741 gchar *buf; | |
2742 va_list ap; | |
2743 guint16 reason; | |
2744 char *destn; | |
2745 | |
2746 va_start(ap, fr); | |
2747 reason = (guint16) va_arg(ap, unsigned int); | |
2748 destn = va_arg(ap, char *); | |
2749 va_end(ap); | |
2750 | |
2751 if (destn == NULL) | |
2752 return 1; | |
2753 | |
2754 buf = g_strdup_printf(_("User information not available: %s"), (reason < msgerrreasonlen) ? _(msgerrreason[reason]) : _("Unknown reason.")); | |
2755 if (!gaim_conv_present_error(destn, gaim_connection_get_account((GaimConnection*)od->gc), buf)) { | |
2756 g_free(buf); | |
2757 buf = g_strdup_printf(_("User information for %s unavailable:"), destn); | |
2758 gaim_notify_error(od->gc, NULL, buf, (reason < msgerrreasonlen) ? _(msgerrreason[reason]) : _("Unknown reason.")); | |
2759 } | |
2760 g_free(buf); | |
2761 | |
2762 return 1; | |
2763 } | |
2764 | |
2765 static int gaim_parse_userinfo(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2766 GaimConnection *gc = od->gc; | |
2767 GaimAccount *account = gaim_connection_get_account(gc); | |
2768 GString *str; | |
2769 gchar *tmp = NULL, *info_utf8 = NULL, *away_utf8 = NULL; | |
2770 va_list ap; | |
2771 aim_userinfo_t *userinfo; | |
2772 | |
2773 va_start(ap, fr); | |
2774 userinfo = va_arg(ap, aim_userinfo_t *); | |
2775 va_end(ap); | |
2776 | |
2777 str = g_string_new(""); | |
2778 g_string_append_printf(str, "<b>%s:</b> %s", _("Screen Name"), userinfo->sn); | |
2779 g_string_append_printf(str, "\n<br><b>%s</b>: %d%%", _("Warning Level"), (int)((userinfo->warnlevel/10.0) + 0.5)); | |
2780 | |
2781 if (userinfo->present & AIM_USERINFO_PRESENT_ONLINESINCE) { | |
2782 time_t t = userinfo->onlinesince - od->timeoffset; | |
2783 oscar_string_append(str, "\n<br>", _("Online Since"), gaim_date_format_full(localtime(&t))); | |
2784 } | |
2785 | |
2786 if (userinfo->present & AIM_USERINFO_PRESENT_MEMBERSINCE) { | |
2787 time_t t = userinfo->membersince - od->timeoffset; | |
2788 oscar_string_append(str, "\n<br>", _("Member Since"), gaim_date_format_full(localtime(&t))); | |
2789 } | |
2790 | |
2791 if (userinfo->capabilities != 0) { | |
2792 tmp = oscar_caps_to_string(userinfo->capabilities); | |
2793 oscar_string_append(str, "\n<br>", _("Capabilities"), tmp); | |
2794 g_free(tmp); | |
2795 } | |
2796 | |
2797 if (userinfo->present & AIM_USERINFO_PRESENT_IDLE) { | |
2798 tmp = gaim_str_seconds_to_string(userinfo->idletime*60); | |
2799 oscar_string_append(str, "\n<br>", _("Idle"), tmp); | |
2800 g_free(tmp); | |
2801 } | |
2802 | |
2803 oscar_string_append_info(gc, str, "\n<br>", NULL, userinfo); | |
2804 | |
2805 /* Available message */ | |
2806 if ((userinfo->status != NULL) && !(userinfo->flags & AIM_FLAG_AWAY)) | |
2807 { | |
2808 if (userinfo->status[0] != '\0') | |
2809 tmp = oscar_encoding_to_utf8(userinfo->status_encoding, | |
2810 userinfo->status, userinfo->status_len); | |
2811 oscar_string_convert_and_append(account, str, "\n<br>", _("Available Message"), tmp); | |
2812 g_free(tmp); | |
2813 } | |
2814 | |
2815 /* Away message */ | |
2816 if ((userinfo->flags & AIM_FLAG_AWAY) && (userinfo->away_len > 0) && (userinfo->away != NULL) && (userinfo->away_encoding != NULL)) { | |
2817 tmp = oscar_encoding_extract(userinfo->away_encoding); | |
2818 away_utf8 = oscar_encoding_to_utf8(tmp, userinfo->away, userinfo->away_len); | |
2819 g_free(tmp); | |
2820 if (away_utf8 != NULL) { | |
2821 g_string_append_printf(str, "\n<hr>%s", away_utf8); | |
2822 g_free(away_utf8); | |
2823 } | |
2824 } | |
2825 | |
2826 /* Info */ | |
2827 if ((userinfo->info_len > 0) && (userinfo->info != NULL) && (userinfo->info_encoding != NULL)) { | |
2828 tmp = oscar_encoding_extract(userinfo->info_encoding); | |
2829 info_utf8 = oscar_encoding_to_utf8(tmp, userinfo->info, userinfo->info_len); | |
2830 g_free(tmp); | |
2831 if (info_utf8 != NULL) { | |
2832 g_string_append_printf(str, "\n<hr>%s", info_utf8); | |
2833 g_free(info_utf8); | |
2834 } | |
2835 } | |
2836 | |
2837 tmp = gaim_str_sub_away_formatters(str->str, gaim_account_get_username(account)); | |
2838 g_string_free(str, TRUE); | |
2839 gaim_str_strip_char(tmp, '\r'); | |
2840 gaim_notify_userinfo(gc, userinfo->sn, tmp, NULL, NULL); | |
2841 g_free(tmp); | |
2842 | |
2843 return 1; | |
2844 } | |
2845 | |
2846 static int gaim_got_infoblock(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
2847 { | |
2848 GaimConnection *gc = od->gc; | |
2849 GaimBuddy *b; | |
2850 GaimPresence *presence; | |
2851 GaimStatus *status; | |
2852 gchar *message = NULL; | |
2853 | |
2854 va_list ap; | |
2855 aim_userinfo_t *userinfo; | |
2856 | |
2857 va_start(ap, fr); | |
2858 userinfo = va_arg(ap, aim_userinfo_t *); | |
2859 va_end(ap); | |
2860 | |
2861 b = gaim_find_buddy(gaim_connection_get_account(gc), userinfo->sn); | |
2862 if (b == NULL) | |
2863 return 1; | |
2864 | |
2865 if (!aim_sn_is_icq(userinfo->sn)) | |
2866 { | |
2867 if (strcmp(gaim_buddy_get_name(b), userinfo->sn)) | |
2868 serv_got_alias(gc, gaim_buddy_get_name(b), userinfo->sn); | |
2869 else | |
2870 serv_got_alias(gc, gaim_buddy_get_name(b), NULL); | |
2871 } | |
2872 | |
2873 presence = gaim_buddy_get_presence(b); | |
2874 status = gaim_presence_get_active_status(presence); | |
2875 | |
2876 if (!gaim_status_is_available(status) && gaim_status_is_online(status)) | |
2877 { | |
2878 if ((userinfo->flags & AIM_FLAG_AWAY) && | |
2879 (userinfo->away_len > 0) && (userinfo->away != NULL) && (userinfo->away_encoding != NULL)) { | |
2880 gchar *charset = oscar_encoding_extract(userinfo->away_encoding); | |
2881 message = oscar_encoding_to_utf8(charset, userinfo->away, userinfo->away_len); | |
2882 g_free(charset); | |
2883 gaim_status_set_attr_string(status, "message", message); | |
2884 g_free(message); | |
2885 } | |
2886 else | |
2887 /* Set an empty message so that we know not to show "pending" */ | |
2888 gaim_status_set_attr_string(status, "message", ""); | |
2889 | |
2890 gaim_blist_update_buddy_status(b, status); | |
2891 } | |
2892 | |
2893 return 1; | |
2894 } | |
2895 | |
2896 static int gaim_parse_motd(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
2897 { | |
2898 char *msg; | |
2899 guint16 id; | |
2900 va_list ap; | |
2901 | |
2902 va_start(ap, fr); | |
2903 id = (guint16) va_arg(ap, unsigned int); | |
2904 msg = va_arg(ap, char *); | |
2905 va_end(ap); | |
2906 | |
2907 gaim_debug_misc("oscar", | |
2908 "MOTD: %s (%hu)\n", msg ? msg : "Unknown", id); | |
2909 if (id < 4) | |
2910 gaim_notify_warning(od->gc, NULL, | |
2911 _("Your AIM connection may be lost."), NULL); | |
2912 | |
2913 return 1; | |
2914 } | |
2915 | |
2916 static int gaim_chatnav_info(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2917 va_list ap; | |
2918 guint16 type; | |
2919 | |
2920 va_start(ap, fr); | |
2921 type = (guint16) va_arg(ap, unsigned int); | |
2922 | |
2923 switch(type) { | |
2924 case 0x0002: { | |
2925 guint8 maxrooms; | |
2926 struct aim_chat_exchangeinfo *exchanges; | |
2927 int exchangecount, i; | |
2928 | |
2929 maxrooms = (guint8) va_arg(ap, unsigned int); | |
2930 exchangecount = va_arg(ap, int); | |
2931 exchanges = va_arg(ap, struct aim_chat_exchangeinfo *); | |
2932 | |
2933 gaim_debug_misc("oscar", "chat info: Chat Rights:\n"); | |
2934 gaim_debug_misc("oscar", | |
2935 "chat info: \tMax Concurrent Rooms: %hhd\n", maxrooms); | |
2936 gaim_debug_misc("oscar", | |
2937 "chat info: \tExchange List: (%d total)\n", exchangecount); | |
2938 for (i = 0; i < exchangecount; i++) | |
2939 gaim_debug_misc("oscar", | |
2940 "chat info: \t\t%hu %s\n", | |
2941 exchanges[i].number, exchanges[i].name ? exchanges[i].name : ""); | |
2942 while (od->create_rooms) { | |
2943 struct create_room *cr = od->create_rooms->data; | |
2944 gaim_debug_info("oscar", | |
2945 "creating room %s\n", cr->name); | |
2946 aim_chatnav_createroom(od, conn, cr->name, cr->exchange); | |
2947 g_free(cr->name); | |
2948 od->create_rooms = g_slist_remove(od->create_rooms, cr); | |
2949 g_free(cr); | |
2950 } | |
2951 } | |
2952 break; | |
2953 case 0x0008: { | |
2954 char *fqcn, *name, *ck; | |
2955 guint16 instance, flags, maxmsglen, maxoccupancy, unknown, exchange; | |
2956 guint8 createperms; | |
2957 guint32 createtime; | |
2958 | |
2959 fqcn = va_arg(ap, char *); | |
2960 instance = (guint16)va_arg(ap, unsigned int); | |
2961 exchange = (guint16)va_arg(ap, unsigned int); | |
2962 flags = (guint16)va_arg(ap, unsigned int); | |
2963 createtime = va_arg(ap, guint32); | |
2964 maxmsglen = (guint16)va_arg(ap, unsigned int); | |
2965 maxoccupancy = (guint16)va_arg(ap, unsigned int); | |
2966 createperms = (guint8)va_arg(ap, unsigned int); | |
2967 unknown = (guint16)va_arg(ap, unsigned int); | |
2968 name = va_arg(ap, char *); | |
2969 ck = va_arg(ap, char *); | |
2970 | |
2971 gaim_debug_misc("oscar", | |
2972 "created room: %s %hu %hu %hu %u %hu %hu %hhu %hu %s %s\n", | |
2973 fqcn, exchange, instance, flags, createtime, | |
2974 maxmsglen, maxoccupancy, createperms, unknown, | |
2975 name, ck); | |
2976 aim_chat_join(od, exchange, ck, instance); | |
2977 } | |
2978 break; | |
2979 default: | |
2980 gaim_debug_warning("oscar", | |
2981 "chatnav info: unknown type (%04hx)\n", type); | |
2982 break; | |
2983 } | |
2984 | |
2985 va_end(ap); | |
2986 | |
2987 return 1; | |
2988 } | |
2989 | |
2990 static int gaim_conv_chat_join(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
2991 va_list ap; | |
2992 int count, i; | |
2993 aim_userinfo_t *info; | |
2994 GaimConnection *gc = od->gc; | |
2995 | |
2996 struct chat_connection *c = NULL; | |
2997 | |
2998 va_start(ap, fr); | |
2999 count = va_arg(ap, int); | |
3000 info = va_arg(ap, aim_userinfo_t *); | |
3001 va_end(ap); | |
3002 | |
3003 c = find_oscar_chat_by_conn(gc, conn); | |
3004 if (!c) | |
3005 return 1; | |
3006 | |
3007 for (i = 0; i < count; i++) | |
3008 gaim_conv_chat_add_user(GAIM_CONV_CHAT(c->conv), info[i].sn, NULL, GAIM_CBFLAGS_NONE, TRUE); | |
3009 | |
3010 return 1; | |
3011 } | |
3012 | |
3013 static int gaim_conv_chat_leave(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3014 va_list ap; | |
3015 int count, i; | |
3016 aim_userinfo_t *info; | |
3017 GaimConnection *gc = od->gc; | |
3018 | |
3019 struct chat_connection *c = NULL; | |
3020 | |
3021 va_start(ap, fr); | |
3022 count = va_arg(ap, int); | |
3023 info = va_arg(ap, aim_userinfo_t *); | |
3024 va_end(ap); | |
3025 | |
3026 c = find_oscar_chat_by_conn(gc, conn); | |
3027 if (!c) | |
3028 return 1; | |
3029 | |
3030 for (i = 0; i < count; i++) | |
3031 gaim_conv_chat_remove_user(GAIM_CONV_CHAT(c->conv), info[i].sn, NULL); | |
3032 | |
3033 return 1; | |
3034 } | |
3035 | |
3036 static int gaim_conv_chat_info_update(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3037 va_list ap; | |
3038 aim_userinfo_t *userinfo; | |
3039 struct aim_chat_roominfo *roominfo; | |
3040 char *roomname; | |
3041 int usercount; | |
3042 char *roomdesc; | |
3043 guint16 unknown_c9, unknown_d2, unknown_d5, maxmsglen, maxvisiblemsglen; | |
3044 guint32 creationtime; | |
3045 GaimConnection *gc = od->gc; | |
3046 struct chat_connection *ccon = find_oscar_chat_by_conn(gc, conn); | |
3047 | |
3048 va_start(ap, fr); | |
3049 roominfo = va_arg(ap, struct aim_chat_roominfo *); | |
3050 roomname = va_arg(ap, char *); | |
3051 usercount= va_arg(ap, int); | |
3052 userinfo = va_arg(ap, aim_userinfo_t *); | |
3053 roomdesc = va_arg(ap, char *); | |
3054 unknown_c9 = (guint16)va_arg(ap, unsigned int); | |
3055 creationtime = va_arg(ap, guint32); | |
3056 maxmsglen = (guint16)va_arg(ap, unsigned int); | |
3057 unknown_d2 = (guint16)va_arg(ap, unsigned int); | |
3058 unknown_d5 = (guint16)va_arg(ap, unsigned int); | |
3059 maxvisiblemsglen = (guint16)va_arg(ap, unsigned int); | |
3060 va_end(ap); | |
3061 | |
3062 gaim_debug_misc("oscar", | |
3063 "inside chat_info_update (maxmsglen = %hu, maxvislen = %hu)\n", | |
3064 maxmsglen, maxvisiblemsglen); | |
3065 | |
3066 ccon->maxlen = maxmsglen; | |
3067 ccon->maxvis = maxvisiblemsglen; | |
3068 | |
3069 return 1; | |
3070 } | |
3071 | |
3072 static int gaim_conv_chat_incoming_msg(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3073 GaimConnection *gc = od->gc; | |
3074 struct chat_connection *ccon = find_oscar_chat_by_conn(gc, conn); | |
3075 gchar *utf8; | |
3076 va_list ap; | |
3077 aim_userinfo_t *info; | |
3078 int len; | |
3079 char *msg; | |
3080 char *charset; | |
3081 | |
3082 va_start(ap, fr); | |
3083 info = va_arg(ap, aim_userinfo_t *); | |
3084 len = va_arg(ap, int); | |
3085 msg = va_arg(ap, char *); | |
3086 charset = va_arg(ap, char *); | |
3087 va_end(ap); | |
3088 | |
3089 utf8 = oscar_encoding_to_utf8(charset, msg, len); | |
3090 if (utf8 == NULL) | |
3091 /* The conversion failed! */ | |
3092 utf8 = g_strdup(_("[Unable to display a message from this user because it contained invalid characters.]")); | |
3093 serv_got_chat_in(gc, ccon->id, info->sn, 0, utf8, time((time_t)NULL)); | |
3094 g_free(utf8); | |
3095 | |
3096 return 1; | |
3097 } | |
3098 | |
3099 static int gaim_email_parseupdate(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3100 va_list ap; | |
3101 GaimConnection *gc = od->gc; | |
3102 struct aim_emailinfo *emailinfo; | |
3103 int havenewmail; | |
3104 char *alertitle, *alerturl; | |
3105 | |
3106 va_start(ap, fr); | |
3107 emailinfo = va_arg(ap, struct aim_emailinfo *); | |
3108 havenewmail = va_arg(ap, int); | |
3109 alertitle = va_arg(ap, char *); | |
3110 alerturl = va_arg(ap, char *); | |
3111 va_end(ap); | |
3112 | |
3113 if ((emailinfo != NULL) && gaim_account_get_check_mail(gc->account)) { | |
3114 gchar *to = g_strdup_printf("%s%s%s", gaim_account_get_username(gaim_connection_get_account(gc)), | |
3115 emailinfo->domain ? "@" : "", | |
3116 emailinfo->domain ? emailinfo->domain : ""); | |
3117 if (emailinfo->unread && havenewmail) | |
3118 gaim_notify_emails(gc, emailinfo->nummsgs, FALSE, NULL, NULL, (const char **)&to, (const char **)&emailinfo->url, NULL, NULL); | |
3119 g_free(to); | |
3120 } | |
3121 | |
3122 if (alertitle) | |
3123 gaim_debug_misc("oscar", "Got an alert '%s' %s\n", alertitle, alerturl ? alerturl : ""); | |
3124 | |
3125 return 1; | |
3126 } | |
3127 | |
3128 static int gaim_icon_error(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3129 GaimConnection *gc = od->gc; | |
3130 char *sn; | |
3131 | |
3132 sn = od->requesticon->data; | |
3133 gaim_debug_misc("oscar", "removing %s from hash table\n", sn); | |
3134 od->requesticon = g_slist_remove(od->requesticon, sn); | |
3135 g_free(sn); | |
3136 | |
3137 if (od->icontimer == 0) | |
3138 od->icontimer = gaim_timeout_add(500, gaim_icon_timerfunc, gc); | |
3139 | |
3140 return 1; | |
3141 } | |
3142 | |
3143 static int gaim_icon_parseicon(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3144 GaimConnection *gc = od->gc; | |
3145 GSList *cur; | |
3146 va_list ap; | |
3147 char *sn; | |
3148 guint8 iconcsumtype, *iconcsum, *icon; | |
3149 guint16 iconcsumlen, iconlen; | |
3150 | |
3151 va_start(ap, fr); | |
3152 sn = va_arg(ap, char *); | |
3153 iconcsumtype = va_arg(ap, int); | |
3154 iconcsum = va_arg(ap, guint8 *); | |
3155 iconcsumlen = va_arg(ap, int); | |
3156 icon = va_arg(ap, guint8 *); | |
3157 iconlen = va_arg(ap, int); | |
3158 va_end(ap); | |
3159 | |
3160 /* | |
3161 * Some AIM clients will send a blank GIF image with iconlen 90 when | |
3162 * no icon is set. Ignore these. | |
3163 */ | |
3164 if ((iconlen > 0) && (iconlen != 90)) { | |
3165 char *b16; | |
3166 GaimBuddy *b; | |
3167 gaim_buddy_icons_set_for_user(gaim_connection_get_account(gc), | |
3168 sn, icon, iconlen); | |
3169 b16 = gaim_base16_encode(iconcsum, iconcsumlen); | |
3170 b = gaim_find_buddy(gc->account, sn); | |
3171 if ((b16 != NULL) && (b != NULL)) { | |
3172 gaim_blist_node_set_string((GaimBlistNode*)b, "icon_checksum", b16); | |
3173 g_free(b16); | |
3174 } | |
3175 } | |
3176 | |
3177 cur = od->requesticon; | |
3178 while (cur) { | |
3179 char *cursn = cur->data; | |
3180 if (!aim_sncmp(cursn, sn)) { | |
3181 od->requesticon = g_slist_remove(od->requesticon, cursn); | |
3182 g_free(cursn); | |
3183 cur = od->requesticon; | |
3184 } else | |
3185 cur = cur->next; | |
3186 } | |
3187 | |
3188 if (od->icontimer == 0) | |
3189 od->icontimer = gaim_timeout_add(250, gaim_icon_timerfunc, gc); | |
3190 | |
3191 return 1; | |
3192 } | |
3193 | |
3194 static gboolean gaim_icon_timerfunc(gpointer data) { | |
3195 GaimConnection *gc = data; | |
3196 OscarData *od = gc->proto_data; | |
3197 aim_userinfo_t *userinfo; | |
3198 FlapConnection *conn; | |
3199 | |
3200 od->icontimer = 0; | |
3201 | |
3202 conn = flap_connection_getbytype(od, SNAC_FAMILY_BART); | |
3203 if (!conn) { | |
3204 if (!od->iconconnecting) { | |
15085 | 3205 aim_srv_requestnew(od, SNAC_FAMILY_BART); |
14192 | 3206 od->iconconnecting = TRUE; |
3207 } | |
3208 return FALSE; | |
3209 } | |
3210 | |
3211 if (od->set_icon) { | |
3212 struct stat st; | |
3213 char *iconfile = gaim_buddy_icons_get_full_path(gaim_account_get_buddy_icon(gaim_connection_get_account(gc))); | |
3214 if (iconfile == NULL) { | |
3215 aim_ssi_delicon(od); | |
3216 } else if (!g_stat(iconfile, &st)) { | |
3217 guchar *buf = g_malloc(st.st_size); | |
3218 FILE *file = g_fopen(iconfile, "rb"); | |
3219 if (file) { | |
3220 /* XXX - Use g_file_get_contents()? */ | |
3221 fread(buf, 1, st.st_size, file); | |
3222 fclose(file); | |
3223 gaim_debug_info("oscar", | |
3224 "Uploading icon to icon server\n"); | |
3225 aim_bart_upload(od, buf, st.st_size); | |
3226 } else | |
3227 gaim_debug_error("oscar", | |
3228 "Can't open buddy icon file!\n"); | |
3229 g_free(buf); | |
3230 } else { | |
3231 gaim_debug_error("oscar", | |
3232 "Can't stat buddy icon file!\n"); | |
3233 } | |
3234 g_free(iconfile); | |
3235 od->set_icon = FALSE; | |
3236 } | |
3237 | |
3238 if (!od->requesticon) { | |
3239 gaim_debug_misc("oscar", | |
3240 "no more icons to request\n"); | |
3241 return FALSE; | |
3242 } | |
3243 | |
3244 userinfo = aim_locate_finduserinfo(od, (char *)od->requesticon->data); | |
3245 if ((userinfo != NULL) && (userinfo->iconcsumlen > 0)) { | |
3246 aim_bart_request(od, od->requesticon->data, userinfo->iconcsumtype, userinfo->iconcsum, userinfo->iconcsumlen); | |
3247 return FALSE; | |
3248 } else { | |
3249 gchar *sn = od->requesticon->data; | |
3250 od->requesticon = g_slist_remove(od->requesticon, sn); | |
3251 g_free(sn); | |
3252 } | |
3253 | |
3254 od->icontimer = gaim_timeout_add(100, gaim_icon_timerfunc, gc); | |
3255 | |
3256 return FALSE; | |
3257 } | |
3258 | |
3259 /* | |
3260 * Recieved in response to an IM sent with the AIM_IMFLAGS_ACK option. | |
3261 */ | |
3262 static int gaim_parse_msgack(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3263 va_list ap; | |
3264 guint16 type; | |
3265 char *sn; | |
3266 | |
3267 va_start(ap, fr); | |
3268 type = (guint16) va_arg(ap, unsigned int); | |
3269 sn = va_arg(ap, char *); | |
3270 va_end(ap); | |
3271 | |
3272 gaim_debug_info("oscar", "Sent message to %s.\n", sn); | |
3273 | |
3274 return 1; | |
3275 } | |
3276 | |
3277 static int gaim_parse_ratechange(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3278 static const char *codes[5] = { | |
3279 "invalid", | |
3280 "change", | |
3281 "warning", | |
3282 "limit", | |
3283 "limit cleared", | |
3284 }; | |
3285 va_list ap; | |
3286 guint16 code, rateclass; | |
3287 guint32 windowsize, clear, alert, limit, disconnect, currentavg, maxavg; | |
3288 | |
3289 va_start(ap, fr); | |
3290 code = (guint16)va_arg(ap, unsigned int); | |
3291 rateclass= (guint16)va_arg(ap, unsigned int); | |
3292 windowsize = va_arg(ap, guint32); | |
3293 clear = va_arg(ap, guint32); | |
3294 alert = va_arg(ap, guint32); | |
3295 limit = va_arg(ap, guint32); | |
3296 disconnect = va_arg(ap, guint32); | |
3297 currentavg = va_arg(ap, guint32); | |
3298 maxavg = va_arg(ap, guint32); | |
3299 va_end(ap); | |
3300 | |
3301 gaim_debug_misc("oscar", | |
3302 "rate %s (param ID 0x%04hx): curavg = %u, maxavg = %u, alert at %u, " | |
3303 "clear warning at %u, limit at %u, disconnect at %u (window size = %u)\n", | |
3304 (code < 5) ? codes[code] : codes[0], | |
3305 rateclass, | |
3306 currentavg, maxavg, | |
3307 alert, clear, | |
3308 limit, disconnect, | |
3309 windowsize); | |
3310 | |
3311 if (code == AIM_RATE_CODE_LIMIT) | |
3312 { | |
3313 gaim_notify_error(od->gc, NULL, _("Rate limiting error."), | |
3314 _("The last action you attempted could not be " | |
3315 "performed because you are over the rate limit. " | |
3316 "Please wait 10 seconds and try again.")); | |
3317 } | |
3318 | |
3319 return 1; | |
3320 } | |
3321 | |
3322 static int gaim_parse_evilnotify(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3323 #ifdef CRAZY_WARNING | |
3324 va_list ap; | |
3325 guint16 newevil; | |
3326 aim_userinfo_t *userinfo; | |
3327 | |
3328 va_start(ap, fr); | |
3329 newevil = (guint16) va_arg(ap, unsigned int); | |
3330 userinfo = va_arg(ap, aim_userinfo_t *); | |
3331 va_end(ap); | |
3332 | |
3333 gaim_prpl_got_account_warning_level(account, (userinfo && userinfo->sn) ? userinfo->sn : NULL, (newevil/10.0) + 0.5); | |
3334 #endif | |
3335 | |
3336 return 1; | |
3337 } | |
3338 | |
3339 static int gaim_selfinfo(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3340 int warning_level; | |
3341 va_list ap; | |
3342 aim_userinfo_t *info; | |
3343 | |
3344 va_start(ap, fr); | |
3345 info = va_arg(ap, aim_userinfo_t *); | |
3346 va_end(ap); | |
3347 | |
3348 /* | |
3349 * What's with the + 0.5? | |
3350 * The 0.5 is basically poor-man's rounding. Normally | |
3351 * casting "13.7" to an int will truncate to "13," but | |
3352 * with 13.7 + 0.5 = 14.2, which becomes "14" when | |
3353 * truncated. | |
3354 */ | |
3355 warning_level = info->warnlevel/10.0 + 0.5; | |
3356 | |
3357 #ifdef CRAZY_WARNING | |
3358 gaim_presence_set_warning_level(presence, warning_level); | |
3359 #endif | |
3360 | |
3361 return 1; | |
3362 } | |
3363 | |
3364 static int gaim_connerr(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3365 GaimConnection *gc = od->gc; | |
3366 va_list ap; | |
3367 guint16 code; | |
3368 char *msg; | |
3369 | |
3370 va_start(ap, fr); | |
3371 code = (guint16)va_arg(ap, int); | |
3372 msg = va_arg(ap, char *); | |
3373 va_end(ap); | |
3374 | |
3375 gaim_debug_info("oscar", "Disconnected. Code is 0x%04x and msg is %s\n", | |
3376 code, (msg != NULL ? msg : "")); | |
3377 | |
3378 g_return_val_if_fail(fr != NULL, 1); | |
3379 g_return_val_if_fail(conn != NULL, 1); | |
3380 | |
3381 if (conn->type == SNAC_FAMILY_LOCATE) { | |
3382 if (code == 0x0001) { | |
3383 gc->wants_to_die = TRUE; | |
3384 gaim_connection_error(gc, _("You have signed on from another location.")); | |
3385 } else { | |
3386 gaim_connection_error(gc, _("You have been signed off for an unknown reason.")); | |
3387 } | |
3388 od->killme = TRUE; | |
3389 } else if (conn->type == SNAC_FAMILY_CHAT) { | |
3390 struct chat_connection *cc; | |
3391 GaimConversation *conv; | |
3392 | |
3393 cc = find_oscar_chat_by_conn(gc, conn); | |
3394 conv = gaim_find_chat(gc, cc->id); | |
3395 | |
3396 if (conv != NULL) | |
3397 { | |
3398 gchar *buf; | |
3399 buf = g_strdup_printf(_("You have been disconnected from chat " | |
3400 "room %s."), cc->name); | |
3401 gaim_conversation_write(conv, NULL, buf, GAIM_MESSAGE_ERROR, time(NULL)); | |
3402 g_free(buf); | |
3403 } | |
3404 oscar_chat_kill(gc, cc); | |
3405 } | |
3406 | |
3407 return 1; | |
3408 } | |
3409 | |
3410 static int gaim_icbm_param_info(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3411 struct aim_icbmparameters *params; | |
3412 va_list ap; | |
3413 | |
3414 va_start(ap, fr); | |
3415 params = va_arg(ap, struct aim_icbmparameters *); | |
3416 va_end(ap); | |
3417 | |
3418 /* XXX - evidently this crashes on solaris. i have no clue why | |
3419 gaim_debug_misc("oscar", "ICBM Parameters: maxchannel = %hu, default flags = 0x%08lx, max msg len = %hu, " | |
3420 "max sender evil = %f, max receiver evil = %f, min msg interval = %u\n", | |
3421 params->maxchan, params->flags, params->maxmsglen, | |
3422 ((float)params->maxsenderwarn)/10.0, ((float)params->maxrecverwarn)/10.0, | |
3423 params->minmsginterval); | |
3424 */ | |
3425 | |
3426 /* Maybe senderwarn and recverwarn should be user preferences... */ | |
3427 params->flags = 0x0000000b; | |
3428 params->maxmsglen = 8000; | |
3429 params->minmsginterval = 0; | |
3430 | |
3431 aim_im_setparams(od, params); | |
3432 | |
3433 return 1; | |
3434 } | |
3435 | |
3436 static int gaim_parse_locaterights(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
3437 { | |
3438 GaimConnection *gc = od->gc; | |
3439 GaimAccount *account = gaim_connection_get_account(gc); | |
3440 va_list ap; | |
3441 guint16 maxsiglen; | |
3442 | |
3443 va_start(ap, fr); | |
3444 maxsiglen = (guint16) va_arg(ap, int); | |
3445 va_end(ap); | |
3446 | |
3447 gaim_debug_misc("oscar", | |
3448 "locate rights: max sig len = %d\n", maxsiglen); | |
3449 | |
3450 od->rights.maxsiglen = od->rights.maxawaymsglen = (guint)maxsiglen; | |
3451 | |
14552 | 3452 aim_locate_setcaps(od, gaim_caps); |
14192 | 3453 oscar_set_info_and_status(account, TRUE, account->user_info, TRUE, |
3454 gaim_account_get_active_status(account)); | |
3455 | |
3456 return 1; | |
3457 } | |
3458 | |
3459 static int gaim_parse_buddyrights(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3460 va_list ap; | |
3461 guint16 maxbuddies, maxwatchers; | |
3462 | |
3463 va_start(ap, fr); | |
3464 maxbuddies = (guint16) va_arg(ap, unsigned int); | |
3465 maxwatchers = (guint16) va_arg(ap, unsigned int); | |
3466 va_end(ap); | |
3467 | |
3468 gaim_debug_misc("oscar", | |
3469 "buddy list rights: Max buddies = %hu / Max watchers = %hu\n", maxbuddies, maxwatchers); | |
3470 | |
3471 od->rights.maxbuddies = (guint)maxbuddies; | |
3472 od->rights.maxwatchers = (guint)maxwatchers; | |
3473 | |
3474 return 1; | |
3475 } | |
3476 | |
3477 static int gaim_bosrights(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3478 GaimConnection *gc; | |
3479 GaimAccount *account; | |
3480 GaimStatus *status; | |
3481 const char *message; | |
3482 char *tmp; | |
3483 va_list ap; | |
3484 guint16 maxpermits, maxdenies; | |
3485 | |
3486 gc = od->gc; | |
3487 od = (OscarData *)gc->proto_data; | |
3488 account = gaim_connection_get_account(gc); | |
3489 | |
3490 va_start(ap, fr); | |
3491 maxpermits = (guint16) va_arg(ap, unsigned int); | |
3492 maxdenies = (guint16) va_arg(ap, unsigned int); | |
3493 va_end(ap); | |
3494 | |
3495 gaim_debug_misc("oscar", | |
3496 "BOS rights: Max permit = %hu / Max deny = %hu\n", maxpermits, maxdenies); | |
3497 | |
3498 od->rights.maxpermits = (guint)maxpermits; | |
3499 od->rights.maxdenies = (guint)maxdenies; | |
3500 | |
3501 gaim_connection_set_state(gc, GAIM_CONNECTED); | |
3502 | |
3503 gaim_debug_info("oscar", "buddy list loaded\n"); | |
3504 | |
3505 aim_clientready(od, conn); | |
3506 | |
15060
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
3507 if (gaim_account_get_user_info(account) != NULL) |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
3508 serv_set_info(gc, gaim_account_get_user_info(account)); |
17e367667cbf
[gaim-migrate @ 17844]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
15057
diff
changeset
|
3509 |
14192 | 3510 /* Set our available message based on the current status */ |
3511 status = gaim_account_get_active_status(account); | |
3512 if (gaim_status_is_available(status)) | |
3513 message = gaim_status_get_attr_string(status, "message"); | |
3514 else | |
3515 message = NULL; | |
3516 tmp = gaim_markup_strip_html(message); | |
3517 aim_srv_setstatusmsg(od, tmp); | |
3518 g_free(tmp); | |
3519 | |
3520 aim_srv_setidle(od, 0); | |
3521 | |
3522 if (od->icq) { | |
3523 aim_icq_reqofflinemsgs(od); | |
3524 oscar_set_extendedstatus(gc); | |
3525 aim_icq_setsecurity(od, | |
3526 gaim_account_get_bool(account, "authorization", OSCAR_DEFAULT_AUTHORIZATION), | |
3527 gaim_account_get_bool(account, "web_aware", OSCAR_DEFAULT_WEB_AWARE)); | |
3528 } | |
3529 | |
15085 | 3530 aim_srv_requestnew(od, SNAC_FAMILY_CHATNAV); |
15077 | 3531 |
3532 /* | |
3533 * The "if" statement here is a pathetic attempt to not attempt to | |
3534 * connect to the alerts servce (aka email notification) if this | |
3535 * screen name does not support it. I think mail notification | |
3536 * works for @mac.com accounts but does not work for the newer | |
3537 * @anythingelse.com accounts. If that's true then this change | |
3538 * breaks mail notification for @mac.com accounts, but it gets rid | |
3539 * of an annoying error at signon for @anythingelse.com accounts. | |
3540 */ | |
3541 if ((od->authinfo->email != NULL) && ((strchr(gc->account->username, '@') == NULL))) | |
15085 | 3542 aim_srv_requestnew(od, SNAC_FAMILY_ALERT); |
14192 | 3543 |
3544 return 1; | |
3545 } | |
3546 | |
3547 static int gaim_offlinemsg(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3548 va_list ap; | |
3549 struct aim_icq_offlinemsg *msg; | |
3550 struct aim_incomingim_ch4_args args; | |
3551 time_t t; | |
3552 | |
3553 va_start(ap, fr); | |
3554 msg = va_arg(ap, struct aim_icq_offlinemsg *); | |
3555 va_end(ap); | |
3556 | |
3557 gaim_debug_info("oscar", | |
3558 "Received offline message. Converting to channel 4 ICBM...\n"); | |
3559 args.uin = msg->sender; | |
3560 args.type = msg->type; | |
3561 args.flags = msg->flags; | |
3562 args.msglen = msg->msglen; | |
3563 args.msg = msg->msg; | |
3564 t = gaim_time_build(msg->year, msg->month, msg->day, msg->hour, msg->minute, 0); | |
3565 incomingim_chan4(od, conn, NULL, &args, t); | |
3566 | |
3567 return 1; | |
3568 } | |
3569 | |
3570 static int gaim_offlinemsgdone(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
3571 { | |
3572 aim_icq_ackofflinemsgs(od); | |
3573 return 1; | |
3574 } | |
3575 | |
3576 static int gaim_icqinfo(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
3577 { | |
3578 GaimConnection *gc; | |
3579 GaimAccount *account; | |
3580 GaimBuddy *buddy; | |
3581 struct buddyinfo *bi; | |
3582 gchar who[16]; | |
3583 GString *str; | |
3584 gchar *utf8; | |
3585 const gchar *alias; | |
3586 va_list ap; | |
3587 struct aim_icq_info *info; | |
3588 | |
3589 gc = od->gc; | |
3590 account = gaim_connection_get_account(gc); | |
3591 | |
3592 va_start(ap, fr); | |
3593 info = va_arg(ap, struct aim_icq_info *); | |
3594 va_end(ap); | |
3595 | |
3596 if (!info->uin) | |
3597 return 0; | |
3598 | |
3599 str = g_string_sized_new(100); | |
3600 g_snprintf(who, sizeof(who), "%u", info->uin); | |
3601 buddy = gaim_find_buddy(gaim_connection_get_account(gc), who); | |
3602 if (buddy != NULL) | |
3603 bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(buddy->account, buddy->name)); | |
3604 else | |
3605 bi = NULL; | |
3606 | |
3607 g_string_append_printf(str, "<b>%s:</b> %s", _("UIN"), who); | |
3608 oscar_string_convert_and_append(account, str, "\n<br>", _("Nick"), info->nick); | |
3609 if ((bi != NULL) && (bi->ipaddr != 0)) { | |
3610 char *tstr = g_strdup_printf("%hhu.%hhu.%hhu.%hhu", | |
3611 (bi->ipaddr & 0xff000000) >> 24, | |
3612 (bi->ipaddr & 0x00ff0000) >> 16, | |
3613 (bi->ipaddr & 0x0000ff00) >> 8, | |
3614 (bi->ipaddr & 0x000000ff)); | |
3615 oscar_string_append(str, "\n<br>", _("IP Address"), tstr); | |
3616 g_free(tstr); | |
3617 } | |
3618 oscar_string_convert_and_append(account, str, "\n<br>", _("First Name"), info->first); | |
3619 oscar_string_convert_and_append(account, str, "\n<br>", _("Last Name"), info->last); | |
3620 if (info->email && info->email[0] && (utf8 = oscar_utf8_try_convert(gc->account, info->email))) { | |
3621 g_string_append_printf(str, "\n<br><b>%s:</b> <a href=\"mailto:%s\">%s</a>", _("E-Mail Address"), utf8, utf8); | |
3622 g_free(utf8); | |
3623 } | |
3624 if (info->numaddresses && info->email2) { | |
3625 int i; | |
3626 for (i = 0; i < info->numaddresses; i++) { | |
3627 if (info->email2[i] && info->email2[i][0] && (utf8 = oscar_utf8_try_convert(gc->account, info->email2[i]))) { | |
3628 g_string_append_printf(str, "\n<br><b>%s:</b> <a href=\"mailto:%s\">%s</a>", _("E-Mail Address"), utf8, utf8); | |
3629 g_free(utf8); | |
3630 } | |
3631 } | |
3632 } | |
3633 oscar_string_convert_and_append(account, str, "\n<br>", _("Mobile Phone"), info->mobile); | |
3634 if (info->gender != 0) | |
3635 oscar_string_append(str, "\n<br>", _("Gender"), info->gender == 1 ? _("Female") : _("Male")); | |
3636 if ((info->birthyear > 1900) && (info->birthmonth > 0) && (info->birthday > 0)) { | |
3637 /* Initialize the struct properly or strftime() will crash | |
3638 * under some conditions (e.g. Debian sarge w/ LANG=en_HK). */ | |
3639 time_t t = time(NULL); | |
3640 struct tm *tm = localtime(&t); | |
3641 | |
3642 tm->tm_mday = (int)info->birthday; | |
3643 tm->tm_mon = (int)info->birthmonth - 1; | |
3644 tm->tm_year = (int)info->birthyear - 1900; | |
3645 | |
3646 /* To be 100% sure that the fields are re-normalized. | |
3647 * If you're sure strftime() ALWAYS does this EVERYWHERE, | |
3648 * feel free to remove it. --rlaager */ | |
3649 mktime(tm); | |
3650 | |
3651 oscar_string_append(str, "\n<br>", _("Birthday"), | |
3652 gaim_date_format_short(tm)); | |
3653 } | |
3654 if ((info->age > 0) && (info->age < 255)) { | |
3655 char age[5]; | |
3656 snprintf(age, sizeof(age), "%hhd", info->age); | |
3657 oscar_string_append(str, "\n<br>", _("Age"), age); | |
3658 } | |
3659 if (info->personalwebpage && info->personalwebpage[0] && (utf8 = oscar_utf8_try_convert(gc->account, info->personalwebpage))) { | |
3660 g_string_append_printf(str, "\n<br><b>%s:</b> <a href=\"%s\">%s</a>", _("Personal Web Page"), utf8, utf8); | |
3661 g_free(utf8); | |
3662 } | |
3663 if (info->info && info->info[0] && (utf8 = oscar_utf8_try_convert(gc->account, info->info))) { | |
3664 g_string_append_printf(str, "<hr><b>%s:</b><br>%s", _("Additional Information"), utf8); | |
3665 g_free(utf8); | |
3666 } | |
3667 g_string_append_printf(str, "<hr>"); | |
3668 if ((info->homeaddr && (info->homeaddr[0])) || (info->homecity && info->homecity[0]) || (info->homestate && info->homestate[0]) || (info->homezip && info->homezip[0])) { | |
3669 g_string_append_printf(str, "<b>%s:</b>", _("Home Address")); | |
3670 oscar_string_convert_and_append(account, str, "\n<br>", _("Address"), info->homeaddr); | |
3671 oscar_string_convert_and_append(account, str, "\n<br>", _("City"), info->homecity); | |
3672 oscar_string_convert_and_append(account, str, "\n<br>", _("State"), info->homestate); | |
3673 oscar_string_convert_and_append(account, str, "\n<br>", _("Zip Code"), info->homezip); | |
3674 g_string_append_printf(str, "\n<hr>"); | |
3675 } | |
3676 if ((info->workaddr && info->workaddr[0]) || (info->workcity && info->workcity[0]) || (info->workstate && info->workstate[0]) || (info->workzip && info->workzip[0])) { | |
3677 g_string_append_printf(str, "<b>%s:</b>", _("Work Address")); | |
3678 oscar_string_convert_and_append(account, str, "\n<br>", _("Address"), info->workaddr); | |
3679 oscar_string_convert_and_append(account, str, "\n<br>", _("City"), info->workcity); | |
3680 oscar_string_convert_and_append(account, str, "\n<br>", _("State"), info->workstate); | |
3681 oscar_string_convert_and_append(account, str, "\n<br>", _("Zip Code"), info->workzip); | |
3682 g_string_append_printf(str, "\n<hr>"); | |
3683 } | |
3684 if ((info->workcompany && info->workcompany[0]) || (info->workdivision && info->workdivision[0]) || (info->workposition && info->workposition[0]) || (info->workwebpage && info->workwebpage[0])) { | |
3685 g_string_append_printf(str, "<b>%s:</b>", _("Work Information")); | |
3686 oscar_string_convert_and_append(account, str, "\n<br>", _("Company"), info->workcompany); | |
3687 oscar_string_convert_and_append(account, str, "\n<br>", _("Division"), info->workdivision); | |
3688 oscar_string_convert_and_append(account, str, "\n<br>", _("Position"), info->workposition); | |
3689 if (info->workwebpage && info->workwebpage[0] && (utf8 = oscar_utf8_try_convert(gc->account, info->workwebpage))) { | |
3690 g_string_append_printf(str, "\n<br><b>%s:</b> <a href=\"%s\">%s</a>", _("Web Page"), utf8, utf8); | |
3691 g_free(utf8); | |
3692 } | |
3693 g_string_append_printf(str, "\n<hr>"); | |
3694 } | |
3695 | |
3696 if (buddy != NULL) | |
3697 alias = gaim_buddy_get_alias(buddy); | |
3698 else | |
3699 alias = who; | |
3700 gaim_notify_userinfo(gc, who, str->str, NULL, NULL); | |
3701 g_string_free(str, TRUE); | |
3702 | |
3703 return 1; | |
3704 } | |
3705 | |
3706 static int gaim_icqalias(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
3707 { | |
3708 GaimConnection *gc = od->gc; | |
3709 GaimAccount *account = gaim_connection_get_account(gc); | |
3710 gchar who[16], *utf8; | |
3711 GaimBuddy *b; | |
3712 va_list ap; | |
3713 struct aim_icq_info *info; | |
3714 | |
3715 va_start(ap, fr); | |
3716 info = va_arg(ap, struct aim_icq_info *); | |
3717 va_end(ap); | |
3718 | |
3719 if (info->uin && info->nick && info->nick[0] && (utf8 = oscar_utf8_try_convert(account, info->nick))) { | |
3720 g_snprintf(who, sizeof(who), "%u", info->uin); | |
3721 serv_got_alias(gc, who, utf8); | |
3722 if ((b = gaim_find_buddy(gc->account, who))) { | |
3723 gaim_blist_node_set_string((GaimBlistNode*)b, "servernick", utf8); | |
3724 } | |
3725 g_free(utf8); | |
3726 } | |
3727 | |
3728 return 1; | |
3729 } | |
3730 | |
3731 static int gaim_popup(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
3732 { | |
3733 GaimConnection *gc = od->gc; | |
3734 gchar *text; | |
3735 va_list ap; | |
3736 char *msg, *url; | |
3737 guint16 wid, hei, delay; | |
3738 | |
3739 va_start(ap, fr); | |
3740 msg = va_arg(ap, char *); | |
3741 url = va_arg(ap, char *); | |
3742 wid = (guint16) va_arg(ap, int); | |
3743 hei = (guint16) va_arg(ap, int); | |
3744 delay = (guint16) va_arg(ap, int); | |
3745 va_end(ap); | |
3746 | |
3747 text = g_strdup_printf("%s<br><a href=\"%s\">%s</a>", msg, url, url); | |
3748 gaim_notify_formatted(gc, NULL, _("Pop-Up Message"), NULL, text, NULL, NULL); | |
3749 g_free(text); | |
3750 | |
3751 return 1; | |
3752 } | |
3753 | |
3754 static void oscar_searchresults_add_buddy_cb(GaimConnection *gc, GList *row, void *user_data) | |
3755 { | |
3756 gaim_blist_request_add_buddy(gaim_connection_get_account(gc), | |
3757 g_list_nth_data(row, 0), NULL, NULL); | |
3758 } | |
3759 | |
3760 static int gaim_parse_searchreply(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
3761 { | |
3762 GaimConnection *gc = od->gc; | |
3763 GaimNotifySearchResults *results; | |
3764 GaimNotifySearchColumn *column; | |
3765 gchar *secondary; | |
3766 int i, num; | |
3767 va_list ap; | |
3768 char *email, *SNs; | |
3769 | |
3770 va_start(ap, fr); | |
3771 email = va_arg(ap, char *); | |
3772 num = va_arg(ap, int); | |
3773 SNs = va_arg(ap, char *); | |
3774 va_end(ap); | |
3775 | |
3776 results = gaim_notify_searchresults_new(); | |
3777 | |
3778 if (results == NULL) { | |
3779 gaim_debug_error("oscar", "gaim_parse_searchreply: " | |
3780 "Unable to display the search results.\n"); | |
3781 gaim_notify_error(gc, NULL, | |
3782 _("Unable to display the search results."), | |
3783 NULL); | |
3784 return 1; | |
3785 } | |
3786 | |
3787 secondary = g_strdup_printf( | |
3788 ngettext("The following screen name is associated with %s", | |
3789 "The following screen names are associated with %s", | |
3790 num), | |
3791 email); | |
3792 | |
3793 column = gaim_notify_searchresults_column_new(_("Screen name")); | |
3794 gaim_notify_searchresults_column_add(results, column); | |
3795 | |
3796 for (i = 0; i < num; i++) { | |
3797 GList *row = NULL; | |
3798 row = g_list_append(row, g_strdup(&SNs[i * (MAXSNLEN + 1)])); | |
3799 gaim_notify_searchresults_row_add(results, row); | |
3800 } | |
3801 gaim_notify_searchresults_button_add(results, GAIM_NOTIFY_BUTTON_ADD, | |
3802 oscar_searchresults_add_buddy_cb); | |
3803 gaim_notify_searchresults(gc, NULL, NULL, secondary, results, NULL, NULL); | |
3804 | |
3805 g_free(secondary); | |
3806 | |
3807 return 1; | |
3808 } | |
3809 | |
3810 static int gaim_parse_searcherror(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3811 va_list ap; | |
3812 char *email; | |
3813 char *buf; | |
3814 | |
3815 va_start(ap, fr); | |
3816 email = va_arg(ap, char *); | |
3817 va_end(ap); | |
3818 | |
3819 buf = g_strdup_printf(_("No results found for e-mail address %s"), email); | |
3820 gaim_notify_error(od->gc, NULL, buf, NULL); | |
3821 g_free(buf); | |
3822 | |
3823 return 1; | |
3824 } | |
3825 | |
3826 static int gaim_account_confirm(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3827 GaimConnection *gc = od->gc; | |
3828 guint16 status; | |
3829 va_list ap; | |
3830 char msg[256]; | |
3831 | |
3832 va_start(ap, fr); | |
3833 status = (guint16) va_arg(ap, unsigned int); /* status code of confirmation request */ | |
3834 va_end(ap); | |
3835 | |
3836 gaim_debug_info("oscar", | |
3837 "account confirmation returned status 0x%04x (%s)\n", status, | |
3838 status ? "unknown" : "e-mail sent"); | |
3839 if (!status) { | |
3840 g_snprintf(msg, sizeof(msg), _("You should receive an e-mail asking to confirm %s."), | |
3841 gaim_account_get_username(gaim_connection_get_account(gc))); | |
3842 gaim_notify_info(gc, NULL, _("Account Confirmation Requested"), msg); | |
3843 } | |
3844 | |
3845 return 1; | |
3846 } | |
3847 | |
3848 static int gaim_info_change(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
3849 GaimConnection *gc = od->gc; | |
3850 va_list ap; | |
3851 guint16 perms, err; | |
3852 char *url, *sn, *email; | |
3853 int change; | |
3854 | |
3855 va_start(ap, fr); | |
3856 change = va_arg(ap, int); | |
3857 perms = (guint16) va_arg(ap, unsigned int); | |
3858 err = (guint16) va_arg(ap, unsigned int); | |
3859 url = va_arg(ap, char *); | |
3860 sn = va_arg(ap, char *); | |
3861 email = va_arg(ap, char *); | |
3862 va_end(ap); | |
3863 | |
3864 gaim_debug_misc("oscar", | |
3865 "account info: because of %s, perms=0x%04x, err=0x%04x, url=%s, sn=%s, email=%s\n", | |
3866 change ? "change" : "request", perms, err, | |
3867 (url != NULL) ? url : "(null)", | |
3868 (sn != NULL) ? sn : "(null)", | |
3869 (email != NULL) ? email : "(null)"); | |
3870 | |
3871 if ((err > 0) && (url != NULL)) { | |
3872 char *dialog_msg; | |
3873 char *dialog_top = g_strdup_printf(_("Error Changing Account Info")); | |
3874 switch (err) { | |
3875 case 0x0001: { | |
3876 dialog_msg = g_strdup_printf(_("Error 0x%04x: Unable to format screen name because the requested screen name differs from the original."), err); | |
3877 } break; | |
3878 case 0x0006: { | |
3879 dialog_msg = g_strdup_printf(_("Error 0x%04x: Unable to format screen name because it is invalid."), err); | |
3880 } break; | |
3881 case 0x000b: { | |
3882 dialog_msg = g_strdup_printf(_("Error 0x%04x: Unable to format screen name because the requested screen name is too long."), err); | |
3883 } break; | |
3884 case 0x001d: { | |
3885 dialog_msg = g_strdup_printf(_("Error 0x%04x: Unable to change e-mail address because there is already a request pending for this screen name."), err); | |
3886 } break; | |
3887 case 0x0021: { | |
3888 dialog_msg = g_strdup_printf(_("Error 0x%04x: Unable to change e-mail address because the given address has too many screen names associated with it."), err); | |
3889 } break; | |
3890 case 0x0023: { | |
3891 dialog_msg = g_strdup_printf(_("Error 0x%04x: Unable to change e-mail address because the given address is invalid."), err); | |
3892 } break; | |
3893 default: { | |
3894 dialog_msg = g_strdup_printf(_("Error 0x%04x: Unknown error."), err); | |
3895 } break; | |
3896 } | |
3897 gaim_notify_error(gc, NULL, dialog_top, dialog_msg); | |
3898 g_free(dialog_top); | |
3899 g_free(dialog_msg); | |
3900 return 1; | |
3901 } | |
3902 | |
3903 if (sn != NULL) { | |
3904 char *dialog_msg = g_strdup_printf(_("Your screen name is currently formatted as follows:\n%s"), sn); | |
3905 gaim_notify_info(gc, NULL, _("Account Info"), dialog_msg); | |
3906 g_free(dialog_msg); | |
3907 } | |
3908 | |
3909 if (email != NULL) { | |
3910 char *dialog_msg = g_strdup_printf(_("The e-mail address for %s is %s"), | |
3911 gaim_account_get_username(gaim_connection_get_account(gc)), email); | |
3912 gaim_notify_info(gc, NULL, _("Account Info"), dialog_msg); | |
3913 g_free(dialog_msg); | |
3914 } | |
3915 | |
3916 return 1; | |
3917 } | |
3918 | |
14968 | 3919 void |
14192 | 3920 oscar_keepalive(GaimConnection *gc) |
3921 { | |
3922 OscarData *od; | |
3923 FlapConnection *conn; | |
3924 | |
3925 od = (OscarData *)gc->proto_data; | |
3926 conn = flap_connection_getbytype(od, SNAC_FAMILY_LOCATE); | |
3927 if (conn != NULL) | |
3928 flap_connection_send_keepalive(od, conn); | |
3929 } | |
3930 | |
14968 | 3931 unsigned int |
14192 | 3932 oscar_send_typing(GaimConnection *gc, const char *name, GaimTypingState state) |
3933 { | |
3934 OscarData *od; | |
3935 PeerConnection *conn; | |
3936 | |
3937 od = (OscarData *)gc->proto_data; | |
3938 conn = peer_connection_find_by_type(od, name, OSCAR_CAPABILITY_DIRECTIM); | |
3939 | |
3940 if ((conn != NULL) && (conn->ready)) | |
3941 { | |
3942 peer_odc_send_typing(conn, state); | |
3943 } | |
3944 else { | |
3945 /* Don't send if this turkey is in our deny list */ | |
3946 GSList *list; | |
3947 for (list=gc->account->deny; (list && aim_sncmp(name, list->data)); list=list->next); | |
3948 if (!list) { | |
3949 struct buddyinfo *bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(gc->account, name)); | |
3950 if (bi && bi->typingnot) { | |
3951 if (state == GAIM_TYPING) | |
3952 aim_im_sendmtn(od, 0x0001, name, 0x0002); | |
3953 else if (state == GAIM_TYPED) | |
3954 aim_im_sendmtn(od, 0x0001, name, 0x0001); | |
3955 else | |
3956 aim_im_sendmtn(od, 0x0001, name, 0x0000); | |
3957 } | |
3958 } | |
3959 } | |
3960 return 0; | |
3961 } | |
3962 | |
3963 /* TODO: Move this into odc.c! */ | |
3964 static void | |
3965 gaim_odc_send_im(PeerConnection *conn, const char *message, GaimMessageFlags imflags) | |
3966 { | |
3967 GString *msg; | |
3968 GString *data; | |
3969 gchar *tmp; | |
3970 int tmplen; | |
3971 guint16 charset, charsubset; | |
3972 GData *attribs; | |
3973 const char *start, *end, *last; | |
3974 int oscar_id = 0; | |
3975 | |
3976 msg = g_string_new("<HTML><BODY>"); | |
3977 data = g_string_new("<BINARY>"); | |
3978 last = message; | |
3979 | |
3980 /* for each valid IMG tag... */ | |
3981 while (last && *last && gaim_markup_find_tag("img", last, &start, &end, &attribs)) | |
3982 { | |
3983 GaimStoredImage *image = NULL; | |
3984 const char *id; | |
3985 | |
3986 if (start - last) { | |
3987 g_string_append_len(msg, last, start - last); | |
3988 } | |
3989 | |
3990 id = g_datalist_get_data(&attribs, "id"); | |
3991 | |
3992 /* ... if it refers to a valid gaim image ... */ | |
3993 if (id && (image = gaim_imgstore_get(atoi(id)))) { | |
3994 /* ... append the message from start to the tag ... */ | |
3995 unsigned long size = gaim_imgstore_get_size(image); | |
3996 const char *filename = gaim_imgstore_get_filename(image); | |
3997 gpointer imgdata = gaim_imgstore_get_data(image); | |
3998 | |
3999 oscar_id++; | |
4000 | |
4001 /* ... insert a new img tag with the oscar id ... */ | |
4002 if (filename) | |
4003 g_string_append_printf(msg, | |
4004 "<IMG SRC=\"%s\" ID=\"%d\" DATASIZE=\"%lu\">", | |
4005 filename, oscar_id, size); | |
4006 else | |
4007 g_string_append_printf(msg, | |
4008 "<IMG ID=\"%d\" DATASIZE=\"%lu\">", | |
4009 oscar_id, size); | |
4010 | |
4011 /* ... and append the data to the binary section ... */ | |
4012 g_string_append_printf(data, "<DATA ID=\"%d\" SIZE=\"%lu\">", | |
4013 oscar_id, size); | |
4014 g_string_append_len(data, imgdata, size); | |
4015 g_string_append(data, "</DATA>"); | |
4016 } | |
4017 /* If the tag is invalid, skip it, thus no else here */ | |
4018 | |
4019 g_datalist_clear(&attribs); | |
4020 | |
4021 /* continue from the end of the tag */ | |
4022 last = end + 1; | |
4023 } | |
4024 | |
4025 /* append any remaining message data */ | |
4026 if (last && *last) | |
4027 g_string_append(msg, last); | |
4028 | |
4029 g_string_append(msg, "</BODY></HTML>"); | |
4030 | |
4031 /* Convert the message to a good encoding */ | |
4032 gaim_plugin_oscar_convert_to_best_encoding(conn->od->gc, | |
4033 conn->sn, msg->str, &tmp, &tmplen, &charset, &charsubset); | |
4034 g_string_free(msg, TRUE); | |
4035 msg = g_string_new_len(tmp, tmplen); | |
4036 | |
4037 /* Append any binary data that we may have */ | |
4038 if (oscar_id) { | |
4039 msg = g_string_append_len(msg, data->str, data->len); | |
4040 msg = g_string_append(msg, "</BINARY>"); | |
4041 } | |
4042 g_string_free(data, TRUE); | |
4043 | |
4044 peer_odc_send_im(conn, msg->str, msg->len, charset, | |
4045 imflags & GAIM_MESSAGE_AUTO_RESP); | |
4046 g_string_free(msg, TRUE); | |
4047 } | |
4048 | |
14968 | 4049 int |
14192 | 4050 oscar_send_im(GaimConnection *gc, const char *name, const char *message, GaimMessageFlags imflags) |
4051 { | |
4052 OscarData *od; | |
4053 GaimAccount *account; | |
4054 PeerConnection *conn; | |
4055 int ret; | |
4056 char *iconfile; | |
4057 char *tmp1, *tmp2; | |
4058 | |
4059 od = (OscarData *)gc->proto_data; | |
4060 account = gaim_connection_get_account(gc); | |
4061 ret = 0; | |
4062 iconfile = gaim_buddy_icons_get_full_path(gaim_account_get_buddy_icon(account)); | |
4063 | |
4064 if (imflags & GAIM_MESSAGE_AUTO_RESP) | |
4065 tmp1 = gaim_str_sub_away_formatters(message, name); | |
4066 else | |
4067 tmp1 = g_strdup(message); | |
4068 | |
4069 conn = peer_connection_find_by_type(od, name, OSCAR_CAPABILITY_DIRECTIM); | |
4070 if ((conn != NULL) && (conn->ready)) | |
4071 { | |
4072 /* If we're directly connected, send a direct IM */ | |
4073 gaim_odc_send_im(conn, tmp1, imflags); | |
4074 } else { | |
4075 struct buddyinfo *bi; | |
4076 struct aim_sendimext_args args; | |
4077 struct stat st; | |
4078 gsize len; | |
4079 GaimConversation *conv; | |
4080 | |
4081 conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, name, account); | |
4082 | |
4083 if (strstr(tmp1, "<IMG ")) | |
4084 gaim_conversation_write(conv, "", | |
4085 _("Your IM Image was not sent. " | |
4086 "You must be Direct Connected to send IM Images."), | |
4087 GAIM_MESSAGE_ERROR, time(NULL)); | |
4088 | |
4089 bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(account, name)); | |
4090 if (!bi) { | |
4091 bi = g_new0(struct buddyinfo, 1); | |
4092 g_hash_table_insert(od->buddyinfo, g_strdup(gaim_normalize(account, name)), bi); | |
4093 } | |
4094 | |
4095 args.flags = AIM_IMFLAGS_ACK | AIM_IMFLAGS_CUSTOMFEATURES; | |
4096 if (od->icq) { | |
4097 /* We have to present different "features" (whose meaning | |
4098 is unclear and are merely a result of protocol inspection) | |
4099 to offline ICQ buddies. Otherwise, the official | |
4100 ICQ client doesn't treat those messages as being "ANSI- | |
4101 encoded" (and instead, assumes them to be UTF-8). | |
4102 For more details, see SF issue 1179452. | |
4103 */ | |
4104 GaimBuddy *buddy = gaim_find_buddy(gc->account, name); | |
4105 if (buddy && GAIM_BUDDY_IS_ONLINE(buddy)) { | |
4106 args.features = features_icq; | |
4107 args.featureslen = sizeof(features_icq); | |
4108 } else { | |
4109 args.features = features_icq_offline; | |
4110 args.featureslen = sizeof(features_icq_offline); | |
4111 } | |
4112 args.flags |= AIM_IMFLAGS_OFFLINE; | |
4113 } else { | |
4114 args.features = features_aim; | |
4115 args.featureslen = sizeof(features_aim); | |
4116 | |
4117 if (imflags & GAIM_MESSAGE_AUTO_RESP) | |
4118 args.flags |= AIM_IMFLAGS_AWAY; | |
4119 } | |
4120 | |
4121 if (bi->ico_need) { | |
4122 gaim_debug_info("oscar", | |
4123 "Sending buddy icon request with message\n"); | |
4124 args.flags |= AIM_IMFLAGS_BUDDYREQ; | |
4125 bi->ico_need = FALSE; | |
4126 } | |
4127 | |
4128 if (iconfile && !g_stat(iconfile, &st)) { | |
4129 FILE *file = g_fopen(iconfile, "rb"); | |
4130 if (file) { | |
4131 guchar *buf = g_malloc(st.st_size); | |
4132 /* TODO: Use g_file_get_contents()? */ | |
4133 fread(buf, 1, st.st_size, file); | |
4134 fclose(file); | |
4135 | |
4136 args.iconlen = st.st_size; | |
4137 args.iconsum = aimutil_iconsum(buf, st.st_size); | |
4138 args.iconstamp = st.st_mtime; | |
4139 | |
4140 if ((args.iconlen != bi->ico_me_len) || (args.iconsum != bi->ico_me_csum) || (args.iconstamp != bi->ico_me_time)) { | |
4141 bi->ico_informed = FALSE; | |
4142 bi->ico_sent = FALSE; | |
4143 } | |
4144 | |
14282 | 4145 /* |
4146 * TODO: | |
4147 * For some reason sending our icon to people only works | |
4148 * when we're the ones who initiated the conversation. If | |
4149 * the other person sends the first IM then they never get | |
4150 * the icon. We should fix that. | |
4151 */ | |
14192 | 4152 if (!bi->ico_informed) { |
4153 gaim_debug_info("oscar", | |
4154 "Claiming to have a buddy icon\n"); | |
4155 args.flags |= AIM_IMFLAGS_HASICON; | |
4156 bi->ico_me_len = args.iconlen; | |
4157 bi->ico_me_csum = args.iconsum; | |
4158 bi->ico_me_time = args.iconstamp; | |
4159 bi->ico_informed = TRUE; | |
4160 } | |
4161 | |
4162 g_free(buf); | |
4163 } | |
4164 } | |
4165 g_free(iconfile); | |
4166 | |
4167 args.destsn = name; | |
4168 | |
4169 /* | |
4170 * If we're IMing an SMS user or an ICQ user from an ICQ account, then strip HTML. | |
4171 */ | |
4172 if (aim_sn_is_sms(name)) { | |
4173 /* Messaging an SMS (mobile) user */ | |
4174 tmp2 = gaim_unescape_html(tmp1); | |
4175 } else if (aim_sn_is_icq(gaim_account_get_username(account))) { | |
4176 if (aim_sn_is_icq(name)) | |
4177 /* From ICQ to ICQ */ | |
4178 tmp2 = gaim_unescape_html(tmp1); | |
4179 else | |
4180 /* From ICQ to AIM */ | |
4181 tmp2 = g_strdup(tmp1); | |
4182 } else { | |
4183 /* From AIM to AIM and AIM to ICQ */ | |
4184 tmp2 = g_strdup(tmp1); | |
4185 } | |
4186 g_free(tmp1); | |
4187 tmp1 = tmp2; | |
4188 len = strlen(tmp1); | |
4189 | |
4190 gaim_plugin_oscar_convert_to_best_encoding(gc, name, tmp1, (char **)&args.msg, &args.msglen, &args.charset, &args.charsubset); | |
4191 gaim_debug_info("oscar", "Sending IM, charset=0x%04hx, charsubset=0x%04hx, length=%d\n", | |
4192 args.charset, args.charsubset, args.msglen); | |
4193 ret = aim_im_sendch1_ext(od, &args); | |
4194 g_free((char *)args.msg); | |
4195 } | |
4196 | |
4197 g_free(tmp1); | |
4198 | |
4199 if (ret >= 0) | |
4200 return 1; | |
4201 | |
4202 return ret; | |
4203 } | |
4204 | |
4205 /* | |
4206 * As of 26 June 2006, ICQ users can request AIM info from | |
4207 * everyone, and can request ICQ info from ICQ users, and | |
4208 * AIM users can only request AIM info. | |
4209 */ | |
14968 | 4210 void oscar_get_info(GaimConnection *gc, const char *name) { |
14192 | 4211 OscarData *od = (OscarData *)gc->proto_data; |
4212 | |
4213 if (od->icq && aim_sn_is_icq(name)) | |
4214 aim_icq_getallinfo(od, name); | |
4215 else | |
4216 aim_locate_getinfoshort(od, name, 0x00000003); | |
4217 } | |
4218 | |
4219 #if 0 | |
4220 static void oscar_set_dir(GaimConnection *gc, const char *first, const char *middle, const char *last, | |
4221 const char *maiden, const char *city, const char *state, const char *country, int web) { | |
4222 /* XXX - some of these things are wrong, but i'm lazy */ | |
4223 OscarData *od = (OscarData *)gc->proto_data; | |
4224 aim_locate_setdirinfo(od, first, middle, last, | |
4225 maiden, NULL, NULL, city, state, NULL, 0, web); | |
4226 } | |
4227 #endif | |
4228 | |
14968 | 4229 void oscar_set_idle(GaimConnection *gc, int time) { |
14192 | 4230 OscarData *od = (OscarData *)gc->proto_data; |
4231 aim_srv_setidle(od, time); | |
4232 } | |
4233 | |
4234 static | |
4235 gchar *gaim_prpl_oscar_convert_to_infotext(const gchar *str, gsize *ret_len, char **encoding) | |
4236 { | |
4237 int charset = 0; | |
4238 char *encoded = NULL; | |
4239 | |
4240 charset = oscar_charset_check(str); | |
4241 if (charset == AIM_CHARSET_UNICODE) { | |
4242 encoded = g_convert(str, strlen(str), "UCS-2BE", "UTF-8", NULL, ret_len, NULL); | |
4243 *encoding = "unicode-2-0"; | |
4244 } else if (charset == AIM_CHARSET_CUSTOM) { | |
4245 encoded = g_convert(str, strlen(str), "ISO-8859-1", "UTF-8", NULL, ret_len, NULL); | |
4246 *encoding = "iso-8859-1"; | |
4247 } else { | |
4248 encoded = g_strdup(str); | |
4249 *ret_len = strlen(str); | |
4250 *encoding = "us-ascii"; | |
4251 } | |
4252 | |
4253 return encoded; | |
4254 } | |
4255 | |
14968 | 4256 void |
14192 | 4257 oscar_set_info(GaimConnection *gc, const char *rawinfo) |
4258 { | |
4259 GaimAccount *account; | |
4260 GaimStatus *status; | |
4261 | |
4262 account = gaim_connection_get_account(gc); | |
4263 status = gaim_account_get_active_status(account); | |
4264 oscar_set_info_and_status(account, TRUE, rawinfo, FALSE, status); | |
4265 } | |
4266 | |
4267 static void | |
4268 oscar_set_extendedstatus(GaimConnection *gc) | |
4269 { | |
4270 OscarData *od; | |
4271 GaimAccount *account; | |
4272 GaimStatus *status; | |
4273 const gchar *status_id; | |
4274 guint32 data = 0x00000000; | |
4275 | |
4276 od = gc->proto_data; | |
4277 account = gaim_connection_get_account(gc); | |
4278 status = gaim_account_get_active_status(account); | |
4279 status_id = gaim_status_get_id(status); | |
4280 | |
4281 data |= AIM_ICQ_STATE_HIDEIP; | |
4282 if (gaim_account_get_bool(account, "web_aware", OSCAR_DEFAULT_WEB_AWARE)) | |
4283 data |= AIM_ICQ_STATE_WEBAWARE; | |
4284 | |
4285 if (!strcmp(status_id, OSCAR_STATUS_ID_AVAILABLE) || !strcmp(status_id, OSCAR_STATUS_ID_AVAILABLE)) | |
4286 data |= AIM_ICQ_STATE_NORMAL; | |
4287 else if (!strcmp(status_id, OSCAR_STATUS_ID_AWAY)) | |
4288 data |= AIM_ICQ_STATE_AWAY; | |
4289 else if (!strcmp(status_id, OSCAR_STATUS_ID_DND)) | |
4290 data |= AIM_ICQ_STATE_AWAY | AIM_ICQ_STATE_DND | AIM_ICQ_STATE_BUSY; | |
4291 else if (!strcmp(status_id, OSCAR_STATUS_ID_NA)) | |
4292 data |= AIM_ICQ_STATE_OUT | AIM_ICQ_STATE_AWAY; | |
4293 else if (!strcmp(status_id, OSCAR_STATUS_ID_OCCUPIED)) | |
4294 data |= AIM_ICQ_STATE_AWAY | AIM_ICQ_STATE_BUSY; | |
4295 else if (!strcmp(status_id, OSCAR_STATUS_ID_FREE4CHAT)) | |
4296 data |= AIM_ICQ_STATE_CHAT; | |
4297 else if (!strcmp(status_id, OSCAR_STATUS_ID_INVISIBLE)) | |
4298 data |= AIM_ICQ_STATE_INVISIBLE; | |
4299 else if (!strcmp(status_id, OSCAR_STATUS_ID_CUSTOM)) | |
4300 data |= AIM_ICQ_STATE_OUT | AIM_ICQ_STATE_AWAY; | |
4301 | |
15085 | 4302 aim_srv_setextstatus(od, data); |
14192 | 4303 } |
4304 | |
4305 static void | |
4306 oscar_set_info_and_status(GaimAccount *account, gboolean setinfo, const char *rawinfo, | |
4307 gboolean setstatus, GaimStatus *status) | |
4308 { | |
4309 GaimConnection *gc = gaim_account_get_connection(account); | |
4310 OscarData *od = gc->proto_data; | |
4311 GaimPresence *presence; | |
4312 GaimStatusType *status_type; | |
4313 GaimStatusPrimitive primitive; | |
4314 gboolean invisible; | |
4315 | |
4316 char *htmlinfo; | |
4317 char *info_encoding = NULL; | |
4318 char *info = NULL; | |
4319 gsize infolen = 0; | |
4320 | |
4321 const char *htmlaway; | |
4322 char *away_encoding = NULL; | |
4323 char *away = NULL; | |
4324 gsize awaylen = 0; | |
4325 | |
4326 status_type = gaim_status_get_type(status); | |
4327 primitive = gaim_status_type_get_primitive(status_type); | |
4328 presence = gaim_account_get_presence(account); | |
4329 invisible = gaim_presence_is_status_primitive_active(presence, GAIM_STATUS_INVISIBLE); | |
4330 | |
4331 if (!setinfo) | |
4332 { | |
4333 /* Do nothing! */ | |
4334 } | |
4335 else if (od->rights.maxsiglen == 0) | |
4336 { | |
4337 gaim_notify_warning(gc, NULL, _("Unable to set AIM profile."), | |
4338 _("You have probably requested to set your " | |
4339 "profile before the login procedure completed. " | |
4340 "Your profile remains unset; try setting it " | |
4341 "again when you are fully connected.")); | |
4342 } | |
4343 else if (rawinfo != NULL) | |
4344 { | |
4345 htmlinfo = gaim_strdup_withhtml(rawinfo); | |
4346 info = gaim_prpl_oscar_convert_to_infotext(htmlinfo, &infolen, &info_encoding); | |
4347 g_free(htmlinfo); | |
4348 | |
4349 if (infolen > od->rights.maxsiglen) | |
4350 { | |
4351 gchar *errstr; | |
4352 errstr = g_strdup_printf(ngettext("The maximum profile length of %d byte " | |
4353 "has been exceeded. Gaim has truncated it for you.", | |
4354 "The maximum profile length of %d bytes " | |
4355 "has been exceeded. Gaim has truncated it for you.", | |
4356 od->rights.maxsiglen), od->rights.maxsiglen); | |
4357 gaim_notify_warning(gc, NULL, _("Profile too long."), errstr); | |
4358 g_free(errstr); | |
4359 } | |
4360 } | |
4361 | |
4362 if (!setstatus) | |
4363 { | |
4364 /* Do nothing! */ | |
4365 } | |
4366 else if (primitive == GAIM_STATUS_AVAILABLE) | |
4367 { | |
4368 const char *status_html; | |
4369 char *status_text = NULL; | |
4370 | |
4371 status_html = gaim_status_get_attr_string(status, "message"); | |
4372 if (status_html != NULL) | |
4373 { | |
4374 status_text = gaim_markup_strip_html(status_html); | |
4375 /* If the status_text is longer than 60 character then truncate it */ | |
4376 if (strlen(status_text) > 60) | |
4377 { | |
4378 char *tmp = g_utf8_find_prev_char(status_text, &status_text[58]); | |
4379 strcpy(tmp, "..."); | |
4380 } | |
4381 } | |
4382 | |
4383 aim_srv_setstatusmsg(od, status_text); | |
4384 g_free(status_text); | |
4385 | |
4386 /* This is needed for us to un-set any previous away message. */ | |
4387 away = g_strdup(""); | |
4388 } | |
4389 else if ((primitive == GAIM_STATUS_AWAY) || | |
4390 (primitive == GAIM_STATUS_EXTENDED_AWAY)) | |
4391 { | |
4392 htmlaway = gaim_status_get_attr_string(status, "message"); | |
4393 if ((htmlaway == NULL) || (*htmlaway == '\0')) | |
4394 htmlaway = _("Away"); | |
4395 away = gaim_prpl_oscar_convert_to_infotext(htmlaway, &awaylen, &away_encoding); | |
4396 | |
4397 if (awaylen > od->rights.maxawaymsglen) | |
4398 { | |
4399 gchar *errstr; | |
4400 | |
4401 errstr = g_strdup_printf(ngettext("The maximum away message length of %d byte " | |
4402 "has been exceeded. Gaim has truncated it for you.", | |
4403 "The maximum away message length of %d bytes " | |
4404 "has been exceeded. Gaim has truncated it for you.", | |
4405 od->rights.maxawaymsglen), od->rights.maxawaymsglen); | |
4406 gaim_notify_warning(gc, NULL, _("Away message too long."), errstr); | |
4407 g_free(errstr); | |
4408 } | |
4409 } | |
4410 | |
4411 if (setstatus) | |
4412 oscar_set_extendedstatus(gc); | |
4413 | |
4414 aim_locate_setprofile(od, info_encoding, info, MIN(infolen, od->rights.maxsiglen), | |
4415 away_encoding, away, MIN(awaylen, od->rights.maxawaymsglen)); | |
4416 g_free(info); | |
4417 g_free(away); | |
4418 } | |
4419 | |
4420 static void | |
4421 oscar_set_status_icq(GaimAccount *account, GaimStatus *status) | |
4422 { | |
4423 GaimConnection *gc = gaim_account_get_connection(account); | |
4424 OscarData *od = NULL; | |
4425 | |
4426 if (gc) | |
4427 od = (OscarData *)gc->proto_data; | |
4428 if (!od) | |
4429 return; | |
4430 | |
4431 if (gaim_status_type_get_primitive(gaim_status_get_type(status)) == GAIM_STATUS_INVISIBLE) | |
4432 account->perm_deny = GAIM_PRIVACY_ALLOW_USERS; | |
4433 else | |
4434 account->perm_deny = GAIM_PRIVACY_DENY_USERS; | |
4435 | |
4436 if ((od->ssi.received_data) && (aim_ssi_getpermdeny(od->ssi.local) != account->perm_deny)) | |
4437 aim_ssi_setpermdeny(od, account->perm_deny, 0xffffffff); | |
4438 | |
4439 oscar_set_extendedstatus(gc); | |
4440 } | |
4441 | |
14968 | 4442 void |
14192 | 4443 oscar_set_status(GaimAccount *account, GaimStatus *status) |
4444 { | |
4445 gaim_debug_info("oscar", "Set status to %s\n", gaim_status_get_name(status)); | |
4446 | |
4447 if (!gaim_status_is_active(status)) | |
4448 return; | |
4449 | |
4450 if (!gaim_account_is_connected(account)) | |
4451 return; | |
4452 | |
4453 /* Set the AIM-style away message for both AIM and ICQ accounts */ | |
4454 oscar_set_info_and_status(account, FALSE, NULL, TRUE, status); | |
4455 | |
4456 /* Set the ICQ status for ICQ accounts only */ | |
4457 if (aim_sn_is_icq(gaim_account_get_username(account))) | |
4458 oscar_set_status_icq(account, status); | |
4459 } | |
4460 | |
4461 #ifdef CRAZY_WARN | |
14968 | 4462 void |
14192 | 4463 oscar_warn(GaimConnection *gc, const char *name, gboolean anonymous) { |
4464 OscarData *od = (OscarData *)gc->proto_data; | |
4465 aim_im_warn(od, od->conn, name, anonymous ? AIM_WARN_ANON : 0); | |
4466 } | |
4467 #endif | |
4468 | |
14968 | 4469 void |
14192 | 4470 oscar_add_buddy(GaimConnection *gc, GaimBuddy *buddy, GaimGroup *group) { |
4471 OscarData *od = (OscarData *)gc->proto_data; | |
4472 | |
4473 if (!aim_snvalid(buddy->name)) { | |
4474 gchar *buf; | |
4475 buf = g_strdup_printf(_("Could not add the buddy %s because the screen name is invalid. Screen names must either start with a letter and contain only letters, numbers and spaces, or contain only numbers."), buddy->name); | |
4476 if (!gaim_conv_present_error(buddy->name, gaim_connection_get_account(gc), buf)) | |
4477 gaim_notify_error(gc, NULL, _("Unable To Add"), buf); | |
4478 g_free(buf); | |
4479 | |
4480 /* Remove from local list */ | |
4481 gaim_blist_remove_buddy(buddy); | |
4482 | |
4483 return; | |
4484 } | |
4485 | |
4486 if ((od->ssi.received_data) && !(aim_ssi_itemlist_finditem(od->ssi.local, group->name, buddy->name, AIM_SSI_TYPE_BUDDY))) { | |
4487 gaim_debug_info("oscar", | |
4488 "ssi: adding buddy %s to group %s\n", buddy->name, group->name); | |
4489 aim_ssi_addbuddy(od, buddy->name, group->name, gaim_buddy_get_alias_only(buddy), NULL, NULL, 0); | |
4490 } | |
4491 | |
4492 /* XXX - Should this be done from AIM accounts, as well? */ | |
4493 if (od->icq) | |
4494 aim_icq_getalias(od, buddy->name); | |
4495 } | |
4496 | |
14968 | 4497 void oscar_remove_buddy(GaimConnection *gc, GaimBuddy *buddy, GaimGroup *group) { |
14192 | 4498 OscarData *od = (OscarData *)gc->proto_data; |
4499 | |
4500 if (od->ssi.received_data) { | |
4501 gaim_debug_info("oscar", | |
4502 "ssi: deleting buddy %s from group %s\n", buddy->name, group->name); | |
4503 aim_ssi_delbuddy(od, buddy->name, group->name); | |
4504 } | |
4505 } | |
4506 | |
14968 | 4507 void oscar_move_buddy(GaimConnection *gc, const char *name, const char *old_group, const char *new_group) { |
14192 | 4508 OscarData *od = (OscarData *)gc->proto_data; |
4509 if (od->ssi.received_data && strcmp(old_group, new_group)) { | |
4510 gaim_debug_info("oscar", | |
4511 "ssi: moving buddy %s from group %s to group %s\n", name, old_group, new_group); | |
4512 aim_ssi_movebuddy(od, old_group, new_group, name); | |
4513 } | |
4514 } | |
4515 | |
14968 | 4516 void oscar_alias_buddy(GaimConnection *gc, const char *name, const char *alias) { |
14192 | 4517 OscarData *od = (OscarData *)gc->proto_data; |
4518 if (od->ssi.received_data) { | |
4519 char *gname = aim_ssi_itemlist_findparentname(od->ssi.local, name); | |
4520 if (gname) { | |
4521 gaim_debug_info("oscar", | |
4522 "ssi: changing the alias for buddy %s to %s\n", name, alias ? alias : "(none)"); | |
4523 aim_ssi_aliasbuddy(od, gname, name, alias); | |
4524 } | |
4525 } | |
4526 } | |
4527 | |
4528 /* | |
4529 * FYI, the OSCAR SSI code removes empty groups automatically. | |
4530 */ | |
14968 | 4531 void oscar_rename_group(GaimConnection *gc, const char *old_name, GaimGroup *group, GList *moved_buddies) { |
14192 | 4532 OscarData *od = (OscarData *)gc->proto_data; |
4533 | |
4534 if (od->ssi.received_data) { | |
4535 if (aim_ssi_itemlist_finditem(od->ssi.local, group->name, NULL, AIM_SSI_TYPE_GROUP)) { | |
4536 GList *cur, *groups = NULL; | |
4537 GaimAccount *account = gaim_connection_get_account(gc); | |
4538 | |
4539 /* Make a list of what the groups each buddy is in */ | |
4540 for (cur = moved_buddies; cur != NULL; cur = cur->next) { | |
4541 GaimBlistNode *node = cur->data; | |
4542 /* node is GaimBuddy, parent is a GaimContact. | |
4543 * We must go two levels up to get the Group */ | |
4544 groups = g_list_append(groups, | |
4545 node->parent->parent); | |
4546 } | |
4547 | |
4548 gaim_account_remove_buddies(account, moved_buddies, groups); | |
4549 gaim_account_add_buddies(account, moved_buddies); | |
4550 g_list_free(groups); | |
4551 gaim_debug_info("oscar", | |
4552 "ssi: moved all buddies from group %s to %s\n", old_name, group->name); | |
4553 } else { | |
4554 aim_ssi_rename_group(od, old_name, group->name); | |
4555 gaim_debug_info("oscar", | |
4556 "ssi: renamed group %s to %s\n", old_name, group->name); | |
4557 } | |
4558 } | |
4559 } | |
4560 | |
4561 static gboolean gaim_ssi_rerequestdata(gpointer data) { | |
4562 OscarData *od = data; | |
4563 | |
4564 aim_ssi_reqdata(od); | |
4565 | |
4566 return TRUE; | |
4567 } | |
4568 | |
4569 static int gaim_ssi_parseerr(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
4570 GaimConnection *gc = od->gc; | |
4571 va_list ap; | |
4572 guint16 reason; | |
4573 | |
4574 va_start(ap, fr); | |
4575 reason = (guint16)va_arg(ap, unsigned int); | |
4576 va_end(ap); | |
4577 | |
4578 gaim_debug_error("oscar", "ssi: SNAC error %hu\n", reason); | |
4579 | |
4580 if (reason == 0x0005) { | |
4581 gaim_notify_error(gc, NULL, _("Unable To Retrieve Buddy List"), | |
4582 _("Gaim was temporarily unable to retrieve your buddy list from the AIM servers. Your buddy list is not lost, and will probably become available in a few hours.")); | |
4583 if (od->getblisttimer > 0) | |
4584 gaim_timeout_remove(od->getblisttimer); | |
4585 od->getblisttimer = gaim_timeout_add(30000, gaim_ssi_rerequestdata, od); | |
4586 } | |
4587 | |
4588 oscar_set_extendedstatus(gc); | |
4589 | |
4590 /* Activate SSI */ | |
4591 /* Sending the enable causes other people to be able to see you, and you to see them */ | |
4592 /* Make sure your privacy setting/invisibility is set how you want it before this! */ | |
4593 gaim_debug_info("oscar", "ssi: activating server-stored buddy list\n"); | |
4594 aim_ssi_enable(od); | |
4595 | |
4596 return 1; | |
4597 } | |
4598 | |
4599 static int gaim_ssi_parserights(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
4600 int i; | |
4601 va_list ap; | |
4602 int numtypes; | |
4603 guint16 *maxitems; | |
4604 | |
4605 va_start(ap, fr); | |
4606 numtypes = va_arg(ap, int); | |
4607 maxitems = va_arg(ap, guint16 *); | |
4608 va_end(ap); | |
4609 | |
4610 gaim_debug_misc("oscar", "ssi rights:"); | |
4611 | |
4612 for (i=0; i<numtypes; i++) | |
4613 gaim_debug_misc(NULL, " max type 0x%04x=%hd,", | |
4614 i, maxitems[i]); | |
4615 | |
4616 gaim_debug_misc(NULL, "\n"); | |
4617 | |
4618 if (numtypes >= 0) | |
4619 od->rights.maxbuddies = maxitems[0]; | |
4620 if (numtypes >= 1) | |
4621 od->rights.maxgroups = maxitems[1]; | |
4622 if (numtypes >= 2) | |
4623 od->rights.maxpermits = maxitems[2]; | |
4624 if (numtypes >= 3) | |
4625 od->rights.maxdenies = maxitems[3]; | |
4626 | |
4627 return 1; | |
4628 } | |
4629 | |
4630 static int gaim_ssi_parselist(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) | |
4631 { | |
4632 GaimConnection *gc; | |
4633 GaimAccount *account; | |
4634 GaimGroup *g; | |
4635 GaimBuddy *b; | |
4636 struct aim_ssi_item *curitem; | |
4637 guint32 tmp; | |
4638 va_list ap; | |
4639 guint16 fmtver, numitems; | |
4640 guint32 timestamp; | |
4641 | |
4642 gc = od->gc; | |
4643 od = gc->proto_data; | |
4644 account = gaim_connection_get_account(gc); | |
4645 | |
4646 va_start(ap, fr); | |
4647 fmtver = (guint16)va_arg(ap, int); | |
4648 numitems = (guint16)va_arg(ap, int); | |
4649 timestamp = va_arg(ap, guint32); | |
4650 va_end(ap); | |
4651 | |
4652 /* Don't attempt to re-request our buddy list later */ | |
4653 if (od->getblisttimer != 0) | |
4654 gaim_timeout_remove(od->getblisttimer); | |
4655 od->getblisttimer = 0; | |
4656 | |
4657 gaim_debug_info("oscar", | |
4658 "ssi: syncing local list and server list\n"); | |
4659 | |
4660 if ((timestamp == 0) || (numitems == 0)) { | |
4661 gaim_debug_info("oscar", "Got AIM SSI with a 0 timestamp or 0 numitems--not syncing. This probably means your buddy list is empty.", NULL); | |
4662 return 1; | |
4663 } | |
4664 | |
4665 /* Clean the buddy list */ | |
4666 aim_ssi_cleanlist(od); | |
4667 | |
4668 { /* If not in server list then prune from local list */ | |
4669 GaimBlistNode *gnode, *cnode, *bnode; | |
4670 GaimBuddyList *blist; | |
4671 GSList *cur, *next; | |
4672 | |
4673 /* Buddies */ | |
4674 cur = NULL; | |
4675 if ((blist = gaim_get_blist()) != NULL) { | |
4676 for (gnode = blist->root; gnode; gnode = gnode->next) { | |
4677 if(!GAIM_BLIST_NODE_IS_GROUP(gnode)) | |
4678 continue; | |
4679 g = (GaimGroup *)gnode; | |
4680 for (cnode = gnode->child; cnode; cnode = cnode->next) { | |
4681 if(!GAIM_BLIST_NODE_IS_CONTACT(cnode)) | |
4682 continue; | |
4683 for (bnode = cnode->child; bnode; bnode = bnode->next) { | |
4684 if(!GAIM_BLIST_NODE_IS_BUDDY(bnode)) | |
4685 continue; | |
4686 b = (GaimBuddy *)bnode; | |
4687 if (b->account == gc->account) { | |
4688 if (aim_ssi_itemlist_exists(od->ssi.local, b->name)) { | |
4689 /* If the buddy is an ICQ user then load his nickname */ | |
4690 const char *servernick = gaim_blist_node_get_string((GaimBlistNode*)b, "servernick"); | |
4691 char *alias; | |
4692 if (servernick) | |
4693 serv_got_alias(gc, b->name, servernick); | |
4694 | |
4695 /* Store local alias on server */ | |
4696 alias = aim_ssi_getalias(od->ssi.local, g->name, b->name); | |
4697 if (!alias && b->alias && strlen(b->alias)) | |
4698 aim_ssi_aliasbuddy(od, g->name, b->name, b->alias); | |
4699 g_free(alias); | |
4700 } else { | |
4701 gaim_debug_info("oscar", | |
4702 "ssi: removing buddy %s from local list\n", b->name); | |
4703 /* We can't actually remove now because it will screw up our looping */ | |
4704 cur = g_slist_prepend(cur, b); | |
4705 } | |
4706 } | |
4707 } | |
4708 } | |
4709 } | |
4710 } | |
4711 | |
4712 while (cur != NULL) { | |
4713 b = cur->data; | |
4714 cur = g_slist_remove(cur, b); | |
4715 gaim_blist_remove_buddy(b); | |
4716 } | |
4717 | |
4718 /* Permit list */ | |
4719 if (gc->account->permit) { | |
4720 next = gc->account->permit; | |
4721 while (next != NULL) { | |
4722 cur = next; | |
4723 next = next->next; | |
4724 if (!aim_ssi_itemlist_finditem(od->ssi.local, NULL, cur->data, AIM_SSI_TYPE_PERMIT)) { | |
4725 gaim_debug_info("oscar", | |
4726 "ssi: removing permit %s from local list\n", (const char *)cur->data); | |
4727 gaim_privacy_permit_remove(account, cur->data, TRUE); | |
4728 } | |
4729 } | |
4730 } | |
4731 | |
4732 /* Deny list */ | |
4733 if (gc->account->deny) { | |
4734 next = gc->account->deny; | |
4735 while (next != NULL) { | |
4736 cur = next; | |
4737 next = next->next; | |
4738 if (!aim_ssi_itemlist_finditem(od->ssi.local, NULL, cur->data, AIM_SSI_TYPE_DENY)) { | |
4739 gaim_debug_info("oscar", | |
4740 "ssi: removing deny %s from local list\n", (const char *)cur->data); | |
4741 gaim_privacy_deny_remove(account, cur->data, TRUE); | |
4742 } | |
4743 } | |
4744 } | |
4745 /* Presence settings (idle time visibility) */ | |
4746 if ((tmp = aim_ssi_getpresence(od->ssi.local)) != 0xFFFFFFFF) | |
4747 if (!(tmp & 0x400)) | |
4748 aim_ssi_setpresence(od, tmp | 0x400); | |
4749 } /* end pruning buddies from local list */ | |
4750 | |
4751 /* Add from server list to local list */ | |
4752 for (curitem=od->ssi.local; curitem; curitem=curitem->next) { | |
4753 if ((curitem->name == NULL) || (g_utf8_validate(curitem->name, -1, NULL))) | |
4754 switch (curitem->type) { | |
4755 case 0x0000: { /* Buddy */ | |
4756 if (curitem->name) { | |
4757 char *gname = aim_ssi_itemlist_findparentname(od->ssi.local, curitem->name); | |
4758 char *gname_utf8 = gname ? oscar_utf8_try_convert(gc->account, gname) : NULL; | |
4759 char *alias = aim_ssi_getalias(od->ssi.local, gname, curitem->name); | |
4760 char *alias_utf8; | |
4761 | |
4762 if (alias != NULL) | |
4763 { | |
4764 if (g_utf8_validate(alias, -1, NULL)) | |
4765 alias_utf8 = g_strdup(alias); | |
4766 else | |
4767 alias_utf8 = oscar_utf8_try_convert(account, alias); | |
4768 } | |
4769 else | |
4770 alias_utf8 = NULL; | |
4771 | |
4772 b = gaim_find_buddy(gc->account, curitem->name); | |
4773 /* Should gname be freed here? -- elb */ | |
4774 /* Not with the current code, but that might be cleaner -- med */ | |
4775 g_free(alias); | |
4776 if (b) { | |
4777 /* Get server stored alias */ | |
4778 if (alias_utf8) { | |
4779 g_free(b->alias); | |
4780 b->alias = g_strdup(alias_utf8); | |
4781 } | |
4782 } else { | |
4783 b = gaim_buddy_new(gc->account, curitem->name, alias_utf8); | |
4784 | |
4785 if (!(g = gaim_find_group(gname_utf8 ? gname_utf8 : _("Orphans")))) { | |
4786 g = gaim_group_new(gname_utf8 ? gname_utf8 : _("Orphans")); | |
4787 gaim_blist_add_group(g, NULL); | |
4788 } | |
4789 | |
4790 gaim_debug_info("oscar", | |
4791 "ssi: adding buddy %s to group %s to local list\n", curitem->name, gname_utf8 ? gname_utf8 : _("Orphans")); | |
4792 gaim_blist_add_buddy(b, NULL, g, NULL); | |
4793 } | |
4794 if (!aim_sncmp(curitem->name, account->username)) { | |
4795 char *comment = aim_ssi_getcomment(od->ssi.local, gname, curitem->name); | |
14552 | 4796 if (comment != NULL) |
4797 { | |
4798 gaim_check_comment(od, comment); | |
4799 g_free(comment); | |
4800 } | |
14192 | 4801 } |
4802 g_free(gname_utf8); | |
4803 g_free(alias_utf8); | |
4804 } | |
4805 } break; | |
4806 | |
4807 case 0x0001: { /* Group */ | |
4808 /* Shouldn't add empty groups */ | |
4809 } break; | |
4810 | |
4811 case 0x0002: { /* Permit buddy */ | |
4812 if (curitem->name) { | |
4813 /* if (!find_permdeny_by_name(gc->permit, curitem->name)) { AAA */ | |
4814 GSList *list; | |
4815 for (list=account->permit; (list && aim_sncmp(curitem->name, list->data)); list=list->next); | |
4816 if (!list) { | |
4817 gaim_debug_info("oscar", | |
4818 "ssi: adding permit buddy %s to local list\n", curitem->name); | |
4819 gaim_privacy_permit_add(account, curitem->name, TRUE); | |
4820 } | |
4821 } | |
4822 } break; | |
4823 | |
4824 case 0x0003: { /* Deny buddy */ | |
4825 if (curitem->name) { | |
4826 GSList *list; | |
4827 for (list=account->deny; (list && aim_sncmp(curitem->name, list->data)); list=list->next); | |
4828 if (!list) { | |
4829 gaim_debug_info("oscar", | |
4830 "ssi: adding deny buddy %s to local list\n", curitem->name); | |
4831 gaim_privacy_deny_add(account, curitem->name, TRUE); | |
4832 } | |
4833 } | |
4834 } break; | |
4835 | |
4836 case 0x0004: { /* Permit/deny setting */ | |
4837 if (curitem->data) { | |
4838 guint8 permdeny; | |
4839 if ((permdeny = aim_ssi_getpermdeny(od->ssi.local)) && (permdeny != account->perm_deny)) { | |
4840 gaim_debug_info("oscar", | |
4841 "ssi: changing permdeny from %d to %hhu\n", account->perm_deny, permdeny); | |
4842 account->perm_deny = permdeny; | |
4843 if (od->icq && account->perm_deny == GAIM_PRIVACY_ALLOW_USERS) { | |
4844 gaim_presence_set_status_active(account->presence, OSCAR_STATUS_ID_INVISIBLE, TRUE); | |
4845 } | |
4846 } | |
4847 } | |
4848 } break; | |
4849 | |
4850 case 0x0005: { /* Presence setting */ | |
4851 /* We don't want to change Gaim's setting because it applies to all accounts */ | |
4852 } break; | |
4853 } /* End of switch on curitem->type */ | |
4854 } /* End of for loop */ | |
4855 | |
4856 oscar_set_extendedstatus(gc); | |
4857 | |
4858 /* Activate SSI */ | |
4859 /* Sending the enable causes other people to be able to see you, and you to see them */ | |
4860 /* Make sure your privacy setting/invisibility is set how you want it before this! */ | |
4861 gaim_debug_info("oscar", | |
4862 "ssi: activating server-stored buddy list\n"); | |
4863 aim_ssi_enable(od); | |
4864 | |
4865 return 1; | |
4866 } | |
4867 | |
4868 static int gaim_ssi_parseack(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
4869 GaimConnection *gc = od->gc; | |
4870 va_list ap; | |
4871 struct aim_ssi_tmp *retval; | |
4872 | |
4873 va_start(ap, fr); | |
4874 retval = va_arg(ap, struct aim_ssi_tmp *); | |
4875 va_end(ap); | |
4876 | |
4877 while (retval) { | |
4878 gaim_debug_misc("oscar", | |
4879 "ssi: status is 0x%04hx for a 0x%04hx action with name %s\n", retval->ack, retval->action, retval->item ? (retval->item->name ? retval->item->name : "no name") : "no item"); | |
4880 | |
4881 if (retval->ack != 0xffff) | |
4882 switch (retval->ack) { | |
4883 case 0x0000: { /* added successfully */ | |
4884 } break; | |
4885 | |
4886 case 0x000c: { /* you are over the limit, the cheat is to the limit, come on fhqwhgads */ | |
4887 gchar *buf; | |
4888 buf = g_strdup_printf(_("Could not add the buddy %s because you have too many buddies in your buddy list. Please remove one and try again."), (retval->name ? retval->name : _("(no name)"))); | |
4889 if ((retval->name != NULL) && !gaim_conv_present_error(retval->name, gaim_connection_get_account(gc), buf)) | |
4890 gaim_notify_error(gc, NULL, _("Unable To Add"), buf); | |
4891 g_free(buf); | |
4892 } | |
4893 | |
4894 case 0x000e: { /* buddy requires authorization */ | |
4895 if ((retval->action == SNAC_SUBTYPE_FEEDBAG_ADD) && (retval->name)) | |
4896 gaim_auth_sendrequest(gc, retval->name); | |
4897 } break; | |
4898 | |
4899 default: { /* La la la */ | |
4900 gchar *buf; | |
4901 gaim_debug_error("oscar", "ssi: Action 0x%04hx was unsuccessful with error 0x%04hx\n", retval->action, retval->ack); | |
4902 buf = g_strdup_printf(_("Could not add the buddy %s for an unknown reason. The most common reason for this is that you have the maximum number of allowed buddies in your buddy list."), (retval->name ? retval->name : _("(no name)"))); | |
4903 if ((retval->name != NULL) && !gaim_conv_present_error(retval->name, gaim_connection_get_account(gc), buf)) | |
4904 gaim_notify_error(gc, NULL, _("Unable To Add"), buf); | |
4905 g_free(buf); | |
4906 } break; | |
4907 } | |
4908 | |
4909 retval = retval->next; | |
4910 } | |
4911 | |
4912 return 1; | |
4913 } | |
4914 | |
4915 static int gaim_ssi_parseadd(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
4916 GaimConnection *gc = od->gc; | |
4917 char *gname, *gname_utf8, *alias, *alias_utf8; | |
4918 GaimBuddy *b; | |
4919 GaimGroup *g; | |
4920 va_list ap; | |
4921 guint16 type; | |
4922 const char *name; | |
4923 | |
4924 va_start(ap, fr); | |
4925 type = (guint16)va_arg(ap, int); | |
4926 name = va_arg(ap, char *); | |
4927 va_end(ap); | |
4928 | |
4929 if ((type != 0x0000) || (name == NULL)) | |
4930 return 1; | |
4931 | |
4932 gname = aim_ssi_itemlist_findparentname(od->ssi.local, name); | |
4933 gname_utf8 = gname ? oscar_utf8_try_convert(gc->account, gname) : NULL; | |
4934 | |
4935 alias = aim_ssi_getalias(od->ssi.local, gname, name); | |
4936 if (alias != NULL) | |
4937 { | |
4938 if (g_utf8_validate(alias, -1, NULL)) | |
4939 alias_utf8 = g_strdup(alias); | |
4940 else | |
4941 alias_utf8 = oscar_utf8_try_convert(gaim_connection_get_account(gc), alias); | |
4942 } | |
4943 else | |
4944 alias_utf8 = NULL; | |
4945 | |
4946 b = gaim_find_buddy(gc->account, name); | |
4947 g_free(alias); | |
4948 | |
4949 if (b) { | |
4950 /* Get server stored alias */ | |
4951 if (alias_utf8) { | |
4952 g_free(b->alias); | |
4953 b->alias = g_strdup(alias_utf8); | |
4954 } | |
4955 } else { | |
4956 b = gaim_buddy_new(gc->account, name, alias_utf8); | |
4957 | |
4958 if (!(g = gaim_find_group(gname_utf8 ? gname_utf8 : _("Orphans")))) { | |
4959 g = gaim_group_new(gname_utf8 ? gname_utf8 : _("Orphans")); | |
4960 gaim_blist_add_group(g, NULL); | |
4961 } | |
4962 | |
4963 gaim_debug_info("oscar", | |
4964 "ssi: adding buddy %s to group %s to local list\n", name, gname_utf8 ? gname_utf8 : _("Orphans")); | |
4965 gaim_blist_add_buddy(b, NULL, g, NULL); | |
4966 } | |
4967 g_free(gname_utf8); | |
4968 g_free(alias_utf8); | |
4969 | |
4970 return 1; | |
4971 } | |
4972 | |
4973 static int gaim_ssi_authgiven(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
4974 GaimConnection *gc = od->gc; | |
4975 va_list ap; | |
4976 char *sn, *msg; | |
4977 gchar *dialog_msg, *nombre; | |
4978 struct name_data *data; | |
4979 GaimBuddy *buddy; | |
4980 | |
4981 va_start(ap, fr); | |
4982 sn = va_arg(ap, char *); | |
4983 msg = va_arg(ap, char *); | |
4984 va_end(ap); | |
4985 | |
4986 gaim_debug_info("oscar", | |
4987 "ssi: %s has given you permission to add him to your buddy list\n", sn); | |
4988 | |
4989 buddy = gaim_find_buddy(gc->account, sn); | |
4990 if (buddy && (gaim_buddy_get_alias_only(buddy))) | |
4991 nombre = g_strdup_printf("%s (%s)", sn, gaim_buddy_get_alias_only(buddy)); | |
4992 else | |
4993 nombre = g_strdup(sn); | |
4994 | |
4995 dialog_msg = g_strdup_printf(_("The user %s has given you permission to add you to their buddy list. Do you want to add them?"), nombre); | |
4996 data = g_new(struct name_data, 1); | |
4997 data->gc = gc; | |
4998 data->name = g_strdup(sn); | |
4999 data->nick = NULL; | |
5000 | |
5001 gaim_request_yes_no(gc, NULL, _("Authorization Given"), dialog_msg, | |
5002 GAIM_DEFAULT_ACTION_NONE, data, | |
5003 G_CALLBACK(gaim_icq_buddyadd), | |
5004 G_CALLBACK(oscar_free_name_data)); | |
5005 | |
5006 g_free(dialog_msg); | |
5007 g_free(nombre); | |
5008 | |
5009 return 1; | |
5010 } | |
5011 | |
5012 static int gaim_ssi_authrequest(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
5013 GaimConnection *gc = od->gc; | |
5014 va_list ap; | |
5015 char *sn; | |
5016 char *msg; | |
5017 GaimAccount *account = gaim_connection_get_account(gc); | |
5018 gchar *nombre; | |
5019 gchar *reason = NULL; | |
5020 struct name_data *data; | |
5021 GaimBuddy *buddy; | |
5022 | |
5023 va_start(ap, fr); | |
5024 sn = va_arg(ap, char *); | |
5025 msg = va_arg(ap, char *); | |
5026 va_end(ap); | |
5027 | |
5028 gaim_debug_info("oscar", | |
5029 "ssi: received authorization request from %s\n", sn); | |
5030 | |
5031 buddy = gaim_find_buddy(account, sn); | |
5032 if (buddy && (gaim_buddy_get_alias_only(buddy))) | |
5033 nombre = g_strdup_printf("%s (%s)", sn, gaim_buddy_get_alias_only(buddy)); | |
5034 else | |
5035 nombre = g_strdup(sn); | |
5036 | |
5037 if (msg != NULL) | |
5038 reason = gaim_plugin_oscar_decode_im_part(account, sn, AIM_CHARSET_CUSTOM, 0x0000, msg, strlen(msg)); | |
5039 | |
5040 data = g_new(struct name_data, 1); | |
5041 data->gc = gc; | |
5042 data->name = g_strdup(sn); | |
5043 data->nick = NULL; | |
5044 | |
15080 | 5045 gaim_account_request_authorization(account, nombre, |
5046 NULL, NULL, reason, G_CALLBACK(gaim_auth_grant), | |
5047 G_CALLBACK(gaim_auth_dontgrant_msgprompt), data); | |
14192 | 5048 g_free(nombre); |
15057 | 5049 g_free(reason); |
14192 | 5050 |
5051 return 1; | |
5052 } | |
5053 | |
5054 static int gaim_ssi_authreply(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
5055 GaimConnection *gc = od->gc; | |
5056 va_list ap; | |
5057 char *sn, *msg; | |
5058 gchar *dialog_msg, *nombre; | |
5059 guint8 reply; | |
5060 GaimBuddy *buddy; | |
5061 | |
5062 va_start(ap, fr); | |
5063 sn = va_arg(ap, char *); | |
5064 reply = (guint8)va_arg(ap, int); | |
5065 msg = va_arg(ap, char *); | |
5066 va_end(ap); | |
5067 | |
5068 gaim_debug_info("oscar", | |
5069 "ssi: received authorization reply from %s. Reply is 0x%04hhx\n", sn, reply); | |
5070 | |
5071 buddy = gaim_find_buddy(gc->account, sn); | |
5072 if (buddy && (gaim_buddy_get_alias_only(buddy))) | |
5073 nombre = g_strdup_printf("%s (%s)", sn, gaim_buddy_get_alias_only(buddy)); | |
5074 else | |
5075 nombre = g_strdup(sn); | |
5076 | |
5077 if (reply) { | |
5078 /* Granted */ | |
5079 dialog_msg = g_strdup_printf(_("The user %s has granted your request to add them to your buddy list."), nombre); | |
5080 gaim_notify_info(gc, NULL, _("Authorization Granted"), dialog_msg); | |
5081 } else { | |
5082 /* Denied */ | |
5083 dialog_msg = g_strdup_printf(_("The user %s has denied your request to add them to your buddy list for the following reason:\n%s"), nombre, msg ? msg : _("No reason given.")); | |
5084 gaim_notify_info(gc, NULL, _("Authorization Denied"), dialog_msg); | |
5085 } | |
5086 g_free(dialog_msg); | |
5087 g_free(nombre); | |
5088 | |
5089 return 1; | |
5090 } | |
5091 | |
5092 static int gaim_ssi_gotadded(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
5093 GaimConnection *gc = od->gc; | |
5094 va_list ap; | |
5095 char *sn; | |
5096 GaimBuddy *buddy; | |
5097 | |
5098 va_start(ap, fr); | |
5099 sn = va_arg(ap, char *); | |
5100 va_end(ap); | |
5101 | |
5102 buddy = gaim_find_buddy(gc->account, sn); | |
5103 gaim_debug_info("oscar", "ssi: %s added you to their buddy list\n", sn); | |
5104 gaim_account_notify_added(gc->account, sn, NULL, (buddy ? gaim_buddy_get_alias_only(buddy) : NULL), NULL); | |
5105 | |
5106 return 1; | |
5107 } | |
5108 | |
14968 | 5109 GList *oscar_chat_info(GaimConnection *gc) { |
14192 | 5110 GList *m = NULL; |
5111 struct proto_chat_entry *pce; | |
5112 | |
5113 pce = g_new0(struct proto_chat_entry, 1); | |
5114 pce->label = _("_Room:"); | |
5115 pce->identifier = "room"; | |
5116 pce->required = TRUE; | |
5117 m = g_list_append(m, pce); | |
5118 | |
5119 pce = g_new0(struct proto_chat_entry, 1); | |
5120 pce->label = _("_Exchange:"); | |
5121 pce->identifier = "exchange"; | |
5122 pce->required = TRUE; | |
5123 pce->is_int = TRUE; | |
5124 pce->min = 4; | |
5125 pce->max = 20; | |
5126 m = g_list_append(m, pce); | |
5127 | |
5128 return m; | |
5129 } | |
5130 | |
14968 | 5131 GHashTable *oscar_chat_info_defaults(GaimConnection *gc, const char *chat_name) |
14192 | 5132 { |
5133 GHashTable *defaults; | |
5134 | |
5135 defaults = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free); | |
5136 | |
5137 if (chat_name != NULL) | |
5138 g_hash_table_insert(defaults, "room", g_strdup(chat_name)); | |
5139 | |
5140 return defaults; | |
5141 } | |
5142 | |
14968 | 5143 char * |
14192 | 5144 oscar_get_chat_name(GHashTable *data) |
5145 { | |
5146 return g_strdup(g_hash_table_lookup(data, "room")); | |
5147 } | |
5148 | |
14968 | 5149 void |
14192 | 5150 oscar_join_chat(GaimConnection *gc, GHashTable *data) |
5151 { | |
5152 OscarData *od = (OscarData *)gc->proto_data; | |
5153 FlapConnection *conn; | |
5154 char *name, *exchange; | |
5155 | |
5156 name = g_hash_table_lookup(data, "room"); | |
5157 exchange = g_hash_table_lookup(data, "exchange"); | |
5158 | |
5159 if ((name == NULL) || (*name == '\0')) { | |
5160 gaim_notify_error(gc, NULL, _("Invalid chat name specified."), NULL); | |
5161 return; | |
5162 } | |
5163 | |
5164 gaim_debug_info("oscar", "Attempting to join chat room %s.\n", name); | |
5165 | |
5166 if ((conn = flap_connection_getbytype(od, SNAC_FAMILY_CHATNAV))) | |
5167 { | |
5168 gaim_debug_info("oscar", "chatnav exists, creating room\n"); | |
5169 aim_chatnav_createroom(od, conn, name, atoi(exchange)); | |
5170 } else { | |
5171 /* this gets tricky */ | |
5172 struct create_room *cr = g_new0(struct create_room, 1); | |
5173 gaim_debug_info("oscar", "chatnav does not exist, opening chatnav\n"); | |
5174 cr->exchange = atoi(exchange); | |
5175 cr->name = g_strdup(name); | |
14348 | 5176 od->create_rooms = g_slist_prepend(od->create_rooms, cr); |
15085 | 5177 aim_srv_requestnew(od, SNAC_FAMILY_CHATNAV); |
14192 | 5178 } |
5179 } | |
5180 | |
14968 | 5181 void |
14192 | 5182 oscar_chat_invite(GaimConnection *gc, int id, const char *message, const char *name) |
5183 { | |
5184 OscarData *od = (OscarData *)gc->proto_data; | |
5185 struct chat_connection *ccon = find_oscar_chat(gc, id); | |
5186 | |
5187 if (ccon == NULL) | |
5188 return; | |
5189 | |
5190 aim_im_sendch2_chatinvite(od, name, message ? message : "", | |
5191 ccon->exchange, ccon->name, 0x0); | |
5192 } | |
5193 | |
14968 | 5194 void |
14192 | 5195 oscar_chat_leave(GaimConnection *gc, int id) |
5196 { | |
5197 GaimConversation *conv; | |
5198 struct chat_connection *cc; | |
5199 | |
5200 conv = gaim_find_chat(gc, id); | |
5201 | |
5202 g_return_if_fail(conv != NULL); | |
5203 | |
5204 gaim_debug_info("oscar", "Leaving chat room %s\n", conv->name); | |
5205 | |
5206 cc = find_oscar_chat(gc, gaim_conv_chat_get_id(GAIM_CONV_CHAT(conv))); | |
5207 oscar_chat_kill(gc, cc); | |
5208 } | |
5209 | |
14968 | 5210 int oscar_send_chat(GaimConnection *gc, int id, const char *message, GaimMessageFlags flags) { |
14192 | 5211 OscarData *od = (OscarData *)gc->proto_data; |
5212 GaimConversation *conv = NULL; | |
5213 struct chat_connection *c = NULL; | |
5214 char *buf, *buf2; | |
5215 guint16 charset, charsubset; | |
5216 char *charsetstr = NULL; | |
5217 int len; | |
5218 | |
5219 if (!(conv = gaim_find_chat(gc, id))) | |
5220 return -EINVAL; | |
5221 | |
5222 if (!(c = find_oscar_chat_by_conv(gc, conv))) | |
5223 return -EINVAL; | |
5224 | |
5225 buf = gaim_strdup_withhtml(message); | |
5226 len = strlen(buf); | |
5227 | |
5228 if (strstr(buf, "<IMG ")) | |
5229 gaim_conversation_write(conv, "", | |
5230 _("Your IM Image was not sent. " | |
5231 "You cannot send IM Images in AIM chats."), | |
5232 GAIM_MESSAGE_ERROR, time(NULL)); | |
5233 | |
5234 gaim_plugin_oscar_convert_to_best_encoding(gc, NULL, buf, &buf2, &len, &charset, &charsubset); | |
5235 /* | |
5236 * Evan S. suggested that maxvis really does mean "number of | |
5237 * visible characters" and not "number of bytes" | |
5238 */ | |
5239 if ((len > c->maxlen) || (len > c->maxvis)) { | |
5240 g_free(buf2); | |
5241 return -E2BIG; | |
5242 } | |
5243 | |
5244 if (charset == AIM_CHARSET_ASCII) | |
5245 charsetstr = "us-ascii"; | |
5246 else if (charset == AIM_CHARSET_UNICODE) | |
5247 charsetstr = "unicode-2-0"; | |
5248 else if (charset == AIM_CHARSET_CUSTOM) | |
5249 charsetstr = "iso-8859-1"; | |
5250 aim_chat_send_im(od, c->conn, 0, buf2, len, charsetstr, "en"); | |
5251 g_free(buf2); | |
5252 | |
5253 return 0; | |
5254 } | |
5255 | |
14968 | 5256 const char *oscar_list_icon_icq(GaimAccount *a, GaimBuddy *b) |
5257 { | |
5258 if ((b == NULL) || (b->name == NULL) || aim_sn_is_sms(b->name)) | |
5259 { | |
5260 if (a == NULL || aim_sn_is_icq(gaim_account_get_username(a))) | |
5261 return "icq"; | |
5262 else | |
5263 return "aim"; | |
5264 } | |
5265 | |
5266 if (aim_sn_is_icq(b->name)) | |
5267 return "icq"; | |
5268 return "aim"; | |
5269 } | |
5270 | |
5271 const char *oscar_list_icon_aim(GaimAccount *a, GaimBuddy *b) | |
14192 | 5272 { |
5273 if ((b == NULL) || (b->name == NULL) || aim_sn_is_sms(b->name)) | |
5274 { | |
5275 if (a != NULL && aim_sn_is_icq(gaim_account_get_username(a))) | |
5276 return "icq"; | |
5277 else | |
5278 return "aim"; | |
5279 } | |
5280 | |
5281 if (aim_sn_is_icq(b->name)) | |
5282 return "icq"; | |
5283 return "aim"; | |
5284 } | |
5285 | |
14968 | 5286 void oscar_list_emblems(GaimBuddy *b, const char **se, const char **sw, const char **nw, const char **ne) |
14192 | 5287 { |
5288 GaimConnection *gc = NULL; | |
5289 OscarData *od = NULL; | |
5290 GaimAccount *account = NULL; | |
5291 GaimPresence *presence; | |
5292 GaimStatus *status; | |
5293 const char *status_id; | |
5294 char *emblems[4] = {NULL,NULL,NULL,NULL}; | |
5295 int i = 0; | |
5296 aim_userinfo_t *userinfo = NULL; | |
5297 | |
5298 account = b->account; | |
5299 if (account != NULL) | |
5300 gc = account->gc; | |
5301 if (gc != NULL) | |
5302 od = gc->proto_data; | |
5303 if (od != NULL) | |
5304 userinfo = aim_locate_finduserinfo(od, b->name); | |
5305 | |
5306 presence = gaim_buddy_get_presence(b); | |
5307 status = gaim_presence_get_active_status(presence); | |
5308 status_id = gaim_status_get_id(status); | |
5309 | |
5310 if (gaim_presence_is_online(presence) == FALSE) { | |
5311 char *gname; | |
5312 if ((b->name) && (od) && (od->ssi.received_data) && | |
5313 (gname = aim_ssi_itemlist_findparentname(od->ssi.local, b->name)) && | |
5314 (aim_ssi_waitingforauth(od->ssi.local, gname, b->name))) { | |
5315 emblems[i++] = "notauthorized"; | |
5316 } else { | |
5317 emblems[i++] = "offline"; | |
5318 } | |
5319 } | |
5320 | |
5321 if (b->name && aim_sn_is_icq(b->name)) { | |
5322 if (!strcmp(status_id, OSCAR_STATUS_ID_INVISIBLE)) | |
5323 emblems[i++] = "invisible"; | |
5324 else if (!strcmp(status_id, OSCAR_STATUS_ID_FREE4CHAT)) | |
5325 emblems[i++] = "freeforchat"; | |
5326 else if (!strcmp(status_id, OSCAR_STATUS_ID_DND)) | |
5327 emblems[i++] = "dnd"; | |
5328 else if (!strcmp(status_id, OSCAR_STATUS_ID_NA)) | |
5329 emblems[i++] = "unavailable"; | |
5330 else if (!strcmp(status_id, OSCAR_STATUS_ID_OCCUPIED)) | |
5331 emblems[i++] = "occupied"; | |
5332 else if (!strcmp(status_id, OSCAR_STATUS_ID_AWAY)) | |
5333 emblems[i++] = "away"; | |
5334 } else if (!strcmp(status_id, OSCAR_STATUS_ID_AWAY)) { | |
5335 emblems[i++] = "away"; | |
5336 } | |
5337 | |
5338 if (userinfo != NULL ) { | |
5339 /* if (userinfo->flags & AIM_FLAG_UNCONFIRMED) | |
5340 emblems[i++] = "unconfirmed"; */ | |
5341 if ((i < 4) && userinfo->flags & AIM_FLAG_ADMINISTRATOR) | |
5342 emblems[i++] = "admin"; | |
5343 if ((i < 4) && userinfo->flags & AIM_FLAG_AOL) | |
5344 emblems[i++] = "aol"; | |
5345 if ((i < 4) && userinfo->flags & AIM_FLAG_WIRELESS) | |
5346 emblems[i++] = "wireless"; | |
5347 if ((i < 4) && userinfo->flags & AIM_FLAG_ACTIVEBUDDY) | |
5348 emblems[i++] = "activebuddy"; | |
5349 | |
5350 if ((i < 4) && (userinfo->capabilities & OSCAR_CAPABILITY_HIPTOP)) | |
5351 emblems[i++] = "hiptop"; | |
5352 | |
5353 if ((i < 4) && (userinfo->capabilities & OSCAR_CAPABILITY_SECUREIM)) | |
5354 emblems[i++] = "secure"; | |
5355 } | |
5356 | |
5357 *se = emblems[0]; | |
5358 *sw = emblems[1]; | |
5359 *nw = emblems[2]; | |
5360 *ne = emblems[3]; | |
5361 } | |
5362 | |
14968 | 5363 void oscar_tooltip_text(GaimBuddy *b, GString *str, gboolean full) { |
14192 | 5364 GaimConnection *gc = b->account->gc; |
5365 OscarData *od = gc->proto_data; | |
5366 aim_userinfo_t *userinfo = aim_locate_finduserinfo(od, b->name); | |
5367 | |
5368 if (GAIM_BUDDY_IS_ONLINE(b)) { | |
5369 GaimPresence *presence; | |
5370 GaimStatus *status; | |
5371 const char *message; | |
5372 | |
5373 if (full) | |
5374 oscar_string_append_info(gc, str, "\n", b, userinfo); | |
5375 | |
5376 presence = gaim_buddy_get_presence(b); | |
5377 status = gaim_presence_get_active_status(presence); | |
5378 message = gaim_status_get_attr_string(status, "message"); | |
5379 | |
5380 if (gaim_status_is_available(status)) | |
5381 { | |
5382 if (message != NULL) | |
5383 { | |
5384 /* Available status messages are plain text */ | |
5385 gchar *tmp; | |
5386 tmp = g_markup_escape_text(message, -1); | |
5387 g_string_append_printf(str, "\n<b>%s:</b> %s", _("Message"), tmp); | |
5388 g_free(tmp); | |
5389 } | |
5390 } | |
5391 else | |
5392 { | |
5393 if (message != NULL) | |
5394 { | |
5395 /* Away messages are HTML */ | |
5396 gchar *tmp1, *tmp2; | |
5397 tmp2 = gaim_markup_strip_html(message); | |
5398 tmp1 = g_markup_escape_text(tmp2, -1); | |
5399 g_free(tmp2); | |
5400 tmp2 = gaim_str_sub_away_formatters(tmp1, gaim_account_get_username(gaim_connection_get_account(gc))); | |
5401 g_free(tmp1); | |
5402 g_string_append_printf(str, "\n<b>%s:</b> %s", _("Message"), tmp2); | |
5403 g_free(tmp2); | |
5404 } | |
5405 else | |
5406 { | |
5407 g_string_append_printf(str, "\n<b>%s:</b> %s", _("Message"), _("<i>(retrieving)</i>")); | |
5408 } | |
5409 } | |
5410 } | |
5411 } | |
5412 | |
14968 | 5413 char *oscar_status_text(GaimBuddy *b) |
14192 | 5414 { |
5415 GaimConnection *gc; | |
5416 GaimAccount *account; | |
5417 OscarData *od; | |
5418 const GaimPresence *presence; | |
5419 const GaimStatus *status; | |
5420 const char *id; | |
5421 const char *message; | |
5422 gchar *ret = NULL; | |
5423 | |
5424 gc = gaim_account_get_connection(gaim_buddy_get_account(b)); | |
5425 account = gaim_connection_get_account(gc); | |
5426 od = gc->proto_data; | |
5427 presence = gaim_buddy_get_presence(b); | |
5428 status = gaim_presence_get_active_status(presence); | |
5429 id = gaim_status_get_id(status); | |
5430 | |
5431 if (!gaim_presence_is_online(presence)) | |
5432 { | |
5433 char *gname = aim_ssi_itemlist_findparentname(od->ssi.local, b->name); | |
5434 if (aim_ssi_waitingforauth(od->ssi.local, gname, b->name)) | |
5435 ret = g_strdup(_("Not Authorized")); | |
5436 else | |
5437 ret = g_strdup(_("Offline")); | |
5438 } | |
5439 else if (gaim_status_is_available(status) && !strcmp(id, OSCAR_STATUS_ID_AVAILABLE)) | |
5440 { | |
5441 /* Available */ | |
5442 message = gaim_status_get_attr_string(status, "message"); | |
5443 if (message != NULL) | |
5444 { | |
5445 ret = g_markup_escape_text(message, -1); | |
5446 gaim_util_chrreplace(ret, '\n', ' '); | |
5447 } | |
5448 } | |
5449 else if (!gaim_status_is_available(status) && !strcmp(id, OSCAR_STATUS_ID_AWAY)) | |
5450 { | |
5451 /* Away */ | |
5452 message = gaim_status_get_attr_string(status, "message"); | |
5453 if (message != NULL) | |
5454 { | |
5455 gchar *tmp1, *tmp2; | |
5456 tmp1 = gaim_markup_strip_html(message); | |
5457 gaim_util_chrreplace(tmp1, '\n', ' '); | |
5458 tmp2 = g_markup_escape_text(tmp1, -1); | |
5459 ret = gaim_str_sub_away_formatters(tmp2, gaim_account_get_username(account)); | |
5460 g_free(tmp1); | |
5461 g_free(tmp2); | |
5462 } | |
5463 else | |
5464 { | |
5465 ret = g_strdup(_("Away")); | |
5466 } | |
5467 } | |
5468 else | |
5469 ret = g_strdup(gaim_status_get_name(status)); | |
5470 | |
5471 return ret; | |
5472 } | |
5473 | |
5474 | |
5475 static int oscar_icon_req(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) { | |
5476 GaimConnection *gc = od->gc; | |
5477 va_list ap; | |
5478 guint16 type; | |
5479 guint8 flags = 0, length = 0; | |
5480 guchar *md5 = NULL; | |
5481 | |
5482 va_start(ap, fr); | |
5483 type = va_arg(ap, int); | |
5484 | |
5485 switch(type) { | |
5486 case 0x0000: | |
5487 case 0x0001: { | |
5488 flags = va_arg(ap, int); | |
5489 length = va_arg(ap, int); | |
5490 md5 = va_arg(ap, guchar *); | |
5491 | |
5492 if (flags == 0x41) { | |
5493 if (!flap_connection_getbytype(od, SNAC_FAMILY_BART) && !od->iconconnecting) { | |
5494 od->iconconnecting = TRUE; | |
5495 od->set_icon = TRUE; | |
15085 | 5496 aim_srv_requestnew(od, SNAC_FAMILY_BART); |
14192 | 5497 } else { |
5498 struct stat st; | |
5499 char *iconfile = gaim_buddy_icons_get_full_path(gaim_account_get_buddy_icon(gaim_connection_get_account(gc))); | |
5500 if (iconfile == NULL) { | |
5501 aim_ssi_delicon(od); | |
5502 } else if (!g_stat(iconfile, &st)) { | |
5503 guchar *buf = g_malloc(st.st_size); | |
5504 FILE *file = g_fopen(iconfile, "rb"); | |
5505 if (file) { | |
5506 /* XXX - Use g_file_get_contents()? */ | |
5507 fread(buf, 1, st.st_size, file); | |
5508 fclose(file); | |
5509 gaim_debug_info("oscar", | |
5510 "Uploading icon to icon server\n"); | |
5511 aim_bart_upload(od, buf, st.st_size); | |
5512 } else | |
5513 gaim_debug_error("oscar", | |
5514 "Can't open buddy icon file!\n"); | |
5515 g_free(buf); | |
5516 } else { | |
5517 gaim_debug_error("oscar", | |
5518 "Can't stat buddy icon file!\n"); | |
5519 } | |
5520 g_free(iconfile); | |
5521 } | |
5522 } else if (flags == 0x81) { | |
5523 char *iconfile = gaim_buddy_icons_get_full_path(gaim_account_get_buddy_icon(gaim_connection_get_account(gc))); | |
5524 if (iconfile == NULL) | |
5525 aim_ssi_delicon(od); | |
5526 else { | |
5527 aim_ssi_seticon(od, md5, length); | |
5528 g_free(iconfile); | |
5529 } | |
5530 } | |
5531 } break; | |
5532 | |
5533 case 0x0002: { /* We just set an "available" message? */ | |
5534 } break; | |
5535 } | |
5536 | |
5537 va_end(ap); | |
5538 | |
5539 return 0; | |
5540 } | |
5541 | |
14968 | 5542 void oscar_set_permit_deny(GaimConnection *gc) { |
14192 | 5543 GaimAccount *account = gaim_connection_get_account(gc); |
5544 OscarData *od = (OscarData *)gc->proto_data; | |
5545 | |
5546 if (od->ssi.received_data) { | |
5547 switch (account->perm_deny) { | |
5548 case GAIM_PRIVACY_ALLOW_ALL: | |
5549 aim_ssi_setpermdeny(od, 0x01, 0xffffffff); | |
5550 break; | |
5551 case GAIM_PRIVACY_ALLOW_BUDDYLIST: | |
5552 aim_ssi_setpermdeny(od, 0x05, 0xffffffff); | |
5553 break; | |
5554 case GAIM_PRIVACY_ALLOW_USERS: | |
5555 aim_ssi_setpermdeny(od, 0x03, 0xffffffff); | |
5556 break; | |
5557 case GAIM_PRIVACY_DENY_ALL: | |
5558 aim_ssi_setpermdeny(od, 0x02, 0xffffffff); | |
5559 break; | |
5560 case GAIM_PRIVACY_DENY_USERS: | |
5561 aim_ssi_setpermdeny(od, 0x04, 0xffffffff); | |
5562 break; | |
5563 default: | |
5564 aim_ssi_setpermdeny(od, 0x01, 0xffffffff); | |
5565 break; | |
5566 } | |
5567 } | |
5568 } | |
5569 | |
14968 | 5570 void oscar_add_permit(GaimConnection *gc, const char *who) { |
14192 | 5571 OscarData *od = (OscarData *)gc->proto_data; |
5572 gaim_debug_info("oscar", "ssi: About to add a permit\n"); | |
5573 if (od->ssi.received_data) | |
5574 aim_ssi_addpermit(od, who); | |
5575 } | |
5576 | |
14968 | 5577 void oscar_add_deny(GaimConnection *gc, const char *who) { |
14192 | 5578 OscarData *od = (OscarData *)gc->proto_data; |
5579 gaim_debug_info("oscar", "ssi: About to add a deny\n"); | |
5580 if (od->ssi.received_data) | |
5581 aim_ssi_adddeny(od, who); | |
5582 } | |
5583 | |
14968 | 5584 void oscar_rem_permit(GaimConnection *gc, const char *who) { |
14192 | 5585 OscarData *od = (OscarData *)gc->proto_data; |
5586 gaim_debug_info("oscar", "ssi: About to delete a permit\n"); | |
5587 if (od->ssi.received_data) | |
5588 aim_ssi_delpermit(od, who); | |
5589 } | |
5590 | |
14968 | 5591 void oscar_rem_deny(GaimConnection *gc, const char *who) { |
14192 | 5592 OscarData *od = (OscarData *)gc->proto_data; |
5593 gaim_debug_info("oscar", "ssi: About to delete a deny\n"); | |
5594 if (od->ssi.received_data) | |
5595 aim_ssi_deldeny(od, who); | |
5596 } | |
5597 | |
14968 | 5598 GList * |
14192 | 5599 oscar_status_types(GaimAccount *account) |
5600 { | |
5601 gboolean is_icq; | |
5602 GList *status_types = NULL; | |
5603 GaimStatusType *type; | |
5604 | |
5605 g_return_val_if_fail(account != NULL, NULL); | |
5606 | |
5607 /* Used to flag some statuses as "user settable" or not */ | |
5608 is_icq = aim_sn_is_icq(gaim_account_get_username(account)); | |
5609 | |
5610 /* Common status types */ | |
5611 /* Really the available message should only be settable for AIM accounts */ | |
5612 type = gaim_status_type_new_with_attrs(GAIM_STATUS_AVAILABLE, | |
5613 OSCAR_STATUS_ID_AVAILABLE, | |
5614 NULL, TRUE, TRUE, FALSE, | |
5615 "message", _("Message"), | |
5616 gaim_value_new(GAIM_TYPE_STRING), NULL); | |
14348 | 5617 status_types = g_list_prepend(status_types, type); |
14192 | 5618 |
5619 type = gaim_status_type_new_full(GAIM_STATUS_AVAILABLE, | |
5620 OSCAR_STATUS_ID_FREE4CHAT, | |
5621 _("Free For Chat"), TRUE, is_icq, FALSE); | |
14348 | 5622 status_types = g_list_prepend(status_types, type); |
14192 | 5623 |
5624 type = gaim_status_type_new_with_attrs(GAIM_STATUS_AWAY, | |
5625 OSCAR_STATUS_ID_AWAY, | |
5626 NULL, TRUE, TRUE, FALSE, | |
5627 "message", _("Message"), | |
5628 gaim_value_new(GAIM_TYPE_STRING), NULL); | |
14348 | 5629 status_types = g_list_prepend(status_types, type); |
14192 | 5630 |
5631 type = gaim_status_type_new_full(GAIM_STATUS_INVISIBLE, | |
5632 OSCAR_STATUS_ID_INVISIBLE, | |
5633 NULL, TRUE, TRUE, FALSE); | |
14348 | 5634 status_types = g_list_prepend(status_types, type); |
14192 | 5635 |
5636 /* ICQ-specific status types */ | |
5637 type = gaim_status_type_new_with_attrs(GAIM_STATUS_UNAVAILABLE, | |
5638 OSCAR_STATUS_ID_OCCUPIED, | |
5639 _("Occupied"), TRUE, is_icq, FALSE, | |
5640 "message", _("Message"), | |
5641 gaim_value_new(GAIM_TYPE_STRING), NULL); | |
14348 | 5642 status_types = g_list_prepend(status_types, type); |
14192 | 5643 |
5644 type = gaim_status_type_new_with_attrs(GAIM_STATUS_EXTENDED_AWAY, | |
5645 OSCAR_STATUS_ID_DND, | |
5646 _("Do Not Disturb"), TRUE, is_icq, FALSE, | |
5647 "message", _("Message"), | |
5648 gaim_value_new(GAIM_TYPE_STRING), NULL); | |
14348 | 5649 status_types = g_list_prepend(status_types, type); |
14192 | 5650 |
5651 type = gaim_status_type_new_with_attrs(GAIM_STATUS_EXTENDED_AWAY, | |
5652 OSCAR_STATUS_ID_NA, | |
5653 _("Not Available"), TRUE, is_icq, FALSE, | |
5654 "message", _("Message"), | |
5655 gaim_value_new(GAIM_TYPE_STRING), NULL); | |
14348 | 5656 status_types = g_list_prepend(status_types, type); |
14192 | 5657 |
5658 type = gaim_status_type_new_full(GAIM_STATUS_OFFLINE, | |
5659 OSCAR_STATUS_ID_OFFLINE, | |
5660 NULL, TRUE, TRUE, FALSE); | |
14348 | 5661 status_types = g_list_prepend(status_types, type); |
5662 | |
5663 status_types = g_list_reverse(status_types); | |
14192 | 5664 |
5665 return status_types; | |
5666 } | |
5667 | |
5668 static void oscar_ssi_editcomment(struct name_data *data, const char *text) { | |
5669 GaimConnection *gc = data->gc; | |
5670 OscarData *od = gc->proto_data; | |
5671 GaimBuddy *b; | |
5672 GaimGroup *g; | |
5673 | |
5674 if (!(b = gaim_find_buddy(gaim_connection_get_account(data->gc), data->name))) { | |
5675 oscar_free_name_data(data); | |
5676 return; | |
5677 } | |
5678 | |
5679 if (!(g = gaim_buddy_get_group(b))) { | |
5680 oscar_free_name_data(data); | |
5681 return; | |
5682 } | |
5683 | |
5684 aim_ssi_editcomment(od, g->name, data->name, text); | |
5685 | |
5686 if (!aim_sncmp(data->name, gc->account->username)) | |
5687 gaim_check_comment(od, text); | |
5688 | |
5689 oscar_free_name_data(data); | |
5690 } | |
5691 | |
5692 static void oscar_buddycb_edit_comment(GaimBlistNode *node, gpointer ignore) { | |
5693 | |
5694 GaimBuddy *buddy; | |
5695 GaimConnection *gc; | |
5696 OscarData *od; | |
5697 struct name_data *data; | |
5698 GaimGroup *g; | |
5699 char *comment; | |
5700 gchar *comment_utf8; | |
5701 gchar *title; | |
5702 | |
5703 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node)); | |
5704 | |
5705 buddy = (GaimBuddy *) node; | |
5706 gc = gaim_account_get_connection(buddy->account); | |
5707 od = gc->proto_data; | |
5708 | |
5709 data = g_new(struct name_data, 1); | |
5710 | |
5711 if (!(g = gaim_buddy_get_group(buddy))) | |
5712 return; | |
5713 comment = aim_ssi_getcomment(od->ssi.local, g->name, buddy->name); | |
5714 comment_utf8 = comment ? oscar_utf8_try_convert(gc->account, comment) : NULL; | |
5715 | |
5716 data->gc = gc; | |
5717 data->name = g_strdup(buddy->name); | |
5718 data->nick = NULL; | |
5719 | |
5720 title = g_strdup_printf(_("Buddy Comment for %s"), data->name); | |
5721 gaim_request_input(gc, title, _("Buddy Comment:"), NULL, | |
5722 comment_utf8, TRUE, FALSE, NULL, | |
5723 _("OK"), G_CALLBACK(oscar_ssi_editcomment), | |
5724 _("Cancel"), G_CALLBACK(oscar_free_name_data), | |
5725 data); | |
5726 g_free(title); | |
5727 | |
5728 g_free(comment); | |
5729 g_free(comment_utf8); | |
5730 } | |
5731 | |
5732 static void | |
5733 oscar_ask_directim_yes_cb(struct oscar_ask_directim_data *data) | |
5734 { | |
5735 peer_connection_propose(data->od, OSCAR_CAPABILITY_DIRECTIM, data->who); | |
5736 g_free(data->who); | |
5737 g_free(data); | |
5738 } | |
5739 | |
5740 static void | |
5741 oscar_ask_directim_no_cb(struct oscar_ask_directim_data *data) | |
5742 { | |
5743 g_free(data->who); | |
5744 g_free(data); | |
5745 } | |
5746 | |
5747 /* This is called from right-click menu on a buddy node. */ | |
5748 static void | |
5749 oscar_ask_directim(gpointer object, gpointer ignored) | |
5750 { | |
5751 GaimBlistNode *node; | |
5752 GaimBuddy *buddy; | |
5753 GaimConnection *gc; | |
5754 gchar *buf; | |
5755 struct oscar_ask_directim_data *data; | |
5756 | |
5757 node = object; | |
5758 | |
5759 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node)); | |
5760 | |
5761 buddy = (GaimBuddy *)node; | |
5762 gc = gaim_account_get_connection(buddy->account); | |
5763 | |
5764 data = g_new0(struct oscar_ask_directim_data, 1); | |
5765 data->who = g_strdup(buddy->name); | |
5766 data->od = gc->proto_data; | |
5767 buf = g_strdup_printf(_("You have selected to open a Direct IM connection with %s."), | |
5768 buddy->name); | |
5769 | |
5770 gaim_request_action(gc, NULL, buf, | |
5771 _("Because this reveals your IP address, it " | |
5772 "may be considered a security risk. Do you " | |
5773 "wish to continue?"), | |
5774 0, data, 2, | |
5775 _("_Connect"), G_CALLBACK(oscar_ask_directim_yes_cb), | |
5776 _("Cancel"), G_CALLBACK(oscar_ask_directim_no_cb)); | |
5777 g_free(buf); | |
5778 } | |
5779 | |
5780 static void | |
5781 oscar_get_aim_info_cb(GaimBlistNode *node, gpointer ignore) | |
5782 { | |
5783 GaimBuddy *buddy; | |
5784 GaimConnection *gc; | |
5785 | |
5786 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node)); | |
5787 | |
5788 buddy = (GaimBuddy *)node; | |
5789 gc = gaim_account_get_connection(buddy->account); | |
5790 | |
5791 aim_locate_getinfoshort(gc->proto_data, gaim_buddy_get_name(buddy), 0x00000003); | |
5792 } | |
5793 | |
15053 | 5794 static GList * |
5795 oscar_buddy_menu(GaimBuddy *buddy) { | |
14192 | 5796 |
5797 GaimConnection *gc; | |
5798 OscarData *od; | |
14348 | 5799 GList *menu; |
14192 | 5800 GaimMenuAction *act; |
5801 aim_userinfo_t *userinfo; | |
5802 | |
5803 gc = gaim_account_get_connection(buddy->account); | |
5804 od = gc->proto_data; | |
5805 userinfo = aim_locate_finduserinfo(od, buddy->name); | |
14348 | 5806 menu = NULL; |
14192 | 5807 |
5808 if (od->icq && aim_sn_is_icq(gaim_buddy_get_name(buddy))) | |
5809 { | |
5810 act = gaim_menu_action_new(_("Get AIM Info"), | |
5811 GAIM_CALLBACK(oscar_get_aim_info_cb), | |
5812 NULL, NULL); | |
14348 | 5813 menu = g_list_prepend(menu, act); |
14192 | 5814 } |
5815 | |
5816 act = gaim_menu_action_new(_("Edit Buddy Comment"), | |
5817 GAIM_CALLBACK(oscar_buddycb_edit_comment), | |
5818 NULL, NULL); | |
14348 | 5819 menu = g_list_prepend(menu, act); |
14192 | 5820 |
5821 #if 0 | |
5822 if (od->icq) | |
5823 { | |
5824 act = gaim_menu_action_new(_("Get Status Msg"), | |
5825 GAIM_CALLBACK(oscar_get_icqstatusmsg), | |
5826 NULL, NULL); | |
14348 | 5827 menu = g_list_prepend(menu, act); |
14192 | 5828 } |
5829 #endif | |
5830 | |
5831 if (userinfo && | |
5832 aim_sncmp(gaim_account_get_username(buddy->account), buddy->name) && | |
5833 GAIM_BUDDY_IS_ONLINE(buddy)) | |
5834 { | |
5835 if (userinfo->capabilities & OSCAR_CAPABILITY_DIRECTIM) | |
5836 { | |
5837 act = gaim_menu_action_new(_("Direct IM"), | |
5838 GAIM_CALLBACK(oscar_ask_directim), | |
5839 NULL, NULL); | |
14348 | 5840 menu = g_list_prepend(menu, act); |
14192 | 5841 } |
5842 #if 0 | |
5843 /* TODO: This menu item should be added by the core */ | |
5844 if (userinfo->capabilities & OSCAR_CAPABILITY_GETFILE) { | |
5845 act = gaim_menu_action_new(_("Get File"), | |
5846 GAIM_CALLBACK(oscar_ask_getfile), | |
5847 NULL, NULL); | |
14348 | 5848 menu = g_list_prepend(menu, act); |
14192 | 5849 } |
5850 #endif | |
5851 } | |
5852 | |
5853 if (od->ssi.received_data) | |
5854 { | |
5855 char *gname; | |
5856 gname = aim_ssi_itemlist_findparentname(od->ssi.local, buddy->name); | |
5857 if (gname && aim_ssi_waitingforauth(od->ssi.local, gname, buddy->name)) | |
5858 { | |
5859 act = gaim_menu_action_new(_("Re-request Authorization"), | |
5860 GAIM_CALLBACK(gaim_auth_sendrequest_menu), | |
5861 NULL, NULL); | |
14348 | 5862 menu = g_list_prepend(menu, act); |
14192 | 5863 } |
5864 } | |
5865 | |
14348 | 5866 menu = g_list_reverse(menu); |
5867 | |
5868 return menu; | |
14192 | 5869 } |
5870 | |
5871 | |
14968 | 5872 GList *oscar_blist_node_menu(GaimBlistNode *node) { |
14192 | 5873 if(GAIM_BLIST_NODE_IS_BUDDY(node)) { |
5874 return oscar_buddy_menu((GaimBuddy *) node); | |
5875 } else { | |
5876 return NULL; | |
5877 } | |
5878 } | |
5879 | |
5880 static void | |
5881 oscar_icq_privacy_opts(GaimConnection *gc, GaimRequestFields *fields) | |
5882 { | |
5883 OscarData *od = gc->proto_data; | |
5884 GaimAccount *account = gaim_connection_get_account(gc); | |
5885 GaimRequestField *f; | |
5886 gboolean auth, web_aware; | |
5887 | |
5888 f = gaim_request_fields_get_field(fields, "authorization"); | |
5889 auth = gaim_request_field_bool_get_value(f); | |
5890 | |
5891 f = gaim_request_fields_get_field(fields, "web_aware"); | |
5892 web_aware = gaim_request_field_bool_get_value(f); | |
5893 | |
5894 gaim_account_set_bool(account, "authorization", auth); | |
5895 gaim_account_set_bool(account, "web_aware", web_aware); | |
5896 | |
5897 oscar_set_extendedstatus(gc); | |
5898 aim_icq_setsecurity(od, auth, web_aware); | |
5899 } | |
5900 | |
5901 static void | |
5902 oscar_show_icq_privacy_opts(GaimPluginAction *action) | |
5903 { | |
5904 GaimConnection *gc = (GaimConnection *) action->context; | |
5905 GaimAccount *account = gaim_connection_get_account(gc); | |
5906 GaimRequestFields *fields; | |
5907 GaimRequestFieldGroup *g; | |
5908 GaimRequestField *f; | |
5909 gboolean auth, web_aware; | |
5910 | |
5911 auth = gaim_account_get_bool(account, "authorization", OSCAR_DEFAULT_AUTHORIZATION); | |
5912 web_aware = gaim_account_get_bool(account, "web_aware", OSCAR_DEFAULT_WEB_AWARE); | |
5913 | |
5914 fields = gaim_request_fields_new(); | |
5915 | |
5916 g = gaim_request_field_group_new(NULL); | |
5917 | |
5918 f = gaim_request_field_bool_new("authorization", _("Require authorization"), auth); | |
5919 gaim_request_field_group_add_field(g, f); | |
5920 | |
5921 f = gaim_request_field_bool_new("web_aware", _("Web aware (enabling this will cause you to receive SPAM!)"), web_aware); | |
5922 gaim_request_field_group_add_field(g, f); | |
5923 | |
5924 gaim_request_fields_add_group(fields, g); | |
5925 | |
5926 gaim_request_fields(gc, _("ICQ Privacy Options"), _("ICQ Privacy Options"), | |
5927 NULL, fields, | |
5928 _("OK"), G_CALLBACK(oscar_icq_privacy_opts), | |
5929 _("Cancel"), NULL, gc); | |
5930 } | |
5931 | |
5932 static void oscar_format_screenname(GaimConnection *gc, const char *nick) { | |
5933 OscarData *od = gc->proto_data; | |
5934 if (!aim_sncmp(gaim_account_get_username(gaim_connection_get_account(gc)), nick)) { | |
5935 if (!flap_connection_getbytype(od, SNAC_FAMILY_ADMIN)) { | |
5936 od->setnick = TRUE; | |
5937 od->newsn = g_strdup(nick); | |
15085 | 5938 aim_srv_requestnew(od, SNAC_FAMILY_ADMIN); |
14192 | 5939 } else { |
5940 aim_admin_setnick(od, flap_connection_getbytype(od, SNAC_FAMILY_ADMIN), nick); | |
5941 } | |
5942 } else { | |
5943 gaim_notify_error(gc, NULL, _("The new formatting is invalid."), | |
5944 _("Screen name formatting can change only capitalization and whitespace.")); | |
5945 } | |
5946 } | |
5947 | |
5948 static void oscar_show_format_screenname(GaimPluginAction *action) | |
5949 { | |
5950 GaimConnection *gc = (GaimConnection *) action->context; | |
5951 gaim_request_input(gc, NULL, _("New screen name formatting:"), NULL, | |
5952 gaim_connection_get_display_name(gc), FALSE, FALSE, NULL, | |
5953 _("OK"), G_CALLBACK(oscar_format_screenname), | |
5954 _("Cancel"), NULL, | |
5955 gc); | |
5956 } | |
5957 | |
5958 static void oscar_confirm_account(GaimPluginAction *action) | |
5959 { | |
5960 GaimConnection *gc; | |
5961 OscarData *od; | |
5962 FlapConnection *conn; | |
5963 | |
5964 gc = (GaimConnection *)action->context; | |
5965 od = gc->proto_data; | |
5966 | |
5967 conn = flap_connection_getbytype(od, SNAC_FAMILY_ADMIN); | |
5968 if (conn != NULL) { | |
5969 aim_admin_reqconfirm(od, conn); | |
5970 } else { | |
5971 od->conf = TRUE; | |
15085 | 5972 aim_srv_requestnew(od, SNAC_FAMILY_ADMIN); |
14192 | 5973 } |
5974 } | |
5975 | |
5976 static void oscar_show_email(GaimPluginAction *action) | |
5977 { | |
5978 GaimConnection *gc = (GaimConnection *) action->context; | |
5979 OscarData *od = gc->proto_data; | |
5980 FlapConnection *conn = flap_connection_getbytype(od, SNAC_FAMILY_ADMIN); | |
5981 | |
5982 if (conn) { | |
5983 aim_admin_getinfo(od, conn, 0x11); | |
5984 } else { | |
5985 od->reqemail = TRUE; | |
15085 | 5986 aim_srv_requestnew(od, SNAC_FAMILY_ADMIN); |
14192 | 5987 } |
5988 } | |
5989 | |
5990 static void oscar_change_email(GaimConnection *gc, const char *email) | |
5991 { | |
5992 OscarData *od = gc->proto_data; | |
5993 FlapConnection *conn = flap_connection_getbytype(od, SNAC_FAMILY_ADMIN); | |
5994 | |
5995 if (conn) { | |
5996 aim_admin_setemail(od, conn, email); | |
5997 } else { | |
5998 od->setemail = TRUE; | |
5999 od->email = g_strdup(email); | |
15085 | 6000 aim_srv_requestnew(od, SNAC_FAMILY_ADMIN); |
14192 | 6001 } |
6002 } | |
6003 | |
6004 static void oscar_show_change_email(GaimPluginAction *action) | |
6005 { | |
6006 GaimConnection *gc = (GaimConnection *) action->context; | |
6007 gaim_request_input(gc, NULL, _("Change Address To:"), NULL, NULL, | |
6008 FALSE, FALSE, NULL, | |
6009 _("OK"), G_CALLBACK(oscar_change_email), | |
6010 _("Cancel"), NULL, | |
6011 gc); | |
6012 } | |
6013 | |
6014 static void oscar_show_awaitingauth(GaimPluginAction *action) | |
6015 { | |
6016 GaimConnection *gc = (GaimConnection *) action->context; | |
6017 OscarData *od = gc->proto_data; | |
6018 gchar *nombre, *text, *tmp; | |
6019 GaimBlistNode *gnode, *cnode, *bnode; | |
6020 int num=0; | |
6021 | |
6022 text = g_strdup(""); | |
6023 | |
6024 for (gnode = gaim_get_blist()->root; gnode; gnode = gnode->next) { | |
6025 GaimGroup *group = (GaimGroup *)gnode; | |
6026 if(!GAIM_BLIST_NODE_IS_GROUP(gnode)) | |
6027 continue; | |
6028 for (cnode = gnode->child; cnode; cnode = cnode->next) { | |
6029 if(!GAIM_BLIST_NODE_IS_CONTACT(cnode)) | |
6030 continue; | |
6031 for (bnode = cnode->child; bnode; bnode = bnode->next) { | |
6032 GaimBuddy *buddy = (GaimBuddy *)bnode; | |
6033 if(!GAIM_BLIST_NODE_IS_BUDDY(bnode)) | |
6034 continue; | |
6035 if (buddy->account == gc->account && aim_ssi_waitingforauth(od->ssi.local, group->name, buddy->name)) { | |
6036 if (gaim_buddy_get_alias_only(buddy)) | |
6037 nombre = g_strdup_printf(" %s (%s)", buddy->name, gaim_buddy_get_alias_only(buddy)); | |
6038 else | |
6039 nombre = g_strdup_printf(" %s", buddy->name); | |
6040 tmp = g_strdup_printf("%s%s<br>", text, nombre); | |
6041 g_free(text); | |
6042 text = tmp; | |
6043 g_free(nombre); | |
6044 num++; | |
6045 } | |
6046 } | |
6047 } | |
6048 } | |
6049 | |
6050 if (!num) { | |
6051 g_free(text); | |
6052 text = g_strdup(_("<i>you are not waiting for authorization</i>")); | |
6053 } | |
6054 | |
6055 gaim_notify_formatted(gc, NULL, _("You are awaiting authorization from " | |
6056 "the following buddies"), _("You can re-request " | |
6057 "authorization from these buddies by " | |
6058 "right-clicking on them and selecting " | |
6059 "\"Re-request Authorization.\""), text, NULL, NULL); | |
6060 g_free(text); | |
6061 } | |
6062 | |
6063 static void search_by_email_cb(GaimConnection *gc, const char *email) | |
6064 { | |
6065 OscarData *od = (OscarData *)gc->proto_data; | |
6066 | |
6067 aim_search_address(od, email); | |
6068 } | |
6069 | |
6070 static void oscar_show_find_email(GaimPluginAction *action) | |
6071 { | |
6072 GaimConnection *gc = (GaimConnection *) action->context; | |
6073 gaim_request_input(gc, _("Find Buddy by E-Mail"), | |
6074 _("Search for a buddy by e-mail address"), | |
6075 _("Type the e-mail address of the buddy you are " | |
6076 "searching for."), | |
6077 NULL, FALSE, FALSE, NULL, | |
6078 _("Search"), G_CALLBACK(search_by_email_cb), | |
6079 _("Cancel"), NULL, gc); | |
6080 } | |
6081 | |
6082 static void oscar_show_set_info(GaimPluginAction *action) | |
6083 { | |
6084 GaimConnection *gc = (GaimConnection *) action->context; | |
6085 gaim_account_request_change_user_info(gaim_connection_get_account(gc)); | |
6086 } | |
6087 | |
6088 static void oscar_show_set_info_icqurl(GaimPluginAction *action) | |
6089 { | |
6090 GaimConnection *gc = (GaimConnection *) action->context; | |
6091 gaim_notify_uri(gc, "http://www.icq.com/whitepages/user_details.php"); | |
6092 } | |
6093 | |
6094 static void oscar_change_pass(GaimPluginAction *action) | |
6095 { | |
6096 GaimConnection *gc = (GaimConnection *) action->context; | |
6097 gaim_account_request_change_password(gaim_connection_get_account(gc)); | |
6098 } | |
6099 | |
6100 static void oscar_show_chpassurl(GaimPluginAction *action) | |
6101 { | |
6102 GaimConnection *gc = (GaimConnection *) action->context; | |
6103 OscarData *od = gc->proto_data; | |
6104 gchar *substituted = gaim_strreplace(od->authinfo->chpassurl, "%s", gaim_account_get_username(gaim_connection_get_account(gc))); | |
6105 gaim_notify_uri(gc, substituted); | |
6106 g_free(substituted); | |
6107 } | |
6108 | |
6109 static void oscar_show_imforwardingurl(GaimPluginAction *action) | |
6110 { | |
6111 GaimConnection *gc = (GaimConnection *) action->context; | |
6112 gaim_notify_uri(gc, "http://mymobile.aol.com/dbreg/register?action=imf&clientID=1"); | |
6113 } | |
6114 | |
14968 | 6115 void oscar_set_icon(GaimConnection *gc, const char *iconfile) |
14192 | 6116 { |
6117 OscarData *od = gc->proto_data; | |
6118 FILE *file; | |
6119 struct stat st; | |
6120 | |
6121 if (iconfile == NULL) { | |
6122 aim_ssi_delicon(od); | |
6123 } else if (!g_stat(iconfile, &st)) { | |
6124 guchar *buf = g_malloc(st.st_size); | |
6125 file = g_fopen(iconfile, "rb"); | |
6126 if (file) | |
6127 { | |
6128 GaimCipher *cipher; | |
6129 GaimCipherContext *context; | |
6130 guchar md5[16]; | |
6131 int len; | |
6132 | |
6133 /* XXX - Use g_file_get_contents()? */ | |
6134 len = fread(buf, 1, st.st_size, file); | |
6135 fclose(file); | |
6136 | |
6137 cipher = gaim_ciphers_find_cipher("md5"); | |
6138 context = gaim_cipher_context_new(cipher, NULL); | |
6139 gaim_cipher_context_append(context, buf, len); | |
6140 gaim_cipher_context_digest(context, 16, md5, NULL); | |
6141 gaim_cipher_context_destroy(context); | |
6142 | |
6143 aim_ssi_seticon(od, md5, 16); | |
6144 } else | |
6145 gaim_debug_error("oscar", | |
6146 "Can't open buddy icon file!\n"); | |
6147 g_free(buf); | |
6148 } else | |
6149 gaim_debug_error("oscar", "Can't stat buddy icon file!\n"); | |
6150 } | |
6151 | |
6152 /** | |
6153 * Called by the Gaim core to determine whether or not we're | |
6154 * allowed to send a file to this user. | |
6155 */ | |
14968 | 6156 gboolean |
14192 | 6157 oscar_can_receive_file(GaimConnection *gc, const char *who) |
6158 { | |
6159 OscarData *od; | |
6160 GaimAccount *account; | |
6161 | |
6162 od = gc->proto_data; | |
6163 account = gaim_connection_get_account(gc); | |
6164 | |
6165 if (od != NULL) | |
6166 { | |
6167 aim_userinfo_t *userinfo; | |
6168 userinfo = aim_locate_finduserinfo(od, who); | |
6169 | |
6170 /* | |
6171 * Don't allowing sending a file to a user that does not support | |
6172 * file transfer, and don't allow sending to ourselves. | |
6173 */ | |
6174 if (((userinfo == NULL) || | |
6175 (userinfo->capabilities & OSCAR_CAPABILITY_SENDFILE)) && | |
6176 aim_sncmp(who, gaim_account_get_username(account))) | |
6177 { | |
6178 return TRUE; | |
6179 } | |
6180 } | |
6181 | |
6182 return FALSE; | |
6183 } | |
6184 | |
14968 | 6185 GaimXfer * |
14192 | 6186 oscar_new_xfer(GaimConnection *gc, const char *who) |
6187 { | |
6188 GaimXfer *xfer; | |
6189 OscarData *od; | |
6190 GaimAccount *account; | |
6191 PeerConnection *conn; | |
6192 | |
6193 od = gc->proto_data; | |
6194 account = gaim_connection_get_account(gc); | |
6195 | |
6196 xfer = gaim_xfer_new(account, GAIM_XFER_SEND, who); | |
6197 gaim_xfer_ref(xfer); | |
6198 gaim_xfer_set_init_fnc(xfer, peer_oft_sendcb_init); | |
6199 gaim_xfer_set_cancel_send_fnc(xfer, peer_oft_cb_generic_cancel); | |
6200 gaim_xfer_set_request_denied_fnc(xfer, peer_oft_cb_generic_cancel); | |
6201 gaim_xfer_set_ack_fnc(xfer, peer_oft_sendcb_ack); | |
6202 | |
6203 conn = peer_connection_new(od, OSCAR_CAPABILITY_SENDFILE, who); | |
6204 conn->flags |= PEER_CONNECTION_FLAG_INITIATED_BY_ME; | |
6205 conn->flags |= PEER_CONNECTION_FLAG_APPROVED; | |
6206 aim_icbm_makecookie(conn->cookie); | |
6207 conn->xfer = xfer; | |
6208 xfer->data = conn; | |
6209 | |
6210 return xfer; | |
6211 } | |
6212 | |
6213 /* | |
6214 * Called by the Gaim core when the user indicates that a | |
6215 * file is to be sent to a special someone. | |
6216 */ | |
14968 | 6217 void |
14192 | 6218 oscar_send_file(GaimConnection *gc, const char *who, const char *file) |
6219 { | |
6220 GaimXfer *xfer; | |
6221 | |
6222 xfer = oscar_new_xfer(gc, who); | |
6223 | |
6224 if (file != NULL) | |
6225 gaim_xfer_request_accepted(xfer, file); | |
6226 else | |
6227 gaim_xfer_request(xfer); | |
6228 } | |
6229 | |
14968 | 6230 GList * |
14192 | 6231 oscar_actions(GaimPlugin *plugin, gpointer context) |
6232 { | |
6233 GaimConnection *gc = (GaimConnection *) context; | |
6234 OscarData *od = gc->proto_data; | |
14348 | 6235 GList *menu = NULL; |
14192 | 6236 GaimPluginAction *act; |
6237 | |
6238 act = gaim_plugin_action_new(_("Set User Info..."), | |
6239 oscar_show_set_info); | |
14348 | 6240 menu = g_list_prepend(menu, act); |
14192 | 6241 |
6242 if (od->icq) | |
6243 { | |
6244 act = gaim_plugin_action_new(_("Set User Info (URL)..."), | |
6245 oscar_show_set_info_icqurl); | |
14348 | 6246 menu = g_list_prepend(menu, act); |
14192 | 6247 } |
6248 | |
6249 act = gaim_plugin_action_new(_("Change Password..."), | |
6250 oscar_change_pass); | |
14348 | 6251 menu = g_list_prepend(menu, act); |
14192 | 6252 |
6253 if (od->authinfo->chpassurl != NULL) | |
6254 { | |
6255 act = gaim_plugin_action_new(_("Change Password (URL)"), | |
6256 oscar_show_chpassurl); | |
14348 | 6257 menu = g_list_prepend(menu, act); |
14192 | 6258 |
6259 act = gaim_plugin_action_new(_("Configure IM Forwarding (URL)"), | |
6260 oscar_show_imforwardingurl); | |
14348 | 6261 menu = g_list_prepend(menu, act); |
6262 } | |
6263 | |
6264 menu = g_list_prepend(menu, NULL); | |
14192 | 6265 |
6266 if (od->icq) | |
6267 { | |
6268 /* ICQ actions */ | |
6269 act = gaim_plugin_action_new(_("Set Privacy Options..."), | |
6270 oscar_show_icq_privacy_opts); | |
14348 | 6271 menu = g_list_prepend(menu, act); |
14192 | 6272 } |
6273 else | |
6274 { | |
6275 /* AIM actions */ | |
6276 act = gaim_plugin_action_new(_("Format Screen Name..."), | |
6277 oscar_show_format_screenname); | |
14348 | 6278 menu = g_list_prepend(menu, act); |
14192 | 6279 |
6280 act = gaim_plugin_action_new(_("Confirm Account"), | |
6281 oscar_confirm_account); | |
14348 | 6282 menu = g_list_prepend(menu, act); |
14192 | 6283 |
6284 act = gaim_plugin_action_new(_("Display Currently Registered E-Mail Address"), | |
6285 oscar_show_email); | |
14348 | 6286 menu = g_list_prepend(menu, act); |
14192 | 6287 |
6288 act = gaim_plugin_action_new(_("Change Currently Registered E-Mail Address..."), | |
6289 oscar_show_change_email); | |
14348 | 6290 menu = g_list_prepend(menu, act); |
6291 } | |
6292 | |
6293 menu = g_list_prepend(menu, NULL); | |
14192 | 6294 |
6295 act = gaim_plugin_action_new(_("Show Buddies Awaiting Authorization"), | |
6296 oscar_show_awaitingauth); | |
14348 | 6297 menu = g_list_prepend(menu, act); |
6298 | |
6299 menu = g_list_prepend(menu, NULL); | |
14192 | 6300 |
6301 act = gaim_plugin_action_new(_("Search for Buddy by E-Mail Address..."), | |
6302 oscar_show_find_email); | |
14348 | 6303 menu = g_list_prepend(menu, act); |
14192 | 6304 |
6305 #if 0 | |
6306 act = gaim_plugin_action_new(_("Search for Buddy by Information"), | |
6307 show_find_info); | |
14348 | 6308 menu = g_list_prepend(menu, act); |
14192 | 6309 #endif |
6310 | |
14348 | 6311 menu = g_list_reverse(menu); |
6312 | |
6313 return menu; | |
14192 | 6314 } |
6315 | |
14968 | 6316 void oscar_change_passwd(GaimConnection *gc, const char *old, const char *new) |
14192 | 6317 { |
6318 OscarData *od = gc->proto_data; | |
6319 | |
6320 if (od->icq) { | |
6321 aim_icq_changepasswd(od, new); | |
6322 } else { | |
6323 FlapConnection *conn; | |
6324 conn = flap_connection_getbytype(od, SNAC_FAMILY_ADMIN); | |
6325 if (conn) { | |
6326 aim_admin_changepasswd(od, conn, new, old); | |
6327 } else { | |
6328 od->chpass = TRUE; | |
6329 od->oldp = g_strdup(old); | |
6330 od->newp = g_strdup(new); | |
15085 | 6331 aim_srv_requestnew(od, SNAC_FAMILY_ADMIN); |
14192 | 6332 } |
6333 } | |
6334 } | |
6335 | |
14968 | 6336 void |
14192 | 6337 oscar_convo_closed(GaimConnection *gc, const char *who) |
6338 { | |
6339 OscarData *od; | |
6340 PeerConnection *conn; | |
6341 | |
6342 od = gc->proto_data; | |
6343 conn = peer_connection_find_by_type(od, who, OSCAR_CAPABILITY_DIRECTIM); | |
6344 | |
6345 if (conn != NULL) | |
6346 { | |
6347 if (!conn->ready) | |
6348 aim_im_sendch2_cancel(conn); | |
6349 | |
14402 | 6350 peer_connection_destroy(conn, OSCAR_DISCONNECT_LOCAL_CLOSED, NULL); |
14192 | 6351 } |
6352 } | |
6353 | |
6354 static void | |
6355 recent_buddies_cb(const char *name, GaimPrefType type, | |
6356 gconstpointer value, gpointer data) | |
6357 { | |
6358 GaimConnection *gc = data; | |
6359 OscarData *od = gc->proto_data; | |
6360 guint32 presence; | |
6361 | |
6362 presence = aim_ssi_getpresence(od->ssi.local); | |
6363 | |
6364 if (value) { | |
6365 presence &= ~AIM_SSI_PRESENCE_FLAG_NORECENTBUDDIES; | |
6366 aim_ssi_setpresence(od, presence); | |
6367 } else { | |
6368 presence |= AIM_SSI_PRESENCE_FLAG_NORECENTBUDDIES; | |
6369 aim_ssi_setpresence(od, presence); | |
6370 } | |
6371 } | |
6372 | |
6373 #ifdef USE_PRPL_PREFERENCES | |
6374 ppref = gaim_plugin_pref_new_with_name_and_label("/plugins/prpl/oscar/recent_buddies", _("Use recent buddies group")); | |
6375 gaim_plugin_pref_frame_add(frame, ppref); | |
6376 | |
6377 ppref = gaim_plugin_pref_new_with_name_and_label("/plugins/prpl/oscar/show_idle", _("Show how long you have been idle")); | |
6378 gaim_plugin_pref_frame_add(frame, ppref); | |
6379 #endif | |
6380 | |
14968 | 6381 const char * |
14192 | 6382 oscar_normalize(const GaimAccount *account, const char *str) |
6383 { | |
6384 static char buf[BUF_LEN]; | |
6385 char *tmp1, *tmp2; | |
6386 int i, j; | |
6387 | |
6388 g_return_val_if_fail(str != NULL, NULL); | |
6389 | |
6390 strncpy(buf, str, BUF_LEN); | |
6391 for (i=0, j=0; buf[j]; i++, j++) | |
6392 { | |
6393 while (buf[j] == ' ') | |
6394 j++; | |
6395 buf[i] = buf[j]; | |
6396 } | |
6397 buf[i] = '\0'; | |
6398 | |
6399 tmp1 = g_utf8_strdown(buf, -1); | |
6400 tmp2 = g_utf8_normalize(tmp1, -1, G_NORMALIZE_DEFAULT); | |
6401 g_snprintf(buf, sizeof(buf), "%s", tmp2); | |
6402 g_free(tmp2); | |
6403 g_free(tmp1); | |
6404 | |
6405 return buf; | |
6406 } | |
6407 | |
14968 | 6408 gboolean |
14192 | 6409 oscar_offline_message(const GaimBuddy *buddy) |
6410 { | |
6411 OscarData *od; | |
6412 GaimAccount *account; | |
6413 GaimConnection *gc; | |
6414 | |
6415 account = gaim_buddy_get_account(buddy); | |
6416 gc = gaim_account_get_connection(account); | |
6417 od = (OscarData *)gc->proto_data; | |
6418 | |
6419 return (od->icq && aim_sn_is_icq(gaim_account_get_username(account))); | |
6420 } | |
6421 |