plugins/messages-tracker.c

   1 /*
   2  *
   3  *  OBEX Server
   4  *
   5  *  Copyright (C) 2010-2011  Nokia Corporation
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <errno.h>
  29 #include <glib.h>
  30 #include <string.h>
  31
  32 #include "messages.h"
  33
  34 struct message_folder {
  35         char *name;
  36         GSList *subfolders;
  37         char *query;
  38 };
  39
  40 struct session {
  41         char *cwd;
  42         struct message_folder *folder;
  43         char *name;
  44         uint16_t max;
  45         uint16_t offset;
  46         void *user_data;
  47         void (*folder_list_cb)(void *session, int err, uint16_t size,
  48                                         const char *name, void *user_data);
  49 };
  50
  51 static struct message_folder *folder_tree = NULL;
  52
  53 static struct message_folder *get_folder(const char *folder)
  54 {
  55         GSList *folders = folder_tree->subfolders;
  56         struct message_folder *last = NULL;
  57         char **path;
  58         int i;
  59
  60         if (g_strcmp0(folder, "/") == 0)
  61                 return folder_tree;
  62
  63         path = g_strsplit(folder, "/", 0);
  64
  65         for (i = 1; path[i] != NULL; i++) {
  66                 gboolean match_found = FALSE;
  67                 GSList *l;
  68
  69                 for (l = folders; l != NULL; l = g_slist_next(l)) {
  70                         struct message_folder *folder = l->data;
  71
  72                         if (g_strcmp0(folder->name, path[i]) == 0) {
  73                                 match_found = TRUE;
  74                                 last = l->data;
  75                                 folders = folder->subfolders;
  76                                 break;
  77                         }
  78                 }
  79
  80                 if (!match_found) {
  81                         g_strfreev(path);
  82                         return NULL;
  83                 }
  84         }
  85
  86         g_strfreev(path);
  87
  88         return last;
  89 }
  90
  91 static struct message_folder *create_folder(const char *name, const char *query)
  92 {
  93         struct message_folder *folder = g_new0(struct message_folder, 1);
  94
  95         folder->name = g_strdup(name);
  96         folder->query = g_strdup(query);
  97
  98         return folder;
  99 }
 100
 101 static void destroy_folder_tree(void *root)
 102 {
 103         struct message_folder *folder = root;
 104         GSList *tmp, *next;
 105
 106         if (folder == NULL)
 107                 return;
 108
 109         g_free(folder->name);
 110         g_free(folder->query);
 111
 112         tmp = folder->subfolders;
 113         while (tmp != NULL) {
 114                 next = g_slist_next(tmp);
 115                 destroy_folder_tree(tmp->data);
 116                 tmp = next;
 117         }
 118
 119         g_slist_free(folder->subfolders);
 120         g_free(folder);
 121 }
 122
 123 static void create_folder_tree(void)
 124 {
 125         struct message_folder *parent, *child;
 126
 127         folder_tree = create_folder("/", "FILTER (!BOUND(?msg))");
 128
 129         parent = create_folder("telecom", "FILTER (!BOUND(?msg))");
 130         folder_tree->subfolders = g_slist_append(folder_tree->subfolders,
 131                                                                 parent);
 132
 133         child = create_folder("msg", "FILTER (!BOUND(?msg))");
 134         parent->subfolders = g_slist_append(parent->subfolders, child);
 135
 136         parent = child;
 137
 138         child = create_folder("inbox", "?msg nmo:isSent \"false\" ; "
 139                                 "nmo:isDeleted \"false\" ; "
 140                                 "nmo:isDraft \"false\". ");
 141         parent->subfolders = g_slist_append(parent->subfolders, child);
 142
 143         child = create_folder("sent", "?msg nmo:isDeleted \"false\" ; "
 144                                 "nmo:isSent \"true\" . ");
 145         parent->subfolders = g_slist_append(parent->subfolders, child);
 146
 147         child = create_folder("deleted", "?msg nmo:isDeleted \"true\" . ");
 148         parent->subfolders = g_slist_append(parent->subfolders, child);
 149 }
 150
 151 int messages_init(void)
 152 {
 153         create_folder_tree();
 154
 155         return 0;
 156 }
 157
 158 void messages_exit(void)
 159 {
 160         destroy_folder_tree(folder_tree);
 161 }
 162
 163 int messages_connect(void **s)
 164 {
 165         struct session *session = g_new0(struct session, 1);
 166
 167         session->cwd = g_strdup("/");
 168         session->folder = folder_tree;
 169
 170         *s = session;
 171
 172         return 0;
 173 }
 174
 175 void messages_disconnect(void *s)
 176 {
 177         struct session *session = s;
 178
 179         g_free(session->cwd);
 180         g_free(session);
 181 }
 182
 183 int messages_set_notification_registration(void *session,
 184                 void (*send_event)(void *session,
 185                         const struct messages_event *event, void *user_data),
 186                 void *user_data)
 187 {
 188         return -EINVAL;
 189 }
 190
 191 int messages_set_folder(void *s, const char *name, gboolean cdup)
 192 {
 193         struct session *session = s;
 194         char *newrel = NULL;
 195         char *newabs;
 196         char *tmp;
 197
 198         if (name && (strchr(name, '/') || strcmp(name, "..") == 0))
 199                 return -EBADR;
 200
 201         if (cdup) {
 202                 if (session->cwd[0] == 0)
 203                         return -ENOENT;
 204
 205                 newrel = g_path_get_dirname(session->cwd);
 206
 207                 /* We use empty string for indication of the root directory */
 208                 if (newrel[0] == '.' && newrel[1] == 0)
 209                         newrel[0] = 0;
 210         }
 211
 212         tmp = newrel;
 213         if (!cdup && (!name || name[0] == 0))
 214                 newrel = g_strdup("");
 215         else
 216                 newrel = g_build_filename(newrel ? newrel : session->cwd, name,
 217                                                                         NULL);
 218         g_free(tmp);
 219
 220         if (newrel[0] != '/')
 221                 newabs = g_build_filename("/", newrel, NULL);
 222         else
 223                 newabs = g_strdup(newrel);
 224
 225         session->folder = get_folder(newabs);
 226         if (session->folder == NULL) {
 227                 g_free(newrel);
 228                 g_free(newabs);
 229
 230                 return -ENOENT;
 231         }
 232
 233         g_free(newrel);
 234         g_free(session->cwd);
 235         session->cwd = newabs;
 236
 237         return 0;
 238 }
 239
 240 static gboolean async_get_folder_listing(void *s)
 241 {
 242         struct session *session = s;
 243         gboolean count = FALSE;
 244         int folder_count = 0;
 245         char *path = NULL;
 246         struct message_folder *folder;
 247         GSList *dir;
 248
 249         if (session->name && strchr(session->name, '/') != NULL)
 250                 goto done;
 251
 252         path = g_build_filename(session->cwd, session->name, NULL);
 253
 254         if (path == NULL || strlen(path) == 0)
 255                 goto done;
 256
 257         folder = get_folder(path);
 258
 259         if (folder == NULL)
 260                 goto done;
 261
 262         if (session->max == 0) {
 263                 session->max = 0xffff;
 264                 session->offset = 0;
 265                 count = TRUE;
 266         }
 267
 268         for (dir = folder->subfolders; dir &&
 269                                 (folder_count - session->offset) < session->max;
 270                                 folder_count++, dir = g_slist_next(dir)) {
 271                 struct message_folder *dir_data = dir->data;
 272
 273                 if (count == FALSE && session->offset <= folder_count)
 274                         session->folder_list_cb(session, -EAGAIN, 0,
 275                                         dir_data->name, session->user_data);
 276         }
 277
 278  done:
 279         session->folder_list_cb(session, 0, folder_count, NULL,
 280                                                         session->user_data);
 281
 282         g_free(path);
 283         g_free(session->name);
 284
 285         return FALSE;
 286 }
 287
 288 int messages_get_folder_listing(void *s, const char *name,
 289                                         uint16_t max, uint16_t offset,
 290                                         messages_folder_listing_cb callback,
 291                                         void *user_data)
 292 {
 293         struct session *session = s;
 294         session->name = g_strdup(name);
 295         session->max = max;
 296         session->offset = offset;
 297         session->folder_list_cb = callback;
 298         session->user_data = user_data;
 299
 300         g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, async_get_folder_listing,
 301                                                 session, NULL);
 302
 303         return 0;
 304 }
 305
 306 int messages_get_messages_listing(void *session,
 307                                 const char *name,
 308                                 uint16_t max, uint16_t offset,
 309                                 const struct messages_filter *filter,
 310                                 messages_get_messages_listing_cb callback,
 311                                 void *user_data)
 312 {
 313         return -EINVAL;
 314 }
 315
 316 int messages_get_message(void *session, const char *handle,
 317                                 unsigned long flags,
 318                                 messages_get_message_cb callback,
 319                                 void *user_data)
 320 {
 321         return -EINVAL;
 322 }
 323
 324 int messages_update_inbox(void *session, messages_update_inbox_cb callback,
 325                                                         void *user_data)
 326 {
 327         return -EINVAL;
 328 }
 329
 330 #ifdef TIZEN_PATCH
 331 int messages_set_message_status(void *session, const char *handle,
 332                                         int indicator, int value,
 333                                         messages_set_message_status_cb callback,
 334                                         void *user_data)
 335 {
 336         return -EINVAL;
 337 }
 338 #endif
 339 void messages_abort(void *session)
 340 {
 341 }