path: root/src/main.c

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <sqlite3.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>

#define DATABASE_PATH (FTAG_ROOT "/ftag.sqlite3")

struct ftag_command {
	const char *name;
	void (*func)(int argc, char **argv);
};

/* Parse arguments using an array of available commands. ARGV[0] has to match
 * the "name" field of an entry of COMMANDS. */
static void parse_args(int argc,
		       char ** argv,
		       const struct ftag_command *commands,
		       int command_count);

static void __sqlite3_check(int rc, sqlite3 *db, const char *file, int line, const char *func)
{
	if (rc == SQLITE_OK)
		return;

	fprintf(stderr, "%s:%d: %s: %s\n", file, line, func, sqlite3_errmsg(db));
	sqlite3_close(db);
	exit(EXIT_FAILURE);
}

#define sqlite3_check(RC, DB) __sqlite3_check(RC, DB, __FILE__, __LINE__, __func__)

static int file_exists(const char *path)
{
	struct stat statbuf __attribute__((unused));
	int rc = stat(path, &statbuf);
	if (rc == 0)
		return 1;
	else
		return 0;
}

static void assert_db_exists(void)
{
	errno = 0;
	if (file_exists(DATABASE_PATH) && (errno == 0))
		return;

	if (errno == ENOENT) {
		fprintf(stderr,
			"ftag: database not found at \"%s\", "
			"have you run \"ftag init\"?\n",
			DATABASE_PATH);
	}
	else {
		perror(DATABASE_PATH);
	}
	exit(EXIT_FAILURE);
}

/* Make sure STR contains no single quote, not to break SQL queries. */
static void assert_no_single_quote(const char *str)
{
	assert(strchr(str, '\'') == NULL);
}

static void ftag_init(int, char **)
{
	int rc = mkdir(FTAG_ROOT "/files", 0755);
	if (rc == -1) {
		perror(FTAG_ROOT "/files");
		exit(EXIT_FAILURE);
	}
	char cmd[1024];
	memset(cmd, 0, sizeof(cmd));
	snprintf(cmd, sizeof(cmd)-1,
		 "sqlite3 %s < %s", DATABASE_PATH, FTAG_ROOT "/sql/init.sql");
	execl("/usr/bin/sh", "/usr/bin/sh", "-c", cmd, NULL);
	perror("exec");
	exit(EXIT_FAILURE);
}

static int ftag_print(void *, int, char **cols, char **)
{
	assert(cols[0]);
	printf("%s\n", cols[0]);
	return 0;
}

static void ftag_list_table(const char *table, const char *col)
{
	char sql[64];
	sqlite3 *db = NULL;
	int rc;

	rc = sqlite3_open(DATABASE_PATH, &db);
	sqlite3_check(rc, db);

	memset(sql, 0, sizeof(sql));
	snprintf(sql, sizeof(sql)-1, "SELECT %s FROM %s;", col, table);
	rc = sqlite3_exec(db, sql, ftag_print, NULL, NULL);
	sqlite3_check(rc, db);
	sqlite3_close(db);
}

/* Write to OUT a version of IN that does not contain any blank or uppercase
 * letter. */
static void canonicalize(char *out, const char *in)
{
	int i;
	for (i = 0; i < strlen(in)-1; i++) {
		if (in[i] >= 'A' && in[i] <= 'Z')
			out[i] = in[i] - 'A' + 'a';
		else if (in[i] == ' ')
			out[i] = '_';
		else
			out[i] = in[i];
	}
	out[i] = '\0';
}

