diff src/protocols/sametime/meanwhile/message.c @ 10969:3ef77720e577

[gaim-migrate @ 12790] importing meanwhile library for use in the sametime plugin committer: Tailor Script <[e-mail]>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/sametime/meanwhile/message.c	Sun Jun 05 02:50:13 2005 +0000
@@ -0,0 +1,715 @@
+
+/*
+  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 <glib.h>
+
+#include "mw_debug.h"
+#include "mw_message.h"
+
+
+/* 7.1 Layering and message encapsulation */
+/* 7.1.1 The Sametime Message Header */
+
+
+static void mwMessageHead_put(struct mwPutBuffer *b, struct mwMessage *msg) {
+  guint16_put(b, msg->type);
+  guint16_put(b, msg->options);
+  guint32_put(b, msg->channel);
+  
+  if(msg->options & mwMessageOption_HAS_ATTRIBS)
+    mwOpaque_put(b, &msg->attribs);
+}
+
+
+static void mwMessageHead_get(struct mwGetBuffer *b, struct mwMessage *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+
+  guint16_get(b, &msg->type);
+  guint16_get(b, &msg->options);
+  guint32_get(b, &msg->channel);
+
+  if(msg->options & mwMessageOption_HAS_ATTRIBS)
+    mwOpaque_get(b, &msg->attribs);
+}
+
+
+static void mwMessageHead_clone(struct mwMessage *to,
+				struct mwMessage *from) {
+
+  to->type = from->type;
+  to->options = from->options;
+  to->channel = from->channel;
+  mwOpaque_clone(&to->attribs, &from->attribs);
+}
+
+
+static void mwMessageHead_clear(struct mwMessage *msg) {
+  mwOpaque_clear(&msg->attribs);
+}
+
+
+/* 8.4 Messages */
+/* 8.4.1 Basic Community Messages */
+/* 8.4.1.1 Handshake */
+
+
+static void HANDSHAKE_put(struct mwPutBuffer *b, struct mwMsgHandshake *msg) {
+  guint16_put(b, msg->major);
+  guint16_put(b, msg->minor);
+  guint32_put(b, msg->head.channel);
+  guint32_put(b, msg->srvrcalc_addr);
+  guint16_put(b, msg->login_type);
+  guint32_put(b, msg->loclcalc_addr);
+}
+
+
+static void HANDSHAKE_clear(struct mwMsgHandshake *msg) {
+  ; /* nothing to clean up */
+}
+
+
+/* 8.4.1.2 HandshakeAck */
+
+
+static void HANDSHAKE_ACK_get(struct mwGetBuffer *b,
+			      struct mwMsgHandshakeAck *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+
+  guint16_get(b, &msg->major);
+  guint16_get(b, &msg->minor);
+  guint32_get(b, &msg->srvrcalc_addr);
+
+  /** @todo: get a better handle on what versions support what parts
+      of this message. eg: minor version 0x0018 doesn't send the
+      following */
+  if(msg->major >= 0x1e && msg->minor > 0x18) {
+    guint32_get(b, &msg->unknown);
+    mwOpaque_get(b, &msg->data);
+  }
+}
+
+
+static void HANDSHAKE_ACK_clear(struct mwMsgHandshakeAck *msg) {
+  mwOpaque_clear(&msg->data);
+}
+
+
+/* 8.4.1.3 Login */
+
+
+static void LOGIN_put(struct mwPutBuffer *b, struct mwMsgLogin *msg) {
+  guint16_put(b, msg->login_type);
+  mwString_put(b, msg->name);
+
+  /* ordering reversed from draft?? */
+  mwOpaque_put(b, &msg->auth_data);
+  guint16_put(b, msg->auth_type);
+}
+
+
+static void LOGIN_clear(struct mwMsgLogin *msg) {
+  g_free(msg->name);
+  mwOpaque_clear(&msg->auth_data);
+}
+
+
+/* 8.4.1.4 LoginAck */
+
+
+static void LOGIN_ACK_get(struct mwGetBuffer *b, struct mwMsgLoginAck *msg) {
+  guint16 junk;
+
+  if(mwGetBuffer_error(b)) return;
+
+  mwLoginInfo_get(b, &msg->login);
+  guint16_get(b, &junk);
+  mwPrivacyInfo_get(b, &msg->privacy);
+  mwUserStatus_get(b, &msg->status);
+}
+
+
+static void LOGIN_ACK_clear(struct mwMsgLoginAck *msg) {
+  mwLoginInfo_clear(&msg->login);
+  mwPrivacyInfo_clear(&msg->privacy);
+  mwUserStatus_clear(&msg->status);
+}
+
+
+/* 8.4.1.5 LoginCont */
+
+
+static void LOGIN_CONTINUE_put(struct mwPutBuffer *b,
+			       struct mwMsgLoginContinue *msg) {
+
+  ; /* nothing but a message header */
+}
+
+
+static void LOGIN_CONTINUE_clear(struct mwMsgLoginContinue *msg) {
+  ; /* this is a very simple message */
+}
+
+
+/* 8.4.1.6 AuthPassed */
+
+
+static void LOGIN_REDIRECT_get(struct mwGetBuffer *b,
+			       struct mwMsgLoginRedirect *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+  mwString_get(b, &msg->host);
+  mwString_get(b, &msg->server_id);  
+}
+
+
+static void LOGIN_REDIRECT_clear(struct mwMsgLoginRedirect *msg) {
+  g_free(msg->host);
+  msg->host = NULL;
+
+  g_free(msg->server_id);
+  msg->server_id = NULL;
+}
+
+
+/* 8.4.1.7 CreateCnl */
+
+
+static void enc_offer_put(struct mwPutBuffer *b, struct mwEncryptOffer *enc) {
+  char tail = 0x07;
+
+  guint16_put(b, enc->mode);
+
+  if(enc->items) {
+    guint32 count;
+    struct mwPutBuffer *p;
+    struct mwOpaque o;
+    GList *list;
+
+    /* write the count, items, extra, and flag into a tmp buffer,
+       render that buffer into an opaque, and write it into b */
+
+    count = g_list_length(enc->items);
+    p = mwPutBuffer_new();
+
+  
+    guint32_put(p, count);
+    for(list = enc->items; list; list = list->next) {
+      mwEncryptItem_put(p, list->data);
+    }
+
+    guint16_put(p, enc->extra);
+    gboolean_put(p, enc->flag);
+
+    mwPutBuffer_finalize(&o, p);
+    mwOpaque_put(b, &o);
+    mwOpaque_clear(&o);
+  }
+
+  guint32_put(b, 0x00);
+  guint32_put(b, 0x00);
+  gboolean_put(b, FALSE);
+  mwPutBuffer_write(b, &tail, 1);
+}
+
+
+static void CHANNEL_CREATE_put(struct mwPutBuffer *b,
+			       struct mwMsgChannelCreate *msg) {
+
+  guint32_put(b, msg->reserved);
+  guint32_put(b, msg->channel);
+  mwIdBlock_put(b, &msg->target);
+  guint32_put(b, msg->service);
+  guint32_put(b, msg->proto_type);
+  guint32_put(b, msg->proto_ver);
+  guint32_put(b, msg->options);
+  mwOpaque_put(b, &msg->addtl);
+  gboolean_put(b, msg->creator_flag);
+
+  if(msg->creator_flag)
+    mwLoginInfo_put(b, &msg->creator);
+
+  enc_offer_put(b, &msg->encrypt);
+}
+
+
+static void enc_offer_get(struct mwGetBuffer *b,
+			  struct mwEncryptOffer *enc) {
+  guint32 skip;
+
+  if(mwGetBuffer_error(b)) return;
+
+  guint16_get(b, &enc->mode);
+  guint32_get(b, &skip);
+
+  if(skip >= 7) {
+    guint32 count;
+
+    guint32_get(b, &count);
+
+    while(count-- && (! mwGetBuffer_error(b))) {
+      struct mwEncryptItem *ei = g_new0(struct mwEncryptItem, 1);
+      mwEncryptItem_get(b, ei);
+      enc->items = g_list_append(enc->items, ei);
+    }
+
+    guint16_get(b, &enc->extra);
+    gboolean_get(b, &enc->flag);
+  }
+}
+
+
+static void CHANNEL_CREATE_get(struct mwGetBuffer *b,
+			       struct mwMsgChannelCreate *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+
+  guint32_get(b, &msg->reserved);
+  guint32_get(b, &msg->channel);
+  mwIdBlock_get(b, &msg->target);
+  guint32_get(b, &msg->service);
+  guint32_get(b, &msg->proto_type);
+  guint32_get(b, &msg->proto_ver);
+  guint32_get(b, &msg->options);
+  mwOpaque_get(b, &msg->addtl);
+  gboolean_get(b, &msg->creator_flag);
+  
+  if(msg->creator_flag)
+    mwLoginInfo_get(b, &msg->creator);
+  
+  enc_offer_get(b, &msg->encrypt);
+}
+
+
+static void CHANNEL_CREATE_clear(struct mwMsgChannelCreate *msg) {
+  GList *list;
+
+  mwIdBlock_clear(&msg->target);
+  mwOpaque_clear(&msg->addtl);
+  mwLoginInfo_clear(&msg->creator);
+  
+  for(list = msg->encrypt.items; list; list = list->next) {
+    mwEncryptItem_clear(list->data);
+    g_free(list->data);
+  }
+  g_list_free(msg->encrypt.items);
+}
+
+
+/* 8.4.1.8 AcceptCnl */
+
+
+static void enc_accept_put(struct mwPutBuffer *b,
+			   struct mwEncryptAccept *enc) {
+
+  char tail = 0x07;
+
+  guint16_put(b, enc->mode);
+
+  if(enc->item) {
+    struct mwPutBuffer *p;
+    struct mwOpaque o;
+
+    p = mwPutBuffer_new();
+
+    mwEncryptItem_put(p, enc->item);
+    guint16_put(p, enc->extra);
+    gboolean_put(p, enc->flag);
+
+    mwPutBuffer_finalize(&o, p);
+    mwOpaque_put(b, &o);
+    mwOpaque_clear(&o);
+  }
+
+  guint32_put(b, 0x00);
+  guint32_put(b, 0x00);
+  gboolean_put(b, FALSE);
+
+  mwPutBuffer_write(b, &tail, 1);
+}
+
+
+static void CHANNEL_ACCEPT_put(struct mwPutBuffer *b,
+			       struct mwMsgChannelAccept *msg) {
+  
+  guint32_put(b, msg->service);
+  guint32_put(b, msg->proto_type);
+  guint32_put(b, msg->proto_ver);
+  mwOpaque_put(b, &msg->addtl);
+  gboolean_put(b, msg->acceptor_flag);
+  
+  if(msg->acceptor_flag)
+    mwLoginInfo_put(b, &msg->acceptor);
+  
+  enc_accept_put(b, &msg->encrypt);
+}
+
+
+static void enc_accept_get(struct mwGetBuffer *b,
+			   struct mwEncryptAccept *enc) {
+  guint32 skip;
+
+  if(mwGetBuffer_error(b)) return;
+
+  guint16_get(b, &enc->mode);
+  guint32_get(b, &skip);
+
+  if(skip >= 6) {
+    enc->item = g_new0(struct mwEncryptItem, 1);
+    mwEncryptItem_get(b, enc->item);
+  }
+
+  if(skip >= 9) {
+    guint16_get(b, &enc->extra);
+    gboolean_get(b, &enc->flag);
+  }
+}
+
+
+static void CHANNEL_ACCEPT_get(struct mwGetBuffer *b,
+			       struct mwMsgChannelAccept *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+
+  guint32_get(b, &msg->service);
+  guint32_get(b, &msg->proto_type);
+  guint32_get(b, &msg->proto_ver);
+  mwOpaque_get(b, &msg->addtl);
+  gboolean_get(b, &msg->acceptor_flag);
+
+  if(msg->acceptor_flag)
+    mwLoginInfo_get(b, &msg->acceptor);
+
+  enc_accept_get(b, &msg->encrypt);
+}
+
+
+static void CHANNEL_ACCEPT_clear(struct mwMsgChannelAccept *msg) {
+  mwOpaque_clear(&msg->addtl);
+  mwLoginInfo_clear(&msg->acceptor);
+
+  if(msg->encrypt.item) {
+    mwEncryptItem_clear(msg->encrypt.item);
+    g_free(msg->encrypt.item);
+  }
+}
+
+
+/* 8.4.1.9 SendOnCnl */
+
+
+static void CHANNEL_SEND_put(struct mwPutBuffer *b,
+			     struct mwMsgChannelSend *msg) {
+
+  guint16_put(b, msg->type);
+  mwOpaque_put(b, &msg->data);
+}
+
+
+static void CHANNEL_SEND_get(struct mwGetBuffer *b,
+			     struct mwMsgChannelSend *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+
+  guint16_get(b, &msg->type);
+  mwOpaque_get(b, &msg->data);
+}
+
+
+static void CHANNEL_SEND_clear(struct mwMsgChannelSend *msg) {
+  mwOpaque_clear(&msg->data);
+}
+
+
+/* 8.4.1.10 DestroyCnl */
+
+
+static void CHANNEL_DESTROY_put(struct mwPutBuffer *b,
+				struct mwMsgChannelDestroy *msg) {
+  guint32_put(b, msg->reason);
+  mwOpaque_put(b, &msg->data);
+}
+
+
+static void CHANNEL_DESTROY_get(struct mwGetBuffer *b,
+				struct mwMsgChannelDestroy *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+
+  guint32_get(b, &msg->reason);
+  mwOpaque_get(b, &msg->data);
+}
+
+
+static void CHANNEL_DESTROY_clear(struct mwMsgChannelDestroy *msg) {
+  mwOpaque_clear(&msg->data);
+}
+
+
+/* 8.4.1.11 SetUserStatus */
+
+
+static void SET_USER_STATUS_put(struct mwPutBuffer *b,
+				struct mwMsgSetUserStatus *msg) {
+  mwUserStatus_put(b, &msg->status);
+}
+
+
+static void SET_USER_STATUS_get(struct mwGetBuffer *b,
+				struct mwMsgSetUserStatus *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+  mwUserStatus_get(b, &msg->status);
+}
+
+
+static void SET_USER_STATUS_clear(struct mwMsgSetUserStatus *msg) {
+  mwUserStatus_clear(&msg->status);
+}
+
+
+/* 8.4.1.12 SetPrivacyList */
+
+
+static void SET_PRIVACY_LIST_put(struct mwPutBuffer *b,
+				 struct mwMsgSetPrivacyList *msg) {
+  mwPrivacyInfo_put(b, &msg->privacy);
+}
+
+
+static void SET_PRIVACY_LIST_get(struct mwGetBuffer *b,
+				 struct mwMsgSetPrivacyList *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+  mwPrivacyInfo_get(b, &msg->privacy);
+}
+
+
+static void SET_PRIVACY_LIST_clear(struct mwMsgSetPrivacyList *msg) {
+  mwPrivacyInfo_clear(&msg->privacy);
+}
+
+
+/* Sense Service messages */
+
+
+static void SENSE_SERVICE_put(struct mwPutBuffer *b,
+			      struct mwMsgSenseService *msg) {
+  guint32_put(b, msg->service);
+}
+
+
+static void SENSE_SERVICE_get(struct mwGetBuffer *b,
+			      struct mwMsgSenseService *msg) {
+
+  if(mwGetBuffer_error(b)) return;
+  guint32_get(b, &msg->service);
+}
+
+
+static void SENSE_SERVICE_clear(struct mwMsgSenseService *msg) {
+  ;
+}
+
+
+/* Admin messages */
+
+
+static void ADMIN_get(struct mwGetBuffer *b, struct mwMsgAdmin *msg) {
+  mwString_get(b, &msg->text);
+}
+
+
+static void ADMIN_clear(struct mwMsgAdmin *msg) {
+  g_free(msg->text);
+  msg->text = NULL;
+}
+
+
+#define CASE(v, t) \
+case mwMessage_ ## v: \
+  msg = (struct mwMessage *) g_new0(struct t, 1); \
+  msg->type = type; \
+  break;
+
+
+struct mwMessage *mwMessage_new(enum mwMessageType type) {
+  struct mwMessage *msg = NULL;
+  
+  switch(type) {
+    CASE(HANDSHAKE, mwMsgHandshake);
+    CASE(HANDSHAKE_ACK, mwMsgHandshakeAck);
+    CASE(LOGIN, mwMsgLogin);
+    CASE(LOGIN_REDIRECT, mwMsgLoginRedirect);
+    CASE(LOGIN_CONTINUE, mwMsgLoginContinue);
+    CASE(LOGIN_ACK, mwMsgLoginAck);
+    CASE(CHANNEL_CREATE, mwMsgChannelCreate);
+    CASE(CHANNEL_DESTROY, mwMsgChannelDestroy);
+    CASE(CHANNEL_SEND, mwMsgChannelSend);
+    CASE(CHANNEL_ACCEPT, mwMsgChannelAccept);
+    CASE(SET_USER_STATUS, mwMsgSetUserStatus);
+    CASE(SET_PRIVACY_LIST, mwMsgSetPrivacyList);
+    CASE(SENSE_SERVICE, mwMsgSenseService);
+    CASE(ADMIN, mwMsgAdmin);
+    
+  default:
+    g_warning("unknown message type 0x%02x\n", type);
+  }
+  
+  return msg;
+}
+
+
+#undef CASE
+
+
+/* each type needs to be passed to a specially named _get functions,
+   and cast to a specific subclass of mwMessage. */
+#define CASE(v, t) \
+case mwMessage_ ## v: \
+  msg = (struct mwMessage *) g_new0(struct t, 1); \
+  mwMessageHead_clone(msg, &head); \
+  v ## _get(b, (struct t *) msg); \
+  break;
+
+
+struct mwMessage *mwMessage_get(struct mwGetBuffer *b) {
+  struct mwMessage *msg = NULL;
+  struct mwMessage head;
+  
+  g_return_val_if_fail(b != NULL, NULL);
+
+  head.attribs.len = 0;
+  head.attribs.data = NULL;
+
+  /* attempt to read the header first */
+  mwMessageHead_get(b, &head);
+
+  if(mwGetBuffer_error(b)) {
+    mwMessageHead_clear(&head);
+    g_warning("problem parsing message head from buffer");
+    return NULL;
+  }
+
+  /* load the rest of the message depending on the header type */
+  switch(head.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_USER_STATUS, mwMsgSetUserStatus);
+    CASE(SET_PRIVACY_LIST, mwMsgSetPrivacyList);
+    CASE(SENSE_SERVICE, mwMsgSenseService);
+    CASE(ADMIN, mwMsgAdmin);
+
+  default:
+    g_warning("unknown message type 0x%02x, no parse handler", head.type);
+  }
+
+  if(mwGetBuffer_error(b)) {
+    g_warning("problem parsing message type 0x%02x, not enough data",
+	      head.type);
+  }
+
+  mwMessageHead_clear(&head);
+  
+  return msg;
+}
+
+
+#undef CASE
+
+
+#define CASE(v, t) \
+case mwMessage_ ## v: \
+  v ## _put(b, (struct t *) msg); \
+  break;
+
+
+void mwMessage_put(struct mwPutBuffer *b, struct mwMessage *msg) {
+
+  g_return_if_fail(b != NULL);
+  g_return_if_fail(msg != NULL);
+
+  mwMessageHead_put(b, msg);
+
+  switch(msg->type) {
+    CASE(HANDSHAKE, mwMsgHandshake);
+    CASE(LOGIN, mwMsgLogin);
+    CASE(LOGIN_CONTINUE, mwMsgLoginContinue);
+    CASE(CHANNEL_CREATE, mwMsgChannelCreate);
+    CASE(CHANNEL_DESTROY, mwMsgChannelDestroy);
+    CASE(CHANNEL_SEND, mwMsgChannelSend);
+    CASE(CHANNEL_ACCEPT, mwMsgChannelAccept);
+    CASE(SET_USER_STATUS, mwMsgSetUserStatus);
+    CASE(SET_PRIVACY_LIST, mwMsgSetPrivacyList);
+    CASE(SENSE_SERVICE, mwMsgSenseService);
+    
+  default:
+    ; /* hrm. */
+  }
+}
+
+
+#undef CASE
+
+
+#define CASE(v, t) \
+case mwMessage_ ## v: \
+  v ## _clear((struct t *) msg); \
+  break;
+
+
+void mwMessage_free(struct mwMessage *msg) {
+  if(! msg) return;
+
+  mwMessageHead_clear(msg);
+
+  switch(msg->type) {
+    CASE(HANDSHAKE, mwMsgHandshake);
+    CASE(HANDSHAKE_ACK, mwMsgHandshakeAck);
+    CASE(LOGIN, mwMsgLogin);
+    CASE(LOGIN_REDIRECT, mwMsgLoginRedirect);
+    CASE(LOGIN_CONTINUE, mwMsgLoginContinue);
+    CASE(LOGIN_ACK, mwMsgLoginAck);
+    CASE(CHANNEL_CREATE, mwMsgChannelCreate);
+    CASE(CHANNEL_DESTROY, mwMsgChannelDestroy);
+    CASE(CHANNEL_SEND, mwMsgChannelSend);
+    CASE(CHANNEL_ACCEPT, mwMsgChannelAccept);
+    CASE(SET_USER_STATUS, mwMsgSetUserStatus);
+    CASE(SET_PRIVACY_LIST, mwMsgSetPrivacyList);
+    CASE(SENSE_SERVICE, mwMsgSenseService);
+    CASE(ADMIN, mwMsgAdmin);
+    
+  default:
+    ; /* hrm. */
+  }
+
+  g_free(msg);
+}
+
+
+#undef CASE
+
+