/*
 * Copyright (c) 2015-2020 Red Hat, Inc.
 *
 * All rights reserved.
 *
 * Author: Jan Friesse (jfriesse@redhat.com)
 *
 * This software licensed under BSD license, the text of which follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of the Red Hat, Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/file.h>
#include <arpa/inet.h>
#include <sys/stat.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <grp.h>
#include <inttypes.h>
#include <libgen.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <syslog.h>

#include "utils.h"

#define UTILS_GID_DETERMINE_MAX_SIZE	65536

/*
 * Check string to value on, off, yes, no, 0, 1. Return 1 if value is on, yes or 1, 0 if
 * value is off, no or 0 and -1 otherwise.
 */
int
utils_parse_bool_str(const char *str)
{

	if (strcasecmp(str, "yes") == 0 ||
	    strcasecmp(str, "on") == 0 ||
	    strcasecmp(str, "1") == 0) {
		return (1);
	} else if (strcasecmp(str, "no") == 0 ||
	    strcasecmp(str, "off") == 0 ||
	    strcasecmp(str, "0") == 0) {
		return (0);
	}

	return (-1);
}

int
utils_flock(const char *lockfile, pid_t pid, int *another_instance_running)
{
	struct flock lock;
	char pid_s[17];
	int fd_flag;
	int lf;
	char *dname;

	*another_instance_running = 0;

	/*
	 * lockfile directory may not exists. Creation of directory should
	 * be handled by initscript/tmpfiles.d. But as a last chance it
	 * make sense to try to create it here.
	 */
	dname = strdup(lockfile);
	if (dname != NULL) {
		(void)mkdir(dirname(dname), 0770);
		free(dname);
	}

	lf = open(lockfile, O_WRONLY | O_CREAT, 0640);
	if (lf == -1) {
		return (-1);
	}

retry_fcntl:
	lock.l_type = F_WRLCK;
	lock.l_start = 0;
	lock.l_whence = SEEK_SET;
	lock.l_len = 0;
	if (fcntl(lf, F_SETLK, &lock) == -1) {
		switch (errno) {
		case EINTR:
			goto retry_fcntl;
			break;
		case EAGAIN:
		case EACCES:
			*another_instance_running = 1;
			goto error_close;
			break;
		default:
			goto error_close;
			break;
		}
	}

	if (ftruncate(lf, 0) == -1) {
		goto error_close_unlink;
	}

	memset(pid_s, 0, sizeof(pid_s));
	snprintf(pid_s, sizeof(pid_s) - 1, "%u\n", pid);

retry_write:
	if (write(lf, pid_s, strlen(pid_s)) != (ssize_t)strlen(pid_s)) {
		if (errno == EINTR) {
			goto retry_write;
		} else {
			goto error_close_unlink;
		}
	}

	if ((fd_flag = fcntl(lf, F_GETFD, 0)) == -1) {
		goto error_close_unlink;
	}
	fd_flag |= FD_CLOEXEC;
	if (fcntl(lf, F_SETFD, fd_flag) == -1) {
		goto error_close_unlink;
	}

	return (lf);

error_close_unlink:
	unlink(lockfile);
error_close:
	close(lf);

	return (-1);
}

void
utils_tty_detach(void)
{
	int devnull;

	switch (fork()) {
		case -1:
			err(EXIT_FAILURE, "Can't create child process");
			break;
		case 0:
			break;
		default:
			exit(EXIT_SUCCESS);
			break;
	}

	/* Create new session */
	(void)setsid();

	/*
	 * Map stdin/out/err to /dev/null.
	 */
	devnull = open("/dev/null", O_RDWR);
	if (devnull == -1) {
		err(EXIT_FAILURE, "Can't open /dev/null");
	}

	if (dup2(devnull, 0) < 0 || dup2(devnull, 1) < 0
	    || dup2(devnull, 2) < 0) {
		close(devnull);
		err(EXIT_FAILURE, "Can't dup2 stdin/out/err to /dev/null");
	}
	close(devnull);
}

int
utils_fd_set_non_blocking(int fd)
{
	int flags;

	flags = fcntl(fd, F_GETFL, NULL);

	if (flags < 0) {
		return (-1);
	}

	flags |= O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags) < 0) {
		return (-1);
	}

	return (0);
}

