/* OperatingStateFile Handler.
 *
 * Copyright 2018 Adiscon GmbH.
 *
 * This file is part of the rsyslog runtime library.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *       -or-
 *       see COPYING.ASL20 in the source distribution
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>

#include "rsyslog.h"
#include "errmsg.h"
#include "operatingstate.h"
#include "rsconf.h"

#ifndef O_LARGEFILE
#define O_LARGEFILE 0
#endif
#ifndef HAVE_LSEEK64
#  define lseek64(fd, offset, whence) lseek(fd, offset, whence)
#endif

/* some important standard states */
#define STATE_INITIALIZING	"INITIALIZING"
#define STATE_CLEAN_CLOSE	"CLEAN CLOSE"

static int fd_osf = -1;

/* check if old osf points to a problem and, if so, report */
static void
osf_checkOnStartup(void)
{
	int do_rename = 1;
	const char *fn_osf = (const char*) glblGetOperatingStateFile(loadConf);
	char iobuf[sizeof(STATE_CLEAN_CLOSE)];
	const int len_clean_close = sizeof(STATE_CLEAN_CLOSE) - 1;
	assert(fn_osf != NULL);

	const int fd = open(fn_osf, O_RDONLY|O_LARGEFILE|O_CLOEXEC, 0);
	if(fd == -1) {
		if(errno != ENOENT) {
			LogError(errno, RS_RET_ERR, "error opening existing operatingStateFile '%s' - "
				"this may be an indication of a problem; ignoring", fn_osf);
		}
		do_rename = 0;
		goto done;
	}
	assert(fd != -1);
	int offs = lseek64(fd, -(len_clean_close + 1), SEEK_END);
	if(offs == -1){
		LogError(errno, RS_RET_IO_ERROR, "error seeking to end of existing operatingStateFile "
			"'%s' - this may be an indication of a problem, e.g. empty file", fn_osf);
		goto done;
	}
	int rd = read(fd, iobuf, len_clean_close);
	if(rd == -1) {
		LogError(errno, RS_RET_IO_ERROR, "error reading existing operatingStateFile "
			"'%s' - this probably indicates an improper shutdown", fn_osf);
		goto done;
	} else {
		assert(rd <= len_clean_close);
		iobuf[rd] = '\0';
		if(rd != len_clean_close || strcmp(iobuf, STATE_CLEAN_CLOSE) != 0) {
			LogError(errno, RS_RET_IO_ERROR, "existing operatingStateFile '%s' does not end "
				"with '%s, instead it has '%s' - this probably indicates an "
				"improper shutdown", fn_osf, STATE_CLEAN_CLOSE, iobuf);
			goto done;
		}
	}

	/* all ok! */
	do_rename = 0;
done:
	if(fd != -1) {
		close(fd);
	}
	if(do_rename) {
		char newname[MAXFNAME];
		snprintf(newname, sizeof(newname)-1, "%s.previous", fn_osf);
		newname[MAXFNAME-1] = '\0';
		if(rename(fn_osf, newname) != 0) {
			LogError(errno, RS_RET_IO_ERROR, "could not rename existing operatingStateFile "
				"'%s' to '%s' - ignored, but will probably be overwritten now",
				fn_osf, newname);
		} else {
			LogMsg(errno, RS_RET_OK, LOG_INFO, "existing state file '%s' renamed "
				"to '%s' - you may want to review it", fn_osf, newname);
		}
	}
	return;
}

void
osf_open(void)
{
	assert(fd_osf == -1);
	const char *fn_osf = (const char*) glblGetOperatingStateFile(loadConf);
	assert(fn_osf != NULL);

	osf_checkOnStartup();

	fd_osf = open(fn_osf, O_WRONLY|O_CREAT|O_APPEND|O_LARGEFILE|O_CLOEXEC,
		S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
	if(fd_osf == -1) {
		LogError(errno, RS_RET_ERR, "error opening operatingStateFile '%s' for write - "
			"ignoring it", fn_osf);
		goto done;
	}
	assert(fd_osf != -1);

	osf_write(OSF_TAG_STATE, STATE_INITIALIZING " " VERSION);
done:
	return;
}


void ATTR_NONNULL()
osf_write(const char *const tag, const char *const line)
{
	char buf[1024]; /* intentionally small */
	time_t tt;
	ssize_t wr;
	size_t len;
	struct tm tm;

	DBGPRINTF("osf: %s %s: ", tag, line); /* ensure everything is inside the debug log */

	if(fd_osf == -1)
		return;

	time(&tt);
	localtime_r(&tt, &tm);
	len = snprintf(buf, sizeof(buf)-1, "%d%2.2d%2.2d-%2.2d%2.2d%2.2d: %-5.5s %s\n",
		tm.tm_year+1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,
		tag, line);
	if(len > sizeof(buf)-1) {
		len = sizeof(buf)-1; /* overflow, truncate */
	}
	wr = write(fd_osf, buf, len);
	// TODO: handle EINTR
	if(wr != (ssize_t) len) {
		LogError(errno, RS_RET_IO_ERROR, "error writing operating state file - line lost");
	}
}


void
osf_close(void)
{
	if(fd_osf == -1)
		return;
	osf_write(OSF_TAG_STATE, STATE_CLEAN_CLOSE);
	close(fd_osf);
}