daemon/recent_store.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of the recent items store
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31
  32 #include "recent_store.h"
  33 #include "save.h"
  34
  35 struct ladish_recent_store
  36 {
  37   char * path;
  38   unsigned int max_items;
  39   char ** items;
  40 };
  41
  42 static
  43 void
  44 ladish_recent_store_save(
  45   struct ladish_recent_store * store_ptr)
  46 {
  47   unsigned int i;
  48   int fd;
  49
  50   fd = open(store_ptr->path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  51   if (fd == -1)
  52   {
  53     log_error("open(%s) failed: %d (%s)", store_ptr->path, errno, strerror(errno));
  54     return;
  55   }
  56
  57   for (i = 0; i < store_ptr->max_items && store_ptr->items[i] != NULL; i++)
  58   {
  59     if (!ladish_write_string(fd, store_ptr->items[i]))
  60     {
  61       log_error("write to file '%s' failed", store_ptr->path);
  62       break;
  63     }
  64
  65     if (!ladish_write_string(fd, "\n"))
  66     {
  67       log_error("write to file '%s' failed", store_ptr->path);
  68       break;
  69     }
  70   }
  71
  72   close(fd);
  73 }
  74
  75 static
  76 void
  77 ladish_recent_store_load(
  78   struct ladish_recent_store * store_ptr)
  79 {
  80   int fd;
  81   struct stat st;
  82   char * buffer;
  83   size_t buffer_size;
  84   ssize_t ret;
  85   char * temp_ptr;
  86   unsigned int i;
  87
  88   fd = open(store_ptr->path, O_RDONLY);
  89   if (fd == -1)
  90   {
  91     log_error("open(%s) failed: %d (%s)", store_ptr->path, errno, strerror(errno));
  92     goto exit;
  93   }
  94
  95   if (fstat(fd, &st) != 0)
  96   {
  97     log_error("fstat(%s) failed: %d (%s)", store_ptr->path, errno, strerror(errno));
  98     goto close;
  99   }
 100
 101   buffer_size = (size_t)st.st_size;
 102   buffer = malloc(buffer_size + 1);
 103   if (buffer == NULL)
 104   {
 105     log_error("malloc() failed to allocate %zy byte buffer for reading the contents of the recent items file '%s'", buffer_size + 1, store_ptr->path);
 106     goto close;
 107   }
 108
 109   ret = read(fd, buffer, buffer_size);
 110   if (ret == -1)
 111   {
 112     log_error("read(%s) failed: %d (%s)", store_ptr->path, errno, strerror(errno));
 113     goto free;
 114   }
 115
 116   if (ret < (size_t)buffer_size)
 117   {
 118     /* this could be handled better but we dont care because it is expected for the file to be small enough */
 119     log_error("read(%s) returned less bytes than requested", store_ptr->path);
 120     goto free;
 121   }
 122
 123   buffer[buffer_size] = 0;
 124
 125   /* read lines and store them in the item array */
 126   temp_ptr = strtok(buffer, "\n");
 127   i = 0;
 128   while (temp_ptr != NULL && i < store_ptr->max_items)
 129   {
 130     ASSERT(store_ptr->items[i] == NULL); /* filling an empty array */
 131
 132     store_ptr->items[i] = strdup(temp_ptr);
 133     if (store_ptr->items[i] == NULL)
 134     {
 135       log_error("strdup(\"%s\") failed.", temp_ptr);
 136       goto free;
 137     }
 138
 139     i++;
 140     temp_ptr = strtok(NULL, "\n");
 141   }
 142
 143 free:
 144   free(buffer);
 145 close:
 146   close(fd);
 147 exit:
 148   return;
 149 }
 150
 151 bool
 152 ladish_recent_store_create(
 153   const char * file_path,
 154   unsigned int max_items,
 155   ladish_recent_store_handle * store_handle_ptr)
 156 {
 157   struct ladish_recent_store * store_ptr;
 158   unsigned int i;
 159
 160   store_ptr = malloc(sizeof(struct ladish_recent_store));
 161   if (store_ptr == NULL)
 162   {
 163     log_error("malloc() failed to allocate a ladish_recent_store struct");
 164     goto fail;
 165   }
 166
 167   store_ptr->path = strdup(file_path);
 168   if (store_ptr->path == NULL)
 169   {
 170     log_error("strdup() failed for recent store path '%s'", file_path);
 171     goto free_store;
 172   }
 173
 174   store_ptr->items = malloc(sizeof(char *) * max_items);
 175   if (store_ptr->items == NULL)
 176   {
 177     log_error("malloc() failed to array of %u pointers", max_items);
 178     goto free_path;
 179   }
 180
 181   for (i = 0; i < max_items; i++)
 182   {
 183     store_ptr->items[i] = NULL;
 184   }
 185
 186   store_ptr->max_items = max_items;
 187
 188   /* try to load items from file */
 189   ladish_recent_store_load(store_ptr);
 190
 191   *store_handle_ptr = (ladish_recent_store_handle)store_ptr;
 192
 193   return true;
 194
 195 free_path:
 196   free(store_ptr->path);
 197 free_store:
 198   free(store_ptr);
 199 fail:
 200   return false;
 201 }
 202
 203 #define store_ptr ((struct ladish_recent_store *)store_handle)
 204
 205 void
 206 ladish_recent_store_destroy(
 207   ladish_recent_store_handle store_handle)
 208 {
 209   free(store_ptr->items);
 210   free(store_ptr->path);
 211   free(store_ptr);
 212 }
 213
 214 void
 215 ladish_recent_store_use_item(
 216   ladish_recent_store_handle store_handle,
 217   const char * item_const)
 218 {
 219   char * item;
 220   char * item_save;
 221   unsigned int i;
 222
 223   for (i = 0; i < store_ptr->max_items && store_ptr->items[i] != NULL; i++)
 224   {
 225     if (strcmp(store_ptr->items[i], item_const) == 0)
 226     { /* already known item */
 227
 228       /* if the item is already the most recent one, there is nothing to do */
 229       if (i != 0)
 230       {
 231         item = store_ptr->items[i];
 232         store_ptr->items[i] = NULL; /* mark end for reorder loop */
 233         goto reorder;
 234       }
 235
 236       return;
 237     }
 238   }
 239
 240   /* new item */
 241   item = strdup(item_const);
 242   if (item == NULL)
 243   {
 244     log_error("strdup() failed for recent item '%s'", item_const);
 245     return;
 246   }
 247
 248 reorder:
 249   /* we have valid non-NULL item pointer before the iteration begins */
 250   /* the item pointer is checked for NULL because that means either
 251      end of used items or a mark created when already known item
 252      was removed from the array */
 253   for (i = 0; i < store_ptr->max_items && item != NULL; i++)
 254   {
 255     item_save = store_ptr->items[i];
 256     store_ptr->items[i] = item;
 257     item = item_save;
 258   }
 259
 260   if (item != NULL)
 261   { /* eventually free the oldest item */
 262     free(item);
 263   }
 264
 265   ladish_recent_store_save(store_ptr);
 266 }
 267
 268 void
 269 ladish_recent_store_iterate_items(
 270   ladish_recent_store_handle store_handle,
 271   void * callback_context,
 272   bool (* callback)(void * callback_context, const char * item))
 273 {
 274   unsigned int i;
 275
 276   for (i = 0; i < store_ptr->max_items && store_ptr->items[i] != NULL; i++)
 277   {
 278     if (!callback(callback_context, store_ptr->items[i]))
 279     {
 280       break;
 281     }
 282   }
 283 }
 284
 285 #undef store_ptr