source: protocols/msn/msn_util.c @ 0b9daac

Last change on this file since 0b9daac was 0b9daac, checked in by dequis <dx@…>, at 2015-02-20T23:16:08Z

Reorganize include files to avoid conflicts with other libs

  • Change all header includes to be relative to the project root
  • Remove -I${includedir} from bitlbee.pc Cflags
  • Install lib and protocols headers to their own directories. So now it is:

/usr/include/bitlbee/*.h
/usr/include/bitlbee/lib/*.h
/usr/include/bitlbee/protocols/*.h

This breaks backwards compatibility of third party plugins, but now
they don't have to do ambiguous includes like #include <proxy.h>

This also fixes trac ticket 1170 - conflicts when libproxy and liboauth
are installed at the same time bitlbee is built, which the macports
project ran into several times.

  • Property mode set to 100644
File size: 12.5 KB
Line 
1/********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2012 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* MSN module - Miscellaneous utilities                                 */
8
9/*
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 2 of the License, or
13  (at your option) any later version.
14
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  GNU General Public License for more details.
19
20  You should have received a copy of the GNU General Public License with
21  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
22  if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
23  Fifth Floor, Boston, MA  02110-1301  USA
24*/
25
26#include "protocols/nogaim.h"
27#include "msn.h"
28#include "lib/md5.h"
29#include "soap.h"
30#include <ctype.h>
31
32static char *adlrml_entry(const char *handle_, msn_buddy_flags_t list)
33{
34        char *domain, handle[strlen(handle_) + 1];
35
36        strcpy(handle, handle_);
37        if ((domain = strchr(handle, '@'))) {
38                *(domain++) = '\0';
39        } else {
40                return NULL;
41        }
42
43        return g_markup_printf_escaped("<ml><d n=\"%s\"><c n=\"%s\" l=\"%d\" t=\"1\"/></d></ml>",
44                                       domain, handle, list);
45}
46
47int msn_buddy_list_add(struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *realname,
48                       const char *group)
49{
50        struct msn_data *md = ic->proto_data;
51        char groupid[8];
52        bee_user_t *bu;
53        struct msn_buddy_data *bd;
54        char *adl;
55
56        *groupid = '\0';
57#if 0
58        if (group) {
59                int i;
60                for (i = 0; i < md->groupcount; i++) {
61                        if (g_strcasecmp(md->grouplist[i], group) == 0) {
62                                g_snprintf(groupid, sizeof(groupid), " %d", i);
63                                break;
64                        }
65                }
66
67                if (*groupid == '\0') {
68                        /* Have to create this group, it doesn't exist yet. */
69                        struct msn_groupadd *ga;
70                        GSList *l;
71
72                        for (l = md->grpq; l; l = l->next) {
73                                ga = l->data;
74                                if (g_strcasecmp(ga->group, group) == 0) {
75                                        break;
76                                }
77                        }
78
79                        ga = g_new0(struct msn_groupadd, 1);
80                        ga->who = g_strdup(who);
81                        ga->group = g_strdup(group);
82                        md->grpq = g_slist_prepend(md->grpq, ga);
83
84                        if (l == NULL) {
85                                char groupname[strlen(group) + 1];
86                                strcpy(groupname, group);
87                                http_encode(groupname);
88                                g_snprintf(buf, sizeof(buf), "ADG %d %s %d\r\n", ++md->trId, groupname, 0);
89                                return msn_write(ic, buf, strlen(buf));
90                        } else {
91                                /* This can happen if the user's doing lots of adds to a
92                                   new group at once; we're still waiting for the server
93                                   to confirm group creation. */
94                                return 1;
95                        }
96                }
97        }
98#endif
99
100        if (!((bu = bee_user_by_handle(ic->bee, ic, who)) ||
101              (bu = bee_user_new(ic->bee, ic, who, 0))) ||
102            !(bd = bu->data) || bd->flags & list) {
103                return 1;
104        }
105
106        bd->flags |= list;
107
108        if (list == MSN_BUDDY_FL) {
109                msn_soap_ab_contact_add(ic, bu);
110        } else {
111                msn_soap_memlist_edit(ic, who, TRUE, list);
112        }
113
114        if ((adl = adlrml_entry(who, list))) {
115                int st = msn_ns_write(ic, -1, "ADL %d %zd\r\n%s",
116                                      ++md->trId, strlen(adl), adl);
117                g_free(adl);
118
119                return st;
120        }
121
122        return 1;
123}
124
125int msn_buddy_list_remove(struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *group)
126{
127        struct msn_data *md = ic->proto_data;
128        char groupid[8];
129        bee_user_t *bu;
130        struct msn_buddy_data *bd;
131        char *adl;
132
133        *groupid = '\0';
134#if 0
135        if (group) {
136                int i;
137                for (i = 0; i < md->groupcount; i++) {
138                        if (g_strcasecmp(md->grouplist[i], group) == 0) {
139                                g_snprintf(groupid, sizeof(groupid), " %d", i);
140                                break;
141                        }
142                }
143        }
144#endif
145
146        if (!(bu = bee_user_by_handle(ic->bee, ic, who)) ||
147            !(bd = bu->data) || !(bd->flags & list)) {
148                return 1;
149        }
150
151        bd->flags &= ~list;
152
153        if (list == MSN_BUDDY_FL) {
154                msn_soap_ab_contact_del(ic, bu);
155        } else {
156                msn_soap_memlist_edit(ic, who, FALSE, list);
157        }
158
159        if ((adl = adlrml_entry(who, list))) {
160                int st = msn_ns_write(ic, -1, "RML %d %zd\r\n%s",
161                                      ++md->trId, strlen(adl), adl);
162                g_free(adl);
163
164                return st;
165        }
166
167        return 1;
168}
169
170struct msn_buddy_ask_data {
171        struct im_connection *ic;
172        char *handle;
173        char *realname;
174};
175
176static void msn_buddy_ask_yes(void *data)
177{
178        struct msn_buddy_ask_data *bla = data;
179
180        msn_buddy_list_add(bla->ic, MSN_BUDDY_AL, bla->handle, bla->realname, NULL);
181
182        imcb_ask_add(bla->ic, bla->handle, NULL);
183
184        g_free(bla->handle);
185        g_free(bla->realname);
186        g_free(bla);
187}
188
189static void msn_buddy_ask_no(void *data)
190{
191        struct msn_buddy_ask_data *bla = data;
192
193        msn_buddy_list_add(bla->ic, MSN_BUDDY_BL, bla->handle, bla->realname, NULL);
194
195        g_free(bla->handle);
196        g_free(bla->realname);
197        g_free(bla);
198}
199
200void msn_buddy_ask(bee_user_t *bu)
201{
202        struct msn_buddy_ask_data *bla;
203        struct msn_buddy_data *bd = bu->data;
204        char buf[1024];
205
206        if (!(bd->flags & MSN_BUDDY_PL)) {
207                return;
208        }
209
210        bla = g_new0(struct msn_buddy_ask_data, 1);
211        bla->ic = bu->ic;
212        bla->handle = g_strdup(bu->handle);
213        bla->realname = g_strdup(bu->fullname);
214
215        g_snprintf(buf, sizeof(buf),
216                   "The user %s (%s) wants to add you to his/her buddy list.",
217                   bu->handle, bu->fullname);
218        imcb_ask(bu->ic, buf, bla, msn_buddy_ask_yes, msn_buddy_ask_no);
219}
220
221/* *NOT* thread-safe, but that's not a problem for now... */
222char **msn_linesplit(char *line)
223{
224        static char **ret = NULL;
225        static int size = 3;
226        int i, n = 0;
227
228        if (ret == NULL) {
229                ret = g_new0(char*, size);
230        }
231
232        for (i = 0; line[i] && line[i] == ' '; i++) {
233                ;
234        }
235        if (line[i]) {
236                ret[n++] = line + i;
237                for (i++; line[i]; i++) {
238                        if (line[i] == ' ') {
239                                line[i] = 0;
240                        } else if (line[i] != ' ' && !line[i - 1]) {
241                                ret[n++] = line + i;
242                        }
243
244                        if (n >= size) {
245                                ret = g_renew(char*, ret, size += 2);
246                        }
247                }
248        }
249        ret[n] = NULL;
250
251        return(ret);
252}
253
254/* This one handles input from a MSN Messenger server. Both the NS and SB servers usually give
255   commands, but sometimes they give additional data (payload). This function tries to handle
256   this all in a nice way and send all data to the right places. */
257
258/* Return values: -1: Read error, abort connection.
259                   0: Command reported error; Abort *immediately*. (The connection does not exist anymore)
260                   1: OK */
261
262int msn_handler(struct msn_handler_data *h)
263{
264        int st;
265
266        h->rxq = g_renew(char, h->rxq, h->rxlen + 1024);
267        st = read(h->fd, h->rxq + h->rxlen, 1024);
268        h->rxlen += st;
269
270        if (st <= 0) {
271                return(-1);
272        }
273
274        if (getenv("BITLBEE_DEBUG")) {
275                write(2, "->C:", 4);
276                write(2, h->rxq + h->rxlen - st, st);
277        }
278
279        while (st) {
280                int i;
281
282                if (h->msglen == 0) {
283                        for (i = 0; i < h->rxlen; i++) {
284                                if (h->rxq[i] == '\r' || h->rxq[i] == '\n') {
285                                        char *cmd_text, **cmd;
286                                        int count;
287
288                                        cmd_text = g_strndup(h->rxq, i);
289                                        cmd = msn_linesplit(cmd_text);
290                                        for (count = 0; cmd[count]; count++) {
291                                                ;
292                                        }
293                                        st = h->exec_command(h, cmd, count);
294                                        g_free(cmd_text);
295
296                                        /* If the connection broke, don't continue. We don't even exist anymore. */
297                                        if (!st) {
298                                                return(0);
299                                        }
300
301                                        if (h->msglen) {
302                                                h->cmd_text = g_strndup(h->rxq, i);
303                                        }
304
305                                        /* Skip to the next non-emptyline */
306                                        while (i < h->rxlen && (h->rxq[i] == '\r' || h->rxq[i] == '\n')) {
307                                                i++;
308                                        }
309
310                                        break;
311                                }
312                        }
313
314                        /* If we reached the end of the buffer, there's still an incomplete command there.
315                           Return and wait for more data. */
316                        if (i == h->rxlen && h->rxq[i - 1] != '\r' && h->rxq[i - 1] != '\n') {
317                                break;
318                        }
319                } else {
320                        char *msg, **cmd;
321                        int count;
322
323                        /* Do we have the complete message already? */
324                        if (h->msglen > h->rxlen) {
325                                break;
326                        }
327
328                        msg = g_strndup(h->rxq, h->msglen);
329                        cmd = msn_linesplit(h->cmd_text);
330                        for (count = 0; cmd[count]; count++) {
331                                ;
332                        }
333
334                        st = h->exec_message(h, msg, h->msglen, cmd, count);
335                        g_free(msg);
336                        g_free(h->cmd_text);
337                        h->cmd_text = NULL;
338
339                        if (!st) {
340                                return(0);
341                        }
342
343                        i = h->msglen;
344                        h->msglen = 0;
345                }
346
347                /* More data after this block? */
348                if (i < h->rxlen) {
349                        char *tmp;
350
351                        tmp = g_memdup(h->rxq + i, h->rxlen - i);
352                        g_free(h->rxq);
353                        h->rxq = tmp;
354                        h->rxlen -= i;
355                        i = 0;
356                } else {
357                        /* If not, reset the rx queue and get lost. */
358                        g_free(h->rxq);
359                        h->rxq = g_new0(char, 1);
360                        h->rxlen = 0;
361                        return(1);
362                }
363        }
364
365        return(1);
366}
367
368void msn_msgq_purge(struct im_connection *ic, GSList **list)
369{
370        struct msn_message *m;
371        GString *ret;
372        GSList *l;
373        int n = 0;
374
375        l = *list;
376        if (l == NULL) {
377                return;
378        }
379
380        m = l->data;
381        ret = g_string_sized_new(1024);
382        g_string_printf(ret, "Warning: Cleaning up MSN (switchboard) connection with unsent "
383                        "messages to %s:", m->who ? m->who : "unknown recipient");
384
385        while (l) {
386                m = l->data;
387
388                if (strncmp(m->text, "\r\r\r", 3) != 0) {
389                        g_string_append_printf(ret, "\n%s", m->text);
390                        n++;
391                }
392
393                g_free(m->who);
394                g_free(m->text);
395                g_free(m);
396
397                l = l->next;
398        }
399        g_slist_free(*list);
400        *list = NULL;
401
402        if (n > 0) {
403                imcb_log(ic, "%s", ret->str);
404        }
405        g_string_free(ret, TRUE);
406}
407
408/* Copied and heavily modified from http://tmsnc.sourceforge.net/chl.c */
409char *msn_p11_challenge(char *challenge)
410{
411        char *output, buf[256];
412        md5_state_t md5c;
413        unsigned char md5Hash[16], *newHash;
414        unsigned int *md5Parts, *chlStringParts, newHashParts[5];
415        long long nHigh = 0, nLow = 0;
416        int i, n;
417
418        /* Create the MD5 hash */
419        md5_init(&md5c);
420        md5_append(&md5c, (unsigned char *) challenge, strlen(challenge));
421        md5_append(&md5c, (unsigned char *) MSNP11_PROD_KEY, strlen(MSNP11_PROD_KEY));
422        md5_finish(&md5c, md5Hash);
423
424        /* Split it into four integers */
425        md5Parts = (unsigned int *) md5Hash;
426        for (i = 0; i < 4; i++) {
427                md5Parts[i] = GUINT32_TO_LE(md5Parts[i]);
428
429                /* & each integer with 0x7FFFFFFF */
430                /* and save one unmodified array for later */
431                newHashParts[i] = md5Parts[i];
432                md5Parts[i] &= 0x7FFFFFFF;
433        }
434
435        /* make a new string and pad with '0' */
436        n = g_snprintf(buf, sizeof(buf) - 5, "%s%s00000000", challenge, MSNP11_PROD_ID);
437        /* truncate at an 8-byte boundary */
438        buf[n &= ~7] = '\0';
439
440        /* split into integers */
441        chlStringParts = (unsigned int *) buf;
442
443        /* this is magic */
444        for (i = 0; i < (n / 4) - 1; i += 2) {
445                long long temp;
446
447                chlStringParts[i]   = GUINT32_TO_LE(chlStringParts[i]);
448                chlStringParts[i + 1] = GUINT32_TO_LE(chlStringParts[i + 1]);
449
450                temp  =
451                        (md5Parts[0] *
452                         (((0x0E79A9C1 *
453                            (long long) chlStringParts[i]) % 0x7FFFFFFF) + nHigh) + md5Parts[1]) % 0x7FFFFFFF;
454                nHigh =
455                        (md5Parts[2] *
456                         (((long long) chlStringParts[i + 1] + temp) % 0x7FFFFFFF) + md5Parts[3]) % 0x7FFFFFFF;
457                nLow  = nLow + nHigh + temp;
458        }
459        nHigh = (nHigh + md5Parts[1]) % 0x7FFFFFFF;
460        nLow = (nLow + md5Parts[3]) % 0x7FFFFFFF;
461
462        newHashParts[0] ^= nHigh;
463        newHashParts[1] ^= nLow;
464        newHashParts[2] ^= nHigh;
465        newHashParts[3] ^= nLow;
466
467        /* swap more bytes if big endian */
468        for (i = 0; i < 4; i++) {
469                newHashParts[i] = GUINT32_TO_LE(newHashParts[i]);
470        }
471
472        /* make a string of the parts */
473        newHash = (unsigned char *) newHashParts;
474
475        /* convert to hexadecimal */
476        output = g_new(char, 33);
477        for (i = 0; i < 16; i++) {
478                sprintf(output + i * 2, "%02x", newHash[i]);
479        }
480
481        return output;
482}
483
484gint msn_domaintree_cmp(gconstpointer a_, gconstpointer b_)
485{
486        const char *a = a_, *b = b_;
487        gint ret;
488
489        if (!(a = strchr(a, '@')) || !(b = strchr(b, '@')) ||
490            (ret = strcmp(a, b)) == 0) {
491                ret = strcmp(a_, b_);
492        }
493
494        return ret;
495}
496
497struct msn_group *msn_group_by_name(struct im_connection *ic, const char *name)
498{
499        struct msn_data *md = ic->proto_data;
500        GSList *l;
501
502        for (l = md->groups; l; l = l->next) {
503                struct msn_group *mg = l->data;
504
505                if (g_strcasecmp(mg->name, name) == 0) {
506                        return mg;
507                }
508        }
509
510        return NULL;
511}
512
513struct msn_group *msn_group_by_id(struct im_connection *ic, const char *id)
514{
515        struct msn_data *md = ic->proto_data;
516        GSList *l;
517
518        for (l = md->groups; l; l = l->next) {
519                struct msn_group *mg = l->data;
520
521                if (g_strcasecmp(mg->id, id) == 0) {
522                        return mg;
523                }
524        }
525
526        return NULL;
527}
528
529int msn_ns_set_display_name(struct im_connection *ic, const char *value)
530{
531        struct msn_data *md = ic->proto_data;
532        char fn[strlen(value) * 3 + 1];
533
534        strcpy(fn, value);
535        http_encode(fn);
536
537        /* Note: We don't actually know if the server accepted the new name,
538           and won't give proper feedback yet if it doesn't. */
539        return msn_ns_write(ic, -1, "PRP %d MFN %s\r\n", ++md->trId, fn);
540}
541
542const char *msn_normalize_handle(const char *handle)
543{
544        if (strncmp(handle, "1:", 2) == 0) {
545                return handle + 2;
546        } else {
547                return handle;
548        }
549}
Note: See TracBrowser for help on using the repository browser.