tools/osyncdump.c

   1 #include <opensync/opensync.h>
   2 #include <opensync/opensync_internals.h>
   3 #include <opensync/opensync-group.h>
   4 #include <opensync/opensync-archive.h>
   5 #include <opensync/opensync-mapping.h>
   6 #include <opensync/opensync-helper.h>
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/types.h>
  12 //#include <sys/wait.h>
  13 #include <sqlite3.h>
  14
  15 static void usage (char *name, int ecode)
  16 {
  17   fprintf (stderr, "Usage: %s <groupname>\n", name);
  18   fprintf (stderr, "[--mappings <objtype>] \tDump all mappings. Default\n");
  19   fprintf (stderr, "[--hash <objtype> <memberid>] \tDump hash table for member id\n");
  20   fprintf (stderr, "[--configdir] \tSet a different configdir then ~./opensync\n");
  21   fprintf (stderr, "[--reset] \tReset the database for this group\n");
  22   exit(ecode);
  23 }
  24
  25 typedef enum  {
  26   DUMPMAPS = 1,
  27   DUMPHASH = 2,
  28   RESET = 4
  29 } ToolAction;
  30
  31 static void dump_map_objtype(OSyncGroupEnv *env, const char *objtype, const char *groupname)
  32 {
  33   OSyncError *error = NULL;
  34   OSyncGroup *group = osync_group_env_find_group(env, groupname);
  35
  36   char *path = g_strdup_printf("%s/archive.db", osync_group_get_configdir(group));
  37   OSyncArchive *archive = osync_archive_new(path, &error);
  38   OSyncList *ids = NULL;
  39   OSyncList *uids = NULL;
  40   OSyncList *mappingids = NULL;
  41   OSyncList *memberids = NULL;
  42   OSyncList *d , *u, *m, *i;
  43
  44   if (!archive)
  45     goto error;
  46   g_free(path);
  47
  48   if (!osync_archive_load_changes(archive, objtype, &ids, &uids, &mappingids, &memberids, &error))
  49     goto error;
  50
  51   d = ids;
  52   u = uids;
  53   m = mappingids;
  54   i = memberids;
  55
  56   for (; u; u = u->next) {
  57     long long int id = (long long int)GPOINTER_TO_INT(d->data);
  58     char *uid = u->data;
  59     long long int memberid = (long long int)GPOINTER_TO_INT(i->data);
  60     long long int mappingid = (long long int)GPOINTER_TO_INT(m->data);
  61
  62     printf("ID: %lli UID: %s MEMBER: %lli MAPPINGID: %lli\n", id, uid, memberid, mappingid);
  63
  64     m = m->next;
  65     d = d->next;
  66     i = i->next;
  67   }
  68
  69   osync_list_free(ids);
  70   osync_list_free(uids);
  71   osync_list_free(mappingids);
  72   osync_list_free(memberids);
  73
  74   osync_archive_unref(archive);
  75   return;
  76
  77  error:
  78   printf("ERROR: %s", osync_error_print(&error));
  79   osync_error_unref(&error);
  80 }
  81
  82 static void dump_map(OSyncGroupEnv *env, const char *groupname)
  83 {
  84
  85   OSyncGroup *group = osync_group_env_find_group(env, groupname);
  86   int i, num_objtypes;
  87
  88   if (!group) {
  89     printf("Unable to find group with name \"%s\"\n", groupname);
  90     return;
  91   }
  92
  93   num_objtypes = osync_group_num_objtypes(group);
  94   if (num_objtypes == 0) {
  95     printf("Group has no objtypes. Have the objtypes already been discovered?\n");
  96     return;
  97   }
  98
  99   for (i = 0; i < num_objtypes; i++) {
 100     const char *objtype = osync_group_nth_objtype(group, i);
 101     printf("Mappings for objtype \"%s\":\n", objtype);
 102     dump_map_objtype(env, objtype, groupname);
 103   }
 104
 105 }
 106
 107 static void print_hashtable(const char *uid, const char *hash, void *user_data)
 108 {
 109   printf("UID: %s\tHASH:%s\n", uid, hash);
 110 }
 111
 112 static void dump_hash(OSyncGroupEnv *env, const char *objtype, const char *groupname, char *memberid)
 113 {
 114   OSyncError *error = NULL;
 115   OSyncGroup *group = osync_group_env_find_group(env, groupname);
 116   long long int id = 0;
 117   OSyncMember *member = NULL;
 118   char *path = NULL;
 119   OSyncHashTable *table = NULL;
 120
 121
 122   if (!group) {
 123     printf("Unable to find group with name \"%s\"\n", groupname);
 124     return;
 125   }
 126
 127   id = atoi(memberid);
 128   member = osync_group_find_member(group, id);
 129   if (!member) {
 130     printf("Unable to find member with id %s\n", memberid);
 131     return;
 132   }
 133
 134   path = g_strdup_printf("%s/hashtable.db", osync_member_get_configdir(member));
 135   table = osync_hashtable_new(path, objtype, &error);
 136   if (!table)
 137     goto error;
 138   g_free(path);
 139
 140   osync_hashtable_foreach(table, print_hashtable, NULL);
 141
 142   osync_hashtable_unref(table);
 143
 144   return;
 145
 146  error:
 147   printf("ERROR: %s", osync_error_print(&error));
 148   osync_error_unref(&error);
 149 }
 150
 151 static void reset(OSyncGroupEnv *osync, char *groupname)
 152 {
 153   OSyncGroup *group = osync_group_env_find_group(osync, groupname);
 154
 155   if (!group) {
 156     printf("Unable to find group with name \"%s\"\n", groupname);
 157     return;
 158   }
 159
 160   osync_group_reset(group, NULL);
 161 }
 162
 163 int main (int argc, char *argv[])
 164 {
 165   int i;
 166   char *groupname = NULL;
 167   char *membername = NULL;
 168   ToolAction action = DUMPMAPS;
 169   char *configdir = NULL;
 170   char *objtype = NULL;
 171   OSyncError *error = NULL;
 172   OSyncGroupEnv *env = NULL;
 173
 174   if (argc == 1)
 175     usage (argv[0], 1);
 176
 177   groupname = argv[1];
 178   for (i = 2; i < argc; i++) {
 179     char *arg = argv[i];
 180     if (!strcmp (arg, "--mappings")) {
 181       action = DUMPMAPS;
 182       objtype = argv[i + 1];
 183       i++;
 184       if (!objtype)
 185         usage (argv[0], 1);
 186     } else if (!strcmp (arg, "--hash")) {
 187       action = DUMPHASH;
 188       objtype = argv[i + 1];
 189       membername = argv[i + 2];
 190       i += 2;
 191       if (!objtype || !membername)
 192         usage (argv[0], 1);
 193     } else if (!strcmp (arg, "--reset")) {
 194       action = RESET;
 195     } else if (!strcmp (arg, "--help")) {
 196       usage (argv[0], 0);
 197     } else if (!strcmp (arg, "--configdir")) {
 198       configdir = argv[i + 1];
 199       i++;
 200       if (!configdir)
 201         usage (argv[0], 1);
 202     } else if (!strcmp (arg, "--")) {
 203       break;
 204     } else if (arg[0] == '-') {
 205       usage (argv[0], 1);
 206     } else {
 207       usage (argv[0], 1);
 208     }
 209   }
 210
 211   env = osync_group_env_new(&error);
 212   if (!env)
 213     goto error;
 214
 215   if (!osync_group_env_load_groups(env, configdir, &error))
 216     goto error;
 217
 218   switch (action) {
 219   case DUMPMAPS:
 220     if (objtype)
 221       dump_map_objtype(env, objtype, groupname);
 222     else
 223       dump_map(env, groupname);
 224     break;
 225   case DUMPHASH:
 226     dump_hash(env, objtype, groupname, membername);
 227     break;
 228   case RESET:
 229     reset(env, groupname);
 230     break;
 231   }
 232
 233   return 0;
 234
 235  error:
 236   printf("ERROR: %s", osync_error_print(&error));
 237   osync_error_unref(&error);
 238   return 1;
 239 }