Mercurial > pidgin
comparison libpurple/protocols/msn/session.c @ 20394:4a099e4d0d09
propagate from branch 'im.pidgin.pidgin' (head 98b6b547b29ea1192b73cc4e1de1e674edef4328)
to branch 'im.pidgin.rlaager.merging.msnp13-and-pidgin' (head 4d82c29e56bd33cd6f94302e343dfeb5d68ab3eb)
author | Richard Laager <rlaager@wiktel.com> |
---|---|
date | Sun, 15 Apr 2007 03:43:17 +0000 |
parents | 32c366eeeb99 |
children | 6f986caeab59 |
comparison
equal
deleted
inserted
replaced
20393:40a04930b233 | 20394:4a099e4d0d09 |
---|---|
1 /** | |
2 * @file session.c MSN session functions | |
3 * | |
4 * purple | |
5 * | |
6 * Purple is the legal property of its developers, whose names are too numerous | |
7 * to list here. Please refer to the COPYRIGHT file distributed with this | |
8 * source distribution. | |
9 * | |
10 * This program is free software; you can redistribute it and/or modify | |
11 * it under the terms of the GNU General Public License as published by | |
12 * the Free Software Foundation; either version 2 of the License, or | |
13 * (at your option) any later version. | |
14 * | |
15 * This program is distributed in the hope that it will be useful, | |
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 * GNU General Public License for more details. | |
19 * | |
20 * You should have received a copy of the GNU General Public License | |
21 * along with this program; if not, write to the Free Software | |
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
23 */ | |
24 #include "msn.h" | |
25 #include "session.h" | |
26 #include "notification.h" | |
27 | |
28 #include "dialog.h" | |
29 | |
30 MsnSession * | |
31 msn_session_new(PurpleAccount *account) | |
32 { | |
33 MsnSession *session; | |
34 | |
35 g_return_val_if_fail(account != NULL, NULL); | |
36 | |
37 session = g_new0(MsnSession, 1); | |
38 | |
39 session->account = account; | |
40 session->notification = msn_notification_new(session); | |
41 session->userlist = msn_userlist_new(session); | |
42 | |
43 session->user = msn_user_new(session->userlist, | |
44 purple_account_get_username(account), NULL); | |
45 session->bnode = NULL; | |
46 | |
47 /*if you want to chat with Yahoo Messenger*/ | |
48 //session->protocol_ver = WLM_YAHOO_PROT_VER; | |
49 session->protocol_ver = WLM_PROT_VER; | |
50 session->conv_seq = 1; | |
51 | |
52 return session; | |
53 } | |
54 | |
55 void | |
56 msn_session_destroy(MsnSession *session) | |
57 { | |
58 g_return_if_fail(session != NULL); | |
59 | |
60 session->destroying = TRUE; | |
61 | |
62 if (session->connected) | |
63 msn_session_disconnect(session); | |
64 | |
65 if (session->notification != NULL) | |
66 msn_notification_destroy(session->notification); | |
67 | |
68 while (session->switches != NULL) | |
69 msn_switchboard_destroy(session->switches->data); | |
70 | |
71 while (session->slplinks != NULL) | |
72 msn_slplink_destroy(session->slplinks->data); | |
73 | |
74 msn_userlist_destroy(session->userlist); | |
75 | |
76 g_free(session->passport_info.t); | |
77 g_free(session->passport_info.p); | |
78 g_free(session->passport_info.kv); | |
79 g_free(session->passport_info.sid); | |
80 g_free(session->passport_info.mspauth); | |
81 g_free(session->passport_info.client_ip); | |
82 | |
83 if (session->passport_info.file != NULL) | |
84 { | |
85 g_unlink(session->passport_info.file); | |
86 g_free(session->passport_info.file); | |
87 } | |
88 | |
89 if (session->sync != NULL) | |
90 msn_sync_destroy(session->sync); | |
91 | |
92 if (session->nexus != NULL) | |
93 msn_nexus_destroy(session->nexus); | |
94 | |
95 if (session->contact != NULL) | |
96 msn_contact_destroy(session->contact); | |
97 if (session->oim != NULL) | |
98 msn_oim_destroy(session->oim); | |
99 | |
100 if (session->user != NULL) | |
101 msn_user_destroy(session->user); | |
102 | |
103 g_free(session); | |
104 } | |
105 | |
106 gboolean | |
107 msn_session_connect(MsnSession *session, const char *host, int port, | |
108 gboolean http_method) | |
109 { | |
110 g_return_val_if_fail(session != NULL, FALSE); | |
111 g_return_val_if_fail(!session->connected, TRUE); | |
112 | |
113 session->connected = TRUE; | |
114 session->http_method = http_method; | |
115 | |
116 if (session->notification == NULL) | |
117 { | |
118 purple_debug_error("msn", "This shouldn't happen\n"); | |
119 g_return_val_if_reached(FALSE); | |
120 } | |
121 | |
122 if (msn_notification_connect(session->notification, host, port)) | |
123 { | |
124 return TRUE; | |
125 } | |
126 | |
127 return FALSE; | |
128 } | |
129 | |
130 void | |
131 msn_session_disconnect(MsnSession *session) | |
132 { | |
133 g_return_if_fail(session != NULL); | |
134 g_return_if_fail(session->connected); | |
135 | |
136 session->connected = FALSE; | |
137 | |
138 while (session->switches != NULL) | |
139 msn_switchboard_close(session->switches->data); | |
140 | |
141 if (session->notification != NULL) | |
142 msn_notification_close(session->notification); | |
143 } | |
144 | |
145 /* TODO: This must go away when conversation is redesigned */ | |
146 MsnSwitchBoard * | |
147 msn_session_find_swboard(MsnSession *session, const char *username) | |
148 { | |
149 GList *l; | |
150 | |
151 g_return_val_if_fail(session != NULL, NULL); | |
152 g_return_val_if_fail(username != NULL, NULL); | |
153 | |
154 for (l = session->switches; l != NULL; l = l->next) | |
155 { | |
156 MsnSwitchBoard *swboard; | |
157 | |
158 swboard = l->data; | |
159 | |
160 if ((swboard->im_user != NULL) && !strcmp(username, swboard->im_user)) | |
161 return swboard; | |
162 } | |
163 | |
164 return NULL; | |
165 } | |
166 | |
167 /*get the conversation*/ | |
168 PurpleConversation * | |
169 msn_session_get_conv(MsnSession *session,const char *passport) | |
170 { | |
171 PurpleAccount *account; | |
172 PurpleConversation * conv; | |
173 | |
174 g_return_val_if_fail(session != NULL, NULL); | |
175 account = session->account; | |
176 | |
177 conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, | |
178 passport, account); | |
179 if(conv == NULL){ | |
180 conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, passport); | |
181 } | |
182 return conv; | |
183 } | |
184 | |
185 /* put Message to User Conversation | |
186 * | |
187 * passport - the one want to talk to you | |
188 */ | |
189 void | |
190 msn_session_report_user(MsnSession *session,const char *passport,char *msg,PurpleMessageFlags flags) | |
191 { | |
192 PurpleConversation * conv; | |
193 | |
194 if ((conv = msn_session_get_conv(session,passport)) != NULL){ | |
195 purple_conversation_write(conv, NULL, msg, flags, time(NULL)); | |
196 } | |
197 } | |
198 | |
199 MsnSwitchBoard * | |
200 msn_session_find_swboard_with_conv(MsnSession *session, PurpleConversation *conv) | |
201 { | |
202 GList *l; | |
203 | |
204 g_return_val_if_fail(session != NULL, NULL); | |
205 g_return_val_if_fail(conv != NULL, NULL); | |
206 | |
207 for (l = session->switches; l != NULL; l = l->next) | |
208 { | |
209 MsnSwitchBoard *swboard; | |
210 | |
211 swboard = l->data; | |
212 | |
213 if (swboard->conv == conv) | |
214 return swboard; | |
215 } | |
216 | |
217 return NULL; | |
218 } | |
219 | |
220 MsnSwitchBoard * | |
221 msn_session_find_swboard_with_id(const MsnSession *session, int chat_id) | |
222 { | |
223 GList *l; | |
224 | |
225 g_return_val_if_fail(session != NULL, NULL); | |
226 g_return_val_if_fail(chat_id >= 0, NULL); | |
227 | |
228 for (l = session->switches; l != NULL; l = l->next) | |
229 { | |
230 MsnSwitchBoard *swboard; | |
231 | |
232 swboard = l->data; | |
233 | |
234 if (swboard->chat_id == chat_id) | |
235 return swboard; | |
236 } | |
237 | |
238 return NULL; | |
239 } | |
240 | |
241 MsnSwitchBoard * | |
242 msn_session_get_swboard(MsnSession *session, const char *username, | |
243 MsnSBFlag flag) | |
244 { | |
245 MsnSwitchBoard *swboard; | |
246 | |
247 g_return_val_if_fail(session != NULL, NULL); | |
248 | |
249 swboard = msn_session_find_swboard(session, username); | |
250 | |
251 if (swboard == NULL) | |
252 { | |
253 swboard = msn_switchboard_new(session); | |
254 swboard->im_user = g_strdup(username); | |
255 msn_switchboard_request(swboard); | |
256 msn_switchboard_request_add_user(swboard, username); | |
257 } | |
258 | |
259 swboard->flag |= flag; | |
260 | |
261 return swboard; | |
262 } | |
263 | |
264 /*setup the bnode, for MSN SOAP contact/address book op*/ | |
265 void | |
266 msn_session_set_bnode(MsnSession *session) | |
267 { | |
268 PurpleBlistNode *gnode, *cnode, *bnode; | |
269 PurpleConnection *gc = purple_account_get_connection(session->account); | |
270 | |
271 g_return_if_fail(gc != NULL); | |
272 | |
273 /* The core used to use msn_add_buddy to add all buddies before | |
274 * being logged in. This no longer happens, so we manually iterate | |
275 * over the whole buddy list to identify sync issues. */ | |
276 | |
277 for (gnode = purple_blist_get_root(); gnode; gnode = gnode->next) { | |
278 PurpleGroup *group = (PurpleGroup *)gnode; | |
279 const char *group_name = group->name; | |
280 if(!PURPLE_BLIST_NODE_IS_GROUP(gnode)) | |
281 continue; | |
282 for(cnode = gnode->child; cnode; cnode = cnode->next) { | |
283 if(!PURPLE_BLIST_NODE_IS_CONTACT(cnode)) | |
284 continue; | |
285 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
286 PurpleBuddy *b; | |
287 if(!PURPLE_BLIST_NODE_IS_BUDDY(bnode)) | |
288 continue; | |
289 b = (PurpleBuddy *)bnode; | |
290 if(b->account == gc->account){ | |
291 session->bnode = bnode; | |
292 return; | |
293 } | |
294 } | |
295 } | |
296 } | |
297 session->bnode = NULL; | |
298 } | |
299 | |
300 /*get bnode*/ | |
301 PurpleBlistNode * | |
302 msn_session_get_bnode(MsnSession *session) | |
303 { | |
304 #if 1 | |
305 return session->bnode; | |
306 #else | |
307 return purple_get_blist()->root; | |
308 #endif | |
309 } | |
310 | |
311 static void | |
312 msn_session_sync_users(MsnSession *session) | |
313 { | |
314 PurpleBlistNode *gnode, *cnode, *bnode; | |
315 PurpleConnection *gc = purple_account_get_connection(session->account); | |
316 | |
317 g_return_if_fail(gc != NULL); | |
318 | |
319 /* The core used to use msn_add_buddy to add all buddies before | |
320 * being logged in. This no longer happens, so we manually iterate | |
321 * over the whole buddy list to identify sync issues. | |
322 */ | |
323 for (gnode = purple_get_blist()->root; gnode; gnode = gnode->next) { | |
324 PurpleGroup *group = (PurpleGroup *)gnode; | |
325 const char *group_name = group->name; | |
326 if(!PURPLE_BLIST_NODE_IS_GROUP(gnode)) | |
327 continue; | |
328 if(!g_strcasecmp(group_name, MSN_INDIVIDUALS_GROUP_NAME) | |
329 || !g_strcasecmp(group_name,MSN_NON_IM_GROUP_NAME)){ | |
330 continue; | |
331 } | |
332 for(cnode = gnode->child; cnode; cnode = cnode->next) { | |
333 if(!PURPLE_BLIST_NODE_IS_CONTACT(cnode)) | |
334 continue; | |
335 for(bnode = cnode->child; bnode; bnode = bnode->next) { | |
336 PurpleBuddy *b; | |
337 if(!PURPLE_BLIST_NODE_IS_BUDDY(bnode)) | |
338 continue; | |
339 b = (PurpleBuddy *)bnode; | |
340 if(purple_buddy_get_account(b) == purple_connection_get_account(gc)) { | |
341 MsnUser *remote_user; | |
342 gboolean found = FALSE; | |
343 | |
344 remote_user = msn_userlist_find_user(session->userlist, purple_buddy_get_name(b)); | |
345 | |
346 if ((remote_user != NULL) && (remote_user->list_op & MSN_LIST_FL_OP)) | |
347 { | |
348 const char *group_id; | |
349 GList *l; | |
350 | |
351 purple_debug_info("MaYuan","remote user:{%s}\n",b->name); | |
352 group_id = msn_userlist_find_group_id(remote_user->userlist, | |
353 group_name); | |
354 if(group_id == NULL){ | |
355 continue; | |
356 } | |
357 purple_debug_info("MaYuan","group_id:{%s}\n",group_id); | |
358 | |
359 for (l = remote_user->group_ids; l != NULL; l = l->next) | |
360 { | |
361 purple_debug_info("MaYuan","l->data:{%s}\n",l->data); | |
362 if (!g_strcasecmp(group_id ,l->data)) | |
363 { | |
364 found = TRUE; | |
365 break; | |
366 } | |
367 } | |
368 } | |
369 | |
370 if (!found) | |
371 { | |
372 /* The user was not on the server list or not in that group | |
373 * on the server list */ | |
374 msn_show_sync_issue(session, b->name, group_name); | |
375 } | |
376 } | |
377 } | |
378 } | |
379 } | |
380 } | |
381 | |
382 void | |
383 msn_session_set_error(MsnSession *session, MsnErrorType error, | |
384 const char *info) | |
385 { | |
386 PurpleConnection *gc; | |
387 char *msg; | |
388 | |
389 gc = purple_account_get_connection(session->account); | |
390 | |
391 switch (error) | |
392 { | |
393 case MSN_ERROR_SERVCONN: | |
394 msg = g_strdup(info); | |
395 break; | |
396 case MSN_ERROR_UNSUPPORTED_PROTOCOL: | |
397 msg = g_strdup(_("Our protocol is not supported by the " | |
398 "server.")); | |
399 break; | |
400 case MSN_ERROR_HTTP_MALFORMED: | |
401 msg = g_strdup(_("Error parsing HTTP.")); | |
402 break; | |
403 case MSN_ERROR_SIGN_OTHER: | |
404 gc->wants_to_die = TRUE; | |
405 msg = g_strdup(_("You have signed on from another location.")); | |
406 break; | |
407 case MSN_ERROR_SERV_UNAVAILABLE: | |
408 msg = g_strdup(_("The MSN servers are temporarily " | |
409 "unavailable. Please wait and try " | |
410 "again.")); | |
411 break; | |
412 case MSN_ERROR_SERV_DOWN: | |
413 msg = g_strdup(_("The MSN servers are going down " | |
414 "temporarily.")); | |
415 break; | |
416 case MSN_ERROR_AUTH: | |
417 msg = g_strdup_printf(_("Unable to authenticate: %s"), | |
418 (info == NULL ) ? | |
419 _("Unknown error") : info); | |
420 break; | |
421 case MSN_ERROR_BAD_BLIST: | |
422 msg = g_strdup(_("Your MSN buddy list is temporarily " | |
423 "unavailable. Please wait and try " | |
424 "again.")); | |
425 break; | |
426 default: | |
427 msg = g_strdup(_("Unknown error.")); | |
428 break; | |
429 } | |
430 | |
431 msn_session_disconnect(session); | |
432 | |
433 purple_connection_error(gc, msg); | |
434 | |
435 g_free(msg); | |
436 } | |
437 | |
438 static const char * | |
439 get_login_step_text(MsnSession *session) | |
440 { | |
441 const char *steps_text[] = { | |
442 _("Connecting"), | |
443 _("Handshaking"), | |
444 _("Transferring"), | |
445 _("Handshaking"), | |
446 _("Starting authentication"), | |
447 _("Getting cookie"), | |
448 _("Authenticating"), | |
449 _("Sending cookie"), | |
450 _("Retrieving buddy list") | |
451 }; | |
452 | |
453 return steps_text[session->login_step]; | |
454 } | |
455 | |
456 void | |
457 msn_session_set_login_step(MsnSession *session, MsnLoginStep step) | |
458 { | |
459 PurpleConnection *gc; | |
460 | |
461 /* Prevent the connection progress going backwards, eg. if we get | |
462 * transferred several times during login */ | |
463 if (session->login_step > step) | |
464 return; | |
465 | |
466 /* If we're already logged in, we're probably here because of a | |
467 * mid-session XFR from the notification server, so we don't want to | |
468 * popup the connection progress dialog */ | |
469 if (session->logged_in) | |
470 return; | |
471 | |
472 gc = session->account->gc; | |
473 | |
474 session->login_step = step; | |
475 | |
476 purple_connection_update_progress(gc, get_login_step_text(session), step, | |
477 MSN_LOGIN_STEPS); | |
478 } | |
479 | |
480 void | |
481 msn_session_finish_login(MsnSession *session) | |
482 { | |
483 PurpleAccount *account; | |
484 PurpleConnection *gc; | |
485 char *icon; | |
486 | |
487 if (session->logged_in) | |
488 return; | |
489 | |
490 account = session->account; | |
491 gc = purple_account_get_connection(account); | |
492 | |
493 icon = purple_buddy_icons_get_full_path(purple_account_get_buddy_icon(session->account)); | |
494 msn_user_set_buddy_icon(session->user, icon); | |
495 g_free(icon); | |
496 | |
497 session->logged_in = TRUE; | |
498 | |
499 msn_change_status(session); | |
500 | |
501 purple_connection_set_state(gc, PURPLE_CONNECTED); | |
502 | |
503 /* Sync users */ | |
504 msn_session_sync_users(session); | |
505 } | |
506 |