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