static void pn_encoder_initialize(void *obj)
{
pn_encoder_t *encoder = (pn_encoder_t *) obj;
encoder->output = NULL;
encoder->size = 0;
encoder->position = NULL;
encoder->error = pn_error();
}
static void
close_impl (PnNode *conn)
{
g_return_if_fail (conn);
if (conn->status == PN_NODE_STATUS_CLOSED) {
pn_log ("already closed: %p", conn);
return;
}
pn_log ("begin");
pn_info ("closing '%s'", conn->name);
pn_debug ("conn=%p,name=%s", conn, conn->name);
conn->status = PN_NODE_STATUS_CLOSED;
g_free (conn->hostname);
conn->hostname = NULL;
if (conn->next) {
pn_node_close (conn->next);
goto leave;
}
#if defined(USE_GIO)
if (conn->socket_conn) {
g_object_unref(conn->socket_conn);
conn->socket_conn = NULL;
}
#else
#if defined(HAVE_LIBPURPLE)
if (conn->connect_data) {
purple_proxy_connect_cancel (conn->connect_data);
conn->connect_data = NULL;
}
#endif
if (conn->read_watch)
{
g_source_remove (conn->read_watch);
conn->read_watch = 0;
}
#endif
if (conn->stream)
{
pn_info ("stream shutdown: %p", conn->stream);
pn_stream_free (conn->stream);
conn->stream = NULL;
}
else
pn_error ("not connected: conn=%p", conn);
leave:
conn->status = PN_NODE_STATUS_CLOSED;
pn_log ("end");
}
pn_scanner_t *pn_scanner()
{
pn_scanner_t *scanner = (pn_scanner_t *) malloc(sizeof(pn_scanner_t));
if (scanner) {
scanner->input = NULL;
scanner->error = pn_error();
}
return scanner;
}
void pn_selector_initialize(void *obj)
{
pn_selector_t *selector = (pn_selector_t *) obj;
selector->iocp = NULL;
selector->selectables = pn_list(PN_WEAKREF, 0);
selector->iocp_descriptors = pn_list(PN_OBJECT, 0);
selector->current = 0;
selector->current_triggered = NULL;
selector->awoken = 0;
selector->error = pn_error();
selector->triggered_list_head = NULL;
selector->triggered_list_tail = NULL;
selector->deadlines_head = NULL;
selector->deadlines_tail = NULL;
}
static GIOStatus
read_impl (PnNode *conn,
gchar *buf,
gsize count,
gsize *ret_bytes_read,
GError **error)
{
GIOStatus status = G_IO_STATUS_NORMAL;
pn_debug ("name=%s", conn->name);
if (conn->next)
{
pn_error ("whaaat");
conn->next->prev = conn;
status = pn_node_read (conn->next, buf, count, ret_bytes_read, error);
conn->next->prev = NULL;
}
else
{
GError *tmp_error = NULL;
gsize bytes_read = 0;
pn_debug ("stream=%p", conn->stream);
status = pn_stream_read (conn->stream, buf, count, &bytes_read, &tmp_error);
if (status != G_IO_STATUS_NORMAL)
{
pn_info ("not normal: status=%d (%s)",
status, status_to_str (status));
}
pn_log ("bytes_read=%zu", bytes_read);
if (ret_bytes_read)
*ret_bytes_read = bytes_read;
if (tmp_error)
{
conn->error = g_error_copy (tmp_error);
g_propagate_error (error, tmp_error);
}
}
return status;
}
void pn_io_initialize(void *obj)
{
pn_io_t *io = (pn_io_t *) obj;
io->error = pn_error();
io->wouldblock = false;
io->trace = pn_env_bool("PN_TRACE_DRV");
/* Request WinSock 2.2 */
WORD wsa_ver = MAKEWORD(2, 2);
WSADATA unused;
int err = WSAStartup(wsa_ver, &unused);
if (err) {
pni_win32_error(io->error, "WSAStartup", WSAGetLastError());
fprintf(stderr, "Can't load WinSock: %s\n", pn_error_text(io->error));
}
io->iocp = pni_iocp();
}
pn_messenger_t *pn_messenger(const char *name)
{
pn_messenger_t *m = malloc(sizeof(pn_messenger_t));
if (m) {
m->name = build_name(name);
m->timeout = -1;
m->driver = pn_driver();
m->size = 0;
m->listeners = 0;
m->credit = 0;
m->next_tag = 0;
m->error = pn_error();
}
return m;
}
iocpdesc_t *pni_iocpdesc_create(iocp_t *iocp, pn_socket_t s, bool external) {
assert (s != INVALID_SOCKET);
assert(!pni_iocpdesc_map_get(iocp, s));
bool listening = is_listener_socket(s);
iocpdesc_t *iocpd = pni_iocpdesc(s);
iocpd->iocp = iocp;
if (iocpd) {
iocpd->external = external;
iocpd->error = pn_error();
if (listening) {
iocpd->acceptor = pni_acceptor(iocpd);
} else {
iocpd->pipeline = pni_write_pipeline(iocpd);
iocpd->read_result = read_result(iocpd);
}
pni_iocpdesc_map_push(iocpd);
}
return iocpd;
}
static inline PecanStatus
util_status_from_session (MsnSession *session)
{
PurpleAccount *account;
PecanStatus msnstatus;
PurplePresence *presence;
PurpleStatus *status;
const gchar *status_id;
account = msn_session_get_user_data (session);
presence = purple_account_get_presence (account);
status = purple_presence_get_active_status (presence);
status_id = purple_status_get_id (status);
if (strcmp (status_id, "available") == 0)
msnstatus = PN_STATUS_ONLINE;
else if (strcmp (status_id, "away") == 0)
msnstatus = PN_STATUS_AWAY;
else if (strcmp (status_id, "brb") == 0)
msnstatus = PN_STATUS_BRB;
else if (strcmp (status_id, "busy") == 0)
msnstatus = PN_STATUS_BUSY;
else if (strcmp (status_id, "phone") == 0)
msnstatus = PN_STATUS_PHONE;
else if (strcmp (status_id, "lunch") == 0)
msnstatus = PN_STATUS_LUNCH;
else if (strcmp (status_id, "invisible") == 0)
msnstatus = PN_STATUS_HIDDEN;
else if (strcmp (status_id, "online") == 0)
{
if (purple_presence_is_idle (presence))
msnstatus = PN_STATUS_IDLE;
else
msnstatus = PN_STATUS_ONLINE;
}
else
{
pn_error ("wrong: status_id=[%s]", status_id);
msnstatus = PN_STATUS_WRONG;
}
return msnstatus;
}
static void
lsg_cmd (MsnCmdProc *cmdproc,
MsnCommand *cmd)
{
MsnSession *session = cmdproc->session;
char *name;
const gchar *group_guid;
name = pn_url_decode (cmd->params[0]);
group_guid = cmd->params[1];
if (strcmp(name, MSN_NULL_GROUP_NAME) == 0) {
pn_error("Invalid group name, ignoring");
goto leave;
}
pn_group_new (session->contactlist, name, group_guid);
if (!purple_find_group (name))
{
PurpleGroup *g = purple_group_new (name);
purple_blist_add_group (g, NULL);
}
/* Group of ungroupped buddies */
if (!group_guid)
{
if (session->sync->total_users == 0)
{
cmdproc->cbs_table = session->sync->old_cbs_table;
msn_session_finish_login (session);
msn_sync_destroy (session->sync);
session->sync = NULL;
}
}
leave:
g_free (name);
}
gboolean
msn_session_connect (MsnSession *session,
const char *host,
int port)
{
g_return_val_if_fail (session, FALSE);
g_return_val_if_fail (!session->connected, TRUE);
session->connected = TRUE;
if (!session->notification)
{
pn_error ("this shouldn't happen");
g_return_val_if_reached (FALSE);
}
if (msn_notification_connect (session->notification, host, port))
{
return TRUE;
}
return FALSE;
}
static GIOStatus
write_impl (PnNode *conn,
const gchar *buf,
gsize count,
gsize *ret_bytes_written,
GError **error)
{
GIOStatus status = G_IO_STATUS_NORMAL;
pn_debug ("name=%s", conn->name);
if (conn->next)
{
PnNode *next;
next = conn->next;
/* conn->next has already a ref from conn, but let's just be sure and
* ref anyway */
g_object_ref (next);
next->prev = conn;
status = pn_node_write (next, buf, count, ret_bytes_written, error);
next->prev = NULL;
g_object_unref (next);
}
else
{
GError *tmp_error = NULL;
gsize bytes_written = 0;
pn_debug ("stream=%p", conn->stream);
status = pn_stream_write_full (conn->stream, buf, count, &bytes_written, &tmp_error);
pn_log ("bytes_written=%zu", bytes_written);
if (status == G_IO_STATUS_NORMAL)
{
if (bytes_written < count)
{
/* This shouldn't happen, right? */
/* It doesn't seem to happen, but keep checking for now. */
pn_error ("write check: %zu < %zu", bytes_written, count);
}
}
else
{
pn_warning ("not normal: status=%d (%s)",
status, status_to_str (status));
}
if (ret_bytes_written)
*ret_bytes_written = bytes_written;
if (tmp_error)
{
conn->error = g_error_copy (tmp_error);
g_propagate_error (error, tmp_error);
}
}
return status;
}
static gboolean
http_poll (gpointer data)
{
PnNode *conn;
PnHttpServer *http_conn;
GIOStatus status = G_IO_STATUS_NORMAL;
GError *tmp_error = NULL;
gsize bytes_written = 0;
static guint count = 0;
gchar *header;
gchar *params;
gchar *auth = NULL;
g_return_val_if_fail (data != NULL, FALSE);
conn = PN_NODE (data);
http_conn = PN_HTTP_SERVER (data);
pn_debug ("stream=%p", conn->stream);
if (!http_conn->cur)
return TRUE;
g_return_val_if_fail (http_conn->cur, FALSE);
count++;
/* Don't poll if we already sent something, unless we have been waiting for
* too long; a disconnection might have happened. */
if (http_conn->waiting_response && count < 10)
{
/* There's no need to poll if we're already waiting for a response */
pn_debug ("waiting for response");
return TRUE;
}
#ifdef HAVE_LIBPURPLE
auth = get_auth(conn);
#endif /* HAVE_LIBPURPLE */
params = g_strdup_printf ("Action=poll&SessionID=%s",
(gchar *) http_conn->cur->foo_data);
header = g_strdup_printf ("POST http://%s/gateway/gateway.dll?%s HTTP/1.1\r\n"
"Accept: */*\r\n"
"User-Agent: MSMSGS\r\n"
"Host: %s\r\n"
"%s" /* Proxy auth */
"Proxy-Connection: Keep-Alive\r\n"
"Connection: Keep-Alive\r\n"
"Pragma: no-cache\r\n"
"Cache-Control: no-cache\r\n"
"Content-Type: application/x-msn-messenger\r\n"
"Content-Length: 0\r\n\r\n",
http_conn->gateway,
params,
http_conn->gateway,
auth ? auth : "");
#ifdef PECAN_DEBUG_HTTP
pn_debug ("header=[%s]", header);
#endif
g_free (params);
status = pn_stream_write_full (conn->stream, header, strlen (header), &bytes_written, &tmp_error);
g_free (header);
http_conn->waiting_response = TRUE;
pn_timer_stop (http_conn->timer);
if (status == G_IO_STATUS_NORMAL)
{
status = pn_stream_flush (conn->stream, &tmp_error);
if (status == G_IO_STATUS_AGAIN) {
http_conn->last_flush = status;
http_conn->write_watch = g_io_add_watch(conn->stream->channel,
G_IO_OUT, write_cb, http_conn);
/* fake status */
status = G_IO_STATUS_NORMAL;
}
if (status == G_IO_STATUS_NORMAL)
pn_log ("bytes_written=%zu", bytes_written);
}
if (status != G_IO_STATUS_NORMAL)
{
PnNodeClass *class;
pn_error ("not normal: status=%d", status);
class = g_type_class_peek (PN_NODE_TYPE);
g_signal_emit (G_OBJECT (conn), class->error_sig, 0, conn);
return FALSE;
}
void pn_io_initialize(void *obj)
{
pn_io_t *io = (pn_io_t *) obj;
io->error = pn_error();
io->wouldblock = false;
}
