Menu
▾
▴
[Gaim-commits] CVS: gaim/src/protocols/msn ft.c,NONE,1.1 msg.c,NONE,1.1 msg.h,NONE,1.1 msn.h,NONE,1.1 switchboard.c,NONE,1.1 switchboard.h,NONE,1.1 Makefile.am,1.9,1.10 msn.c,1.138,1.139
|
From: Christian H. <ch...@us...> - 2003-02-06 10:13:21
|
Update of /cvsroot/gaim/gaim/src/protocols/msn
In directory sc8-pr-cvs1:/tmp/cvs-serv13455
Modified Files:
Makefile.am msn.c
Added Files:
ft.c msg.c msg.h msn.h switchboard.c switchboard.h
Log Message:
Split up the MSN module a bit and added file receive support.
Caution: I lost some data in a large file that was sent to me. Don't rely
on this yet. I'll get it all fixed tomorrow.
--- NEW FILE: ft.c ---
/**
* @file msn.c The MSN protocol plugin
*
* gaim
*
* Copyright (C) 2003, Christian Hammond <ch...@gn...>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "msn.h"
G_MODULE_IMPORT GSList *connections;
static struct gaim_xfer *
find_xfer_by_cookie(struct gaim_connection *gc, unsigned long cookie)
{
GSList *g;
struct msn_data *md = (struct msn_data *)gc->proto_data;
struct gaim_xfer *xfer = NULL;
struct msn_xfer_data *xfer_data;
for (g = md->file_transfers; g != NULL; g = g->next) {
xfer = (struct gaim_xfer *)g->data;
xfer_data = (struct msn_xfer_data *)xfer->data;
if (xfer_data->cookie == cookie)
break;
xfer = NULL;
}
return xfer;
}
static void
msn_xfer_init(struct gaim_xfer *xfer)
{
struct gaim_account *account;
struct msn_xfer_data *xfer_data;
struct msn_switchboard *ms;
char header[MSN_BUF_LEN];
char buf[MSN_BUF_LEN];
account = gaim_xfer_get_account(xfer);
ms = msn_find_switch(account->gc, xfer->who);
xfer_data = (struct msn_xfer_data *)xfer->data;
if (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) {
/*
* NOTE: We actually have to wait for the next Invitation message
* before the transfer starts. We handle that in
* msn_xfer_start().
*/
g_snprintf(header, sizeof(header),
"MIME-Version: 1.0\r\n"
"Content-Type: text/x-msmsgsinvite; charset=UTF-8\r\n\r\n"
"Invitation-Command: ACCEPT\r\n"
"Invitation-Cookie: %lu\r\n"
"Launch-Application: FALSE\r\n"
"Request-Data: IP-Address:\r\n",
(unsigned long)xfer_data->cookie);
g_snprintf(buf, sizeof(buf), "MSG %u N %d\r\n%s\r\n\r\n",
++ms->trId, strlen(header) + strlen("\r\n\r\n"),
header);
if (msn_write(ms->fd, buf, strlen(buf)) < 0) {
msn_kill_switch(ms);
gaim_xfer_destroy(xfer);
return;
}
}
}
static void
msn_xfer_start(struct gaim_xfer *xfer)
{
struct msn_xfer_data *xfer_data;
xfer_data = (struct msn_xfer_data *)xfer->data;
xfer_data->transferring = TRUE;
if (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) {
char sendbuf[MSN_BUF_LEN];
/* Send the TFR string to request the start of a transfer. */
g_snprintf(sendbuf, sizeof(sendbuf), "TFR\r\n");
if (msn_write(xfer->fd, sendbuf, strlen(sendbuf)) < 0) {
gaim_xfer_cancel(xfer);
}
}
}
static void
msn_xfer_end(struct gaim_xfer *xfer)
{
struct gaim_account *account;
struct msn_xfer_data *xfer_data;
struct msn_data *md;
account = gaim_xfer_get_account(xfer);
xfer_data = (struct msn_xfer_data *)xfer->data;
md = (struct msn_data *)account->gc->proto_data;
if (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) {
char sendbuf[MSN_BUF_LEN];
g_snprintf(sendbuf, sizeof(sendbuf), "BYE 16777989\r\n");
msn_write(xfer->fd, sendbuf, strlen(sendbuf));
md->file_transfers = g_slist_remove(md->file_transfers, xfer);
g_free(xfer_data);
xfer->data = NULL;
}
}
static void
msn_xfer_cancel(struct gaim_xfer *xfer)
{
struct gaim_account *account;
struct msn_xfer_data *xfer_data;
struct msn_data *md;
account = gaim_xfer_get_account(xfer);
xfer_data = (struct msn_xfer_data *)xfer->data;
md = (struct msn_data *)account->gc->proto_data;
if (gaim_xfer_get_type(xfer) == GAIM_XFER_RECEIVE) {
md->file_transfers = g_slist_remove(md->file_transfers, xfer);
g_free(xfer_data);
xfer->data = NULL;
}
}
static size_t
msn_xfer_read(char **buffer, struct gaim_xfer *xfer)
{
unsigned char header[3];
size_t len, size;
if (read(xfer->fd, header, sizeof(header)) < 3) {
gaim_xfer_set_completed(xfer, TRUE);
return 0;
}
if (header[0] != 0) {
debug_printf("MSNFTP: Invalid header[0]: %d. Aborting.\n",
header[0]);
return 0;
}
size = header[1] | (header[2] << 8);
*buffer = g_new0(char, size);
for (len = 0;
len < size;
len += read(xfer->fd, *buffer + len, size - len))
;
if (len == 0)
gaim_xfer_set_completed(xfer, TRUE);
return len;
}
static size_t
msn_xfer_write(const char *buffer, size_t size, struct gaim_xfer *xfer)
{
return 0;
}
static int
msn_process_msnftp(struct gaim_xfer *xfer, gint source, const char *buf)
{
struct msn_xfer_data *xfer_data;
struct gaim_account *account;
char sendbuf[MSN_BUF_LEN];
xfer_data = (struct msn_xfer_data *)xfer->data;
account = gaim_xfer_get_account(xfer);
if (!g_strncasecmp(buf, "VER MSNFTP", 10)) {
/* Send the USR string */
g_snprintf(sendbuf, sizeof(sendbuf), "USR %s %lu\r\n",
account->gc->username,
(unsigned long)xfer_data->authcookie);
if (msn_write(source, sendbuf, strlen(sendbuf)) < 0) {
gaim_xfer_cancel(xfer); /* ? */
return 0;
}
}
else if (!g_strncasecmp(buf, "FIL", 3)) {
gaim_input_remove(xfer_data->inpa);
xfer_data->inpa = 0;
gaim_xfer_start(xfer, source, NULL, 0);
}
#if 0
char *tmp = buf;
/*
* This data is the size, but we already have
* the size, so who cares.
*/
GET_NEXT(tmp);
/* Send the TFR string to request the start of a transfer. */
g_snprintf(sendbuf, sizeof(sendbuf), "TFR\r\n");
if (msn_write(source, sendbuf, strlen(sendbuf)) < 0) {
gaim_xfer_cancel(xfer);
return 0;
}
#endif
return 1;
}
static void
msn_msnftp_cb(gpointer data, gint source, GaimInputCondition cond)
{
struct gaim_xfer *xfer;
struct msn_xfer_data *xfer_data;
char buf[MSN_BUF_LEN];
gboolean cont = TRUE;
size_t len;
xfer = (struct gaim_xfer *)data;
xfer_data = (struct msn_xfer_data *)xfer->data;
len = read(source, buf, sizeof(buf));
if (len <= 0) {
gaim_xfer_cancel(xfer);
return;
}
xfer_data->rxqueue = g_realloc(xfer_data->rxqueue,
len + xfer_data->rxlen);
memcpy(xfer_data->rxqueue + xfer_data->rxlen, buf, len);
xfer_data->rxlen += len;
while (cont) {
char *end = xfer_data->rxqueue;
char *cmd;
int cmdlen;
int i = 0;
if (!xfer_data->rxlen)
return;
for (i = 0; i < xfer_data->rxlen - 1; end++, i++) {
if (*end == '\r' && *(end + 1) == '\n')
break;
}
if (i == xfer_data->rxlen - 1)
return;
cmdlen = end - xfer_data->rxqueue + 2;
cmd = xfer_data->rxqueue;
xfer_data->rxlen -= cmdlen;
if (xfer_data->rxlen)
xfer_data->rxqueue = g_memdup(cmd + cmdlen, xfer_data->rxlen);
else {
xfer_data->rxqueue = NULL;
cmd = g_realloc(cmd, cmdlen + 1);
}
cmd[cmdlen] = '\0';
g_strchomp(cmd);
cont = msn_process_msnftp(xfer, source, cmd);
g_free(cmd);
}
}
static void
msn_msnftp_connect(gpointer data, gint source, GaimInputCondition cond)
{
struct gaim_account *account;
struct gaim_xfer *xfer;
struct msn_xfer_data *xfer_data;
char buf[MSN_BUF_LEN];
xfer = (struct gaim_xfer *)data;
account = gaim_xfer_get_account(xfer);
xfer_data = (struct msn_xfer_data *)xfer->data;
if (source == -1 || !g_slist_find(connections, account->gc)) {
debug_printf("MSNFTP: Error establishing connection\n");
close(source);
gaim_xfer_cancel(xfer);
return;
}
g_snprintf(buf, sizeof(buf), "VER MSNFTP\r\n");
if (msn_write(source, buf, strlen(buf)) < 0) {
gaim_xfer_cancel(xfer);
return;
}
xfer_data->inpa = gaim_input_add(source, GAIM_INPUT_READ,
msn_msnftp_cb, xfer);
}
void
msn_process_ft_msg(struct msn_switchboard *ms, char *msg)
{
struct gaim_xfer *xfer;
struct msn_xfer_data *xfer_data;
struct msn_data *md = ms->gc->proto_data;
char *tmp = msg;
if (strstr(msg, "Application-GUID: " MSN_FT_GUID) &&
strstr(msg, "Invitation-Command: INVITE")) {
/*
* First invitation message, requesting an ACCEPT or CANCEL from
* the recipient. Used in incoming file transfers.
*/
char *filename;
char *cookie_s, *filesize_s;
tmp = strstr(msg, "Invitation-Cookie");
GET_NEXT(tmp);
cookie_s = tmp;
GET_NEXT(tmp);
GET_NEXT(tmp);
filename = tmp;
/* Needed for filenames with spaces */
tmp = strchr(tmp, '\r');
*tmp = '\0';
tmp += 2;
GET_NEXT(tmp);
filesize_s = tmp;
GET_NEXT(tmp);
/* Setup the MSN-specific file transfer data */
xfer_data = g_new0(struct msn_xfer_data, 1);
xfer_data->cookie = atoi(cookie_s);
xfer_data->transferring = FALSE;
/* Build the file transfer handle. */
xfer = gaim_xfer_new(ms->gc->account, GAIM_XFER_RECEIVE, ms->msguser);
xfer->data = xfer_data;
/* Set the info about the incoming file. */
gaim_xfer_set_filename(xfer, filename);
gaim_xfer_set_size(xfer, atoi(filesize_s));
/* Setup our I/O op functions */
gaim_xfer_set_init_fnc(xfer, msn_xfer_init);
gaim_xfer_set_start_fnc(xfer, msn_xfer_start);
gaim_xfer_set_end_fnc(xfer, msn_xfer_end);
gaim_xfer_set_cancel_fnc(xfer, msn_xfer_cancel);
gaim_xfer_set_read_fnc(xfer, msn_xfer_read);
gaim_xfer_set_write_fnc(xfer, msn_xfer_write);
/* Keep track of this transfer for later. */
md->file_transfers = g_slist_append(md->file_transfers, xfer);
/* Now perform the request */
gaim_xfer_request(xfer);
}
else if (strstr(msg, "Invitation-Command: ACCEPT")) {
/*
* XXX I hope these checks don't return false positives, but they
* seem like they should work. The only issue is alternative
* protocols, *maybe*.
*/
if (strstr(msg, "AuthCookie:")) {
/*
* Second invitation request, sent after the recipient accepts
* the request. Used in incoming file transfers.
*/
char *cookie_s, *ip, *port_s, *authcookie_s;
char ip_s[16];
tmp = strstr(msg, "Invitation-Cookie");
GET_NEXT(tmp);
cookie_s = tmp;
GET_NEXT(tmp);
GET_NEXT(tmp);
ip = tmp;
GET_NEXT(tmp);
GET_NEXT(tmp);
port_s = tmp;
GET_NEXT(tmp);
GET_NEXT(tmp);
authcookie_s = tmp;
GET_NEXT(tmp);
xfer = find_xfer_by_cookie(ms->gc, atoi(cookie_s));
if (xfer == NULL)
{
debug_printf("MSNFTP : Cookie not found. "
"File transfer aborted.\n");
return;
}
xfer_data = (struct msn_xfer_data *)xfer->data;
xfer_data->authcookie = atol(authcookie_s);
strncpy(ip_s, ip, sizeof(ip_s));
if (proxy_connect(ip_s, atoi(port_s),
msn_msnftp_connect, xfer) != 0) {
gaim_xfer_cancel(xfer);
return;
}
}
else
{
/*
* An accept message from the recipient. Used in outgoing
* file transfers.
*/
}
}
}
--- NEW FILE: msg.c ---
/**
* @file msg.c Message functions
*
* gaim
*
* Copyright (C) 2003, Christian Hammond <ch...@gn...>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "msn.h"
int
msn_write(int fd, void *data, int len)
{
debug_printf("MSN C: %s", (char *)data);
return write(fd, data, len);
}
--- NEW FILE: msg.h ---
/**
* @file msg.h Message functions
*
* gaim
*
* Copyright (C) 2003, Christian Hammond <ch...@gn...>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _MSN_MSG_H_
#define _MSN_MSG_H_
/**
* Writes a message to the server.
*
* @param fd The file descriptor.
* @param data The data to write.
* @param len The length of the data
*
* @return The number of bytes written.
*/
int msn_write(int fd, void *data, int len);
#endif /* _MSN_MSG_H_ */
--- NEW FILE: msn.h ---
/**
* @file msn.h The MSN protocol plugin
*
* gaim
*
* Copyright (C) 2003, Christian Hammond <ch...@gn...>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _MSN_H_
#define _MSN_H_
#include "config.h"
#ifndef _WIN32
#include <unistd.h>
#else
#include <winsock.h>
#include <io.h>
#endif
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <ctype.h>
#ifndef _WIN32
#include <netdb.h>
#endif
#include "gaim.h"
#include "prpl.h"
#include "proxy.h"
#include "md5.h"
#ifdef _WIN32
#include "win32dep.h"
#include "stdint.h"
#endif
#include "msg.h"
#include "switchboard.h"
#define MSN_BUF_LEN 8192
#define MIME_HEADER "MIME-Version: 1.0\r\n" \
"Content-Type: text/plain; charset=UTF-8\r\n" \
"User-Agent: Gaim/" VERSION "\r\n" \
"X-MMS-IM-Format: FN=Arial; EF=; CO=0; PF=0\r\n\r\n"
#define HOTMAIL_URL "http://www.hotmail.com/cgi-bin/folders"
#define PASSPORT_URL "http://lc1.law13.hotmail.passport.com/cgi-bin/dologin?login="
#define MSN_ONLINE 1
#define MSN_BUSY 2
#define MSN_IDLE 3
#define MSN_BRB 4
#define MSN_AWAY 5
#define MSN_PHONE 6
#define MSN_LUNCH 7
#define MSN_OFFLINE 8
#define MSN_HIDDEN 9
#define USEROPT_HOTMAIL 0
#define USEROPT_MSNSERVER 3
#define MSN_SERVER "messenger.hotmail.com"
#define USEROPT_MSNPORT 4
#define MSN_PORT 1863
#define MSN_TYPING_RECV_TIMEOUT 6
#define MSN_TYPING_SEND_TIMEOUT 4
#define MSN_FT_GUID "{5D3E02AB-6190-11d3-BBBB-00C04F795683}"
#define GET_NEXT(tmp) \
while (*(tmp) && *(tmp) != ' ' && *(tmp) != '\r') \
(tmp)++; \
*(tmp)++ = 0; \
while (*(tmp) && *(tmp) == ' ') \
(tmp)++;
struct msn_xfer_data {
int inpa;
uint32_t cookie;
uint32_t authcookie;
gboolean transferring;
char *rxqueue;
int rxlen;
gboolean msg;
char *msguser;
int msglen;
};
struct msn_data {
int fd;
uint32_t trId;
int inpa;
char *rxqueue;
int rxlen;
gboolean msg;
char *msguser;
int msglen;
GSList *switches;
GSList *fl;
GSList *permit;
GSList *deny;
GSList *file_transfers;
char *kv;
char *sid;
char *mspauth;
unsigned long sl;
char *passport;
};
struct msn_buddy {
char *user;
char *friend;
};
/**
* Processes a file transfer message.
*
* @param ms The switchboard.
* @param msg The message.
*/
void msn_process_ft_msg(struct msn_switchboard *ms, char *msg);
char *handle_errcode(char *buf, gboolean show);
char *url_decode(const char *msg);
#endif /* _MSN_H_ */
--- NEW FILE: switchboard.c ---
/**
* @file switchboard.c MSN switchboard functions
*
* gaim
*
* Copyright (C) 2003, Christian Hammond <ch...@gn...>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "msn.h"
static char *
msn_parse_format(char *mime)
{
char *cur;
GString *ret = g_string_new(NULL);
guint colorbuf;
char *colors = (char *)(&colorbuf);
cur = strstr(mime, "FN=");
if (cur && (*(cur = cur + 3) != ';')) {
ret = g_string_append(ret, "<FONT FACE=\"");
while (*cur && *cur != ';') {
ret = g_string_append_c(ret, *cur);
cur++;
}
ret = g_string_append(ret, "\">");
}
cur = strstr(mime, "EF=");
if (cur && (*(cur = cur + 3) != ';')) {
while (*cur && *cur != ';') {
ret = g_string_append_c(ret, '<');
ret = g_string_append_c(ret, *cur);
ret = g_string_append_c(ret, '>');
cur++;
}
}
cur = strstr(mime, "CO=");
if (cur && (*(cur = cur + 3) != ';')) {
if (sscanf (cur, "%x;", &colorbuf) == 1) {
char tag[64];
g_snprintf(tag, sizeof(tag), "<FONT COLOR=\"#%02hhx%02hhx%02hhx\">", colors[0], colors[1], colors[2]);
ret = g_string_append(ret, tag);
}
}
cur = url_decode(ret->str);
g_string_free(ret, TRUE);
return cur;
}
static int
msn_process_switch(struct msn_switchboard *ms, char *buf)
{
struct gaim_connection *gc = ms->gc;
char sendbuf[MSN_BUF_LEN];
static int id = 0;
if (!g_strncasecmp(buf, "ACK", 3)) {
} else if (!g_strncasecmp(buf, "ANS", 3)) {
if (ms->chat)
gaim_chat_add_user(GAIM_CHAT(ms->chat), gc->username, NULL);
} else if (!g_strncasecmp(buf, "BYE", 3)) {
char *user, *tmp = buf;
GET_NEXT(tmp);
user = tmp;
if (ms->chat) {
gaim_chat_remove_user(GAIM_CHAT(ms->chat), user, NULL);
} else {
char msgbuf[256];
const char *username;
struct gaim_conversation *cnv;
struct buddy *b;
if ((b = find_buddy(gc->account, user)) != NULL)
username = get_buddy_alias(b);
else
username = user;
g_snprintf(msgbuf, sizeof(msgbuf),
_("%s has closed the conversation window"), username);
if ((cnv = gaim_find_conversation(user)))
gaim_conversation_write(cnv, NULL, msgbuf, -1,
WFLAG_SYSTEM, time(NULL));
msn_kill_switch(ms);
return 0;
}
} else if (!g_strncasecmp(buf, "CAL", 3)) {
} else if (!g_strncasecmp(buf, "IRO", 3)) {
char *tot, *user, *tmp = buf;
GET_NEXT(tmp);
GET_NEXT(tmp);
GET_NEXT(tmp);
tot = tmp;
GET_NEXT(tmp);
ms->total = atoi(tot);
user = tmp;
GET_NEXT(tmp);
if (ms->total > 1) {
if (!ms->chat)
ms->chat = serv_got_joined_chat(gc, ++id, "MSN Chat");
gaim_chat_add_user(GAIM_CHAT(ms->chat), user, NULL);
}
} else if (!g_strncasecmp(buf, "JOI", 3)) {
char *user, *tmp = buf;
GET_NEXT(tmp);
user = tmp;
GET_NEXT(tmp);
if (ms->total == 1) {
ms->chat = serv_got_joined_chat(gc, ++id, "MSN Chat");
gaim_chat_add_user(GAIM_CHAT(ms->chat), ms->user, NULL);
gaim_chat_add_user(GAIM_CHAT(ms->chat), gc->username, NULL);
g_free(ms->user);
ms->user = NULL;
}
if (ms->chat)
gaim_chat_add_user(GAIM_CHAT(ms->chat), user, NULL);
ms->total++;
while (ms->txqueue) {
char *send = add_cr(ms->txqueue->data);
g_snprintf(sendbuf, sizeof(sendbuf),
"MSG %u N %d\r\n%s%s", ++ms->trId,
strlen(MIME_HEADER) + strlen(send),
MIME_HEADER, send);
g_free(ms->txqueue->data);
ms->txqueue = g_slist_remove(ms->txqueue, ms->txqueue->data);
if (msn_write(ms->fd, sendbuf, strlen(sendbuf)) < 0) {
msn_kill_switch(ms);
return 0;
}
debug_printf("\n");
}
} else if (!g_strncasecmp(buf, "MSG", 3)) {
char *user, *tmp = buf;
int length;
GET_NEXT(tmp);
user = tmp;
GET_NEXT(tmp);
GET_NEXT(tmp);
length = atoi(tmp);
ms->msg = TRUE;
ms->msguser = g_strdup(user);
ms->msglen = length;
} else if (!g_strncasecmp(buf, "NAK", 3)) {
do_error_dialog(_("An MSN message may not have been received."), NULL, GAIM_ERROR);
} else if (!g_strncasecmp(buf, "NLN", 3)) {
} else if (!g_strncasecmp(buf, "OUT", 3)) {
if (ms->chat)
serv_got_chat_left(gc, gaim_chat_get_id(GAIM_CHAT(ms->chat)));
msn_kill_switch(ms);
return 0;
} else if (!g_strncasecmp(buf, "USR", 3)) {
/* good, we got USR, now we need to find out who we want to talk to */
struct msn_switchboard *ms = msn_find_writable_switch(gc);
if (!ms)
return 0;
g_snprintf(sendbuf, sizeof(sendbuf), "CAL %u %s\r\n",
++ms->trId, ms->user);
if (msn_write(ms->fd, sendbuf, strlen(sendbuf)) < 0) {
msn_kill_switch(ms);
return 0;
}
} else if (isdigit(*buf)) {
handle_errcode(buf, TRUE);
if (atoi(buf) == 217)
msn_kill_switch(ms);
} else {
debug_printf("Unhandled message!\n");
}
return 1;
}
static void
msn_process_switch_msg(struct msn_switchboard *ms, char *msg)
{
char *content, *agent, *format;
char *message = NULL;
int flags = 0;
agent = strstr(msg, "User-Agent: ");
if (agent) {
if (!g_strncasecmp(agent, "User-Agent: Gaim",
strlen("User-Agent: Gaim")))
flags |= IM_FLAG_GAIMUSER;
}
format = strstr(msg, "X-MMS-IM-Format: ");
if (format) {
format = msn_parse_format(format);
} else {
format = NULL;
}
content = strstr(msg, "Content-Type: ");
if (!content)
return;
if (!g_strncasecmp(content, "Content-Type: text/x-msmsgscontrol\r\n",
strlen( "Content-Type: text/x-msmsgscontrol\r\n"))) {
if (strstr(content,"TypingUser: ") && !ms->chat) {
serv_got_typing(ms->gc, ms->msguser,
MSN_TYPING_RECV_TIMEOUT, TYPING);
return;
}
} else if (!g_strncasecmp(content, "Content-Type: text/x-msmsgsinvite;",
strlen("Content-Type: text/x-msmsgsinvite;"))) {
/*
* NOTE: Other things, such as voice communication, would go in
* here too (since they send the same Content-Type). However,
* this is the best check for file transfer messages, so I'm
* calling msn_process_ft_invite_msg(). If anybody adds support
* for anything else that sends a text/x-msmsgsinvite, perhaps
* this should be changed. For now, it stays.
*/
msn_process_ft_msg(ms, content);
} else if (!g_strncasecmp(content, "Content-Type: text/plain",
strlen("Content-Type: text/plain"))) {
char *skiphead = strstr(msg, "\r\n\r\n");
if (!skiphead || !skiphead[4]) {
return;
}
skiphead += 4;
strip_linefeed(skiphead);
if (format) {
message = g_strdup_printf("%s%s", format, skiphead);
} else {
message = g_strdup(skiphead);
}
if (ms->chat)
serv_got_chat_in(ms->gc, gaim_chat_get_id(GAIM_CHAT(ms->chat)),
ms->msguser, flags, message, time(NULL));
else
serv_got_im(ms->gc, ms->msguser, message, flags, time(NULL), -1);
g_free(message);
}
}
static void
msn_switchboard_callback(gpointer data, gint source, GaimInputCondition cond)
{
struct msn_switchboard *ms = data;
char buf[MSN_BUF_LEN];
int cont = 1;
int len;
ms->fd = source;
len = read(ms->fd, buf, sizeof(buf));
if (len <= 0) {
msn_kill_switch(ms);
return;
}
ms->rxqueue = g_realloc(ms->rxqueue, len + ms->rxlen);
memcpy(ms->rxqueue + ms->rxlen, buf, len);
ms->rxlen += len;
while (cont) {
if (!ms->rxlen)
return;
if (ms->msg) {
char *msg;
if (ms->msglen > ms->rxlen)
return;
msg = ms->rxqueue;
ms->rxlen -= ms->msglen;
if (ms->rxlen) {
ms->rxqueue = g_memdup(msg + ms->msglen, ms->rxlen);
} else {
ms->rxqueue = NULL;
msg = g_realloc(msg, ms->msglen + 1);
}
msg[ms->msglen] = 0;
ms->msglen = 0;
ms->msg = FALSE;
msn_process_switch_msg(ms, msg);
g_free(ms->msguser);
g_free(msg);
} else {
char *end = ms->rxqueue;
int cmdlen;
char *cmd;
int i = 0;
while (i + 1 < ms->rxlen) {
if (*end == '\r' && end[1] == '\n')
break;
end++; i++;
}
if (i + 1 == ms->rxlen)
return;
cmdlen = end - ms->rxqueue + 2;
cmd = ms->rxqueue;
ms->rxlen -= cmdlen;
if (ms->rxlen) {
ms->rxqueue = g_memdup(cmd + cmdlen, ms->rxlen);
} else {
ms->rxqueue = NULL;
cmd = g_realloc(cmd, cmdlen + 1);
}
cmd[cmdlen] = 0;
debug_printf("MSN S: %s", cmd);
g_strchomp(cmd);
cont = msn_process_switch(ms, cmd);
g_free(cmd);
}
}
}
void
msn_rng_connect(gpointer data, gint source, GaimInputCondition cond)
{
struct msn_switchboard *ms = data;
struct gaim_connection *gc = ms->gc;
struct msn_data *md;
char buf[MSN_BUF_LEN];
if (source == -1 || !g_slist_find(connections, gc)) {
close(source);
g_free(ms->sessid);
g_free(ms->auth);
g_free(ms);
return;
}
md = gc->proto_data;
if (ms->fd != source)
ms->fd = source;
g_snprintf(buf, sizeof(buf), "ANS %u %s %s %s\r\n", ++ms->trId, gc->username, ms->auth, ms->sessid);
if (msn_write(ms->fd, buf, strlen(buf)) < 0) {
close(ms->fd);
g_free(ms->sessid);
g_free(ms->auth);
g_free(ms);
return;
}
md->switches = g_slist_append(md->switches, ms);
ms->inpa = gaim_input_add(ms->fd, GAIM_INPUT_READ,
msn_switchboard_callback, ms);
}
static void
msn_ss_xfr_connect(gpointer data, gint source, GaimInputCondition cond)
{
struct msn_switchboard *ms = data;
struct gaim_connection *gc = ms->gc;
char buf[MSN_BUF_LEN];
if (source == -1 || !g_slist_find(connections, gc)) {
close(source);
if (g_slist_find(connections, gc)) {
msn_kill_switch(ms);
do_error_dialog(_("Gaim was unable to send an MSN message"),
_("Gaim encountered an error communicating with the "
"MSN switchboard server. Please try again later."),
GAIM_ERROR);
}
return;
}
if (ms->fd != source)
ms->fd = source;
g_snprintf(buf, sizeof(buf), "USR %u %s %s\r\n",
++ms->trId, gc->username, ms->auth);
if (msn_write(ms->fd, buf, strlen(buf)) < 0) {
g_free(ms->auth);
g_free(ms);
return;
}
ms->inpa = gaim_input_add(ms->fd, GAIM_INPUT_READ,
msn_switchboard_callback, ms);
}
struct msn_switchboard *
msn_find_switch(struct gaim_connection *gc, const char *username)
{
struct msn_data *md = (struct msn_data *)gc->proto_data;
GSList *m = md->switches;
for (m = md->switches; m != NULL; m = m->next) {
struct msn_switchboard *ms = (struct msn_switchboard *)m->data;
if (ms->total <= 1 && !g_strcasecmp(ms->user, username))
return ms;
}
return NULL;
}
struct msn_switchboard *
msn_find_switch_by_id(struct gaim_connection *gc, int chat_id)
{
struct msn_data *md = (struct msn_data *)gc->proto_data;
GSList *m;
for (m = md->switches; m != NULL; m = m->next) {
struct msn_switchboard *ms = (struct msn_switchboard *)m->data;
if (ms->chat && gaim_chat_get_id(GAIM_CHAT(ms->chat)) == chat_id)
return ms;
}
return NULL;
}
struct msn_switchboard *
msn_find_writable_switch(struct gaim_connection *gc)
{
struct msn_data *md = (struct msn_data *)gc->proto_data;
GSList *m;
for (m = md->switches; m != NULL; m = m->next) {
struct msn_switchboard *ms = (struct msn_switchboard *)m->data;
if (ms->txqueue != NULL)
return ms;
}
return NULL;
}
void
msn_kill_switch(struct msn_switchboard *ms)
{
struct gaim_connection *gc = ms->gc;
struct msn_data *md = gc->proto_data;
if (ms->inpa)
gaim_input_remove(ms->inpa);
close(ms->fd);
g_free(ms->rxqueue);
if (ms->msg) g_free(ms->msguser);
if (ms->user) g_free(ms->user);
if (ms->sessid) g_free(ms->sessid);
g_free(ms->auth);
while (ms->txqueue) {
g_free(ms->txqueue->data);
ms->txqueue = g_slist_remove(ms->txqueue, ms->txqueue->data);
}
if (ms->chat)
serv_got_chat_left(gc, gaim_chat_get_id(GAIM_CHAT(ms->chat)));
md->switches = g_slist_remove(md->switches, ms);
g_free(ms);
}
struct msn_switchboard *
msn_switchboard_connect(struct gaim_connection *gc, const char *host, int port)
{
struct msn_switchboard *ms;
if (host == NULL || port == 0)
return NULL;
ms = msn_find_writable_switch(gc);
if (ms == NULL)
return NULL;
if (proxy_connect((char *)host, port, msn_ss_xfr_connect, ms) != 0) {
msn_kill_switch(ms);
return NULL;
}
return ms;
}
--- NEW FILE: switchboard.h ---
/**
* @file switchboard.h MSN switchboard functions
*
* gaim
*
* Copyright (C) 2003, Christian Hammond <ch...@gn...>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef _MSN_SWITCHBOARD_H_
#define _MSN_SWITCHBOARD_H_
struct msn_switchboard {
struct gaim_connection *gc;
struct gaim_conversation *chat;
int fd;
int inpa;
char *rxqueue;
int rxlen;
gboolean msg;
char *msguser;
int msglen;
char *sessid;
char *auth;
uint32_t trId;
int total;
char *user;
GSList *txqueue;
};
/**
* Finds a switch with the given username.
*
* @param gc The gaim connection.
* @param username The username to search for.
*
* @return The switchboard, if found.
*/
struct msn_switchboard *msn_find_switch(struct gaim_connection *gc,
const char *username);
/**
* Finds a switchboard with the given chat ID.
*
* @param gc The gaim connection.
* @param chat_id The chat ID to search for.
*
* @return The switchboard, if found.
*/
struct msn_switchboard *msn_find_switch_by_id(struct gaim_connection *gc,
int chat_id);
/**
* Finds the first writable switchboard.
*
* @param gc The gaim connection.
*
* @return The first writable switchboard, if found.
*/
struct msn_switchboard *msn_find_writable_switch(struct gaim_connection *gc);
/**
* Connects to a switchboard.
*
* @param gc The gaim connection.
* @param host The hostname.
* @param port The port.
*
* @return The new switchboard.
*/
struct msn_switchboard *msn_switchboard_connect(struct gaim_connection *gc,
const char *host, int port);
/**
* Kills a switchboard.
*
* @param ms The switchboard to kill.
*/
void msn_kill_switch(struct msn_switchboard *ms);
void msn_rng_connect(gpointer data, gint source, GaimInputCondition cond);
#endif /* _MSN_SWITCHBOARD_H_ */
Index: Makefile.am
===================================================================
RCS file: /cvsroot/gaim/gaim/src/protocols/msn/Makefile.am,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- Makefile.am 5 Jan 2003 03:02:55 -0000 1.9
+++ Makefile.am 6 Feb 2003 10:13:18 -0000 1.10
@@ -2,7 +2,14 @@
pkgdir = $(libdir)/gaim
-MSNSOURCES = msn.c
+MSNSOURCES = \
+ ft.c \
+ msg.c \
+ msg.h \
+ msn.c \
+ msn.h \
+ switchboard.c \
+ switchboard.h
AM_CFLAGS = $(st)
Index: msn.c
===================================================================
RCS file: /cvsroot/gaim/gaim/src/protocols/msn/msn.c,v
retrieving revision 1.138
retrieving revision 1.139
diff -u -d -r1.138 -r1.139
--- msn.c 2 Feb 2003 07:43:27 -0000 1.138
+++ msn.c 6 Feb 2003 10:13:18 -0000 1.139
@@ -1,146 +1,37 @@
-#include "config.h"
-
-#ifndef _WIN32
-#include <unistd.h>
-#else
-#include <winsock.h>
-#include <io.h>
-#endif
-
-
-#include <sys/stat.h>
[...1031 lines suppressed...]
- unsigned long cookie)
-{
- GSList *g = ((struct msn_data *)gc->proto_data)->file_transfers;
- struct msn_file_transfer *f = NULL;
-
- while (g) {
- f = (struct msn_file_transfer *)g->data;
- if (f->cookie == cookie)
- break;
-
- g = g->next;
- f = NULL;
- }
-
- return f;
-}
-
static void msn_file_transfer_cancel(struct gaim_connection *gc,
struct file_transfer *xfer)
{
|