utils.c

/*
	Copyright(C) 2016, Red Hat, Inc., Stanislav Kozina

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/*
 * This file contains couple of generally useful functions.
 */

#include <sys/types.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <assert.h>
#include <libgen.h> /* dirname() */

#include "main.h"
#include "utils.h"
#include "hash.h"

/*
 * Sort function for scandir.
 * Walk regular file first, then process subdirectories.
 */
int reg_first(const struct dirent **a, const struct dirent **b)
{
	if ((*a)->d_type == DT_REG && (*b)->d_type != DT_REG)
		return -1;
	if ((*b)->d_type == DT_REG && (*a)->d_type != DT_REG)
		return 1;

	/*
	 * Backup to default collation
	 * Note: the behavior depends on LC_COLLATE
	 */
	return alphasort(a, b);
}

/*
 * Call cb() on all nodes in the directory structure @path.
 * If list_dirs == true run cb() on subdirectories as well, otherwise list only
 * files.
 * The cb() has to return true if we continue directory walk or false if we're
 * all done.
 */
void walk_dir(char *path, bool list_dirs, walk_rv_t (*cb)(char *, void *),
		void *arg)
{
	struct dirent **entlist;
	walk_rv_t cb_rv = WALK_CONT;
	int entries, i;

	assert(path != NULL && strlen(path) >= 1);

	entries = scandir(path, &entlist, NULL, reg_first);
	if (entries == -1) {
		fail("Failed to scan module directory %s: %s\n", path,
		    strerror(errno));
	}

	/* process all the files and directories within directory */
	for (i = 0; i < entries; i++) {
		struct dirent *ent = entlist[i];
		struct stat entstat;
		char *new_path;

		if ((strcmp(ent->d_name, "..") == 0) ||
		    (strcmp(ent->d_name, ".") == 0)) {
			free(ent);
			continue;
		}

		if (path[strlen(path) - 1] == '/')
			safe_asprintf(&new_path, "%s%s", path, ent->d_name);
		else
			safe_asprintf(&new_path, "%s/%s", path, ent->d_name);

		if (lstat(new_path, &entstat) != 0) {
			fail("Failed to stat directory %s: %s\n", new_path,
			    strerror(errno));
		}

		if (S_ISDIR(entstat.st_mode)) {
			if (list_dirs) {
				cb_rv = cb(new_path, arg);
				if (cb_rv != WALK_CONT)
					goto out;
			}

			/* Ignore symlinks */
			if (!S_ISLNK(entstat.st_mode))
				walk_dir(new_path, list_dirs, cb, arg);
		} else if (S_ISREG(entstat.st_mode)) {
			cb_rv = cb(new_path, arg);
		}

out:
		free(new_path);
		free(ent);

		if (cb_rv == WALK_STOP)
			break;
		if (cb_rv == WALK_SKIP) {
			cb_rv = WALK_CONT;
			break;
		}
	}

	free(entlist);
}

int check_is_directory(char *dir)
{
	struct stat dirstat;

	if (stat(dir, &dirstat) != 0)
		return errno;

	if (!S_ISDIR(dirstat.st_mode))
		return ENOTDIR;

	return 0;
}

