Mercurial > pidgin
annotate src/protocols/msn/msn.c @ 2169:b7807144bf44
[gaim-migrate @ 2179]
better reading
committer: Tailor Script <tailor@pidgin.im>
author | Eric Warmenhoven <eric@warmenhoven.org> |
---|---|
date | Mon, 27 Aug 2001 04:53:19 +0000 |
parents | edf8c5a70e5b |
children | c24595d3c364 |
rev | line source |
---|---|
2086 | 1 #include "config.h" |
2 | |
3 #include <stdlib.h> | |
4 #include <gtk/gtk.h> | |
5 #include <string.h> | |
2167
edf8c5a70e5b
[gaim-migrate @ 2177]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2162
diff
changeset
|
6 #include <errno.h> |
2086 | 7 #include <stdio.h> |
8 #include <unistd.h> | |
9 #include <ctype.h> | |
10 #include "gaim.h" | |
11 #include "prpl.h" | |
12 #include "proxy.h" | |
13 #include "md5.h" | |
14 | |
15 #include "pixmaps/msn_online.xpm" | |
16 #include "pixmaps/msn_away.xpm" | |
17 | |
18 #define MSN_BUF_LEN 8192 | |
19 #define MIME_HEADER "MIME-Version: 1.0\r\n" \ | |
20 "Content-Type: text/plain; charset=UTF-8\r\n" \ | |
21 "X-MMS-IM-Format: FN=MS%20Sans%20Serif; EF=; CO=0; PF=0\r\n\r\n" | |
22 | |
23 #define MSN_ONLINE 1 | |
24 #define MSN_BUSY 2 | |
25 #define MSN_IDLE 3 | |
26 #define MSN_BRB 4 | |
27 #define MSN_AWAY 5 | |
28 #define MSN_PHONE 6 | |
29 #define MSN_LUNCH 7 | |
30 #define MSN_OFFLINE 8 | |
31 #define MSN_HIDDEN 9 | |
32 | |
33 #define USEROPT_HOTMAIL 0 | |
34 | |
35 struct msn_data { | |
36 int fd; | |
37 int trId; | |
38 int inpa; | |
39 GSList *switches; | |
40 GSList *fl; | |
41 gboolean imported; | |
42 }; | |
43 | |
44 struct msn_switchboard { | |
45 struct gaim_connection *gc; | |
46 struct conversation *chat; | |
47 int fd; | |
48 int inpa; | |
49 char *sessid; | |
50 char *auth; | |
51 int trId; | |
52 int total; | |
53 char *user; | |
54 char *txqueue; | |
55 }; | |
56 | |
57 struct msn_buddy { | |
58 char *user; | |
59 char *friend; | |
60 }; | |
61 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
62 static void msn_login_callback(gpointer, gint, GaimInputCondition); |
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
63 static void msn_login_xfr_connect(gpointer, gint, GaimInputCondition); |
2086 | 64 |
65 #define GET_NEXT(tmp) while (*(tmp) && !isspace(*(tmp))) \ | |
66 (tmp)++; \ | |
67 *(tmp)++ = 0; \ | |
68 while (*(tmp) && isspace(*(tmp))) \ | |
69 (tmp)++; | |
70 | |
71 static char *msn_name() | |
72 { | |
73 return "MSN"; | |
74 } | |
75 | |
76 static char *msn_normalize(const char *s) | |
77 { | |
78 static char buf[BUF_LEN]; | |
79 | |
80 g_return_val_if_fail(s != NULL, NULL); | |
81 | |
82 g_snprintf(buf, sizeof(buf), "%s%s", s, strchr(s, '@') ? "" : "@hotmail.com"); | |
83 | |
84 return buf; | |
85 } | |
86 | |
87 static int msn_write(int fd, void *data, int len) | |
88 { | |
89 debug_printf("C: %s", data); | |
90 return write(fd, data, len); | |
91 } | |
92 | |
93 static char *url_decode(const char *msg) | |
94 { | |
95 static char buf[MSN_BUF_LEN]; | |
96 int i, j = 0; | |
97 | |
98 bzero(buf, sizeof(buf)); | |
99 for (i = 0; i < strlen(msg); i++) { | |
100 char hex[3]; | |
101 if (msg[i] != '%') { | |
102 buf[j++] = msg[i]; | |
103 continue; | |
104 } | |
2093
83d8a9b7e89b
[gaim-migrate @ 2103]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2090
diff
changeset
|
105 strncpy(hex, msg + ++i, 2); hex[2] = 0; |
83d8a9b7e89b
[gaim-migrate @ 2103]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2090
diff
changeset
|
106 /* i is pointing to the start of the number */ |
83d8a9b7e89b
[gaim-migrate @ 2103]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2090
diff
changeset
|
107 i++; /* now it's at the end and at the start of the for loop |
83d8a9b7e89b
[gaim-migrate @ 2103]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2090
diff
changeset
|
108 will be at the next character */ |
83d8a9b7e89b
[gaim-migrate @ 2103]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2090
diff
changeset
|
109 buf[j++] = strtol(hex, NULL, 16); |
2086 | 110 } |
111 buf[j] = 0; | |
112 | |
113 return buf; | |
114 } | |
115 | |
116 static char *handle_errcode(char *buf, gboolean show) | |
117 { | |
118 int errcode; | |
119 static char msg[MSN_BUF_LEN]; | |
120 | |
121 buf[4] = 0; | |
122 errcode = atoi(buf); | |
123 | |
124 switch (errcode) { | |
125 case 200: | |
126 g_snprintf(msg, sizeof(msg), "Syntax Error (probably a Gaim bug)"); | |
127 break; | |
128 case 201: | |
129 g_snprintf(msg, sizeof(msg), "Invalid Parameter (probably a Gaim bug)"); | |
130 break; | |
131 case 205: | |
132 g_snprintf(msg, sizeof(msg), "Invalid User"); | |
133 break; | |
134 case 206: | |
135 g_snprintf(msg, sizeof(msg), "Fully Qualified Domain Name missing"); | |
136 break; | |
137 case 207: | |
138 g_snprintf(msg, sizeof(msg), "Already Login"); | |
139 break; | |
140 case 208: | |
141 g_snprintf(msg, sizeof(msg), "Invalid Username"); | |
142 break; | |
143 case 209: | |
144 g_snprintf(msg, sizeof(msg), "Invalid Friendly Name"); | |
145 break; | |
146 case 210: | |
147 g_snprintf(msg, sizeof(msg), "List Full"); | |
148 break; | |
149 case 215: | |
150 g_snprintf(msg, sizeof(msg), "Already there"); | |
151 break; | |
152 case 216: | |
153 g_snprintf(msg, sizeof(msg), "Not on list"); | |
154 break; | |
155 case 218: | |
156 g_snprintf(msg, sizeof(msg), "Already in the mode"); | |
157 break; | |
158 case 219: | |
159 g_snprintf(msg, sizeof(msg), "Already in opposite list"); | |
160 break; | |
161 case 280: | |
162 g_snprintf(msg, sizeof(msg), "Switchboard failed"); | |
163 break; | |
164 case 281: | |
165 g_snprintf(msg, sizeof(msg), "Notify Transfer failed"); | |
166 break; | |
167 | |
168 case 300: | |
169 g_snprintf(msg, sizeof(msg), "Required fields missing"); | |
170 break; | |
171 case 302: | |
172 g_snprintf(msg, sizeof(msg), "Not logged in"); | |
173 break; | |
174 | |
175 case 500: | |
176 g_snprintf(msg, sizeof(msg), "Internal server error"); | |
177 break; | |
178 case 501: | |
179 g_snprintf(msg, sizeof(msg), "Database server error"); | |
180 break; | |
181 case 510: | |
182 g_snprintf(msg, sizeof(msg), "File operation error"); | |
183 break; | |
184 case 520: | |
185 g_snprintf(msg, sizeof(msg), "Memory allocation error"); | |
186 break; | |
187 | |
188 case 600: | |
189 g_snprintf(msg, sizeof(msg), "Server busy"); | |
190 break; | |
191 case 601: | |
192 g_snprintf(msg, sizeof(msg), "Server unavailable"); | |
193 break; | |
194 case 602: | |
195 g_snprintf(msg, sizeof(msg), "Peer Notification server down"); | |
196 break; | |
197 case 603: | |
198 g_snprintf(msg, sizeof(msg), "Database connect error"); | |
199 break; | |
200 case 604: | |
201 g_snprintf(msg, sizeof(msg), "Server is going down (abandon ship)"); | |
202 break; | |
203 | |
204 case 707: | |
205 g_snprintf(msg, sizeof(msg), "Error creating connection"); | |
206 break; | |
207 case 711: | |
208 g_snprintf(msg, sizeof(msg), "Unable to write"); | |
209 break; | |
210 case 712: | |
211 g_snprintf(msg, sizeof(msg), "Session overload"); | |
212 break; | |
213 case 713: | |
214 g_snprintf(msg, sizeof(msg), "User is too active"); | |
215 break; | |
216 case 714: | |
217 g_snprintf(msg, sizeof(msg), "Too many sessions"); | |
218 break; | |
219 case 715: | |
220 g_snprintf(msg, sizeof(msg), "Not expected"); | |
221 break; | |
222 case 717: | |
223 g_snprintf(msg, sizeof(msg), "Bad friend file"); | |
224 break; | |
225 | |
226 case 911: | |
227 g_snprintf(msg, sizeof(msg), "Authentication failed"); | |
228 break; | |
229 case 913: | |
230 g_snprintf(msg, sizeof(msg), "Not allowed when offline"); | |
231 break; | |
232 case 920: | |
233 g_snprintf(msg, sizeof(msg), "Not accepting new users"); | |
234 break; | |
235 | |
236 default: | |
237 g_snprintf(msg, sizeof(msg), "Unknown Error Code"); | |
238 break; | |
239 } | |
240 | |
241 if (show) | |
242 do_error_dialog(msg, "MSN Error"); | |
243 | |
244 return msg; | |
245 } | |
246 | |
247 static void handle_hotmail(struct gaim_connection *gc, char *data) | |
248 { | |
2153
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
249 if (strstr(data, "Content-Type: text/x-msmsgsinitialemailnotification;")) { |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
250 char *x = strstr(data, "Inbox-Unread:"); |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
251 if (!x) return; |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
252 x += strlen("Inbox-Unread: "); |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
253 connection_has_mail(gc, atoi(x), NULL, NULL); |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
254 } else if (strstr(data, "Content-Type: text/x-msmsgsemailnotification;")) { |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
255 char *from = strstr(data, "From:"); |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
256 char *subject = strstr(data, "Subject:"); |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
257 char *x; |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
258 if (!from || !subject) { |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
259 connection_has_mail(gc, 1, NULL, NULL); |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
260 return; |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
261 } |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
262 from += strlen("From: "); |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
263 x = strstr(from, "\r\n"); *x = 0; |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
264 subject += strlen("Subject: "); |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
265 x = strstr(subject, "\r\n"); *x = 0; |
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
266 connection_has_mail(gc, -1, from, subject); |
2086 | 267 } |
268 } | |
269 | |
270 static struct msn_switchboard *msn_find_switch(struct gaim_connection *gc, char *id) | |
271 { | |
272 struct msn_data *md = gc->proto_data; | |
273 GSList *m = md->switches; | |
274 | |
275 while (m) { | |
276 struct msn_switchboard *ms = m->data; | |
277 m = m->next; | |
278 if ((ms->total == 1) && !g_strcasecmp(ms->user, id)) | |
279 return ms; | |
280 } | |
281 | |
282 return NULL; | |
283 } | |
284 | |
285 static struct msn_switchboard *msn_find_switch_by_id(struct gaim_connection *gc, int id) | |
286 { | |
287 struct msn_data *md = gc->proto_data; | |
288 GSList *m = md->switches; | |
289 | |
290 while (m) { | |
291 struct msn_switchboard *ms = m->data; | |
292 m = m->next; | |
293 if (ms->chat && (ms->chat->id == id)) | |
294 return ms; | |
295 } | |
296 | |
297 return NULL; | |
298 } | |
299 | |
300 static struct msn_switchboard *msn_find_writable_switch(struct gaim_connection *gc) | |
301 { | |
302 struct msn_data *md = gc->proto_data; | |
303 GSList *m = md->switches; | |
304 | |
305 while (m) { | |
306 struct msn_switchboard *ms = m->data; | |
307 m = m->next; | |
308 if (ms->txqueue) | |
309 return ms; | |
310 } | |
311 | |
312 return NULL; | |
313 } | |
314 | |
315 static void msn_kill_switch(struct msn_switchboard *ms) | |
316 { | |
317 struct gaim_connection *gc = ms->gc; | |
318 struct msn_data *md = gc->proto_data; | |
319 | |
320 if (ms->inpa) | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
321 gaim_input_remove(ms->inpa); |
2086 | 322 close(ms->fd); |
323 if (ms->sessid) | |
324 g_free(ms->sessid); | |
325 g_free(ms->auth); | |
326 if (ms->user) | |
327 g_free(ms->user); | |
328 if (ms->txqueue) | |
329 g_free(ms->txqueue); | |
330 if (ms->chat) | |
331 serv_got_chat_left(gc, ms->chat->id); | |
332 | |
333 md->switches = g_slist_remove(md->switches, ms); | |
334 | |
335 g_free(ms); | |
336 } | |
337 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
338 static void msn_switchboard_callback(gpointer data, gint source, GaimInputCondition cond) |
2086 | 339 { |
340 struct msn_switchboard *ms = data; | |
341 struct gaim_connection *gc = ms->gc; | |
342 char buf[MSN_BUF_LEN]; | |
343 static int id = 0; | |
344 int i = 0; | |
345 | |
346 bzero(buf, sizeof(buf)); | |
347 while ((read(ms->fd, buf + i, 1) > 0) && (buf[i++] != '\n')) | |
348 if (i == sizeof(buf)) | |
349 i--; /* yes i know this loses data but we shouldn't get messages this long | |
350 and it's better than possibly writing past our buffer */ | |
351 if (i == 0 || buf[i - 1] != '\n') { | |
352 msn_kill_switch(ms); | |
353 return; | |
354 } | |
355 debug_printf("S: %s", buf); | |
356 g_strchomp(buf); | |
357 | |
358 if (!g_strncasecmp(buf, "ACK", 3)) { | |
359 } else if (!g_strncasecmp(buf, "ANS", 3)) { | |
360 if (ms->chat) | |
361 add_chat_buddy(ms->chat, gc->username); | |
362 } else if (!g_strncasecmp(buf, "BYE", 3)) { | |
363 if (ms->chat) { | |
364 char *user, *tmp = buf; | |
365 GET_NEXT(tmp); | |
366 user = tmp; | |
367 remove_chat_buddy(ms->chat, user); | |
368 } else | |
369 msn_kill_switch(ms); | |
370 } else if (!g_strncasecmp(buf, "CAL", 3)) { | |
371 } else if (!g_strncasecmp(buf, "IRO", 3)) { | |
372 char *tot, *user, *tmp = buf; | |
373 | |
374 GET_NEXT(tmp); | |
375 GET_NEXT(tmp); | |
376 GET_NEXT(tmp); | |
377 tot = tmp; | |
378 GET_NEXT(tmp); | |
379 ms->total = atoi(tot); | |
380 user = tmp; | |
381 GET_NEXT(tmp); | |
382 | |
383 if (ms->total > 1) { | |
384 if (!ms->chat) | |
385 ms->chat = serv_got_joined_chat(gc, ++id, "MSN Chat"); | |
386 add_chat_buddy(ms->chat, user); | |
387 } | |
388 } else if (!g_strncasecmp(buf, "JOI", 3)) { | |
389 char *user, *tmp = buf; | |
390 GET_NEXT(tmp); | |
391 user = tmp; | |
392 GET_NEXT(tmp); | |
393 | |
394 if (ms->total == 1) { | |
395 ms->chat = serv_got_joined_chat(gc, ++id, "MSN Chat"); | |
396 add_chat_buddy(ms->chat, ms->user); | |
397 add_chat_buddy(ms->chat, gc->username); | |
398 g_free(ms->user); | |
399 ms->user = NULL; | |
400 } | |
401 if (ms->chat) | |
402 add_chat_buddy(ms->chat, user); | |
403 ms->total++; | |
404 if (ms->txqueue) { | |
405 char *utf8 = str_to_utf8(ms->txqueue); | |
406 g_snprintf(buf, sizeof(buf), "MSG %d N %d\r\n%s%s", ++ms->trId, | |
407 strlen(MIME_HEADER) + strlen(utf8), | |
408 MIME_HEADER, utf8); | |
409 g_free(utf8); | |
410 g_free(ms->txqueue); | |
411 ms->txqueue = NULL; | |
412 if (msn_write(ms->fd, buf, strlen(buf)) < 0) | |
413 msn_kill_switch(ms); | |
414 debug_printf("\n"); | |
415 } | |
416 } else if (!g_strncasecmp(buf, "MSG", 3)) { | |
417 char *user, *tmp = buf; | |
418 int length; | |
419 char *msg, *content, *utf; | |
420 int len, r; | |
421 | |
422 GET_NEXT(tmp); | |
423 user = tmp; | |
424 | |
425 GET_NEXT(tmp); | |
426 | |
427 GET_NEXT(tmp); | |
428 length = atoi(tmp); | |
429 | |
430 msg = g_new0(char, MAX(length + 1, MSN_BUF_LEN)); | |
431 | |
432 for (len = 0; len < length; len += r) { | |
433 if ((r = read(ms->fd, msg+len, length-len)) <= 0) { | |
434 g_free(msg); | |
435 hide_login_progress(gc, "Unable to read message"); | |
436 signoff(gc); | |
437 return; | |
438 } | |
439 } | |
440 | |
441 content = strstr(msg, "Content-Type: "); | |
442 if (!content) { | |
443 g_free(msg); | |
444 return; | |
445 } | |
446 if (!g_strncasecmp(content, "Content-Type: text/plain", | |
447 strlen("Content-Type: text/plain"))) { | |
448 char *final, *skiphead; | |
449 skiphead = strstr(msg, "\r\n\r\n"); | |
450 if (!skiphead || !skiphead[4]) { | |
451 g_free(msg); | |
452 return; | |
453 } | |
454 skiphead += 4; | |
455 utf = utf8_to_str(skiphead); | |
456 len = MAX(strlen(utf) + 1, BUF_LEN); | |
457 final = g_malloc(len); | |
458 g_snprintf(final, len, "%s", utf); | |
459 g_free(utf); | |
460 | |
461 if (ms->chat) | |
462 serv_got_chat_in(gc, ms->chat->id, user, 0, final, time(NULL)); | |
463 else | |
464 serv_got_im(gc, user, final, 0, time(NULL)); | |
465 | |
466 g_free(final); | |
467 } | |
468 g_free(msg); | |
469 } else if (!g_strncasecmp(buf, "NAK", 3)) { | |
470 do_error_dialog("A message may not have been received.", "MSN Error"); | |
471 } else if (!g_strncasecmp(buf, "NLN", 3)) { | |
472 } else if (!g_strncasecmp(buf, "OUT", 3)) { | |
473 if (ms->chat) | |
474 serv_got_chat_left(gc, ms->chat->id); | |
475 msn_kill_switch(ms); | |
476 } else if (!g_strncasecmp(buf, "USR", 3)) { | |
477 /* good, we got USR, now we need to find out who we want to talk to */ | |
478 struct msn_switchboard *ms = msn_find_writable_switch(gc); | |
479 | |
480 if (!ms) | |
481 return; | |
482 | |
483 g_snprintf(buf, sizeof(buf), "CAL %d %s\n", ++ms->trId, ms->user); | |
484 if (msn_write(ms->fd, buf, strlen(buf)) < 0) | |
485 msn_kill_switch(ms); | |
486 } else if (isdigit(*buf)) { | |
487 handle_errcode(buf, TRUE); | |
488 } else { | |
489 debug_printf("Unhandled message!\n"); | |
490 } | |
491 } | |
492 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
493 static void msn_rng_connect(gpointer data, gint source, GaimInputCondition cond) |
2086 | 494 { |
495 struct msn_switchboard *ms = data; | |
496 struct gaim_connection *gc = ms->gc; | |
497 struct msn_data *md; | |
498 char buf[MSN_BUF_LEN]; | |
499 | |
500 if (source == -1 || !g_slist_find(connections, gc)) { | |
501 g_free(ms->sessid); | |
502 g_free(ms->auth); | |
503 g_free(ms); | |
504 return; | |
505 } | |
506 | |
507 md = gc->proto_data; | |
508 | |
509 if (ms->fd != source) | |
510 ms->fd = source; | |
511 | |
512 g_snprintf(buf, sizeof(buf), "ANS %d %s %s %s\n", ++ms->trId, gc->username, ms->auth, ms->sessid); | |
513 if (msn_write(ms->fd, buf, strlen(buf)) < 0) { | |
514 close(ms->fd); | |
515 g_free(ms->sessid); | |
516 g_free(ms->auth); | |
517 g_free(ms); | |
518 return; | |
519 } | |
520 | |
521 md->switches = g_slist_append(md->switches, ms); | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
522 ms->inpa = gaim_input_add(ms->fd, GAIM_INPUT_READ, msn_switchboard_callback, ms); |
2086 | 523 } |
524 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
525 static void msn_ss_xfr_connect(gpointer data, gint source, GaimInputCondition cond) |
2086 | 526 { |
527 struct msn_switchboard *ms = data; | |
528 struct gaim_connection *gc = ms->gc; | |
529 char buf[MSN_BUF_LEN]; | |
530 | |
531 if (source == -1 || !g_slist_find(connections, gc)) { | |
532 g_free(ms->auth); | |
533 g_free(ms); | |
534 return; | |
535 } | |
536 | |
537 if (ms->fd != source) | |
538 ms->fd = source; | |
539 | |
540 g_snprintf(buf, sizeof(buf), "USR %d %s %s\n", ++ms->trId, gc->username, ms->auth); | |
541 if (msn_write(ms->fd, buf, strlen(buf)) < 0) { | |
542 g_free(ms->auth); | |
543 g_free(ms); | |
544 return; | |
545 } | |
546 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
547 ms->inpa = gaim_input_add(ms->fd, GAIM_INPUT_READ, msn_switchboard_callback, ms); |
2086 | 548 } |
549 | |
550 struct msn_add_permit { | |
551 struct gaim_connection *gc; | |
552 char *user; | |
553 char *friend; | |
554 }; | |
555 | |
556 static void msn_accept_add(gpointer w, struct msn_add_permit *map) | |
557 { | |
558 struct msn_data *md = map->gc->proto_data; | |
559 char buf[MSN_BUF_LEN]; | |
560 | |
561 g_snprintf(buf, sizeof(buf), "ADD %d AL %s %s\n", ++md->trId, map->user, map->friend); | |
562 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
563 hide_login_progress(map->gc, "Write error"); | |
564 signoff(map->gc); | |
565 return; | |
566 } | |
567 } | |
568 | |
569 static void msn_cancel_add(gpointer w, struct msn_add_permit *map) | |
570 { | |
571 g_free(map->user); | |
572 g_free(map->friend); | |
573 g_free(map); | |
574 } | |
575 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
576 static void msn_callback(gpointer data, gint source, GaimInputCondition cond) |
2086 | 577 { |
578 struct gaim_connection *gc = data; | |
579 struct msn_data *md = gc->proto_data; | |
580 char buf[MSN_BUF_LEN]; | |
581 int i = 0; | |
582 | |
583 bzero(buf, sizeof(buf)); | |
584 while ((read(md->fd, buf + i, 1) > 0) && (buf[i++] != '\n')) | |
585 if (i == sizeof(buf)) | |
586 i--; /* yes i know this loses data but we shouldn't get messages this long | |
587 and it's better than possibly writing past our buffer */ | |
588 if (i == 0 || buf[i - 1] != '\n') { | |
589 hide_login_progress(gc, "Error reading from server"); | |
590 signoff(gc); | |
591 return; | |
592 } | |
593 debug_printf("S: %s", buf); | |
594 g_strchomp(buf); | |
595 | |
596 if (!g_strncasecmp(buf, "ADD", 3)) { | |
597 char *list, *user, *friend, *tmp = buf; | |
598 struct msn_add_permit *ap = g_new0(struct msn_add_permit, 1); | |
599 char msg[MSN_BUF_LEN]; | |
600 | |
601 GET_NEXT(tmp); | |
602 GET_NEXT(tmp); | |
603 list = tmp; | |
604 | |
605 GET_NEXT(tmp); | |
606 GET_NEXT(tmp); | |
607 user = tmp; | |
608 | |
609 GET_NEXT(tmp); | |
610 friend = tmp; | |
611 | |
612 if (g_strcasecmp(list, "RL")) | |
613 return; | |
614 | |
615 ap->user = g_strdup(user); | |
616 ap->friend = g_strdup(friend); | |
617 ap->gc = gc; | |
618 | |
619 g_snprintf(msg, sizeof(msg), "The user %s (%s) wants to add you to their buddy list.", | |
620 ap->user, url_decode(ap->friend)); | |
621 | |
622 do_ask_dialog(msg, ap, msn_accept_add, msn_cancel_add); | |
623 } else if (!g_strncasecmp(buf, "BLP", 3)) { | |
624 } else if (!g_strncasecmp(buf, "BPR", 3)) { | |
625 } else if (!g_strncasecmp(buf, "CHG", 3)) { | |
626 } else if (!g_strncasecmp(buf, "CHL", 3)) { | |
627 char *hash = buf; | |
628 char buf2[MSN_BUF_LEN]; | |
629 md5_state_t st; | |
630 md5_byte_t di[16]; | |
631 int i; | |
632 | |
633 GET_NEXT(hash); | |
634 GET_NEXT(hash); | |
635 | |
636 md5_init(&st); | |
637 md5_append(&st, (const md5_byte_t *)hash, strlen(hash)); | |
638 md5_append(&st, (const md5_byte_t *)"Q1P7W2E4J9R8U3S5", strlen("Q1P7W2E4J9R8U3S5")); | |
639 md5_finish(&st, di); | |
640 | |
641 g_snprintf(buf, sizeof(buf), "QRY %d msmsgs@msnmsgr.com 32\r\n", ++md->trId); | |
642 for (i = 0; i < 16; i++) { | |
643 g_snprintf(buf2, sizeof(buf2), "%02x", di[i]); | |
644 strcat(buf, buf2); | |
645 } | |
646 | |
647 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
648 hide_login_progress(gc, "Unable to write to server"); | |
649 signoff(gc); | |
650 } | |
651 | |
652 debug_printf("\n"); | |
653 } else if (!g_strncasecmp(buf, "FLN", 3)) { | |
654 char *usr = buf; | |
655 | |
656 GET_NEXT(usr); | |
657 serv_got_update(gc, usr, 0, 0, 0, 0, 0, 0); | |
658 } else if (!g_strncasecmp(buf, "GTC", 3)) { | |
659 } else if (!g_strncasecmp(buf, "INF", 3)) { | |
660 } else if (!g_strncasecmp(buf, "ILN", 3)) { | |
661 char *state, *user, *tmp = buf; | |
662 int status = UC_NORMAL; | |
663 | |
664 GET_NEXT(tmp); | |
665 | |
666 GET_NEXT(tmp); | |
667 state = tmp; | |
668 | |
669 GET_NEXT(tmp); | |
670 user = tmp; | |
671 | |
672 GET_NEXT(tmp); | |
673 | |
674 if (!g_strcasecmp(state, "BSY")) { | |
675 status |= (MSN_BUSY << 5); | |
676 } else if (!g_strcasecmp(state, "IDL")) { | |
677 status |= (MSN_IDLE << 5); | |
678 } else if (!g_strcasecmp(state, "BRB")) { | |
679 status |= (MSN_BRB << 5); | |
680 } else if (!g_strcasecmp(state, "AWY")) { | |
681 status = UC_UNAVAILABLE; | |
682 } else if (!g_strcasecmp(state, "PHN")) { | |
683 status |= (MSN_PHONE << 5); | |
684 } else if (!g_strcasecmp(state, "LUN")) { | |
685 status |= (MSN_LUNCH << 5); | |
686 } | |
687 | |
688 serv_got_update(gc, user, 1, 0, 0, 0, status, 0); | |
689 } else if (!g_strncasecmp(buf, "LST", 3)) { | |
690 char *which, *who, *friend, *tmp = buf; | |
691 | |
692 GET_NEXT(tmp); | |
693 GET_NEXT(tmp); | |
694 which = tmp; | |
695 | |
696 GET_NEXT(tmp); | |
697 GET_NEXT(tmp); | |
698 GET_NEXT(tmp); | |
699 GET_NEXT(tmp); | |
700 who = tmp; | |
701 | |
702 GET_NEXT(tmp); | |
703 friend = url_decode(tmp); | |
704 | |
705 if (!g_strcasecmp(which, "FL")) { | |
706 struct msn_buddy *b = g_new0(struct msn_buddy, 1); | |
707 b->user = g_strdup(who); | |
708 b->friend = g_strdup(friend); | |
709 md->fl = g_slist_append(md->fl, b); | |
710 } else if (!md->imported) { | |
711 if (bud_list_cache_exists(gc)) | |
712 do_import(NULL, gc); | |
713 md->imported = TRUE; | |
714 while (md->fl) { | |
715 struct msn_buddy *mb = md->fl->data; | |
716 struct buddy *b; | |
717 md->fl = g_slist_remove(md->fl, mb); | |
718 if (!(b = find_buddy(gc, mb->user))) | |
719 add_buddy(gc, "Buddies", mb->user, mb->friend); | |
720 else if (!g_strcasecmp(b->name, b->show)) { | |
721 g_snprintf(b->show, sizeof(b->show), "%s", mb->friend); | |
722 handle_buddy_rename(b, b->name); | |
723 } | |
724 g_free(mb->user); | |
725 g_free(mb->friend); | |
726 g_free(mb); | |
727 } | |
728 } | |
729 } else if (!g_strncasecmp(buf, "MSG", 3)) { | |
730 char *user, *tmp = buf; | |
731 int length; | |
732 char *msg, *skiphead, *utf, *final; | |
2169
b7807144bf44
[gaim-migrate @ 2179]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2167
diff
changeset
|
733 int len, r; |
2086 | 734 |
735 GET_NEXT(tmp); | |
736 user = tmp; | |
737 | |
738 GET_NEXT(tmp); | |
739 | |
740 GET_NEXT(tmp); | |
741 length = atoi(tmp); | |
742 | |
743 msg = g_new0(char, MAX(length + 1, MSN_BUF_LEN)); | |
744 | |
2169
b7807144bf44
[gaim-migrate @ 2179]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2167
diff
changeset
|
745 for (len = 0; len < length; len += r) { |
b7807144bf44
[gaim-migrate @ 2179]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2167
diff
changeset
|
746 if ((r = read(md->fd, msg+len, length-len)) <= 0) { |
b7807144bf44
[gaim-migrate @ 2179]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2167
diff
changeset
|
747 g_free(msg); |
b7807144bf44
[gaim-migrate @ 2179]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2167
diff
changeset
|
748 hide_login_progress(gc, "Unable to read message"); |
b7807144bf44
[gaim-migrate @ 2179]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2167
diff
changeset
|
749 signoff(gc); |
b7807144bf44
[gaim-migrate @ 2179]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2167
diff
changeset
|
750 return; |
b7807144bf44
[gaim-migrate @ 2179]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2167
diff
changeset
|
751 } |
2086 | 752 } |
753 | |
754 if (!g_strcasecmp(user, "hotmail")) { | |
755 handle_hotmail(gc, msg); | |
756 g_free(msg); | |
757 return; | |
758 } | |
759 | |
760 skiphead = strstr(msg, "\r\n\r\n"); | |
761 if (!skiphead || !skiphead[4]) { | |
762 g_free(msg); | |
763 return; | |
764 } | |
765 skiphead += 4; | |
766 utf = utf8_to_str(skiphead); | |
767 len = MAX(strlen(utf) + 1, BUF_LEN); | |
768 final = g_malloc(len); | |
769 g_snprintf(final, len, "%s", utf); | |
770 g_free(utf); | |
771 | |
772 serv_got_im(gc, user, final, 0, time(NULL)); | |
773 | |
774 g_free(final); | |
775 g_free(msg); | |
776 } else if (!g_strncasecmp(buf, "NLN", 3)) { | |
777 char *state, *user, *tmp = buf; | |
778 int status = UC_NORMAL; | |
779 | |
780 GET_NEXT(tmp); | |
781 state = tmp; | |
782 | |
783 GET_NEXT(tmp); | |
784 user = tmp; | |
785 | |
786 GET_NEXT(tmp); | |
787 | |
788 if (!g_strcasecmp(state, "BSY")) { | |
789 status |= (MSN_BUSY << 5); | |
790 } else if (!g_strcasecmp(state, "IDL")) { | |
791 status |= (MSN_IDLE << 5); | |
792 } else if (!g_strcasecmp(state, "BRB")) { | |
793 status |= (MSN_BRB << 5); | |
794 } else if (!g_strcasecmp(state, "AWY")) { | |
795 status = UC_UNAVAILABLE; | |
796 } else if (!g_strcasecmp(state, "PHN")) { | |
797 status |= (MSN_PHONE << 5); | |
798 } else if (!g_strcasecmp(state, "LUN")) { | |
799 status |= (MSN_LUNCH << 5); | |
800 } | |
801 | |
802 serv_got_update(gc, user, 1, 0, 0, 0, status, 0); | |
803 } else if (!g_strncasecmp(buf, "OUT", 3)) { | |
804 } else if (!g_strncasecmp(buf, "PRP", 3)) { | |
805 } else if (!g_strncasecmp(buf, "QRY", 3)) { | |
806 } else if (!g_strncasecmp(buf, "REM", 3)) { | |
807 } else if (!g_strncasecmp(buf, "RNG", 3)) { | |
808 struct msn_switchboard *ms; | |
809 char *sessid, *ssaddr, *auth, *user; | |
810 int port, i = 0; | |
811 char *tmp = buf; | |
812 | |
813 GET_NEXT(tmp); | |
814 sessid = tmp; | |
815 | |
816 GET_NEXT(tmp); | |
817 ssaddr = tmp; | |
818 | |
819 GET_NEXT(tmp); | |
820 | |
821 GET_NEXT(tmp); | |
822 auth = tmp; | |
823 | |
824 GET_NEXT(tmp); | |
825 user = tmp; | |
826 GET_NEXT(tmp); | |
827 | |
828 while (ssaddr[i] && ssaddr[i] != ':') i++; | |
829 if (ssaddr[i] == ':') { | |
830 char *x = &ssaddr[i + 1]; | |
831 ssaddr[i] = 0; | |
832 port = atoi(x); | |
833 } else | |
834 port = 1863; | |
835 | |
836 ms = g_new0(struct msn_switchboard, 1); | |
837 ms->user = g_strdup(user); | |
838 ms->sessid = g_strdup(sessid); | |
839 ms->auth = g_strdup(auth); | |
840 ms->gc = gc; | |
841 ms->fd = proxy_connect(ssaddr, port, msn_rng_connect, ms); | |
842 } else if (!g_strncasecmp(buf, "SYN", 3)) { | |
843 } else if (!g_strncasecmp(buf, "USR", 3)) { | |
844 } else if (!g_strncasecmp(buf, "XFR", 3)) { | |
845 char *host = strstr(buf, "SB"); | |
846 int port; | |
847 int i = 0; | |
848 gboolean switchboard = TRUE; | |
849 char *tmp; | |
850 | |
851 if (!host) { | |
852 host = strstr(buf, "NS"); | |
853 if (!host) { | |
854 hide_login_progress(gc, "Got invalid XFR\n"); | |
855 signoff(gc); | |
856 return; | |
857 } | |
858 switchboard = FALSE; | |
859 } | |
860 | |
861 GET_NEXT(host); | |
862 while (host[i] && host[i] != ':') i++; | |
863 if (host[i] == ':') { | |
864 tmp = &host[i + 1]; | |
865 host[i] = 0; | |
866 while (isdigit(*tmp)) tmp++; | |
867 *tmp++ = 0; | |
868 port = atoi(&host[i + 1]); | |
869 } else { | |
870 port = 1863; | |
871 tmp = host; | |
872 GET_NEXT(tmp); | |
873 } | |
874 | |
875 if (switchboard) { | |
876 struct msn_switchboard *ms = msn_find_writable_switch(gc); | |
877 if (!ms) | |
878 return; | |
879 | |
880 GET_NEXT(tmp); | |
881 | |
882 ms->auth = g_strdup(tmp); | |
883 ms->fd = proxy_connect(host, port, msn_ss_xfr_connect, ms); | |
884 } else { | |
885 close(md->fd); | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
886 gaim_input_remove(md->inpa); |
2086 | 887 md->inpa = 0; |
888 md->fd = 0; | |
889 md->fd = proxy_connect(host, port, msn_login_xfr_connect, gc); | |
890 } | |
891 } else if (isdigit(*buf)) { | |
892 handle_errcode(buf, TRUE); | |
893 } else { | |
894 debug_printf("Unhandled message!\n"); | |
895 } | |
896 } | |
897 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
898 static void msn_login_xfr_connect(gpointer data, gint source, GaimInputCondition cond) |
2086 | 899 { |
900 struct gaim_connection *gc = data; | |
901 struct msn_data *md; | |
902 char buf[MSN_BUF_LEN]; | |
903 | |
904 if (!g_slist_find(connections, gc)) | |
905 return; | |
906 | |
907 md = gc->proto_data; | |
908 | |
909 if (md->fd != source) | |
910 md->fd = source; | |
911 | |
912 if (md->fd == -1) { | |
913 hide_login_progress(gc, "Unable to connect to Notification Server"); | |
914 signoff(gc); | |
915 return; | |
916 } | |
917 | |
918 g_snprintf(buf, sizeof(buf), "USR %d MD5 I %s\n", ++md->trId, gc->username); | |
919 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
920 hide_login_progress(gc, "Unable to talk to Notification Server"); | |
921 signoff(gc); | |
922 return; | |
923 } | |
924 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
925 md->inpa = gaim_input_add(md->fd, GAIM_INPUT_READ, msn_login_callback, gc); |
2086 | 926 } |
927 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
928 static void msn_login_callback(gpointer data, gint source, GaimInputCondition cond) |
2086 | 929 { |
930 struct gaim_connection *gc = data; | |
931 struct msn_data *md = gc->proto_data; | |
932 char buf[MSN_BUF_LEN]; | |
933 int i = 0; | |
934 | |
935 bzero(buf, sizeof(buf)); | |
936 while ((read(md->fd, buf + i, 1) > 0) && (buf[i++] != '\n')) | |
937 if (i == sizeof(buf)) | |
938 i--; /* yes i know this loses data but we shouldn't get messages this long | |
939 and it's better than possibly writing past our buffer */ | |
940 if (i == 0 || buf[i - 1] != '\n') { | |
941 hide_login_progress(gc, "Error reading from server"); | |
942 signoff(gc); | |
943 return; | |
944 } | |
945 debug_printf("S: %s", buf); | |
946 g_strchomp(buf); | |
947 | |
948 if (!g_strncasecmp(buf, "VER", 3)) { | |
949 /* we got VER, check to see that MSNP2 is in the list, then send INF */ | |
950 if (!strstr(buf, "MSNP2")) { | |
951 hide_login_progress(gc, "Protocol not supported"); | |
952 signoff(gc); | |
953 return; | |
954 } | |
955 | |
956 g_snprintf(buf, sizeof(buf), "INF %d\n", ++md->trId); | |
957 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
958 hide_login_progress(gc, "Unable to request INF\n"); | |
959 signoff(gc); | |
960 return; | |
961 } | |
962 } else if (!g_strncasecmp(buf, "INF", 3)) { | |
963 /* check to make sure we can use md5 */ | |
964 if (!strstr(buf, "MD5")) { | |
965 hide_login_progress(gc, "Unable to login using MD5"); | |
966 signoff(gc); | |
967 return; | |
968 } | |
969 | |
970 g_snprintf(buf, sizeof(buf), "USR %d MD5 I %s\n", ++md->trId, gc->username); | |
971 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
972 hide_login_progress(gc, "Unable to send USR\n"); | |
973 signoff(gc); | |
974 return; | |
975 } | |
976 | |
977 set_login_progress(gc, 3, "Requesting to send password"); | |
978 } else if (!g_strncasecmp(buf, "USR", 3)) { | |
979 /* so here, we're either getting the challenge or the OK */ | |
980 if (strstr(buf, "OK")) { | |
981 g_snprintf(buf, sizeof(buf), "SYN %d 0\n", ++md->trId); | |
982 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
983 hide_login_progress(gc, "Unable to write"); | |
984 signoff(gc); | |
985 return; | |
986 } | |
987 | |
988 g_snprintf(buf, sizeof(buf), "CHG %d NLN\n", ++md->trId); | |
989 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
990 hide_login_progress(gc, "Unable to write"); | |
991 signoff(gc); | |
992 return; | |
993 } | |
994 | |
995 g_snprintf(buf, sizeof(buf), "BLP %d AL\n", ++md->trId); | |
996 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
997 hide_login_progress(gc, "Unable to write"); | |
998 signoff(gc); | |
999 return; | |
1000 } | |
1001 | |
1002 account_online(gc); | |
1003 serv_finish_login(gc); | |
1004 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
1005 gaim_input_remove(md->inpa); |
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
1006 md->inpa = gaim_input_add(md->fd, GAIM_INPUT_READ, msn_callback, gc); |
2086 | 1007 } else if (strstr(buf, "MD5")) { |
1008 char *challenge = buf; | |
1009 char buf2[MSN_BUF_LEN]; | |
1010 md5_state_t st; | |
1011 md5_byte_t di[16]; | |
1012 int spaces = 4; | |
1013 int i; | |
1014 | |
1015 while (spaces) { | |
1016 if (isspace(*challenge)) { | |
1017 spaces--; | |
1018 while (isspace(challenge[1])) | |
1019 challenge++; | |
1020 } | |
1021 challenge++; | |
1022 } | |
1023 | |
1024 g_snprintf(buf2, sizeof(buf2), "%s%s", challenge, gc->password); | |
1025 | |
1026 md5_init(&st); | |
1027 md5_append(&st, (const md5_byte_t *)buf2, strlen(buf2)); | |
1028 md5_finish(&st, di); | |
1029 | |
1030 g_snprintf(buf, sizeof(buf), "USR %d MD5 S ", ++md->trId); | |
1031 for (i = 0; i < 16; i++) { | |
1032 g_snprintf(buf2, sizeof(buf2), "%02x", di[i]); | |
1033 strcat(buf, buf2); | |
1034 } | |
1035 strcat(buf, "\n"); | |
1036 | |
1037 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
1038 hide_login_progress(gc, "Unable to send password"); | |
1039 signoff(gc); | |
1040 return; | |
1041 } | |
1042 | |
1043 set_login_progress(gc, 4, "Password sent"); | |
1044 } | |
1045 } else if (!g_strncasecmp(buf, "XFR", 3)) { | |
1046 char *host = strstr(buf, "NS"); | |
1047 int port; | |
1048 int i = 0; | |
1049 | |
1050 if (!host) { | |
1051 hide_login_progress(gc, "Got invalid XFR\n"); | |
1052 signoff(gc); | |
1053 return; | |
1054 } | |
1055 | |
1056 GET_NEXT(host); | |
1057 while (host[i] && host[i] != ':') i++; | |
1058 if (host[i] == ':') { | |
1059 char *x = &host[i + 1]; | |
1060 host[i] = 0; | |
1061 port = atoi(x); | |
1062 } else | |
1063 port = 1863; | |
1064 | |
1065 close(md->fd); | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
1066 gaim_input_remove(md->inpa); |
2086 | 1067 md->inpa = 0; |
1068 md->fd = 0; | |
1069 md->fd = proxy_connect(host, port, msn_login_xfr_connect, gc); | |
1070 } else { | |
1071 if (isdigit(*buf)) | |
1072 hide_login_progress(gc, handle_errcode(buf, FALSE)); | |
1073 else | |
1074 hide_login_progress(gc, "Unable to parse message"); | |
1075 signoff(gc); | |
1076 return; | |
1077 } | |
1078 } | |
1079 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
1080 static void msn_login_connect(gpointer data, gint source, GaimInputCondition cond) |
2086 | 1081 { |
1082 struct gaim_connection *gc = data; | |
1083 struct msn_data *md; | |
1084 char buf[1024]; | |
1085 | |
1086 if (!g_slist_find(connections, gc)) | |
1087 return; | |
1088 | |
1089 md = gc->proto_data; | |
1090 | |
1091 if (md->fd != source) | |
1092 md->fd = source; | |
1093 | |
1094 if (md->fd == -1) { | |
1095 hide_login_progress(gc, "Unable to connect"); | |
1096 signoff(gc); | |
1097 return; | |
1098 } | |
1099 | |
1100 g_snprintf(buf, sizeof(buf), "VER %d MSNP2\n", ++md->trId); | |
1101 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
1102 hide_login_progress(gc, "Unable to write to server"); | |
1103 signoff(gc); | |
1104 return; | |
1105 } | |
1106 | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
1107 md->inpa = gaim_input_add(md->fd, GAIM_INPUT_READ, msn_login_callback, gc); |
2086 | 1108 set_login_progress(gc, 2, "Synching with server"); |
1109 } | |
1110 | |
1111 static void msn_login(struct aim_user *user) | |
1112 { | |
1113 struct gaim_connection *gc = new_gaim_conn(user); | |
1114 struct msn_data *md = gc->proto_data = g_new0(struct msn_data, 1); | |
1115 | |
1116 set_login_progress(gc, 1, "Connecting"); | |
1117 | |
1118 g_snprintf(gc->username, sizeof(gc->username), "%s", msn_normalize(gc->username)); | |
1119 | |
1120 md->fd = proxy_connect("messenger.hotmail.com", 1863, msn_login_connect, gc); | |
1121 } | |
1122 | |
1123 static void msn_close(struct gaim_connection *gc) | |
1124 { | |
1125 struct msn_data *md = gc->proto_data; | |
1126 close(md->fd); | |
1127 if (md->inpa) | |
2090
b66aca8e8dce
[gaim-migrate @ 2100]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
1128 gaim_input_remove(md->inpa); |
2086 | 1129 while (md->switches) |
1130 msn_kill_switch(md->switches->data); | |
1131 while (md->fl) { | |
1132 struct msn_buddy *tmp = md->fl->data; | |
1133 md->fl = g_slist_remove(md->fl, tmp); | |
1134 g_free(tmp->user); | |
1135 g_free(tmp->friend); | |
1136 g_free(tmp); | |
1137 } | |
1138 g_free(md); | |
1139 } | |
1140 | |
2123
56c4382f2909
[gaim-migrate @ 2133]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2093
diff
changeset
|
1141 static int msn_send_im(struct gaim_connection *gc, char *who, char *message, int away) |
2086 | 1142 { |
1143 struct msn_data *md = gc->proto_data; | |
1144 struct msn_switchboard *ms = msn_find_switch(gc, who); | |
1145 char buf[MSN_BUF_LEN]; | |
1146 | |
1147 if (ms) { | |
1148 char *utf8 = str_to_utf8(message); | |
1149 g_snprintf(buf, sizeof(buf), "MSG %d N %d\r\n%s%s", ++ms->trId, | |
1150 strlen(MIME_HEADER) + strlen(utf8), | |
1151 MIME_HEADER, utf8); | |
1152 g_free(utf8); | |
1153 if (msn_write(ms->fd, buf, strlen(buf)) < 0) | |
1154 msn_kill_switch(ms); | |
1155 debug_printf("\n"); | |
1156 } else if (strcmp(who, gc->username)) { | |
1157 g_snprintf(buf, MSN_BUF_LEN, "XFR %d SB\n", ++md->trId); | |
1158 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
1159 hide_login_progress(gc, "Write error"); | |
1160 signoff(gc); | |
2123
56c4382f2909
[gaim-migrate @ 2133]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2093
diff
changeset
|
1161 return 0; |
2086 | 1162 } |
1163 | |
1164 ms = g_new0(struct msn_switchboard, 1); | |
1165 md->switches = g_slist_append(md->switches, ms); | |
1166 ms->user = g_strdup(who); | |
1167 ms->txqueue = g_strdup(message); | |
1168 ms->gc = gc; | |
1169 ms->fd = -1; | |
1170 } else | |
1171 /* in msn you can't send messages to yourself, so we'll fake like we received it ;) */ | |
1172 serv_got_im(gc, who, message, away, time(NULL)); | |
2123
56c4382f2909
[gaim-migrate @ 2133]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2093
diff
changeset
|
1173 return 0; |
2086 | 1174 } |
1175 | |
2167
edf8c5a70e5b
[gaim-migrate @ 2177]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2162
diff
changeset
|
1176 static int msn_chat_send(struct gaim_connection *gc, int id, char *message) |
2086 | 1177 { |
1178 struct msn_switchboard *ms = msn_find_switch_by_id(gc, id); | |
1179 char buf[MSN_BUF_LEN]; | |
1180 | |
1181 if (!ms) | |
2167
edf8c5a70e5b
[gaim-migrate @ 2177]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2162
diff
changeset
|
1182 return -EINVAL; |
2086 | 1183 |
1184 g_snprintf(buf, sizeof(buf), "MSG %d N %d\r\n%s%s", ++ms->trId, | |
1185 strlen(MIME_HEADER) + strlen(message), | |
1186 MIME_HEADER, message); | |
1187 if (msn_write(ms->fd, buf, strlen(buf)) < 0) | |
1188 msn_kill_switch(ms); | |
1189 debug_printf("\n"); | |
1190 serv_got_chat_in(gc, id, gc->username, 0, message, time(NULL)); | |
2167
edf8c5a70e5b
[gaim-migrate @ 2177]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2162
diff
changeset
|
1191 return 0; |
2086 | 1192 } |
1193 | |
1194 static void msn_chat_invite(struct gaim_connection *gc, int id, char *msg, char *who) | |
1195 { | |
1196 struct msn_switchboard *ms = msn_find_switch_by_id(gc, id); | |
1197 char buf[MSN_BUF_LEN]; | |
1198 | |
1199 if (!ms) | |
1200 return; | |
1201 | |
1202 g_snprintf(buf, sizeof(buf), "CAL %d %s\n", ++ms->trId, who); | |
1203 if (msn_write(ms->fd, buf, strlen(buf)) < 0) | |
1204 msn_kill_switch(ms); | |
1205 } | |
1206 | |
1207 static void msn_chat_leave(struct gaim_connection *gc, int id) | |
1208 { | |
1209 struct msn_switchboard *ms = msn_find_switch_by_id(gc, id); | |
1210 char buf[MSN_BUF_LEN]; | |
1211 | |
1212 if (!ms) | |
1213 return; | |
1214 | |
1215 g_snprintf(buf, sizeof(buf), "OUT\n"); | |
1216 if (msn_write(ms->fd, buf, strlen(buf)) < 0) | |
1217 msn_kill_switch(ms); | |
1218 } | |
1219 | |
1220 static GList *msn_away_states() | |
1221 { | |
1222 GList *m = NULL; | |
1223 | |
1224 m = g_list_append(m, "Available"); | |
1225 m = g_list_append(m, "Away From Computer"); | |
1226 m = g_list_append(m, "Be Right Back"); | |
1227 m = g_list_append(m, "Busy"); | |
1228 m = g_list_append(m, "On The Phone"); | |
1229 m = g_list_append(m, "Out To Lunch"); | |
2152
f631cfc8e824
[gaim-migrate @ 2162]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2123
diff
changeset
|
1230 m = g_list_append(m, "Hidden"); |
2086 | 1231 |
1232 return m; | |
1233 } | |
1234 | |
1235 static void msn_set_away(struct gaim_connection *gc, char *state, char *msg) | |
1236 { | |
1237 struct msn_data *md = gc->proto_data; | |
1238 char buf[MSN_BUF_LEN]; | |
1239 char *away; | |
1240 | |
1241 gc->away = NULL; | |
1242 | |
1243 if (msg) { | |
1244 gc->away = ""; | |
1245 away = "AWY"; | |
1246 } else if (state) { | |
1247 gc->away = ""; | |
1248 | |
1249 if (!strcmp(state, "Away From Computer")) | |
1250 away = "AWY"; | |
1251 else if (!strcmp(state, "Be Right Back")) | |
1252 away = "BRB"; | |
1253 else if (!strcmp(state, "Busy")) | |
1254 away = "BSY"; | |
1255 else if (!strcmp(state, "On The Phone")) | |
1256 away = "PHN"; | |
1257 else if (!strcmp(state, "Out To Lunch")) | |
1258 away = "LUN"; | |
2152
f631cfc8e824
[gaim-migrate @ 2162]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2123
diff
changeset
|
1259 else if (!strcmp(state, "Hidden")) |
f631cfc8e824
[gaim-migrate @ 2162]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2123
diff
changeset
|
1260 away = "HDN"; |
2086 | 1261 else { |
1262 gc->away = NULL; | |
1263 away = "NLN"; | |
1264 } | |
1265 } else if (gc->is_idle) | |
1266 away = "IDL"; | |
1267 else | |
1268 away = "NLN"; | |
1269 | |
1270 g_snprintf(buf, sizeof(buf), "CHG %d %s\n", ++md->trId, away); | |
1271 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
1272 hide_login_progress(gc, "Write error"); | |
1273 signoff(gc); | |
1274 return; | |
1275 } | |
1276 } | |
1277 | |
1278 static void msn_set_idle(struct gaim_connection *gc, int idle) | |
1279 { | |
1280 struct msn_data *md = gc->proto_data; | |
1281 char buf[MSN_BUF_LEN]; | |
1282 | |
1283 if (gc->away) | |
1284 return; | |
1285 if (idle) | |
1286 g_snprintf(buf, sizeof(buf), "CHG %d IDL\n", ++md->trId); | |
1287 else | |
1288 g_snprintf(buf, sizeof(buf), "CHG %d NLN\n", ++md->trId); | |
1289 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
1290 hide_login_progress(gc, "Write error"); | |
1291 signoff(gc); | |
1292 return; | |
1293 } | |
1294 } | |
1295 | |
1296 static char **msn_list_icon(int uc) | |
1297 { | |
1298 if (uc == UC_NORMAL) | |
1299 return msn_online_xpm; | |
1300 | |
1301 return msn_away_xpm; | |
1302 } | |
1303 | |
1304 static char *msn_get_away_text(int s) | |
1305 { | |
1306 switch (s) { | |
1307 case MSN_BUSY : | |
1308 return "Busy"; | |
1309 case MSN_BRB : | |
1310 return "Be right back"; | |
1311 case MSN_AWAY : | |
1312 return "Away from the computer"; | |
1313 case MSN_PHONE : | |
1314 return "On the phone"; | |
1315 case MSN_LUNCH : | |
1316 return "Out to lunch"; | |
1317 case MSN_IDLE : | |
1318 return "Idle"; | |
1319 default: | |
1320 return "Available"; | |
1321 } | |
1322 } | |
1323 | |
1324 static void msn_buddy_menu(GtkWidget *menu, struct gaim_connection *gc, char *who) | |
1325 { | |
1326 struct buddy *b = find_buddy(gc, who); | |
1327 char buf[MSN_BUF_LEN]; | |
1328 GtkWidget *button; | |
1329 | |
1330 if (!b || !(b->uc >> 5)) | |
1331 return; | |
1332 | |
1333 g_snprintf(buf, sizeof(buf), "Status: %s", msn_get_away_text(b->uc >> 5)); | |
1334 | |
1335 button = gtk_menu_item_new_with_label(buf); | |
1336 gtk_menu_append(GTK_MENU(menu), button); | |
1337 gtk_widget_show(button); | |
1338 } | |
1339 | |
1340 static void msn_add_buddy(struct gaim_connection *gc, char *who) | |
1341 { | |
1342 struct msn_data *md = gc->proto_data; | |
1343 char buf[MSN_BUF_LEN]; | |
1344 GSList *l = md->fl; | |
1345 | |
1346 while (l) { | |
1347 struct msn_buddy *b = l->data; | |
1348 if (!g_strcasecmp(who, b->user)) | |
1349 break; | |
1350 l = l->next; | |
1351 } | |
1352 if (l) | |
1353 return; | |
1354 | |
1355 g_snprintf(buf, sizeof(buf), "ADD %d FL %s %s\n", ++md->trId, who, who); | |
1356 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
1357 hide_login_progress(gc, "Write error"); | |
1358 signoff(gc); | |
1359 return; | |
1360 } | |
1361 } | |
1362 | |
1363 static void msn_rem_buddy(struct gaim_connection *gc, char *who) | |
1364 { | |
1365 struct msn_data *md = gc->proto_data; | |
1366 char buf[MSN_BUF_LEN]; | |
1367 | |
1368 g_snprintf(buf, sizeof(buf), "REM %d FL %s\n", ++md->trId, who); | |
1369 if (msn_write(md->fd, buf, strlen(buf)) < 0) { | |
1370 hide_login_progress(gc, "Write error"); | |
1371 signoff(gc); | |
1372 return; | |
1373 } | |
1374 } | |
1375 | |
1376 static struct prpl *my_protocol = NULL; | |
1377 | |
1378 void msn_init(struct prpl *ret) | |
1379 { | |
1380 ret->protocol = PROTO_MSN; | |
2153
0befa2d2e540
[gaim-migrate @ 2163]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2152
diff
changeset
|
1381 ret->options = OPT_PROTO_MAIL_CHECK; |
2086 | 1382 ret->name = msn_name; |
1383 ret->list_icon = msn_list_icon; | |
1384 ret->buddy_menu = msn_buddy_menu; | |
1385 ret->login = msn_login; | |
1386 ret->close = msn_close; | |
1387 ret->send_im = msn_send_im; | |
1388 ret->away_states = msn_away_states; | |
1389 ret->set_away = msn_set_away; | |
1390 ret->set_idle = msn_set_idle; | |
1391 ret->add_buddy = msn_add_buddy; | |
1392 ret->remove_buddy = msn_rem_buddy; | |
1393 ret->chat_send = msn_chat_send; | |
1394 ret->chat_invite = msn_chat_invite; | |
1395 ret->chat_leave = msn_chat_leave; | |
1396 ret->normalize = msn_normalize; | |
1397 | |
1398 my_protocol = ret; | |
1399 } | |
1400 | |
1401 #ifndef STATIC | |
1402 | |
1403 char *gaim_plugin_init(GModule *handle) | |
1404 { | |
1405 load_protocol(msn_init, sizeof(struct prpl)); | |
1406 return NULL; | |
1407 } | |
1408 | |
1409 void gaim_plugin_remove() | |
1410 { | |
1411 struct prpl *p = find_prpl(PROTO_MSN); | |
1412 if (p == my_protocol) | |
1413 unload_protocol(p); | |
1414 } | |
1415 | |
1416 char *name() | |
1417 { | |
1418 return "MSN"; | |
1419 } | |
1420 | |
1421 char *description() | |
1422 { | |
2162
a464da684307
[gaim-migrate @ 2172]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2153
diff
changeset
|
1423 return PRPL_DESC("MSN"); |
2086 | 1424 } |
1425 | |
1426 #endif |