comparison libpurple/protocols/sametime/sametime.c @ 32672:3828a61c44da

A boring and large patch so I can merge heads.

32671:0e69949b3e61

#define BLIST_PREF_IS_STORE()  BLIST_PREF_IS(blist_choice_STORE)
#define BLIST_PREF_IS_SYNCH()  BLIST_PREF_IS(blist_choice_SYNCH)


/* debugging output */
#define DEBUG_ERROR(a...)  purple_debug_error(G_LOG_DOMAIN, a)
#define DEBUG_INFO(a...)   purple_debug_info(G_LOG_DOMAIN, a)
#define DEBUG_MISC(a...)   purple_debug_misc(G_LOG_DOMAIN, a)
#define DEBUG_WARN(a...)   purple_debug_warning(G_LOG_DOMAIN, a)


/** ensure non-null strings */
#ifndef NSTR
# define NSTR(str) ((str)? (str): "(null)")

/** handler IDs from g_log_set_handler in mw_plugin_init */
static guint log_handler[2] = { 0, 0 };


/** the purple plugin data.
    available as gc->proto_data and mwSession_getClientData */
struct mwPurplePluginData {
  struct mwSession *session;

  struct mwServiceAware *srvc_aware;
  struct mwServiceConference *srvc_conf;

  /** event id for the buddy list save callback */
  guint save_event;

  /** socket fd */
  int socket;
  gint outpa;  /* like inpa, but the other way */

  /** circular buffer for outgoing data */
  PurpleCircBuffer *sock_buf;

static struct mwSession *gc_to_session(PurpleConnection *gc) {
  struct mwPurplePluginData *pd;

  g_return_val_if_fail(gc != NULL, NULL);

  pd = gc->proto_data;
  g_return_val_if_fail(pd != NULL, NULL);

  return pd->session;
}

  if(pd->socket) {
    close(pd->socket);
    pd->socket = 0;
  }

  if(gc->inpa) {
    purple_input_remove(gc->inpa);
    gc->inpa = 0;
  }
}