static void safe_mkdir(char *path)
{
	if (mkdir(path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0)
		fail("%s", strerror(errno));
}

void rec_mkdir(char *path)
{
	char *buf;
	char *pos;
	size_t len = strlen(path);

	assert(path != NULL && len > 0);

	buf = safe_strdup(path);

	/* Get rid of trailing slashes */
	for (pos = buf + len - 1; pos > buf && *pos == '/'; --pos)
		*pos = '\0';

	pos = buf;
	while (pos != NULL) {
		int rv;
		char *next;

		/* Skip multiple slashes */
		for (next = pos + 1; *next == '/'; next++)
			;

		pos = strchr(next, '/');
		if (pos != NULL)
			*pos = '\0';
		rv = check_is_directory(buf);
		if (rv != 0) {
			if (rv == ENOENT)
				safe_mkdir(buf);
			else
				fail("%s", strerror(rv));
		}

		if (pos != NULL)
			*pos = '/';
	}

	free(buf);
}

void safe_rename(const char *oldpath, const char *newpath)
{
	char *temp;

	temp = safe_strdup(newpath);
	/* dirname() modifies its buffer! */
	rec_mkdir(dirname(temp));
	free(temp);

	if (rename(oldpath, newpath) != 0)
		fail("rename() failed: %s\n", strerror(errno));
}

struct norm_ctx {
	char *path;
	char *p;
	char *outp;
};

/* actually, second last, skip the whole directory */
static char *last_slash(char *str, char *end)
{
	char c = '/';
	int met = 0;

	for (; end > str; end--) {
		if (*end == c) {
			if (met)
				return end;
			else
				met = 1;
		}
	}
	return NULL;
}

typedef void *(*state_t)(struct norm_ctx *);

static void *initial(struct norm_ctx *ctx);
static void *normal(struct norm_ctx *ctx);
static void *one_dot(struct norm_ctx *ctx);
static void *two_dots(struct norm_ctx *ctx);
static void *slash(struct norm_ctx *ctx);
static void *end(struct norm_ctx *ctx);

static void *initial(struct norm_ctx *ctx)
{
	char c = *ctx->p++;

	switch (c) {
	case '\0':
		*ctx->outp = c;
		return end;
	case '/':
		*ctx->outp++ = c;
		return slash;
	case '.':
		return one_dot;
	default:
		*ctx->outp++ = c;
	}
	return normal;
}

static void *normal(struct norm_ctx *ctx)
{
	char c = *ctx->p++;

	switch (c) {
	case '\0':
		*ctx->outp++ = c;
		return end;
	case '/':
		*ctx->outp++ = c;
		return slash;
	default:
		*ctx->outp++ = c;
	}
	return normal;
}

static void *slash(struct norm_ctx *ctx)
{
	char c = *ctx->p++;

	switch (c) {
	case '\0':
		fail("Cannot normalize path %s", ctx->path);
	case '/':
		return slash;
	case '.':
		return one_dot;
	default:
		*ctx->outp++ = c;
	}
	return normal;
}

static void *one_dot(struct norm_ctx *ctx)
{
	char c = *ctx->p++;

	switch (c) {
	case '\0':
		*--ctx->outp = c;
		return end;
	case '/':
		return slash;
	case '.':
		return two_dots;
	default:
		*ctx->outp++ = '.';
		*ctx->outp++ = c;
	}
	return normal;
}

static void *two_dots(struct norm_ctx *ctx)
{
	char c = *ctx->p++;
	char *p;

	switch (c) {
	case '\0':
		p = last_slash(ctx->path, ctx->outp);
		if (p == NULL)
			p = ctx->path;
		*p = c;
		return end;
	case '/':
		p = last_slash(ctx->path, ctx->outp);
		if (p == NULL) {
			ctx->outp = ctx->path;
			return normal;
		}
		ctx->outp = ++p;
		return slash;
	default:
		*ctx->outp++ = '.';
		*ctx->outp++ = '.';
		*ctx->outp++ = c;
	}
	return normal;
}

static void *end(struct norm_ctx *ctx)
{
	fail("Cannot normalize path %s", ctx->path);
}

char *path_normalize(char *path)
{
	struct norm_ctx ctx = {
		.path = path,
		.p = path,
		.outp = path,
	};
	state_t state = initial;

	while (state != end)
		state = state(&ctx);

	return path;
}

/* Removes the two dashes at the end of the prefix */
#define IS_PREFIX(s, prefix) !strncmp(s, prefix, strlen(prefix) - 2)

static void split_filename(const char *filename, char **prefix,
			   char **name, int *version)
{
	/* GNU version of basename never modifies its argument */
	char *base = basename((char *)filename);

	version = 0;

	if ((sscanf(base, "%m[a-z]--%m[^.-].txt", prefix, name) != 2) &&
	    (sscanf(base, "%m[a-z]--%m[^.-]-%i.txt",
		    prefix, name, version) != 3))
		fail("Unexpected file name: %s\n", filename);
}

/*
 * Get the type of a symbol from the name of the kabi file
 *
 * It allocates the string which must be freed by the caller.
 */
char *filenametotype(const char *filename)
{
	char *prefix = NULL, *name = NULL, *type = NULL;
	int version = 0;

	split_filename(filename, &prefix, &name, &version);

	if (IS_PREFIX(prefix, TYPEDEF_FILE))
		type = name;
	else if (IS_PREFIX(prefix, STRUCT_FILE) ||
		 IS_PREFIX(prefix, UNION_FILE) ||
		 IS_PREFIX(prefix, ENUM_FILE))
		safe_asprintf(&type, "%s %s", prefix, name);
	else
		fail("Unexpected file prefix: %s\n", prefix);

	free(prefix);
	if (name != type)
		free(name);

	return type;
}

/*
 * Get the name of a symbol from the name of the kabi file
 *
 * It allocates the string which must be freed by the caller.
 */
char *filenametosymbol(const char *filename)
{
	char *prefix = NULL, *name = NULL;
	int version = 0;

	split_filename(filename, &prefix, &name, &version);
	free(prefix);

	return name;
}

struct hash *global_string_keeper;

void global_string_keeper_init(void)
{
	global_string_keeper = hash_new(1 << 20, free);
}

void global_string_keeper_free(void)
{
	hash_free(global_string_keeper);
}

const char *global_string_get_copy(const char *string)
{
	const char *result;

	if (string == NULL)
		return NULL;

	result = hash_find(global_string_keeper, string);
	if (result == NULL) {
		result = safe_strdup(string);
		hash_add(global_string_keeper, result, result);
	}

	return result;
}

const char *global_string_get_move(char *string)
{
	const char *result;

	if (string == NULL)
		return NULL;

	result = hash_find(global_string_keeper, string);
	if (result == NULL) {
		result = string;
		hash_add(global_string_keeper, result, result);
	} else {
		free(string);
	}

	return result;
}