// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2021 Weidmüller Interface GmbH & Co. KG
 * Roland Gaudig <roland.gaudig@weidmueller.com>
 *
 * Copyright 1999 Dave Cinege
 * Portions copyright (C) 1990-1996 Free Software Foundation, Inc.
 *
 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
 */
/*
 * This file provides a shell printf like format string expansion as required
 * for the setexpr <name> fmt <format> <value> command.
 * This source file was mostly taken from the BusyBox project (www.busybox.net)
 * In contrast to the original sources the output is not written to stdout
 * anymore but into a char array, which can be used as input for the env_set()
 * function.
 */
/* Usage: printf format [argument...]
 *
 * A front end to the printf function that lets it be used from the shell.
 *
 * Backslash escapes:
 *
 * \" = double quote
 * \\ = backslash
 * \a = alert (bell)
 * \b = backspace
 * \c = produce no further output
 * \f = form feed
 * \n = new line
 * \r = carriage return
 * \t = horizontal tab
 * \v = vertical tab
 * \0ooo = octal number (ooo is 0 to 3 digits)
 * \xhhh = hexadecimal number (hhh is 1 to 3 digits)
 *
 * Additional directive:
 *
 * %b = print an argument string, interpreting backslash escapes
 *
 * The 'format' argument is re-used as many times as necessary
 * to convert all of the given arguments.
 *
 * David MacKenzie <djm@gnu.ai.mit.edu>
 */
/* 19990508 Busy Boxed! Dave Cinege */

//config:config PRINTF
//config:	bool "printf (3.8 kb)"
//config:	default y
//config:	help
//config:	printf is used to format and print specified strings.
//config:	It's similar to 'echo' except it has more options.

//applet:IF_PRINTF(APPLET_NOFORK(printf, printf, BB_DIR_USR_BIN, BB_SUID_DROP, printf))

//kbuild:lib-$(CONFIG_PRINTF) += printf.o
//kbuild:lib-$(CONFIG_ASH_PRINTF)  += printf.o
//kbuild:lib-$(CONFIG_HUSH_PRINTF) += printf.o

//usage:#define printf_trivial_usage
//usage:       "FORMAT [ARG]..."
//usage:#define printf_full_usage "\n\n"
//usage:       "Format and print ARG(s) according to FORMAT (a-la C printf)"
//usage:
//usage:#define printf_example_usage
//usage:       "$ printf \"Val=%d\\n\" 5\n"
//usage:       "Val=5\n"

/* A note on bad input: neither bash 3.2 nor coreutils 6.10 stop on it.
 * They report it:
 *  bash: printf: XXX: invalid number
 *  printf: XXX: expected a numeric value
 *  bash: printf: 123XXX: invalid number
 *  printf: 123XXX: value not completely converted
 * but then they use 0 (or partially converted numeric prefix) as a value
 * and continue. They exit with 1 in this case.
 * Both accept insane field width/precision (e.g. %9999999999.9999999999d).
 * Both print error message and assume 0 if %*.*f width/precision is "bad"
 *  (but negative numbers are not "bad").
 * Both accept negative numbers for %u specifier.
 *
 * We try to be compatible.
 */

#include <common.h>
#include <ctype.h>
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

#define WANT_HEX_ESCAPES 0
#define PRINT_CONVERSION_ERROR 1
#define PRINT_TRUNCATED_ERROR 2
#define PRINT_SIZE_ERROR 4

struct print_inf {
	char *str;
	size_t size;
	size_t offset;
	unsigned int error;
};

typedef void (*converter)(const char *arg, void *result);

/**
 * printf_str() - print formatted into char array with length checks
 *
 * This function povides a printf like function for printing into a char array
 * with checking the boundaries.
 * Unlike snprintf, all checks are performed inside this function and status
 * reports are stored inside the print_inf struct. That way, this function can
 * be used almost as drop-in replacement without needing much code changes.
 * Unlike snprintf errors are not reported by return value, but inside the
 * error member of struct print_inf. The output stored inside the struct
 * print_inf str member shall only be used when the error member is 0.
 *
 * @inf: Info structure for print operation
 * @char: format string with optional arguments
 */
static void printf_str(struct print_inf *inf, char *format, ...)
{
	va_list args;
	int i;

	if (!inf)
		return;

	/* Do not write anything if previous error is pending */
	if (inf->error)
		return;

	/* Check if end of receiving buffer is already reached */
	if (inf->offset >= inf->size) {
		inf->error |= PRINT_SIZE_ERROR;
		return;
	}

	size_t remaining = inf->size - inf->offset;

	va_start(args, format);
	i = vsnprintf(inf->str + inf->offset, remaining, format, args);
	va_end(args);

	if (i >= remaining)
		inf->error |= PRINT_TRUNCATED_ERROR;
	else if (i < 0)
		inf->error |= PRINT_CONVERSION_ERROR;
	else
		inf->offset += i;
}

