MsnSlpLink *
msn_slplink_new(MsnSession *session, const char *username)
{
MsnSlpLink *slplink;
g_return_val_if_fail(session != NULL, NULL);
slplink = g_new0(MsnSlpLink, 1);
#ifdef PECAN_DEBUG_SLPLINK
pecan_info ("slplink_new: slplink(%p)", slplink);
#endif
slplink->session = session;
slplink->slp_seq_id = rand() % 0xFFFFFF00 + 4;
slplink->slp_session_id = rand() % 0xFFFFFF00 + 4;
slplink->local_user = g_strdup(msn_session_get_username(session));
slplink->remote_user = g_strdup(username);
slplink->slp_msg_queue = g_queue_new();
session->slplinks =
g_list_append(session->slplinks, slplink);
return slplink;
}
void
msn_slplink_destroy(MsnSlpLink *slplink)
{
MsnSession *session;
#ifdef PECAN_DEBUG_SLPLINK
pecan_info ("slplink_destroy: slplink(%p)", slplink);
#endif
g_return_if_fail(slplink != NULL);
if (slplink->swboard != NULL)
slplink->swboard->slplinks = g_list_remove(slplink->swboard->slplinks, slplink);
session = slplink->session;
if (slplink->local_user != NULL)
g_free(slplink->local_user);
if (slplink->remote_user != NULL)
g_free(slplink->remote_user);
#ifdef MSN_DIRECTCONN
if (slplink->directconn != NULL)
msn_directconn_destroy(slplink->directconn);
#endif /* MSN_DIRECTCONN */
while (slplink->slp_calls != NULL)
msn_slp_call_destroy(slplink->slp_calls->data);
session->slplinks =
g_list_remove(session->slplinks, slplink);
g_free(slplink);
}
static void
got_transresp(MsnSlpCall *slpcall, const char *nonce,
const char *ips_str, int port)
{
MsnDirectConn *directconn;
char **ip_addrs, **c;
directconn = msn_directconn_new(slpcall->slplink);
directconn->initial_call = slpcall;
/* msn_directconn_parse_nonce(directconn, nonce); */
directconn->nonce = g_strdup(nonce);
ip_addrs = g_strsplit(ips_str, " ", -1);
for (c = ip_addrs; *c != NULL; c++)
{
pecan_info ("ip_addr = %s", *c);
if (msn_directconn_connect(directconn, *c, port))
break;
}
g_strfreev(ip_addrs);
}
static void
msn_xfer_init(PurpleXfer *xfer)
{
MsnSlpCall *slpcall;
/* MsnSlpLink *slplink; */
char *content;
pecan_info ("xfer_init");
slpcall = xfer->data;
/* Send Ok */
content = pecan_strdup_printf("SessionID: %lu\r\n\r\n",
slpcall->session_id);
send_ok(slpcall, slpcall->branch, "application/x-msnmsgr-sessionreqbody",
content);
g_free(content);
msn_slplink_unleash(slpcall->slplink);
}
static void
ipg_cmd_post(MsnCmdProc *cmdproc, MsnCommand *cmd, char *payload, size_t len)
{
pecan_info ("incoming page: [%s]", payload);
}
static void
got_ok(MsnSlpCall *slpcall,
const char *type, const char *content)
{
g_return_if_fail(slpcall != NULL);
g_return_if_fail(type != NULL);
pecan_log ("type=%s", type);
if (!strcmp(type, "application/x-msnmsgr-sessionreqbody"))
{
#ifdef MSN_DIRECTCONN
if (slpcall->slplink->session->use_directconn &&
slpcall->type == MSN_SLPCALL_DC)
{
/* First let's try a DirectConnection. */
MsnSlpLink *slplink;
MsnSlpMessage *slpmsg;
char *header;
gchar *new_content;
char *branch;
slplink = slpcall->slplink;
branch = msn_rand_guid();
new_content = pecan_strdup_printf(
"Bridges: TRUDPv1 TCPv1\r\n"
"NetID: 0\r\n"
"Conn-Type: Direct-Connect\r\n"
"UPnPNat: false\r\n"
"ICF: false\r\n"
);
header = pecan_strdup_printf("INVITE MSNMSGR:%s MSNSLP/1.0",
slplink->remote_user);
slpmsg = msn_slpmsg_sip_new(slpcall, 0, header, branch,
"application/x-msnmsgr-transreqbody",
new_content);
#ifdef PECAN_DEBUG_SLP
slpmsg->info = "SLP INVITE";
slpmsg->text_body = TRUE;
#endif
msn_slplink_send_slpmsg(slplink, slpmsg);
g_free(header);
g_free(new_content);
g_free(branch);
}
else
{
msn_slp_call_session_init(slpcall);
}
#else
msn_slp_call_session_init(slpcall);
#endif /* MSN_DIRECTCONN */
}
else if (!strcmp(type, "application/x-msnmsgr-transreqbody"))
{
/* Do we get this? */
pecan_info ("OK with transreqbody");
}
#ifdef MSN_DIRECTCONN
else if (!strcmp(type, "application/x-msnmsgr-transrespbody"))
{
char *ip_addrs;
char *temp;
char *nonce;
int port;
{
char *listening;
listening = get_token(content, "Listening: ", "\r\n");
if (strcmp (listening, "false") == 0)
{
/** @todo I'm not sure if this is OK. */
msn_slp_call_session_init(slpcall);
g_free (listening);
return;
}
g_free (listening);
}
nonce = get_token(content, "Nonce: {", "}\r\n");
ip_addrs = get_token(content, "IPv4Internal-Addrs: ", "\r\n");
temp = get_token(content, "IPv4Internal-Port: ", "\r\n");
if (temp != NULL)
port = atoi(temp);
else
port = -1;
g_free(temp);
if (ip_addrs == NULL)
return;
if (port > 0)
got_transresp(slpcall, nonce, ip_addrs, port);
g_free(nonce);
g_free(ip_addrs);
}
#endif /* MSN_DIRECTCONN */
}
static void
got_sessionreq(MsnSlpCall *slpcall, const char *branch,
const char *euf_guid, const char *context)
{
pecan_debug ("euf_guid=[%s]", euf_guid);
if (!strcmp(euf_guid, "A4268EEC-FEC5-49E5-95C3-F126696BDBF6"))
{
/* Emoticon or UserDisplay */
char *content;
gsize len;
MsnSlpSession *slpsession;
MsnSlpLink *slplink;
MsnSlpMessage *slpmsg;
MsnObject *obj;
char *msnobj_data;
PecanBuffer *image;
int type;
/* Send Ok */
content = pecan_strdup_printf("SessionID: %lu\r\n\r\n",
slpcall->session_id);
send_ok(slpcall, branch, "application/x-msnmsgr-sessionreqbody",
content);
g_free(content);
slplink = slpcall->slplink;
msnobj_data = (char *)purple_base64_decode(context, &len);
obj = msn_object_new_from_string(msnobj_data);
type = msn_object_get_type(obj);
g_free(msnobj_data);
if (type == MSN_OBJECT_USERTILE)
{
/* image is owned by a local object, not obj */
image = msn_object_get_image(obj);
}
#if PURPLE_VERSION_CHECK(2,5,0)
else if (type == MSN_OBJECT_EMOTICON)
{
PurpleStoredImage *img;
char *path;
path = g_build_filename(purple_smileys_get_storing_dir(), msn_object_get_location(obj), NULL);
img = purple_imgstore_new_from_file(path);
image = pecan_buffer_new_memdup ((const gpointer) purple_imgstore_get_data (img),
purple_imgstore_get_size (img));
purple_imgstore_unref(img);
g_free(path);
}
#endif /* PURPLE_VERSION_CHECK(2,5,0) */
else
{
pecan_error ("Wrong object?");
msn_object_destroy(obj);
g_return_if_reached();
}
if (!image)
{
pecan_error ("Wrong object");
msn_object_destroy (obj);
g_return_if_reached ();
}
msn_object_destroy(obj);
{
gchar *tmp;
tmp = msn_object_to_string (obj);
pecan_info ("object requested: %s", tmp);
g_free (tmp);
}
slpsession = msn_slplink_find_slp_session(slplink,
slpcall->session_id);
/* DATA PREP */
slpmsg = msn_slpmsg_new(slplink);
slpmsg->slpcall = slpcall;
slpmsg->slpsession = slpsession;
slpmsg->session_id = slpsession->id;
msn_slpmsg_set_body(slpmsg, NULL, 4);
#ifdef PECAN_DEBUG_SLP
slpmsg->info = "SLP DATA PREP";
#endif
msn_slplink_queue_slpmsg(slplink, slpmsg);
/* DATA */
slpmsg = msn_slpmsg_new(slplink);
slpmsg->slpcall = slpcall;
slpmsg->slpsession = slpsession;
slpmsg->flags = 0x20;
#ifdef PECAN_DEBUG_SLP
slpmsg->info = "SLP DATA";
#endif
msn_slpmsg_set_image (slpmsg, image);
msn_slplink_queue_slpmsg(slplink, slpmsg);
}
else if (!strcmp(euf_guid, "5D3E02AB-6190-11D3-BBBB-00C04F795683"))
{
/* File Transfer */
PurpleAccount *account;
PurpleXfer *xfer;
char *bin;
gsize bin_len;
guint32 file_size;
char *file_name;
gunichar2 *uni_name;
account = slpcall->slplink->session->account;
slpcall->cb = msn_xfer_completed_cb;
slpcall->end_cb = msn_xfer_end_cb;
slpcall->progress_cb = msn_xfer_progress_cb;
slpcall->branch = g_strdup(branch);
slpcall->pending = TRUE;
xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE,
slpcall->slplink->remote_user);
if (xfer)
{
bin = (char *)purple_base64_decode(context, &bin_len);
file_size = GUINT32_FROM_LE(*(gsize *)(bin + 8));
uni_name = (gunichar2 *)(bin + 20);
while(*uni_name != 0 && ((char *)uni_name - (bin + 20)) < MAX_FILE_NAME_LEN) {
*uni_name = GUINT16_FROM_LE(*uni_name);
uni_name++;
}
file_name = g_utf16_to_utf8((const gunichar2 *)(bin + 20), -1,
NULL, NULL, NULL);
g_free(bin);
purple_xfer_set_filename(xfer, file_name);
purple_xfer_set_size(xfer, file_size);
purple_xfer_set_init_fnc(xfer, msn_xfer_init);
purple_xfer_set_request_denied_fnc(xfer, msn_xfer_cancel);
purple_xfer_set_cancel_recv_fnc(xfer, msn_xfer_cancel);
slpcall->xfer = xfer;
purple_xfer_ref(slpcall->xfer);
xfer->data = slpcall;
purple_xfer_request(xfer);
}
}
}
