src/fs.c

   1 /* agg - the news aggregator
   2  * Copyright (C) 2011 Andreas Waidler <arandes@programmers.at>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #define _XOPEN_SOURCE
  17 #include <sys/time.h>
  18 #include <sys/stat.h>
  19 #include <unistd.h>
  20 #include <string.h>
  21 #include <assert.h>
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <fcntl.h>
  25 #include <time.h>
  26 #include "config.h"
  27 #include "bool.h"
  28 #include "fail.h"
  29 #include "fs.h"
  30
  31 char   feed_title[TEXT_BUFFER_SIZE] = { 0 };
  32 time_t feed_date = 0;
  33 time_t feed_date_new = 0;
  34 bool   feed_is_open = false;
  35
  36 char   item_title[TEXT_BUFFER_SIZE] = { 0 };
  37 char   item_link [TEXT_BUFFER_SIZE] = { 0 };
  38 char   item_desc [TEXT_BUFFER_SIZE] = { 0 };
  39 time_t item_date = 0;
  40
  41 void fs_buffer(char* dest, const char* src, size_t size)
  42 {
  43         assert(dest);
  44         assert(src);
  45         assert(size);
  46
  47         strncpy(dest, src, size);
  48
  49         /* Destination is not null-terminated iff
  50          * strlen(src) >= size. */
  51         if (dest[size - 1] != '\0') {
  52                 dest[size - 4] = '.';
  53                 dest[size - 3] = '.';
  54                 dest[size - 2] = '.';
  55                 dest[size - 1] = '\0';
  56         }
  57
  58         assert(strlen(dest) < size);
  59 }
  60
  61 void sanitize(char* str)
  62 {
  63         char* evil;
  64         while ((evil = strchr(str, '/'))) *evil = '\\';
  65 }
  66
  67 void set_item_date(const char* date)
  68 {
  69         struct tm t;
  70         assert(item_title[0]);
  71         assert(strptime(date, "%a, %d %b %Y %T %z", &t));
  72         item_date = mktime(&t);
  73         assert(item_date != -1);
  74         if (item_date <= feed_date) {
  75                 printf("No new feeds assumed.\n");
  76                 fail(0);
  77         } else if (item_date > feed_date_new) {
  78                 feed_date_new = item_date;
  79         }
  80 }
  81
  82 void set_item_link(const char* link)
  83 {
  84         assert(item_title[0]);
  85         fs_buffer(item_link, link, TEXT_BUFFER_SIZE);
  86 }
  87
  88 void set_item_desc(const char* desc)
  89 {
  90         fs_buffer(item_desc, desc, TEXT_BUFFER_SIZE);
  91 }
  92
  93 void set_item_title(const char* title)
  94 {
  95         assert(item_desc[0] == 0);
  96         fs_buffer(item_title, title, TEXT_BUFFER_SIZE);
  97 }
  98
  99 const char* get_item_title()
 100 {
 101         return item_title;
 102 }
 103
 104 void feed_open(const char* title)
 105 {
 106         struct stat st;
 107
 108         fs_buffer(feed_title, title, TEXT_BUFFER_SIZE);
 109         sanitize(feed_title);
 110
 111         if (!stat(feed_title, &st)) feed_date = st.st_mtime;
 112         mkdir(feed_title, 0755);
 113         assert(!chdir(feed_title));
 114         feed_is_open = true;
 115 }
 116
 117
 118
 119 void feed_flush()
 120 {
 121         struct timeval times[2];
 122         times[0].tv_sec  = feed_date_new;
 123         times[0].tv_usec = 0;
 124         times[1].tv_sec  = feed_date_new;
 125         times[1].tv_usec = 0;
 126
 127         if (!feed_is_open) return;
 128
 129         assert(!chdir(".."));
 130         assert(!utimes(feed_title, times));
 131         feed_is_open = false;
 132 }
 133
 134
 135 void fs_set(const char* name, const char* value)
 136 {
 137         FILE* f;
 138
 139         assert(name);
 140         assert(value);
 141
 142         /* Only write if attribute has a value. */
 143         if (value[0]) {
 144                 assert(f = fopen(name, "w"));
 145                 fprintf(f, "%s", value);
 146                 fclose(f);
 147         }
 148 }
 149
 150 void item_flush()
 151 {
 152         struct timeval times[2];
 153         char buf[FILE_NAME_LENGTH + 1] = { 0 };
 154         const char* name_src;
 155         assert(feed_is_open);
 156
 157
 158         name_src = item_title[0] ? item_title : item_desc;
 159         assert(name_src[0]);
 160         fs_buffer(buf, name_src, FILE_NAME_LENGTH + 1);
 161         sanitize(buf);
 162
 163         assert(mkdir(buf, 0755) == 0);
 164         assert(chdir(buf) == 0);
 165         fs_set("title", item_title);
 166         fs_set("desc",  item_desc);
 167         fs_set("link", item_link);
 168         assert(chdir("..") == 0);
 169
 170         /* FIXME: item date might not have been set. */
 171         times[0].tv_sec  = item_date;
 172         times[0].tv_usec = 0;
 173         times[1].tv_sec  = item_date;
 174         times[1].tv_usec = 0;
 175
 176         assert(!utimes(buf, times));
 177
 178         item_title[0] = 0;
 179         item_desc[0] = 0;
 180         item_link[0] = 0;
 181 }