/**
 * putchar_str() - Print single character into char array with length checks
 *
 * This function provices a putchar like function, which stores the output
 * into a char array with checking boundaries.
 *
 * @inf: Info structure for print operation
 * @char: Single character to be printed
 */
static void putchar_str(struct print_inf *inf, char c)
{
	printf_str(inf, "%c", c);
}

static char process_escape_sequence(const char **ptr)
{
	const char *q;
	unsigned int num_digits;
	unsigned int n;
	unsigned int base;

	num_digits = 0;
	n = 0;
	base = 8;
	q = *ptr;

	if (WANT_HEX_ESCAPES && *q == 'x') {
		++q;
		base = 16;
		++num_digits;
	}

	/* bash requires leading 0 in octal escapes:
	 * \02 works, \2 does not (prints \ and 2).
	 * We treat \2 as a valid octal escape sequence.
	 */
	do {
		unsigned int r;
		unsigned int d = (unsigned char)(*q) - '0';
#if WANT_HEX_ESCAPES
		if (d >= 10) {
			d = (unsigned char)tolower(*q) - 'a';
			//d += 10;
			/* The above would map 'A'-'F' and 'a'-'f' to 10-15,
			 * however, some chars like '@' would map to 9 < base.
			 * Do not allow that, map invalid chars to N > base:
			 */
			if ((int)d >= 0)
				d += 10;
		}
#endif
		if (d >= base) {
			if (WANT_HEX_ESCAPES && base == 16) {
				--num_digits;
				if (num_digits == 0) {
					/* \x<bad_char>: return '\',
					 * leave ptr pointing to x
					 */
					return '\\';
				}
			}
			break;
		}

		r = n * base + d;
		if (r > 255)
			break;

		n = r;
		++q;
	} while (++num_digits < 3);

	if (num_digits == 0) {
		/* Not octal or hex escape sequence.
		 * Is it one-letter one?
		 */
		/* bash builtin "echo -e '\ec'" interprets \e as ESC,
		 * but coreutils "/bin/echo -e '\ec'" does not.
		 * Manpages tend to support coreutils way.
		 * Update: coreutils added support for \e on 28 Oct 2009.
		 */
		static const char charmap[] = {
			'a',  'b', 'e', 'f',  'n',  'r',  't',  'v',  '\\', '\0',
			'\a', '\b', 27, '\f', '\n', '\r', '\t', '\v', '\\', '\\',
		};

		const char *p = charmap;

		do {
			if (*p == *q) {
				q++;
				break;
			}
		} while (*++p != '\0');
		/* p points to found escape char or NUL,
		 * advance it and find what it translates to.
		 * Note that \NUL and unrecognized sequence \z return '\'
		 * and leave ptr pointing to NUL or z.
		 */
		n = p[sizeof(charmap) / 2];
	}

	*ptr = q;

	return (char)n;
}

static char *skip_whitespace(const char *s)
{
	/* In POSIX/C locale (the only locale we care about: do we REALLY want
	 * to allow Unicode whitespace in, say, .conf files? nuts!)
	 * isspace is only these chars: "\t\n\v\f\r" and space.
	 * "\t\n\v\f\r" happen to have ASCII codes 9,10,11,12,13.
	 * Use that.
	 */
	while (*s == ' ' || (unsigned char)(*s - 9) <= (13 - 9))
		s++;

	return (char *)s;
}

/* Like strcpy but can copy overlapping strings. */
static void overlapping_strcpy(char *dst, const char *src)
{
	/* Cheap optimization for dst == src case -
	 * better to have it here than in many callers.
	 */
	if (dst != src) {
		while ((*dst = *src) != '\0') {
			dst++;
			src++;
		}
	}
}

static int multiconvert(const char *arg, void *result, converter convert)
{
	if (*arg == '"' || *arg == '\'')
		sprintf((char *)arg + strlen(arg), "%u", (unsigned char)arg[1]);
	//errno = 0;
	convert(arg, result);
	/* Unlike their Posix counterparts, simple_strtoll and
	 * simple_strtoull do not set errno
	 *
	 * if (errno) {
	 *	printf("error invalid number '%s'", arg);
	 *	return 1;
	 * }
	 */
	return 0;
}

