Mercurial > pidgin
annotate plugins/msn/msn.c @ 1756:baf57b74e818
[gaim-migrate @ 1766]
msn normalizing of names and such
committer: Tailor Script <tailor@pidgin.im>
author | Rob Flynn <gaim@robflynn.com> |
---|---|
date | Fri, 27 Apr 2001 00:28:44 +0000 |
parents | 6e51e206a388 |
children | 1e0613d9526b |
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" |
1717 | 45 #include "pixmaps/ok.xpm" |
1284 | 46 |
1567 | 47 #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 | 48 |
1567 | 49 #define MSN_BUF_LEN 8192 |
1259 | 50 |
51 #define MSN_ONLINE 1 | |
52 #define MSN_BUSY 2 | |
53 #define MSN_IDLE 3 | |
54 #define MSN_BRB 4 | |
55 #define MSN_AWAY 5 | |
56 #define MSN_PHONE 6 | |
57 #define MSN_LUNCH 7 | |
58 #define MSN_OFFLINE 8 | |
59 #define MSN_HIDDEN 9 | |
60 | |
1567 | 61 #define MSN_SIGNON_GOT_XFR 0x0001 |
62 #define MSN_SIGNON_SENT_USR 0x0002 | |
1259 | 63 |
1717 | 64 #define USEROPT_HOTMAIL 0 |
65 | |
66 struct mod_usr_opt { | |
67 struct aim_user *user; | |
68 int opt; | |
69 }; | |
70 | |
1598 | 71 struct msn_ask_add_permit { |
72 struct gaim_connection *gc; | |
73 char *user; | |
74 char *friendly; | |
75 }; | |
76 | |
1259 | 77 struct msn_data { |
78 int fd; | |
79 | |
80 char protocol[6]; | |
81 char *friendly; | |
82 gchar *policy; | |
1567 | 83 int inpa; |
84 int status; | |
1631 | 85 int away; |
1567 | 86 time_t last_trid; |
1259 | 87 }; |
88 | |
89 struct msn_conn { | |
90 gchar *user; | |
91 int inpa; | |
92 int fd; | |
1572 | 93 struct gaim_connection *gc; |
94 char *secret; | |
95 char *session; | |
1584 | 96 time_t last_trid; |
97 char *txqueue; | |
1259 | 98 }; |
99 | |
1567 | 100 GSList *msn_connections = NULL; |
1259 | 101 |
1567 | 102 unsigned long long globalc = 0; |
1572 | 103 static void msn_callback(gpointer data, gint source, GdkInputCondition condition); |
1598 | 104 static void msn_add_permit(struct gaim_connection *gc, char *who); |
1717 | 105 static void process_hotmail_msg(struct gaim_connection *gc, gchar *msgdata); |
1733 | 106 void msn_des_win(GtkWidget *a, GtkWidget *b); |
107 void msn_newmail_dialog(const char *text); | |
1756 | 108 static char *msn_normalize(const char *s); |
1598 | 109 |
1754 | 110 char tochar(char *h) |
111 { | |
112 char alphabet[] = "0123456789abcdef"; | |
113 char tmp; | |
114 char b; | |
115 int v = 0; | |
116 int i; | |
117 | |
118 for (i = strlen(h); i > 0; i--) | |
119 { | |
120 tmp = tolower(h[strlen(h) - i]); | |
121 | |
122 if (tmp >= '0' && tmp <= '9') | |
123 b = tmp - '0'; | |
124 else if (tmp >= 'a' && tmp <= 'f') | |
125 b = (tmp - 'a') + 10; | |
126 | |
127 if (i > 1) | |
128 v =+ ((i-1) * 16) * b; | |
129 else | |
130 v += b; | |
131 } | |
132 | |
133 return v; | |
134 } | |
135 | |
136 char *url_decode(char *text) | |
137 { | |
138 static char newtext[MSN_BUF_LEN]; | |
139 char *buf; | |
140 int c = 0; | |
141 int i = 0; | |
142 int j = 0; | |
143 | |
144 for (i = 0; i < strlen(text); i++) | |
145 { | |
146 if (text[i] == '%') | |
147 c++; | |
148 } | |
149 | |
150 buf = (char *)malloc(strlen(text) + c + 1); | |
151 | |
152 for (i = 0, j = 0 ; text[i] != 0; i++) | |
153 { | |
154 if (text[i] != '%') | |
155 { | |
156 buf[j++] = text[i]; | |
157 } | |
158 else | |
159 { | |
160 char hex[3]; | |
161 hex[0] = text[++i]; | |
162 hex[1] = text[++i]; | |
163 hex[2] = 0; | |
164 | |
165 buf[j++] = tochar(hex); | |
166 } | |
167 } | |
168 | |
169 for (i = 0; i < strlen(buf); i++) | |
170 newtext[i] = buf[i]; | |
171 | |
172 free(buf); | |
173 | |
174 return newtext; | |
175 } | |
176 | |
1598 | 177 void msn_accept_add_permit(gpointer w, struct msn_ask_add_permit *ap) |
178 { | |
179 msn_add_permit(ap->gc, ap->user); | |
1733 | 180 /* leak if we don't free these? */ |
181 g_free(ap->user); | |
182 g_free(ap->friendly); | |
183 g_free(ap); | |
1598 | 184 } |
185 | |
186 void msn_cancel_add_permit(gpointer w, struct msn_ask_add_permit *ap) | |
187 { | |
188 g_free(ap->user); | |
189 g_free(ap->friendly); | |
190 g_free(ap); | |
191 } | |
1259 | 192 |
1588 | 193 void free_msn_conn(struct msn_conn *mc) |
194 { | |
195 if (mc->user) | |
196 free(mc->user); | |
197 | |
198 if (mc->secret) | |
199 free(mc->secret); | |
200 | |
201 if (mc->session) | |
202 free(mc->session); | |
203 | |
204 if (mc->txqueue) | |
205 free(mc->txqueue); | |
206 | |
207 gdk_input_remove(mc->inpa); | |
208 close(mc->fd); | |
209 | |
210 msn_connections = g_slist_remove(msn_connections, mc); | |
211 | |
212 g_free(mc); | |
213 } | |
214 | |
215 | |
1584 | 216 struct msn_conn *find_msn_conn_by_user(gchar * user) |
217 { | |
218 struct msn_conn *mc; | |
219 GSList *conns = msn_connections; | |
220 | |
221 while (conns) { | |
222 mc = (struct msn_conn *)conns->data; | |
223 | |
224 if (mc != NULL) { | |
225 if (strcasecmp(mc->user, user) == 0) { | |
226 return mc; | |
227 } | |
228 } | |
229 | |
230 conns = g_slist_next(conns); | |
231 } | |
232 | |
233 return NULL; | |
234 } | |
235 | |
236 struct msn_conn *find_msn_conn_by_trid(time_t trid) | |
237 { | |
238 struct msn_conn *mc; | |
239 GSList *conns = msn_connections; | |
240 | |
241 while (conns) { | |
242 mc = (struct msn_conn *)conns->data; | |
243 | |
244 if (mc != NULL) { | |
245 | |
1733 | 246 debug_printf("Comparing: %d <==> %d\n", mc->last_trid, trid); |
1584 | 247 if (mc->last_trid == trid) { |
248 return mc; | |
249 } | |
250 } | |
251 | |
252 conns = g_slist_next(conns); | |
253 } | |
254 | |
255 return NULL; | |
256 } | |
257 | |
1282 | 258 static char *msn_name() |
259 { | |
1259 | 260 return "MSN"; |
261 } | |
262 | |
1282 | 263 char *name() |
264 { | |
1259 | 265 return "MSN"; |
266 } | |
267 | |
1282 | 268 char *description() |
269 { | |
1259 | 270 return "Allows gaim to use the MSN protocol. For some reason, this frightens me."; |
271 } | |
272 | |
1567 | 273 time_t trId(struct msn_data *md) |
1282 | 274 { |
1567 | 275 md->last_trid = time((time_t *)NULL) + globalc++; |
276 return md->last_trid; | |
277 } | |
278 | |
279 void msn_write(int fd, char *buf) | |
280 { | |
281 write(fd, buf, strlen(buf)); | |
1733 | 282 debug_printf("MSN(%d) <== %s", fd, buf); |
283 } | |
284 | |
285 void msn_add_request(struct gaim_connection *gc, char *buf) | |
286 { | |
287 char **res; | |
288 | |
289 res = g_strsplit(buf, " ", 0); | |
290 | |
291 if (!strcasecmp(res[2], "RL")) | |
292 { | |
293 struct msn_ask_add_permit *ap = g_new0(struct msn_ask_add_permit, 1); | |
294 | |
295 snprintf(buf, MSN_BUF_LEN, "The user %s (%s) wants to add you to their buddylist.", res[4], res[5]); | |
296 | |
297 ap->user = g_strdup(res[4]); | |
1756 | 298 ap->friendly = g_strdup(url_decode(res[5])); |
1733 | 299 ap->gc = gc; |
300 | |
301 do_ask_dialog(buf, ap, (GtkFunction) msn_accept_add_permit, (GtkFunction) msn_cancel_add_permit); | |
302 } | |
303 | |
304 g_strfreev(res); | |
1567 | 305 } |
1259 | 306 |
1572 | 307 static void msn_answer_callback(gpointer data, gint source, GdkInputCondition condition) |
308 { | |
309 struct msn_conn *mc = data; | |
310 char buf[MSN_BUF_LEN]; | |
311 | |
312 fcntl(source, F_SETFL, 0); | |
313 | |
1756 | 314 g_snprintf(buf, MSN_BUF_LEN, "ANS 1 %s %s %s\n",mc->gc->username, mc->secret, mc->session); |
1572 | 315 msn_write(mc->fd, buf); |
316 | |
317 gdk_input_remove(mc->inpa); | |
318 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_callback, mc->gc); | |
319 | |
320 /* Append our connection */ | |
321 msn_connections = g_slist_append(msn_connections, mc); | |
322 } | |
323 | |
1584 | 324 static void msn_invite_callback(gpointer data, gint source, GdkInputCondition condition) |
325 { | |
326 struct msn_conn *mc = data; | |
327 struct msn_data *md = (struct msn_data *)mc->gc->proto_data; | |
328 char buf[MSN_BUF_LEN]; | |
329 struct gaim_connection *gc = mc->gc; | |
330 int i = 0; | |
1585 | 331 |
332 fcntl(source, F_SETFL, 0); | |
1584 | 333 |
334 if (condition == GDK_INPUT_WRITE) | |
335 { | |
336 /* We just got in here */ | |
337 gdk_input_remove(mc->inpa); | |
338 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_invite_callback, mc); | |
339 | |
340 /* Write our signon request */ | |
341 g_snprintf(buf, MSN_BUF_LEN, "USR %d %s %s\n", mc->last_trid, mc->gc->username, mc->secret); | |
1585 | 342 msn_write(mc->fd, buf); |
1584 | 343 return; |
344 } | |
345 | |
346 bzero(buf, MSN_BUF_LEN); | |
347 do | |
348 { | |
1588 | 349 if (!read(source, buf + i, 1)) |
1584 | 350 { |
1588 | 351 free_msn_conn(mc); |
1584 | 352 return; |
353 } | |
354 | |
355 } while (buf[i++] != '\n'); | |
356 | |
357 g_strchomp(buf); | |
358 | |
1733 | 359 debug_printf("MSN(%d) ==> %s\n", source, buf); |
1584 | 360 |
361 if (!strncmp("USR ", buf, 4)) | |
362 { | |
363 char **res; | |
364 | |
365 res = g_strsplit(buf, " ", 0); | |
1733 | 366 debug_printf("%s\n",res[2]); |
1584 | 367 if (strcasecmp("OK", res[2])) |
368 { | |
369 g_strfreev(res); | |
370 close(mc->fd); | |
371 return; | |
372 } | |
373 | |
374 /* We've authorized. Let's send an invite request */ | |
375 g_snprintf(buf, MSN_BUF_LEN, "CAL %d %s\n", trId(md), mc->user); | |
376 msn_write(source, buf); | |
377 return; | |
378 } | |
379 | |
380 else if (!strncmp("JOI ", buf, 4)) | |
381 { | |
382 /* Looks like they just joined! Write their queued message */ | |
383 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); | |
384 | |
385 msn_write(source, buf); | |
386 | |
387 gdk_input_remove(mc->inpa); | |
388 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_callback, mc->gc); | |
389 | |
390 return; | |
391 | |
392 } | |
393 } | |
394 | |
1567 | 395 static void msn_callback(gpointer data, gint source, GdkInputCondition condition) |
396 { | |
397 struct gaim_connection *gc = data; | |
398 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
399 char buf[MSN_BUF_LEN]; | |
400 int i = 0; | |
1572 | 401 int num; |
1259 | 402 |
1567 | 403 bzero(buf, MSN_BUF_LEN); |
404 | |
405 do | |
406 { | |
1588 | 407 if (!read(source, buf + i, 1)) |
1567 | 408 { |
1588 | 409 if (md->fd == source) |
410 { | |
411 hide_login_progress(gc, "Read error"); | |
412 signoff(gc); | |
413 } | |
414 | |
415 close(source); | |
416 | |
1567 | 417 return; |
1259 | 418 } |
419 | |
1567 | 420 } while (buf[i++] != '\n'); |
421 | |
422 g_strchomp(buf); | |
423 | |
1733 | 424 debug_printf("MSN(%d) ==> %s\n", source, buf); |
1567 | 425 |
1569 | 426 if (!strncmp("NLN ", buf, 4) || !strncmp("ILN ", buf, 4)) |
427 { | |
428 int status; | |
429 int query; | |
430 char **res; | |
431 | |
432 res = g_strsplit(buf, " ", 0); | |
433 | |
434 if (!strcmp(res[0], "NLN")) | |
435 query = 1; | |
436 else | |
437 query = 2; | |
438 | |
439 if (!strcasecmp(res[query], "NLN")) | |
440 status = UC_NORMAL; | |
441 else if (!strcasecmp(res[query], "BSY")) | |
442 status = UC_NORMAL | (MSN_BUSY << 5); | |
443 else if (!strcasecmp(res[query], "IDL")) | |
444 status = UC_NORMAL | (MSN_IDLE << 5); | |
445 else if (!strcasecmp(res[query], "BRB")) | |
446 status = UC_NORMAL | (MSN_BRB << 5); | |
447 else if (!strcasecmp(res[query], "AWY")) | |
448 status = UC_UNAVAILABLE; | |
449 else if (!strcasecmp(res[query], "PHN")) | |
450 status = UC_NORMAL | (MSN_PHONE << 5); | |
451 else if (!strcasecmp(res[query], "LUN")) | |
452 status = UC_NORMAL | (MSN_LUNCH << 5); | |
453 else | |
454 status = UC_NORMAL; | |
455 | |
456 serv_got_update(gc, res[query+1], 1, 0, 0, 0, status, 0); | |
457 | |
458 g_strfreev(res); | |
459 | |
460 return; | |
461 | |
462 } | |
1628 | 463 else if (!strncmp("BYE ", buf, 4)) |
464 { | |
465 char **res; | |
466 struct msn_conn *mc; | |
467 | |
468 res = g_strsplit(buf, " ", 0); | |
469 | |
470 mc = find_msn_conn_by_user(res[1]); | |
471 | |
472 if (mc) | |
473 { | |
474 /* Looks like we need to close up some stuff :-) */ | |
475 free_msn_conn(mc); | |
476 } | |
477 | |
478 g_strfreev(res); | |
479 return; | |
480 } | |
1572 | 481 else if (!strncmp("MSG ", buf, 4)) |
482 { | |
483 /* We are receiving an incoming message */ | |
484 gchar **res; | |
485 gchar *user; | |
486 gchar *msgdata; | |
487 int size; | |
1731
7fc4b9fe295a
[gaim-migrate @ 1741]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1717
diff
changeset
|
488 char rahc[MSN_BUF_LEN * 2]; |
1572 | 489 |
490 res = g_strsplit(buf, " ", 0); | |
491 | |
492 user = g_strdup(res[1]); | |
493 size = atoi(res[3]); | |
494 | |
495 /* Ok, we know who we're receiving a message from as well as | |
496 * how big the message is */ | |
497 | |
498 msgdata = (gchar *)g_malloc(sizeof(gchar) *(size + 1)); | |
499 num = recv(source, msgdata, size, 0); | |
500 msgdata[size] = 0; | |
501 | |
502 if (num < size) | |
1733 | 503 debug_printf("MSN: Uhh .. we gots a problem!. Expected %d but got %d.\n", size, num); |
1572 | 504 |
505 /* We should ignore messages from the user Hotmail */ | |
506 if (!strcasecmp("hotmail", res[1])) | |
507 { | |
1717 | 508 process_hotmail_msg(gc,msgdata); |
1572 | 509 g_strfreev(res); |
510 g_free(msgdata); | |
511 return; | |
512 } | |
513 | |
514 /* Check to see if any body is in the message */ | |
515 if (!strcmp(strstr(msgdata, "\r\n\r\n") + 4, "\r\n")) | |
516 { | |
517 g_strfreev(res); | |
518 g_free(msgdata); | |
519 return; | |
520 } | |
521 | |
522 /* Otherwise, everything is ok. Let's show the message. Skipping, | |
523 * of course, the header. */ | |
524 | |
1731
7fc4b9fe295a
[gaim-migrate @ 1741]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1717
diff
changeset
|
525 g_snprintf(rahc, sizeof(rahc), "%s", strstr(msgdata, "\r\n\r\n") + 4); |
7fc4b9fe295a
[gaim-migrate @ 1741]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1717
diff
changeset
|
526 serv_got_im(gc, res[1], rahc, 0); |
1572 | 527 |
528 g_strfreev(res); | |
529 g_free(msgdata); | |
530 | |
531 return; | |
532 } | |
533 else if (!strncmp("RNG ", buf, 4)) | |
534 { | |
535 /* Ok, someone wants to talk to us. Ring ring? Hi!!! */ | |
536 gchar **address; | |
537 gchar **res; | |
538 struct msn_conn *mc = g_new0(struct msn_conn, 1); | |
539 | |
540 res = g_strsplit(buf, " ", 0); | |
541 address = g_strsplit(res[2], ":", 0); | |
542 | |
543 if (!(mc->fd = msn_connect(address[0], atoi(address[1])))) | |
544 { | |
545 /* Looks like we had an error connecting. */ | |
546 g_strfreev(address); | |
547 g_strfreev(res); | |
548 g_free(mc); | |
549 return; | |
550 } | |
551 | |
552 /* Set up our struct with user and input watcher */ | |
553 mc->user = g_strdup(res[5]); | |
554 mc->secret = g_strdup(res[4]); | |
555 mc->session = g_strdup(res[1]); | |
556 mc->gc = gc; | |
557 | |
558 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_WRITE, msn_answer_callback, mc); | |
559 | |
560 g_strfreev(address); | |
561 g_strfreev(res); | |
562 | |
563 return; | |
564 } | |
1584 | 565 else if (!strncmp("XFR ", buf, 4)) |
566 { | |
567 char **res; | |
568 char *host; | |
569 char *port; | |
570 struct msn_conn *mc; | |
571 | |
572 res = g_strsplit(buf, " ", 0); | |
573 | |
1733 | 574 debug_printf("Last trid is: %d\n", md->last_trid); |
575 debug_printf("This TrId is: %d\n", atoi(res[1])); | |
1584 | 576 |
577 mc = find_msn_conn_by_trid(atoi(res[1])); | |
578 | |
579 if (!mc) | |
580 { | |
581 g_strfreev(res); | |
582 return; | |
583 } | |
584 | |
585 strcpy(buf, res[3]); | |
586 | |
587 mc->secret = g_strdup(res[5]); | |
588 mc->session = g_strdup(res[1]); | |
589 | |
590 g_strfreev(res); | |
591 | |
592 res = g_strsplit(buf, ":", 0); | |
593 | |
594 /* Now we have the host and port */ | |
1585 | 595 if (!(mc->fd = msn_connect(res[0], atoi(res[1])))) |
1584 | 596 return; |
597 | |
1733 | 598 debug_printf("Connected to: %s:%s\n", res[0], res[1]); |
1584 | 599 |
1585 | 600 if (mc->inpa) |
601 gdk_input_remove(mc->inpa); | |
602 | |
1584 | 603 mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_WRITE, msn_invite_callback, mc); |
604 | |
605 g_strfreev(res); | |
606 | |
607 return; | |
608 } | |
1569 | 609 else if (!strncmp("LST ", buf, 4)) |
1567 | 610 { |
611 char **res; | |
612 | |
613 res = g_strsplit(buf, " ", 0); | |
614 | |
1568 | 615 /* If we have zero buddies, abort */ |
616 if (atoi(res[5]) == 0) | |
617 { | |
618 g_strfreev(res); | |
619 return; | |
620 } | |
621 | |
1567 | 622 /* First, let's check the list type */ |
623 if (!strcmp("FL", res[2])) | |
624 { | |
625 /* We're dealing with a forward list. Add them | |
626 * to our buddylist and continue along our | |
627 * merry little way */ | |
628 | |
629 struct buddy *b; | |
630 | |
631 b = find_buddy(gc, res[6]); | |
632 | |
633 if (!b) | |
634 add_buddy(gc, "Buddies", res[6], res[7]); | |
635 } | |
636 | |
637 g_strfreev(res); | |
638 | |
639 return; | |
1259 | 640 } |
1628 | 641 else if (!strncmp("FLN ", buf, 4)) |
642 { | |
643 /* Someone signed off */ | |
644 char **res; | |
645 | |
646 res = g_strsplit(buf, " ", 0); | |
647 | |
648 serv_got_update(gc, res[1], 0, 0, 0, 0, 0, 0); | |
649 | |
650 g_strfreev(res); | |
651 | |
652 return; | |
653 } | |
1733 | 654 else if (!strncmp("ADD ", buf, 4)) |
655 { | |
656 msn_add_request(gc,buf); | |
657 return; | |
658 } | |
1628 | 659 if ( (!strncmp("NLN ", buf, 4)) || (!strncmp("ILN ", buf, 4))) |
660 { | |
661 int status; | |
662 int query; | |
663 char **res; | |
664 | |
665 res = g_strsplit(buf, " ", 0); | |
666 | |
667 if (strcasecmp(res[0], "NLN") == 0) | |
668 query = 1; | |
669 else | |
670 query = 2; | |
671 | |
672 if (!strcasecmp(res[query], "NLN")) | |
673 status = UC_NORMAL; | |
674 else if (!strcasecmp(res[query], "BSY")) | |
675 status = UC_NORMAL | (MSN_BUSY << 5); | |
676 else if (!strcasecmp(res[query], "IDL")) | |
677 status = UC_NORMAL | (MSN_IDLE << 5); | |
678 else if (!strcasecmp(res[query], "BRB")) | |
679 status = UC_NORMAL | (MSN_BRB << 5); | |
680 else if (!strcasecmp(res[query], "AWY")) | |
681 status = UC_UNAVAILABLE; | |
682 else if (!strcasecmp(res[query], "PHN")) | |
683 status = UC_NORMAL | (MSN_PHONE << 5); | |
684 else if (!strcasecmp(res[query], "LUN")) | |
685 status = UC_NORMAL | (MSN_LUNCH << 5); | |
686 else | |
687 status = UC_NORMAL; | |
688 | |
689 serv_got_update(gc, res[query+1], 1, 0, 0, 0, status, 0); | |
690 | |
691 g_strfreev(res); | |
692 return; | |
693 } | |
1259 | 694 |
695 } | |
696 | |
1567 | 697 static void msn_login_callback(gpointer data, gint source, GdkInputCondition condition) |
1282 | 698 { |
1567 | 699 struct gaim_connection *gc = data; |
700 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
701 char buf[MSN_BUF_LEN]; | |
1259 | 702 int i = 0; |
1282 | 703 |
1567 | 704 if (!gc->inpa) |
705 { | |
706 fcntl(source, F_SETFL, 0); | |
707 | |
708 gdk_input_remove(md->inpa); | |
709 md->inpa = 0; | |
710 | |
711 gc->inpa = gdk_input_add(md->fd, GDK_INPUT_READ, msn_login_callback, gc); | |
1307 | 712 |
1567 | 713 if (md->status & MSN_SIGNON_GOT_XFR) |
714 { | |
715 /* Looks like we were transfered here. Just send a sign on */ | |
716 set_login_progress(gc, 3, "Signing On"); | |
1756 | 717 g_snprintf(buf, MSN_BUF_LEN, "USR %d %s I %s\n", md->last_trid, md->policy, gc->username); |
1567 | 718 msn_write(md->fd, buf); |
719 | |
720 /* Reset this bit */ | |
721 md->status ^= MSN_SIGNON_GOT_XFR; | |
722 } | |
723 else | |
724 { | |
725 /* Otherwise, send an initial request */ | |
1733 | 726 set_login_progress(gc, 2, "Verifying"); |
1259 | 727 |
1567 | 728 g_snprintf(md->protocol, 6, "MSNP2"); |
729 | |
730 g_snprintf(buf, MSN_BUF_LEN, "VER %d %s\n", trId(md), md->protocol); | |
731 msn_write(md->fd, buf); | |
732 } | |
733 | |
734 return; | |
735 } | |
736 | |
737 bzero(buf, MSN_BUF_LEN); | |
738 | |
739 do | |
740 { | |
1588 | 741 if (!read(source, buf + i, 1)) |
1567 | 742 { |
743 hide_login_progress(gc, "Read error"); | |
744 signoff(gc); | |
1259 | 745 return; |
1567 | 746 } |
1259 | 747 |
1567 | 748 } while (buf[i++] != '\n'); |
1259 | 749 |
750 g_strchomp(buf); | |
751 | |
1733 | 752 debug_printf("MSN ==> %s\n", buf); |
1567 | 753 |
754 /* Check to see what was just sent back to us. We should be seeing a VER tag. */ | |
755 if (!strncmp("VER ", buf, 4) && (!strstr("MSNP2", buf))) | |
756 { | |
1733 | 757 /* Now that we got our ver, we should send a policy request */ |
1567 | 758 g_snprintf(buf, MSN_BUF_LEN, "INF %d\n", trId(md)); |
759 msn_write(md->fd, buf); | |
760 | |
761 return; | |
762 } | |
763 else if (!strncmp("INF ", buf, 4)) | |
764 { | |
765 char **res; | |
766 | |
767 /* Make a copy of our resulting policy */ | |
768 res = g_strsplit(buf, " ", 0); | |
769 md->policy = g_strdup(res[2]); | |
770 | |
771 /* And send our signon packet */ | |
772 set_login_progress(gc, 3, "Signing On"); | |
773 | |
774 g_snprintf(buf, MSN_BUF_LEN, "USR %d %s I %s\n", trId(md), md->policy, gc->username); | |
775 msn_write(md->fd, buf); | |
776 | |
777 g_strfreev(res); | |
778 | |
779 return; | |
780 } | |
1598 | 781 else if (!strncmp("ADD ", buf, 4)) |
782 { | |
1733 | 783 msn_add_request(gc,buf); |
1598 | 784 return; |
785 } | |
1567 | 786 else if (!strncmp("XFR ", buf, 4)) |
787 { | |
788 char **res; | |
789 char *host; | |
790 char *port; | |
791 | |
792 res = g_strsplit(buf, " ", 0); | |
793 | |
794 strcpy(buf, res[3]); | |
795 | |
796 g_strfreev(res); | |
797 | |
798 res = g_strsplit(buf, ":", 0); | |
799 | |
800 close(md->fd); | |
801 | |
1603 | 802 set_login_progress(gc, 3, "Connecting to Auth"); |
1567 | 803 |
804 /* Now we have the host and port */ | |
805 if (!(md->fd = msn_connect(res[0], atoi(res[1])))) | |
806 { | |
807 hide_login_progress(gc, "Error connecting to server"); | |
808 signoff(gc); | |
809 return; | |
810 } | |
811 | |
812 g_strfreev(res); | |
813 | |
814 md->status |= MSN_SIGNON_GOT_XFR; | |
815 | |
816 gdk_input_remove(gc->inpa); | |
817 gc->inpa = 0; | |
818 | |
819 md->inpa = gdk_input_add(md->fd, GDK_INPUT_WRITE, msn_login_callback, gc); | |
820 | |
821 return; | |
822 } | |
823 else if (!strncmp("USR ", buf, 4)) | |
824 { | |
825 if (md->status & MSN_SIGNON_SENT_USR) | |
826 { | |
827 char **res; | |
828 | |
829 res = g_strsplit(buf, " ", 0); | |
830 | |
831 if (strcasecmp("OK", res[2])) | |
832 { | |
833 hide_login_progress(gc, "Error signing on"); | |
834 signoff(gc); | |
835 } | |
836 else | |
837 { | |
1756 | 838 md->friendly = g_strdup(url_decode(res[4])); |
1567 | 839 |
840 /* Ok, ok. Your account is FINALLY online. Ya think Microsoft | |
841 * could have had any more steps involved? */ | |
842 | |
843 set_login_progress(gc, 4, "Fetching config"); | |
844 | |
845 /* Sync our buddylist */ | |
846 g_snprintf(buf, MSN_BUF_LEN, "SYN %d 0\n", trId(md)); | |
847 msn_write(md->fd, buf); | |
848 | |
849 /* And set ourselves online */ | |
850 g_snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
851 msn_write(md->fd, buf); | |
852 | |
853 account_online(gc); | |
854 serv_finish_login(gc); | |
855 | |
856 if (bud_list_cache_exists(gc)) | |
857 do_import(NULL, gc); | |
858 | |
859 gdk_input_remove(gc->inpa); | |
860 gc->inpa = gdk_input_add(md->fd, GDK_INPUT_READ, msn_callback, gc); | |
861 } | |
862 | |
863 g_strfreev(res); | |
864 } | |
865 else | |
866 { | |
867 char **res; | |
868 char buf2[MSN_BUF_LEN]; | |
869 int j; | |
870 md5_state_t st; | |
871 md5_byte_t di[16]; | |
872 | |
873 res = g_strsplit(buf, " ", 0); | |
874 | |
875 /* Make a copy of our MD5 Hash key */ | |
876 strcpy(buf, res[4]); | |
877 | |
878 /* Generate our secret with our key and password */ | |
879 snprintf(buf2, MSN_BUF_LEN, "%s%s", buf, gc->password); | |
880 | |
881 md5_init(&st); | |
882 md5_append(&st, (const md5_byte_t *)buf2, strlen(buf2)); | |
883 md5_finish(&st, di); | |
884 | |
885 /* Now that we have the MD5 Hash, lets' hex encode this bad boy. I smoke bad crack. */ | |
886 sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", | |
887 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], | |
888 di[13],di[14],di[15]); | |
889 | |
890 /* And now, send our final sign on packet */ | |
891 g_snprintf(buf2, MSN_BUF_LEN, "USR %s %s S %s\n", res[1], md->policy, buf); | |
892 msn_write(md->fd, buf2); | |
893 | |
894 md->status |= MSN_SIGNON_SENT_USR; | |
895 | |
896 g_strfreev(res); | |
897 } | |
898 | |
899 return; | |
900 } | |
1259 | 901 } |
902 | |
1282 | 903 int msn_connect(char *server, int port) |
904 { | |
1259 | 905 int fd; |
906 struct hostent *host; | |
907 struct sockaddr_in site; | |
908 | |
1567 | 909 if (!(host = gethostbyname(server))) |
910 { | |
1733 | 911 debug_printf("Could not resolve host name: %s\n", server); |
1259 | 912 return -1; |
913 } | |
914 | |
1567 | 915 bzero(&site, sizeof(struct sockaddr_in)); |
916 site.sin_port = htons(port); | |
917 memcpy(&site.sin_addr, host->h_addr, host->h_length); | |
918 site.sin_family = host->h_addrtype; | |
1259 | 919 |
1567 | 920 fd = socket(host->h_addrtype, SOCK_STREAM, 0); |
1259 | 921 |
1567 | 922 fcntl(fd, F_SETFL, O_NONBLOCK); |
1259 | 923 |
1567 | 924 if (connect(fd, (struct sockaddr *)&site, sizeof(struct sockaddr_in)) < 0) |
925 { | |
926 if ((errno == EINPROGRESS) || (errno == EINTR)) | |
927 { | |
1733 | 928 debug_printf("Connection would block\n"); |
1567 | 929 return fd; |
1259 | 930 } |
931 | |
1567 | 932 close(fd); |
933 fd = -1; | |
1259 | 934 } |
1567 | 935 |
936 return fd; | |
1259 | 937 } |
938 | |
1282 | 939 void msn_login(struct aim_user *user) |
940 { | |
1567 | 941 struct gaim_connection *gc = new_gaim_conn(user); |
942 struct msn_data *md = gc->proto_data = g_new0(struct msn_data, 1); | |
1282 | 943 |
1567 | 944 gc->inpa = 0; |
1282 | 945 |
946 set_login_progress(gc, 1, "Connecting"); | |
1259 | 947 |
948 while (gtk_events_pending()) | |
949 gtk_main_iteration(); | |
1567 | 950 |
1259 | 951 if (!g_slist_find(connections, gc)) |
952 return; | |
953 | |
1567 | 954 md->status = 0; |
1282 | 955 |
1567 | 956 if (!(md->fd = msn_connect("messenger.hotmail.com", 1863))) |
957 { | |
958 hide_login_progress(gc, "Error connecting to server"); | |
1259 | 959 signoff(gc); |
960 return; | |
961 } | |
962 | |
1756 | 963 sprintf(gc->username, "%s", msn_normalize(gc->username)); |
964 | |
1567 | 965 md->inpa = gdk_input_add(md->fd, GDK_INPUT_WRITE, msn_login_callback, gc); |
1259 | 966 |
1733 | 967 debug_printf("Connected.\n"); |
1284 | 968 } |
969 | |
1584 | 970 void msn_send_im(struct gaim_connection *gc, char *who, char *message, int away) |
971 { | |
972 struct msn_conn *mc; | |
973 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
974 char buf[MSN_BUF_LEN]; | |
975 | |
976 if (!g_strcasecmp(who, gc->username)) | |
977 { | |
1733 | 978 do_error_dialog("You can not send a message to yourself!", "Gaim: MSN Error"); |
1584 | 979 return; |
980 } | |
981 | |
982 mc = find_msn_conn_by_user(who); | |
983 | |
984 /* If we're not already in a conversation with | |
985 * this person then we have to do some tricky things. */ | |
986 | |
987 if (!mc) | |
988 { | |
989 gchar buf2[MSN_BUF_LEN]; | |
990 gchar *address; | |
991 gchar *auth; | |
992 gchar **res; | |
993 | |
994 /* Request a new switchboard connection */ | |
995 g_snprintf(buf, MSN_BUF_LEN, "XFR %d SB\n", trId(md)); | |
996 msn_write(md->fd, buf); | |
997 | |
998 mc = g_new0(struct msn_conn, 1); | |
999 | |
1000 mc->user = g_strdup(who); | |
1001 mc->gc = gc; | |
1002 mc->last_trid = md->last_trid; | |
1003 mc->txqueue = g_strdup(message); | |
1004 | |
1005 /* Append our connection */ | |
1006 msn_connections = g_slist_append(msn_connections, mc); | |
1007 } | |
1585 | 1008 else |
1009 { | |
1598 | 1010 g_snprintf(buf, MSN_BUF_LEN, "MSG %d N %d\r\n%s%s", trId(md), |
1011 strlen(message) + strlen(MIME_HEADER), MIME_HEADER, message); | |
1585 | 1012 |
1013 msn_write(mc->fd, buf); | |
1014 } | |
1584 | 1015 |
1016 } | |
1017 | |
1598 | 1018 static void msn_add_buddy(struct gaim_connection *gc, char *who) |
1019 { | |
1020 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1021 char buf[MSN_BUF_LEN - 1]; | |
1022 | |
1023 snprintf(buf, MSN_BUF_LEN, "ADD %d FL %s %s\n", trId(md), who, who); | |
1024 msn_write(md->fd, buf); | |
1025 } | |
1026 | |
1027 static void msn_remove_buddy(struct gaim_connection *gc, char *who) | |
1028 { | |
1029 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1030 char buf[MSN_BUF_LEN - 1]; | |
1031 | |
1032 snprintf(buf, MSN_BUF_LEN, "REM %d FL %s\n", trId(md), who); | |
1033 msn_write(md->fd, buf); | |
1034 } | |
1035 | |
1036 static void msn_rem_permit(struct gaim_connection *gc, char *who) | |
1037 { | |
1038 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1039 char buf[MSN_BUF_LEN - 1]; | |
1040 | |
1041 snprintf(buf, MSN_BUF_LEN, "REM %d AL %s\n", trId(md), who); | |
1042 msn_write(md->fd, buf); | |
1043 } | |
1044 | |
1045 static void msn_add_permit(struct gaim_connection *gc, char *who) | |
1046 { | |
1047 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1048 char buf[MSN_BUF_LEN - 1]; | |
1049 | |
1050 snprintf(buf, MSN_BUF_LEN, "ADD %d AL %s %s\n", trId(md), who, who); | |
1051 msn_write(md->fd, buf); | |
1052 } | |
1053 | |
1054 static void msn_rem_deny(struct gaim_connection *gc, char *who) | |
1055 { | |
1056 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1057 char buf[MSN_BUF_LEN - 1]; | |
1058 | |
1059 snprintf(buf, MSN_BUF_LEN, "REM %d BL %s\n", trId(md), who); | |
1060 msn_write(md->fd, buf); | |
1061 } | |
1062 | |
1063 static void msn_add_deny(struct gaim_connection *gc, char *who) | |
1064 { | |
1065 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1066 char buf[MSN_BUF_LEN - 1]; | |
1067 | |
1068 snprintf(buf, MSN_BUF_LEN, "ADD %d BL %s %s\n", trId(md), who, who); | |
1069 msn_write(md->fd, buf); | |
1070 } | |
1071 | |
1630 | 1072 static GList *msn_away_states() |
1073 { | |
1074 GList *m = NULL; | |
1075 | |
1076 m = g_list_append(m, "Available"); | |
1077 m = g_list_append(m, "Away From Computer"); | |
1078 m = g_list_append(m, "Be Right Back"); | |
1079 m = g_list_append(m, "Busy"); | |
1080 m = g_list_append(m, "On The Phone"); | |
1081 m = g_list_append(m, "Out To Lunch"); | |
1082 | |
1083 return m; | |
1084 } | |
1085 | |
1600 | 1086 static void msn_set_away(struct gaim_connection *gc, char *state, char *msg) |
1087 { | |
1088 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1089 char buf[MSN_BUF_LEN - 1]; | |
1090 | |
1630 | 1091 |
1092 gc->away = NULL; | |
1093 | |
1600 | 1094 if (msg) |
1630 | 1095 { |
1096 gc->away = ""; | |
1600 | 1097 snprintf(buf, MSN_BUF_LEN, "CHG %d AWY\n", trId(md)); |
1630 | 1098 } |
1099 | |
1100 else if (state) | |
1101 { | |
1102 char away[4]; | |
1103 | |
1104 gc->away = ""; | |
1105 | |
1106 if (!strcmp(state, "Available")) | |
1107 sprintf(away, "NLN"); | |
1108 else if (!strcmp(state, "Away From Computer")) | |
1109 sprintf(away, "AWY"); | |
1110 else if (!strcmp(state, "Be Right Back")) | |
1111 sprintf(away, "BRB"); | |
1112 else if (!strcmp(state, "Busy")) | |
1113 sprintf(away, "BSY"); | |
1114 else if (!strcmp(state, "On The Phone")) | |
1115 sprintf(away, "PHN"); | |
1116 else if (!strcmp(state, "Out To Lunch")) | |
1117 sprintf(away, "LUN"); | |
1118 else | |
1119 sprintf(away, "NLN"); | |
1120 | |
1121 snprintf(buf, MSN_BUF_LEN, "CHG %d %s\n", trId(md), away); | |
1122 } | |
1600 | 1123 else if (gc->is_idle) |
1124 snprintf(buf, MSN_BUF_LEN, "CHG %d IDL\n", trId(md)); | |
1125 else | |
1126 snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
1127 | |
1128 msn_write(md->fd, buf); | |
1129 } | |
1130 | |
1131 | |
1132 static void msn_set_idle(struct gaim_connection *gc, int idle) | |
1133 { | |
1134 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1135 char buf[MSN_BUF_LEN - 1]; | |
1136 | |
1137 if (idle) | |
1138 snprintf(buf, MSN_BUF_LEN, "CHG %d IDL\n", trId(md)); | |
1139 else | |
1140 snprintf(buf, MSN_BUF_LEN, "CHG %d NLN\n", trId(md)); | |
1141 | |
1142 msn_write(md->fd, buf); | |
1143 } | |
1144 | |
1145 static void msn_close(struct gaim_connection *gc) | |
1146 { | |
1147 struct msn_data *md = (struct msn_data *)gc->proto_data; | |
1148 char buf[MSN_BUF_LEN - 1]; | |
1149 struct msn_conn *mc = NULL; | |
1150 | |
1151 while (msn_connections) | |
1152 { | |
1153 mc = (struct msn_conn *)msn_connections->data; | |
1154 | |
1155 free_msn_conn(mc); | |
1156 } | |
1157 | |
1158 if (md->fd) | |
1159 { | |
1160 snprintf(buf, MSN_BUF_LEN, "OUT\n"); | |
1161 msn_write(md->fd, buf); | |
1162 close(md->fd); | |
1163 } | |
1164 | |
1165 if (gc->inpa) | |
1166 gdk_input_remove(gc->inpa); | |
1167 | |
1168 if (md->friendly) | |
1169 free(md->friendly); | |
1170 | |
1171 g_free(gc->proto_data); | |
1172 } | |
1173 | |
1639 | 1174 static char *msn_get_away_text(int s) |
1175 { | |
1176 switch (s) | |
1177 { | |
1178 case MSN_BUSY : | |
1179 return "Busy"; | |
1180 case MSN_BRB : | |
1181 return "Be right back"; | |
1182 case MSN_AWAY : | |
1183 return "Away from the computer"; | |
1184 case MSN_PHONE : | |
1185 return "On the phone"; | |
1186 case MSN_LUNCH : | |
1187 return "Out to lunch"; | |
1640 | 1188 case MSN_IDLE : |
1189 return "Idle"; | |
1639 | 1190 default: |
1191 return NULL; | |
1192 } | |
1193 } | |
1194 | |
1195 static void msn_buddy_menu(GtkWidget *menu, struct gaim_connection *gc, char *who) | |
1196 { | |
1197 struct buddy *b = find_buddy(gc, who); | |
1198 char buf[MSN_BUF_LEN]; | |
1199 GtkWidget *button; | |
1200 | |
1201 if (!(b->uc >> 5)) | |
1202 return; | |
1203 | |
1204 g_snprintf(buf, MSN_BUF_LEN, "Status: %s", msn_get_away_text(b->uc >> 5)); | |
1205 | |
1206 button = gtk_menu_item_new_with_label(buf); | |
1207 gtk_menu_append(GTK_MENU(menu), button); | |
1208 gtk_widget_show(button); | |
1209 } | |
1210 | |
1717 | 1211 void msn_newmail_dialog(const char *text) |
1212 { | |
1213 GtkWidget *window; | |
1214 GtkWidget *vbox; | |
1215 GtkWidget *label; | |
1216 GtkWidget *hbox; | |
1217 GtkWidget *button; | |
1218 | |
1219 window = gtk_window_new(GTK_WINDOW_DIALOG); | |
1220 gtk_window_set_wmclass(GTK_WINDOW(window), "prompt", "Gaim"); | |
1221 gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE); | |
1222 gtk_window_set_title(GTK_WINDOW(window), _("Gaim-MSN: New Mail")); | |
1223 gtk_widget_realize(window); | |
1224 aol_icon(window->window); | |
1225 | |
1226 vbox = gtk_vbox_new(FALSE, 5); | |
1227 gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); | |
1228 gtk_container_add(GTK_CONTAINER(window), vbox); | |
1229 | |
1230 label = gtk_label_new(text); | |
1231 gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); | |
1232 | |
1233 hbox = gtk_hbox_new(FALSE, 5); | |
1234 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); | |
1235 | |
1236 button = picture_button(window, _("OK"), ok_xpm); | |
1237 gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); | |
1238 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(msn_des_win), window); | |
1239 | |
1240 gtk_widget_show_all(window); | |
1241 } | |
1242 | |
1243 void msn_des_win(GtkWidget *a, GtkWidget *b) | |
1244 { | |
1245 gtk_widget_destroy(b); | |
1246 } | |
1247 | |
1248 static void mod_opt(GtkWidget *b, struct mod_usr_opt *m) | |
1249 { | |
1250 if (m->user) { | |
1251 if (m->user->proto_opt[m->opt][0] == '1') | |
1252 m->user->proto_opt[m->opt][0] = '\0'; | |
1253 else | |
1254 strcpy(m->user->proto_opt[m->opt],"1"); | |
1255 } | |
1256 } | |
1257 | |
1258 static void free_muo(GtkWidget *b, struct mod_usr_opt *m) | |
1259 { | |
1260 g_free(m); | |
1261 } | |
1262 | |
1263 static GtkWidget *msn_protoopt_button(const char *text, struct aim_user *u, int option, GtkWidget *box) | |
1264 { | |
1265 GtkWidget *button; | |
1266 struct mod_usr_opt *muo = g_new0(struct mod_usr_opt, 1); | |
1267 button = gtk_check_button_new_with_label(text); | |
1268 if (u) { | |
1269 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), (u->proto_opt[option][0] == '1')); | |
1270 } | |
1271 gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0); | |
1272 muo->user = u; | |
1273 muo->opt = option; | |
1274 gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(mod_opt), muo); | |
1275 gtk_signal_connect(GTK_OBJECT(button), "destroy", GTK_SIGNAL_FUNC(free_muo), muo); | |
1276 gtk_widget_show(button); | |
1277 return button; | |
1278 } | |
1279 | |
1280 static void msn_user_opts(GtkWidget *book, struct aim_user *user) { | |
1281 GtkWidget *vbox; | |
1282 GtkWidget *button; | |
1283 | |
1284 vbox = gtk_vbox_new(FALSE, 5); | |
1285 gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); | |
1286 gtk_notebook_append_page(GTK_NOTEBOOK(book), vbox, | |
1287 gtk_label_new("MSN Options")); | |
1288 gtk_widget_show(vbox); | |
1289 button = msn_protoopt_button("Notify me of new HotMail",user,USEROPT_HOTMAIL,vbox); | |
1290 } | |
1291 | |
1292 /* | |
1293 Process messages from Hotmail service. right now we just check for new | |
1294 mail notifications, if the user has checking enabled. | |
1295 */ | |
1296 | |
1297 static void process_hotmail_msg(struct gaim_connection *gc, gchar *msgdata) | |
1298 { | |
1299 gchar *mailnotice; | |
1300 char *mailfrom,*mailsubj,*mailct,*mailp; | |
1301 | |
1302 if (gc->user->proto_opt[USEROPT_HOTMAIL][0] != '1') return; | |
1303 mailfrom=NULL; mailsubj=NULL; mailct=NULL; mailp=NULL; | |
1304 mailct = strstr(msgdata,"Content-Type: "); | |
1305 mailp = strstr(mailct,";"); | |
1306 if (mailct != NULL && mailp != NULL && mailp > mailct && !strncmp(mailct,"Content-Type: text/x-msmsgsemailnotification",(mailp-mailct)-1)) | |
1307 { | |
1308 mailfrom=strstr(mailp,"From: "); | |
1309 mailsubj=strstr(mailp,"Subject: "); | |
1310 } | |
1311 | |
1312 if (mailfrom != NULL && mailsubj != NULL) | |
1313 { | |
1314 mailfrom += 6; | |
1315 mailp=strstr(mailfrom,"\r\n"); | |
1316 if (mailp==NULL) return; | |
1317 *mailp = 0; | |
1318 mailsubj += 9; | |
1319 mailp=strstr(mailsubj,"\r\n"); | |
1320 if (mailp==NULL) return; | |
1321 *mailp = 0; | |
1322 mailnotice = (gchar *)g_malloc(sizeof(gchar) *(strlen(mailfrom)+strlen(mailsubj)+128)); | |
1323 sprintf(mailnotice,"Mail from %s, re: %s",mailfrom,mailsubj); | |
1324 msn_newmail_dialog(mailnotice); | |
1325 g_free(mailnotice); | |
1326 } | |
1327 } | |
1328 | |
1756 | 1329 static char *msn_normalize(const char *s) |
1330 { | |
1331 static char buf[BUF_LEN]; | |
1332 char *t, *u; | |
1333 int x = 0; | |
1334 | |
1335 g_return_val_if_fail((s != NULL), NULL); | |
1336 | |
1337 u = t = g_strdup(s); | |
1338 | |
1339 g_strdown(t); | |
1340 | |
1341 while (*t && (x < BUF_LEN - 1)) { | |
1342 if (*t != ' ') | |
1343 buf[x++] = *t; | |
1344 t++; | |
1345 } | |
1346 buf[x] = '\0'; | |
1347 g_free(u); | |
1348 | |
1349 if (!strchr(buf, '@')) { | |
1350 strcat(buf, "@hotmail.com"); /* if they don't specify something, it will be hotmail.com. msn.com | |
1351 is valid too, but hey, if they wanna use it, they gotta enter it | |
1352 themselves. */ | |
1353 } else if ((u = strchr(strchr(buf, '@'), '/')) != NULL) { | |
1354 *u = '\0'; | |
1355 } | |
1356 | |
1357 return buf; | |
1358 } | |
1359 | |
1360 | |
1572 | 1361 static char **msn_list_icon(int uc) |
1362 { | |
1363 if (uc == UC_UNAVAILABLE) | |
1364 return msn_away_xpm; | |
1365 else if (uc == UC_NORMAL) | |
1366 return msn_online_xpm; | |
1367 | |
1631 | 1368 return msn_away_xpm; |
1572 | 1369 } |
1370 | |
1259 | 1371 static struct prpl *my_protocol = NULL; |
1372 | |
1282 | 1373 void msn_init(struct prpl *ret) |
1374 { | |
1259 | 1375 ret->protocol = PROTO_MSN; |
1376 ret->name = msn_name; | |
1572 | 1377 ret->list_icon = msn_list_icon; |
1639 | 1378 ret->buddy_menu = msn_buddy_menu; |
1717 | 1379 ret->user_opts = msn_user_opts; |
1259 | 1380 ret->login = msn_login; |
1600 | 1381 ret->close = msn_close; |
1584 | 1382 ret->send_im = msn_send_im; |
1259 | 1383 ret->set_info = NULL; |
1384 ret->get_info = NULL; | |
1630 | 1385 ret->away_states = msn_away_states; |
1600 | 1386 ret->set_away = msn_set_away; |
1259 | 1387 ret->get_away_msg = NULL; |
1388 ret->set_dir = NULL; | |
1389 ret->get_dir = NULL; | |
1390 ret->dir_search = NULL; | |
1600 | 1391 ret->set_idle = msn_set_idle; |
1259 | 1392 ret->change_passwd = NULL; |
1598 | 1393 ret->add_buddy = msn_add_buddy; |
1259 | 1394 ret->add_buddies = NULL; |
1598 | 1395 ret->remove_buddy = msn_remove_buddy; |
1396 ret->add_permit = msn_add_permit; | |
1397 ret->rem_permit = msn_rem_permit; | |
1398 ret->add_deny = msn_add_deny; | |
1399 ret->rem_deny = msn_rem_deny; | |
1259 | 1400 ret->warn = NULL; |
1401 ret->accept_chat = NULL; | |
1402 ret->join_chat = NULL; | |
1403 ret->chat_invite = NULL; | |
1404 ret->chat_leave = NULL; | |
1405 ret->chat_whisper = NULL; | |
1406 ret->chat_send = NULL; | |
1407 ret->keepalive = NULL; | |
1756 | 1408 ret->normalize = msn_normalize; |
1259 | 1409 |
1410 my_protocol = ret; | |
1411 } | |
1412 | |
1282 | 1413 char *gaim_plugin_init(GModule * handle) |
1414 { | |
1443
336fc98b7f90
[gaim-migrate @ 1453]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
1327
diff
changeset
|
1415 load_protocol(msn_init, sizeof(struct prpl)); |
1259 | 1416 return NULL; |
1417 } | |
1418 | |
1282 | 1419 void gaim_plugin_remove() |
1420 { | |
1259 | 1421 struct prpl *p = find_prpl(PROTO_MSN); |
1422 if (p == my_protocol) | |
1423 unload_protocol(p); | |
1424 } |