diff -r 39a4efae983c -r 9af807a5c9e7 src/protocols/sametime/meanwhile/session.c --- a/src/protocols/sametime/meanwhile/session.c Fri Jan 20 00:19:53 2006 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1206 +0,0 @@ - -/* - Meanwhile - Unofficial Lotus Sametime Community Client Library - Copyright (C) 2004 Christopher (siege) O'Brien - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library 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 - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public - License along with this library; if not, write to the Free - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -*/ - -#include -#include - -#include "mw_channel.h" -#include "mw_cipher.h" -#include "mw_debug.h" -#include "mw_error.h" -#include "mw_message.h" -#include "mw_service.h" -#include "mw_session.h" -#include "mw_util.h" - - -/** the hash table key for a service, for mwSession::services */ -#define SERVICE_KEY(srvc) mwService_getType(srvc) - -/** the hash table key for a cipher, for mwSession::ciphers */ -#define CIPHER_KEY(ciph) mwCipher_getType(ciph) - - -#define GPOINTER(val) (GUINT_TO_POINTER((guint) (val))) -#define GUINT(val) (GPOINTER_TO_UINT((val))) - - -struct mwSession { - - /** provides I/O and callback functions */ - struct mwSessionHandler *handler; - - enum mwSessionState state; /**< session state */ - gpointer state_info; /**< additional state info */ - - /* input buffering for an incoming message */ - guchar *buf; /**< buffer for incoming message data */ - gsize buf_len; /**< length of buf */ - gsize buf_used; /**< offset to last-used byte of buf */ - - struct mwLoginInfo login; /**< login information */ - struct mwUserStatus status; /**< user status */ - struct mwPrivacyInfo privacy; /**< privacy list */ - - /** the collection of channels */ - struct mwChannelSet *channels; - - /** the collection of services, keyed to guint32 service id */ - GHashTable *services; - - /** the collection of ciphers, keyed to guint16 cipher type */ - GHashTable *ciphers; - - /** arbitrary key:value pairs */ - GHashTable *attributes; - - /** optional user data */ - struct mw_datum client_data; -}; - - -static void property_set(struct mwSession *s, const char *key, - gpointer val, GDestroyNotify clean) { - - g_hash_table_insert(s->attributes, g_strdup(key), - mw_datum_new(val, clean)); -} - - -static gpointer property_get(struct mwSession *s, const char *key) { - struct mw_datum *p = g_hash_table_lookup(s->attributes, key); - return p? p->data: NULL; -} - - -static void property_del(struct mwSession *s, const char *key) { - g_hash_table_remove(s->attributes, key); -} - - -/** - set up the default properties for a newly created session -*/ -static void session_defaults(struct mwSession *s) { - property_set(s, mwSession_CLIENT_VER_MAJOR, - GPOINTER(MW_PROTOCOL_VERSION_MAJOR), NULL); - - property_set(s, mwSession_CLIENT_VER_MINOR, - GPOINTER(MW_PROTOCOL_VERSION_MINOR), NULL); - - property_set(s, mwSession_CLIENT_TYPE_ID, - GPOINTER(mwLogin_MEANWHILE), NULL); -} - - -struct mwSession *mwSession_new(struct mwSessionHandler *handler) { - struct mwSession *s; - - g_return_val_if_fail(handler != NULL, NULL); - - /* consider io_write and io_close to be absolute necessities */ - g_return_val_if_fail(handler->io_write != NULL, NULL); - g_return_val_if_fail(handler->io_close != NULL, NULL); - - s = g_new0(struct mwSession, 1); - - s->state = mwSession_STOPPED; - - s->handler = handler; - - s->channels = mwChannelSet_new(s); - s->services = map_guint_new(); - s->ciphers = map_guint_new(); - - s->attributes = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, - (GDestroyNotify) mw_datum_free); - - session_defaults(s); - - return s; -} - - -/** free and reset the session buffer */ -static void session_buf_free(struct mwSession *s) { - g_return_if_fail(s != NULL); - - g_free(s->buf); - s->buf = NULL; - s->buf_len = 0; - s->buf_used = 0; -} - - -/** a polite string version of the session state enum */ -static const char *state_str(enum mwSessionState state) { - switch(state) { - case mwSession_STARTING: return "starting"; - case mwSession_HANDSHAKE: return "handshake sent"; - case mwSession_HANDSHAKE_ACK: return "handshake acknowledged"; - case mwSession_LOGIN: return "login sent"; - case mwSession_LOGIN_REDIR: return "login redirected"; - case mwSession_LOGIN_CONT: return "forcing login"; - case mwSession_LOGIN_ACK: return "login acknowledged"; - case mwSession_STARTED: return "started"; - case mwSession_STOPPING: return "stopping"; - case mwSession_STOPPED: return "stopped"; - - case mwSession_UNKNOWN: /* fall-through */ - default: return "UNKNOWN"; - } -} - - -void mwSession_free(struct mwSession *s) { - struct mwSessionHandler *h; - - g_return_if_fail(s != NULL); - - if(! mwSession_isStopped(s)) { - g_debug("session is not stopped (state: %s), proceeding with free", - state_str(s->state)); - } - - h = s->handler; - if(h && h->clear) h->clear(s); - s->handler = NULL; - - session_buf_free(s); - - mwChannelSet_free(s->channels); - g_hash_table_destroy(s->services); - g_hash_table_destroy(s->ciphers); - g_hash_table_destroy(s->attributes); - - mwLoginInfo_clear(&s->login); - mwUserStatus_clear(&s->status); - mwPrivacyInfo_clear(&s->privacy); - - g_free(s); -} - - -/** write data to the session handler */ -static int io_write(struct mwSession *s, const guchar *buf, gsize len) { - g_return_val_if_fail(s != NULL, -1); - g_return_val_if_fail(s->handler != NULL, -1); - g_return_val_if_fail(s->handler->io_write != NULL, -1); - - return s->handler->io_write(s, buf, len); -} - - -/** close the session handler */ -static void io_close(struct mwSession *s) { - g_return_if_fail(s != NULL); - g_return_if_fail(s->handler != NULL); - g_return_if_fail(s->handler->io_close != NULL); - - s->handler->io_close(s); -} - - -static void state(struct mwSession *s, enum mwSessionState state, - gpointer info) { - - struct mwSessionHandler *sh; - - g_return_if_fail(s != NULL); - g_return_if_fail(s->handler != NULL); - - if(mwSession_isState(s, state)) return; - - s->state = state; - s->state_info = info; - - switch(state) { - case mwSession_STOPPING: - case mwSession_STOPPED: - g_message("session state: %s (0x%08x)", state_str(state), - GPOINTER_TO_UINT(info)); - break; - - case mwSession_LOGIN_REDIR: - g_message("session state: %s (%s)", state_str(state), - (char *)info); - break; - - default: - g_message("session state: %s", state_str(state)); - } - - sh = s->handler; - if(sh && sh->on_stateChange) - sh->on_stateChange(s, state, info); -} - - -void mwSession_start(struct mwSession *s) { - struct mwMsgHandshake *msg; - int ret; - - g_return_if_fail(s != NULL); - g_return_if_fail(mwSession_isStopped(s)); - - if(mwSession_isStarted(s) || mwSession_isStarting(s)) { - g_debug("attempted to start session that is already started/starting"); - return; - } - - state(s, mwSession_STARTING, 0); - - msg = (struct mwMsgHandshake *) mwMessage_new(mwMessage_HANDSHAKE); - msg->major = GUINT(property_get(s, mwSession_CLIENT_VER_MAJOR)); - msg->minor = GUINT(property_get(s, mwSession_CLIENT_VER_MINOR)); - msg->login_type = GUINT(property_get(s, mwSession_CLIENT_TYPE_ID)); - - msg->loclcalc_addr = GUINT(property_get(s, mwSession_CLIENT_IP)); - - if(msg->major >= 0x001e && msg->minor >= 0x001d) { - msg->unknown_a = 0x0100; - msg->local_host = (char *) property_get(s, mwSession_CLIENT_HOST); - } - - ret = mwSession_send(s, MW_MESSAGE(msg)); - mwMessage_free(MW_MESSAGE(msg)); - - if(ret) { - mwSession_stop(s, CONNECTION_BROKEN); - } else { - state(s, mwSession_HANDSHAKE, 0); - } -} - - -void mwSession_stop(struct mwSession *s, guint32 reason) { - GList *list, *l = NULL; - struct mwMsgChannelDestroy *msg; - - g_return_if_fail(s != NULL); - - if(mwSession_isStopped(s) || mwSession_isStopping(s)) { - g_debug("attempted to stop session that is already stopped/stopping"); - return; - } - - state(s, mwSession_STOPPING, GUINT_TO_POINTER(reason)); - - for(list = l = mwSession_getServices(s); l; l = l->next) - mwService_stop(MW_SERVICE(l->data)); - g_list_free(list); - - msg = (struct mwMsgChannelDestroy *) - mwMessage_new(mwMessage_CHANNEL_DESTROY); - - msg->head.channel = MW_MASTER_CHANNEL_ID; - msg->reason = reason; - - /* don't care if this fails, we're closing the connection anyway */ - mwSession_send(s, MW_MESSAGE(msg)); - mwMessage_free(MW_MESSAGE(msg)); - - session_buf_free(s); - - /* close the connection */ - io_close(s); - - state(s, mwSession_STOPPED, GUINT_TO_POINTER(reason)); -} - - -/** compose authentication information into an opaque based on the - password, encrypted via RC2/40 */ -static void compose_auth_rc2_40(struct mwOpaque *auth, const char *pass) { - guchar iv[8], key[5]; - struct mwOpaque a, b, z; - struct mwPutBuffer *p; - - /* get an IV and a random five-byte key */ - mwIV_init(iv); - mwKeyRandom(key, 5); - - /* the opaque with the key */ - a.len = 5; - a.data = key; - - /* the opaque to receive the encrypted pass */ - b.len = 0; - b.data = NULL; - - /* the plain-text pass dressed up as an opaque */ - z.len = strlen(pass); - z.data = (guchar *) pass; - - /* the opaque with the encrypted pass */ - mwEncrypt(a.data, a.len, iv, &z, &b); - - /* an opaque containing the other two opaques */ - p = mwPutBuffer_new(); - mwOpaque_put(p, &a); - mwOpaque_put(p, &b); - mwPutBuffer_finalize(auth, p); - - /* this is the only one to clear, as the other uses a static buffer */ - mwOpaque_clear(&b); -} - - -static void compose_auth_rc2_128(struct mwOpaque *auth, const char *pass, - guint32 magic, struct mwOpaque *rkey) { - - guchar iv[8]; - struct mwOpaque a, b, c; - struct mwPutBuffer *p; - - struct mwMpi *private, *public; - struct mwMpi *remote; - struct mwMpi *shared; - - private = mwMpi_new(); - public = mwMpi_new(); - remote = mwMpi_new(); - shared = mwMpi_new(); - - mwIV_init(iv); - - mwMpi_randDHKeypair(private, public); - mwMpi_import(remote, rkey); - mwMpi_calculateDHShared(shared, remote, private); - - /* put the password in opaque a */ - p = mwPutBuffer_new(); - guint32_put(p, magic); - mwString_put(p, pass); - mwPutBuffer_finalize(&a, p); - - /* put the shared key in opaque b */ - mwMpi_export(shared, &b); - - /* encrypt the password (a) using the shared key (b), put the result - in opaque c */ - mwEncrypt(b.data+(b.len-16), 16, iv, &a, &c); - - /* don't need the shared key anymore, re-use opaque (b) as the - export of the public key */ - mwOpaque_clear(&b); - mwMpi_export(public, &b); - - p = mwPutBuffer_new(); - guint16_put(p, 0x0001); /* XXX: unknown */ - mwOpaque_put(p, &b); - mwOpaque_put(p, &c); - mwPutBuffer_finalize(auth, p); - - mwOpaque_clear(&a); - mwOpaque_clear(&b); - mwOpaque_clear(&c); - - mwMpi_free(private); - mwMpi_free(public); - mwMpi_free(remote); - mwMpi_free(shared); -} - - -/** handle the receipt of a handshake_ack message by sending the login - message */ -static void HANDSHAKE_ACK_recv(struct mwSession *s, - struct mwMsgHandshakeAck *msg) { - struct mwMsgLogin *log; - int ret; - - g_return_if_fail(s != NULL); - g_return_if_fail(msg != NULL); - g_return_if_fail(mwSession_isState(s, mwSession_HANDSHAKE) || - mwSession_isState(s, mwSession_LOGIN_CONT)); - - if(mwSession_isState(s, mwSession_LOGIN_CONT)) { - /* this is a login continuation, don't re-send the login. We - should receive a login ack in a moment */ - - state(s, mwSession_HANDSHAKE_ACK, 0); - state(s, mwSession_LOGIN, 0); - return; - - } else { - state(s, mwSession_HANDSHAKE_ACK, 0); - } - - /* record the major/minor versions from the server */ - property_set(s, mwSession_SERVER_VER_MAJOR, GPOINTER(msg->major), NULL); - property_set(s, mwSession_SERVER_VER_MINOR, GPOINTER(msg->minor), NULL); - - /* compose the login message */ - log = (struct mwMsgLogin *) mwMessage_new(mwMessage_LOGIN); - log->login_type = GUINT(property_get(s, mwSession_CLIENT_TYPE_ID)); - log->name = g_strdup(property_get(s, mwSession_AUTH_USER_ID)); - - /** @todo default to password for now. later use token optionally */ - { - const char *pw; - pw = (const char *) property_get(s, mwSession_AUTH_PASSWORD); - - if(msg->data.len >= 64) { - /* good login encryption */ - log->auth_type = mwAuthType_RC2_128; - compose_auth_rc2_128(&log->auth_data, pw, msg->magic, &msg->data); - - } else { - /* BAD login encryption */ - log->auth_type = mwAuthType_RC2_40; - compose_auth_rc2_40(&log->auth_data, pw); - } - } - - /* send the login message */ - ret = mwSession_send(s, MW_MESSAGE(log)); - mwMessage_free(MW_MESSAGE(log)); - - if(! ret) { - /* sent login OK, set state appropriately */ - state(s, mwSession_LOGIN, 0); - } -} - - -/** handle the receipt of a login_ack message. This completes the - startup sequence for the session */ -static void LOGIN_ACK_recv(struct mwSession *s, - struct mwMsgLoginAck *msg) { - GList *ll, *l; - - g_return_if_fail(s != NULL); - g_return_if_fail(msg != NULL); - g_return_if_fail(mwSession_isState(s, mwSession_LOGIN)); - - /* store the login information in the session */ - mwLoginInfo_clear(&s->login); - mwLoginInfo_clone(&s->login, &msg->login); - - state(s, mwSession_LOGIN_ACK, 0); - - /* start up our services */ - for(ll = l = mwSession_getServices(s); l; l = l->next) { - mwService_start(l->data); - } - g_list_free(ll); - - /* @todo any further startup stuff? */ - - state(s, mwSession_STARTED, 0); -} - - -static void CHANNEL_CREATE_recv(struct mwSession *s, - struct mwMsgChannelCreate *msg) { - struct mwChannel *chan; - chan = mwChannel_newIncoming(s->channels, msg->channel); - - /* hand off to channel */ - mwChannel_recvCreate(chan, msg); -} - - -static void CHANNEL_ACCEPT_recv(struct mwSession *s, - struct mwMsgChannelAccept *msg) { - struct mwChannel *chan; - chan = mwChannel_find(s->channels, msg->head.channel); - - g_return_if_fail(chan != NULL); - - /* hand off to channel */ - mwChannel_recvAccept(chan, msg); -} - - -static void CHANNEL_DESTROY_recv(struct mwSession *s, - struct mwMsgChannelDestroy *msg) { - - /* the server can indicate that we should close the session by - destroying the zero channel */ - if(msg->head.channel == MW_MASTER_CHANNEL_ID) { - mwSession_stop(s, msg->reason); - - } else { - struct mwChannel *chan; - chan = mwChannel_find(s->channels, msg->head.channel); - - /* we don't have any such channel... so I guess we destroyed it. - This is to remove a warning from timing errors when two clients - both try to close a channel at about the same time. */ - if(! chan) return; - - /* hand off to channel */ - mwChannel_recvDestroy(chan, msg); - } -} - - -static void CHANNEL_SEND_recv(struct mwSession *s, - struct mwMsgChannelSend *msg) { - struct mwChannel *chan; - chan = mwChannel_find(s->channels, msg->head.channel); - - /* if we don't have any such channel, we're certainly not going to - accept data from it */ - if(! chan) return; - - /* hand off to channel */ - mwChannel_recv(chan, msg); -} - - -static void SET_PRIVACY_LIST_recv(struct mwSession *s, - struct mwMsgSetPrivacyList *msg) { - struct mwSessionHandler *sh = s->handler; - - g_info("SET_PRIVACY_LIST"); - - mwPrivacyInfo_clear(&s->privacy); - mwPrivacyInfo_clone(&s->privacy, &msg->privacy); - - if(sh && sh->on_setPrivacyInfo) - sh->on_setPrivacyInfo(s); -} - - -static void SET_USER_STATUS_recv(struct mwSession *s, - struct mwMsgSetUserStatus *msg) { - struct mwSessionHandler *sh = s->handler; - - mwUserStatus_clear(&s->status); - mwUserStatus_clone(&s->status, &msg->status); - - if(sh && sh->on_setUserStatus) - sh->on_setUserStatus(s); -} - - -static void SENSE_SERVICE_recv(struct mwSession *s, - struct mwMsgSenseService *msg) { - struct mwService *srvc; - - srvc = mwSession_getService(s, msg->service); - if(srvc) mwService_start(srvc); -} - - -static void ADMIN_recv(struct mwSession *s, struct mwMsgAdmin *msg) { - struct mwSessionHandler *sh = s->handler; - - if(sh && sh->on_admin) - sh->on_admin(s, msg->text); -} - - -static void ANNOUNCE_recv(struct mwSession *s, struct mwMsgAnnounce *msg) { - struct mwSessionHandler *sh = s->handler; - - if(sh && sh->on_announce) - sh->on_announce(s, &msg->sender, msg->may_reply, msg->text); -} - - -static void LOGIN_REDIRECT_recv(struct mwSession *s, - struct mwMsgLoginRedirect *msg) { - - state(s, mwSession_LOGIN_REDIR, msg->host); -} - - -#define CASE(var, type) \ -case mwMessage_ ## var: \ - var ## _recv(s, (struct type *) msg); \ - break; - - -static void session_process(struct mwSession *s, - const guchar *buf, gsize len) { - - struct mwOpaque o = { .len = len, .data = (guchar *) buf }; - struct mwGetBuffer *b; - struct mwMessage *msg; - - g_return_if_fail(s != NULL); - g_return_if_fail(buf != NULL); - - /* ignore zero-length messages */ - if(len == 0) return; - - /* wrap up buf */ - b = mwGetBuffer_wrap(&o); - - /* attempt to parse the message. */ - msg = mwMessage_get(b); - - if(mwGetBuffer_error(b)) { - mw_mailme_opaque(&o, "parsing of message failed"); - } - - mwGetBuffer_free(b); - - g_return_if_fail(msg != NULL); - - /* handle each of the appropriate incoming types of mwMessage */ - switch(msg->type) { - CASE(HANDSHAKE_ACK, mwMsgHandshakeAck); - CASE(LOGIN_REDIRECT, mwMsgLoginRedirect); - CASE(LOGIN_ACK, mwMsgLoginAck); - CASE(CHANNEL_CREATE, mwMsgChannelCreate); - CASE(CHANNEL_DESTROY, mwMsgChannelDestroy); - CASE(CHANNEL_SEND, mwMsgChannelSend); - CASE(CHANNEL_ACCEPT, mwMsgChannelAccept); - CASE(SET_PRIVACY_LIST, mwMsgSetPrivacyList); - CASE(SET_USER_STATUS, mwMsgSetUserStatus); - CASE(SENSE_SERVICE, mwMsgSenseService); - CASE(ADMIN, mwMsgAdmin); - CASE(ANNOUNCE, mwMsgAnnounce); - - default: - g_warning("unknown message type 0x%04x, no handler", msg->type); - } - - mwMessage_free(msg); -} - - -#undef CASE - - -#define ADVANCE(b, n, count) { b += count; n -= count; } - - -/* handle input to complete an existing buffer */ -static gsize session_recv_cont(struct mwSession *s, - const guchar *b, gsize n) { - - /* determine how many bytes still required */ - gsize x = s->buf_len - s->buf_used; - - /* g_message(" session_recv_cont: session = %p, b = %p, n = %u", - s, b, n); */ - - if(n < x) { - /* not quite enough; still need some more */ - memcpy(s->buf+s->buf_used, b, n); - s->buf_used += n; - return 0; - - } else { - /* enough to finish the buffer, at least */ - memcpy(s->buf+s->buf_used, b, x); - ADVANCE(b, n, x); - - if(s->buf_len == 4) { - /* if only the length bytes were being buffered, we'll now try - to complete an actual message */ - - struct mwOpaque o = { 4, s->buf }; - struct mwGetBuffer *gb = mwGetBuffer_wrap(&o); - x = guint32_peek(gb); - mwGetBuffer_free(gb); - - if(n < x) { - /* there isn't enough to meet the demands of the length, so - we'll buffer it for next time */ - - guchar *t; - x += 4; - t = (guchar *) g_malloc(x); - memcpy(t, s->buf, 4); - memcpy(t+4, b, n); - - session_buf_free(s); - - s->buf = t; - s->buf_len = x; - s->buf_used = n + 4; - return 0; - - } else { - /* there's enough (maybe more) for a full message. don't need - the old session buffer (which recall, was only the length - bytes) any more */ - - session_buf_free(s); - session_process(s, b, x); - ADVANCE(b, n, x); - } - - } else { - /* process the now-complete buffer. remember to skip the first - four bytes, since they're just the size count */ - session_process(s, s->buf+4, s->buf_len-4); - session_buf_free(s); - } - } - - return n; -} - - -/* handle input when there's nothing previously buffered */ -static gsize session_recv_empty(struct mwSession *s, - const guchar *b, gsize n) { - - struct mwOpaque o = { n, (guchar *) b }; - struct mwGetBuffer *gb; - gsize x; - - if(n < 4) { - /* uh oh. less than four bytes means we've got an incomplete - length indicator. Have to buffer to get the rest of it. */ - s->buf = (guchar *) g_malloc0(4); - memcpy(s->buf, b, n); - s->buf_len = 4; - s->buf_used = n; - return 0; - } - - /* peek at the length indicator. if it's a zero length message, - don't process, just skip it */ - gb = mwGetBuffer_wrap(&o); - x = guint32_peek(gb); - mwGetBuffer_free(gb); - if(! x) return n - 4; - - if(n < (x + 4)) { - /* if the total amount of data isn't enough to cover the length - bytes and the length indicated by those bytes, then we'll need - to buffer. This is where the DOS mentioned below in - session_recv takes place */ - - x += 4; - s->buf = (guchar *) g_malloc(x); - memcpy(s->buf, b, n); - s->buf_len = x; - s->buf_used = n; - return 0; - - } else { - /* advance past length bytes */ - ADVANCE(b, n, 4); - - /* process and advance */ - session_process(s, b, x); - ADVANCE(b, n, x); - - /* return left-over count */ - return n; - } -} - - -static gsize session_recv(struct mwSession *s, - const guchar *b, gsize n) { - - /* This is messy and kind of confusing. I'd like to simplify it at - some point, but the constraints are as follows: - - - buffer up to a single full message on the session buffer - - buffer must contain the four length bytes - - the four length bytes indicate how much we'll need to buffer - - the four length bytes might not arrive all at once, so it's - possible that we'll need to buffer to get them. - - since our buffering includes the length bytes, we know we - still have an incomplete length if the buffer length is only - four. */ - - /** @todo we should allow a compiled-in upper limit to message - sizes, and just drop messages over that size. However, to do that - we'd need to keep track of the size of a message and keep - dropping bytes until we'd fulfilled the entire length. eg: if we - receive a message size of 10MB, we need to pass up exactly 10MB - before it's safe to start processing the rest as a new - message. As it stands, a malicious packet from the server can run - us out of memory by indicating it's going to send us some - obscenely long message (even if it never actually sends it) */ - - /* g_message(" session_recv: session = %p, b = %p, n = %u", - s, b, n); */ - - if(s->buf_len == 0) { - while(n && (*b & 0x80)) { - /* keep-alive and series bytes are ignored */ - ADVANCE(b, n, 1); - } - } - - if(n == 0) { - return 0; - - } else if(s->buf_len > 0) { - return session_recv_cont(s, b, n); - - } else { - return session_recv_empty(s, b, n); - } -} - - -#undef ADVANCE - - -void mwSession_recv(struct mwSession *s, const guchar *buf, gsize n) { - guchar *b = (guchar *) buf; - gsize remain = 0; - - g_return_if_fail(s != NULL); - - while(n > 0) { - remain = session_recv(s, b, n); - b += (n - remain); - n = remain; - } -} - - -int mwSession_send(struct mwSession *s, struct mwMessage *msg) { - struct mwPutBuffer *b; - struct mwOpaque o; - int ret = 0; - - g_return_val_if_fail(s != NULL, -1); - - /* writing nothing is easy */ - if(! msg) return 0; - - /* first we render the message into an opaque */ - b = mwPutBuffer_new(); - mwMessage_put(b, msg); - mwPutBuffer_finalize(&o, b); - - /* then we render the opaque into... another opaque! */ - b = mwPutBuffer_new(); - mwOpaque_put(b, &o); - mwOpaque_clear(&o); - mwPutBuffer_finalize(&o, b); - - /* then we use that opaque's data and length to write to the socket */ - ret = io_write(s, o.data, o.len); - mwOpaque_clear(&o); - - /* ensure we could actually write the message */ - if(! ret) { - - /* special case, as the server doesn't always respond to user - status messages. Thus, we trigger the event when we send the - messages as well as when we receive them */ - if(msg->type == mwMessage_SET_USER_STATUS) { - SET_USER_STATUS_recv(s, (struct mwMsgSetUserStatus *) msg); - } - } - - return ret; -} - - -int mwSession_sendKeepalive(struct mwSession *s) { - const guchar b = 0x80; - - g_return_val_if_fail(s != NULL, -1); - return io_write(s, &b, 1); -} - - -int mwSession_forceLogin(struct mwSession *s) { - struct mwMsgLoginContinue *msg; - int ret; - - g_return_val_if_fail(s != NULL, -1); - g_return_val_if_fail(mwSession_isState(s, mwSession_LOGIN_REDIR), -1); - - state(s, mwSession_LOGIN_CONT, 0x00); - - msg = (struct mwMsgLoginContinue *) - mwMessage_new(mwMessage_LOGIN_CONTINUE); - - ret = mwSession_send(s, MW_MESSAGE(msg)); - mwMessage_free(MW_MESSAGE(msg)); - - return ret; -} - - -int mwSession_sendAnnounce(struct mwSession *s, gboolean may_reply, - const char *text, const GList *recipients) { - - struct mwMsgAnnounce *msg; - int ret; - - g_return_val_if_fail(s != NULL, -1); - g_return_val_if_fail(mwSession_isStarted(s), -1); - - msg = (struct mwMsgAnnounce *) mwMessage_new(mwMessage_ANNOUNCE); - - msg->recipients = (GList *) recipients; - msg->may_reply = may_reply; - msg->text = g_strdup(text); - - ret = mwSession_send(s, MW_MESSAGE(msg)); - - msg->recipients = NULL; /* don't kill our recipients param */ - mwMessage_free(MW_MESSAGE(msg)); - - return ret; -} - - -struct mwSessionHandler *mwSession_getHandler(struct mwSession *s) { - g_return_val_if_fail(s != NULL, NULL); - return s->handler; -} - - -struct mwLoginInfo *mwSession_getLoginInfo(struct mwSession *s) { - g_return_val_if_fail(s != NULL, NULL); - return &s->login; -} - - -int mwSession_setPrivacyInfo(struct mwSession *s, - struct mwPrivacyInfo *privacy) { - - struct mwMsgSetPrivacyList *msg; - int ret; - - g_return_val_if_fail(s != NULL, -1); - g_return_val_if_fail(privacy != NULL, -1); - - msg = (struct mwMsgSetPrivacyList *) - mwMessage_new(mwMessage_SET_PRIVACY_LIST); - - mwPrivacyInfo_clone(&msg->privacy, privacy); - - ret = mwSession_send(s, MW_MESSAGE(msg)); - mwMessage_free(MW_MESSAGE(msg)); - - return ret; -} - - -struct mwPrivacyInfo *mwSession_getPrivacyInfo(struct mwSession *s) { - g_return_val_if_fail(s != NULL, NULL); - return &s->privacy; -} - - -int mwSession_setUserStatus(struct mwSession *s, - struct mwUserStatus *stat) { - - struct mwMsgSetUserStatus *msg; - int ret; - - g_return_val_if_fail(s != NULL, -1); - g_return_val_if_fail(stat != NULL, -1); - - msg = (struct mwMsgSetUserStatus *) - mwMessage_new(mwMessage_SET_USER_STATUS); - - mwUserStatus_clone(&msg->status, stat); - - ret = mwSession_send(s, MW_MESSAGE(msg)); - mwMessage_free(MW_MESSAGE(msg)); - - return ret; -} - - -struct mwUserStatus *mwSession_getUserStatus(struct mwSession *s) { - g_return_val_if_fail(s != NULL, NULL); - return &s->status; -} - - -enum mwSessionState mwSession_getState(struct mwSession *s) { - g_return_val_if_fail(s != NULL, mwSession_UNKNOWN); - return s->state; -} - - -gpointer mwSession_getStateInfo(struct mwSession *s) { - g_return_val_if_fail(s != NULL, 0); - return s->state_info; -} - - -struct mwChannelSet *mwSession_getChannels(struct mwSession *session) { - g_return_val_if_fail(session != NULL, NULL); - return session->channels; -} - - -gboolean mwSession_addService(struct mwSession *s, struct mwService *srv) { - g_return_val_if_fail(s != NULL, FALSE); - g_return_val_if_fail(srv != NULL, FALSE); - g_return_val_if_fail(s->services != NULL, FALSE); - - if(map_guint_lookup(s->services, SERVICE_KEY(srv))) { - return FALSE; - - } else { - map_guint_insert(s->services, SERVICE_KEY(srv), srv); - if(mwSession_isState(s, mwSession_STARTED)) - mwSession_senseService(s, mwService_getType(srv)); - return TRUE; - } -} - - -struct mwService *mwSession_getService(struct mwSession *s, guint32 srv) { - g_return_val_if_fail(s != NULL, NULL); - g_return_val_if_fail(s->services != NULL, NULL); - - return map_guint_lookup(s->services, srv); -} - - -struct mwService *mwSession_removeService(struct mwSession *s, guint32 srv) { - struct mwService *svc; - - g_return_val_if_fail(s != NULL, NULL); - g_return_val_if_fail(s->services != NULL, NULL); - - svc = map_guint_lookup(s->services, srv); - if(svc) map_guint_remove(s->services, srv); - return svc; -} - - -GList *mwSession_getServices(struct mwSession *s) { - g_return_val_if_fail(s != NULL, NULL); - g_return_val_if_fail(s->services != NULL, NULL); - - return map_collect_values(s->services); -} - - -void mwSession_senseService(struct mwSession *s, guint32 srvc) { - struct mwMsgSenseService *msg; - - g_return_if_fail(s != NULL); - g_return_if_fail(srvc != 0x00); - g_return_if_fail(mwSession_isStarted(s)); - - msg = (struct mwMsgSenseService *) - mwMessage_new(mwMessage_SENSE_SERVICE); - msg->service = srvc; - - mwSession_send(s, MW_MESSAGE(msg)); - mwMessage_free(MW_MESSAGE(msg)); -} - - -gboolean mwSession_addCipher(struct mwSession *s, struct mwCipher *c) { - g_return_val_if_fail(s != NULL, FALSE); - g_return_val_if_fail(c != NULL, FALSE); - g_return_val_if_fail(s->ciphers != NULL, FALSE); - - if(map_guint_lookup(s->ciphers, mwCipher_getType(c))) { - g_message("cipher %s is already added, apparently", - NSTR(mwCipher_getName(c))); - return FALSE; - - } else { - g_message("adding cipher %s", NSTR(mwCipher_getName(c))); - map_guint_insert(s->ciphers, mwCipher_getType(c), c); - return TRUE; - } -} - - -struct mwCipher *mwSession_getCipher(struct mwSession *s, guint16 c) { - g_return_val_if_fail(s != NULL, NULL); - g_return_val_if_fail(s->ciphers != NULL, NULL); - - return map_guint_lookup(s->ciphers, c); -} - - -struct mwCipher *mwSession_removeCipher(struct mwSession *s, guint16 c) { - struct mwCipher *ciph; - - g_return_val_if_fail(s != NULL, NULL); - g_return_val_if_fail(s->ciphers != NULL, NULL); - - ciph = map_guint_lookup(s->ciphers, c); - if(ciph) map_guint_remove(s->ciphers, c); - return ciph; -} - - -GList *mwSession_getCiphers(struct mwSession *s) { - g_return_val_if_fail(s != NULL, NULL); - g_return_val_if_fail(s->ciphers != NULL, NULL); - - return map_collect_values(s->ciphers); -} - - -void mwSession_setProperty(struct mwSession *s, const char *key, - gpointer val, GDestroyNotify clean) { - - g_return_if_fail(s != NULL); - g_return_if_fail(s->attributes != NULL); - g_return_if_fail(key != NULL); - - property_set(s, key, val, clean); -} - - -gpointer mwSession_getProperty(struct mwSession *s, const char *key) { - - g_return_val_if_fail(s != NULL, NULL); - g_return_val_if_fail(s->attributes != NULL, NULL); - g_return_val_if_fail(key != NULL, NULL); - - return property_get(s, key); -} - - -void mwSession_removeProperty(struct mwSession *s, const char *key) { - g_return_if_fail(s != NULL); - g_return_if_fail(s->attributes != NULL); - g_return_if_fail(key != NULL); - - property_del(s, key); -} - - -void mwSession_setClientData(struct mwSession *session, - gpointer data, GDestroyNotify clear) { - - g_return_if_fail(session != NULL); - mw_datum_set(&session->client_data, data, clear); -} - - -gpointer mwSession_getClientData(struct mwSession *session) { - g_return_val_if_fail(session != NULL, NULL); - return mw_datum_get(&session->client_data); -} - - -void mwSession_removeClientData(struct mwSession *session) { - g_return_if_fail(session != NULL); - mw_datum_clear(&session->client_data); -} -