static void ftag_add_one_file(sqlite3 *db,
			      int *last_id,
			      const char *file)
{
	char sql[2048];
	int rc;
	char *full_name = NULL;
	char *canonical_name = NULL;
	char *description =  NULL;
	char *date = NULL;
	size_t line_len = 0;
	ssize_t read_len;

	if (!file_exists(file)) {
		perror(file);
		exit(EXIT_FAILURE);
	}

	printf("ftag file add: adding file \"%s\" to database\n", file);
	
	printf("Enter the full name, a version of the name that\n"
	       "may contain blanks and every type of character.\n");
	read_len = getline(&full_name, &line_len, stdin);
	if (read_len == -1) {
		perror("getline");
		exit(EXIT_FAILURE);
	}
	assert_no_single_quote(full_name);

	line_len = read_len+1;
	canonical_name = malloc(line_len);
	canonicalize(canonical_name, full_name);

	printf("Enter the canonical name, a version of the name that\n"
	       "ideally contains no blank and, if possible, no upper\n"
	       "case letters and no symbols. If no input is given,\n"
	       "canonical name will be \"%s\".\n", canonical_name);
	read_len = getline(&canonical_name, &line_len, stdin);
	if (read_len == -1) {
		perror("getline");
		exit(EXIT_FAILURE);
	}
	if (canonical_name[0] == '\n')
		canonicalize(canonical_name, full_name);
	assert_no_single_quote(canonical_name);

	printf("Enter the description.\n");
	line_len = 0;
	read_len = getline(&description, &line_len, stdin);
	if (read_len == -1) {
		perror("getline");
		exit(EXIT_FAILURE);
	}
	if (!description)
		description = strdup("");
	assert_no_single_quote(description);

	line_len = 32;
	date = malloc(line_len);
	time_t now = time(NULL);
	struct tm *now_tm = localtime(&now);
	strftime(date, line_len-1, "%Y-%m-%d", now_tm);
	printf("Enter the date in the format YYYY-MM-DD. If no input is\n"
	       "given, date will be \"%s\".\n", date);
	read_len = getline(&date, &line_len, stdin);
	if (read_len == -1) {
		perror("getline");
		exit(EXIT_FAILURE);
	}
	if (date[0] == '\n')
		strftime(date, line_len-1, "%Y-%m-%d", now_tm);

	memset(sql, 0, sizeof(sql));
	snprintf(sql, sizeof(sql)-1,
		 "INSERT INTO files VALUES(%d, '%s', '%s', '%s', '%s')",
		 *last_id, canonical_name, full_name, description, date);
	rc = sqlite3_exec(db, sql, NULL, NULL, NULL);
	sqlite3_check(rc, db);
	(*last_id)++;

	char new_path[512];
	memset(new_path, 0, sizeof(new_path));
	snprintf(new_path, sizeof(new_path)-1,
		 "%s/files/%s", FTAG_ROOT, canonical_name);
	int out_fd = open(new_path, O_WRONLY | O_CREAT, 0644);

	if (out_fd == -1) {
		perror("open");
		exit(EXIT_FAILURE);
	}

	int in_fd = open(file, O_RDONLY);

	if (in_fd == -1) {
		perror("open");
		exit(EXIT_FAILURE);
	}

	ssize_t written_bytes;
	while ((written_bytes = sendfile(out_fd, in_fd, NULL, 4096)) == 4096)
		;

	if (written_bytes == -1) {
		perror("sendfile");
		exit(EXIT_FAILURE);
	}

	free(now_tm);
	close(in_fd);
	close(out_fd);
	free(full_name);
	free(canonical_name);
	free(description);
}

/* Add new files to the database. */
static void ftag_file_add(int argc, char **argv)
{
	if (argc == 0) {
		fprintf(stderr, "ftag file add: must supply file names\n");
		exit(EXIT_FAILURE);
	}
	sqlite3 *db = NULL;
	int rc;
	int last_id;
	rc = sqlite3_open(DATABASE_PATH, &db);
	sqlite3_check(rc, db);
	/* TODO: set last_id properly */
	for (int i = 0; i < argc; i++)
		ftag_add_one_file(db, &last_id, argv[i]);
	sqlite3_close(db);
}

static void ftag_file_list(int argc, char **argv)
{
	ftag_list_table("files", "full_name");
}

static void ftag_file_tag(int argc, char **argv)
{
	if (argc < 2) {
		fprintf(stderr,
			"ftag file tag: must supply a file name and tags\n");
		exit(EXIT_FAILURE);
	}
}

static void ftag_file(int argc, char **argv)
{
	assert_db_exists();
	const struct ftag_command file_commands[] = {
		{.name = "add", .func = ftag_file_add},
		{.name = "list", .func = ftag_file_list},
		{.name = "tag", .func = ftag_file_tag}
	};
	const int file_command_count = sizeof(file_commands) / sizeof(struct ftag_command);
	parse_args(argc, argv, file_commands, file_command_count);
}

