Changes in / [356e2dd:291c49b]

Files:

• lib/misc.c (modified) (1 diff)
• protocols/msn/Makefile (modified) (1 diff)
• protocols/msn/gw.c (deleted)
• protocols/msn/msn.c (modified) (10 diffs)
• protocols/msn/msn.h (modified) (12 diffs)
• protocols/msn/msn_util.c (modified) (9 diffs)
• protocols/msn/ns.c (modified) (23 diffs)
• protocols/msn/sb.c (added)
• protocols/msn/soap.c (modified) (2 diffs)
• protocols/msn/tables.c (modified) (2 diffs)

lib/misc.c

@@ -719 +719 @@
                         }
 
+                        /* Make sure we're still inside the string */
+                        if (i >= len) {
+                                return(NULL);
+                        }
+
                         /* Copy the found data */
                         return(g_strndup(ret, text + i - ret));

protocols/msn/Makefile

@@ -13 +13 @@
 
 # [SH] Program variables
-objects = msn.o msn_util.o ns.o soap.o tables.o gw.o
+objects = msn.o msn_util.o ns.o sb.o soap.o tables.o
 
 LFLAGS += -r

protocols/msn/msn.c

@@ -30 +30 @@
 int msn_chat_id;
 GSList *msn_connections;
+GSList *msn_switchboards;
 
 static char *set_eval_display_name(set_t *set, char *value);
@@ -47 +48 @@
 
         set_add(&acc->set, "mail_notifications", "false", set_eval_bool, acc);
+        set_add(&acc->set, "switchboard_keepalives", "false", set_eval_bool, acc);
 
         acc->flags |= ACC_FLAG_AWAY_MESSAGE | ACC_FLAG_STATUS_MESSAGE |
@@ -62 +64 @@
 
         if (!server) {
-                server = "geo.gateway.messenger.live.com";
+                imcb_error(ic, "The msn protocol is disabled in this version because most servers disabled MSNP18 over port 1863.");
+                imcb_error(ic, "If you find a working server, you can change the 'server' setting of this account. Good luck!");
+                imcb_error(ic, "See also: http://ismsndeadyet.com/"); // shameless plug
+                imc_logout(ic, FALSE);
+                return;
         }
 
@@ -74 +80 @@
         md->away_state = msn_away_state_list;
         md->domaintree = g_tree_new(msn_domaintree_cmp);
-        md->fd = -1;
-        md->is_http = TRUE;
+        md->ns->fd = -1;
 
         msn_connections = g_slist_prepend(msn_connections, ic);
 
         imcb_log(ic, "Connecting");
-        msn_ns_connect(ic, server,
+        msn_ns_connect(ic, md->ns, server,
                        set_getint(&ic->acc->set, "port"));
 }
@@ -91 +96 @@
 
         if (md) {
-                msn_ns_close(md);
-
+                msn_ns_close(md->ns);
+
+                while (md->switchboards) {
+                        msn_sb_destroy(md->switchboards->data);
+                }
+
+                msn_msgq_purge(ic, &md->msgq);
                 msn_soapq_flush(ic, FALSE);
 
@@ -144 +154 @@
 {
         struct bee_user *bu = bee_user_by_handle(ic->bee, ic, who);
+        struct msn_buddy_data *bd = bu ? bu->data : NULL;
+        struct msn_switchboard *sb;
 
 #ifdef DEBUG
         if (strcmp(who, "raw") == 0) {
                 msn_ns_write(ic, -1, "%s\r\n", message);
-                return 0;
-        }
+        } else
 #endif
-
-        msn_ns_sendmessage(ic, bu, message);
+        if (bd && bd->flags & MSN_BUDDY_FED) {
+                msn_ns_sendmessage(ic, bu, message);
+        } else if ((sb = msn_sb_by_handle(ic, who))) {
+                return(msn_sb_sendmessage(sb, message));
+        } else {
+                struct msn_message *m;
+
+                /* Create a message. We have to arrange a usable switchboard, and send the message later. */
+                m = g_new0(struct msn_message, 1);
+                m->who = g_strdup(who);
+                m->text = g_strdup(message);
+
+                return msn_sb_write_msg(ic, m);
+        }
+
         return(0);
 }
@@ -174 +198 @@
 static void msn_set_away(struct im_connection *ic, char *state, char *message)
 {
+        char *uux;
         struct msn_data *md = ic->proto_data;
-        char *nick, *psm, *idle, *statecode, *body, *buf;
 
         if (state == NULL) {
@@ -183 +207 @@
         }
 
-        statecode = (char *) md->away_state->code;
-        nick = set_getstr(&ic->acc->set, "display_name");
-        psm = message ? message : "";
-        idle = (strcmp(statecode, "IDL") == 0) ? "false" : "true";
-
-        body = g_markup_printf_escaped(MSN_PUT_USER_BODY,
-                nick, psm, psm, md->uuid, statecode, md->uuid, idle, statecode,
-                MSN_CAP1, MSN_CAP2, MSN_CAP1, MSN_CAP2
-        );
-
-        buf = g_strdup_printf(MSN_PUT_HEADERS, ic->acc->user, ic->acc->user, md->uuid,
-                "/user", "application/user+xml",
-                strlen(body), body);
-        msn_ns_write(ic, -1, "PUT %d %zd\r\n%s", ++md->trId, strlen(buf), buf);
-
-        g_free(buf);
-        g_free(body);
+        if (!msn_ns_write(ic, -1, "CHG %d %s %d:%02d\r\n", ++md->trId, md->away_state->code, MSN_CAP1, MSN_CAP2)) {
+                return;
+        }
+
+        uux = g_markup_printf_escaped("<EndpointData><Capabilities>%d:%02d"
+                                      "</Capabilities></EndpointData>",
+                                      MSN_CAP1, MSN_CAP2);
+        msn_ns_write(ic, -1, "UUX %d %zd\r\n%s", ++md->trId, strlen(uux), uux);
+        g_free(uux);
+
+        uux = g_markup_printf_escaped("<PrivateEndpointData><EpName>%s</EpName>"
+                                      "<Idle>%s</Idle><ClientType>%d</ClientType>"
+                                      "<State>%s</State></PrivateEndpointData>",
+                                      md->uuid,
+                                      strcmp(md->away_state->code, "IDL") ? "false" : "true",
+                                      1,  /* ? */
+                                      md->away_state->code);
+        msn_ns_write(ic, -1, "UUX %d %zd\r\n%s", ++md->trId, strlen(uux), uux);
+        g_free(uux);
+
+        uux = g_markup_printf_escaped("<Data><DDP></DDP><PSM>%s</PSM>"
+                                      "<CurrentMedia></CurrentMedia>"
+                                      "<MachineGuid>%s</MachineGuid></Data>",
+                                      message ? message : "", md->uuid);
+        msn_ns_write(ic, -1, "UUX %d %zd\r\n%s", ++md->trId, strlen(uux), uux);
+        g_free(uux);
 }
 
