task

main.c (12216B)

---

 #define _DEFAULT_SOURCE
 #include <dirent.h>
 #include <errno.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/random.h>
 #include <unistd.h>
 
 #define TASK_ID_BYTES 8
 #define TASK_ID_CHARS (TASK_ID_BYTES * 2)
 #define TASKS_DIR "."
 #define DONE_TASKS_DIR "done"
 
 static const char reverse_hex[] = "klmnopqrstuvwxyz";
 
 struct options {
   char *title;
   char priority;
 };
 
 static void print_help(const char *program) {
   printf("usage: %s [--priority A|-p A] <title> [properties...]\n", program);
   printf("\n");
   printf("create a new task.\n");
   printf("\n");
   printf("options:\n");
   printf("  -h, --help           show this help\n");
   printf("  -p, --priority A     set priority A-Z\n");
   printf("  --context            list all known contexts\n");
   printf("  --projects           list all known projects\n");
 }
 
 int has_txt_extension(const char *name) {
   size_t len = strlen(name);
   return len >= 4 && strcmp(name + len - 4, ".txt") == 0;
 }
 
 int generate_task_id(char out[TASK_ID_CHARS + 1]) {
   uint8_t bytes[TASK_ID_BYTES];
 
   size_t got = 0;
   while (got < sizeof(bytes)) {
     ssize_t n = getrandom(bytes + got, sizeof(bytes) - got, 0);
     if (n == -1) {
       return -1;
     }
     got += n;
   }
 
   for (size_t i = 0; i < TASK_ID_BYTES; i++) {
     out[i * 2] = reverse_hex[bytes[i] >> 4];
     out[i * 2 + 1] = reverse_hex[bytes[i] & 0x0f];
   }
 
   out[TASK_ID_CHARS] = '\0';
   return 0;
 }
 
 int task_id_exists_in_dir(const char *dir, const char *id, int allow_missing) {
   struct dirent *dp;
   FILE *fd = NULL;
   int rc = -1;
 
   DIR *dirp = opendir(dir);
   if (dirp == NULL) {
     if (allow_missing && errno == ENOENT) {
       return 0;
     }
 
     fprintf(stderr, "err: failed to open directory: %s\n", strerror(errno));
     goto cleanup;
   }
 
   for (;;) {
     errno = 0;
     dp = readdir(dirp);
     if (dp == NULL) {
       if (errno == 0) {
         break;
       }
       fprintf(stderr, "err: failed to iterate directory: %s\n",
               strerror(errno));
       goto cleanup;
     }
 
     if (dp->d_type != DT_REG) {
       continue;
     }
 
     if (has_txt_extension(dp->d_name) == 0) {
       continue;
     }
 
     char path[1024];
     int path_len;
     if (strcmp(dir, ".") == 0) {
       path_len = snprintf(path, sizeof path, "%s", dp->d_name);
     } else {
       path_len = snprintf(path, sizeof path, "%s/%s", dir, dp->d_name);
     }
 
     if (path_len < 0 || (size_t)path_len >= sizeof path) {
       fprintf(stderr, "err: task file path too long\n");
       goto cleanup;
     }
 
     fd = fopen(path, "r");
     if (fd == NULL) {
       fprintf(stderr, "err: failed to open file: %s\n", strerror(errno));
       goto cleanup;
     }
 
     char line[1024];
     if (fgets(line, sizeof line, fd) == NULL) {
       if (ferror(fd)) {
         fprintf(stderr, "err: failed to read file: %s\n", strerror(errno));
         goto cleanup;
       }
 
       // empty file
       if (fclose(fd) != 0) {
         fprintf(stderr, "err: failed to close file: %s\n", strerror(errno));
         goto cleanup;
       }
 
       fd = NULL;
       continue;
     }
 
     if (fgets(line, sizeof line, fd) == NULL) {
       if (ferror(fd)) {
         fprintf(stderr, "err: failed to read file: %s\n", strerror(errno));
         goto cleanup;
       }
 
       if (fclose(fd) != 0) {
         fprintf(stderr, "err: failed to close file: %s\n", strerror(errno));
         goto cleanup;
       }
 
       fd = NULL;
       continue;
     }
 
     char expected[TASK_ID_CHARS + 6]; // "id: " + 16 + "\n" + "\0"
     snprintf(expected, sizeof expected, "id: %s\n", id);
     if (strcmp(line, expected) == 0) {
       rc = 1;
       goto cleanup;
     }
 
     if (fclose(fd) != 0) {
       fd = NULL;
       fprintf(stderr, "err: failed to close file: %s\n", strerror(errno));
       goto cleanup;
     }
     fd = NULL;
   }
 
   rc = 0;
 
 cleanup:
   if (fd != NULL) {
     if (fclose(fd) != 0) {
       fprintf(stderr, "err: failed to close file: %s\n", strerror(errno));
       rc = -1;
     }
   }
 
   if (dirp != NULL && closedir(dirp) != 0) {
     fprintf(stderr, "err: failed to close directory: %s\n", strerror(errno));
     rc = -1;
   }
 
   return rc;
 }
 
 int task_id_exists(const char *id) {
   int exists = task_id_exists_in_dir(TASKS_DIR, id, 0);
   if (exists != 0) {
     return exists;
   }
 
   return task_id_exists_in_dir(DONE_TASKS_DIR, id, 1);
 }
 
 int generate_unique_task_id(char id[TASK_ID_CHARS + 1]) {
   for (;;) {
     if (generate_task_id(id) != 0) {
       return -1;
     }
 
     int exists = task_id_exists(id);
     if (exists == -1) {
       return -1;
     }
 
     if (!exists) {
       return 0;
     }
   }
 }
 
 static void print_properties(char identifier) {
   struct dirent *dp;
   FILE *fd = NULL;
   int rc = 1;
 
   char *properties[1024];
   size_t properties_len = 0;
 
   DIR *dirp = opendir(TASKS_DIR);
   if (dirp == NULL) {
     fprintf(stderr, "err: failed to open directory: %s\n", strerror(errno));
     goto cleanup;
   }
 
   for (;;) {
     errno = 0;
     dp = readdir(dirp);
     if (dp == NULL) {
       if (errno == 0) {
         break;
       }
       fprintf(stderr, "err: failed to iterate directory: %s\n",
               strerror(errno));
       goto cleanup;
     }
 
     if (dp->d_type != DT_REG) {
       continue;
     }
 
     if (has_txt_extension(dp->d_name) == 0) {
       continue;
     }
 
     fd = fopen(dp->d_name, "r");
     if (fd == NULL) {
       fprintf(stderr, "err: failed to open file: %s\n", strerror(errno));
       goto cleanup;
     }
 
     char line[1024];
     if (fgets(line, sizeof line, fd) == NULL) {
       if (ferror(fd)) {
         fprintf(stderr, "err: failed to read file: %s\n", strerror(errno));
         goto cleanup;
       }
 
       // empty file
       if (fclose(fd) != 0) {
         fprintf(stderr, "err: failed to close file: %s\n", strerror(errno));
         goto cleanup;
       }
 
       fd = NULL;
       continue;
     }
 
     size_t byte = 0;
     while (line[byte] != '\0') {
       char c = line[byte];
 
       if (c == identifier) {
         char property[1024];
         size_t property_len = 0;
 
         while (line[byte] != ' ' && line[byte] != '\n' && line[byte] != '\0' &&
                property_len < sizeof(property) - 1) {
           property[property_len] = line[byte];
           property_len++;
           byte++;
         }
         property[property_len] = '\0';
         property_len++;
 
         char *property_ptr = malloc(sizeof(char) * property_len);
         if (property_ptr == NULL) {
           fprintf(stderr, "err: failed to alloc space for read property: %s\n",
                   strerror(errno));
           goto cleanup;
         }
 
         if (property_len < sizeof(property)) {
           memcpy(property_ptr, property, property_len);
         }
 
         if (properties_len == sizeof(properties) / sizeof(properties[0])) {
           fprintf(stderr, "err: too many properties\n");
           free(property_ptr);
           goto cleanup;
         }
 
         properties[properties_len] = property_ptr;
         properties_len++;
       } else {
         byte++;
       }
     }
 
     if (fclose(fd) != 0) {
       fd = NULL;
       fprintf(stderr, "err: failed to close file: %s\n", strerror(errno));
       goto cleanup;
     }
     fd = NULL;
   }
 
   rc = 0;
 
   for (size_t i = 0; i < properties_len; i++) {
     int is_duplicate = 0;
     for (size_t j = i; j > 0; j--) {
       if (strcmp(properties[i], properties[j - 1]) == 0) {
         is_duplicate = 1;
         break;
       }
     }
 
     if (is_duplicate == 1) {
       continue;
     }
 
     printf("%s\n", properties[i]);
   }
 
 cleanup:
   if (fd != NULL) {
     fclose(fd);
   }
 
   for (size_t i = 0; i < properties_len; i++) {
     free(properties[i]);
   }
 
   if (dirp != NULL && closedir(dirp) != 0 && rc == 0) {
     fprintf(stderr, "err: failed to close directory: %s\n", strerror(errno));
     rc = 1;
   }
 
   if (rc != 0) {
     exit(1);
   }
 }
 
 int main(int argc, char *argv[]) {
   struct options cli_args = {0};
   cli_args.priority = '\0';
 
   if (argc > 1 &&
       (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0)) {
     print_help(argv[0]);
     return 0;
   }
 
   if (argc > 1 && (strcmp(argv[1], "--contexts") == 0)) {
     print_properties('@');
     return 0;
   }
 
   if (argc > 1 && (strcmp(argv[1], "--projects") == 0)) {
     print_properties('+');
     return 0;
   }
 
   if (argc == 1) {
     fprintf(stderr, "err: title required\n");
     exit(1);
   }
 
   int positionals = 0;
   for (int idx = 1; idx < argc; idx++) {
     if (strcmp(argv[idx], "--priority") == 0 || strcmp(argv[idx], "-p") == 0) {
       if (cli_args.priority != '\0') {
         fprintf(stderr, "err: priority specified multiple times\n");
         exit(1);
       }
 
       if (idx + 1 == argc) {
         fprintf(stderr, "err: priority required\n");
         exit(1);
       }
 
       if (strcmp(argv[idx + 1], "") == 0) {
         fprintf(stderr, "err: priority can not be empty\n");
         exit(1);
       }
 
       if (strlen(argv[idx + 1]) != 1) {
         fprintf(stderr,
                 "err: priority must be a single letter between [A-Z]\n");
         exit(1);
       }
 
       cli_args.priority = argv[idx + 1][0];
       idx++;
       continue;
     }
 
     if (strcmp(argv[idx], "") == 0) {
       fprintf(stderr, "err: argument can not be empty\n");
       exit(1);
     }
 
     if (positionals == 0) {
       cli_args.title = argv[idx];
     }
 
     positionals++;
   }
 
   if (cli_args.title == NULL) {
     fprintf(stderr, "err: title required\n");
     exit(1);
   }
 
   if (cli_args.priority != '\0') {
     if (cli_args.priority < 'A' || cli_args.priority > 'Z') {
       fprintf(stderr, "err: priority must be between [A-Z]\n");
       exit(1);
     }
   }
 
   size_t title_len = strlen(cli_args.title);
   if (title_len > 251) {
     fprintf(stderr, "err: title too long for file name\n");
     exit(1);
   }
 
   char title_to_file[256];
   int in_leading_dots = 1;
   for (size_t idx = 0; idx < title_len; idx++) {
     if ((in_leading_dots && cli_args.title[idx] == '.') ||
         cli_args.title[idx] == ' ' || cli_args.title[idx] == '/' ||
         cli_args.title[idx] == '\\') {
       title_to_file[idx] = '_';
     } else {
       in_leading_dots = 0;
       title_to_file[idx] = cli_args.title[idx];
     }
   }
   strcpy(title_to_file + title_len, ".txt");
 
   char id[TASK_ID_CHARS + 1];
   if (generate_unique_task_id(id) != 0) {
     perror("generate_unique_task_id");
     return 1;
   }
 
   FILE *f = fopen(title_to_file, "wx");
   if (f == NULL) {
     fprintf(stderr, "err: failed to open file: %s\n", strerror(errno));
     exit(1);
   }
 
   int write_failed = 0;
   int write_errno = 0;
   if (cli_args.priority != '\0') {
     if (fprintf(f, "(%c) ", cli_args.priority) < 0) {
       write_failed = 1;
       write_errno = errno;
     }
   }
 
   if (fprintf(f, "%s", cli_args.title) < 0) {
     if (!write_failed) {
       write_failed = 1;
       write_errno = errno;
     }
   }
 
   int seen_title = 0;
   for (int idx = 1; idx < argc; idx++) {
     if (strcmp(argv[idx], "--priority") == 0 || strcmp(argv[idx], "-p") == 0) {
       idx++;
       continue;
     }
 
     seen_title++;
     if (seen_title == 1) {
       continue;
     }
 
     if (fprintf(f, " %s", argv[idx]) < 0) {
       if (!write_failed) {
         write_failed = 1;
         write_errno = errno;
       }
     }
   }
 
   if (fprintf(f, "\n") < 0) {
     if (!write_failed) {
       write_failed = 1;
       write_errno = errno;
     }
   }
 
   if (fprintf(f, "id: %s\n", id) < 0) {
     if (!write_failed) {
       write_failed = 1;
       write_errno = errno;
     }
   }
 
   int close_failed = 0;
   int close_errno = 0;
   if (fclose(f) != 0) {
     close_failed = 1;
     close_errno = errno;
   }
 
   if (write_failed) {
     fprintf(stderr, "err: failed to write file: %s\n", strerror(write_errno));
     exit(1);
   }
 
   if (close_failed) {
     fprintf(stderr, "err: failed to close file: %s\n", strerror(close_errno));
     exit(1);
   }
 
   char *editor = getenv("VISUAL");
   if (editor != NULL && strcmp(editor, "") == 0) {
     editor = NULL;
   }
 
   if (editor == NULL) {
     editor = getenv("EDITOR");
   }
 
   if (editor != NULL && strcmp(editor, "") == 0) {
     editor = NULL;
   }
 
   if (editor == NULL) {
     return 0;
   }
 
   execlp("sh", "sh", "-c", "exec $1 \"$2\"", "task", editor, title_to_file,
          NULL);
   perror("err: failed to open editor");
   return 1;
 }