diff src/protocols/sametime/meanwhile/srvc_ft.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/srvc_ft.c	Sun Jun 05 02:50:13 2005 +0000
@@ -0,0 +1,647 @@
+
+/*
+  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/glist.h>
+
+#include "mw_channel.h"
+#include "mw_common.h"
+#include "mw_debug.h"
+#include "mw_error.h"
+#include "mw_message.h"
+#include "mw_service.h"
+#include "mw_session.h"
+#include "mw_srvc_ft.h"
+#include "mw_util.h"
+
+
+#define PROTOCOL_TYPE  0x00000000
+#define PROTOCOL_VER   0x00000001
+
+
+/** send-on-channel type: FT transfer data */
+#define msg_TRANSFER  0x0001
+
+
+/** ack received transfer data */
+#define msg_RECEIVED  0x0002
+
+
+struct mwServiceFileTransfer {
+  struct mwService service;
+
+  struct mwFileTransferHandler *handler;
+  GList *transfers;
+};
+
+
+struct mwFileTransfer {
+  struct mwServiceFileTransfer *service;
+  
+  struct mwChannel *channel;
+  struct mwIdBlock who;
+
+  enum mwFileTransferState state;
+
+  char *filename;
+  char *message;
+
+  guint32 size;
+  guint32 remaining;
+
+  struct mw_datum client_data;
+};
+
+
+/** momentarily places a mwLoginInfo into a mwIdBlock */
+static void login_into_id(struct mwIdBlock *to, struct mwLoginInfo *from) {
+  to->user = from->user_id;
+  to->community = from->community;
+}
+
+
+static const char *ft_state_str(enum mwFileTransferState state) {
+  switch(state) {
+  case mwFileTransfer_NEW:
+    return "new";
+
+  case mwFileTransfer_PENDING:
+    return "pending";
+
+  case mwFileTransfer_OPEN:
+    return "open";
+
+  case mwFileTransfer_CANCEL_LOCAL:
+    return "cancelled locally";
+
+  case mwFileTransfer_CANCEL_REMOTE:
+    return "cancelled remotely";
+
+  case mwFileTransfer_DONE:
+    return "done";
+
+  case mwFileTransfer_ERROR:
+    return "error";
+
+  case mwFileTransfer_UNKNOWN:
+  default:
+    return "UNKNOWN";
+  }
+}
+
+
+static void ft_state(struct mwFileTransfer *ft,
+		     enum mwFileTransferState state) {
+
+  g_return_if_fail(ft != NULL);
+
+  if(ft->state == state) return;
+
+  g_info("setting ft (%s, %s) state: %s",
+	 NSTR(ft->who.user), NSTR(ft->who.community),
+	 ft_state_str(state));
+
+  ft->state = state;
+}
+
+
+static void recv_channelCreate(struct mwServiceFileTransfer *srvc,
+			       struct mwChannel *chan,
+			       struct mwMsgChannelCreate *msg) {
+
+  struct mwFileTransferHandler *handler;
+  struct mwGetBuffer *b;
+
+  char *fnm, *txt;
+  guint32 size, junk;
+  gboolean b_err;
+
+  g_return_if_fail(srvc->handler != NULL);
+  handler = srvc->handler;
+  
+  b = mwGetBuffer_wrap(&msg->addtl);
+
+  guint32_get(b, &junk); /* unknown */
+  mwString_get(b, &fnm); /* offered filename */
+  mwString_get(b, &txt); /* offering message */
+  guint32_get(b, &size); /* size of offered file */
+  guint32_get(b, &junk); /* unknown */
+  /* and we just skip an unknown guint16 at the end */
+
+  b_err = mwGetBuffer_error(b);
+  mwGetBuffer_free(b);
+
+  if(b_err) {
+    g_warning("bad/malformed addtl in File Transfer service");
+    mwChannel_destroy(chan, ERR_FAILURE, NULL);
+
+  } else {
+    struct mwIdBlock idb;
+    struct mwFileTransfer *ft;
+
+    login_into_id(&idb, mwChannel_getUser(chan));
+    ft = mwFileTransfer_new(srvc, &idb, txt, fnm, size);
+    ft->channel = chan;
+    ft_state(ft, mwFileTransfer_PENDING);
+
+    mwChannel_setServiceData(chan, ft, NULL);
+
+    if(handler->ft_offered)
+      handler->ft_offered(ft);
+  }
+
+  g_free(fnm);
+  g_free(txt);
+}
+
+
+static void recv_channelAccept(struct mwServiceFileTransfer *srvc,
+			       struct mwChannel *chan,
+			       struct mwMsgChannelAccept *msg) {
+
+  struct mwFileTransferHandler *handler;
+  struct mwFileTransfer *ft;
+
+  g_return_if_fail(srvc->handler != NULL);
+  handler = srvc->handler;
+
+  ft = mwChannel_getServiceData(chan);
+  g_return_if_fail(ft != NULL);
+
+  ft_state(ft, mwFileTransfer_OPEN);
+
+  if(handler->ft_opened)
+    handler->ft_opened(ft);
+}
+
+
+static void recv_channelDestroy(struct mwServiceFileTransfer *srvc,
+				struct mwChannel *chan,
+				struct mwMsgChannelDestroy *msg) {
+
+  struct mwFileTransferHandler *handler;
+  struct mwFileTransfer *ft;
+  guint32 code;
+
+  code = msg->reason;
+
+  g_return_if_fail(srvc->handler != NULL);
+  handler = srvc->handler;
+
+  ft = mwChannel_getServiceData(chan);
+  g_return_if_fail(ft != NULL);
+
+  ft->channel = NULL;
+
+  if(! mwFileTransfer_isDone(ft))
+    ft_state(ft, mwFileTransfer_CANCEL_REMOTE);
+
+  mwFileTransfer_close(ft, code);
+}
+
+
+static void recv_TRANSFER(struct mwFileTransfer *ft,
+			  struct mwOpaque *data) {
+
+  struct mwServiceFileTransfer *srvc;
+  struct mwFileTransferHandler *handler;
+  
+  srvc = ft->service;
+  handler = srvc->handler;
+
+  g_return_if_fail(mwFileTransfer_isOpen(ft));
+
+  if(data->len > ft->remaining) {
+    /* @todo handle error */
+
+  } else {
+    ft->remaining -= data->len;
+
+    if(! ft->remaining)
+      ft_state(ft, mwFileTransfer_DONE);
+    
+    if(handler->ft_recv)
+      handler->ft_recv(ft, data);
+  }
+}
+
+
+static void recv_RECEIVED(struct mwFileTransfer *ft,
+			  struct mwOpaque *data) {
+
+  struct mwServiceFileTransfer *srvc;
+  struct mwFileTransferHandler *handler;
+  
+  srvc = ft->service;
+  handler = srvc->handler;
+
+  if(! ft->remaining)
+    ft_state(ft, mwFileTransfer_DONE);
+
+  if(handler->ft_ack)
+    handler->ft_ack(ft);
+
+  if(! ft->remaining)
+    mwFileTransfer_close(ft, mwFileTransfer_SUCCESS);
+}
+
+
+static void recv(struct mwService *srvc, struct mwChannel *chan,
+		 guint16 type, struct mwOpaque *data) {
+
+  struct mwFileTransfer *ft;
+  
+  ft = mwChannel_getServiceData(chan);
+  g_return_if_fail(ft != NULL);
+
+  switch(type) {
+  case msg_TRANSFER:
+    recv_TRANSFER(ft, data);
+    break;
+
+  case msg_RECEIVED:
+    recv_RECEIVED(ft, data);
+    break;
+
+  default:
+    mw_debug_mailme(data, "unknown message in ft service: 0x%04x", type);
+  }
+}
+
+
+static void clear(struct mwServiceFileTransfer *srvc) {
+  struct mwFileTransferHandler *h;
+  
+  h = srvc->handler;
+  if(h && h->clear)
+    h->clear(srvc);
+  srvc->handler = NULL;
+}
+
+
+static const char *name(struct mwService *srvc) {
+  return "File Transfer";
+}
+
+
+static const char *desc(struct mwService *srvc) {
+  return "Provides file transfer capabilities through the community server";
+}
+
+
+static void start(struct mwService *srvc) {
+  mwService_started(srvc);
+}
+
+
+static void stop(struct mwServiceFileTransfer *srvc) {
+  while(srvc->transfers) {
+    mwFileTransfer_free(srvc->transfers->data);
+  }
+
+  mwService_stopped(MW_SERVICE(srvc));
+}
+
+
+struct mwServiceFileTransfer *
+mwServiceFileTransfer_new(struct mwSession *session,
+			  struct mwFileTransferHandler *handler) {
+
+  struct mwServiceFileTransfer *srvc_ft;
+  struct mwService *srvc;
+
+  g_return_val_if_fail(session != NULL, NULL);
+  g_return_val_if_fail(handler != NULL, NULL);
+
+  srvc_ft = g_new0(struct mwServiceFileTransfer, 1);
+  srvc = MW_SERVICE(srvc_ft);
+
+  mwService_init(srvc, session, mwService_FILE_TRANSFER);
+  srvc->recv_create = (mwService_funcRecvCreate) recv_channelCreate;
+  srvc->recv_accept = (mwService_funcRecvAccept) recv_channelAccept;
+  srvc->recv_destroy = (mwService_funcRecvDestroy) recv_channelDestroy;
+  srvc->recv = recv;
+  srvc->clear = (mwService_funcClear) clear;
+  srvc->get_name = name;
+  srvc->get_desc = desc;
+  srvc->start = start;
+  srvc->stop = (mwService_funcStop) stop;
+
+  srvc_ft->handler = handler;
+
+  return srvc_ft;
+}
+
+
+struct mwFileTransferHandler *
+mwServiceFileTransfer_getHandler(struct mwServiceFileTransfer *srvc) {
+  g_return_val_if_fail(srvc != NULL, NULL);
+  return srvc->handler;
+}
+
+
+struct mwFileTransfer *
+mwFileTransfer_new(struct mwServiceFileTransfer *srvc,
+		   const struct mwIdBlock *who, const char *msg,
+		   const char *filename, guint32 filesize) {
+  
+  struct mwFileTransfer *ft;
+
+  g_return_val_if_fail(srvc != NULL, NULL);
+  g_return_val_if_fail(who != NULL, NULL);
+  
+  ft = g_new0(struct mwFileTransfer, 1);
+  ft->service = srvc;
+  mwIdBlock_clone(&ft->who, who);
+  ft->filename = g_strdup(filename);
+  ft->message = g_strdup(msg);
+  ft->size = ft->remaining = filesize;
+
+  ft_state(ft, mwFileTransfer_NEW);
+
+  /* stick a reference in the service */
+  srvc->transfers = g_list_prepend(srvc->transfers, ft);
+
+  return ft;
+}
+
+
+struct mwServiceFileTransfer *
+mwFileTransfer_getService(struct mwFileTransfer *ft) {
+  g_return_val_if_fail(ft != NULL, NULL);
+  return ft->service;
+}
+
+
+enum mwFileTransferState
+mwFileTransfer_getState(struct mwFileTransfer *ft) {
+  g_return_val_if_fail(ft != NULL, mwFileTransfer_UNKNOWN);
+  return ft->state;
+}
+
+
+const struct mwIdBlock *
+mwFileTransfer_getUser(struct mwFileTransfer *ft) {
+  g_return_val_if_fail(ft != NULL, NULL);
+  return &ft->who;
+}
+
+
+const char *
+mwFileTransfer_getMessage(struct mwFileTransfer *ft) {
+  g_return_val_if_fail(ft != NULL, NULL);
+  return ft->message;
+}
+
+
+const char *
+mwFileTransfer_getFileName(struct mwFileTransfer *ft) {
+  g_return_val_if_fail(ft != NULL, NULL);
+  return ft->filename;
+}
+
+
+guint32 mwFileTransfer_getFileSize(struct mwFileTransfer *ft) {
+  g_return_val_if_fail(ft != NULL, 0);
+  return ft->size;
+}
+
+
+guint32 mwFileTransfer_getRemaining(struct mwFileTransfer *ft) {
+  g_return_val_if_fail(ft != NULL, 0);
+  return ft->remaining;
+}
+
+
+int mwFileTransfer_accept(struct mwFileTransfer *ft) {
+  struct mwServiceFileTransfer *srvc;
+  struct mwFileTransferHandler *handler;
+  int ret;
+
+  g_return_val_if_fail(ft != NULL, -1);
+  g_return_val_if_fail(ft->channel != NULL, -1);
+  g_return_val_if_fail(mwFileTransfer_isPending(ft), -1);
+  g_return_val_if_fail(mwChannel_isIncoming(ft->channel), -1);
+  g_return_val_if_fail(mwChannel_isState(ft->channel, mwChannel_WAIT), -1);
+
+  g_return_val_if_fail(ft->service != NULL, -1);
+  srvc = ft->service;
+
+  g_return_val_if_fail(srvc->handler != NULL, -1);
+  handler = srvc->handler;
+
+  ret = mwChannel_accept(ft->channel);
+
+  if(ret) {
+    mwFileTransfer_close(ft, ERR_FAILURE);
+
+  } else {
+    ft_state(ft, mwFileTransfer_OPEN);
+    if(handler->ft_opened)
+      handler->ft_opened(ft);
+  }
+
+  return ret;
+}
+
+
+static void ft_create_chan(struct mwFileTransfer *ft) {
+  struct mwSession *s;
+  struct mwChannelSet *cs;
+  struct mwChannel *chan;
+  struct mwLoginInfo *login;
+  struct mwPutBuffer *b;
+  
+  /* we only should be calling this if there isn't a channel already
+     associated with the conversation */
+  g_return_if_fail(ft != NULL);
+  g_return_if_fail(mwFileTransfer_isNew(ft));
+  g_return_if_fail(ft->channel == NULL);
+		   
+  s = mwService_getSession(MW_SERVICE(ft->service));
+  cs = mwSession_getChannels(s);
+
+  chan = mwChannel_newOutgoing(cs);
+  mwChannel_setService(chan, MW_SERVICE(ft->service));
+  mwChannel_setProtoType(chan, PROTOCOL_TYPE);
+  mwChannel_setProtoVer(chan, PROTOCOL_VER);
+
+  /* offer all known ciphers */
+  mwChannel_populateSupportedCipherInstances(chan);
+
+  /* set the target */
+  login = mwChannel_getUser(chan);
+  login->user_id = g_strdup(ft->who.user);
+  login->community = g_strdup(ft->who.community);
+
+  /* compose the addtl create */
+  b = mwPutBuffer_new();
+  guint32_put(b, 0x00);
+  mwString_put(b, ft->filename);
+  mwString_put(b, ft->message);
+  guint32_put(b, ft->size);
+  guint32_put(b, 0x00);
+  guint16_put(b, 0x00);
+
+  mwPutBuffer_finalize(mwChannel_getAddtlCreate(chan), b);
+
+  ft->channel = mwChannel_create(chan)? NULL: chan;
+  if(ft->channel) {
+    mwChannel_setServiceData(ft->channel, ft, NULL);
+  }
+}
+
+
+int mwFileTransfer_offer(struct mwFileTransfer *ft) {
+  struct mwServiceFileTransfer *srvc;
+  struct mwFileTransferHandler *handler;
+
+  g_return_val_if_fail(ft != NULL, -1);
+  g_return_val_if_fail(ft->channel == NULL, -1);
+  g_return_val_if_fail(mwFileTransfer_isNew(ft), -1);
+
+  g_return_val_if_fail(ft->service != NULL, -1);
+  srvc = ft->service;
+
+  g_return_val_if_fail(srvc->handler != NULL, -1);
+  handler = srvc->handler;
+
+  ft_create_chan(ft);
+  if(ft->channel) {
+    ft_state(ft, mwFileTransfer_PENDING);
+  } else {
+    ft_state(ft, mwFileTransfer_ERROR);
+    mwFileTransfer_close(ft, ERR_FAILURE);
+  }
+
+  return 0;
+}
+
+
+int mwFileTransfer_close(struct mwFileTransfer *ft, guint32 code) {
+  struct mwServiceFileTransfer *srvc;
+  struct mwFileTransferHandler *handler;
+  int ret;
+
+  g_return_val_if_fail(ft != NULL, -1);
+
+  if(mwFileTransfer_isOpen(ft))
+    ft_state(ft, mwFileTransfer_CANCEL_LOCAL);
+
+  if(ft->channel) {
+    ret = mwChannel_destroy(ft->channel, code, NULL);
+    ft->channel = NULL;
+  }
+
+  srvc = ft->service;
+  g_return_val_if_fail(srvc != NULL, ret);
+
+  handler = srvc->handler;
+  g_return_val_if_fail(handler != NULL, ret);
+
+  if(handler->ft_closed)
+    handler->ft_closed(ft, code);
+
+  return ret;
+}
+
+
+void mwFileTransfer_free(struct mwFileTransfer *ft) {
+  struct mwServiceFileTransfer *srvc;
+
+  if(! ft) return;
+
+  srvc = ft->service;
+  if(srvc)
+    srvc->transfers = g_list_remove(srvc->transfers, ft);
+
+  if(ft->channel) {
+    mwChannel_destroy(ft->channel, mwFileTransfer_SUCCESS, NULL);
+    ft->channel = NULL;
+  }
+
+  mwFileTransfer_removeClientData(ft);
+
+  mwIdBlock_clear(&ft->who);
+  g_free(ft->filename);
+  g_free(ft->message);
+  g_free(ft);
+}
+
+
+int mwFileTransfer_send(struct mwFileTransfer *ft,
+			struct mwOpaque *data) {
+
+  struct mwChannel *chan;
+  int ret;
+
+  g_return_val_if_fail(ft != NULL, -1);
+  g_return_val_if_fail(mwFileTransfer_isOpen(ft), -1);
+  g_return_val_if_fail(ft->channel != NULL, -1);
+  chan = ft->channel;
+
+  g_return_val_if_fail(mwChannel_isOutgoing(chan), -1);
+
+  if(data->len > ft->remaining) {
+    /* @todo handle error */
+    return -1;
+  }
+
+  ret = mwChannel_send(chan, msg_TRANSFER, data);
+  if(! ret) ft->remaining -= data->len;
+  
+  /* we're not done until we receive an ACK for the last piece of
+     outgoing data */
+
+  return ret;
+}
+
+
+int mwFileTransfer_ack(struct mwFileTransfer *ft) {
+  struct mwChannel *chan;
+
+  g_return_val_if_fail(ft != NULL, -1);
+
+  chan = ft->channel;
+  g_return_val_if_fail(chan != NULL, -1);
+  g_return_val_if_fail(mwChannel_isIncoming(chan), -1);
+
+  return mwChannel_sendEncrypted(chan, msg_RECEIVED, NULL, FALSE);
+}
+
+
+void mwFileTransfer_setClientData(struct mwFileTransfer *ft,
+				  gpointer data, GDestroyNotify clean) {
+  g_return_if_fail(ft != NULL);
+  mw_datum_set(&ft->client_data, data, clean);
+}
+
+
+gpointer mwFileTransfer_getClientData(struct mwFileTransfer *ft) {
+  g_return_val_if_fail(ft != NULL, NULL);
+  return mw_datum_get(&ft->client_data);
+}
+
+
+void mwFileTransfer_removeClientData(struct mwFileTransfer *ft) {
+  g_return_if_fail(ft != NULL);
+  mw_datum_clear(&ft->client_data);
+}
+