/**************************************************************************
* Connect stuff
**************************************************************************/
static void
connect_cb(MsnServConn *servconn)
{
MsnSwitchBoard *swboard;
MsnCmdProc *cmdproc;
GaimAccount *account;
cmdproc = servconn->cmdproc;
g_return_if_fail(cmdproc != NULL);
account = cmdproc->session->account;
swboard = cmdproc->data;
g_return_if_fail(swboard != NULL);
if (msn_switchboard_is_invited(swboard))
{
swboard->empty = FALSE;
msn_cmdproc_send(cmdproc, "ANS", "%s %s %s",
gaim_account_get_username(account),
swboard->auth_key, swboard->session_id);
}
else
{
msn_cmdproc_send(cmdproc, "USR", "%s %s",
gaim_account_get_username(account),
swboard->auth_key);
}
}
void
msn_session_set_prp (MsnSession *session,
const char *key,
const char *value)
{
MsnCmdProc *cmdproc;
cmdproc = session->notification->cmdproc;
if (value) {
/*
* We should investigate if other properties also need striping. If so,
* then pn_friendly_name_encode should be renamed to pn_prop_encode or
* something like that, and g_strstrip should be handled internally.
*/
gchar *tmp = g_strdup (value);
gchar *enc = pn_friendly_name_encode (g_strstrip (tmp));
g_free (tmp);
msn_cmdproc_send (cmdproc, "PRP", "%s %s", key, enc);
g_free (enc);
}
else {
msn_cmdproc_send (cmdproc, "PRP", "%s", key);
}
}
void
pn_update_status (MsnSession *session)
{
MsnCmdProc *cmdproc;
struct pn_contact *user;
const gchar *state_text;
int client_id;
int caps;
g_return_if_fail (session);
if (!session->logged_in)
return;
user = msn_session_get_contact (session);
cmdproc = session->notification->cmdproc;
state_text = util_type_to_str (util_status_from_session (session));
caps = PN_CLIENT_CAP_BASE;
#if defined(PECAN_CVR)
caps |= PN_CLIENT_CAP_INK_GIF;
#if defined(PECAN_LIBSIREN)
caps |= PN_CLIENT_CAP_VOICE_CLIP;
#endif
#if defined(PECAN_LIBMSPACK)
caps |= PN_CLIENT_CAP_WINKS;
#endif
#endif
client_id = caps | (PN_CLIENT_VER_7_5 << 24);
#if defined(PECAN_CVR)
{
struct pn_msnobj *obj;
obj = pn_contact_get_object (user);
if (obj)
{
gchar *msnobj_str;
msnobj_str = pn_msnobj_to_string (obj);
msn_cmdproc_send (cmdproc, "CHG", "%s %d %s", state_text,
client_id, purple_url_encode (msnobj_str));
g_free (msnobj_str);
}
else
{
msn_cmdproc_send (cmdproc, "CHG", "%s %d", state_text,
client_id);
}
}
#else
msn_cmdproc_send (cmdproc, "CHG", "%s %d", state_text,
client_id);
#endif /* defined(PECAN_CVR) */
}
static void
connect_cb(MsnServConn *servconn)
{
MsnCmdProc *cmdproc;
MsnSession *session;
GaimAccount *account;
char **a, **c, *vers;
int i;
g_return_if_fail(servconn != NULL);
cmdproc = servconn->cmdproc;
session = servconn->session;
account = session->account;
/* Allocate an array for CVR0, NULL, and all the versions */
a = c = g_new0(char *, session->protocol_ver - 8 + 3);
for (i = session->protocol_ver; i >= 8; i--)
*c++ = g_strdup_printf("MSNP%d", i);
*c++ = g_strdup("CVR0");
vers = g_strjoinv(" ", a);
if (session->login_step == MSN_LOGIN_STEP_START)
msn_session_set_login_step(session, MSN_LOGIN_STEP_HANDSHAKE);
else
msn_session_set_login_step(session, MSN_LOGIN_STEP_HANDSHAKE2);
msn_cmdproc_send(cmdproc, "VER", "%s", vers);
g_strfreev(a);
g_free(vers);
}
void msn_set_friendly_name(PurpleConnection *gc, const char *entry)
{
MsnCmdProc *cmdproc;
MsnSession *session;
PurpleAccount *account;
const char *alias;
session = gc->proto_data;
cmdproc = session->notification->cmdproc;
account = purple_connection_get_account(gc);
if(entry && strlen(entry))
alias = purple_url_encode(entry);
else
alias = "";
if (strlen(alias) > BUDDY_ALIAS_MAXLEN)
{
purple_notify_error(gc, NULL,
_("Your new MSN friendly name is too long."), NULL);
return;
}
msn_cmdproc_send(cmdproc, "REA", "%s %s",
purple_account_get_username(account),
alias);
}
void
msn_notification_rem_buddy(MsnNotification *notification, const char *list,
const char *who, int group_id)
{
MsnCmdProc *cmdproc;
cmdproc = notification->servconn->cmdproc;
if (group_id >= 0)
{
msn_cmdproc_send(cmdproc, "REM", "%s %s %d", list, who, group_id);
}
else
{
msn_cmdproc_send(cmdproc, "REM", "%s %s", list, who);
}
}
static void
ver_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSession *session;
gboolean protocol_supported = FALSE;
const gchar *proto_str;
guint i;
session = cmdproc->session;
proto_str = "MSNP12";
for (i = 1; i < cmd->param_count; i++)
{
if (!strcmp(cmd->params[i], proto_str))
{
protocol_supported = TRUE;
break;
}
}
if (!protocol_supported)
{
msn_session_set_error(session, MSN_ERROR_UNSUPPORTED_PROTOCOL,
NULL);
return;
}
msn_cmdproc_send(cmdproc, "CVR",
"0x0409 winnt 5.1 i386 MSNMSGR 6.0.0602 MSMSGS %s",
msn_session_get_username(session));
}
static void
ver_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSession *session;
GaimAccount *account;
gboolean protocol_supported = FALSE;
char proto_str[8];
size_t i;
session = cmdproc->session;
account = session->account;
g_snprintf(proto_str, sizeof(proto_str), "MSNP%d", session->protocol_ver);
for (i = 1; i < cmd->param_count; i++)
{
if (!strcmp(cmd->params[i], proto_str))
{
protocol_supported = TRUE;
break;
}
}
if (!protocol_supported)
{
msn_session_set_error(session, MSN_ERROR_UNSUPPORTED_PROTOCOL,
NULL);
return;
}
msn_cmdproc_send(cmdproc, "CVR",
"0x0409 winnt 5.1 i386 MSNMSGR 6.0.0602 MSMSGS %s",
gaim_account_get_username(account));
}
void
pn_update_status (MsnSession *session)
{
MsnCmdProc *cmdproc;
struct pn_contact *user;
const gchar *state_text;
g_return_if_fail (session);
if (!session->logged_in)
return;
user = msn_session_get_contact (session);
cmdproc = session->notification->cmdproc;
state_text = util_type_to_str (util_status_from_session (session));
#if defined(PECAN_CVR)
{
struct pn_msnobj *obj;
obj = pn_contact_get_object (user);
if (obj)
{
gchar *msnobj_str;
msnobj_str = pn_msnobj_to_string (obj);
msn_cmdproc_send (cmdproc, "CHG", "%s %ld %s", state_text,
session->client_id, purple_url_encode (msnobj_str));
g_free (msnobj_str);
}
else
{
msn_cmdproc_send (cmdproc, "CHG", "%s %ld", state_text,
session->client_id);
}
}
#else
msn_cmdproc_send (cmdproc, "CHG", "%s %ld", state_text,
session->client_id);
#endif /* defined(PECAN_CVR) */
pn_send_login_uux (session);
}
static void
cvr_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
GaimAccount *account;
account = cmdproc->session->account;
msn_cmdproc_send(cmdproc, "USR", "TWN I %s",
gaim_account_get_username(account));
}
void
msn_notification_add_buddy(MsnNotification *notification, const char *list,
const char *who, const gchar *user_guid, const char *store_name,
const gchar *group_guid)
{
MsnCmdProc *cmdproc;
cmdproc = notification->cmdproc;
/* moogman:
* If old_group_name == NULL, then ADC cmd is different.
* If a new buddy (as opposed to a buddy move), ADC cmd is different.
* If !Fl, then do same as "new". */
if (user_guid && group_guid)
{
/* Buddy already in FL. Add it to group_guid. */
msn_cmdproc_send (cmdproc, "ADC", "%s C=%s %s", list, user_guid, group_guid);
}
else if (strcmp(list, "FL") == 0)
{
/* Add buddy to our FL. */
/* FunkTastic Foo! */
MsnTransaction *trans;
MsnAddBuddy *data;
data = g_new0 (MsnAddBuddy, 1);
data->who = g_strdup (who);
data->group_guid = g_strdup (group_guid);
trans = msn_transaction_new (cmdproc, "ADC", "%s N=%s F=%s",
list, who, purple_url_encode (store_name));
msn_transaction_set_data (trans, data);
msn_cmdproc_send_trans (cmdproc, trans);
}
else
{
/* Add buddy to another list (BL, AL). */
msn_cmdproc_send (cmdproc, "ADC", "%s N=%s", list, who);
}
}
void
msn_got_login_params(MsnSession *session, const char *login_params)
{
MsnCmdProc *cmdproc;
cmdproc = session->notification->cmdproc;
msn_session_set_login_step(session, MSN_LOGIN_STEP_AUTH_END);
msn_cmdproc_send(cmdproc, "USR", "TWN S %s", login_params);
}
void
msn_notification_add_buddy(MsnNotification *notification, const char *list,
const char *who, const char *store_name,
int group_id)
{
MsnCmdProc *cmdproc;
cmdproc = notification->servconn->cmdproc;
if (group_id < 0 && !strcmp(list, "FL"))
group_id = 0;
if (group_id >= 0)
{
msn_cmdproc_send(cmdproc, "ADD", "%s %s %s %d",
list, who, store_name, group_id);
}
else
{
msn_cmdproc_send(cmdproc, "ADD", "%s %s %s", list, who, store_name);
}
}
void
msn_notification_rem_buddy(MsnNotification *notification, const char *list,
const char *who, const gchar *user_guid, const gchar *group_guid)
{
MsnCmdProc *cmdproc;
const gchar *final_who;
cmdproc = notification->cmdproc;
final_who = ((strcmp (list, "FL") == 0) ? user_guid : who);
/* moogman: If user is only in one group, set group_guid == NULL (force a complete remove).
* It seems as if we don't need to do the above check. I've tested it as it is and it seems
* to work fine. However, a note is left here incase things change. */
if (group_guid)
{
msn_cmdproc_send (cmdproc, "REM", "%s %s %s", list, final_who, group_guid);
}
else
{
msn_cmdproc_send (cmdproc, "REM", "%s %s", list, final_who);
}
}
static void
usr_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSession *session;
GaimAccount *account;
GaimConnection *gc;
session = cmdproc->session;
account = session->account;
gc = gaim_account_get_connection(account);
if (!g_ascii_strcasecmp(cmd->params[1], "OK"))
{
/* OK */
const char *friendly = gaim_url_decode(cmd->params[3]);
gaim_connection_set_display_name(gc, friendly);
msn_session_set_login_step(session, MSN_LOGIN_STEP_SYN);
msn_cmdproc_send(cmdproc, "SYN", "%s", "0");
}
else if (!g_ascii_strcasecmp(cmd->params[1], "TWN"))
{
/* Passport authentication */
char **elems, **cur, **tokens;
session->nexus = msn_nexus_new(session);
/* Parse the challenge data. */
elems = g_strsplit(cmd->params[3], ",", 0);
for (cur = elems; *cur != NULL; cur++)
{
tokens = g_strsplit(*cur, "=", 2);
g_hash_table_insert(session->nexus->challenge_data, tokens[0], tokens[1]);
/* Don't free each of the tokens, only the array. */
g_free(tokens);
}
g_strfreev(elems);
msn_session_set_login_step(session, MSN_LOGIN_STEP_AUTH_START);
msn_nexus_connect(session->nexus);
}
}
void
msn_session_finish_login(MsnSession *session)
{
PurpleAccount *account;
PurpleConnection *gc;
PurpleStoredImage *img;
const char *passport;
if (session->logged_in) {
/* We are probably here because of a mid-session notification server XFR
* We must send a CHG now, otherwise the servers default to invisible,
* and prevent things happening, like sending IMs */
msn_change_status(session);
return;
}
account = session->account;
gc = purple_account_get_connection(account);
img = purple_buddy_icons_find_account_icon(session->account);
msn_user_set_buddy_icon(session->user, img);
purple_imgstore_unref(img);
session->logged_in = TRUE;
msn_change_status(session);
purple_connection_set_state(gc, PURPLE_CONNECTED);
/* Sync users */
msn_session_sync_users(session);
/* It seems that some accounts that haven't accessed hotmail for a while
* and @msn.com accounts don't automatically get the initial email
* notification so we always request it on login
*/
passport = purple_normalize(account, purple_account_get_username(account));
if ((strstr(passport, "@hotmail.") != NULL) ||
(strstr(passport, "@msn.com") != NULL))
{
msn_cmdproc_send(session->notification->cmdproc, "URL", "%s", "INBOX");
}
}
void
msn_got_login_params(MsnSession *session, const char *login_params)
{
MsnCmdProc *cmdproc;
cmdproc = session->notification->cmdproc;
msn_session_set_login_step(session, PECAN_LOGIN_STEP_AUTH_END);
{
gchar **tokens;
tokens = g_strsplit (login_params, "&", 2);
session->passport_cookie.t = g_strdup (tokens[0] + 2);
session->passport_cookie.p = g_strdup (tokens[1] + 2);
g_strfreev (tokens);
}
msn_cmdproc_send(cmdproc, "USR", "TWN S %s", login_params);
}
static void
usr_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSwitchBoard *swboard;
swboard = cmdproc->data;
#if 0
GList *l;
for (l = swboard->users; l != NULL; l = l->next)
{
const char *user;
user = l->data;
msn_cmdproc_send(cmdproc, "CAL", "%s", user);
}
#endif
swboard->ready = TRUE;
msn_cmdproc_process_queue(cmdproc);
}
void
msn_session_finish_login(MsnSession *session)
{
PurpleAccount *account;
PurpleConnection *gc;
PurpleStoredImage *img;
const char *passport;
if (session->logged_in)
return;
account = session->account;
gc = purple_account_get_connection(account);
img = purple_buddy_icons_find_account_icon(session->account);
msn_user_set_buddy_icon(session->user, img);
purple_imgstore_unref(img);
session->logged_in = TRUE;
msn_change_status(session);
purple_connection_set_state(gc, PURPLE_CONNECTED);
/* Sync users */
msn_session_sync_users(session);
/* It seems that some accounts that haven't accessed hotmail for a while
* and @msn.com accounts don't automatically get the initial email
* notification so we always request it on login
*/
passport = purple_normalize(account, purple_account_get_username(account));
if ((strstr(passport, "@hotmail.") != NULL) ||
(strstr(passport, "@msn.com") != NULL))
{
msn_cmdproc_send(session->notification->cmdproc, "URL", "%s", "INBOX");
}
}
static void
open_cb (PecanNode *conn,
MsnNotification *notification)
{
MsnSession *session;
PecanCmdServer *cmd_conn;
g_return_if_fail (conn != NULL);
pecan_log ("begin");
session = conn->session;
cmd_conn = CMD_PECAN_NODE (conn);
if (session->login_step == PECAN_LOGIN_STEP_START)
msn_session_set_login_step (session, PECAN_LOGIN_STEP_HANDSHAKE);
else
msn_session_set_login_step (session, PECAN_LOGIN_STEP_HANDSHAKE2);
msn_cmdproc_send (cmd_conn->cmdproc, "VER", "MSNP12 CVR0");
pecan_log ("end");
}
static void
nln_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSession *session;
PurpleAccount *account;
PurpleConnection *gc;
PecanContact *user;
#if defined(PECAN_CVR)
MsnObject *msnobj;
#endif /* defined(PECAN_CVR) */
unsigned long clientid;
const char *state, *passport;
gchar *friendly;
session = cmdproc->session;
account = session->account;
gc = purple_account_get_connection(account);
state = cmd->params[0];
passport = cmd->params[1];
friendly = pecan_url_decode(cmd->params[2]);
user = pecan_contactlist_find_contact(session->contactlist, passport);
if (!user)
{
pecan_error ("unknown user: passport=[%s]", passport);
return;
}
pecan_contact_set_friendly_name(user, friendly);
#if defined(PECAN_CVR)
if (session->use_userdisplay)
{
if (cmd->param_count == 5)
{
gchar *tmp;
tmp = pecan_url_decode(cmd->params[4]);
msnobj = msn_object_new_from_string(tmp);
pecan_contact_set_object(user, msnobj);
g_free (tmp);
}
else
{
pecan_contact_set_object(user, NULL);
}
}
#endif /* defined(PECAN_CVR) */
clientid = strtoul (cmd->params[3], NULL, 10);
user->mobile = (clientid & MSN_CLIENT_CAP_MSNMOBILE);
pecan_contact_set_state(user, state);
pecan_contact_update(user);
/* store the friendly name on the server. */
if (!session->server_alias)
msn_cmdproc_send (cmdproc, "SBP", "%s %s %s", pecan_contact_get_guid (user), "MFN", cmd->params[2]);
g_free (friendly);
}
static void
cvr_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
msn_cmdproc_send(cmdproc, "USR", "TWN I %s",
msn_session_get_username(cmdproc->session));
}
static void
initial_mdata_msg (MsnCmdProc *cmdproc,
MsnMessage *msg)
{
MsnSession *session;
PurpleConnection *gc;
GHashTable *table;
session = cmdproc->session;
gc = session->account->gc;
if (strcmp (msg->remote_user, "Hotmail"))
{
pecan_warning ("unofficial message");
return;
}
table = msn_message_get_hashtable_from_body (msg);
{
gchar *mdata;
mdata = g_hash_table_lookup (table, "Mail-Data");
if (mdata)
{
gchar *iu = NULL;
const gchar *start;
const gchar *end;
guint len;
len = strlen (mdata);
start = g_strstr_len (mdata, len, "<IU>");
if (start)
{
start += strlen ("<IU>");
end = g_strstr_len (start, len - (start - mdata), "</IU>");
if (end > start)
iu = g_strndup (start, end - start);
}
if (iu)
{
session->inbox_unread_count = atoi (iu);
g_free (iu);
}
do
{
start = g_strstr_len (start, len - (start - mdata), "<M>");
if (start)
{
start += strlen ("<M>");
end = g_strstr_len (start, len - (start - mdata), "</M>");
if (end > start)
{
gchar *read_set;
#if 0
{
gchar *field;
gchar *tmp;
tmp = pecan_get_xml_field ("N", start, end);
field = purple_mime_decode_field (tmp);
g_print ("field={%s}\n", field);
g_free (field);
g_free (tmp);
}
#endif
read_set = pecan_get_xml_field ("RS", start, end);
if (strcmp (read_set, "0") == 0)
{
gchar *passport;
gchar *message_id;
passport = pecan_get_xml_field ("E", start, end);
message_id = pecan_get_xml_field ("I", start, end);
pecan_oim_session_request (session->oim_session,
passport,
message_id);
g_free (passport);
g_free (message_id);
}
g_free (read_set);
start = end + strlen ("</M>");
}
}
} while (start);
}
if (purple_account_get_check_mail (session->account) &&
session->passport_info.email_enabled == 1)
{
msn_cmdproc_send (cmdproc, "URL", "%s", "INBOX");
}
}
g_hash_table_destroy(table);
}