static void ftag_help(int, char **)
{
	printf("Usage: ftag COMMAND [COMMAND-ARG]...\n");
	printf("Available values for COMMAND:\n");
	printf("  init    initialize the database\n");
	printf("  file    manage files");
	printf("  help    print this message\n");
	printf("  tag     manage tags\n");
	printf("Configuration:\n");
	printf("  database path    %s\n", DATABASE_PATH);
	printf("  ftag root        %s\n", FTAG_ROOT);
}

/* Check that the tag we are trying to create does not exist yet. If this
 * callback is ever called, then it already exist, this is a fatal error. */
static int ftag_tag_check(void *, int, char **cols, char **)
{
	assert(cols[0]);
	assert(cols[1]);
	fprintf(stderr,
		"ftag tag add: error: tag \"%s\" already exists, its description is:\n",
		cols[0]);
	fprintf(stderr, "%s\n", cols[1]);
	return 1;
}

static int ftag_tag_last_id(void *_id, int, char **cols, char **)
{
	int *id = _id;
	assert(cols);
	assert(cols[0]);
	*id = atoi(cols[0]);
	return 0;
}

static void ftag_tag_add(int argc, char **argv)
{
	if (argc != 2) {
		fprintf(stderr,
			"ftag tag add: error: must supply two arguments, "
			"the tag name and its description\n");
		exit(EXIT_FAILURE);
	}
	const char *new_tag_name = argv[0];
	assert(strlen(new_tag_name) <= 255);
	assert_no_single_quote(new_tag_name);

	char sql[1024];
	sqlite3 *db = NULL;
	int rc;

	rc = sqlite3_open(DATABASE_PATH, &db);
	sqlite3_check(rc, db);

	memset(sql, 0, sizeof(sql));
	snprintf(sql, sizeof(sql)-1,
		 "SELECT name, description FROM tags WHERE name = '%s';", new_tag_name);
	rc = sqlite3_exec(db, sql, ftag_tag_check, NULL, NULL);
	sqlite3_check(rc, db);

	int last_id = -1;
	memset(sql, 0, sizeof(sql));
	snprintf(sql, sizeof(sql)-1, "SELECT MAX(id) FROM tags;");
	rc = sqlite3_exec(db, sql, ftag_tag_last_id, &last_id, NULL);
	sqlite3_check(rc, db);

	const char *new_tag_desc = argv[1];
	assert(strlen(new_tag_desc) <= 600);
	assert_no_single_quote(new_tag_desc);
	last_id++;
	memset(sql, 0, sizeof(sql));
	snprintf(sql, sizeof(sql)-1,
		 "INSERT INTO tags VALUES(%d, '%s', '%s');",
		 last_id, new_tag_name, new_tag_desc);
	rc = sqlite3_exec(db, sql, NULL, NULL, NULL);
	sqlite3_check(rc, db);
	sqlite3_close(db);
}

static void ftag_tag_list(int argc, char **argv)
{
	ftag_list_table("tags", "name");
}

static void ftag_tag(int argc, char **argv)
{
	assert_db_exists();
	const struct ftag_command tag_commands[] = {
		{.name = "add",  .func = ftag_tag_add},
		{.name = "list", .func = ftag_tag_list}
	};
	int tag_command_count = sizeof(tag_commands) / sizeof(struct ftag_command);
	parse_args(argc, argv, tag_commands, tag_command_count);
}

static void parse_args(int argc,
		       char **argv,
		       const struct ftag_command *commands,
		       int command_count)
{
	assert(argc > 0);
	assert(command_count > 0);
	for (int i = 0; i < command_count; i++) {
		if (strcmp(argv[0], commands[i].name) == 0) {
			commands[i].func(argc-1, argv+1);
			return;
		}
	}

	fprintf(stderr, "ftag: command \"%s\" unknown\n", argv[0]);
	exit(EXIT_FAILURE);
}

int main(int argc, char *argv[])
{
	if (argc == 1) {
		ftag_help(0, NULL);
		exit(EXIT_FAILURE);
	}

	const struct ftag_command toplevel_commands[] = {
		{.name = "init", .func = ftag_init},
		{.name = "file", .func = ftag_file},
		{.name = "help", .func = ftag_help},
		{.name = "tag",  .func = ftag_tag}
	};
	const int toplevel_command_count = sizeof(toplevel_commands) / sizeof(struct ftag_command);
	parse_args(argc-1, argv+1, toplevel_commands, toplevel_command_count);
	return EXIT_SUCCESS;
}