snprintf.c

/*
 * Copyright (c) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
 *	The President and Fellows of Harvard College.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of the University 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 UNIVERSITY 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 UNIVERSITY 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.
 */

/*
 * This file is shared between libc and the kernel, so don't put anything
 * in here that won't work in both contexts.
 */

#ifdef _KERNEL
#include <types.h>
#include <lib.h>

#else
#include <stdio.h>

#endif /* _KERNEL */

#include <stdarg.h>

/*
 * Standard C string/IO function: printf into a character buffer.
 */


/*
 * Context structure for snprintf: buffer to print into, maximum 
 * length, and index of the next character to write.
 *
 * Note that while the length argument to snprintf includes space for
 * a null terminator, SNP.buflen does not. This is to make something
 * vaguely reasonable happen if a length of 0 is passed to snprintf.
 */

typedef struct {
	char *buf;
	size_t buflen;
	size_t bufpos;
} SNP;

/*
 * Send function for snprintf. This is the function handed to the
 * printf guts. It gets called with mydata pointing to the context,
 * and some string data of length LEN in DATA. DATA is not necessarily
 * null-terminated.
 */

static
void
__snprintf_send(void *mydata, const char *data, size_t len)
{
	SNP *snp = mydata;
	unsigned i;

	/* For each character we're sent... */
	for (i=0; i<len; i++) {

		/* If we aren't past the length, */
		if (snp->bufpos < snp->buflen) {

			/* store the character */
			snp->buf[snp->bufpos] = data[i];

			/* and increment the position. */
			snp->bufpos++;
		}
	}
}

/*
 * The va_list version of snprintf.
 */
int
vsnprintf(char *buf, size_t len, const char *fmt, va_list ap)
{
	int chars;
	SNP snp;

	/*
	 * Fill in the context structure.
	 * We set snp.buflen to the number of characters that can be
	 * written (excluding the null terminator) so as not to have
	 * to special-case the possibility that we got passed a length
	 * of zero elsewhere.
	 */
	snp.buf = buf;
	if (len==0) {
		snp.buflen = 0;
	}
	else {
		snp.buflen = len-1;
	}
	snp.bufpos = 0;

	/* Call __vprintf to do the actual work. */
	chars = __vprintf(__snprintf_send, &snp, fmt, ap);

	/*
	 * Add a null terminator. If the length *we were passed* is greater
	 * than zero, we reserved a space in the buffer for the terminator,
	 * so this won't overflow. If the length we were passed is zero,
	 * nothing will have been or should be written anyway, and buf
	 * might even be NULL. (C99 explicitly endorses this possibility.)
	 */
	if (len > 0) {
		buf[snp.bufpos] = 0;
	}

	/*
	 * Return the number of characters __vprintf processed.
	 * According to C99, snprintf should return this number, not
	 * the number of characters actually stored, and should not
	 * return -1 on overflow but only on other errors. (All none
	 * of them since we don't do multibyte characters...)
	 */
	return chars;
}

/*
 * snprintf - hand off to vsnprintf.
 */
int
snprintf(char *buf, size_t len, const char *fmt, ...)
{
	int chars;
	va_list ap;
	va_start(ap, fmt);
	chars = vsnprintf(buf, len, fmt, ap);
	va_end(ap);
	return chars;
}