/*
 * Safer wrapper of strtoll. Return 0 on success, otherwise -1.
 */
int
utils_strtonum_base(const char *str, long long int min_val, long long int max_val,
    int base, long long int *res)
{
	long long int tmp_ll;
	char *ep;

	if (min_val > max_val) {
		return (-1);
	}

	errno = 0;

	tmp_ll = strtoll(str, &ep, base);
	if (ep == str || *ep != '\0' || errno != 0) {
		return (-1);
	}

	if (tmp_ll < min_val || tmp_ll > max_val) {
		return (-1);
	}

	*res = tmp_ll;

	return (0);
}

/*
 * Shortcut for decimal utils_strtonum_base
 */
int
utils_strtonum(const char *str, long long int min_val, long long int max_val,
    long long int *res)
{

	return (utils_strtonum_base(str, min_val, max_val, 10, res));
}

/*
 * Safer wrapper of strtod. Return 0 on success, otherwise -1.
 */
int
utils_strtod(const char *str, double min_val, double max_val,
    double *res)
{
	double tmp_d;
	char *ep;

	if (min_val > max_val) {
		return (-1);
	}

	errno = 0;

	tmp_d = strtod(str, &ep);
	if (ep == str || *ep != '\0' || errno != 0) {
		return (-1);
	}

	if (tmp_d < min_val || tmp_d > max_val || isnan(tmp_d)) {
		return (-1);
	}

	*res = tmp_d;

	return (0);
}

/*
 * Check if string is empty and set set_umask to 0, or parse string
 * as umask octal number and set set_umask to 1 and umask value.
 * Return 0 on success, otherwise -1.
 */
int
utils_parse_umask(const char *str, int *set_umask, mode_t *umask)
{
	long long int tmpll;

	if (strcmp(str, "") == 0) {
		*set_umask = 0;
	} else {
		if (utils_strtonum_base(str, 0, S_IRWXU|S_IRWXG|S_IRWXO, 8, &tmpll) == -1) {
			return (-1);
		}

		*set_umask = 1;
		*umask = (mode_t)tmpll;
	}

	return (0);
}

/*
 * Get gid of group with grp_name name. On success, 0 is returned and
 * gid contains valid group id or -1 if grp_name is empty string or -1.
 * In case of error including group doesn't exist -1 is returned and
 * gid is not changed.
 */
int
utils_get_group_gid(const char *grp_name, gid_t *gid)
{
	long long int tmpll;
	char *grp_buf, *tmp_buf;
	long int grp_buf_size;
	int res;
	struct group grp, *grp_res;
	int ret;

	ret = 0;

	if (strcmp(grp_name, "") == 0) {
		*gid = (gid_t)-1;

		return (0);
	}

	if (utils_strtonum(grp_name, -1, UINT_MAX, &tmpll) == 0) {
		*gid = (gid_t)tmpll;

		return (0);
	}

	grp_buf_size = sysconf(_SC_GETGR_R_SIZE_MAX);
	if (grp_buf_size == -1) {
		grp_buf_size = 4096;
	}

	grp_buf = malloc(grp_buf_size);
	if (grp_buf == NULL) {
		return (-1);
	}

	while ((res = getgrnam_r(grp_name, &grp, grp_buf, grp_buf_size, &grp_res)) == ERANGE) {
		grp_buf_size *= 2;

		if (grp_buf_size > UTILS_GID_DETERMINE_MAX_SIZE) {
			ret = -1;

			goto exit_free_grp_buf;
		}

		tmp_buf = realloc(grp_buf, grp_buf_size);
		if (tmp_buf == NULL) {
			ret = -1;

			goto exit_free_grp_buf;
		}

		grp_buf = tmp_buf;
	}

	if (res != 0) {
		ret = -1;

		goto exit_free_grp_buf;
	}

	if (grp_res == NULL) {
		ret = -1;

		goto exit_free_grp_buf;
	} else {
		*gid = grp.gr_gid;
	}

exit_free_grp_buf:
	free(grp_buf);

	return (ret);
}