@@ -225 +258 @@
 static void msn_chat_msg(struct groupchat *c, char *message, int flags)
 {
-        /* TODO: groupchats*/
+        struct msn_switchboard *sb = msn_sb_by_chat(c);
+
+        if (sb) {
+                msn_sb_sendmessage(sb, message);
+        }
+        /* FIXME: Error handling (although this can't happen unless something's
+           already severely broken) disappeared here! */
 }
 
 static void msn_chat_invite(struct groupchat *c, char *who, char *message)
 {
-        /* TODO: groupchats*/
+        struct msn_switchboard *sb = msn_sb_by_chat(c);
+
+        if (sb) {
+                msn_sb_write(sb, "CAL %d %s\r\n", ++sb->trId, who);
+        }
 }
 
 static void msn_chat_leave(struct groupchat *c)
 {
-        /* TODO: groupchats*/
+        struct msn_switchboard *sb = msn_sb_by_chat(c);
+
+        if (sb) {
+                msn_sb_write(sb, "OUT\r\n");
+        }
 }
 
 static struct groupchat *msn_chat_with(struct im_connection *ic, char *who)
 {
-        /* TODO: groupchats*/
+        struct msn_switchboard *sb;
         struct groupchat *c = imcb_chat_new(ic, who);
-        return c;
+
+        if ((sb = msn_sb_by_handle(ic, who))) {
+                debug("Converting existing switchboard to %s to a groupchat", who);
+                return msn_sb_to_chat(sb);
+        } else {
+                struct msn_message *m;
+
+                /* Create a magic message. This is quite hackish, but who cares? :-P */
+                m = g_new0(struct msn_message, 1);
+                m->who = g_strdup(who);
+                m->text = g_strdup(GROUPCHAT_SWITCHBOARD_MESSAGE);
+
+                msn_sb_write_msg(ic, m);
+
+                return c;
+        }
 }
 
@@ -262 +324 @@
 static void msn_add_deny(struct im_connection *ic, char *who)
 {
+        struct msn_switchboard *sb;
+
         msn_buddy_list_add(ic, MSN_BUDDY_BL, who, who, NULL);
+
+        /* If there's still a conversation with this person, close it. */
+        if ((sb = msn_sb_by_handle(ic, who))) {
+                msn_sb_destroy(sb);
+        }
 }
 

protocols/msn/msn.h

@@ -32 +32 @@
 #define NUDGE_MESSAGE "\r\r\rSHAKE THAT THING\r\r\r"
 #define GROUPCHAT_SWITCHBOARD_MESSAGE "\r\r\rME WANT TALK TO MANY PEOPLE\r\r\r"
+#define SB_KEEPALIVE_MESSAGE "\r\r\rDONT HANG UP ON ME!\r\r\r"
 
 #ifdef DEBUG_MSN
@@ -59 +60 @@
 #define MSNP11_PROD_KEY "C1BX{V4W}Q3*10SM"
 #define MSNP11_PROD_ID  "PROD0120PW!CCV9@"
-#define MSNP_VER        "MSNP21"
+#define MSNP_VER        "MSNP18"
 #define MSNP_BUILD      "14.0.8117.416"
 
@@ -67 +68 @@
 #define MSN_CAP2        0x0000
 
-#define MSN_BASE_HEADERS \
-        "Routing: 1.0\r\n" \
-        "To: 1:%s\r\n" \
-        "From: 1:%s;epid={%s}\r\n" \
-        "\r\n" \
-        "Reliability: 1.0\r\n" \
+#define MSN_MESSAGE_HEADERS "MIME-Version: 1.0\r\n" \
+        "Content-Type: text/plain; charset=UTF-8\r\n" \
+        "User-Agent: BitlBee " BITLBEE_VERSION "\r\n" \
+        "X-MMS-IM-Format: FN=MS%20Shell%20Dlg; EF=; CO=0; CS=0; PF=0\r\n" \
         "\r\n"
-
-#define MSN_MESSAGE_HEADERS MSN_BASE_HEADERS \
-        "Messaging: 2.0\r\n" \
-        "Message-Type: Text\r\n" \
-        "Content-Length: %zd\r\n" \
-        "Content-Type: text/plain; charset=UTF-8\r\n" \
-        "X-MMS-IM-Format: FN=Segoe%%20UI; EF=; CO=0; CS=0; PF=0\r\n" \
-        "\r\n" \
-        "%s"
-
-#define MSN_PUT_HEADERS MSN_BASE_HEADERS \
-        "Publication: 1.0\r\n" \
-        "Uri: %s\r\n" \
-        "Content-Type: %s\r\n" \
-        "Content-Length: %zd\r\n" \
-        "\r\n" \
-        "%s"
-
-#define MSN_PUT_USER_BODY \
-        "<user>" \
-        "<s n=\"PE\"><UserTileLocation></UserTileLocation><FriendlyName>%s</FriendlyName><PSM>%s</PSM><DDP></DDP>" \
-        "<Scene></Scene><ASN></ASN><ColorScheme>-3</ColorScheme><BDG></BDG><RUM>%s</RUM><RUL></RUL><RLT>0</RLT>" \
-        "<RID></RID><SUL></SUL><MachineGuid>%s</MachineGuid></s>" \
-        "<s n=\"IM\"><Status>%s</Status><CurrentMedia></CurrentMedia></s>" \
-        "<sep n=\"PD\"><ClientType>1</ClientType><EpName>%s</EpName><Idle>%s</Idle><State>%s</State></sep>" \
-        "<sep n=\"PE\"><VER>BitlBee:" BITLBEE_VERSION "</VER><TYP>1</TYP><Capabilities>%d:%d</Capabilities></sep>" \
-        "<sep n=\"IM\"><Capabilities>%d:%d</Capabilities></sep>" \
-        "</user>"
 
 #define MSN_TYPING_HEADERS "MIME-Version: 1.0\r\n" \
@@ -113 +84 @@
         "ID: 1\r\n" \
         "\r\n"
+
+#define MSN_SB_KEEPALIVE_HEADERS "MIME-Version: 1.0\r\n" \
+        "Content-Type: text/x-ping\r\n" \
+        "\r\n\r\n"
 
 #define PROFILE_URL "http://members.msn.com/"
@@ -124 +99 @@
 } msn_flags_t;
 
