#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include "portability.h"

/*
 * vasprintf() and asprintf() for platforms with a C99-compliant
 * snprintf() - so that, if you format into a 1-byte buffer, it
 * will return how many characters it would have produced had
 * it been given an infinite-sized buffer.
 */
int
pcap_vasprintf(char **strp, const char *format, va_list args)
{
	char buf;
	int len;
	size_t str_size;
	char *str;
	int ret;

	/*
	 * XXX - the C99 standard says, in section 7.19.6.5 "Thes
	 * nprintf function":
	 *
	 *    The snprintf function is equivalent to fprintf, except that
	 *    the output is written into an array (specified by argument s)
	 *    rather than to a stream.  If n is zero, nothing is written,
	 *    and s may be a null pointer.  Otherwise, output characters
	 *    beyond the n-1st are discarded rather than being written
	 *    to the array, and a null character is written at the end
	 *    of the characters actually written into the array.
	 *
	 *        ...
	 *
	 *    The snprintf function returns the number of characters that
	 *    would have been written had n been sufficiently large, not
	 *    counting the terminating null character, or a negative value
	 *    if an encoding error occurred. Thus, the null-terminated
	 *    output has been completely written if and only if the returned
	 *    value is nonnegative and less than n.
	 *
	 * That doesn't make it entirely clear whether, if a null buffer
	 * pointer and a zero count are passed, it will return the number
	 * of characters that would have been written had a buffer been
	 * passed.
	 *
	 * And, even if C99 *does*, in fact, say it has to work, it
	 * doesn't work in Solaris 8, for example - it returns -1 for
	 * NULL/0, but returns the correct character count for a 1-byte
	 * buffer.
	 *
	 * So we pass a one-character pointer in order to find out how
	 * many characters this format and those arguments will need
	 * without actually generating any more of those characters
	 * than we need.
	 *
	 * (The fact that it might happen to work with GNU libc or with
	 * various BSD libcs is completely uninteresting, as those tend
	 * to have asprintf() already and thus don't even *need* this
	 * code; this is for use in those UN*Xes that *don't* have
	 * asprintf().)
	 */
	len = vsnprintf(&buf, sizeof buf, format, args);
	if (len == -1) {
		*strp = NULL;
		return (-1);
	}
	str_size = len + 1;
	str = malloc(str_size);
	if (str == NULL) {
		*strp = NULL;
		return (-1);
	}
	ret = vsnprintf(str, str_size, format, args);
	if (ret == -1) {
		free(str);
		*strp = NULL;
		return (-1);
	}
	*strp = str;
	/*
	 * vsnprintf() shouldn't truncate the string, as we have
	 * allocated a buffer large enough to hold the string, so its
	 * return value should be the number of characters written.
	 */
	return (ret);
}

int
pcap_asprintf(char **strp, const char *format, ...)
{
	va_list args;
	int ret;

	va_start(args, format);
	ret = pcap_vasprintf(strp, format, args);
	va_end(args);
	return (ret);
}