pidgin3: comparison src/protocols/sametime/meanwhile/session.c

-:e392054bc95b
+:81ee4bc13c28
 License along with this library; if not, write to the Free
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 #include <glib.h>
+#include <gmp.h>
 #include <string.h>
 #include "mw_channel.h"
 #include "mw_cipher.h"
 #include "mw_debug.h"
 /** provides I/O and callback functions */
 struct mwSessionHandler *handler;
 enum mwSessionState state;  /**< session state */
-guint32 state_info;         /**< additional state info */
+gpointer state_info;        /**< additional state info */
 /* input buffering for an incoming message */
 char *buf;       /**< buffer for incoming message data */
 gsize buf_len;   /**< length of buf */
 gsize buf_used;  /**< offset to last-used byte of buf */
 s->handler->io_close(s);
 }
-/** set the state of the session, and trigger the session handler's
-on_stateChange function. Has no effect if the session is already
-in the specified state (ignores additional state info)
-@param s      the session
-@param state  the state to set
-@param info   additional state info
-*/
 static void state(struct mwSession *s, enum mwSessionState state,
-		  guint32 info) {
+		  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;
-if(info) {
+switch(state) {
-g_message("session state: %s (0x%08x)", state_str(state), info);
+case mwSession_STOPPING:
-} else {
+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->on_stateChange)
+if(sh && sh->on_stateChange)
 sh->on_stateChange(s, state, info);
 }
 void mwSession_start(struct mwSession *s) {
 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);
 void mwSession_stop(struct mwSession *s, guint32 reason) {
 GList *list, *l = NULL;
 struct mwMsgChannelDestroy *msg;
 g_return_if_fail(s != NULL);
-g_return_if_fail(! mwSession_isStopping(s));
-g_return_if_fail(! mwSession_isStopped(s));
+if(mwSession_isStopped(s) || mwSession_isStopping(s)) {
+g_debug("attempted to stop session that is already stopped/stopping");
-state(s, mwSession_STOPPING, reason);
+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);
 session_buf_free(s);
 /* close the connection */
 io_close(s);
-state(s, mwSession_STOPPED, reason);
+state(s, mwSession_STOPPED, GUINT_TO_POINTER(reason));
 }
 /** compose authentication information into an opaque based on the
-password */
+password, encrypted via RC2/40 */
-static void compose_auth(struct mwOpaque *auth, const char *pass) {
+static void compose_auth_rc2_40(struct mwOpaque *auth, const char *pass) {
 char iv[8], key[5];
 struct mwOpaque a, b, z;
 struct mwPutBuffer *p;
 /* get an IV and a random five-byte key */
 mwIV_init((char *) iv);
-rand_key((char *) key, 5);
+mwKeyRandom((char *) key, 5);
 /* the opaque with the key */
 a.len = 5;
 a.data = key;
 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) {
+char iv[8];
+struct mwOpaque a, b, c;
+struct mwPutBuffer *p;
+mpz_t private, public;
+mpz_t remote;
+mpz_t shared;
+mpz_init(private);
+mpz_init(public);
+mpz_init(remote);
+mpz_init(shared);
+mwIV_init(iv);
+mwDHRandKeypair(private, public);
+mwDHImportKey(remote, rkey);
+mwDHCalculateShared(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 */
+mwDHExportKey(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);
+mwDHExportKey(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);
+mpz_clear(private);
+mpz_clear(public);
+mpz_clear(remote);
+mpz_clear(shared);
 }
 /** handle the receipt of a handshake_ack message by sending 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 */
-log->auth_type = mwAuthType_ENCRYPT;
+{
-compose_auth(&log->auth_data, property_get(s, mwSession_AUTH_PASSWORD));
+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(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) {
-struct mwSessionHandler *sh = s->handler;
+state(s, mwSession_LOGIN_REDIR, msg->host);
-state(s, mwSession_LOGIN_REDIR, 0);
-if(sh && sh->on_loginRedirect)
-sh->on_loginRedirect(s, msg->host);
 }
 #define CASE(var, type) \
 case mwMessage_ ## var: \
 static void session_process(struct mwSession *s,
 			    const char *buf, gsize len) {
-struct mwOpaque o = { len, (char *) buf };
+struct mwOpaque o = { .len = len, .data = (char *) buf };
 struct mwGetBuffer *b;
 struct mwMessage *msg;
 g_return_if_fail(s != NULL);
 g_return_if_fail(buf != NULL);
 /* 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(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);
 }
-if(mwGetBuffer_error(b)) {
-struct mwOpaque o = { .data = (char *) buf, .len = len };
-mw_debug_mailme(&o, "parsing of message type 0x%04x failed", msg->type);
-}
-mwGetBuffer_free(b);
 mwMessage_free(msg);
 }
 #undef CASE
-#define ADVANCE(b, n, count) (b += count, n -= count)
+#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 char *b, gsize n) {
 obscenely long message (even if it never actually sends it) */
 /* g_message(" session_recv: session = %p, b = %p, n = %u",
 	    s, b, n); */
-if(n && (s->buf_len == 0) && (*b & 0x80)) {
+if(s->buf_len == 0) {
-/* keep-alive and series bytes are ignored */
+while(n && (*b & 0x80)) {
-ADVANCE(b, n, 1);
+/* keep-alive and series bytes are ignored */
+ADVANCE(b, n, 1);
+}
 }
 if(n == 0) {
 return 0;
 void mwSession_recv(struct mwSession *s, const char *buf, gsize n) {
 char *b = (char *) buf;
 gsize remain = 0;
 g_return_if_fail(s != NULL);
-/* g_message(" mwSession_recv: session = %p, b = %p, n = %u",
-	    s, b, n); */
 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;
-gsize len;
 int ret = 0;
 g_return_val_if_fail(s != NULL, -1);
 /* writing nothing is easy */
 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 */
-len = o.len;
 ret = io_write(s, o.data, o.len);
 mwOpaque_clear(&o);
 /* ensure we could actually write the message */
 if(! ret) {
 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;
 }
 g_return_val_if_fail(s != NULL, mwSession_UNKNOWN);
 return s->state;
 }
-guint32 mwSession_getStateInfo(struct mwSession *s) {
+gpointer mwSession_getStateInfo(struct mwSession *s) {
 g_return_val_if_fail(s != NULL, 0);
 return s->state_info;
 }

Mercurial > pidgin3 / file comparison

comparison: src/protocols/sametime/meanwhile/session.c

src/protocols/sametime/meanwhile/session.c