source: protocols/msn/msn_util.c @ c5a1502

Last change on this file since c5a1502 was c5a1502, checked in by dequis <dx@…>, at 2015-03-15T14:41:47Z

msn: remove unsupported commands, OIMs and dead code

  • Property mode set to 100644
File size: 10.5 KB
RevLine 
[5ebff60]1/********************************************************************\
[b7d3cc34]2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
[79bb7e4]4  * Copyright 2002-2012 Wilmer van der Gaast and others                *
[b7d3cc34]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;
[6f10697]22  if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
23  Fifth Floor, Boston, MA  02110-1301  USA
[b7d3cc34]24*/
25
26#include "nogaim.h"
27#include "msn.h"
[21029d0]28#include "md5.h"
[193dc74]29#include "soap.h"
[b7d3cc34]30#include <ctype.h>
31
[5ebff60]32static char *adlrml_entry(const char *handle_, msn_buddy_flags_t list)
[193dc74]33{
[5ebff60]34        char *domain, handle[strlen(handle_) + 1];
35
36        strcpy(handle, handle_);
37        if ((domain = strchr(handle, '@'))) {
[d97f51b]38                *(domain++) = '\0';
[5ebff60]39        } else {
[193dc74]40                return NULL;
[5ebff60]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);
[193dc74]45}
46
[5ebff60]47int msn_buddy_list_add(struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *realname,
48                       const char *group)
[b7d3cc34]49{
[0da65d5]50        struct msn_data *md = ic->proto_data;
[64768d4]51        char groupid[8];
[193dc74]52        bee_user_t *bu;
53        struct msn_buddy_data *bd;
54        char *adl;
[5ebff60]55
[6acc033]56        *groupid = '\0';
[5ebff60]57
58        if (!((bu = bee_user_by_handle(ic->bee, ic, who)) ||
59              (bu = bee_user_new(ic->bee, ic, who, 0))) ||
60            !(bd = bu->data) || bd->flags & list) {
[193dc74]61                return 1;
[5ebff60]62        }
63
[193dc74]64        bd->flags |= list;
[5ebff60]65
66        if (list == MSN_BUDDY_FL) {
67                msn_soap_ab_contact_add(ic, bu);
68        } else {
69                msn_soap_memlist_edit(ic, who, TRUE, list);
70        }
71
72        if ((adl = adlrml_entry(who, list))) {
73                int st = msn_ns_write(ic, -1, "ADL %d %zd\r\n%s",
74                                      ++md->trId, strlen(adl), adl);
75                g_free(adl);
76
[64768d4]77                return st;
[193dc74]78        }
[5ebff60]79
[6ddb223]80        return 1;
[b7d3cc34]81}
82
[5ebff60]83int msn_buddy_list_remove(struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *group)
[b7d3cc34]84{
[0da65d5]85        struct msn_data *md = ic->proto_data;
[64768d4]86        char groupid[8];
[193dc74]87        bee_user_t *bu;
88        struct msn_buddy_data *bd;
89        char *adl;
[5ebff60]90
[8b01217]91        *groupid = '\0';
[5ebff60]92
93        if (!(bu = bee_user_by_handle(ic->bee, ic, who)) ||
94            !(bd = bu->data) || !(bd->flags & list)) {
[193dc74]95                return 1;
[5ebff60]96        }
97
[193dc74]98        bd->flags &= ~list;
[5ebff60]99
100        if (list == MSN_BUDDY_FL) {
101                msn_soap_ab_contact_del(ic, bu);
102        } else {
103                msn_soap_memlist_edit(ic, who, FALSE, list);
104        }
105
106        if ((adl = adlrml_entry(who, list))) {
107                int st = msn_ns_write(ic, -1, "RML %d %zd\r\n%s",
108                                      ++md->trId, strlen(adl), adl);
109                g_free(adl);
110
[64768d4]111                return st;
[193dc74]112        }
[5ebff60]113
[6ddb223]114        return 1;
[b7d3cc34]115}
116
[5ebff60]117struct msn_buddy_ask_data {
[0da65d5]118        struct im_connection *ic;
[b7d3cc34]119        char *handle;
120        char *realname;
121};
122
[5ebff60]123static void msn_buddy_ask_yes(void *data)
[b7d3cc34]124{
[9143aeb]125        struct msn_buddy_ask_data *bla = data;
[5ebff60]126
127        msn_buddy_list_add(bla->ic, MSN_BUDDY_AL, bla->handle, bla->realname, NULL);
128
129        imcb_ask_add(bla->ic, bla->handle, NULL);
130
131        g_free(bla->handle);
132        g_free(bla->realname);
133        g_free(bla);
[b7d3cc34]134}
135
[5ebff60]136static void msn_buddy_ask_no(void *data)
[b7d3cc34]137{
[9143aeb]138        struct msn_buddy_ask_data *bla = data;
[5ebff60]139
140        msn_buddy_list_add(bla->ic, MSN_BUDDY_BL, bla->handle, bla->realname, NULL);
141
142        g_free(bla->handle);
143        g_free(bla->realname);
144        g_free(bla);
[b7d3cc34]145}
146
[5ebff60]147void msn_buddy_ask(bee_user_t *bu)
[b7d3cc34]148{
[e5854a8]149        struct msn_buddy_ask_data *bla;
150        struct msn_buddy_data *bd = bu->data;
[b7d3cc34]151        char buf[1024];
[5ebff60]152
153        if (!(bd->flags & MSN_BUDDY_PL)) {
[e5854a8]154                return;
[5ebff60]155        }
156
157        bla = g_new0(struct msn_buddy_ask_data, 1);
[e5854a8]158        bla->ic = bu->ic;
[5ebff60]159        bla->handle = g_strdup(bu->handle);
160        bla->realname = g_strdup(bu->fullname);
161
162        g_snprintf(buf, sizeof(buf),
163                   "The user %s (%s) wants to add you to his/her buddy list.",
164                   bu->handle, bu->fullname);
165        imcb_ask(bu->ic, buf, bla, msn_buddy_ask_yes, msn_buddy_ask_no);
[b7d3cc34]166}
167
168/* *NOT* thread-safe, but that's not a problem for now... */
[5ebff60]169char **msn_linesplit(char *line)
[b7d3cc34]170{
171        static char **ret = NULL;
172        static int size = 3;
173        int i, n = 0;
[5ebff60]174
175        if (ret == NULL) {
176                ret = g_new0(char*, size);
177        }
178
179        for (i = 0; line[i] && line[i] == ' '; i++) {
180                ;
181        }
182        if (line[i]) {
[b7d3cc34]183                ret[n++] = line + i;
[5ebff60]184                for (i++; line[i]; i++) {
185                        if (line[i] == ' ') {
[b7d3cc34]186                                line[i] = 0;
[5ebff60]187                        } else if (line[i] != ' ' && !line[i - 1]) {
[b7d3cc34]188                                ret[n++] = line + i;
[5ebff60]189                        }
190
191                        if (n >= size) {
192                                ret = g_renew(char*, ret, size += 2);
193                        }
[b7d3cc34]194                }
195        }
196        ret[n] = NULL;
[5ebff60]197
198        return(ret);
[b7d3cc34]199}
200
201/* This one handles input from a MSN Messenger server. Both the NS and SB servers usually give
202   commands, but sometimes they give additional data (payload). This function tries to handle
203   this all in a nice way and send all data to the right places. */
204
205/* Return values: -1: Read error, abort connection.
206                   0: Command reported error; Abort *immediately*. (The connection does not exist anymore)
207                   1: OK */
208
[ffa5b70]209int msn_handler(struct msn_data *h)
[b7d3cc34]210{
[ffa5b70]211        struct im_connection *ic = h->ic;
[b7d3cc34]212        int st;
[5ebff60]213
214        h->rxq = g_renew(char, h->rxq, h->rxlen + 1024);
215        st = read(h->fd, h->rxq + h->rxlen, 1024);
[b7d3cc34]216        h->rxlen += st;
[5ebff60]217
218        if (st <= 0) {
[fa8c775]219                fprintf(stderr, "\n\x1b[92m<<< [closed]\x1b[97m ");
[5ebff60]220                return(-1);
221        }
222
223        if (getenv("BITLBEE_DEBUG")) {
[fa8c775]224                fprintf(stderr, "\n\x1b[92m<<< ");
[5ebff60]225                write(2, h->rxq + h->rxlen - st, st);
[fa8c775]226                fprintf(stderr, "\x1b[97m");
[523fb23]227        }
[5ebff60]228
229        while (st) {
[b7d3cc34]230                int i;
[5ebff60]231
232                if (h->msglen == 0) {
233                        for (i = 0; i < h->rxlen; i++) {
234                                if (h->rxq[i] == '\r' || h->rxq[i] == '\n') {
[b7d3cc34]235                                        char *cmd_text, **cmd;
236                                        int count;
[5ebff60]237
238                                        cmd_text = g_strndup(h->rxq, i);
239                                        cmd = msn_linesplit(cmd_text);
240                                        for (count = 0; cmd[count]; count++) {
241                                                ;
242                                        }
[ffa5b70]243                                        st = msn_ns_command(h, cmd, count);
[5ebff60]244                                        g_free(cmd_text);
245
[b7d3cc34]246                                        /* If the connection broke, don't continue. We don't even exist anymore. */
[5ebff60]247                                        if (!st) {
248                                                return(0);
249                                        }
250
251                                        if (h->msglen) {
252                                                h->cmd_text = g_strndup(h->rxq, i);
253                                        }
254
[b7d3cc34]255                                        /* Skip to the next non-emptyline */
[5ebff60]256                                        while (i < h->rxlen && (h->rxq[i] == '\r' || h->rxq[i] == '\n')) {
257                                                i++;
258                                        }
259
[b7d3cc34]260                                        break;
261                                }
262                        }
[5ebff60]263
[b7d3cc34]264                        /* If we reached the end of the buffer, there's still an incomplete command there.
265                           Return and wait for more data. */
[5ebff60]266                        if (i == h->rxlen && h->rxq[i - 1] != '\r' && h->rxq[i - 1] != '\n') {
[b7d3cc34]267                                break;
[5ebff60]268                        }
269                } else {
[b7d3cc34]270                        char *msg, **cmd;
271                        int count;
[5ebff60]272
[b7d3cc34]273                        /* Do we have the complete message already? */
[5ebff60]274                        if (h->msglen > h->rxlen) {
[b7d3cc34]275                                break;
[5ebff60]276                        }
277
278                        msg = g_strndup(h->rxq, h->msglen);
279                        cmd = msn_linesplit(h->cmd_text);
280                        for (count = 0; cmd[count]; count++) {
281                                ;
282                        }
283
[ffa5b70]284                        st = msn_ns_message(h, msg, h->msglen, cmd, count);
[5ebff60]285                        g_free(msg);
286                        g_free(h->cmd_text);
[b7d3cc34]287                        h->cmd_text = NULL;
[5ebff60]288
289                        if (!st) {
290                                return(0);
291                        }
292
[b7d3cc34]293                        i = h->msglen;
294                        h->msglen = 0;
295                }
[5ebff60]296
[b7d3cc34]297                /* More data after this block? */
[5ebff60]298                if (i < h->rxlen) {
[b7d3cc34]299                        char *tmp;
[5ebff60]300
301                        tmp = g_memdup(h->rxq + i, h->rxlen - i);
302                        g_free(h->rxq);
[b7d3cc34]303                        h->rxq = tmp;
304                        h->rxlen -= i;
305                        i = 0;
[5ebff60]306                } else {
307                        /* If not, reset the rx queue and get lost. */
308                        g_free(h->rxq);
309                        h->rxq = g_new0(char, 1);
[b7d3cc34]310                        h->rxlen = 0;
[5ebff60]311                        return(1);
[b7d3cc34]312                }
313        }
[5ebff60]314
315        return(1);
[b7d3cc34]316}
[54794b8]317
[21029d0]318/* Copied and heavily modified from http://tmsnc.sourceforge.net/chl.c */
[5ebff60]319char *msn_p11_challenge(char *challenge)
[21029d0]320{
321        char *output, buf[256];
322        md5_state_t md5c;
323        unsigned char md5Hash[16], *newHash;
324        unsigned int *md5Parts, *chlStringParts, newHashParts[5];
325        long long nHigh = 0, nLow = 0;
326        int i, n;
327
328        /* Create the MD5 hash */
329        md5_init(&md5c);
[5ebff60]330        md5_append(&md5c, (unsigned char *) challenge, strlen(challenge));
331        md5_append(&md5c, (unsigned char *) MSNP11_PROD_KEY, strlen(MSNP11_PROD_KEY));
[21029d0]332        md5_finish(&md5c, md5Hash);
333
334        /* Split it into four integers */
[5ebff60]335        md5Parts = (unsigned int *) md5Hash;
336        for (i = 0; i < 4; i++) {
[523fb23]337                md5Parts[i] = GUINT32_TO_LE(md5Parts[i]);
[5ebff60]338
[21029d0]339                /* & each integer with 0x7FFFFFFF */
340                /* and save one unmodified array for later */
341                newHashParts[i] = md5Parts[i];
342                md5Parts[i] &= 0x7FFFFFFF;
343        }
[5ebff60]344
[21029d0]345        /* make a new string and pad with '0' */
[5ebff60]346        n = g_snprintf(buf, sizeof(buf) - 5, "%s%s00000000", challenge, MSNP11_PROD_ID);
[21029d0]347        /* truncate at an 8-byte boundary */
[5ebff60]348        buf[n &= ~7] = '\0';
349
[21029d0]350        /* split into integers */
[5ebff60]351        chlStringParts = (unsigned int *) buf;
352
[21029d0]353        /* this is magic */
[5ebff60]354        for (i = 0; i < (n / 4) - 1; i += 2) {
[21029d0]355                long long temp;
356
[523fb23]357                chlStringParts[i]   = GUINT32_TO_LE(chlStringParts[i]);
[5ebff60]358                chlStringParts[i + 1] = GUINT32_TO_LE(chlStringParts[i + 1]);
[21029d0]359
[5ebff60]360                temp  =
361                        (md5Parts[0] *
362                         (((0x0E79A9C1 *
363                            (long long) chlStringParts[i]) % 0x7FFFFFFF) + nHigh) + md5Parts[1]) % 0x7FFFFFFF;
364                nHigh =
365                        (md5Parts[2] *
366                         (((long long) chlStringParts[i + 1] + temp) % 0x7FFFFFFF) + md5Parts[3]) % 0x7FFFFFFF;
[21029d0]367                nLow  = nLow + nHigh + temp;
368        }
[5ebff60]369        nHigh = (nHigh + md5Parts[1]) % 0x7FFFFFFF;
370        nLow = (nLow + md5Parts[3]) % 0x7FFFFFFF;
371
[21029d0]372        newHashParts[0] ^= nHigh;
373        newHashParts[1] ^= nLow;
374        newHashParts[2] ^= nHigh;
375        newHashParts[3] ^= nLow;
[5ebff60]376
[21029d0]377        /* swap more bytes if big endian */
[5ebff60]378        for (i = 0; i < 4; i++) {
379                newHashParts[i] = GUINT32_TO_LE(newHashParts[i]);
380        }
381
[21029d0]382        /* make a string of the parts */
[5ebff60]383        newHash = (unsigned char *) newHashParts;
384
[21029d0]385        /* convert to hexadecimal */
386        output = g_new(char, 33);
[5ebff60]387        for (i = 0; i < 16; i++) {
[21029d0]388                sprintf(output + i * 2, "%02x", newHash[i]);
[5ebff60]389        }
390
[21029d0]391        return output;
392}
[ca7de3a]393
[5ebff60]394gint msn_domaintree_cmp(gconstpointer a_, gconstpointer b_)
[ca7de3a]395{
396        const char *a = a_, *b = b_;
397        gint ret;
[5ebff60]398
399        if (!(a = strchr(a, '@')) || !(b = strchr(b, '@')) ||
400            (ret = strcmp(a, b)) == 0) {
401                ret = strcmp(a_, b_);
402        }
403
[ca7de3a]404        return ret;
405}
[ff27648]406
[5ebff60]407struct msn_group *msn_group_by_name(struct im_connection *ic, const char *name)
[ff27648]408{
409        struct msn_data *md = ic->proto_data;
410        GSList *l;
[5ebff60]411
412        for (l = md->groups; l; l = l->next) {
[ff27648]413                struct msn_group *mg = l->data;
[5ebff60]414
415                if (g_strcasecmp(mg->name, name) == 0) {
[ff27648]416                        return mg;
[5ebff60]417                }
[ff27648]418        }
[5ebff60]419
[ff27648]420        return NULL;
421}
422
[5ebff60]423struct msn_group *msn_group_by_id(struct im_connection *ic, const char *id)
[ff27648]424{
425        struct msn_data *md = ic->proto_data;
426        GSList *l;
[5ebff60]427
428        for (l = md->groups; l; l = l->next) {
[ff27648]429                struct msn_group *mg = l->data;
[5ebff60]430
431                if (g_strcasecmp(mg->id, id) == 0) {
[ff27648]432                        return mg;
[5ebff60]433                }
[ff27648]434        }
[5ebff60]435
[ff27648]436        return NULL;
437}
[e0e1546]438
[5ebff60]439int msn_ns_set_display_name(struct im_connection *ic, const char *value)
[e0e1546]440{
[6e74911]441        // TODO, implement this through msn_set_away's method
442        return 1;
[e0e1546]443}
[79bb7e4]444
[5ebff60]445const char *msn_normalize_handle(const char *handle)
[79bb7e4]446{
[5ebff60]447        if (strncmp(handle, "1:", 2) == 0) {
[79bb7e4]448                return handle + 2;
[5ebff60]449        } else {
[79bb7e4]450                return handle;
[5ebff60]451        }
[79bb7e4]452}
Note: See TracBrowser for help on using the repository browser.