Mercurial > pidgin.yaz
annotate plugins/msn/msn.c @ 1603:b9f6f0190787
[gaim-migrate @ 1613]
A cow goes: Moo
committer: Tailor Script <tailor@pidgin.im>
author | Rob Flynn <gaim@robflynn.com> |
---|---|
date | Fri, 16 Mar 2001 23:52:04 +0000 |
parents | aa82b76afa3a |
children | bde395f3dbf1 |
rev | line source |
---|---|
1259 | 1 /* |
2 * gaim - MSN Protocol Plugin | |
3 * | |
4 * Copyright (C) 2000, Rob Flynn <rob@tgflinux.com> | |
5 * | |
6 * This program is free software; you can redistribute it and/or modify | |
7 * it under the terms of the GNU General Public License as published by | |
8 * the Free Software Foundation; either version 2 of the License, or | |
9 * (at your option) any later version. | |
10 * | |
11 * This program is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 * GNU General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public License | |
17 * along with this program; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 * | |
20 */ | |
21 | |
1514
0dd012166152
[gaim-migrate @ 1524]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1499
diff
changeset
|
22 #include "config.h" |
1259 | 23 |
24 #include <netdb.h> | |
25 #include <gtk/gtk.h> | |
26 #include <unistd.h> | |
27 #include <errno.h> | |
28 #include <netinet/in.h> | |
29 #include <arpa/inet.h> | |
30 #include <string.h> | |
31 #include <stdlib.h> | |
32 #include <stdio.h> | |
33 #include <time.h> | |
1567 | 34 #include <fcntl.h> |
1259 | 35 #include <sys/socket.h> |
36 #include <sys/stat.h> | |
1567 | 37 #include <sys/types.h> |
1259 | 38 #include "multi.h" |
39 #include "prpl.h" | |
40 #include "gaim.h" | |
41 #include "md5.h" | |
42 | |
1284 | 43 #include "pixmaps/msn_online.xpm" |
1285 | 44 #include "pixmaps/msn_away.xpm" |
1284 | 45 |
1567 | 46 #define MIME_HEADER "MIME-Version: 1.0\r\nContent-Type: text/plain; charset=UTF-8\r\nX-MMS-IM-Format: FN=MS%20Sans%20Serif; EF=; CO=0; CS=0; PF=0\r\n\r\n" |
1259 | 47 |
1567 | 48 #define MSN_BUF_LEN 8192 |
1259 | 49 |
50 #define MSN_ONLINE 1 | |
51 #define MSN_BUSY 2 | |
52 #define MSN_IDLE 3 | |
53 #define MSN_BRB 4 | |
54 #define MSN_AWAY 5 | |
55 #define MSN_PHONE 6 | |
56 #define MSN_LUNCH 7 | |
57 #define MSN_OFFLINE 8 | |
58 #define MSN_HIDDEN 9 | |
59 | |
1567 | 60 #define MSN_SIGNON_GOT_XFR 0x0001 |
61 #define MSN_SIGNON_SENT_USR 0x0002 | |
1259 | 62 |
1598 | 63 struct msn_ask_add_permit { |
64 struct gaim_connection *gc; | |
65 char *user; | |
66 char *friendly; | |
67 }; | |
68 | |
1259 | 69 struct msn_data { |
70 int fd; | |
71 | |
72 char protocol[6]; | |
73 char *friendly; | |
74 gchar *policy; | |
1567 | 75 int inpa; |
76 int status; | |
77 time_t last_trid; | |
1259 | 78 }; |
79 | |
80 struct msn_conn { | |
81 gchar *user; | |
82 int inpa; | |
83 int fd; | |
1572 | 84 struct gaim_connection *gc; |
85 char *secret; | |
86 char *session; | |
1584 | 87 time_t last_trid; |
88 char *txqueue; | |
1259 | 89 }; |
90 | |
1567 | 91 GSList *msn_connections = NULL; |
1259 | 92 |
1567 | 93 unsigned long long globalc = 0; |
1572 | 94 static void msn_callback(gpointer data, gint source, GdkInputCondition condition); |
1598 | 95 static void msn_add_permit(struct gaim_connection *gc, char *who); |
96 | |
97 void msn_accept_add_permit(gpointer w, struct msn_ask_add_permit *ap) | |
98 { | |
99 msn_add_permit(ap->gc, ap->user); | |
100 } | |
101 | |
102 void msn_cancel_add_permit(gpointer w, struct msn_ask_add_permit *ap) | |
103 { | |
104 g_free(ap->user); | |
105 g_free(ap->friendly); | |
106 g_free(ap); | |
107 } | |
1259 | 108 |
1588 | 109 void free_msn_conn(struct msn_conn *mc) |
110 { | |
111 if (mc->user) | |
112 free(mc->user); | |
113 | |
114 if (mc->secret) | |
115 free(mc->secret); | |
116 | |
117 if (mc->session) | |
118 free(mc->session); | |
119 | |
120 if (mc->txqueue) | |
121 free(mc->txqueue); | |
122 | |
123 gdk_input_remove(mc->inpa); | |
124 close(mc->fd); | |
125 | |
126 msn_connections = g_slist_remove(msn_connections, mc); | |
127 | |
128 g_free(mc); | |
129 } | |
130 | |
131 | |
1584 | 132 struct msn_conn *find_msn_conn_by_user(gchar * user) |
133 { | |
134 struct msn_conn *mc; | |
135 GSList *conns = msn_connections; | |
136 | |
137 while (conns) { | |
138 mc = (struct msn_conn *)conns->data; | |
139 | |
140 if (mc != NULL) { | |
141 if (strcasecmp(mc->user, user) == 0) { | |
142 return mc; | |
143 } | |
144 } | |
145 | |
146 conns = g_slist_next(conns); | |
147 } | |
148 | |
149 return NULL; | |
150 } | |
151 | |
152 struct msn_conn *find_msn_conn_by_trid(time_t trid) | |
153 { | |
154 struct msn_conn *mc; | |
155 GSList *conns = msn_connections; | |
156 | |
157 while (conns) { | |
158 mc = (struct msn_conn *)conns->data; | |
159 | |
160 if (mc != NULL) { | |
161 | |
162 printf("Comparing: %d <==> %d\n", mc->last_trid, trid); | |
163 if (mc->last_trid == trid) { | |
164 return mc; | |
165 } | |
166 } | |
167 | |
168 conns = g_slist_next(conns); | |
169 } | |
170 | |
171 return NULL; | |
172 } | |
173 | |
1282 | 174 static char *msn_name() |
175 { | |
1259 | 176 return "MSN"; |
177 } | |
178 | |
1282 | 179 char *name() |
180 { | |
1259 | 181 return "MSN"; |
182 } | |
183 | |
1282 | 184 char *description() |
185 { | |
1259 | 186 return "Allows gaim to use the MSN protocol. For some reason, this frightens me."; |
187 } | |
188 | |
1567 | 189 time_t trId(struct msn_data *md) |
1282 | 190 { |
1567 | 191 md->last_trid = time((time_t *)NULL) + globalc++; |
192 return md->last_trid; | |
193 } | |
194 | |
195 void msn_write(int fd, char *buf) | |
196 { | |
197 write(fd, buf, strlen(buf)); | |
1585 | 198 printf("MSN(%d) <== %s", fd, buf); |
1567 | 199 } |
1259 | 200 |
1572 | 201 static void msn_answer_callback(gpointer data, gint source, GdkInputCondition condition) |
202 { | |
203 struct msn_conn *mc = data; | |
204 char buf[MSN_BUF_LEN]; | |
205 | |
206 fcntl(source, F_SETFL, 0); | |
207 | |
208 g_snprintf(buf, MSN_BUF_LEN, "ANS 1 %s %s %s\n", mc->gc->username, mc->secret, mc->session); | |
209 msn_write(mc->fd, buf); | |
210 | |
211 gdk_input_remove(mc->inpa); | |
212 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_callback, mc->gc); | |
213 | |
214 /* Append our connection */ | |
215 msn_connections = g_slist_append(msn_connections, mc); | |
216 } | |
217 | |
1584 | 218 static void msn_invite_callback(gpointer data, gint source, GdkInputCondition condition) |
219 { | |
220 struct msn_conn *mc = data; | |
221 struct msn_data *md = (struct msn_data *)mc->gc->proto_data; | |
222 char buf[MSN_BUF_LEN]; | |
223 struct gaim_connection *gc = mc->gc; | |
224 int i = 0; | |
1585 | 225 |
226 fcntl(source, F_SETFL, 0); | |
1584 | 227 |
1585 | 228 printf("GOT HERE|\n"); |
1584 | 229 |
230 if (condition == GDK_INPUT_WRITE) | |
231 { | |
232 /* We just got in here */ | |
233 gdk_input_remove(mc->inpa); | |
234 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_invite_callback, mc); | |
235 | |
236 /* Write our signon request */ | |
237 g_snprintf(buf, MSN_BUF_LEN, "USR %d %s %s\n", mc->last_trid, mc->gc->username, mc->secret); | |
1585 | 238 msn_write(mc->fd, buf); |
1584 | 239 return; |
240 } | |
241 | |
242 bzero(buf, MSN_BUF_LEN); | |
243 do | |
244 { | |
1588 | 245 if (!read(source, buf + i, 1)) |
1584 | 246 { |
1588 | 247 free_msn_conn(mc); |
1584 | 248 return; |
249 } | |
250 | |
251 } while (buf[i++] != '\n'); | |
252 | |
253 g_strchomp(buf); | |
254 | |
1585 | 255 printf("!!MSN(%d) ==> %s\n", source, buf); |
256 printf("Got here.\n"); | |
1584 | 257 |
258 if (!strncmp("USR ", buf, 4)) | |
259 { | |
260 char **res; | |
261 | |
1585 | 262 printf("Got here2.\n"); |
263 | |
1584 | 264 res = g_strsplit(buf, " ", 0); |
1585 | 265 printf("%s\n",res[2]); |
1584 | 266 if (strcasecmp("OK", res[2])) |
267 { | |
268 g_strfreev(res); | |
269 close(mc->fd); | |
270 return; | |
271 } | |
272 | |
273 /* We've authorized. Let's send an invite request */ | |
274 g_snprintf(buf, MSN_BUF_LEN, "CAL %d %s\n", trId(md), mc->user); | |
275 msn_write(source, buf); | |
276 return; | |
277 } | |
278 | |
279 else if (!strncmp("JOI ", buf, 4)) | |
280 { | |
281 /* Looks like they just joined! Write their queued message */ | |
282 g_snprintf(buf, MSN_BUF_LEN, "MSG %d N %d\r\n%s%s", trId(md), strlen(mc->txqueue) + strlen(MIME_HEADER), MIME_HEADER, mc->txqueue); | |
283 | |
284 msn_write(source, buf); | |
285 | |
286 gdk_input_remove(mc->inpa); | |
287 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_callback, mc->gc); | |
288 | |
289 return; | |
290 | |
291 } | |
292 } | |
293 | |
1567 | 294 static void msn_callback(gpointer data, gint source, GdkInputCondition condition) |
295 { | |
296 struct gaim_connection *gc = data; | |
297 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
298 char buf[MSN_BUF_LEN]; | |
299 int i = 0; | |
1572 | 300 int num; |
1259 | 301 |
1567 | 302 bzero(buf, MSN_BUF_LEN); |
303 | |
304 do | |
305 { | |
1588 | 306 if (!read(source, buf + i, 1)) |
1567 | 307 { |
1588 | 308 if (md->fd == source) |
309 { | |
310 hide_login_progress(gc, "Read error"); | |
311 signoff(gc); | |
312 } | |
313 | |
314 close(source); | |
315 | |
1567 | 316 return; |
1259 | 317 } |
318 | |
1567 | 319 } while (buf[i++] != '\n'); |
320 | |
321 g_strchomp(buf); | |
322 | |
1572 | 323 printf("MSN(%d) ==> %s\n", source, buf); |
1567 | 324 |
1569 | 325 if (!strncmp("NLN ", buf, 4) || !strncmp("ILN ", buf, 4)) |
326 { | |
327 int status; | |
328 int query; | |
329 char **res; | |
330 | |
331 res = g_strsplit(buf, " ", 0); | |
332 | |
333 if (!strcmp(res[0], "NLN")) | |
334 query = 1; | |
335 else | |
336 query = 2; | |
337 | |
338 if (!strcasecmp(res[query], "NLN")) | |
339 status = UC_NORMAL; | |
340 else if (!strcasecmp(res[query], "BSY")) | |
341 status = UC_NORMAL | (MSN_BUSY << 5); | |
342 else if (!strcasecmp(res[query], "IDL")) | |
343 status = UC_NORMAL | (MSN_IDLE << 5); | |
344 else if (!strcasecmp(res[query], "BRB")) | |
345 status = UC_NORMAL | (MSN_BRB << 5); | |
346 else if (!strcasecmp(res[query], "AWY")) | |
347 status = UC_UNAVAILABLE; | |
348 else if (!strcasecmp(res[query], "PHN")) | |
349 status = UC_NORMAL | (MSN_PHONE << 5); | |
350 else if (!strcasecmp(res[query], "LUN")) | |
351 status = UC_NORMAL | (MSN_LUNCH << 5); | |
352 else | |
353 status = UC_NORMAL; | |
354 | |
355 serv_got_update(gc, res[query+1], 1, 0, 0, 0, status, 0); | |
356 | |
357 g_strfreev(res); | |
358 | |
359 return; | |
360 | |
361 } | |
1572 | 362 else if (!strncmp("MSG ", buf, 4)) |
363 { | |
364 /* We are receiving an incoming message */ | |
365 gchar **res; | |
366 gchar *user; | |
367 gchar *msgdata; | |
368 int size; | |
369 | |
370 res = g_strsplit(buf, " ", 0); | |
371 | |
372 user = g_strdup(res[1]); | |
373 size = atoi(res[3]); | |
374 | |
375 /* Ok, we know who we're receiving a message from as well as | |
376 * how big the message is */ | |
377 | |
378 msgdata = (gchar *)g_malloc(sizeof(gchar) *(size + 1)); | |
379 num = recv(source, msgdata, size, 0); | |
380 msgdata[size] = 0; | |
381 | |
382 if (num < size) | |
383 printf("MSN: Uhh .. we gots a problem!. Expected %d but got %d.\n", size, num); | |
384 | |
385 /* We should ignore messages from the user Hotmail */ | |
386 if (!strcasecmp("hotmail", res[1])) | |
387 { | |
388 g_strfreev(res); | |
389 g_free(msgdata); | |
390 return; | |
391 } | |
392 | |
393 /* Check to see if any body is in the message */ | |
394 if (!strcmp(strstr(msgdata, "\r\n\r\n") + 4, "\r\n")) | |
395 { | |
396 g_strfreev(res); | |
397 g_free(msgdata); | |
398 return; | |
399 } | |
400 | |
401 /* Otherwise, everything is ok. Let's show the message. Skipping, | |
402 * of course, the header. */ | |
403 | |
404 serv_got_im(gc, res[1], strstr(msgdata, "\r\n\r\n") + 4, 0); | |
405 | |
406 g_strfreev(res); | |
407 g_free(msgdata); | |
408 | |
409 return; | |
410 } | |
411 else if (!strncmp("RNG ", buf, 4)) | |
412 { | |
413 /* Ok, someone wants to talk to us. Ring ring? Hi!!! */ | |
414 gchar **address; | |
415 gchar **res; | |
416 struct msn_conn *mc = g_new0(struct msn_conn, 1); | |
417 | |
418 res = g_strsplit(buf, " ", 0); | |
419 address = g_strsplit(res[2], ":", 0); | |
420 | |
421 if (!(mc->fd = msn_connect(address[0], atoi(address[1])))) | |
422 { | |
423 /* Looks like we had an error connecting. */ | |
424 g_strfreev(address); | |
425 g_strfreev(res); | |
426 g_free(mc); | |
427 return; | |
428 } | |
429 | |
430 /* Set up our struct with user and input watcher */ | |
431 mc->user = g_strdup(res[5]); | |
432 mc->secret = g_strdup(res[4]); | |
433 mc->session = g_strdup(res[1]); | |
434 mc->gc = gc; | |
435 | |
436 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_WRITE, msn_answer_callback, mc); | |
437 | |
438 g_strfreev(address); | |
439 g_strfreev(res); | |
440 | |
441 return; | |
442 } | |
1584 | 443 else if (!strncmp("XFR ", buf, 4)) |
444 { | |
445 char **res; | |
446 char *host; | |
447 char *port; | |
448 struct msn_conn *mc; | |
449 | |
450 res = g_strsplit(buf, " ", 0); | |
451 | |
452 printf("Last trid is: %d\n", md->last_trid); | |
453 printf("This TrId is: %d\n", atoi(res[1])); | |
454 | |
455 mc = find_msn_conn_by_trid(atoi(res[1])); | |
456 | |
457 if (!mc) | |
458 { | |
459 g_strfreev(res); | |
460 return; | |
461 } | |
462 | |
463 strcpy(buf, res[3]); | |
464 | |
465 mc->secret = g_strdup(res[5]); | |
466 mc->session = g_strdup(res[1]); | |
467 | |
468 g_strfreev(res); | |
469 | |
470 res = g_strsplit(buf, ":", 0); | |
471 | |
472 /* Now we have the host and port */ | |
1585 | 473 if (!(mc->fd = msn_connect(res[0], atoi(res[1])))) |
1584 | 474 return; |
475 | |
476 printf("Connected to: %s:%s\n", res[0], res[1]); | |
477 | |
1585 | 478 if (mc->inpa) |
479 gdk_input_remove(mc->inpa); | |
480 | |
1584 | 481 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_WRITE, msn_invite_callback, mc); |
482 | |
483 g_strfreev(res); | |
484 | |
485 return; | |
486 } | |
1569 | 487 else if (!strncmp("LST ", buf, 4)) |
1567 | 488 { |
489 char **res; | |
490 | |
491 res = g_strsplit(buf, " ", 0); | |
492 | |
1568 | 493 /* If we have zero buddies, abort */ |
494 if (atoi(res[5]) == 0) | |
495 { | |
496 g_strfreev(res); | |
497 return; | |
498 } | |
499 | |
1567 | 500 /* First, let's check the list type */ |
501 if (!strcmp("FL", res[2])) | |
502 { | |
503 /* We're dealing with a forward list. Add them | |
504 * to our buddylist and continue along our | |
505 * merry little way */ | |
506 | |
507 struct buddy *b; | |
508 | |
509 b = find_buddy(gc, res[6]); | |
510 | |
511 if (!b) | |
512 add_buddy(gc, "Buddies", res[6], res[7]); | |
513 } | |
514 | |
515 g_strfreev(res); | |
516 | |
517 return; | |
1259 | 518 } |
519 | |
520 } | |
521 | |
1567 | 522 static void msn_login_callback(gpointer data, gint source, GdkInputCondition condition) |
1282 | 523 { |
1567 | 524 struct gaim_connection *gc = data; |
525 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
526 char buf[MSN_BUF_LEN]; | |
1259 | 527 int i = 0; |
1282 | 528 |
1567 | 529 if (!gc->inpa) |
530 { | |
531 fcntl(source, F_SETFL, 0); | |
532 | |
533 gdk_input_remove(md->inpa); | |
534 md->inpa = 0; | |
535 | |
536 gc->inpa = gdk_input_add(md->fd, GDK_INPUT_READ, msn_login_callback, gc); | |
1307 | 537 |
1567 | 538 if (md->status & MSN_SIGNON_GOT_XFR) |
539 { | |
540 /* Looks like we were transfered here. Just send a sign on */ | |
541 set_login_progress(gc, 3, "Signing On"); | |
542 g_snprintf(buf, MSN_BUF_LEN, "USR %d %s I %s\n", md->last_trid, md->policy, gc->username); | |
543 msn_write(md->fd, buf); | |
544 | |
545 /* Reset this bit */ | |
546 md->status ^= MSN_SIGNON_GOT_XFR; | |
547 } | |
548 else | |
549 { | |
550 /* Otherwise, send an initial request */ | |
551 set_login_progress(gc, 2, "Verifiying"); | |
1259 | 552 |
1567 | 553 g_snprintf(md->protocol, 6, "MSNP2"); |
554 | |
555 g_snprintf(buf, MSN_BUF_LEN, "VER %d %s\n", trId(md), md->protocol); | |
556 msn_write(md->fd, buf); | |
557 } | |
558 | |
559 return; | |
560 } | |
561 | |
562 bzero(buf, MSN_BUF_LEN); | |
563 | |
564 do | |
565 { | |
1588 | 566 if (!read(source, buf + i, 1)) |
1567 | 567 { |
568 hide_login_progress(gc, "Read error"); | |
569 signoff(gc); | |
1259 | 570 return; |
1567 | 571 } |
1259 | 572 |
1567 | 573 } while (buf[i++] != '\n'); |
1259 | 574 |
575 g_strchomp(buf); | |
576 | |
1567 | 577 printf("MSN ==> %s\n", buf); |
578 | |
579 /* Check to see what was just sent back to us. We should be seeing a VER tag. */ | |
580 if (!strncmp("VER ", buf, 4) && (!strstr("MSNP2", buf))) | |
581 { | |
582 /* Now that we got our ver, we shoudl send a policy request */ | |
583 g_snprintf(buf, MSN_BUF_LEN, "INF %d\n", trId(md)); | |
584 msn_write(md->fd, buf); | |
585 | |
586 return; | |
587 } | |
588 else if (!strncmp("INF ", buf, 4)) | |
589 { | |
590 char **res; | |
591 | |
592 /* Make a copy of our resulting policy */ | |
593 res = g_strsplit(buf, " ", 0); | |
594 md->policy = g_strdup(res[2]); | |
595 | |
596 /* And send our signon packet */ | |
597 set_login_progress(gc, 3, "Signing On"); | |
598 | |
599 g_snprintf(buf, MSN_BUF_LEN, "USR %d %s I %s\n", trId(md), md->policy, gc->username); | |
600 msn_write(md->fd, buf); | |
601 | |
602 g_strfreev(res); | |
603 | |
604 return; | |
605 } | |
1598 | 606 else if (!strncmp("ADD ", buf, 4)) |
607 { | |
608 char **res; | |
609 | |
610 res = g_strsplit(buf, " ", 0); | |
611 | |
612 if (!strcasecmp(res[2], "RL")) | |
613 { | |
614 struct msn_ask_add_permit *ap = g_new0(struct msn_ask_add_permit, 1); | |
615 | |
616 snprintf(buf, MSN_BUF_LEN, "The user %s (%s) wants to add you to their buddylist.", res[4], res[5]); | |
617 | |
618 ap->user = g_strdup(res[4]); | |
619 ap->friendly = g_strdup(res[5]); | |
620 ap->gc = gc; | |
621 | |
622 do_ask_dialog(buf, ap, (GtkFunction) msn_accept_add_permit, (GtkFunction) msn_cancel_add_permit); | |
623 } | |
624 | |
625 g_strfreev(res); | |
626 return; | |
627 } | |
1589 | 628 else if (!strncmp("FLN ", buf, 4)) |
629 { | |
630 /* Someone signed off */ | |
631 char **res; | |
632 | |
633 res = g_strsplit(buf, " ", 0); | |
634 | |
635 serv_got_update(gc, res[1], 0, 0, 0, 0, 0, 0); | |
636 | |
637 g_strfreev(res); | |
638 | |
639 return; | |
640 } | |
641 if ( (!strncmp("NLN ", buf, 4)) || (!strncmp("ILN ", buf, 4))) | |
642 { | |
643 int status; | |
644 int query; | |
645 char **res; | |
646 | |
647 res = g_strsplit(buf, " ", 0); | |
648 | |
649 if (strcasecmp(res[0], "NLN") == 0) | |
650 query = 1; | |
651 else | |
652 query = 2; | |
653 | |
654 if (!strcasecmp(res[query], "NLN")) | |
655 status = UC_NORMAL; | |
656 else if (!strcasecmp(res[query], "BSY")) | |
657 status = UC_NORMAL | (MSN_BUSY << 5); | |
658 else if (!strcasecmp(res[query], "IDL")) | |
659 status = UC_NORMAL | (MSN_IDLE << 5); | |
660 else if (!strcasecmp(res[query], "BRB")) | |
661 status = UC_NORMAL | (MSN_BRB << 5); | |
662 else if (!strcasecmp(res[query], "AWY")) | |
663 status = UC_UNAVAILABLE; | |
664 else if (!strcasecmp(res[query], "PHN")) | |
665 status = UC_NORMAL | (MSN_PHONE << 5); | |
666 else if (!strcasecmp(res[query], "LUN")) | |
667 status = UC_NORMAL | (MSN_LUNCH << 5); | |
668 else | |
669 status = UC_NORMAL; | |
670 | |
671 serv_got_update(gc, res[query+1], 1, 0, 0, 0, status, 0); | |
672 | |
673 g_strfreev(res); | |
674 return; | |
675 } | |
676 | |
677 | |
1586 | 678 else if (!strncmp("BYE ", buf, 4)) |
679 { | |
680 char **res; | |
681 struct msn_conn *mc; | |
682 | |
683 res = g_strsplit(buf, " ", 0); | |
684 | |
685 mc = find_msn_conn_by_user(res[1]); | |
686 | |
687 if (mc) | |
688 { | |
689 /* Looks like we need to close up some stuff :-) */ | |
1588 | 690 free_msn_conn(mc); |
1586 | 691 } |
692 | |
693 g_strfreev(res); | |
694 return; | |
695 } | |
696 | |
1567 | 697 else if (!strncmp("XFR ", buf, 4)) |
698 { | |
699 char **res; | |
700 char *host; | |
701 char *port; | |
702 | |
703 res = g_strsplit(buf, " ", 0); | |
704 | |
705 strcpy(buf, res[3]); | |
706 | |
707 g_strfreev(res); | |
708 | |
709 res = g_strsplit(buf, ":", 0); | |
710 | |
711 close(md->fd); | |
712 | |
1603 | 713 set_login_progress(gc, 3, "Connecting to Auth"); |
1567 | 714 |
715 /* Now we have the host and port */ | |
716 if (!(md->fd = msn_connect(res[0], atoi(res[1])))) | |
717 { | |
718 hide_login_progress(gc, "Error connecting to server"); | |
719 signoff(gc); | |
720 return; | |
721 } | |
722 | |
723 g_strfreev(res); | |
724 | |
725 md->status |= MSN_SIGNON_GOT_XFR; | |
726 | |
727 gdk_input_remove(gc->inpa); | |
728 gc->inpa = 0; | |
729 | |
730 md->inpa = gdk_input_add(md->fd, GDK_INPUT_WRITE, msn_login_callback, gc); | |
731 | |
732 return; | |
733 } | |
734 else if (!strncmp("USR ", buf, 4)) | |
735 { | |
736 if (md->status & MSN_SIGNON_SENT_USR) | |
737 { | |
738 char **res; | |
739 | |
740 res = g_strsplit(buf, " ", 0); | |
741 | |
742 if (strcasecmp("OK", res[2])) | |
743 { | |
744 hide_login_progress(gc, "Error signing on"); | |
745 signoff(gc); | |
746 } | |
747 else | |
748 { | |
749 md->friendly = g_strdup(res[4]); | |
750 | |
751 /* Ok, ok. Your account is FINALLY online. Ya think Microsoft | |
752 * could have had any more steps involved? */ | |
753 | |
754 set_login_progress(gc, 4, "Fetching config"); | |
755 | |
756 /* Sync our buddylist */ | |
757 g_snprintf(buf, MSN_BUF_LEN, "SYN %d 0\n", trId(md)); | |
758 msn_write(md->fd, buf); | |
759 | |
760 /* And set ourselves online */ | |
761 g_snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
762 msn_write(md->fd, buf); | |
763 | |
764 account_online(gc); | |
765 serv_finish_login(gc); | |
766 | |
767 if (bud_list_cache_exists(gc)) | |
768 do_import(NULL, gc); | |
769 | |
770 gdk_input_remove(gc->inpa); | |
771 gc->inpa = gdk_input_add(md->fd, GDK_INPUT_READ, msn_callback, gc); | |
772 } | |
773 | |
774 g_strfreev(res); | |
775 } | |
776 else | |
777 { | |
778 char **res; | |
779 char buf2[MSN_BUF_LEN]; | |
780 int j; | |
781 md5_state_t st; | |
782 md5_byte_t di[16]; | |
783 | |
784 res = g_strsplit(buf, " ", 0); | |
785 | |
786 /* Make a copy of our MD5 Hash key */ | |
787 strcpy(buf, res[4]); | |
788 | |
789 /* Generate our secret with our key and password */ | |
790 snprintf(buf2, MSN_BUF_LEN, "%s%s", buf, gc->password); | |
791 | |
792 md5_init(&st); | |
793 md5_append(&st, (const md5_byte_t *)buf2, strlen(buf2)); | |
794 md5_finish(&st, di); | |
795 | |
796 /* Now that we have the MD5 Hash, lets' hex encode this bad boy. I smoke bad crack. */ | |
797 sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", | |
798 di[0],di[1],di[2],di[3],di[4],di[5],di[6],di[7],di[8],di[9],di[10],di[11],di[12], | |
799 di[13],di[14],di[15]); | |
800 | |
801 /* And now, send our final sign on packet */ | |
802 g_snprintf(buf2, MSN_BUF_LEN, "USR %s %s S %s\n", res[1], md->policy, buf); | |
803 msn_write(md->fd, buf2); | |
804 | |
805 md->status |= MSN_SIGNON_SENT_USR; | |
806 | |
807 g_strfreev(res); | |
808 } | |
809 | |
810 return; | |
811 } | |
1259 | 812 } |
813 | |
1282 | 814 int msn_connect(char *server, int port) |
815 { | |
1259 | 816 int fd; |
817 struct hostent *host; | |
818 struct sockaddr_in site; | |
819 | |
1567 | 820 if (!(host = gethostbyname(server))) |
821 { | |
822 printf("Could not resolve host name: %s\n", server); | |
1259 | 823 return -1; |
824 } | |
825 | |
1567 | 826 bzero(&site, sizeof(struct sockaddr_in)); |
827 site.sin_port = htons(port); | |
828 memcpy(&site.sin_addr, host->h_addr, host->h_length); | |
829 site.sin_family = host->h_addrtype; | |
1259 | 830 |
1567 | 831 fd = socket(host->h_addrtype, SOCK_STREAM, 0); |
1259 | 832 |
1567 | 833 fcntl(fd, F_SETFL, O_NONBLOCK); |
1259 | 834 |
1567 | 835 if (connect(fd, (struct sockaddr *)&site, sizeof(struct sockaddr_in)) < 0) |
836 { | |
837 if ((errno == EINPROGRESS) || (errno == EINTR)) | |
838 { | |
839 printf("Connection would block\n"); | |
840 return fd; | |
1259 | 841 } |
842 | |
1567 | 843 close(fd); |
844 fd = -1; | |
1259 | 845 } |
1567 | 846 |
847 return fd; | |
1259 | 848 } |
849 | |
1282 | 850 void msn_login(struct aim_user *user) |
851 { | |
1567 | 852 struct gaim_connection *gc = new_gaim_conn(user); |
853 struct msn_data *md = gc->proto_data = g_new0(struct msn_data, 1); | |
1282 | 854 |
1567 | 855 gc->inpa = 0; |
1282 | 856 |
857 set_login_progress(gc, 1, "Connecting"); | |
1259 | 858 |
859 while (gtk_events_pending()) | |
860 gtk_main_iteration(); | |
1567 | 861 |
1259 | 862 if (!g_slist_find(connections, gc)) |
863 return; | |
864 | |
1567 | 865 md->status = 0; |
1282 | 866 |
1567 | 867 if (!(md->fd = msn_connect("messenger.hotmail.com", 1863))) |
868 { | |
869 hide_login_progress(gc, "Error connecting to server"); | |
1259 | 870 signoff(gc); |
871 return; | |
872 } | |
873 | |
1567 | 874 md->inpa = gdk_input_add(md->fd, GDK_INPUT_WRITE, msn_login_callback, gc); |
1259 | 875 |
1567 | 876 printf("Connected.\n"); |
1284 | 877 } |
878 | |
1584 | 879 void msn_send_im(struct gaim_connection *gc, char *who, char *message, int away) |
880 { | |
881 struct msn_conn *mc; | |
882 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
883 char buf[MSN_BUF_LEN]; | |
884 | |
885 if (!g_strcasecmp(who, gc->username)) | |
886 { | |
887 do_error_dialog("You can not send a message to yourself!", "Gaim: MSN Error"); | |
888 return; | |
889 } | |
890 | |
891 mc = find_msn_conn_by_user(who); | |
892 | |
893 /* If we're not already in a conversation with | |
894 * this person then we have to do some tricky things. */ | |
895 | |
896 if (!mc) | |
897 { | |
898 gchar buf2[MSN_BUF_LEN]; | |
899 gchar *address; | |
900 gchar *auth; | |
901 gchar **res; | |
902 | |
903 /* Request a new switchboard connection */ | |
904 g_snprintf(buf, MSN_BUF_LEN, "XFR %d SB\n", trId(md)); | |
905 msn_write(md->fd, buf); | |
906 | |
907 mc = g_new0(struct msn_conn, 1); | |
908 | |
909 mc->user = g_strdup(who); | |
910 mc->gc = gc; | |
911 mc->last_trid = md->last_trid; | |
912 mc->txqueue = g_strdup(message); | |
913 | |
914 /* Append our connection */ | |
915 msn_connections = g_slist_append(msn_connections, mc); | |
916 } | |
1585 | 917 else |
918 { | |
1598 | 919 g_snprintf(buf, MSN_BUF_LEN, "MSG %d N %d\r\n%s%s", trId(md), |
920 strlen(message) + strlen(MIME_HEADER), MIME_HEADER, message); | |
1585 | 921 |
922 msn_write(mc->fd, buf); | |
923 } | |
1584 | 924 |
925 } | |
926 | |
1598 | 927 static void msn_add_buddy(struct gaim_connection *gc, char *who) |
928 { | |
929 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
930 char buf[MSN_BUF_LEN - 1]; | |
931 | |
932 snprintf(buf, MSN_BUF_LEN, "ADD %d FL %s %s\n", trId(md), who, who); | |
933 msn_write(md->fd, buf); | |
934 } | |
935 | |
936 static void msn_remove_buddy(struct gaim_connection *gc, char *who) | |
937 { | |
938 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
939 char buf[MSN_BUF_LEN - 1]; | |
940 | |
941 snprintf(buf, MSN_BUF_LEN, "REM %d FL %s\n", trId(md), who); | |
942 msn_write(md->fd, buf); | |
943 } | |
944 | |
945 static void msn_rem_permit(struct gaim_connection *gc, char *who) | |
946 { | |
947 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
948 char buf[MSN_BUF_LEN - 1]; | |
949 | |
950 snprintf(buf, MSN_BUF_LEN, "REM %d AL %s\n", trId(md), who); | |
951 msn_write(md->fd, buf); | |
952 } | |
953 | |
954 static void msn_add_permit(struct gaim_connection *gc, char *who) | |
955 { | |
956 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
957 char buf[MSN_BUF_LEN - 1]; | |
958 | |
959 snprintf(buf, MSN_BUF_LEN, "ADD %d AL %s %s\n", trId(md), who, who); | |
960 msn_write(md->fd, buf); | |
961 } | |
962 | |
963 static void msn_rem_deny(struct gaim_connection *gc, char *who) | |
964 { | |
965 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
966 char buf[MSN_BUF_LEN - 1]; | |
967 | |
968 snprintf(buf, MSN_BUF_LEN, "REM %d BL %s\n", trId(md), who); | |
969 msn_write(md->fd, buf); | |
970 } | |
971 | |
972 static void msn_add_deny(struct gaim_connection *gc, char *who) | |
973 { | |
974 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
975 char buf[MSN_BUF_LEN - 1]; | |
976 | |
977 snprintf(buf, MSN_BUF_LEN, "ADD %d BL %s %s\n", trId(md), who, who); | |
978 msn_write(md->fd, buf); | |
979 } | |
980 | |
1600 | 981 static void msn_set_away(struct gaim_connection *gc, char *state, char *msg) |
982 { | |
983 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
984 char buf[MSN_BUF_LEN - 1]; | |
985 | |
986 if (msg) | |
987 snprintf(buf, MSN_BUF_LEN, "CHG %d AWY\n", trId(md)); | |
988 else if (gc->is_idle) | |
989 snprintf(buf, MSN_BUF_LEN, "CHG %d IDL\n", trId(md)); | |
990 else | |
991 snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
992 | |
993 msn_write(md->fd, buf); | |
994 } | |
995 | |
996 | |
997 static void msn_set_idle(struct gaim_connection *gc, int idle) | |
998 { | |
999 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1000 char buf[MSN_BUF_LEN - 1]; | |
1001 | |
1002 if (idle) | |
1003 snprintf(buf, MSN_BUF_LEN, "CHG %d IDL\n", trId(md)); | |
1004 else | |
1005 snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
1006 | |
1007 msn_write(md->fd, buf); | |
1008 } | |
1009 | |
1010 static void msn_close(struct gaim_connection *gc) | |
1011 { | |
1012 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1013 char buf[MSN_BUF_LEN - 1]; | |
1014 struct msn_conn *mc = NULL; | |
1015 | |
1016 while (msn_connections) | |
1017 { | |
1018 mc = (struct msn_conn *)msn_connections->data; | |
1019 | |
1020 free_msn_conn(mc); | |
1021 } | |
1022 | |
1023 if (md->fd) | |
1024 { | |
1025 snprintf(buf, MSN_BUF_LEN, "OUT\n"); | |
1026 msn_write(md->fd, buf); | |
1027 close(md->fd); | |
1028 } | |
1029 | |
1030 if (gc->inpa) | |
1031 gdk_input_remove(gc->inpa); | |
1032 | |
1033 if (md->friendly) | |
1034 free(md->friendly); | |
1035 | |
1036 g_free(gc->proto_data); | |
1037 } | |
1038 | |
1572 | 1039 static char **msn_list_icon(int uc) |
1040 { | |
1041 if (uc == UC_UNAVAILABLE) | |
1042 return msn_away_xpm; | |
1043 else if (uc == UC_NORMAL) | |
1044 return msn_online_xpm; | |
1045 | |
1046 return msn_online_xpm; | |
1047 } | |
1048 | |
1259 | 1049 static struct prpl *my_protocol = NULL; |
1050 | |
1282 | 1051 void msn_init(struct prpl *ret) |
1052 { | |
1259 | 1053 ret->protocol = PROTO_MSN; |
1054 ret->name = msn_name; | |
1572 | 1055 ret->list_icon = msn_list_icon; |
1499
de0b946e86a4
[gaim-migrate @ 1509]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1443
diff
changeset
|
1056 ret->buddy_menu = NULL; |
1259 | 1057 ret->user_opts = NULL; |
1058 ret->login = msn_login; | |
1600 | 1059 ret->close = msn_close; |
1584 | 1060 ret->send_im = msn_send_im; |
1259 | 1061 ret->set_info = NULL; |
1062 ret->get_info = NULL; | |
1600 | 1063 ret->set_away = msn_set_away; |
1259 | 1064 ret->get_away_msg = NULL; |
1065 ret->set_dir = NULL; | |
1066 ret->get_dir = NULL; | |
1067 ret->dir_search = NULL; | |
1600 | 1068 ret->set_idle = msn_set_idle; |
1259 | 1069 ret->change_passwd = NULL; |
1598 | 1070 ret->add_buddy = msn_add_buddy; |
1259 | 1071 ret->add_buddies = NULL; |
1598 | 1072 ret->remove_buddy = msn_remove_buddy; |
1073 ret->add_permit = msn_add_permit; | |
1074 ret->rem_permit = msn_rem_permit; | |
1075 ret->add_deny = msn_add_deny; | |
1076 ret->rem_deny = msn_rem_deny; | |
1259 | 1077 ret->warn = NULL; |
1078 ret->accept_chat = NULL; | |
1079 ret->join_chat = NULL; | |
1080 ret->chat_invite = NULL; | |
1081 ret->chat_leave = NULL; | |
1082 ret->chat_whisper = NULL; | |
1083 ret->chat_send = NULL; | |
1084 ret->keepalive = NULL; | |
1085 | |
1086 my_protocol = ret; | |
1087 } | |
1088 | |
1282 | 1089 char *gaim_plugin_init(GModule * handle) |
1090 { | |
1443
336fc98b7f90
[gaim-migrate @ 1453]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1327
diff
changeset
|
1091 load_protocol(msn_init, sizeof(struct prpl)); |
1259 | 1092 return NULL; |
1093 } | |
1094 | |
1282 | 1095 void gaim_plugin_remove() |
1096 { | |
1259 | 1097 struct prpl *p = find_prpl(PROTO_MSN); |
1098 if (p == my_protocol) | |
1099 unload_protocol(p); | |
1100 } |