Mercurial > pidgin
annotate plugins/msn/msn.c @ 1628:bde395f3dbf1
[gaim-migrate @ 1638]
You are my nice friend!! Thank you pokey! YES!
committer: Tailor Script <tailor@pidgin.im>
author | Rob Flynn <gaim@robflynn.com> |
---|---|
date | Thu, 22 Mar 2001 19:31:43 +0000 |
parents | b9f6f0190787 |
children | 862a2acf2bcc |
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 | |
1628 | 255 printf("MSN(%d) ==> %s\n", source, buf); |
1584 | 256 |
257 if (!strncmp("USR ", buf, 4)) | |
258 { | |
259 char **res; | |
260 | |
261 res = g_strsplit(buf, " ", 0); | |
1585 | 262 printf("%s\n",res[2]); |
1584 | 263 if (strcasecmp("OK", res[2])) |
264 { | |
265 g_strfreev(res); | |
266 close(mc->fd); | |
267 return; | |
268 } | |
269 | |
270 /* We've authorized. Let's send an invite request */ | |
271 g_snprintf(buf, MSN_BUF_LEN, "CAL %d %s\n", trId(md), mc->user); | |
272 msn_write(source, buf); | |
273 return; | |
274 } | |
275 | |
276 else if (!strncmp("JOI ", buf, 4)) | |
277 { | |
278 /* Looks like they just joined! Write their queued message */ | |
279 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); | |
280 | |
281 msn_write(source, buf); | |
282 | |
283 gdk_input_remove(mc->inpa); | |
284 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_callback, mc->gc); | |
285 | |
286 return; | |
287 | |
288 } | |
289 } | |
290 | |
1567 | 291 static void msn_callback(gpointer data, gint source, GdkInputCondition condition) |
292 { | |
293 struct gaim_connection *gc = data; | |
294 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
295 char buf[MSN_BUF_LEN]; | |
296 int i = 0; | |
1572 | 297 int num; |
1259 | 298 |
1567 | 299 bzero(buf, MSN_BUF_LEN); |
300 | |
301 do | |
302 { | |
1588 | 303 if (!read(source, buf + i, 1)) |
1567 | 304 { |
1588 | 305 if (md->fd == source) |
306 { | |
307 hide_login_progress(gc, "Read error"); | |
308 signoff(gc); | |
309 } | |
310 | |
311 close(source); | |
312 | |
1567 | 313 return; |
1259 | 314 } |
315 | |
1567 | 316 } while (buf[i++] != '\n'); |
317 | |
318 g_strchomp(buf); | |
319 | |
1572 | 320 printf("MSN(%d) ==> %s\n", source, buf); |
1567 | 321 |
1569 | 322 if (!strncmp("NLN ", buf, 4) || !strncmp("ILN ", buf, 4)) |
323 { | |
324 int status; | |
325 int query; | |
326 char **res; | |
327 | |
328 res = g_strsplit(buf, " ", 0); | |
329 | |
330 if (!strcmp(res[0], "NLN")) | |
331 query = 1; | |
332 else | |
333 query = 2; | |
334 | |
335 if (!strcasecmp(res[query], "NLN")) | |
336 status = UC_NORMAL; | |
337 else if (!strcasecmp(res[query], "BSY")) | |
338 status = UC_NORMAL | (MSN_BUSY << 5); | |
339 else if (!strcasecmp(res[query], "IDL")) | |
340 status = UC_NORMAL | (MSN_IDLE << 5); | |
341 else if (!strcasecmp(res[query], "BRB")) | |
342 status = UC_NORMAL | (MSN_BRB << 5); | |
343 else if (!strcasecmp(res[query], "AWY")) | |
344 status = UC_UNAVAILABLE; | |
345 else if (!strcasecmp(res[query], "PHN")) | |
346 status = UC_NORMAL | (MSN_PHONE << 5); | |
347 else if (!strcasecmp(res[query], "LUN")) | |
348 status = UC_NORMAL | (MSN_LUNCH << 5); | |
349 else | |
350 status = UC_NORMAL; | |
351 | |
352 serv_got_update(gc, res[query+1], 1, 0, 0, 0, status, 0); | |
353 | |
354 g_strfreev(res); | |
355 | |
356 return; | |
357 | |
358 } | |
1628 | 359 else if (!strncmp("BYE ", buf, 4)) |
360 { | |
361 char **res; | |
362 struct msn_conn *mc; | |
363 | |
364 res = g_strsplit(buf, " ", 0); | |
365 | |
366 mc = find_msn_conn_by_user(res[1]); | |
367 | |
368 if (mc) | |
369 { | |
370 /* Looks like we need to close up some stuff :-) */ | |
371 free_msn_conn(mc); | |
372 } | |
373 | |
374 g_strfreev(res); | |
375 return; | |
376 } | |
1572 | 377 else if (!strncmp("MSG ", buf, 4)) |
378 { | |
379 /* We are receiving an incoming message */ | |
380 gchar **res; | |
381 gchar *user; | |
382 gchar *msgdata; | |
383 int size; | |
384 | |
385 res = g_strsplit(buf, " ", 0); | |
386 | |
387 user = g_strdup(res[1]); | |
388 size = atoi(res[3]); | |
389 | |
390 /* Ok, we know who we're receiving a message from as well as | |
391 * how big the message is */ | |
392 | |
393 msgdata = (gchar *)g_malloc(sizeof(gchar) *(size + 1)); | |
394 num = recv(source, msgdata, size, 0); | |
395 msgdata[size] = 0; | |
396 | |
397 if (num < size) | |
398 printf("MSN: Uhh .. we gots a problem!. Expected %d but got %d.\n", size, num); | |
399 | |
400 /* We should ignore messages from the user Hotmail */ | |
401 if (!strcasecmp("hotmail", res[1])) | |
402 { | |
403 g_strfreev(res); | |
404 g_free(msgdata); | |
405 return; | |
406 } | |
407 | |
408 /* Check to see if any body is in the message */ | |
409 if (!strcmp(strstr(msgdata, "\r\n\r\n") + 4, "\r\n")) | |
410 { | |
411 g_strfreev(res); | |
412 g_free(msgdata); | |
413 return; | |
414 } | |
415 | |
416 /* Otherwise, everything is ok. Let's show the message. Skipping, | |
417 * of course, the header. */ | |
418 | |
419 serv_got_im(gc, res[1], strstr(msgdata, "\r\n\r\n") + 4, 0); | |
420 | |
421 g_strfreev(res); | |
422 g_free(msgdata); | |
423 | |
424 return; | |
425 } | |
426 else if (!strncmp("RNG ", buf, 4)) | |
427 { | |
428 /* Ok, someone wants to talk to us. Ring ring? Hi!!! */ | |
429 gchar **address; | |
430 gchar **res; | |
431 struct msn_conn *mc = g_new0(struct msn_conn, 1); | |
432 | |
433 res = g_strsplit(buf, " ", 0); | |
434 address = g_strsplit(res[2], ":", 0); | |
435 | |
436 if (!(mc->fd = msn_connect(address[0], atoi(address[1])))) | |
437 { | |
438 /* Looks like we had an error connecting. */ | |
439 g_strfreev(address); | |
440 g_strfreev(res); | |
441 g_free(mc); | |
442 return; | |
443 } | |
444 | |
445 /* Set up our struct with user and input watcher */ | |
446 mc->user = g_strdup(res[5]); | |
447 mc->secret = g_strdup(res[4]); | |
448 mc->session = g_strdup(res[1]); | |
449 mc->gc = gc; | |
450 | |
451 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_WRITE, msn_answer_callback, mc); | |
452 | |
453 g_strfreev(address); | |
454 g_strfreev(res); | |
455 | |
456 return; | |
457 } | |
1584 | 458 else if (!strncmp("XFR ", buf, 4)) |
459 { | |
460 char **res; | |
461 char *host; | |
462 char *port; | |
463 struct msn_conn *mc; | |
464 | |
465 res = g_strsplit(buf, " ", 0); | |
466 | |
467 printf("Last trid is: %d\n", md->last_trid); | |
468 printf("This TrId is: %d\n", atoi(res[1])); | |
469 | |
470 mc = find_msn_conn_by_trid(atoi(res[1])); | |
471 | |
472 if (!mc) | |
473 { | |
474 g_strfreev(res); | |
475 return; | |
476 } | |
477 | |
478 strcpy(buf, res[3]); | |
479 | |
480 mc->secret = g_strdup(res[5]); | |
481 mc->session = g_strdup(res[1]); | |
482 | |
483 g_strfreev(res); | |
484 | |
485 res = g_strsplit(buf, ":", 0); | |
486 | |
487 /* Now we have the host and port */ | |
1585 | 488 if (!(mc->fd = msn_connect(res[0], atoi(res[1])))) |
1584 | 489 return; |
490 | |
491 printf("Connected to: %s:%s\n", res[0], res[1]); | |
492 | |
1585 | 493 if (mc->inpa) |
494 gdk_input_remove(mc->inpa); | |
495 | |
1584 | 496 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_WRITE, msn_invite_callback, mc); |
497 | |
498 g_strfreev(res); | |
499 | |
500 return; | |
501 } | |
1569 | 502 else if (!strncmp("LST ", buf, 4)) |
1567 | 503 { |
504 char **res; | |
505 | |
506 res = g_strsplit(buf, " ", 0); | |
507 | |
1568 | 508 /* If we have zero buddies, abort */ |
509 if (atoi(res[5]) == 0) | |
510 { | |
511 g_strfreev(res); | |
512 return; | |
513 } | |
514 | |
1567 | 515 /* First, let's check the list type */ |
516 if (!strcmp("FL", res[2])) | |
517 { | |
518 /* We're dealing with a forward list. Add them | |
519 * to our buddylist and continue along our | |
520 * merry little way */ | |
521 | |
522 struct buddy *b; | |
523 | |
524 b = find_buddy(gc, res[6]); | |
525 | |
526 if (!b) | |
527 add_buddy(gc, "Buddies", res[6], res[7]); | |
528 } | |
529 | |
530 g_strfreev(res); | |
531 | |
532 return; | |
1259 | 533 } |
1628 | 534 else if (!strncmp("FLN ", buf, 4)) |
535 { | |
536 /* Someone signed off */ | |
537 char **res; | |
538 | |
539 res = g_strsplit(buf, " ", 0); | |
540 | |
541 serv_got_update(gc, res[1], 0, 0, 0, 0, 0, 0); | |
542 | |
543 g_strfreev(res); | |
544 | |
545 return; | |
546 } | |
547 if ( (!strncmp("NLN ", buf, 4)) || (!strncmp("ILN ", buf, 4))) | |
548 { | |
549 int status; | |
550 int query; | |
551 char **res; | |
552 | |
553 res = g_strsplit(buf, " ", 0); | |
554 | |
555 if (strcasecmp(res[0], "NLN") == 0) | |
556 query = 1; | |
557 else | |
558 query = 2; | |
559 | |
560 if (!strcasecmp(res[query], "NLN")) | |
561 status = UC_NORMAL; | |
562 else if (!strcasecmp(res[query], "BSY")) | |
563 status = UC_NORMAL | (MSN_BUSY << 5); | |
564 else if (!strcasecmp(res[query], "IDL")) | |
565 status = UC_NORMAL | (MSN_IDLE << 5); | |
566 else if (!strcasecmp(res[query], "BRB")) | |
567 status = UC_NORMAL | (MSN_BRB << 5); | |
568 else if (!strcasecmp(res[query], "AWY")) | |
569 status = UC_UNAVAILABLE; | |
570 else if (!strcasecmp(res[query], "PHN")) | |
571 status = UC_NORMAL | (MSN_PHONE << 5); | |
572 else if (!strcasecmp(res[query], "LUN")) | |
573 status = UC_NORMAL | (MSN_LUNCH << 5); | |
574 else | |
575 status = UC_NORMAL; | |
576 | |
577 serv_got_update(gc, res[query+1], 1, 0, 0, 0, status, 0); | |
578 | |
579 g_strfreev(res); | |
580 return; | |
581 } | |
1259 | 582 |
583 } | |
584 | |
1567 | 585 static void msn_login_callback(gpointer data, gint source, GdkInputCondition condition) |
1282 | 586 { |
1567 | 587 struct gaim_connection *gc = data; |
588 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
589 char buf[MSN_BUF_LEN]; | |
1259 | 590 int i = 0; |
1282 | 591 |
1567 | 592 if (!gc->inpa) |
593 { | |
594 fcntl(source, F_SETFL, 0); | |
595 | |
596 gdk_input_remove(md->inpa); | |
597 md->inpa = 0; | |
598 | |
599 gc->inpa = gdk_input_add(md->fd, GDK_INPUT_READ, msn_login_callback, gc); | |
1307 | 600 |
1567 | 601 if (md->status & MSN_SIGNON_GOT_XFR) |
602 { | |
603 /* Looks like we were transfered here. Just send a sign on */ | |
604 set_login_progress(gc, 3, "Signing On"); | |
605 g_snprintf(buf, MSN_BUF_LEN, "USR %d %s I %s\n", md->last_trid, md->policy, gc->username); | |
606 msn_write(md->fd, buf); | |
607 | |
608 /* Reset this bit */ | |
609 md->status ^= MSN_SIGNON_GOT_XFR; | |
610 } | |
611 else | |
612 { | |
613 /* Otherwise, send an initial request */ | |
614 set_login_progress(gc, 2, "Verifiying"); | |
1259 | 615 |
1567 | 616 g_snprintf(md->protocol, 6, "MSNP2"); |
617 | |
618 g_snprintf(buf, MSN_BUF_LEN, "VER %d %s\n", trId(md), md->protocol); | |
619 msn_write(md->fd, buf); | |
620 } | |
621 | |
622 return; | |
623 } | |
624 | |
625 bzero(buf, MSN_BUF_LEN); | |
626 | |
627 do | |
628 { | |
1588 | 629 if (!read(source, buf + i, 1)) |
1567 | 630 { |
631 hide_login_progress(gc, "Read error"); | |
632 signoff(gc); | |
1259 | 633 return; |
1567 | 634 } |
1259 | 635 |
1567 | 636 } while (buf[i++] != '\n'); |
1259 | 637 |
638 g_strchomp(buf); | |
639 | |
1567 | 640 printf("MSN ==> %s\n", buf); |
641 | |
642 /* Check to see what was just sent back to us. We should be seeing a VER tag. */ | |
643 if (!strncmp("VER ", buf, 4) && (!strstr("MSNP2", buf))) | |
644 { | |
645 /* Now that we got our ver, we shoudl send a policy request */ | |
646 g_snprintf(buf, MSN_BUF_LEN, "INF %d\n", trId(md)); | |
647 msn_write(md->fd, buf); | |
648 | |
649 return; | |
650 } | |
651 else if (!strncmp("INF ", buf, 4)) | |
652 { | |
653 char **res; | |
654 | |
655 /* Make a copy of our resulting policy */ | |
656 res = g_strsplit(buf, " ", 0); | |
657 md->policy = g_strdup(res[2]); | |
658 | |
659 /* And send our signon packet */ | |
660 set_login_progress(gc, 3, "Signing On"); | |
661 | |
662 g_snprintf(buf, MSN_BUF_LEN, "USR %d %s I %s\n", trId(md), md->policy, gc->username); | |
663 msn_write(md->fd, buf); | |
664 | |
665 g_strfreev(res); | |
666 | |
667 return; | |
668 } | |
1598 | 669 else if (!strncmp("ADD ", buf, 4)) |
670 { | |
671 char **res; | |
672 | |
673 res = g_strsplit(buf, " ", 0); | |
674 | |
675 if (!strcasecmp(res[2], "RL")) | |
676 { | |
677 struct msn_ask_add_permit *ap = g_new0(struct msn_ask_add_permit, 1); | |
678 | |
679 snprintf(buf, MSN_BUF_LEN, "The user %s (%s) wants to add you to their buddylist.", res[4], res[5]); | |
680 | |
681 ap->user = g_strdup(res[4]); | |
682 ap->friendly = g_strdup(res[5]); | |
683 ap->gc = gc; | |
684 | |
685 do_ask_dialog(buf, ap, (GtkFunction) msn_accept_add_permit, (GtkFunction) msn_cancel_add_permit); | |
686 } | |
687 | |
688 g_strfreev(res); | |
689 return; | |
690 } | |
1589 | 691 |
1567 | 692 else if (!strncmp("XFR ", buf, 4)) |
693 { | |
694 char **res; | |
695 char *host; | |
696 char *port; | |
697 | |
698 res = g_strsplit(buf, " ", 0); | |
699 | |
700 strcpy(buf, res[3]); | |
701 | |
702 g_strfreev(res); | |
703 | |
704 res = g_strsplit(buf, ":", 0); | |
705 | |
706 close(md->fd); | |
707 | |
1603 | 708 set_login_progress(gc, 3, "Connecting to Auth"); |
1567 | 709 |
710 /* Now we have the host and port */ | |
711 if (!(md->fd = msn_connect(res[0], atoi(res[1])))) | |
712 { | |
713 hide_login_progress(gc, "Error connecting to server"); | |
714 signoff(gc); | |
715 return; | |
716 } | |
717 | |
718 g_strfreev(res); | |
719 | |
720 md->status |= MSN_SIGNON_GOT_XFR; | |
721 | |
722 gdk_input_remove(gc->inpa); | |
723 gc->inpa = 0; | |
724 | |
725 md->inpa = gdk_input_add(md->fd, GDK_INPUT_WRITE, msn_login_callback, gc); | |
726 | |
727 return; | |
728 } | |
729 else if (!strncmp("USR ", buf, 4)) | |
730 { | |
731 if (md->status & MSN_SIGNON_SENT_USR) | |
732 { | |
733 char **res; | |
734 | |
735 res = g_strsplit(buf, " ", 0); | |
736 | |
737 if (strcasecmp("OK", res[2])) | |
738 { | |
739 hide_login_progress(gc, "Error signing on"); | |
740 signoff(gc); | |
741 } | |
742 else | |
743 { | |
744 md->friendly = g_strdup(res[4]); | |
745 | |
746 /* Ok, ok. Your account is FINALLY online. Ya think Microsoft | |
747 * could have had any more steps involved? */ | |
748 | |
749 set_login_progress(gc, 4, "Fetching config"); | |
750 | |
751 /* Sync our buddylist */ | |
752 g_snprintf(buf, MSN_BUF_LEN, "SYN %d 0\n", trId(md)); | |
753 msn_write(md->fd, buf); | |
754 | |
755 /* And set ourselves online */ | |
756 g_snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
757 msn_write(md->fd, buf); | |
758 | |
759 account_online(gc); | |
760 serv_finish_login(gc); | |
761 | |
762 if (bud_list_cache_exists(gc)) | |
763 do_import(NULL, gc); | |
764 | |
765 gdk_input_remove(gc->inpa); | |
766 gc->inpa = gdk_input_add(md->fd, GDK_INPUT_READ, msn_callback, gc); | |
767 } | |
768 | |
769 g_strfreev(res); | |
770 } | |
771 else | |
772 { | |
773 char **res; | |
774 char buf2[MSN_BUF_LEN]; | |
775 int j; | |
776 md5_state_t st; | |
777 md5_byte_t di[16]; | |
778 | |
779 res = g_strsplit(buf, " ", 0); | |
780 | |
781 /* Make a copy of our MD5 Hash key */ | |
782 strcpy(buf, res[4]); | |
783 | |
784 /* Generate our secret with our key and password */ | |
785 snprintf(buf2, MSN_BUF_LEN, "%s%s", buf, gc->password); | |
786 | |
787 md5_init(&st); | |
788 md5_append(&st, (const md5_byte_t *)buf2, strlen(buf2)); | |
789 md5_finish(&st, di); | |
790 | |
791 /* Now that we have the MD5 Hash, lets' hex encode this bad boy. I smoke bad crack. */ | |
792 sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", | |
793 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], | |
794 di[13],di[14],di[15]); | |
795 | |
796 /* And now, send our final sign on packet */ | |
797 g_snprintf(buf2, MSN_BUF_LEN, "USR %s %s S %s\n", res[1], md->policy, buf); | |
798 msn_write(md->fd, buf2); | |
799 | |
800 md->status |= MSN_SIGNON_SENT_USR; | |
801 | |
802 g_strfreev(res); | |
803 } | |
804 | |
805 return; | |
806 } | |
1259 | 807 } |
808 | |
1282 | 809 int msn_connect(char *server, int port) |
810 { | |
1259 | 811 int fd; |
812 struct hostent *host; | |
813 struct sockaddr_in site; | |
814 | |
1567 | 815 if (!(host = gethostbyname(server))) |
816 { | |
817 printf("Could not resolve host name: %s\n", server); | |
1259 | 818 return -1; |
819 } | |
820 | |
1567 | 821 bzero(&site, sizeof(struct sockaddr_in)); |
822 site.sin_port = htons(port); | |
823 memcpy(&site.sin_addr, host->h_addr, host->h_length); | |
824 site.sin_family = host->h_addrtype; | |
1259 | 825 |
1567 | 826 fd = socket(host->h_addrtype, SOCK_STREAM, 0); |
1259 | 827 |
1567 | 828 fcntl(fd, F_SETFL, O_NONBLOCK); |
1259 | 829 |
1567 | 830 if (connect(fd, (struct sockaddr *)&site, sizeof(struct sockaddr_in)) < 0) |
831 { | |
832 if ((errno == EINPROGRESS) || (errno == EINTR)) | |
833 { | |
834 printf("Connection would block\n"); | |
835 return fd; | |
1259 | 836 } |
837 | |
1567 | 838 close(fd); |
839 fd = -1; | |
1259 | 840 } |
1567 | 841 |
842 return fd; | |
1259 | 843 } |
844 | |
1282 | 845 void msn_login(struct aim_user *user) |
846 { | |
1567 | 847 struct gaim_connection *gc = new_gaim_conn(user); |
848 struct msn_data *md = gc->proto_data = g_new0(struct msn_data, 1); | |
1282 | 849 |
1567 | 850 gc->inpa = 0; |
1282 | 851 |
852 set_login_progress(gc, 1, "Connecting"); | |
1259 | 853 |
854 while (gtk_events_pending()) | |
855 gtk_main_iteration(); | |
1567 | 856 |
1259 | 857 if (!g_slist_find(connections, gc)) |
858 return; | |
859 | |
1567 | 860 md->status = 0; |
1282 | 861 |
1567 | 862 if (!(md->fd = msn_connect("messenger.hotmail.com", 1863))) |
863 { | |
864 hide_login_progress(gc, "Error connecting to server"); | |
1259 | 865 signoff(gc); |
866 return; | |
867 } | |
868 | |
1567 | 869 md->inpa = gdk_input_add(md->fd, GDK_INPUT_WRITE, msn_login_callback, gc); |
1259 | 870 |
1567 | 871 printf("Connected.\n"); |
1284 | 872 } |
873 | |
1584 | 874 void msn_send_im(struct gaim_connection *gc, char *who, char *message, int away) |
875 { | |
876 struct msn_conn *mc; | |
877 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
878 char buf[MSN_BUF_LEN]; | |
879 | |
880 if (!g_strcasecmp(who, gc->username)) | |
881 { | |
882 do_error_dialog("You can not send a message to yourself!", "Gaim: MSN Error"); | |
883 return; | |
884 } | |
885 | |
886 mc = find_msn_conn_by_user(who); | |
887 | |
888 /* If we're not already in a conversation with | |
889 * this person then we have to do some tricky things. */ | |
890 | |
891 if (!mc) | |
892 { | |
893 gchar buf2[MSN_BUF_LEN]; | |
894 gchar *address; | |
895 gchar *auth; | |
896 gchar **res; | |
897 | |
898 /* Request a new switchboard connection */ | |
899 g_snprintf(buf, MSN_BUF_LEN, "XFR %d SB\n", trId(md)); | |
900 msn_write(md->fd, buf); | |
901 | |
902 mc = g_new0(struct msn_conn, 1); | |
903 | |
904 mc->user = g_strdup(who); | |
905 mc->gc = gc; | |
906 mc->last_trid = md->last_trid; | |
907 mc->txqueue = g_strdup(message); | |
908 | |
909 /* Append our connection */ | |
910 msn_connections = g_slist_append(msn_connections, mc); | |
911 } | |
1585 | 912 else |
913 { | |
1598 | 914 g_snprintf(buf, MSN_BUF_LEN, "MSG %d N %d\r\n%s%s", trId(md), |
915 strlen(message) + strlen(MIME_HEADER), MIME_HEADER, message); | |
1585 | 916 |
917 msn_write(mc->fd, buf); | |
918 } | |
1584 | 919 |
920 } | |
921 | |
1598 | 922 static void msn_add_buddy(struct gaim_connection *gc, char *who) |
923 { | |
924 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
925 char buf[MSN_BUF_LEN - 1]; | |
926 | |
927 snprintf(buf, MSN_BUF_LEN, "ADD %d FL %s %s\n", trId(md), who, who); | |
928 msn_write(md->fd, buf); | |
929 } | |
930 | |
931 static void msn_remove_buddy(struct gaim_connection *gc, char *who) | |
932 { | |
933 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
934 char buf[MSN_BUF_LEN - 1]; | |
935 | |
936 snprintf(buf, MSN_BUF_LEN, "REM %d FL %s\n", trId(md), who); | |
937 msn_write(md->fd, buf); | |
938 } | |
939 | |
940 static void msn_rem_permit(struct gaim_connection *gc, char *who) | |
941 { | |
942 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
943 char buf[MSN_BUF_LEN - 1]; | |
944 | |
945 snprintf(buf, MSN_BUF_LEN, "REM %d AL %s\n", trId(md), who); | |
946 msn_write(md->fd, buf); | |
947 } | |
948 | |
949 static void msn_add_permit(struct gaim_connection *gc, char *who) | |
950 { | |
951 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
952 char buf[MSN_BUF_LEN - 1]; | |
953 | |
954 snprintf(buf, MSN_BUF_LEN, "ADD %d AL %s %s\n", trId(md), who, who); | |
955 msn_write(md->fd, buf); | |
956 } | |
957 | |
958 static void msn_rem_deny(struct gaim_connection *gc, char *who) | |
959 { | |
960 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
961 char buf[MSN_BUF_LEN - 1]; | |
962 | |
963 snprintf(buf, MSN_BUF_LEN, "REM %d BL %s\n", trId(md), who); | |
964 msn_write(md->fd, buf); | |
965 } | |
966 | |
967 static void msn_add_deny(struct gaim_connection *gc, char *who) | |
968 { | |
969 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
970 char buf[MSN_BUF_LEN - 1]; | |
971 | |
972 snprintf(buf, MSN_BUF_LEN, "ADD %d BL %s %s\n", trId(md), who, who); | |
973 msn_write(md->fd, buf); | |
974 } | |
975 | |
1600 | 976 static void msn_set_away(struct gaim_connection *gc, char *state, char *msg) |
977 { | |
978 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
979 char buf[MSN_BUF_LEN - 1]; | |
980 | |
981 if (msg) | |
982 snprintf(buf, MSN_BUF_LEN, "CHG %d AWY\n", trId(md)); | |
983 else if (gc->is_idle) | |
984 snprintf(buf, MSN_BUF_LEN, "CHG %d IDL\n", trId(md)); | |
985 else | |
986 snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
987 | |
988 msn_write(md->fd, buf); | |
989 } | |
990 | |
991 | |
992 static void msn_set_idle(struct gaim_connection *gc, int idle) | |
993 { | |
994 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
995 char buf[MSN_BUF_LEN - 1]; | |
996 | |
997 if (idle) | |
998 snprintf(buf, MSN_BUF_LEN, "CHG %d IDL\n", trId(md)); | |
999 else | |
1000 snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
1001 | |
1002 msn_write(md->fd, buf); | |
1003 } | |
1004 | |
1005 static void msn_close(struct gaim_connection *gc) | |
1006 { | |
1007 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1008 char buf[MSN_BUF_LEN - 1]; | |
1009 struct msn_conn *mc = NULL; | |
1010 | |
1011 while (msn_connections) | |
1012 { | |
1013 mc = (struct msn_conn *)msn_connections->data; | |
1014 | |
1015 free_msn_conn(mc); | |
1016 } | |
1017 | |
1018 if (md->fd) | |
1019 { | |
1020 snprintf(buf, MSN_BUF_LEN, "OUT\n"); | |
1021 msn_write(md->fd, buf); | |
1022 close(md->fd); | |
1023 } | |
1024 | |
1025 if (gc->inpa) | |
1026 gdk_input_remove(gc->inpa); | |
1027 | |
1028 if (md->friendly) | |
1029 free(md->friendly); | |
1030 | |
1031 g_free(gc->proto_data); | |
1032 } | |
1033 | |
1572 | 1034 static char **msn_list_icon(int uc) |
1035 { | |
1036 if (uc == UC_UNAVAILABLE) | |
1037 return msn_away_xpm; | |
1038 else if (uc == UC_NORMAL) | |
1039 return msn_online_xpm; | |
1040 | |
1041 return msn_online_xpm; | |
1042 } | |
1043 | |
1259 | 1044 static struct prpl *my_protocol = NULL; |
1045 | |
1282 | 1046 void msn_init(struct prpl *ret) |
1047 { | |
1259 | 1048 ret->protocol = PROTO_MSN; |
1049 ret->name = msn_name; | |
1572 | 1050 ret->list_icon = msn_list_icon; |
1499
de0b946e86a4
[gaim-migrate @ 1509]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1443
diff
changeset
|
1051 ret->buddy_menu = NULL; |
1259 | 1052 ret->user_opts = NULL; |
1053 ret->login = msn_login; | |
1600 | 1054 ret->close = msn_close; |
1584 | 1055 ret->send_im = msn_send_im; |
1259 | 1056 ret->set_info = NULL; |
1057 ret->get_info = NULL; | |
1600 | 1058 ret->set_away = msn_set_away; |
1259 | 1059 ret->get_away_msg = NULL; |
1060 ret->set_dir = NULL; | |
1061 ret->get_dir = NULL; | |
1062 ret->dir_search = NULL; | |
1600 | 1063 ret->set_idle = msn_set_idle; |
1259 | 1064 ret->change_passwd = NULL; |
1598 | 1065 ret->add_buddy = msn_add_buddy; |
1259 | 1066 ret->add_buddies = NULL; |
1598 | 1067 ret->remove_buddy = msn_remove_buddy; |
1068 ret->add_permit = msn_add_permit; | |
1069 ret->rem_permit = msn_rem_permit; | |
1070 ret->add_deny = msn_add_deny; | |
1071 ret->rem_deny = msn_rem_deny; | |
1259 | 1072 ret->warn = NULL; |
1073 ret->accept_chat = NULL; | |
1074 ret->join_chat = NULL; | |
1075 ret->chat_invite = NULL; | |
1076 ret->chat_leave = NULL; | |
1077 ret->chat_whisper = NULL; | |
1078 ret->chat_send = NULL; | |
1079 ret->keepalive = NULL; | |
1080 | |
1081 my_protocol = ret; | |
1082 } | |
1083 | |
1282 | 1084 char *gaim_plugin_init(GModule * handle) |
1085 { | |
1443
336fc98b7f90
[gaim-migrate @ 1453]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1327
diff
changeset
|
1086 load_protocol(msn_init, sizeof(struct prpl)); |
1259 | 1087 return NULL; |
1088 } | |
1089 | |
1282 | 1090 void gaim_plugin_remove() |
1091 { | |
1259 | 1092 struct prpl *p = find_prpl(PROTO_MSN); |
1093 if (p == my_protocol) | |
1094 unload_protocol(p); | |
1095 } |