static void conv_strtoull(const char *arg, void *result)
{
	/* both coreutils 6.10 and bash 3.2:
	 * $ printf '%x\n' -2
	 * fffffffffffffffe
	 * Mimic that:
	 */
	if (arg[0] == '-') {
		*(unsigned long long *)result = simple_strtoll(arg, NULL, 16);
		return;
	}
	/* Allow leading '+' - simple_strtoull() by itself does not allow it,
	 * and probably shouldn't (other callers might require purely numeric
	 * inputs to be allowed.
	 */
	if (arg[0] == '+')
		arg++;
	*(unsigned long long *)result = simple_strtoull(arg, NULL, 16);
}

static void conv_strtoll(const char *arg, void *result)
{
	if (arg[0] == '+')
		arg++;
	*(long long *)result = simple_strtoll(arg, NULL, 16);
}

/* Callers should check errno to detect errors */
static unsigned long long my_xstrtoull(const char *arg)
{
	unsigned long long result;

	if (multiconvert(arg, &result, conv_strtoull))
		result = 0;
	return result;
}

static long long my_xstrtoll(const char *arg)
{
	long long result;

	if (multiconvert(arg, &result, conv_strtoll))
		result = 0;
	return result;
}

/* Handles %b; return 1 if output is to be short-circuited by \c */
static int print_esc_string(struct print_inf *inf, const char *str)
{
	char c;

	while ((c = *str) != '\0') {
		str++;
		if (c == '\\') {
			/* %b also accepts 4-digit octals of the form \0### */
			if (*str == '0') {
				if ((unsigned char)(str[1] - '0') < 8) {
					/* 2nd char is 0..7: skip leading '0' */
					str++;
				}
			} else if (*str == 'c') {
				return 1;
			}
			{
				/* optimization: don't force arg to be on-stack,
				 * use another variable for that.
				 */
				const char *z = str;

				c = process_escape_sequence(&z);
				str = z;
			}
		}
		putchar_str(inf, c);
	}

	return 0;
}

static void print_direc(struct print_inf *inf, char *format, unsigned int fmt_length,
			int field_width, int precision,
			const char *argument)
{
	long long llv;
	char saved;
	char *have_prec, *have_width;

	saved = format[fmt_length];
	format[fmt_length] = '\0';

	have_prec = strstr(format, ".*");
	have_width = strchr(format, '*');
	if (have_width - 1 == have_prec)
		have_width = NULL;

	/* multiconvert sets errno = 0, but %s needs it cleared */
	errno = 0;

	switch (format[fmt_length - 1]) {
	case 'c':
		printf_str(inf, format, *argument);
		break;
	case 'd':
	case 'i':
		llv = my_xstrtoll(skip_whitespace(argument));
 print_long:
		if (!have_width) {
			if (!have_prec)
				printf_str(inf, format, llv);
			else
				printf_str(inf, format, precision, llv);
		} else {
			if (!have_prec)
				printf_str(inf, format, field_width, llv);
			else
				printf_str(inf, format, field_width, precision, llv);
		}
		break;
	case 'o':
	case 'u':
	case 'x':
	case 'X':
		llv = my_xstrtoull(skip_whitespace(argument));
		/* cheat: unsigned long and long have same width, so... */
		goto print_long;
	case 's':
		/* Are char* and long long the same? */
		if (sizeof(argument) == sizeof(llv)) {
			llv = (long long)(ptrdiff_t)argument;
			goto print_long;
		} else {
			/* Hope compiler will optimize it out by moving call
			 * instruction after the ifs...
			 */
			if (!have_width) {
				if (!have_prec)
					printf_str(inf, format, argument,
						   /*unused:*/ argument, argument);
				else
					printf_str(inf, format, precision,
						   argument, /*unused:*/ argument);
			} else {
				if (!have_prec)
					printf_str(inf, format, field_width,
						   argument, /*unused:*/ argument);
				else
					printf_str(inf, format, field_width,
						   precision, argument);
			}
			break;
		}
		break;
	} /* switch */

	format[fmt_length] = saved;
}

/* Handle params for "%*.*f". Negative numbers are ok (compat). */
static int get_width_prec(const char *str)
{
	long v = simple_strtol(str, NULL, 10);

	/* Unlike its Posix counterpart, simple_strtol does not set errno
	 *
	 * if (errno) {
	 *	printf("error invalid number '%s'", str);
	 *	v = 0;
	 * }
	 */
	return (int)v;
}