static void mw_session_clear(struct mwSession *session) {

  const char *status = MW_STATE_ACTIVE;

  gc = mwAwareList_getClientData(list);
  acct = purple_connection_get_account(gc);

  pd = gc->proto_data;
  idle = aware->status.time;
  stat = aware->status.status;
  id = aware->id.user;

  if(idle) {

/** ensure that a PurpleBuddy exists in the group with data
    appropriately matching the st user entry from the st list */
static PurpleBuddy *buddy_ensure(PurpleConnection *gc, PurpleGroup *group,
			       struct mwSametimeUser *stuser) {

  struct mwPurplePluginData *pd = gc->proto_data;
  PurpleBuddy *buddy;
  PurpleAccount *acct = purple_connection_get_account(gc);

  const char *id = mwSametimeUser_getUser(stuser);
  const char *name = mwSametimeUser_getShortName(stuser);

  if (!name) {
    DEBUG_WARN("Can't ensure a null group\n");
    return NULL;
  }

  DEBUG_INFO("attempting to ensure group %s, called %s\n",
	     NSTR(name), NSTR(alias));

  /* first attempt at finding the group, by the name key */
  for(gn = purple_blist_get_root(); gn;

  purple_blist_node_set_string(gn, GROUP_KEY_NAME, name);
  purple_blist_node_set_int(gn, GROUP_KEY_TYPE, type);

  if(type == mwSametimeGroup_DYNAMIC) {
    purple_blist_node_set_string(gn, GROUP_KEY_OWNER, owner);
    group_add(gc->proto_data, group);
  }

  return group;
}

  PurpleConnection *gc;
  struct mwIdBlock who = { 0, 0 };
  struct mwConversation *conv;

  gc = purple_conversation_get_gc(g_conv);
  if(pd->gc != gc)
    return; /* not ours */

  if(purple_conversation_get_type(g_conv) != PURPLE_CONV_TYPE_IM)
    return; /* wrong type */

      }
    }
  }

  if(add_buds) {
    purple_account_add_buddies(acct, add_buds);
    g_list_free(add_buds);
  }
}

  if(pd->socket) {
    close(pd->socket);
    pd->socket = 0;
  }

  if(pd->gc->inpa) {
    purple_input_remove(pd->gc->inpa);
    pd->gc->inpa = 0;
  }

  if(! ret) {
    DEBUG_INFO("connection reset\n");
    purple_connection_error(pd->gc,

/** Callback passed to purple_proxy_connect when an account is logged
    in, and if the session logging in receives a redirect message */
static void connect_cb(gpointer data, gint source, const gchar *error_message) {

  struct mwPurplePluginData *pd = data;
  PurpleConnection *gc = pd->gc;

  if(source < 0) {
    /* connection failed */

    if(pd->socket) {

    /* stop any existing login attempt */
    mwSession_stop(pd->session, ERR_SUCCESS);
  }

  pd->socket = source;
  gc->inpa = purple_input_add(source, PURPLE_INPUT_READ,
			    read_cb, pd);

  mwSession_start(pd->session);
}

#define MW_FT_LEN  (BUF_LONG * 2)


static void ft_incoming_cancel(PurpleXfer *xfer) {
  /* incoming transfer rejected or cancelled in-progress */
  struct mwFileTransfer *ft = xfer->data;
  if(ft) mwFileTransfer_reject(ft);
}


static void ft_incoming_init(PurpleXfer *xfer) {

  */

  struct mwFileTransfer *ft;
  FILE *fp;

  ft = xfer->data;

  fp = g_fopen(xfer->local_filename, "wb");
  if(! fp) {
    mwFileTransfer_cancel(ft);
    return;
  }

  xfer = purple_xfer_new(acct, PURPLE_XFER_RECEIVE, who);
  if (xfer)
  {
	purple_xfer_ref(xfer);
	mwFileTransfer_setClientData(ft, xfer, (GDestroyNotify) purple_xfer_unref);
	xfer->data = ft;

	purple_xfer_set_init_fnc(xfer, ft_incoming_init);
	purple_xfer_set_cancel_recv_fnc(xfer, ft_incoming_cancel);
	purple_xfer_set_request_denied_fnc(xfer, ft_incoming_cancel);

}


static void ft_send(struct mwFileTransfer *ft, FILE *fp) {
  guchar buf[MW_FT_LEN];
  struct mwOpaque o = { .data = buf, .len = MW_FT_LEN };
  guint32 rem;
  PurpleXfer *xfer;

  xfer = mwFileTransfer_getClientData(ft);

  if(rem < MW_FT_LEN) o.len = rem;

  if(fread(buf, (size_t) o.len, 1, fp)) {

    /* calculate progress and display it */
    xfer->bytes_sent += o.len;
    xfer->bytes_remaining -= o.len;
    purple_xfer_update_progress(xfer);

    mwFileTransfer_send(ft, &o);

  } else {

    mwFileTransfer_free(ft);
    g_return_if_reached();
  }

  if(purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) {
    xfer->dest_fp = g_fopen(xfer->local_filename, "rb");
    ft_send(ft, xfer->dest_fp);
  }
}

  PurpleXfer *xfer;

  xfer = mwFileTransfer_getClientData(ft);
  if(xfer) {
    xfer->data = NULL;

    if(! mwFileTransfer_getRemaining(ft)) {
      purple_xfer_set_completed(xfer, TRUE);
      purple_xfer_end(xfer);

    purple_xfer_cancel_local(xfer);
    return;
  }

  /* update the progress */
  xfer->bytes_sent += data->len;
  xfer->bytes_remaining -= data->len;
  purple_xfer_update_progress(xfer);

  /* let the other side know we got it, and to send some more */
  mwFileTransfer_ack(ft);
}

static void mw_ft_ack(struct mwFileTransfer *ft) {
  PurpleXfer *xfer;

  xfer = mwFileTransfer_getClientData(ft);
  g_return_if_fail(xfer != NULL);
  g_return_if_fail(xfer->watcher == 0);

  if(! mwFileTransfer_getRemaining(ft)) {
    purple_xfer_set_completed(xfer, TRUE);
    purple_xfer_end(xfer);

  tmp = mwError(err);
  text = g_strconcat(_("Unable to send message: "), tmp, NULL);

  gconv = convo_get_gconv(conv);
  if(gconv && !purple_conv_present_error(idb->user, gconv->account, text)) {

    g_free(text);
    text = g_strdup_printf(_("Unable to send message to %s:"),
			   (idb->user)? idb->user: "(unknown)");
    purple_notify_error(purple_account_get_connection(gconv->account),
		      NULL, text, tmp);
  }

  g_free(tmp);
  g_free(text);

  PurpleConnection *gc;

  gconv = convo_get_gconv(conv);
  if(! gconv) return;

  gc = purple_conversation_get_gc(gconv);
  if(! gc) return;

  purple_conversation_set_features(gconv, gc->flags);
}


/** called when a mw conversation and purple conversation come together,
    to inform the purple conversation of what features to offer the

  mwSession_addCipher(pd->session, mwCipher_new_RC2_40(pd->session));
  mwSession_addCipher(pd->session, mwCipher_new_RC2_128(pd->session));

  mwSession_setClientData(pd->session, pd, NULL);
  gc->proto_data = pd;

  return pd;
}


static void mwPurplePluginData_free(struct mwPurplePluginData *pd) {
  g_return_if_fail(pd != NULL);

  pd->gc->proto_data = NULL;

  mwSession_removeService(pd->session, mwService_AWARE);
  mwSession_removeService(pd->session, mwService_CONFERENCE);
  mwSession_removeService(pd->session, mwService_FILE_TRANSFER);
  mwSession_removeService(pd->session, mwService_IM);

  struct mwPurplePluginData *pd;
  struct mwAwareIdBlock t = { mwAware_USER, (char *)purple_buddy_get_name(b), NULL };
  const char *ret = NULL;

  if ((gc = purple_account_get_connection(purple_buddy_get_account(b)))
      && (pd = gc->proto_data))
    ret = mwServiceAware_getText(pd->srvc_aware, &t);

  return (ret && g_utf8_validate(ret, -1, NULL)) ? g_markup_escape_text(ret, -1): NULL;
}

  const char *message = NULL;
  const char *status;
  char *tmp;

  if ((gc = purple_account_get_connection(purple_buddy_get_account(b)))
      && (pd = gc->proto_data))
     message = mwServiceAware_getText(pd->srvc_aware, &idb);

  status = status_text(b);

  if(message != NULL && g_utf8_validate(message, -1, NULL) && purple_utf8_strcasecmp(status, message)) {

  struct mwConference *conf;
  struct mwIdBlock idb = { NULL, NULL };

  acct = purple_buddy_get_account(buddy);
  gc = purple_account_get_connection(acct);
  pd = gc->proto_data;
  srvc = pd->srvc_conf;

  f = purple_request_fields_get_field(fields, CHAT_KEY_TOPIC);
  topic = purple_request_field_string_get_value(f);

  g_return_if_fail(acct != NULL);

  gc = purple_account_get_connection(acct);
  g_return_if_fail(gc != NULL);

  pd = gc->proto_data;
  g_return_if_fail(pd != NULL);

  /*
    - get a list of all conferences on this session
    - if none, prompt to create one, and invite buddy to it

  g_return_if_fail(acct != NULL);

  gc = purple_account_get_connection(acct);
  g_return_if_fail(gc != NULL);

  pd = gc->proto_data;
  g_return_if_fail(pd != NULL);

  rcpt_name = g_strdup_printf("@U %s", buddy->name);
  rcpt = g_list_prepend(NULL, rcpt_name);

static void mw_prpl_login(PurpleAccount *acct);


static void prompt_host_cancel_cb(PurpleConnection *gc) {
  const char *msg = _("No Sametime Community Server specified");
  purple_connection_error(gc,
                                 PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
                                 msg);
}


static void prompt_host_ok_cb(PurpleConnection *gc, const char *host) {
  if(host && *host) {
    PurpleAccount *acct = purple_connection_get_account(gc);
    purple_account_set_string(acct, MW_KEY_HOST, host);
    mw_prpl_login(acct);

  } else {
    prompt_host_cancel_cb(gc);
  }
}


static void prompt_host(PurpleConnection *gc) {
  PurpleAccount *acct;
  const char *msgA;
  char *msg;

  acct = purple_connection_get_account(gc);
  msgA = _("No host or IP address has been configured for the"
	  " Meanwhile account %s. Please enter one below to"
	  " continue logging in.");
  msg = g_strdup_printf(msgA, NSTR(purple_account_get_username(acct)));

  purple_request_input(gc, _("Meanwhile Connection Setup"),
		     _("No Sametime Community Server Specified"), msg,
		     MW_PLUGIN_DEFAULT_HOST, FALSE, FALSE, NULL,
		     _("Connect"), G_CALLBACK(prompt_host_ok_cb),
		     _("Cancel"), G_CALLBACK(prompt_host_cancel_cb),
			 acct, NULL, NULL,
		     gc);

  g_free(msg);
}


static void mw_prpl_login(PurpleAccount *account) {
  PurpleConnection *gc;
  struct mwPurplePluginData *pd;

  char *user, *pass, *host;

  gc = purple_account_get_connection(account);
  pd = mwPurplePluginData_new(gc);

  /* while we do support images, the default is to not offer it */
  gc->flags |= PURPLE_CONNECTION_NO_IMAGES;

  user = g_strdup(purple_account_get_username(account));

  host = strrchr(user, ':');
  if(host) {

  if(! host || ! *host) {
    /* somehow, we don't have a host to connect to. Well, we need one
       to actually continue, so let's ask the user directly. */
    g_free(user);
    prompt_host(gc);
    return;
  }

  pass = g_strdup(purple_account_get_password(account));
  port = purple_account_get_int(account, MW_KEY_PORT, MW_PLUGIN_DEFAULT_PORT);

static void mw_prpl_close(PurpleConnection *gc) {
  struct mwPurplePluginData *pd;

  g_return_if_fail(gc != NULL);

  pd = gc->proto_data;
  g_return_if_fail(pd != NULL);

  /* get rid of the blist save timeout */
  if(pd->save_event) {
    purple_timeout_remove(pd->save_event);

  /* stop the session */
  mwSession_stop(pd->session, 0x00);

  /* no longer necessary */
  gc->proto_data = NULL;

  /* stop watching the socket */
  if(gc->inpa) {
    purple_input_remove(gc->inpa);
    gc->inpa = 0;
  }

  /* clean up the rest */
  mwPurplePluginData_free(pd);
}

  struct mwPurplePluginData *pd;
  struct mwIdBlock who = { (char *) name, NULL };
  struct mwConversation *conv;

  g_return_val_if_fail(gc != NULL, 0);
  pd = gc->proto_data;

  g_return_val_if_fail(pd != NULL, 0);

  conv = mwServiceIm_getConversation(pd->srvc_im, &who);

  struct mwConversation *conv;

  gpointer t = GINT_TO_POINTER(!! state);

  g_return_val_if_fail(gc != NULL, 0);
  pd = gc->proto_data;

  g_return_val_if_fail(pd != NULL, 0);

  conv = mwServiceIm_getConversation(pd->srvc_im, &who);

  const char *tmp2;

  g_return_if_fail(who != NULL);
  g_return_if_fail(*who != '\0');

  pd = gc->proto_data;

  acct = purple_connection_get_account(gc);
  b = purple_find_buddy(acct, who);
  user_info = purple_notify_user_info_new();

  g_return_if_fail(data != NULL);

  buddy = data->buddy;

  gc = purple_account_get_connection(purple_buddy_get_account(buddy));
  pd = gc->proto_data;

  if(results)
    res = results->data;

  if(!code && res && res->matches) {

}


static void mw_prpl_add_buddy(PurpleConnection *gc,
			      PurpleBuddy *buddy,
			      PurpleGroup *group) {

  struct mwPurplePluginData *pd = gc->proto_data;
  struct mwServiceResolve *srvc;
  GList *query;
  enum mwResolveFlag flags;
  guint32 req;
  BuddyAddData *data;

}


static void mw_prpl_add_buddies(PurpleConnection *gc,
				GList *buddies,
				GList *groups) {

  struct mwPurplePluginData *pd;
  GHashTable *group_sets;
  struct mwAwareIdBlock *idbs, *idb;

  pd = gc->proto_data;

  /* map PurpleGroup:GList of mwAwareIdBlock */
  group_sets = g_hash_table_new(g_direct_hash, g_direct_equal);

  /* bunch of mwAwareIdBlock allocated at once, free'd at once */

  struct mwAwareIdBlock idb = { mwAware_USER, (char *)purple_buddy_get_name(buddy), NULL };
  struct mwAwareList *list;

  GList *rem = g_list_prepend(NULL, &idb);

  pd = gc->proto_data;
  group = purple_buddy_get_group(buddy);
  list = list_ensure(pd, group);

  mwAwareList_removeAware(list, rem);
  blist_schedule(pd);

  g_return_if_fail(gc != NULL);

  acct = purple_connection_get_account(gc);
  g_return_if_fail(acct != NULL);

  pd = gc->proto_data;
  g_return_if_fail(pd != NULL);

  session = pd->session;
  g_return_if_fail(session != NULL);

  switch(acct->perm_deny) {
  case PURPLE_PRIVACY_DENY_USERS:
    DEBUG_INFO("PURPLE_PRIVACY_DENY_USERS\n");
    privacy_fill(&privacy, acct->deny);
    privacy.deny = TRUE;
    break;

    DEBUG_INFO("PURPLE_PRIVACY_DENY_ALL\n");
    privacy.deny = FALSE;
    break;

  default:
    DEBUG_INFO("acct->perm_deny is 0x%x\n", acct->perm_deny);
    return;
  }

  mwSession_setPrivacyInfo(session, &privacy);
  g_free(privacy.users);

			      GHashTable *components) {

  struct mwPurplePluginData *pd;
  char *c, *t;

  pd = gc->proto_data;

  c = g_hash_table_lookup(components, CHAT_KEY_NAME);
  t = g_hash_table_lookup(components, CHAT_KEY_TOPIC);

  if(g_hash_table_lookup(components, CHAT_KEY_IS_PLACE)) {

  struct mwPurplePluginData *pd;
  struct mwServiceConference *srvc;
  char *c;

  pd = gc->proto_data;
  srvc = pd->srvc_conf;

  if(g_hash_table_lookup(components, CHAT_KEY_IS_PLACE)) {
    ; /* nothing needs doing */

  struct mwPurplePluginData *pd;
  struct mwConference *conf;
  struct mwPlace *place;
  struct mwIdBlock idb = { (char *) who, NULL };

  pd = gc->proto_data;
  g_return_if_fail(pd != NULL);

  conf = ID_TO_CONF(pd, id);

  if(conf) {

			       int id) {

  struct mwPurplePluginData *pd;
  struct mwConference *conf;

  pd = gc->proto_data;

  g_return_if_fail(pd != NULL);
  conf = ID_TO_CONF(pd, id);

  if(conf) {

  struct mwPurplePluginData *pd;
  struct mwConference *conf;
  char *msg;
  int ret;

  pd = gc->proto_data;

  g_return_val_if_fail(pd != NULL, 0);
  conf = ID_TO_CONF(pd, id);

  msg = purple_markup_strip_html(message);

static void mw_prpl_alias_buddy(PurpleConnection *gc,
				const char *who,
				const char *alias) {

  struct mwPurplePluginData *pd = gc->proto_data;
  g_return_if_fail(pd != NULL);

  /* it's a change to the buddy list, so we've gotta reflect that in
     the server copy */

				const char *new_group) {

  struct mwAwareIdBlock idb = { mwAware_USER, (char *) who, NULL };
  GList *gl = g_list_prepend(NULL, &idb);

  struct mwPurplePluginData *pd = gc->proto_data;
  PurpleGroup *group;
  struct mwAwareList *list;

  /* add who to new_group's aware list */
  group = purple_find_group(new_group);

static void mw_prpl_rename_group(PurpleConnection *gc,
				 const char *old,
				 PurpleGroup *group,
				 GList *buddies) {

  struct mwPurplePluginData *pd = gc->proto_data;
  g_return_if_fail(pd != NULL);

  /* it's a change in the buddy list, so we've gotta reflect that in
     the server copy. Also, having this function should prevent all
     those buddies from being removed and re-added. We don't really

  ;
}


static void mw_prpl_convo_closed(PurpleConnection *gc, const char *who) {
  struct mwPurplePluginData *pd = gc->proto_data;
  struct mwServiceIm *srvc;
  struct mwConversation *conv;
  struct mwIdBlock idb = { (char *) who, NULL };

  g_return_if_fail(pd != NULL);

static void mw_prpl_remove_group(PurpleConnection *gc, PurpleGroup *group) {
  struct mwPurplePluginData *pd;
  struct mwAwareList *list;

  pd = gc->proto_data;
  g_return_if_fail(pd != NULL);
  g_return_if_fail(pd->group_list_map != NULL);

  list = g_hash_table_lookup(pd->group_list_map, group);

  struct mwServiceAware *srvc;
  PurpleAccount *acct;

  g_return_val_if_fail(gc != NULL, FALSE);

  pd = gc->proto_data;
  g_return_val_if_fail(pd != NULL, FALSE);

  srvc = pd->srvc_aware;
  g_return_val_if_fail(srvc != NULL, FALSE);

  DEBUG_INFO("ft_outgoing_init\n");

  acct = purple_xfer_get_account(xfer);
  gc = purple_account_get_connection(acct);
  pd = gc->proto_data;
  srvc = pd->srvc_ft;

  filename = purple_xfer_get_local_filename(xfer);
  filesize = purple_xfer_get_size(xfer);
  idb.user = xfer->who;

  purple_xfer_update_progress(xfer);

  /* test that we can actually send the file */
  fp = g_fopen(filename, "rb");
  if(! fp) {
    char *msg = g_strdup_printf(_("Error reading file %s: \n%s\n"),
				filename, g_strerror(errno));
    purple_xfer_error(purple_xfer_get_type(xfer), acct, xfer->who, msg);
    g_free(msg);
    return;
  }
  fclose(fp);

  ft = mwFileTransfer_new(srvc, &idb, NULL, filename, filesize);

  purple_xfer_ref(xfer);
  mwFileTransfer_setClientData(ft, xfer, (GDestroyNotify) purple_xfer_unref);
  xfer->data = ft;

  mwFileTransfer_offer(ft);
}


static void ft_outgoing_cancel(PurpleXfer *xfer) {
  struct mwFileTransfer *ft = xfer->data;

  DEBUG_INFO("ft_outgoing_cancel called\n");

  if(ft) mwFileTransfer_cancel(ft);
}

  }
}


static PurplePluginProtocolInfo mw_prpl_info = {
  .options                   = OPT_PROTO_IM_IMAGE,
  .user_splits               = NULL, /*< set in mw_plugin_init */
  .protocol_options          = NULL, /*< set in mw_plugin_init */
  .icon_spec                 = NO_BUDDY_ICONS,
  .list_icon                 = mw_prpl_list_icon,
  .list_emblem               = mw_prpl_list_emblem,
  .status_text               = mw_prpl_status_text,
  .tooltip_text              = mw_prpl_tooltip_text,
  .status_types              = mw_prpl_status_types,
  .blist_node_menu           = mw_prpl_blist_node_menu,
  .chat_info                 = mw_prpl_chat_info,
  .chat_info_defaults        = mw_prpl_chat_info_defaults,
  .login                     = mw_prpl_login,
  .close                     = mw_prpl_close,
  .send_im                   = mw_prpl_send_im,
  .set_info                  = NULL,
  .send_typing               = mw_prpl_send_typing,
  .get_info                  = mw_prpl_get_info,
  .set_status                = mw_prpl_set_status,
  .set_idle                  = mw_prpl_set_idle,
  .change_passwd             = NULL,
  .add_buddy                 = mw_prpl_add_buddy,
  .add_buddies               = mw_prpl_add_buddies,
  .remove_buddy              = mw_prpl_remove_buddy,
  .remove_buddies            = NULL,
  .add_permit                = mw_prpl_add_permit,
  .add_deny                  = mw_prpl_add_deny,
  .rem_permit                = mw_prpl_rem_permit,
  .rem_deny                  = mw_prpl_rem_deny,
  .set_permit_deny           = mw_prpl_set_permit_deny,
  .join_chat                 = mw_prpl_join_chat,
  .reject_chat               = mw_prpl_reject_chat,
  .get_chat_name             = mw_prpl_get_chat_name,
  .chat_invite               = mw_prpl_chat_invite,
  .chat_leave                = mw_prpl_chat_leave,
  .chat_whisper              = mw_prpl_chat_whisper,
  .chat_send                 = mw_prpl_chat_send,
  .keepalive                 = mw_prpl_keepalive,
  .register_user             = NULL,
  .get_cb_info               = NULL,
  .get_cb_away               = NULL,
  .alias_buddy               = mw_prpl_alias_buddy,
  .group_buddy               = mw_prpl_group_buddy,
  .rename_group              = mw_prpl_rename_group,
  .buddy_free                = mw_prpl_buddy_free,
  .convo_closed              = mw_prpl_convo_closed,
  .normalize                 = mw_prpl_normalize,
  .set_buddy_icon            = NULL,
  .remove_group              = mw_prpl_remove_group,
  .get_cb_real_name          = NULL,
  .set_chat_topic            = NULL,
  .find_blist_chat           = NULL,
  .roomlist_get_list         = NULL,
  .roomlist_expand_category  = NULL,
  .can_receive_file          = mw_prpl_can_receive_file,
  .send_file                 = mw_prpl_send_file,
  .new_xfer                  = mw_prpl_new_xfer,
  .offline_message           = NULL,
  .whiteboard_prpl_ops       = NULL,
  .send_raw                  = NULL,
  .struct_size               = sizeof(PurplePluginProtocolInfo)
};


static PurplePluginPrefFrame *
mw_plugin_get_plugin_pref_frame(PurplePlugin *plugin) {

  struct mwServiceResolve *srvc;
  GList *query;
  enum mwResolveFlag flags;
  guint32 req;

  pd = gc->proto_data;
  srvc = pd->srvc_resolve;

  query = g_list_prepend(NULL, (char *) name);
  flags = mwResolveFlag_FIRST | mwResolveFlag_GROUPS;

  struct mwServiceResolve *srvc;
  GList *query;
  enum mwResolveFlag flags;
  guint32 req;

  pd = gc->proto_data;
  srvc = pd->srvc_resolve;

  query = g_list_prepend(NULL, (char *) name);
  flags = mwResolveFlag_FIRST | mwResolveFlag_USERS;

  }
}


static void mw_plugin_init(PurplePlugin *plugin) {
  PurpleAccountOption *opt;
  GList *l = NULL;

  GLogLevelFlags logflags =
    G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION;

  /* set up the preferences */
  purple_prefs_add_none(MW_PRPL_OPT_BASE);
  purple_prefs_add_int(MW_PRPL_OPT_BLIST_ACTION, BLIST_CHOICE_DEFAULT);

  /* remove dead preferences */
  purple_prefs_remove(MW_PRPL_OPT_PSYCHIC);
  purple_prefs_remove(MW_PRPL_OPT_SAVE_DYNAMIC);

  /* host to connect to */
  opt = purple_account_option_string_new(_("Server"), MW_KEY_HOST,
				       MW_PLUGIN_DEFAULT_HOST);
  l = g_list_append(l, opt);

  /* port to connect to */
  opt = purple_account_option_int_new(_("Port"), MW_KEY_PORT,
				    MW_PLUGIN_DEFAULT_PORT);
  l = g_list_append(l, opt);

32672:3828a61c44da

#define BLIST_PREF_IS_STORE()  BLIST_PREF_IS(blist_choice_STORE)
#define BLIST_PREF_IS_SYNCH()  BLIST_PREF_IS(blist_choice_SYNCH)


/* debugging output */
#define DEBUG_ERROR(...)  purple_debug_error(G_LOG_DOMAIN, __VA_ARGS__)
#define DEBUG_INFO(...)   purple_debug_info(G_LOG_DOMAIN, __VA_ARGS__)
#define DEBUG_MISC(...)   purple_debug_misc(G_LOG_DOMAIN, __VA_ARGS__)
#define DEBUG_WARN(...)   purple_debug_warning(G_LOG_DOMAIN, __VA_ARGS__)


/** ensure non-null strings */
#ifndef NSTR
# define NSTR(str) ((str)? (str): "(null)")

/** handler IDs from g_log_set_handler in mw_plugin_init */
static guint log_handler[2] = { 0, 0 };


/** the purple plugin data.
    available as purple_connection_get_protocol_data(gc) and mwSession_getClientData */
struct mwPurplePluginData {
  struct mwSession *session;

  struct mwServiceAware *srvc_aware;
  struct mwServiceConference *srvc_conf;

  /** event id for the buddy list save callback */
  guint save_event;

  /** socket fd */
  int socket;
  guint inpa;  /* input watcher */
  gint outpa;  /* like inpa, but the other way */

  /** circular buffer for outgoing data */
  PurpleCircBuffer *sock_buf;

static struct mwSession *gc_to_session(PurpleConnection *gc) {
  struct mwPurplePluginData *pd;

  g_return_val_if_fail(gc != NULL, NULL);

  pd = purple_connection_get_protocol_data(gc);
  g_return_val_if_fail(pd != NULL, NULL);

  return pd->session;
}

  if(pd->socket) {
    close(pd->socket);
    pd->socket = 0;
  }

  if(pd->inpa) {
    purple_input_remove(pd->inpa);
    pd->inpa = 0;
  }
}


static void mw_session_clear(struct mwSession *session) {

  const char *status = MW_STATE_ACTIVE;

  gc = mwAwareList_getClientData(list);
  acct = purple_connection_get_account(gc);

  pd = purple_connection_get_protocol_data(gc);
  idle = aware->status.time;
  stat = aware->status.status;
  id = aware->id.user;

  if(idle) {

/** ensure that a PurpleBuddy exists in the group with data
    appropriately matching the st user entry from the st list */
static PurpleBuddy *buddy_ensure(PurpleConnection *gc, PurpleGroup *group,
			       struct mwSametimeUser *stuser) {

  struct mwPurplePluginData *pd = purple_connection_get_protocol_data(gc);
  PurpleBuddy *buddy;
  PurpleAccount *acct = purple_connection_get_account(gc);

  const char *id = mwSametimeUser_getUser(stuser);
  const char *name = mwSametimeUser_getShortName(stuser);

  if (!name) {
    DEBUG_WARN("Can't ensure a null group\n");
    return NULL;
  }

  if (!name) {
    DEBUG_WARN("Can't ensure a null group\n");
    return NULL;
  }

  DEBUG_INFO("attempting to ensure group %s, called %s\n",
	     NSTR(name), NSTR(alias));

  /* first attempt at finding the group, by the name key */
  for(gn = purple_blist_get_root(); gn;

  purple_blist_node_set_string(gn, GROUP_KEY_NAME, name);
  purple_blist_node_set_int(gn, GROUP_KEY_TYPE, type);

  if(type == mwSametimeGroup_DYNAMIC) {
    purple_blist_node_set_string(gn, GROUP_KEY_OWNER, owner);
    group_add(purple_connection_get_protocol_data(gc), group);
  }

  return group;
}

  PurpleConnection *gc;
  struct mwIdBlock who = { 0, 0 };
  struct mwConversation *conv;

  gc = purple_conversation_get_connection(g_conv);
  if(pd->gc != gc)
    return; /* not ours */

  if(purple_conversation_get_type(g_conv) != PURPLE_CONV_TYPE_IM)
    return; /* wrong type */

      }
    }
  }

  if(add_buds) {
    purple_account_add_buddies(acct, add_buds, NULL);
    g_list_free(add_buds);
  }
}

  if(pd->socket) {
    close(pd->socket);
    pd->socket = 0;
  }

  if(pd->inpa) {
    purple_input_remove(pd->inpa);
    pd->inpa = 0;
  }

  if(! ret) {
    DEBUG_INFO("connection reset\n");
    purple_connection_error(pd->gc,

/** Callback passed to purple_proxy_connect when an account is logged
    in, and if the session logging in receives a redirect message */
static void connect_cb(gpointer data, gint source, const gchar *error_message) {

  struct mwPurplePluginData *pd = data;

  if(source < 0) {
    /* connection failed */

    if(pd->socket) {

    /* stop any existing login attempt */
    mwSession_stop(pd->session, ERR_SUCCESS);
  }

  pd->socket = source;
  pd->inpa = purple_input_add(source, PURPLE_INPUT_READ,
			    read_cb, pd);

  mwSession_start(pd->session);
}

#define MW_FT_LEN  (BUF_LONG * 2)


static void ft_incoming_cancel(PurpleXfer *xfer) {
  /* incoming transfer rejected or cancelled in-progress */
  struct mwFileTransfer *ft = purple_xfer_get_protocol_data(xfer);
  if(ft) mwFileTransfer_reject(ft);
}


static void ft_incoming_init(PurpleXfer *xfer) {

  */

  struct mwFileTransfer *ft;
  FILE *fp;

  ft = purple_xfer_get_protocol_data(xfer);

  fp = g_fopen(purple_xfer_get_local_filename(xfer), "wb");
  if(! fp) {
    mwFileTransfer_cancel(ft);
    return;
  }

  xfer = purple_xfer_new(acct, PURPLE_XFER_RECEIVE, who);
  if (xfer)
  {
	purple_xfer_ref(xfer);
	mwFileTransfer_setClientData(ft, xfer, (GDestroyNotify) purple_xfer_unref);
	purple_xfer_set_protocol_data(xfer, ft);

	purple_xfer_set_init_fnc(xfer, ft_incoming_init);
	purple_xfer_set_cancel_recv_fnc(xfer, ft_incoming_cancel);
	purple_xfer_set_request_denied_fnc(xfer, ft_incoming_cancel);

}


static void ft_send(struct mwFileTransfer *ft, FILE *fp) {
  guchar buf[MW_FT_LEN];
  struct mwOpaque o = { MW_FT_LEN, buf };
  guint32 rem;
  PurpleXfer *xfer;

  xfer = mwFileTransfer_getClientData(ft);

  if(rem < MW_FT_LEN) o.len = rem;

  if(fread(buf, (size_t) o.len, 1, fp)) {

    /* calculate progress and display it */
    purple_xfer_set_bytes_sent(xfer, purple_xfer_get_bytes_sent(xfer) + o.len);
    purple_xfer_update_progress(xfer);

    mwFileTransfer_send(ft, &o);

  } else {

    mwFileTransfer_free(ft);
    g_return_if_reached();
  }

  if(purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) {
    xfer->dest_fp = g_fopen(purple_xfer_get_local_filename(xfer), "rb");
    ft_send(ft, xfer->dest_fp);
  }
}

  PurpleXfer *xfer;

  xfer = mwFileTransfer_getClientData(ft);
  if(xfer) {
    purple_xfer_set_protocol_data(xfer, NULL);

    if(! mwFileTransfer_getRemaining(ft)) {
      purple_xfer_set_completed(xfer, TRUE);
      purple_xfer_end(xfer);

    purple_xfer_cancel_local(xfer);
    return;
  }

  /* update the progress */
  purple_xfer_set_bytes_sent(xfer, purple_xfer_get_bytes_sent(xfer) + data->len);
  purple_xfer_update_progress(xfer);

  /* let the other side know we got it, and to send some more */
  mwFileTransfer_ack(ft);
}

static void mw_ft_ack(struct mwFileTransfer *ft) {
  PurpleXfer *xfer;

  xfer = mwFileTransfer_getClientData(ft);
  g_return_if_fail(xfer != NULL);
  g_return_if_fail(purple_xfer_get_watcher(xfer) == 0);

  if(! mwFileTransfer_getRemaining(ft)) {
    purple_xfer_set_completed(xfer, TRUE);
    purple_xfer_end(xfer);

  tmp = mwError(err);
  text = g_strconcat(_("Unable to send message: "), tmp, NULL);

  gconv = convo_get_gconv(conv);
  if(gconv && !purple_conv_present_error(idb->user, purple_conversation_get_account(gconv), text)) {

    g_free(text);
    text = g_strdup_printf(_("Unable to send message to %s:"),
			   (idb->user)? idb->user: "(unknown)");
    purple_notify_error(purple_account_get_connection(purple_conversation_get_account(gconv)),
		      NULL, text, tmp);
  }

  g_free(tmp);
  g_free(text);

  PurpleConnection *gc;

  gconv = convo_get_gconv(conv);
  if(! gconv) return;

  gc = purple_conversation_get_connection(gconv);
  if(! gc) return;

  purple_conversation_set_features(gconv, purple_connection_get_flags(gc));
}


/** called when a mw conversation and purple conversation come together,
    to inform the purple conversation of what features to offer the

  mwSession_addCipher(pd->session, mwCipher_new_RC2_40(pd->session));
  mwSession_addCipher(pd->session, mwCipher_new_RC2_128(pd->session));

  mwSession_setClientData(pd->session, pd, NULL);
  purple_connection_set_protocol_data(gc, pd);

  return pd;
}


static void mwPurplePluginData_free(struct mwPurplePluginData *pd) {
  g_return_if_fail(pd != NULL);

  purple_connection_set_protocol_data(pd->gc, NULL);

  mwSession_removeService(pd->session, mwService_AWARE);
  mwSession_removeService(pd->session, mwService_CONFERENCE);
  mwSession_removeService(pd->session, mwService_FILE_TRANSFER);
  mwSession_removeService(pd->session, mwService_IM);

  struct mwPurplePluginData *pd;
  struct mwAwareIdBlock t = { mwAware_USER, (char *)purple_buddy_get_name(b), NULL };
  const char *ret = NULL;

  if ((gc = purple_account_get_connection(purple_buddy_get_account(b)))
      && (pd = purple_connection_get_protocol_data(gc)))
    ret = mwServiceAware_getText(pd->srvc_aware, &t);

  return (ret && g_utf8_validate(ret, -1, NULL)) ? g_markup_escape_text(ret, -1): NULL;
}

  const char *message = NULL;
  const char *status;
  char *tmp;

  if ((gc = purple_account_get_connection(purple_buddy_get_account(b)))
      && (pd = purple_connection_get_protocol_data(gc)))
     message = mwServiceAware_getText(pd->srvc_aware, &idb);

  status = status_text(b);

  if(message != NULL && g_utf8_validate(message, -1, NULL) && purple_utf8_strcasecmp(status, message)) {

  struct mwConference *conf;
  struct mwIdBlock idb = { NULL, NULL };

  acct = purple_buddy_get_account(buddy);
  gc = purple_account_get_connection(acct);
  pd = purple_connection_get_protocol_data(gc);
  srvc = pd->srvc_conf;

  f = purple_request_fields_get_field(fields, CHAT_KEY_TOPIC);
  topic = purple_request_field_string_get_value(f);

  g_return_if_fail(acct != NULL);

  gc = purple_account_get_connection(acct);
  g_return_if_fail(gc != NULL);

  pd = purple_connection_get_protocol_data(gc);
  g_return_if_fail(pd != NULL);

  /*
    - get a list of all conferences on this session
    - if none, prompt to create one, and invite buddy to it

  g_return_if_fail(acct != NULL);

  gc = purple_account_get_connection(acct);
  g_return_if_fail(gc != NULL);

  pd = purple_connection_get_protocol_data(gc);
  g_return_if_fail(pd != NULL);

  rcpt_name = g_strdup_printf("@U %s", buddy->name);
  rcpt = g_list_prepend(NULL, rcpt_name);

static void mw_prpl_login(PurpleAccount *acct);


static void mw_prpl_login(PurpleAccount *account) {
  PurpleConnection *gc;
  struct mwPurplePluginData *pd;

  char *user, *pass, *host;

  gc = purple_account_get_connection(account);
  pd = mwPurplePluginData_new(gc);

  /* while we do support images, the default is to not offer it */
  purple_connection_set_flags(gc, PURPLE_CONNECTION_NO_IMAGES);

  user = g_strdup(purple_account_get_username(account));

  host = strrchr(user, ':');
  if(host) {

  if(! host || ! *host) {
    /* somehow, we don't have a host to connect to. Well, we need one
       to actually continue, so let's ask the user directly. */
    g_free(user);
    purple_connection_error(gc,
            PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
            _("A server is required to connect this account"));
    return;
  }

  pass = g_strdup(purple_account_get_password(account));
  port = purple_account_get_int(account, MW_KEY_PORT, MW_PLUGIN_DEFAULT_PORT);

static void mw_prpl_close(PurpleConnection *gc) {
  struct mwPurplePluginData *pd;

  g_return_if_fail(gc != NULL);

  pd = purple_connection_get_protocol_data(gc);
  g_return_if_fail(pd != NULL);

  /* get rid of the blist save timeout */
  if(pd->save_event) {
    purple_timeout_remove(pd->save_event);

  /* stop the session */
  mwSession_stop(pd->session, 0x00);

  /* no longer necessary */
  purple_connection_set_protocol_data(gc, NULL);

  /* stop watching the socket */
  if(pd->inpa) {
    purple_input_remove(pd->inpa);
    pd->inpa = 0;
  }

  /* clean up the rest */
  mwPurplePluginData_free(pd);
}

  struct mwPurplePluginData *pd;
  struct mwIdBlock who = { (char *) name, NULL };
  struct mwConversation *conv;

  g_return_val_if_fail(gc != NULL, 0);
  pd = purple_connection_get_protocol_data(gc);

  g_return_val_if_fail(pd != NULL, 0);

  conv = mwServiceIm_getConversation(pd->srvc_im, &who);

  struct mwConversation *conv;

  gpointer t = GINT_TO_POINTER(!! state);

  g_return_val_if_fail(gc != NULL, 0);
  pd = purple_connection_get_protocol_data(gc);

  g_return_val_if_fail(pd != NULL, 0);

  conv = mwServiceIm_getConversation(pd->srvc_im, &who);

  const char *tmp2;

  g_return_if_fail(who != NULL);
  g_return_if_fail(*who != '\0');

  pd = purple_connection_get_protocol_data(gc);

  acct = purple_connection_get_account(gc);
  b = purple_find_buddy(acct, who);
  user_info = purple_notify_user_info_new();

  g_return_if_fail(data != NULL);

  buddy = data->buddy;

  gc = purple_account_get_connection(purple_buddy_get_account(buddy));
  pd = purple_connection_get_protocol_data(gc);

  if(results)
    res = results->data;

  if(!code && res && res->matches) {

}


static void mw_prpl_add_buddy(PurpleConnection *gc,
			      PurpleBuddy *buddy,
			      PurpleGroup *group,
			      const char *message) {

  struct mwPurplePluginData *pd = purple_connection_get_protocol_data(gc);
  struct mwServiceResolve *srvc;
  GList *query;
  enum mwResolveFlag flags;
  guint32 req;
  BuddyAddData *data;

}


static void mw_prpl_add_buddies(PurpleConnection *gc,
				GList *buddies,
				GList *groups,
				const char *message) {

  struct mwPurplePluginData *pd;
  GHashTable *group_sets;
  struct mwAwareIdBlock *idbs, *idb;

  pd = purple_connection_get_protocol_data(gc);

  /* map PurpleGroup:GList of mwAwareIdBlock */
  group_sets = g_hash_table_new(g_direct_hash, g_direct_equal);

  /* bunch of mwAwareIdBlock allocated at once, free'd at once */

  struct mwAwareIdBlock idb = { mwAware_USER, (char *)purple_buddy_get_name(buddy), NULL };
  struct mwAwareList *list;

  GList *rem = g_list_prepend(NULL, &idb);

  pd = purple_connection_get_protocol_data(gc);
  group = purple_buddy_get_group(buddy);
  list = list_ensure(pd, group);

  mwAwareList_removeAware(list, rem);
  blist_schedule(pd);

  g_return_if_fail(gc != NULL);

  acct = purple_connection_get_account(gc);
  g_return_if_fail(acct != NULL);

  pd = purple_connection_get_protocol_data(gc);
  g_return_if_fail(pd != NULL);

  session = pd->session;
  g_return_if_fail(session != NULL);

  switch(purple_account_get_privacy_type(acct)) {
  case PURPLE_PRIVACY_DENY_USERS:
    DEBUG_INFO("PURPLE_PRIVACY_DENY_USERS\n");
    privacy_fill(&privacy, acct->deny);
    privacy.deny = TRUE;
    break;

    DEBUG_INFO("PURPLE_PRIVACY_DENY_ALL\n");
    privacy.deny = FALSE;
    break;

  default:
    DEBUG_INFO("acct->perm_deny is 0x%x\n", purple_account_get_privacy_type(acct));
    return;
  }

  mwSession_setPrivacyInfo(session, &privacy);
  g_free(privacy.users);

			      GHashTable *components) {

  struct mwPurplePluginData *pd;
  char *c, *t;

  pd = purple_connection_get_protocol_data(gc);

  c = g_hash_table_lookup(components, CHAT_KEY_NAME);
  t = g_hash_table_lookup(components, CHAT_KEY_TOPIC);

  if(g_hash_table_lookup(components, CHAT_KEY_IS_PLACE)) {

  struct mwPurplePluginData *pd;
  struct mwServiceConference *srvc;
  char *c;

  pd = purple_connection_get_protocol_data(gc);
  srvc = pd->srvc_conf;

  if(g_hash_table_lookup(components, CHAT_KEY_IS_PLACE)) {
    ; /* nothing needs doing */

  struct mwPurplePluginData *pd;
  struct mwConference *conf;
  struct mwPlace *place;
  struct mwIdBlock idb = { (char *) who, NULL };

  pd = purple_connection_get_protocol_data(gc);
  g_return_if_fail(pd != NULL);

  conf = ID_TO_CONF(pd, id);

  if(conf) {

			       int id) {

  struct mwPurplePluginData *pd;
  struct mwConference *conf;

  pd = purple_connection_get_protocol_data(gc);

  g_return_if_fail(pd != NULL);
  conf = ID_TO_CONF(pd, id);

  if(conf) {

  struct mwPurplePluginData *pd;
  struct mwConference *conf;
  char *msg;
  int ret;

  pd = purple_connection_get_protocol_data(gc);

  g_return_val_if_fail(pd != NULL, 0);
  conf = ID_TO_CONF(pd, id);

  msg = purple_markup_strip_html(message);

static void mw_prpl_alias_buddy(PurpleConnection *gc,
				const char *who,
				const char *alias) {

  struct mwPurplePluginData *pd = purple_connection_get_protocol_data(gc);
  g_return_if_fail(pd != NULL);

  /* it's a change to the buddy list, so we've gotta reflect that in
     the server copy */

				const char *new_group) {

  struct mwAwareIdBlock idb = { mwAware_USER, (char *) who, NULL };
  GList *gl = g_list_prepend(NULL, &idb);

  struct mwPurplePluginData *pd = purple_connection_get_protocol_data(gc);
  PurpleGroup *group;
  struct mwAwareList *list;

  /* add who to new_group's aware list */
  group = purple_find_group(new_group);

static void mw_prpl_rename_group(PurpleConnection *gc,
				 const char *old,
				 PurpleGroup *group,
				 GList *buddies) {

  struct mwPurplePluginData *pd = purple_connection_get_protocol_data(gc);
  g_return_if_fail(pd != NULL);

  /* it's a change in the buddy list, so we've gotta reflect that in
     the server copy. Also, having this function should prevent all
     those buddies from being removed and re-added. We don't really

  ;
}


static void mw_prpl_convo_closed(PurpleConnection *gc, const char *who) {
  struct mwPurplePluginData *pd = purple_connection_get_protocol_data(gc);
  struct mwServiceIm *srvc;
  struct mwConversation *conv;
  struct mwIdBlock idb = { (char *) who, NULL };

  g_return_if_fail(pd != NULL);

static void mw_prpl_remove_group(PurpleConnection *gc, PurpleGroup *group) {
  struct mwPurplePluginData *pd;
  struct mwAwareList *list;

  pd = purple_connection_get_protocol_data(gc);
  g_return_if_fail(pd != NULL);
  g_return_if_fail(pd->group_list_map != NULL);

  list = g_hash_table_lookup(pd->group_list_map, group);

  struct mwServiceAware *srvc;
  PurpleAccount *acct;

  g_return_val_if_fail(gc != NULL, FALSE);

  pd = purple_connection_get_protocol_data(gc);
  g_return_val_if_fail(pd != NULL, FALSE);

  srvc = pd->srvc_aware;
  g_return_val_if_fail(srvc != NULL, FALSE);

  DEBUG_INFO("ft_outgoing_init\n");

  acct = purple_xfer_get_account(xfer);
  gc = purple_account_get_connection(acct);
  pd = purple_connection_get_protocol_data(gc);
  srvc = pd->srvc_ft;

  filename = purple_xfer_get_local_filename(xfer);
  filesize = purple_xfer_get_size(xfer);
  idb.user = purple_xfer_get_remote_user(xfer);

  purple_xfer_update_progress(xfer);

  /* test that we can actually send the file */
  fp = g_fopen(filename, "rb");
  if(! fp) {
    char *msg = g_strdup_printf(_("Error reading file %s: \n%s\n"),
				filename, g_strerror(errno));
    purple_xfer_error(purple_xfer_get_type(xfer), acct, purple_xfer_get_remote_user(xfer), msg);
    g_free(msg);
    return;
  }
  fclose(fp);

  ft = mwFileTransfer_new(srvc, &idb, NULL, filename, filesize);

  purple_xfer_ref(xfer);
  mwFileTransfer_setClientData(ft, xfer, (GDestroyNotify) purple_xfer_unref);
  purple_xfer_set_protocol_data(xfer, ft);

  mwFileTransfer_offer(ft);
}


static void ft_outgoing_cancel(PurpleXfer *xfer) {
  struct mwFileTransfer *ft = purple_xfer_get_protocol_data(xfer);

  DEBUG_INFO("ft_outgoing_cancel called\n");

  if(ft) mwFileTransfer_cancel(ft);
}

  }
}


static PurplePluginProtocolInfo mw_prpl_info = {
  sizeof(PurplePluginProtocolInfo),
  OPT_PROTO_IM_IMAGE,
  NULL, /*< set in mw_plugin_init */
  NULL, /*< set in mw_plugin_init */
  NO_BUDDY_ICONS,
  mw_prpl_list_icon,
  mw_prpl_list_emblem,
  mw_prpl_status_text,
  mw_prpl_tooltip_text,
  mw_prpl_status_types,
  mw_prpl_blist_node_menu,
  mw_prpl_chat_info,
  mw_prpl_chat_info_defaults,
  mw_prpl_login,
  mw_prpl_close,
  mw_prpl_send_im,
  NULL,
  mw_prpl_send_typing,
  mw_prpl_get_info,
  mw_prpl_set_status,
  mw_prpl_set_idle,
  NULL,
  mw_prpl_add_buddy,
  mw_prpl_add_buddies,
  mw_prpl_remove_buddy,
  NULL,
  mw_prpl_add_permit,
  mw_prpl_add_deny,
  mw_prpl_rem_permit,
  mw_prpl_rem_deny,
  mw_prpl_set_permit_deny,
  mw_prpl_join_chat,
  mw_prpl_reject_chat,
  mw_prpl_get_chat_name,
  mw_prpl_chat_invite,
  mw_prpl_chat_leave,
  mw_prpl_chat_whisper,
  mw_prpl_chat_send,
  mw_prpl_keepalive,
  NULL,
  NULL,
  mw_prpl_alias_buddy,
  mw_prpl_group_buddy,
  mw_prpl_rename_group,
  mw_prpl_buddy_free,
  mw_prpl_convo_closed,
  mw_prpl_normalize,
  NULL,
  mw_prpl_remove_group,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  mw_prpl_can_receive_file,
  mw_prpl_send_file,
  mw_prpl_new_xfer,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL
};


static PurplePluginPrefFrame *
mw_plugin_get_plugin_pref_frame(PurplePlugin *plugin) {

  struct mwServiceResolve *srvc;
  GList *query;
  enum mwResolveFlag flags;
  guint32 req;

  pd = purple_connection_get_protocol_data(gc);
  srvc = pd->srvc_resolve;

  query = g_list_prepend(NULL, (char *) name);
  flags = mwResolveFlag_FIRST | mwResolveFlag_GROUPS;

  struct mwServiceResolve *srvc;
  GList *query;
  enum mwResolveFlag flags;
  guint32 req;

  pd = purple_connection_get_protocol_data(gc);
  srvc = pd->srvc_resolve;

  query = g_list_prepend(NULL, (char *) name);
  flags = mwResolveFlag_FIRST | mwResolveFlag_USERS;

  }
}


static void mw_plugin_init(PurplePlugin *plugin) {
  PurpleAccountUserSplit *split;
  PurpleAccountOption *opt;
  GList *l = NULL;

  GLogLevelFlags logflags =
    G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION;

  /* set up the preferences */
  purple_prefs_add_none(MW_PRPL_OPT_BASE);
  purple_prefs_add_int(MW_PRPL_OPT_BLIST_ACTION, BLIST_CHOICE_DEFAULT);

  /* set up account ID as user:server */
  split = purple_account_user_split_new(_("Server"),
                                        MW_PLUGIN_DEFAULT_HOST, ':');
  mw_prpl_info.user_splits = g_list_append(mw_prpl_info.user_splits, split);

  /* remove dead preferences */
  purple_prefs_remove(MW_PRPL_OPT_PSYCHIC);
  purple_prefs_remove(MW_PRPL_OPT_SAVE_DYNAMIC);

  /* port to connect to */
  opt = purple_account_option_int_new(_("Port"), MW_KEY_PORT,
				    MW_PLUGIN_DEFAULT_PORT);
  l = g_list_append(l, opt);