static void
connect_cb(gpointer data, gint source, const gchar *error_message)
{
MsnServConn *servconn;
servconn = data;
servconn->connect_data = NULL;
servconn->processing = FALSE;
if (servconn->wasted)
{
if (source >= 0)
close(source);
msn_servconn_destroy(servconn);
return;
}
servconn->fd = source;
if (source >= 0)
{
servconn->connected = TRUE;
/* Someone wants to know we connected. */
servconn->connect_cb(servconn);
servconn->inpa = gaim_input_add(servconn->fd, GAIM_INPUT_READ,
read_cb, data);
}
else
{
msn_servconn_got_error(servconn, MSN_SERVCONN_ERROR_CONNECT);
}
}
void
msn_notification_destroy(MsnNotification *notification)
{
notification->cmdproc->data = NULL;
msn_servconn_set_destroy_cb(notification->servconn, NULL);
msn_servconn_destroy(notification->servconn);
g_free(notification);
}
void
msn_switchboard_destroy(MsnSwitchBoard *swboard)
{
MsnSession *session;
MsnMessage *msg;
GList *l;
if (purple_debug_is_verbose())
purple_debug_info("msn", "switchboard destroy: swboard(%p)\n", swboard);
g_return_if_fail(swboard != NULL);
if (swboard->destroying)
return;
swboard->destroying = TRUE;
if (swboard->reconn_timeout_h > 0)
purple_timeout_remove(swboard->reconn_timeout_h);
/* If it linked us is because its looking for trouble */
while (swboard->slplinks != NULL)
msn_slplink_destroy(swboard->slplinks->data);
/* Destroy the message queue */
while ((msg = g_queue_pop_head(swboard->msg_queue)) != NULL)
{
if (swboard->error != MSN_SB_ERROR_NONE)
{
/* The messages could not be sent due to a switchboard error */
msg_error_helper(swboard->cmdproc, msg,
MSN_MSG_ERROR_SB);
}
msn_message_unref(msg);
}
g_queue_free(swboard->msg_queue);
/* msg_error_helper will both remove the msg from ack_list and
unref it, so we don't need to do either here */
while ((l = swboard->ack_list) != NULL)
msg_error_helper(swboard->cmdproc, l->data, MSN_MSG_ERROR_SB);
g_free(swboard->im_user);
g_free(swboard->auth_key);
g_free(swboard->session_id);
for (; swboard->users; swboard->users = g_list_delete_link(swboard->users, swboard->users))
g_free(swboard->users->data);
session = swboard->session;
session->switches = g_list_remove(session->switches, swboard);
for (l = session->slplinks; l; l = l->next) {
MsnSlpLink *slplink = l->data;
if (slplink->swboard == swboard) slplink->swboard = NULL;
}
#if 0
/* This should never happen or we are in trouble. */
if (swboard->servconn != NULL)
msn_servconn_destroy(swboard->servconn);
#endif
swboard->cmdproc->data = NULL;
msn_servconn_set_disconnect_cb(swboard->servconn, NULL);
msn_servconn_destroy(swboard->servconn);
g_free(swboard);
}
static void
read_cb(gpointer data, gint source, GaimInputCondition cond)
{
MsnServConn *servconn;
MsnSession *session;
char buf[MSN_BUF_LEN];
char *cur, *end, *old_rx_buf;
int len, cur_len;
servconn = data;
session = servconn->session;
len = read(servconn->fd, buf, sizeof(buf) - 1);
if (len < 0 && errno == EAGAIN)
return;
else if (len <= 0)
{
gaim_debug_error("msn", "servconn read error, len: %d error: %s\n", len, strerror(errno));
msn_servconn_got_error(servconn, MSN_SERVCONN_ERROR_READ);
return;
}
buf[len] = '\0';
servconn->rx_buf = g_realloc(servconn->rx_buf, len + servconn->rx_len + 1);
memcpy(servconn->rx_buf + servconn->rx_len, buf, len + 1);
servconn->rx_len += len;
end = old_rx_buf = servconn->rx_buf;
servconn->processing = TRUE;
do
{
cur = end;
if (servconn->payload_len)
{
if (servconn->payload_len > servconn->rx_len)
/* The payload is still not complete. */
break;
cur_len = servconn->payload_len;
end += cur_len;
}
else
{
end = strstr(cur, "\r\n");
if (end == NULL)
/* The command is still not complete. */
break;
*end = '\0';
end += 2;
cur_len = end - cur;
}
servconn->rx_len -= cur_len;
if (servconn->payload_len)
{
msn_cmdproc_process_payload(servconn->cmdproc, cur, cur_len);
servconn->payload_len = 0;
}
else
{
msn_cmdproc_process_cmd_text(servconn->cmdproc, cur);
}
} while (servconn->connected && !servconn->wasted && servconn->rx_len > 0);
if (servconn->connected && !servconn->wasted)
{
if (servconn->rx_len > 0)
servconn->rx_buf = g_memdup(cur, servconn->rx_len);
else
servconn->rx_buf = NULL;
}
servconn->processing = FALSE;
if (servconn->wasted)
msn_servconn_destroy(servconn);
g_free(old_rx_buf);
}
MsnServConn *msn_servconn_process_data(MsnServConn *servconn)
{
char *cur, *end, *old_rx_buf;
int cur_len;
end = old_rx_buf = servconn->rx_buf;
servconn->processing = TRUE;
do
{
cur = end;
if (servconn->payload_len)
{
if (servconn->payload_len > servconn->rx_len)
/* The payload is still not complete. */
break;
cur_len = servconn->payload_len;
end += cur_len;
}
else
{
end = strstr(cur, "\r\n");
if (end == NULL)
/* The command is still not complete. */
break;
*end = '\0';
end += 2;
cur_len = end - cur;
}
servconn->rx_len -= cur_len;
if (servconn->payload_len)
{
msn_cmdproc_process_payload(servconn->cmdproc, cur, cur_len);
servconn->payload_len = 0;
}
else
{
msn_cmdproc_process_cmd_text(servconn->cmdproc, cur);
servconn->payload_len = servconn->cmdproc->last_cmd->payload_len;
}
} while (servconn->connected && !servconn->wasted && servconn->rx_len > 0);
if (servconn->connected && !servconn->wasted)
{
if (servconn->rx_len > 0)
servconn->rx_buf = g_memdup(cur, servconn->rx_len);
else
servconn->rx_buf = NULL;
}
servconn->processing = FALSE;
if (servconn->wasted) {
msn_servconn_destroy(servconn);
servconn = NULL;
}
g_free(old_rx_buf);
return servconn;
}
static void
read_cb(gpointer data, gint source, PurpleInputCondition cond)
{
MsnHttpConn *httpconn;
MsnServConn *servconn;
MsnSession *session;
char buf[MSN_BUF_LEN];
char *cur, *end, *old_rx_buf;
int len, cur_len;
char *result_msg = NULL;
size_t result_len = 0;
gboolean error = FALSE;
httpconn = data;
servconn = NULL;
session = httpconn->session;
len = read(httpconn->fd, buf, sizeof(buf) - 1);
if (len < 0 && errno == EAGAIN)
return;
else if (len <= 0)
{
purple_debug_error("msn", "HTTP: Read error\n");
msn_servconn_got_error(httpconn->servconn, MSN_SERVCONN_ERROR_READ);
return;
}
buf[len] = '\0';
httpconn->rx_buf = g_realloc(httpconn->rx_buf, len + httpconn->rx_len + 1);
memcpy(httpconn->rx_buf + httpconn->rx_len, buf, len + 1);
httpconn->rx_len += len;
if (!msn_httpconn_parse_data(httpconn, httpconn->rx_buf, httpconn->rx_len,
&result_msg, &result_len, &error))
{
/* Either we must wait for more input, or something went wrong */
if (error)
msn_servconn_got_error(httpconn->servconn, MSN_SERVCONN_ERROR_READ);
return;
}
httpconn->servconn->processing = FALSE;
servconn = httpconn->servconn;
if (error)
{
purple_debug_error("msn", "HTTP: Special error\n");
msn_servconn_got_error(httpconn->servconn, MSN_SERVCONN_ERROR_READ);
return;
}
g_free(httpconn->rx_buf);
httpconn->rx_buf = NULL;
httpconn->rx_len = 0;
if (result_len == 0)
{
/* Nothing to do here */
#if 0
purple_debug_info("msn", "HTTP: nothing to do here\n");
#endif
g_free(result_msg);
return;
}
g_free(servconn->rx_buf);
servconn->rx_buf = result_msg;
servconn->rx_len = result_len;
end = old_rx_buf = servconn->rx_buf;
servconn->processing = TRUE;
do
{
cur = end;
if (servconn->payload_len)
{
if (servconn->payload_len > servconn->rx_len)
/* The payload is still not complete. */
break;
cur_len = servconn->payload_len;
end += cur_len;
}
else
{
end = strstr(cur, "\r\n");
if (end == NULL)
/* The command is still not complete. */
break;
*end = '\0';
end += 2;
cur_len = end - cur;
}
servconn->rx_len -= cur_len;
if (servconn->payload_len)
{
msn_cmdproc_process_payload(servconn->cmdproc, cur, cur_len);
servconn->payload_len = 0;
}
else
{
msn_cmdproc_process_cmd_text(servconn->cmdproc, cur);
}
} while (servconn->connected && servconn->rx_len > 0);
if (servconn->connected)
{
if (servconn->rx_len > 0)
servconn->rx_buf = g_memdup(cur, servconn->rx_len);
else
servconn->rx_buf = NULL;
}
servconn->processing = FALSE;
if (servconn->wasted)
msn_servconn_destroy(servconn);
g_free(old_rx_buf);
}