/* Print the text in FORMAT, using ARGV for arguments to any '%' directives.
 * Return advanced ARGV.
 */
static char **print_formatted(struct print_inf *inf, char *f, char **argv, int *conv_err)
{
	char *direc_start;          /* Start of % directive.  */
	unsigned int direc_length;  /* Length of % directive.  */
	int field_width;            /* Arg to first '*' */
	int precision;              /* Arg to second '*' */
	char **saved_argv = argv;

	for (; *f; ++f) {
		switch (*f) {
		case '%':
			direc_start = f++;
			direc_length = 1;
			field_width = 0;
			precision = 0;
			if (*f == '%') {
				putchar_str(inf, '%');
				break;
			}
			if (*f == 'b') {
				if (*argv) {
					if (print_esc_string(inf, *argv))
						return saved_argv; /* causes main() to exit */
					++argv;
				}
				break;
			}
			if (*f && strchr("-+ #", *f)) {
				++f;
				++direc_length;
			}
			if (*f == '*') {
				++f;
				++direc_length;
				if (*argv)
					field_width = get_width_prec(*argv++);
			} else {
				while (isdigit(*f)) {
					++f;
					++direc_length;
				}
			}
			if (*f == '.') {
				++f;
				++direc_length;
				if (*f == '*') {
					++f;
					++direc_length;
					if (*argv)
						precision = get_width_prec(*argv++);
				} else {
					while (isdigit(*f)) {
						++f;
						++direc_length;
					}
				}
			}

			/* Remove "lLhz" size modifiers, repeatedly.
			 * bash does not like "%lld", but coreutils
			 * happily takes even "%Llllhhzhhzd"!
			 * We are permissive like coreutils
			 */
			while ((*f | 0x20) == 'l' || *f == 'h' || *f == 'z')
				overlapping_strcpy(f, f + 1);
			/* Add "ll" if integer modifier, then print */
			{
				static const char format_chars[] = "diouxXcs";
				char *p = strchr(format_chars, *f);
				/* needed - try "printf %" without it */
				if (!p || *f == '\0') {
					printf("`%s': invalid format\n", direc_start);
					/* causes main() to exit with error */
					return saved_argv - 1;
				}
				++direc_length;
				if (p - format_chars <= 5) {
					/* it is one of "diouxX" */
					p = malloc(direc_length + 3);
					if (!p) {
						/* exit with error */
						return saved_argv - 1;
					}
					memcpy(p, direc_start, direc_length);
					p[direc_length + 1] = p[direc_length - 1];
					p[direc_length - 1] = 'l';
					p[direc_length] = 'l';
					//bb_error_msg("<%s>", p);
					direc_length += 2;
					direc_start = p;
				} else {
					p = NULL;
				}
				if (*argv) {
					print_direc(inf, direc_start, direc_length,
						    field_width, precision, *argv++);
				} else {
					print_direc(inf, direc_start, direc_length,
						    field_width, precision, "");
				}
				*conv_err |= errno;
				free(p);
			}
			break;
		case '\\':
			if (*++f == 'c')
				return saved_argv; /* causes main() to exit */
			putchar_str(inf, process_escape_sequence((const char **)&f));
			f--;
			break;
		default:
			putchar_str(inf, *f);
		}
	}

	return argv;
}

/**
 * printf_setexpr() - Implements the setexpr <name> fmt <format> command
 *
 * This function implements the format string evaluation for the
 * setexpr <name> fmt <format> <value> command.
 *
 * @str: Output string of the evaluated expression
 * @size: Length of @str buffer
 * @argc: Number of arguments
 * @argv: Argument list
 * @return: 0 if OK, 1 on error
 */
int printf_setexpr(char *str, size_t size, int argc, char *const *argv)
{
	int conv_err;
	char *format;
	char **argv2;
	struct print_inf inf = {
		.str = str,
		.size = size,
		.offset = 0,
		.error = 0,
	};

	if (!str || !size)
		return 1;

	inf.str[0] = '\0';

	format = argv[0];
	argv2 = (char **)argv + 1;

	conv_err = 0;
	argv = argv2;
	/* In case any print_str call raises an error inf.error will be
	 * set after print_formatted returns.
	 */
	argv2 = print_formatted(&inf, format, (char **)argv, &conv_err);

	/* coreutils compat (bash doesn't do this):
	 *if (*argv)
	 *	fprintf(stderr, "excess args ignored");
	 */

	return (argv2 < argv) || /* if true, print_formatted errored out */
		conv_err || /* print_formatted saw invalid number */
		inf.error;  /* print_str reported error */
}