import nautilus dropbox 0.7.1

1 files changed, 893 insertions, 0 deletions

diff --git a/src/dropbox-command-client.c b/src/dropbox-command-client.c
new file mode 100644
index 0000000..bdec125
--- /dev/null
+++ b/src/dropbox-command-client.c
@@ -0,0 +1,893 @@
+/*
+ * Copyright 2008 Evenflow, Inc.
+ *
+ * dropbox-command-client.c
+ * Implements connection handling and C interface for the Dropbox command socket.
+ *
+ * This file is part of nautilus-dropbox.
+ *
+ * nautilus-dropbox is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * nautilus-dropbox 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with nautilus-dropbox.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <stdarg.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include "g-util.h"
+#include "dropbox-client-util.h"
+#include "dropbox-command-client.h"
+#include "nautilus-dropbox.h"
+#include "nautilus-dropbox-hooks.h"
+
+/* TODO: make this asynchronous ;) */
+
+/*
+  this is a tiny hack, necessitated by the fact that
+  finish_file info command is in nautilus_dropbox,
+  this can be cleaned up once the file_info_command isn't a special
+  case anylonger
+*/
+gboolean nautilus_dropbox_finish_file_info_command(DropboxFileInfoCommandResponse *);
+
+typedef struct {
+  DropboxCommandClient *dcc;
+  guint connect_attempt;
+} ConnectionAttempt;
+
+typedef struct {
+  DropboxCommandClientConnectionAttemptHook h;
+  gpointer ud;
+} DropboxCommandClientConnectionAttempt;
+
+typedef struct {
+  DropboxGeneralCommand *dgc;
+  GHashTable *response;
+} DropboxGeneralCommandResponse;
+
+static gboolean
+on_connect(DropboxCommandClient *dcc) {
+  g_hook_list_invoke(&(dcc->onconnect_hooklist), FALSE);
+  return FALSE;
+}
+
+static gboolean
+on_disconnect(DropboxCommandClient *dcc) {
+  g_hook_list_invoke(&(dcc->ondisconnect_hooklist), FALSE);
+  return FALSE;
+}
+
+static gboolean
+on_connection_attempt(ConnectionAttempt *ca) {
+  GList *ll;
+
+  for (ll = ca->dcc->ca_hooklist; ll != NULL; ll = g_list_next(ll)) {
+    DropboxCommandClientConnectionAttempt *dccca =
+      (DropboxCommandClientConnectionAttempt *)(ll->data);
+    dccca->h(ca->connect_attempt, dccca->ud);
+  }
+
+  g_free(ca);
+
+  return FALSE;
+}
+
+static gboolean
+receive_args_until_done(GIOChannel *chan, GHashTable *return_table,
+			GError **err) {
+  GIOStatus iostat;
+  GError *tmp_error = NULL;
+  guint numargs = 0;
+
+  while (1) {
+    gchar *line;
+    gsize term_pos;
+
+    /* if we are getting too many args, connection could be malicious */
+    if (numargs >= 20) {
+      g_set_error(err,
+		  g_quark_from_static_string("malicious connection"),
+		  0, "malicious connection");
+      return FALSE;
+    }
+    
+    /* get the string */
+    iostat = g_io_channel_read_line(chan, &line, NULL,
+				    &term_pos, &tmp_error);
+    if (iostat == G_IO_STATUS_ERROR || tmp_error != NULL) {
+      g_free(line);
+      if (tmp_error != NULL) {
+	g_propagate_error(err, tmp_error);
+      }
+      return FALSE;
+    }
+    else if (iostat == G_IO_STATUS_EOF) {
+      g_free(line);
+      g_set_error(err,
+		  g_quark_from_static_string("connection closed"),
+		  0, "connection closed");
+      return FALSE;
+    }
+
+    *(line+term_pos) = '\0';
+
+    if (strcmp("done", line) == 0) {
+      g_free(line);
+      break;
+    }
+    else {
+      gboolean parse_result;
+
+      parse_result = dropbox_client_util_command_parse_arg(line, return_table);
+      g_free(line);
+
+      if (FALSE == parse_result) {
+	g_set_error(err,
+		    g_quark_from_static_string("parse error"),
+		    0, "parse error");
+	return FALSE;
+      }
+    }
+    
+    numargs += 1;
+  }
+
+  return TRUE;
+}
+
+static void my_g_hash_table_get_keys_helper(gpointer key,
+					    gpointer value,
+					    GList **ud) {
+  *ud = g_list_append(*ud, key);
+}
+
+static GList *my_g_hash_table_get_keys(GHashTable *ght) {
+  GList *list = NULL;
+  g_hash_table_foreach(ght, (GHFunc) 
+		       my_g_hash_table_get_keys_helper, &list);
+  return list;
+}
+
+/*
+  sends a command to the dropbox server
+  returns an hash of the return values
+
+  in theory, this should disconnection errors
+  but it doesn't matter right now, any error is a sufficient
+  condition to disconnect
+*/
+static GHashTable *
+send_command_to_db(GIOChannel *chan, const gchar *command_name,
+		   GHashTable *args, GError **err) {
+  GError *tmp_error = NULL;
+  GIOStatus iostat;
+  gsize bytes_trans;
+  gchar *line;
+
+  g_assert(chan != NULL);
+  g_assert(command_name != NULL);
+  
+
+#define WRITE_OR_DIE_SANI(s,l) {					\
+    gchar *sani_s;							\
+    sani_s = dropbox_client_util_sanitize(s);				\
+    iostat = g_io_channel_write_chars(chan, sani_s,l, &bytes_trans,	\
+				      &tmp_error);			\
+    g_free(sani_s);							\
+    if (iostat == G_IO_STATUS_ERROR ||					\
+	iostat == G_IO_STATUS_AGAIN) {					\
+      if (tmp_error != NULL) {						\
+	g_propagate_error(err, tmp_error);				\
+      }									\
+      return NULL;							\
+    }									\
+  }
+  
+#define WRITE_OR_DIE(s,l) {						\
+    iostat = g_io_channel_write_chars(chan, s,l, &bytes_trans,		\
+				      &tmp_error);			\
+    if (iostat == G_IO_STATUS_ERROR ||					\
+	iostat == G_IO_STATUS_AGAIN) {					\
+      if (tmp_error != NULL) {						\
+	g_propagate_error(err, tmp_error);				\
+      }									\
+      return NULL;							\
+    }									\
+  }
+  
+  /* send command to server */
+  WRITE_OR_DIE_SANI(command_name, -1);
+  WRITE_OR_DIE("\n", -1);
+
+  if (args != NULL) {
+    GList *keys, *li;
+
+    /* oh god */
+    keys = glib_check_version(2, 14, 0)
+      ? my_g_hash_table_get_keys(args)
+      : g_hash_table_get_keys(args);
+
+    for (li = keys; li != NULL; li = g_list_next(li)) {
+      int i;
+      gchar **value;
+      
+      WRITE_OR_DIE_SANI((gchar *) li->data, -1);
+      
+      value = g_hash_table_lookup(args, li->data);
+      for (i = 0; value[i] != NULL; i++) {
+	WRITE_OR_DIE("\t", -1);
+	WRITE_OR_DIE_SANI(value[i], -1);
+      }
+      WRITE_OR_DIE("\n", -1);
+    }
+
+    g_list_free(keys);
+  }
+
+  WRITE_OR_DIE("done\n", -1);
+
+#undef WRITE_OR_DIE
+#undef WRITE_OR_DIE_SANI
+
+  g_io_channel_flush(chan, &tmp_error);
+  if (tmp_error != NULL) {
+    g_propagate_error(err, tmp_error);
+    return NULL;
+  }
+
+  /* now we have to read the data */
+  iostat = g_io_channel_read_line(chan, &line, NULL,
+				  NULL, &tmp_error);
+  if (iostat == G_IO_STATUS_ERROR) {
+    g_assert(line == NULL);
+    g_propagate_error(err, tmp_error);
+    return NULL;
+  }
+  else if (iostat == G_IO_STATUS_AGAIN) {
+    g_assert(line == NULL);
+    g_set_error(err,
+		g_quark_from_static_string("dropbox command connection timed out"),
+		0,
+		"dropbox command connection timed out");
+    return NULL;
+  }
+  else if (iostat == G_IO_STATUS_EOF) {
+    g_assert(line == NULL);
+    g_set_error(err,
+		g_quark_from_static_string("dropbox command connection closed"),
+		0,
+		"dropbox command connection closed");
+    return NULL;
+  }
+
+  /* if the response was okay */
+  if (strncmp(line, "ok\n", 3) == 0) {
+    GHashTable *return_table = 
+      g_hash_table_new_full((GHashFunc) g_str_hash,
+			    (GEqualFunc) g_str_equal,
+			    (GDestroyNotify) g_free,
+			    (GDestroyNotify) g_strfreev);
+    
+    g_free(line);
+    line = NULL;
+
+    receive_args_until_done(chan, return_table, &tmp_error);
+    if (tmp_error != NULL) {
+      g_hash_table_destroy(return_table);
+      g_propagate_error(err, tmp_error);
+      return NULL;
+    }
+      
+    return return_table;
+  }
+  /* otherwise */
+  else {
+    /* read errors off until we get done */
+    do {
+      g_free(line);
+      line = NULL;
+      
+      /* clear string */
+      iostat = g_io_channel_read_line(chan, &line, NULL,
+				      NULL, &tmp_error);
+      if (iostat == G_IO_STATUS_ERROR) {
+	g_assert(line == NULL);
+	g_propagate_error(err, tmp_error);
+	return NULL;
+      }
+      else if (iostat == G_IO_STATUS_AGAIN) {
+	g_assert(line == NULL);
+	g_set_error(err,
+		    g_quark_from_static_string("dropbox command connection timed out"),
+		    0,
+		    "dropbox command connection timed out");
+	return NULL;
+	
+      }
+      else if (iostat == G_IO_STATUS_EOF) {
+	g_assert(line == NULL);
+	g_set_error(err,
+		    g_quark_from_static_string("dropbox command connection closed"),
+		    0,
+		    "dropbox command connection closed");
+	return NULL;
+      }
+
+      /* we got our line */
+    } while (strncmp(line, "done\n", 5) != 0);
+
+    g_free(line);
+    return NULL;
+  }
+}
+
+static void
+do_file_info_command(GIOChannel *chan, DropboxFileInfoCommand *dfic, GError **gerr) {
+  /* we need to send two requests to dropbox:
+     file status, and folder_tags */
+  GError *tmp_gerr = NULL;
+  DropboxFileInfoCommandResponse *dficr;
+  GHashTable *file_status_response = NULL, *args, *folder_tag_response = NULL, *emblems_response = NULL;
+  gchar *filename = NULL;
+
+  {
+    gchar *filename_un, *uri;
+    uri = nautilus_file_info_get_uri(dfic->file);
+    filename_un = uri ? g_filename_from_uri(uri, NULL, NULL): NULL;
+    g_free(uri);
+    if (filename_un) {
+      filename = g_filename_to_utf8(filename_un, -1, NULL, NULL, NULL);
+      g_free(filename_un);
+      if (filename == NULL) {
+        /* oooh, filename wasn't correctly encoded. mark as  */
+	debug("file wasn't correctly encoded %s", filename_un);
+      }
+    }
+  }
+
+  if (filename == NULL) {
+    /* We couldn't get the filename.  Just return empty. */
+    goto exit;
+  }
+
+  args = g_hash_table_new_full((GHashFunc) g_str_hash,
+			       (GEqualFunc) g_str_equal,
+			       (GDestroyNotify) g_free,
+			       (GDestroyNotify) g_strfreev);
+  {
+    gchar **path_arg;
+    path_arg = g_new(gchar *, 2);
+    path_arg[0] = g_strdup(filename);
+    path_arg[1] = NULL;
+    g_hash_table_insert(args, g_strdup("path"), path_arg);
+  }
+
+  emblems_response = send_command_to_db(chan, "get_emblems", args, NULL);
+  if (emblems_response) {
+      /* Don't need to do the other calls. */
+      g_hash_table_unref(args);
+      goto exit;
+  }
+
+  /* send status command to server */
+  file_status_response = send_command_to_db(chan, "icon_overlay_file_status",
+					    args, &tmp_gerr);
+  g_hash_table_unref(args);
+  args = NULL;
+  if (tmp_gerr != NULL) {
+    g_free(filename);
+    g_assert(file_status_response == NULL);
+    g_propagate_error(gerr, tmp_gerr);
+    return;
+  }
+
+  if (nautilus_file_info_is_directory(dfic->file)) {
+    args = g_hash_table_new_full((GHashFunc) g_str_hash,
+				 (GEqualFunc) g_str_equal,
+				 (GDestroyNotify) g_free,
+				 (GDestroyNotify) g_strfreev);
+    {
+      gchar **paths_arg;
+      paths_arg = g_new(gchar *, 2);
+      paths_arg[0] = g_strdup(filename);
+      paths_arg[1] = NULL;
+      g_hash_table_insert(args, g_strdup("path"), paths_arg);
+    }
+    
+    folder_tag_response =
+      send_command_to_db(chan, "get_folder_tag", args, &tmp_gerr);
+    g_hash_table_unref(args);
+    args = NULL;
+    if (tmp_gerr != NULL) {
+      if (file_status_response != NULL)
+	g_hash_table_destroy(file_status_response);
+      g_assert(folder_tag_response == NULL);
+      g_propagate_error(gerr, tmp_gerr);
+      return;
+    }
+  }
+  
+  /* great server responded perfectly,
+     now let's get this request done,
+     ...in the glib main loop */
+exit:
+  dficr = g_new0(DropboxFileInfoCommandResponse, 1);
+  dficr->dfic = dfic;
+  dficr->folder_tag_response = folder_tag_response;
+  dficr->file_status_response = file_status_response;
+  dficr->emblems_response = emblems_response;
+  g_idle_add((GSourceFunc) nautilus_dropbox_finish_file_info_command, dficr);
+
+  g_free(filename);
+  
+  return;
+}
+
+static gboolean
+finish_general_command(DropboxGeneralCommandResponse *dgcr) {
+  if (dgcr->dgc->handler != NULL) {
+    dgcr->dgc->handler(dgcr->response, dgcr->dgc->handler_ud);
+  }
+  
+  if (dgcr->response != NULL) {
+    g_hash_table_unref(dgcr->response);
+  }
+
+  g_free(dgcr->dgc->command_name);
+  if (dgcr->dgc->command_args != NULL) {
+    g_hash_table_unref(dgcr->dgc->command_args);
+  }
+  g_free(dgcr->dgc);
+  g_free(dgcr);
+  
+  return FALSE;
+}
+
+static void
+do_general_command(GIOChannel *chan, DropboxGeneralCommand *dcac,
+		   GError **gerr) {
+  GError *tmp_gerr = NULL;
+  GHashTable *response;
+
+  /* send status command to server */
+  response = send_command_to_db(chan, dcac->command_name,
+				dcac->command_args, &tmp_gerr);
+  if (tmp_gerr != NULL) {
+    g_assert(response == NULL);
+    g_propagate_error(gerr, tmp_gerr);
+    return;
+  }
+
+  /* great, the server did the command perfectly,
+     now call the handler with the response */
+  {
+    DropboxGeneralCommandResponse *dgcr = g_new0(DropboxGeneralCommandResponse, 1);
+    dgcr->dgc = dcac;
+    dgcr->response = response;
+    finish_general_command(dgcr);
+  }
+  
+  return;
+}
+
+static gboolean
+check_connection(GIOChannel *chan) {
+  gchar fake_buf[4096];
+  gsize bytes_read;
+  GError *tmp_error = NULL;
+  GIOFlags flags;
+  GIOStatus ret, iostat;
+
+  flags = g_io_channel_get_flags(chan);
+  
+  /* set non-blocking */
+  ret = g_io_channel_set_flags(chan, flags | G_IO_FLAG_NONBLOCK, NULL);
+  if (ret == G_IO_STATUS_ERROR) {
+    return FALSE;
+  }
+  
+  iostat = g_io_channel_read_chars(chan, fake_buf,
+				   sizeof(fake_buf), 
+				   &bytes_read, &tmp_error);
+
+  ret = g_io_channel_set_flags(chan, flags, NULL);
+  if (ret == G_IO_STATUS_ERROR) {
+    return FALSE;
+  }
+
+  /* this makes us disconnect from bad servers
+     (those that send us information without us asking for it) */
+  return iostat == G_IO_STATUS_AGAIN;
+}
+
+static gpointer
+dropbox_command_client_thread(DropboxCommandClient *data);
+
+static void
+end_request(DropboxCommand *dc) {
+  if ((gpointer (*)(DropboxCommandClient *data)) dc != &dropbox_command_client_thread) {
+    switch (dc->request_type) {
+    case GET_FILE_INFO: {
+      DropboxFileInfoCommand *dfic = (DropboxFileInfoCommand *) dc;
+      DropboxFileInfoCommandResponse *dficr = g_new0(DropboxFileInfoCommandResponse, 1);
+      dficr->dfic = dfic;
+      dficr->file_status_response = NULL;
+      dficr->emblems_response = NULL;
+      g_idle_add((GSourceFunc) nautilus_dropbox_finish_file_info_command, dficr);
+    }
+      break;
+    case GENERAL_COMMAND: {
+      DropboxGeneralCommand *dgc = (DropboxGeneralCommand *) dc;
+      DropboxGeneralCommandResponse *dgcr = g_new0(DropboxGeneralCommandResponse, 1);
+      dgcr->dgc = dgc;
+      dgcr->response = NULL;
+      finish_general_command(dgcr);
+    }
+      break;
+    default: 
+      g_assert_not_reached();
+      break;
+    }
+  }
+}
+
+
+static gpointer
+dropbox_command_client_thread(DropboxCommandClient *dcc) {
+  struct sockaddr_un addr;
+  socklen_t addr_len;
+  int connection_attempts = 1;
+
+  /* intialize address structure */
+  addr.sun_family = AF_UNIX;
+  g_snprintf(addr.sun_path,
+	     sizeof(addr.sun_path),
+	     "%s/.dropbox/command_socket",
+	     g_get_home_dir());
+  addr_len = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path);
+
+  while (1) {
+    GIOChannel *chan = NULL;
+    GError *gerr = NULL;
+    int sock;
+    gboolean failflag = TRUE;
+
+    do {
+      int flags;
+
+      if (0 > (sock = socket(PF_UNIX, SOCK_STREAM, 0))) {
+	/* WTF */
+	break;
+      }
+
+      /* set timeout on socket, to protect against
+	 bad servers */
+      {
+	struct timeval tv = {3, 0};
+	if (0 > setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
+			   &tv, sizeof(struct timeval)) ||
+	    0 > setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO,
+			   &tv, sizeof(struct timeval))) {
+	  /* debug("setsockopt failed"); */
+	  break;
+	}
+      }
+
+      /* set native non-blocking, for connect timeout */
+      {
+	if ((flags = fcntl(sock, F_GETFL, 0)) < 0 ||
+	    fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
+	  /* debug("fcntl failed"); */
+	  break;
+	}
+      }
+
+      /* if there was an error we have to try again later */
+      if (connect(sock, (struct sockaddr *) &addr, addr_len) < 0) {
+	if (errno == EINPROGRESS) {
+	  fd_set writers;
+	  struct timeval tv = {1, 0};
+
+	  FD_ZERO(&writers);
+	  FD_SET(sock, &writers);
+
+	  /* if nothing was ready after 3 seconds, fail out homie */
+	  if (select(sock+1, NULL, &writers, NULL, &tv) == 0) {
+	    /* debug("connection timeout"); */
+	    break;
+	  }
+
+	  if (connect(sock, (struct sockaddr *) &addr, addr_len) < 0) {
+	    /*	    debug("couldn't connect to command server after 1 second"); */
+	    break;
+	  }
+	}
+	/* errno != EINPROGRESS */
+	else {
+	  /*	  debug("bad connection"); */
+	  break;
+	}
+      }
+
+      /* set back to blocking */
+      if (fcntl(sock, F_SETFL, flags) < 0) {
+	/* debug("fcntl2 failed"); */
+	break;
+      }
+
+      failflag = FALSE;
+    } while (0);
+
+    if (failflag) {
+      ConnectionAttempt *ca = g_new(ConnectionAttempt, 1);
+      ca->dcc = dcc;
+      ca->connect_attempt = connection_attempts;
+      g_idle_add((GSourceFunc) on_connection_attempt, ca);
+      if (sock >= 0) {
+	close(sock);
+      }
+      g_usleep(G_USEC_PER_SEC);
+      connection_attempts++;
+      continue;
+    }
+    else {
+      connection_attempts = 0;
+    }
+
+    /* connected */
+    debug("command client connected");
+
+    chan = g_io_channel_unix_new(sock);
+    g_io_channel_set_close_on_unref(chan, TRUE);
+    g_io_channel_set_line_term(chan, "\n", -1);
+
+#define SET_CONNECTED_STATE(s)     {			\
+      g_mutex_lock(dcc->command_connected_mutex);	\
+      dcc->command_connected = s;			\
+      g_mutex_unlock(dcc->command_connected_mutex);	\
+    }
+
+    SET_CONNECTED_STATE(TRUE);
+
+    g_idle_add((GSourceFunc) on_connect, dcc);
+
+    while (1) {
+      DropboxCommand *dc;
+
+      while (1) {
+	GTimeVal gtv;
+
+	g_get_current_time(&gtv);
+	g_time_val_add(&gtv, G_USEC_PER_SEC / 10);
+	/* get a request from nautilus */
+	dc = g_async_queue_timed_pop(dcc->command_queue, &gtv);
+	if (dc != NULL) {
+	  break;
+	}
+	else {
+	  if (check_connection(chan) == FALSE) {
+	    goto BADCONNECTION;
+	  }
+	}
+      }
+
+      /* this pointer should be unique */
+      if ((gpointer (*)(DropboxCommandClient *data)) dc == &dropbox_command_client_thread) {
+	debug("got a reset request");
+	goto BADCONNECTION;
+      }
+
+      switch (dc->request_type) {
+      case GET_FILE_INFO: {
+	debug("doing file info command");
+	do_file_info_command(chan, (DropboxFileInfoCommand *) dc, &gerr);
+      }
+	break;
+      case GENERAL_COMMAND: {
+	debug("doing general command");
+	do_general_command(chan, (DropboxGeneralCommand *) dc, &gerr);
+      }
+	break;
+      default: 
+	g_assert_not_reached();
+	break;
+      }
+      
+      debug("done.");
+
+      if (gerr != NULL) {
+	//	debug("COMMAND ERROR*****************************");
+	/* mark this request as never to be completed */
+	end_request(dc);
+
+	debug("command error: %s", gerr->message);
+	
+	g_error_free(gerr);
+      BADCONNECTION:
+	/* grab all the rest of the data off the async queue and mark it
+	   never to be completed, who knows how long we'll be disconnected */
+	while ((dc = g_async_queue_try_pop(dcc->command_queue)) != NULL) {
+	  end_request(dc);
+	}
+
+	g_io_channel_unref(chan);
+
+	SET_CONNECTED_STATE(FALSE);
+
+	/* call the disconnect handler */
+	g_idle_add((GSourceFunc) on_disconnect, dcc);
+
+	break;
+      }
+    }
+    
+#undef SET_CONNECTED_STATE
+  }
+  
+  return NULL;
+}
+
+/* thread safe */
+gboolean
+dropbox_command_client_is_connected(DropboxCommandClient *dcc) {
+  gboolean command_connected;
+
+  g_mutex_lock(dcc->command_connected_mutex);
+  command_connected = dcc->command_connected;
+  g_mutex_unlock(dcc->command_connected_mutex);
+
+  return command_connected;
+}
+
+/* thread safe */
+void dropbox_command_client_force_reconnect(DropboxCommandClient *dcc) {
+  if (dropbox_command_client_is_connected(dcc) == TRUE) {
+    debug("forcing command to reconnect");
+    dropbox_command_client_request(dcc, (DropboxCommand *) &dropbox_command_client_thread);
+  }
+}
+
+/* thread safe */
+void
+dropbox_command_client_request(DropboxCommandClient *dcc, DropboxCommand *dc) {
+  g_async_queue_push(dcc->command_queue, dc);
+}
+
+/* should only be called once on initialization */
+void
+dropbox_command_client_setup(DropboxCommandClient *dcc) {
+  dcc->command_queue = g_async_queue_new();
+  dcc->command_connected_mutex = g_mutex_new();
+  dcc->command_connected = FALSE;
+  dcc->ca_hooklist = NULL;
+
+  g_hook_list_init(&(dcc->ondisconnect_hooklist), sizeof(GHook));
+  g_hook_list_init(&(dcc->onconnect_hooklist), sizeof(GHook));
+}
+
+void
+dropbox_command_client_add_on_disconnect_hook(DropboxCommandClient *dcc,
+					      DropboxCommandClientConnectHook dhcch,
+					      gpointer ud) {
+  GHook *newhook;
+  
+  newhook = g_hook_alloc(&(dcc->ondisconnect_hooklist));
+  newhook->func = dhcch;
+  newhook->data = ud;
+  
+  g_hook_append(&(dcc->ondisconnect_hooklist), newhook);
+}
+
+void
+dropbox_command_client_add_on_connect_hook(DropboxCommandClient *dcc,
+					   DropboxCommandClientConnectHook dhcch,
+					   gpointer ud) {
+  GHook *newhook;
+  
+  newhook = g_hook_alloc(&(dcc->onconnect_hooklist));
+  newhook->func = dhcch;
+  newhook->data = ud;
+  
+  g_hook_append(&(dcc->onconnect_hooklist), newhook);
+}
+
+void
+dropbox_command_client_add_connection_attempt_hook(DropboxCommandClient *dcc,
+						   DropboxCommandClientConnectionAttemptHook dhcch,
+						   gpointer ud) {
+  DropboxCommandClientConnectionAttempt *newhook;
+
+  debug("shouldn't be here...");
+  
+  newhook = g_new(DropboxCommandClientConnectionAttempt, 1);
+  newhook->h = dhcch;
+  newhook->ud = ud;
+
+  dcc->ca_hooklist = g_list_append(dcc->ca_hooklist, newhook);
+}
+
+/* should only be called once on initialization */
+void
+dropbox_command_client_start(DropboxCommandClient *dcc) {
+  /* setup the connect to the command server */
+  debug("starting command thread");
+  g_thread_create((gpointer (*)(gpointer data)) dropbox_command_client_thread,
+		  dcc, FALSE, NULL);
+}
+
+/* thread safe */
+void dropbox_command_client_send_simple_command(DropboxCommandClient *dcc, 
+					 const char *command) {
+  DropboxGeneralCommand *dgc;
+  
+  dgc = g_new(DropboxGeneralCommand, 1);
+  
+  dgc->dc.request_type = GENERAL_COMMAND;
+  dgc->command_name = g_strdup(command);
+  dgc->command_args = NULL;
+  dgc->handler = NULL;
+  dgc->handler_ud = NULL;
+  
+  dropbox_command_client_request(dcc, (DropboxCommand *) dgc);
+}
+
+/* thread safe */
+/* this is the C API, there is another send_command_to_db
+   that is more the actual over the wire command */
+void dropbox_command_client_send_command(DropboxCommandClient *dcc, 
+					 NautilusDropboxCommandResponseHandler h,
+					 gpointer ud,
+					 const char *command, ...) {
+  va_list ap;
+  DropboxGeneralCommand *dgc;
+  gchar *na;
+  va_start(ap, command);
+
+  dgc = g_new(DropboxGeneralCommand, 1);
+  dgc->dc.request_type = GENERAL_COMMAND;
+  dgc->command_name = g_strdup(command);
+  dgc->command_args = g_hash_table_new_full((GHashFunc) g_str_hash,
+					    (GEqualFunc) g_str_equal,
+					    (GDestroyNotify) g_free,
+					    (GDestroyNotify) g_strfreev);
+  /*
+   * NB: The handler is called in the DropboxCommandClient Thread.  If you need
+   * it in the main thread you must call g_idle_add in the callback.
+   */
+  dgc->handler = h;
+  dgc->handler_ud = ud;
+
+  while ((na = va_arg(ap, char *)) != NULL) {
+    gchar **is_active_arg;
+
+    is_active_arg = g_new(gchar *, 2);
+
+    g_hash_table_insert(dgc->command_args,
+			g_strdup(na), is_active_arg);
+
+    is_active_arg[0] = g_strdup(va_arg(ap, char *));
+    is_active_arg[1] = NULL;
+  }
+  va_end(ap);
+
+  dropbox_command_client_request(dcc, (DropboxCommand *) dgc);
+}