-struct msn_gw {
-        char *last_host;
-        int port;
-        gboolean ssl;
-
-        char *session_id;
-
-        GByteArray *in;
-        GByteArray *out;
-
-        int poll_timeout;
-
-        b_event_handler callback;
-
-        struct im_connection *ic;
-        struct msn_data *md;
-
-        gboolean open;
-        gboolean waiting;
-        gboolean polling;
-};
-
-struct msn_data {
+struct msn_handler_data {
         int fd, inpa;
         int rxlen;
@@ -154 +107 @@
         char *cmd_text;
 
+        /* Either ic or sb */
+        gpointer data;
+
+        int (*exec_command) (struct msn_handler_data *handler, char **cmd, int count);
+        int (*exec_message) (struct msn_handler_data *handler, char *msg, int msglen, char **cmd, int count);
+};
+
+struct msn_data {
         struct im_connection *ic;
 
+        struct msn_handler_data ns[1];
         msn_flags_t flags;
 
@@ -164 +126 @@
 
         GSList *msgq, *grpq, *soapq;
+        GSList *switchboards;
+        int sb_failures;
+        time_t first_sb_failure;
 
         const struct msn_away_state *away_state;
@@ -174 +139 @@
         GTree *domaintree;
         int adl_todo;
-
-        gboolean is_http;
-        struct msn_gw *gw;
+};
+
+struct msn_switchboard {
+        struct im_connection *ic;
+
+        /* The following two are also in the handler. TODO: Clean up. */
+        int fd;
+        gint inp;
+        struct msn_handler_data *handler;
+        gint keepalive;
+
+        int trId;
+        int ready;
+
+        int session;
+        char *key;
+
+        GSList *msgq;
+        char *who;
+        struct groupchat *chat;
 };
 
@@ -223 +205 @@
 #define STATUS_FATAL            1
 #define STATUS_SB_FATAL         2
+#define STATUS_SB_IM_SPARE      4       /* Make one-to-one conversation switchboard available again, invite failed. */
+#define STATUS_SB_CHAT_SPARE    8       /* Same, but also for groupchats (not used yet). */
 
 extern int msn_chat_id;
@@ -234 +218 @@
    before doing *anything* else. */
 extern GSList *msn_connections;
+extern GSList *msn_switchboards;
 
 /* ns.c */
 int msn_ns_write(struct im_connection *ic, int fd, const char *fmt, ...) G_GNUC_PRINTF(3, 4);
-gboolean msn_ns_connect(struct im_connection *ic, const char *host, int port);
-void msn_ns_close(struct msn_data *handler);
+gboolean msn_ns_connect(struct im_connection *ic, struct msn_handler_data *handler, const char *host, int port);
+void msn_ns_close(struct msn_handler_data *handler);
 void msn_auth_got_passport_token(struct im_connection *ic, const char *token, const char *error);
 void msn_auth_got_contact_list(struct im_connection *ic);
 int msn_ns_finish_login(struct im_connection *ic);
 int msn_ns_sendmessage(struct im_connection *ic, struct bee_user *bu, const char *text);
-int msn_ns_command(struct msn_data *md, char **cmd, int num_parts);
-int msn_ns_message(struct msn_data *md, char *msg, int msglen, char **cmd, int num_parts);
+void msn_ns_oim_send_queue(struct im_connection *ic, GSList **msgq);
 
 /* msn_util.c */
@@ -251 +235 @@
 int msn_buddy_list_remove(struct im_connection *ic, msn_buddy_flags_t list, const char *who, const char *group);
 void msn_buddy_ask(bee_user_t *bu);
-void msn_queue_feed(struct msn_data *h, char *bytes, int st);
-int msn_handler(struct msn_data *h);
+char **msn_linesplit(char *line);
+int msn_handler(struct msn_handler_data *h);
+void msn_msgq_purge(struct im_connection *ic, GSList **list);
 char *msn_p11_challenge(char *challenge);
 gint msn_domaintree_cmp(gconstpointer a_, gconstpointer b_);
@@ -266 +251 @@
 const struct msn_status_code *msn_status_by_number(int number);
 
-/* gw.c */
-struct msn_gw *msn_gw_new(struct im_connection *ic);
-void msn_gw_free(struct msn_gw *gw);
-void msn_gw_open(struct msn_gw *gw);
-ssize_t msn_gw_read(struct msn_gw *gw, char **buf);
-void msn_gw_write(struct msn_gw *gw, char *buf, size_t len);
+/* sb.c */
+int msn_sb_write(struct msn_switchboard *sb, const char *fmt, ...) G_GNUC_PRINTF(2, 3);;
+struct msn_switchboard *msn_sb_create(struct im_connection *ic, char *host, int port, char *key, int session);
+struct msn_switchboard *msn_sb_by_handle(struct im_connection *ic, const char *handle);
+struct msn_switchboard *msn_sb_by_chat(struct groupchat *c);
+struct msn_switchboard *msn_sb_spare(struct im_connection *ic);
+int msn_sb_sendmessage(struct msn_switchboard *sb, char *text);
+struct groupchat *msn_sb_to_chat(struct msn_switchboard *sb);
+void msn_sb_destroy(struct msn_switchboard *sb);
+gboolean msn_sb_connected(gpointer data, gint source, b_input_condition cond);
+int msn_sb_write_msg(struct im_connection *ic, struct msn_message *m);
+void msn_sb_start_keepalives(struct msn_switchboard *sb, gboolean initial);
+void msn_sb_stop_keepalives(struct msn_switchboard *sb);
 
 #endif //_MSN_H

protocols/msn/msn_util.c

@@ -55 +55 @@
 
         *groupid = '\0';
+#if 0
+        if (group) {
+                int i;
+                for (i = 0; i < md->groupcount; i++) {
+                        if (g_strcasecmp(md->grouplist[i], group) == 0) {
+                                g_snprintf(groupid, sizeof(groupid), " %d", i);
+                                break;
+                        }
+                }
+
+                if (*groupid == '\0') {
+                        /* Have to create this group, it doesn't exist yet. */
+                        struct msn_groupadd *ga;
+                        GSList *l;
+
+                        for (l = md->grpq; l; l = l->next) {
+                                ga = l->data;
+                                if (g_strcasecmp(ga->group, group) == 0) {
+                                        break;
+                                }
+                        }
+
+                        ga = g_new0(struct msn_groupadd, 1);
+                        ga->who = g_strdup(who);
+                        ga->group = g_strdup(group);
+                        md->grpq = g_slist_prepend(md->grpq, ga);
+
+                        if (l == NULL) {
+                                char groupname[strlen(group) + 1];
+                                strcpy(groupname, group);
+                                http_encode(groupname);
+                                g_snprintf(buf, sizeof(buf), "ADG %d %s %d\r\n", ++md->trId, groupname, 0);
+                                return msn_write(ic, buf, strlen(buf));
+                        } else {
+                                /* This can happen if the user's doing lots of adds to a
+                                   new group at once; we're still waiting for the server
+                                   to confirm group creation. */
+                                return 1;
+                        }
+                }
+        }
+#endif
 
         if (!((bu = bee_user_by_handle(ic->bee, ic, who)) ||
@@ -90 +132 @@
 
         *groupid = '\0';
+#if 0
+        if (group) {
+                int i;
+                for (i = 0; i < md->groupcount; i++) {
+                        if (g_strcasecmp(md->grouplist[i], group) == 0) {
+                                g_snprintf(groupid, sizeof(groupid), " %d", i);
+                                break;
+                        }
+                }
+        }
+#endif
 
         if (!(bu = bee_user_by_handle(ic->bee, ic, who)) ||
@@ -172 +225 @@
 }
 
-void msn_queue_feed(struct msn_data *h, char *bytes, int st)
-{
-        h->rxq = g_renew(char, h->rxq, h->rxlen + st);
-        memcpy(h->rxq + h->rxlen, bytes, st);
-        h->rxlen += st;
-
-        if (getenv("BITLBEE_DEBUG")) {
-                fprintf(stderr, "\n\x1b[92m<<< ");
-                write(2, bytes , st);
-                fprintf(stderr, "\x1b[97m");
-        }
+/* *NOT* thread-safe, but that's not a problem for now... */
+char **msn_linesplit(char *line)
+{
+        static char **ret = NULL;
+        static int size = 3;
+        int i, n = 0;
+
+        if (ret == NULL) {
+                ret = g_new0(char*, size);
+        }
+
+        for (i = 0; line[i] && line[i] == ' '; i++) {
+                ;
+        }
+        if (line[i]) {
+                ret[n++] = line + i;
+                for (i++; line[i]; i++) {
+                        if (line[i] == ' ') {
+                                line[i] = 0;
+                        } else if (line[i] != ' ' && !line[i - 1]) {
+                                ret[n++] = line + i;
+                        }
+
+                        if (n >= size) {
+                                ret = g_renew(char*, ret, size += 2);
+                        }
+                }
+        }
+        ret[n] = NULL;
+
+        return(ret);
 }
 
@@ -193 +266 @@
                    1: OK */
 
-int msn_handler(struct msn_data *h)
-{
-        int st = 1;
+int msn_handler(struct msn_handler_data *h)
+{
+        int st;
+
+        h->rxq = g_renew(char, h->rxq, h->rxlen + 1024);
+        st = read(h->fd, h->rxq + h->rxlen, 1024);
+        h->rxlen += st;
+
+        if (st <= 0) {
+                return(-1);
+        }
+
+        if (getenv("BITLBEE_DEBUG")) {
+                write(2, "->C:", 4);
+                write(2, h->rxq + h->rxlen - st, st);
+        }
 
         while (st) {
@@ -207 +293 @@
 
                                         cmd_text = g_strndup(h->rxq, i);
-                                        cmd = g_strsplit_set(cmd_text, " ", -1);
-                                        count = g_strv_length(cmd);
-
-                                        st = msn_ns_command(h, cmd, count);
-
-                                        g_strfreev(cmd);
+                                        cmd = msn_linesplit(cmd_text);
+                                        for (count = 0; cmd[count]; count++) {
+                                                ;
+                                        }
+                                        st = h->exec_command(h, cmd, count);
                                         g_free(cmd_text);
 
@@ -235 +320 @@
                         /* If we reached the end of the buffer, there's still an incomplete command there.
                            Return and wait for more data. */
-                        if (i && i == h->rxlen && h->rxq[i - 1] != '\r' && h->rxq[i - 1] != '\n') {
+                        if (i == h->rxlen && h->rxq[i - 1] != '\r' && h->rxq[i - 1] != '\n') {
                                 break;
                         }
@@ -248 +333 @@
 
                         msg = g_strndup(h->rxq, h->msglen);
-
-                        cmd = g_strsplit_set(h->cmd_text, " ", -1);
-                        count = g_strv_length(cmd);
-
-                        st = msn_ns_message(h, msg, h->msglen, cmd, count);
-
-                        g_strfreev(cmd);
+                        cmd = msn_linesplit(h->cmd_text);
+                        for (count = 0; cmd[count]; count++) {
+                                ;
+                        }
+
+                        st = h->exec_message(h, msg, h->msglen, cmd, count);
                         g_free(msg);
                         g_free(h->cmd_text);
@@ -288 +372 @@
 }
 
+void msn_msgq_purge(struct im_connection *ic, GSList **list)
+{
+        struct msn_message *m;
+        GString *ret;
+        GSList *l;
+        int n = 0;
+
+        l = *list;
+        if (l == NULL) {
+                return;
+        }
+
+        m = l->data;
+        ret = g_string_sized_new(1024);
+        g_string_printf(ret, "Warning: Cleaning up MSN (switchboard) connection with unsent "
+                        "messages to %s:", m->who ? m->who : "unknown recipient");
+
+        while (l) {
+                m = l->data;
+
+                if (strncmp(m->text, "\r\r\r", 3) != 0) {
+                        g_string_append_printf(ret, "\n%s", m->text);
+                        n++;
+                }
+
+                g_free(m->who);
+                g_free(m->text);
+                g_free(m);
+
+                l = l->next;
+        }
+        g_slist_free(*list);
+        *list = NULL;
+
+        if (n > 0) {
+                imcb_log(ic, "%s", ret->str);
+        }
+        g_string_free(ret, TRUE);
+}
+
 /* Copied and heavily modified from http://tmsnc.sourceforge.net/chl.c */
 char *msn_p11_challenge(char *challenge)
@@ -411 +535 @@
 int msn_ns_set_display_name(struct im_connection *ic, const char *value)
 {
-        // TODO, implement this through msn_set_away's method
-        return 1;
+        struct msn_data *md = ic->proto_data;
+        char fn[strlen(value) * 3 + 1];
+
+        strcpy(fn, value);
+        http_encode(fn);
+
+        /* Note: We don't actually know if the server accepted the new name,
+           and won't give proper feedback yet if it doesn't. */
+        return msn_ns_write(ic, -1, "PRP %d MFN %s\r\n", ++md->trId, fn);
 }
 

protocols/msn/ns.c

@@ -35 +35 @@
 static gboolean msn_ns_connected(gpointer data, gint source, b_input_condition cond);
 static gboolean msn_ns_callback(gpointer data, gint source, b_input_condition cond);
+static int msn_ns_command(struct msn_handler_data *handler, char **cmd, int num_parts);
+static int msn_ns_message(struct msn_handler_data *handler, char *msg, int msglen, char **cmd, int num_parts);
 
 static void msn_ns_send_adl_start(struct im_connection *ic);
 static void msn_ns_send_adl(struct im_connection *ic);
-static void msn_ns_structured_message(struct msn_data *md, char *msg, int msglen, char **cmd);
-static void msn_ns_sdg(struct msn_data *md, char *who, char **parts, char *action);
-static void msn_ns_nfy(struct msn_data *md, char *who, char **parts, char *action, gboolean is_put);
 
 int msn_ns_write(struct im_connection *ic, int fd, const char *fmt, ...)
@@ -55 +54 @@
 
         if (fd < 0) {
-                fd = md->fd;
+                fd = md->ns->fd;
         }
 
         if (getenv("BITLBEE_DEBUG")) {
-                fprintf(stderr, "\x1b[91m>>>[NS%d] %s\n\x1b[97m", fd, out);
+                fprintf(stderr, "->NS%d:%s\n", fd, out);
         }
 
         len = strlen(out);
-
-        if (md->is_http) {
-                st = len;
-                msn_gw_write(md->gw, out, len);
-        } else {
-                st = write(fd, out, len);
-        }
-
+        st = write(fd, out, len);
         g_free(out);
         if (st != len) {
@@ -81 +73 @@
 }
 
-gboolean msn_ns_connect(struct im_connection *ic, const char *host, int port)
-{
-        struct msn_data *md = ic->proto_data;
-
-        if (md->fd >= 0) {
-                closesocket(md->fd);
-        }
-
-        if (md->is_http) {
-                md->gw = msn_gw_new(ic);
-                md->gw->callback = msn_ns_callback;
-                msn_ns_connected(md, -1, B_EV_IO_READ);
-        } else {
-                md->fd = proxy_connect(host, port, msn_ns_connected, md);
-                if (md->fd < 0) {
-                        imcb_error(ic, "Could not connect to server");
-                        imc_logout(ic, TRUE);
-                        return FALSE;
-                }
-        }
-
-        return TRUE;
-}
-
-static gboolean msn_ns_connected(gpointer data, gint source, b_input_condition cond)
-{
-        struct msn_data *md = data;
-        struct im_connection *ic = md->ic;
-
-        if (source == -1 && !md->is_http) {
+gboolean msn_ns_connect(struct im_connection *ic, struct msn_handler_data *handler, const char *host, int port)
+{
+        if (handler->fd >= 0) {
+                closesocket(handler->fd);
+        }
+
+        handler->exec_command = msn_ns_command;
+        handler->exec_message = msn_ns_message;
+        handler->data = ic;
+        handler->fd = proxy_connect(host, port, msn_ns_connected, handler);
+        if (handler->fd < 0) {
                 imcb_error(ic, "Could not connect to server");
                 imc_logout(ic, TRUE);
@@ -116 +89 @@
         }
 
-        g_free(md->rxq);
-        md->rxlen = 0;
-        md->rxq = g_new0(char, 1);
+        return TRUE;
+}
+
+static gboolean msn_ns_connected(gpointer data, gint source, b_input_condition cond)
+{
+        struct msn_handler_data *handler = data;
+        struct im_connection *ic = handler->data;
+        struct msn_data *md;
+
+        if (!g_slist_find(msn_connections, ic)) {
+                return FALSE;
+        }
+
+        md = ic->proto_data;
+
+        if (source == -1) {
+                imcb_error(ic, "Could not connect to server");
+                imc_logout(ic, TRUE);
+                return FALSE;
+        }
+
+        g_free(handler->rxq);
+        handler->rxlen = 0;
+        handler->rxq = g_new0(char, 1);
 
         if (md->uuid == NULL) {
@@ -136 +130 @@
 
         if (msn_ns_write(ic, source, "VER %d %s CVR0\r\n", ++md->trId, MSNP_VER)) {
-                if (!md->is_http) {
-                        md->inpa = b_input_add(md->fd, B_EV_IO_READ, msn_ns_callback, md);
-                }
+                handler->inpa = b_input_add(handler->fd, B_EV_IO_READ, msn_ns_callback, handler);
                 imcb_log(ic, "Connected to server, waiting for reply");
         }
@@ -145 +137 @@
 }
 
-void msn_ns_close(struct msn_data *md)
-{
-        if (md->gw) {
-                msn_gw_free(md->gw);
-        }
-        if (md->fd >= 0) {
-                closesocket(md->fd);
-                b_event_remove(md->inpa);
-        }
-
-        md->fd = md->inpa = -1;
-        g_free(md->rxq);
-        g_free(md->cmd_text);
-
-        md->rxlen = 0;
-        md->rxq = NULL;
-        md->cmd_text = NULL;
+void msn_ns_close(struct msn_handler_data *handler)
+{
+        if (handler->fd >= 0) {
+                closesocket(handler->fd);
+                b_event_remove(handler->inpa);
+        }
+
+        handler->fd = handler->inpa = -1;
+        g_free(handler->rxq);
+        g_free(handler->cmd_text);
+
+        handler->rxlen = 0;
+        handler->rxq = NULL;
+        handler->cmd_text = NULL;
 }
 
 static gboolean msn_ns_callback(gpointer data, gint source, b_input_condition cond)
 {
-        struct msn_data *md = data;
-        struct im_connection *ic = md->ic;
-        char *bytes;
-        int st;
-
-        if (md->is_http) {
-                st = msn_gw_read(md->gw, &bytes);
-        } else {
-                bytes = g_malloc(1024);
-                st = read(md->fd, bytes, 1024);
-        }
-
-        if (st <= 0) {
+        struct msn_handler_data *handler = data;
+        struct im_connection *ic = handler->data;
+
+        if (msn_handler(handler) == -1) {  /* Don't do this on ret == 0, it's already done then. */
                 imcb_error(ic, "Error while reading from server");
                 imc_logout(ic, TRUE);
+
                 return FALSE;
-        }
-
-        msn_queue_feed(md, bytes, st);
-
-        g_free(bytes);
-
-        /* Ignore ret == 0, it's already disconnected then. */
-        msn_handler(md);
-
-        return TRUE;
-        
-}
-
-int msn_ns_command(struct msn_data *md, char **cmd, int num_parts)
-{
-        struct im_connection *ic = md->ic;
+        } else {
+                return TRUE;
+        }
+}
+
+static int msn_ns_command(struct msn_handler_data *handler, char **cmd, int num_parts)
+{
+        struct im_connection *ic = handler->data;
+        struct msn_data *md = ic->proto_data;
 
         if (num_parts == 0) {
@@ -211 +185 @@
                 }
 
-                return(msn_ns_write(ic, md->fd, "CVR %d 0x0409 mac 10.2.0 ppc macmsgs 3.5.1 macmsgs %s VmVyc2lvbjogMQ0KWGZyQ291bnQ6IDINClhmclNlbnRVVENUaW1lOiA2MzU2MTQ3OTU5NzgzOTAwMDANCklzR2VvWGZyOiB0cnVlDQo=\r\n",
+                return(msn_ns_write(ic, handler->fd, "CVR %d 0x0409 mac 10.2.0 ppc macmsgs 3.5.1 macmsgs %s\r\n",
                                     ++md->trId, ic->acc->user));
         } else if (strcmp(cmd[0], "CVR") == 0) {
                 /* We don't give a damn about the information we just received */
-                return msn_ns_write(ic, md->fd, "USR %d SSO I %s\r\n", ++md->trId, ic->acc->user);
+                return msn_ns_write(ic, handler->fd, "USR %d SSO I %s\r\n", ++md->trId, ic->acc->user);
         } else if (strcmp(cmd[0], "XFR") == 0) {
                 char *server;
@@ -221 +195 @@
 
                 if (num_parts >= 6 && strcmp(cmd[2], "NS") == 0) {
-                        b_event_remove(md->inpa);
-                        md->inpa = -1;
+                        b_event_remove(handler->inpa);
+                        handler->inpa = -1;
 
                         server = strchr(cmd[3], ':');
@@ -235 +209 @@
 
                         imcb_log(ic, "Transferring to other server");
-                        return msn_ns_connect(ic, server, port);
+                        return msn_ns_connect(ic, handler, server, port);
+                } else if (num_parts >= 6 && strcmp(cmd[2], "SB") == 0) {
+                        struct msn_switchboard *sb;
+
+                        server = strchr(cmd[3], ':');
+                        if (!server) {
+                                imcb_error(ic, "Syntax error");
+                                imc_logout(ic, TRUE);
+                                return(0);
+                        }
+                        *server = 0;
+                        port = atoi(server + 1);
+                        server = cmd[3];
+
+                        if (strcmp(cmd[4], "CKI") != 0) {
+                                imcb_error(ic, "Unknown authentication method for switchboard");
+                                imc_logout(ic, TRUE);
+                                return(0);
+                        }
+
+                        debug("Connecting to a new switchboard with key %s", cmd[5]);
+
+                        if ((sb = msn_sb_create(ic, server, port, cmd[5], MSN_SB_NEW)) == NULL) {
+                                /* Although this isn't strictly fatal for the NS connection, it's
+                                   definitely something serious (we ran out of file descriptors?). */
+                                imcb_error(ic, "Could not create new switchboard");
+                                imc_logout(ic, TRUE);
+                                return(0);
+                        }
+
+                        if (md->msgq) {
+                                struct msn_message *m = md->msgq->data;
+                                GSList *l;
+
+                                sb->who = g_strdup(m->who);
+
+                                /* Move all the messages to the first user in the message
+                                   queue to the switchboard message queue. */
+                                l = md->msgq;
+                                while (l) {
+                                        m = l->data;
+                                        l = l->next;
+                                        if (strcmp(m->who, sb->who) == 0) {
+                                                sb->msgq = g_slist_append(sb->msgq, m);
+                                                md->msgq = g_slist_remove(md->msgq, m);
+                                        }
+                                }
+                        }
                 } else {
                         imcb_error(ic, "Syntax error");
@@ -269 +290 @@
                 }
 
-                md->msglen = atoi(cmd[3]);
-
-                if (md->msglen <= 0) {
+                handler->msglen = atoi(cmd[3]);
+
+                if (handler->msglen <= 0) {
                         imcb_error(ic, "Syntax error");
                         imc_logout(ic, TRUE);
                         return(0);
                 }
+        } else if (strcmp(cmd[0], "BLP") == 0) {
+                msn_ns_send_adl_start(ic);
+                return msn_ns_finish_login(ic);
         } else if (strcmp(cmd[0], "ADL") == 0) {
                 if (num_parts >= 3 && strcmp(cmd[2], "OK") == 0) {
@@ -281 +305 @@
                         return msn_ns_finish_login(ic);
                 } else if (num_parts >= 3) {
-                        md->msglen = atoi(cmd[2]);
-                }
+                        handler->msglen = atoi(cmd[2]);
+                }
+        } else if (strcmp(cmd[0], "PRP") == 0) {
+                imcb_connected(ic);
         } else if (strcmp(cmd[0], "CHL") == 0) {
                 char *resp;
@@ -300 +326 @@
                 g_free(resp);
                 return st;
-        } else if (strcmp(cmd[0], "QRY") == 0) {
-                /* CONGRATULATIONS */
+        } else if (strcmp(cmd[0], "ILN") == 0 || strcmp(cmd[0], "NLN") == 0) {
+                const struct msn_away_state *st;
+                const char *handle;
+                int cap = 0;
+
+                if (num_parts < 6) {
+                        imcb_error(ic, "Syntax error");
+                        imc_logout(ic, TRUE);
+                        return(0);
+                }
+                /* ILN and NLN are more or less the same, except ILN has a trId
+                   at the start, and NLN has a capability field at the end.
+                   Does ILN still exist BTW? */
+                if (cmd[0][1] == 'I') {
+                        cmd++;
+                } else {
+                        cap = atoi(cmd[4]);
+                }
+
+                handle = msn_normalize_handle(cmd[2]);
+                if (strcmp(handle, ic->acc->user) == 0) {
+                        return 1; /* That's me! */
+
+                }
+                http_decode(cmd[3]);
+                imcb_rename_buddy(ic, handle, cmd[3]);
+
+                st = msn_away_state_by_code(cmd[1]);
+                if (!st) {
+                        /* FIXME: Warn/Bomb about unknown away state? */
+                        st = msn_away_state_list + 1;
+                }
+
+                imcb_buddy_status(ic, handle, OPT_LOGGED_IN |
+                                  (st != msn_away_state_list ? OPT_AWAY : 0) |
+                                  (cap & 1 ? OPT_MOBILE : 0),
+                                  st->name, NULL);
+
+                msn_sb_stop_keepalives(msn_sb_by_handle(ic, handle));
+        } else if (strcmp(cmd[0], "FLN") == 0) {
+                const char *handle;
+
+                if (cmd[1] == NULL) {
+                        return 1;
+                }
+
+                handle = msn_normalize_handle(cmd[1]);
+                imcb_buddy_status(ic, handle, 0, NULL, NULL);
+                msn_sb_start_keepalives(msn_sb_by_handle(ic, handle), TRUE);
+        } else if (strcmp(cmd[0], "RNG") == 0) {
+                struct msn_switchboard *sb;
+                char *server;
+                int session, port;
+
+                if (num_parts < 7) {
+                        imcb_error(ic, "Syntax error");
+                        imc_logout(ic, TRUE);
+                        return(0);
+                }
+
+                session = atoi(cmd[1]);
+
+                server = strchr(cmd[2], ':');
+                if (!server) {
+                        imcb_error(ic, "Syntax error");
+                        imc_logout(ic, TRUE);
+                        return(0);
+                }
+                *server = 0;
+                port = atoi(server + 1);
+                server = cmd[2];
+
+                if (strcmp(cmd[3], "CKI") != 0) {
+                        imcb_error(ic, "Unknown authentication method for switchboard");
+                        imc_logout(ic, TRUE);
+                        return(0);
+                }
+
+                debug("Got a call from %s (session %d). Key = %s", cmd[5], session, cmd[4]);
+
+                if ((sb = msn_sb_create(ic, server, port, cmd[4], session)) == NULL) {
+                        /* Although this isn't strictly fatal for the NS connection, it's
+                           definitely something serious (we ran out of file descriptors?). */
+                        imcb_error(ic, "Could not create new switchboard");
+                        imc_logout(ic, TRUE);
+                        return(0);
+                } else {
+                        sb->who = g_strdup(msn_normalize_handle(cmd[5]));
+                }
         } else if (strcmp(cmd[0], "OUT") == 0) {
-                imcb_error(ic, "Session terminated by remote server (%s)", cmd[1] ? cmd[1] : "reason unknown");
-                imc_logout(ic, TRUE);
+                int allow_reconnect = TRUE;
+
+                if (cmd[1] && strcmp(cmd[1], "OTH") == 0) {
+                        imcb_error(ic, "Someone else logged in with your account");
+                        allow_reconnect = FALSE;
+                } else if (cmd[1] && strcmp(cmd[1], "SSD") == 0) {
+                        imcb_error(ic, "Terminating session because of server shutdown");
+                } else {
+                        imcb_error(ic, "Session terminated by remote server (%s)",
+                                   cmd[1] ? cmd[1] : "reason unknown)");
+                }
+
+                imc_logout(ic, allow_reconnect);
                 return(0);
-        } else if (strcmp(cmd[0], "GCF") == 0) {
+        } else if (strcmp(cmd[0], "IPG") == 0) {
+                imcb_error(ic, "Received IPG command, we don't handle them yet.");
+
+                handler->msglen = atoi(cmd[1]);
+
+                if (handler->msglen <= 0) {
+                        imcb_error(ic, "Syntax error");
+                        imc_logout(ic, TRUE);
+                        return(0);
+                }
+        }
+#if 0
+        else if (strcmp(cmd[0], "ADG") == 0) {
+                char *group = g_strdup(cmd[3]);
+                int groupnum, i;
+                GSList *l, *next;
+
+                http_decode(group);
+                if (sscanf(cmd[4], "%d", &groupnum) == 1) {
+                        if (groupnum >= md->groupcount) {
+                                md->grouplist = g_renew(char *, md->grouplist, groupnum + 1);
+                                for (i = md->groupcount; i <= groupnum; i++) {
+                                        md->grouplist[i] = NULL;
+                                }
+                                md->groupcount = groupnum + 1;
+                        }
+                        g_free(md->grouplist[groupnum]);
+                        md->grouplist[groupnum] = group;
+                } else {
+                        /* Shouldn't happen, but if it does, give up on the group. */
+                        g_free(group);
+                        imcb_error(ic, "Syntax error");
+                        imc_logout(ic, TRUE);
+                        return 0;
+                }
+
+                for (l = md->grpq; l; l = next) {
+                        struct msn_groupadd *ga = l->data;
+                        next = l->next;
+                        if (g_strcasecmp(ga->group, group) == 0) {
+                                if (!msn_buddy_list_add(ic, "FL", ga->who, ga->who, group)) {
+                                        return 0;
+                                }
+
+                                g_free(ga->group);
+                                g_free(ga->who);
+                                g_free(ga);
+                                md->grpq = g_slist_remove(md->grpq, ga);
+                        }
+                }
+        }
+#endif
+        else if (strcmp(cmd[0], "GCF") == 0) {
                 /* Coming up is cmd[2] bytes of stuff we're supposed to
                    censore. Meh. */
-                md->msglen = atoi(cmd[2]);
-        } else if ((strcmp(cmd[0], "NFY") == 0) || (strcmp(cmd[0], "SDG") == 0)) {
+                handler->msglen = atoi(cmd[2]);
+        } else if (strcmp(cmd[0], "UBX") == 0) {
+                /* Status message. */
                 if (num_parts >= 3) {
-                        md->msglen = atoi(cmd[2]);
-                }
-        } else if (strcmp(cmd[0], "PUT") == 0) {
-                if (num_parts >= 4) {
-                        md->msglen = atoi(cmd[3]);
+                        handler->msglen = atoi(cmd[2]);
                 }
         } else if (strcmp(cmd[0], "NOT") == 0) {
+                /* Some kind of notification, poorly documented but
+                   apparently used to announce address book changes. */
                 if (num_parts >= 2) {
-                        md->msglen = atoi(cmd[1]);
+                        handler->msglen = atoi(cmd[1]);
+                }
+        } else if (strcmp(cmd[0], "UBM") == 0) {
+                if (num_parts >= 7) {
+                        handler->msglen = atoi(cmd[6]);
                 }
         } else if (strcmp(cmd[0], "QNG") == 0) {
@@ -337 +516 @@
                 /* Oh yes, errors can have payloads too now. Discard them for now. */
                 if (num_parts >= 3) {
-                        md->msglen = atoi(cmd[2]);
+                        handler->msglen = atoi(cmd[2]);
                 }
         } else {
-                imcb_error(ic, "Received unknown command from main server: %s", cmd[0]);
+                /* debug( "Received unknown command from main server: %s", cmd[0] ); */
         }
 
@@ -346 +525 @@
 }
 
-int msn_ns_message(struct msn_data *md, char *msg, int msglen, char **cmd, int num_parts)
-{
-        struct im_connection *ic = md->ic;
+static int msn_ns_message(struct msn_handler_data *handler, char *msg, int msglen, char **cmd, int num_parts)
+{
+        struct im_connection *ic = handler->data;
         char *body;
         int blen = 0;
@@ -419 +598 @@
                                 }
                         } else if (g_strncasecmp(ct, "text/x-msmsgsactivemailnotification", 35) == 0) {
-                                /* Notification that a message has been read... Ignore it */
+                        } else if (g_strncasecmp(ct, "text/x-msmsgsinitialmdatanotification", 37) == 0 ||
+                                   g_strncasecmp(ct, "text/x-msmsgsoimnotification", 28) == 0) {
+                                /* We received an offline message. Or at least notification
+                                   that there is one waiting for us. Fetching the message(s)
+                                   and purging them from the server is a lot of SOAPy work
+                                   not worth doing IMHO. Also I thought it was possible to
+                                   have the notification server send them directly, I was
+                                   pretty sure I saw Pidgin do it..
+
+                                   At least give a notification for now, seems like a
+                                   reasonable thing to do. Only problem is, they'll keep
+                                   coming back at login time until you read them using a
+                                   different client. :-( */
+
+                                char *xml = get_rfc822_header(body, "Mail-Data:", blen);
+                                struct xt_node *md, *m;
+
+                                if (!xml) {
+                                        return 1;
+                                }
+                                md = xt_from_string(xml, 0);
+                                if (!md) {
+                                        return 1;
+                                }
+
+                                for (m = md->children; (m = xt_find_node(m, "M")); m = m->next) {
+                                        struct xt_node *e = xt_find_node(m->children, "E");
+                                        struct xt_node *rt = xt_find_node(m->children, "RT");
+                                        struct tm tp;
+                                        time_t msgtime = 0;
+
+                                        if (!e || !e->text) {
+                                                continue;
+                                        }
+
+                                        memset(&tp, 0, sizeof(tp));
+                                        if (rt && rt->text &&
+                                            sscanf(rt->text, "%4d-%2d-%2dT%2d:%2d:%2d.",
+                                                   &tp.tm_year, &tp.tm_mon, &tp.tm_mday,
+                                                   &tp.tm_hour, &tp.tm_min, &tp.tm_sec) == 6) {
+                                                tp.tm_year -= 1900;
+                                                tp.tm_mon--;
+                                                msgtime = mktime_utc(&tp);
+
+                                        }
+                                        imcb_buddy_msg(ic, e->text,
+                                                       "<< \002BitlBee\002 - Received offline message. BitlBee can't show these. >>", 0,
+                                                       msgtime);
+                                }
+
+                                g_free(xml);
+                                xt_free_node(md);
                         } else {
                                 debug("Can't handle %s packet from notification server", ct);
@@ -426 +656 @@
                         g_free(ct);
                 }
+        } else if (strcmp(cmd[0], "UBX") == 0) {
+                struct xt_node *ubx, *psm;
+                char *psm_text = NULL;
+
+                ubx = xt_from_string(msg, msglen);
+                if (ubx && strcmp(ubx->name, "Data") == 0 &&
+                    (psm = xt_find_node(ubx->children, "PSM"))) {
+                        psm_text = psm->text;
+                }
+
+                imcb_buddy_status_msg(ic, msn_normalize_handle(cmd[1]), psm_text);
+                xt_free_node(ubx);
         } else if (strcmp(cmd[0], "ADL") == 0) {
                 struct xt_node *adl, *d, *c;
@@ -474 +716 @@
                         }
                 }
-        } else if ((strcmp(cmd[0], "SDG") == 0) || (strcmp(cmd[0], "NFY") == 0)) {
-                msn_ns_structured_message(md, msg, msglen, cmd);
+        } else if (strcmp(cmd[0], "UBM") == 0) {
+                /* This one will give us msgs from federated networks. Technically
+                   it should also get us offline messages, but I don't know how
+                   I can signal MSN servers to use it. */
+                char *ct, *handle;
+
+                if (strcmp(cmd[1], ic->acc->user) == 0) {
+                        /* With MPOP, you'll get copies of your own msgs from other
+                           sessions. Discard those at least for now. */
+                        return 1;
+                }
+
+                ct = get_rfc822_header(msg, "Content-Type", msglen);
+                if (strncmp(ct, "text/plain", 10) != 0) {
+                        /* Typing notification or something? */
+                        g_free(ct);
+                        return 1;
+                }
+                if (strcmp(cmd[2], "1") != 0) {
+                        handle = g_strdup_printf("%s:%s", cmd[2], cmd[1]);
+                } else {
+                        handle = g_strdup(cmd[1]);
+                }
+
+                imcb_buddy_msg(ic, handle, body, 0, 0);
+                g_free(handle);
         }
 
         return 1;
-}
-
-static void msn_ns_structured_message(struct msn_data *md, char *msg, int msglen, char **cmd)
-{
-        char **parts = NULL;
-        char *semicolon = NULL;
-        char *action = NULL;
-        char *from = NULL;
-        char *who = NULL;
-
-        parts = g_strsplit(msg, "\r\n\r\n", 4);
-
-        if (!(from = get_rfc822_header(parts[0], "From", 0))) {
-                goto cleanup;
-        }
-
-        /* either the semicolon or the end of the string */
-        semicolon = strchr(from, ';') ? : (from + strlen(from));
-
-        who = g_strndup(from + 2, semicolon - from - 2);
-
-        if ((strcmp(cmd[0], "SDG") == 0) && (action = get_rfc822_header(parts[2], "Message-Type", 0))) {
-                msn_ns_sdg(md, who, parts, action);
-
-        } else if ((strcmp(cmd[0], "NFY") == 0) && (action = get_rfc822_header(parts[2], "Uri", 0))) {
-                gboolean is_put = (strcmp(cmd[1], "PUT") == 0);
-                msn_ns_nfy(md, who, parts, action, is_put);
-        }
-
-cleanup:
-        g_strfreev(parts);
-        g_free(action);
-        g_free(from);
-        g_free(who);
-}
-
-static void msn_ns_sdg(struct msn_data *md, char *who, char **parts, char *action)
-{
-        struct im_connection *ic = md->ic;
-
-        if (strcmp(action, "Control/Typing") == 0) {
-                imcb_buddy_typing(ic, who, OPT_TYPING);
-        } else if (strcmp(action, "Text") == 0) {
-                imcb_buddy_msg(ic, who, parts[3], 0, 0);
-        }
-}
-
-static void msn_ns_nfy(struct msn_data *md, char *who, char **parts, char *action, gboolean is_put)
-{
-        struct im_connection *ic = md->ic;
-        struct xt_node *body = NULL;
-        struct xt_node *s = NULL;
-        const char *state = NULL;
-        char *nick = NULL;
-        char *psm = NULL;
-        int flags = OPT_LOGGED_IN;
-
-        if (strcmp(action, "/user") != 0) {
-                return;
-        }
-
-        if (!(body = xt_from_string(parts[3], 0))) {
-                goto cleanup;
-        }
-
-        s = body->children;
-        while ((s = xt_find_node(s, "s"))) {
-                struct xt_node *s2;
-                char *n = xt_find_attr(s, "n");  /* service name: IM, PE, etc */
-
-                if (strcmp(n, "IM") == 0) {
-                        /* IM has basic presence information */
-                        if (!is_put) {
-                                /* NFY DEL with a <s> usually means log out from the last endpoint */
-                                flags &= ~OPT_LOGGED_IN;
-                                break;
-                        }
-
-                        s2 = xt_find_node(s->children, "Status");
-                        if (s2 && s2->text_len) {
-                                const struct msn_away_state *msn_state = msn_away_state_by_code(s2->text);
-                                state = msn_state->name;
-                                if (msn_state != msn_away_state_list) {
-                                        flags |= OPT_AWAY;
-                                }
-                        }
-                } else if (strcmp(n, "PE") == 0) {
-                        if ((s2 = xt_find_node(s->children, "PSM")) && s2->text_len) {
-                                psm = s2->text;
-                        }
-                        if ((s2 = xt_find_node(s->children, "FriendlyName")) && s2->text_len) {
-                                nick = s2->text;
-                        }
-                }
-                s = s->next;
-        }
-
-        imcb_buddy_status(ic, who, flags, state, psm);
-
-        if (nick) {
-                imcb_rename_buddy(ic, who, nick);
-        }
-
-cleanup:
-        xt_free_node(body);
 }
 
@@ -607 +768 @@
 void msn_auth_got_contact_list(struct im_connection *ic)
 {
+        struct msn_data *md;
+
         /* Dead connection? */
         if (g_slist_find(msn_connections, ic) == NULL) {
@@ -612 +775 @@
         }
 
-        msn_ns_send_adl_start(ic);
-        msn_ns_finish_login(ic);
+        md = ic->proto_data;
+        msn_ns_write(ic, -1, "BLP %d %s\r\n", ++md->trId, "BL");
 }
 
 static gboolean msn_ns_send_adl_1(gpointer key, gpointer value, gpointer data)
 {
-        struct xt_node *adl = data, *d, *c, *s;
+        struct xt_node *adl = data, *d, *c;
         struct bee_user *bu = value;
         struct msn_buddy_data *bd = bu->data;
@@ -647 +810 @@
         c = xt_new_node("c", NULL, NULL);
         xt_add_attr(c, "n", handle);
+        xt_add_attr(c, "l", l);
         xt_add_attr(c, "t", "1");   /* FIXME: Network type, i.e. 32 for Y!MSG */
-        s = xt_new_node("s", NULL, NULL);
-        xt_add_attr(s, "n", "IM");
-        xt_add_attr(s, "l", l);
-        xt_insert_child(c, s);
         xt_insert_child(d, c);
 
@@ -721 +881 @@
 
         if ((md->flags & MSN_DONE_ADL) && (md->flags & MSN_GOT_PROFILE)) {
-                imcb_connected(ic);
+                if (md->flags & MSN_EMAIL_UNVERIFIED) {
+                        imcb_connected(ic);
+                } else {
+                        return msn_ns_set_display_name(ic, set_getstr(&ic->acc->set, "display_name"));
+                }
         }
 
@@ -727 +891 @@
 }
 
-// TODO: typing notifications, nudges lol, etc
 int msn_ns_sendmessage(struct im_connection *ic, bee_user_t *bu, const char *text)
 {
         struct msn_data *md = ic->proto_data;
-        int retval = 0;
-        char *buf;
+        int type = 0;
+        char *buf, *handle;
 
         if (strncmp(text, "\r\r\r", 3) == 0) {
@@ -740 +903 @@
         }
 
-        buf = g_strdup_printf(MSN_MESSAGE_HEADERS, bu->handle, ic->acc->user, md->uuid, strlen(text), text);
-        retval = msn_ns_write(ic, -1, "SDG %d %zd\r\n%s", ++md->trId, strlen(buf), buf);
-        g_free(buf);
-        return retval;
-}
+        /* This might be a federated contact. Get its network number,
+           prefixed to bu->handle with a colon. Default is 1. */
+        for (handle = bu->handle; g_ascii_isdigit(*handle); handle++) {
+                type = type * 10 + *handle - '0';
+        }
+        if (*handle == ':') {
+                handle++;
+        } else {
+                type = 1;
+        }
+
+        buf = g_strdup_printf("%s%s", MSN_MESSAGE_HEADERS, text);
+
+        if (msn_ns_write(ic, -1, "UUM %d %s %d %d %zd\r\n%s",
+                         ++md->trId, handle, type,
+                         1,          /* type == IM (not nudge/typing) */
+                         strlen(buf), buf)) {
+                return 1;
+        } else {
+                return 0;
+        }
+}
+
+void msn_ns_oim_send_queue(struct im_connection *ic, GSList **msgq)
+{
+        GSList *l;
+
+        for (l = *msgq; l; l = l->next) {
+                struct msn_message *m = l->data;
+                bee_user_t *bu = bee_user_by_handle(ic->bee, ic, m->who);
+
+                if (bu) {
+                        if (!msn_ns_sendmessage(ic, bu, m->text)) {
+                                return;
+                        }
+                }
+        }
+
+        while (*msgq != NULL) {
+                struct msn_message *m = (*msgq)->data;
+
+                *msgq = g_slist_remove(*msgq, m);
+                g_free(m->who);
+                g_free(m->text);
+                g_free(m);
+        }
+}

protocols/msn/soap.c

@@ -209 +209 @@
                 return;
         }
-        fprintf(stderr, "\n\x1b[90mSOAP:\n");
 
         if (headers) {
@@ -226 +225 @@
                 xt_free_node(xt);
         }
-        fprintf(stderr, "\n\x1b[97m\n");
 }
 

protocols/msn/tables.c

@@ -73 +73 @@
         { 206, "Domain name missing",                                   0 },
         { 207, "Already logged in",                                     0 },
-        { 208, "Invalid handle",                                        0 },
+        { 208, "Invalid handle",                                        STATUS_SB_IM_SPARE },
         { 209, "Forbidden nickname",                                    0 },
         { 210, "Buddy list too long",                                   0 },
         { 215, "Handle is already in list",                             0 },
-        { 216, "Handle is not in list",                                 0 },
-        { 217, "Person is off-line or non-existent",                    0 },
+        { 216, "Handle is not in list",                                 STATUS_SB_IM_SPARE },
+        { 217, "Person is off-line or non-existent",                    STATUS_SB_IM_SPARE },
         { 218, "Already in that mode",                                  0 },
         { 219, "Handle is already in opposite list",                    0 },
@@ -113 +113 @@
         { 711, "Write is blocking",                                     STATUS_FATAL },
         { 712, "Session is overloaded",                                 STATUS_FATAL },
-        { 713, "Calling too rapidly",                                   0 },
+        { 713, "Calling too rapidly",                                   STATUS_SB_IM_SPARE },
         { 714, "Too many sessions",                                     STATUS_FATAL },
         { 715, "Not expected/Invalid argument/action",                  0 },