simplefiles

html.c (5924B)

---

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "html.h"
 
 static const char *
 find_variable(const char *,
     const struct html_var *, size_t,
     const struct html_var *, size_t);
 
 static int
 render_text(FILE *,
     const char *,
     size_t,
     const struct html_var *,
     size_t,
     const struct html_var *,
     size_t);
 
 static const struct html_block *
 find_block(const char *, const struct html_block *, size_t);
 static const char *
 find_marker(const char *, size_t, const char[2]);
 
 void
 html_escape(FILE * fp, const char *s)
 {
 	unsigned char c;
 
 	while ((c = (unsigned char) *s++) != '\0') {
 		switch (c) {
 		case '&':
 			fputs("&amp;", fp);
 			break;
 
 		case '<':
 			fputs("&lt;", fp);
 			break;
 
 		case '>':
 			fputs("&gt;", fp);
 			break;
 
 		case '"':
 			fputs("&quot;", fp);
 			break;
 
 		case '\'':
 			fputs("&#39;", fp);
 			break;
 
 		default:
 			fputc(c, fp);
 			break;
 		}
 	}
 }
 
 /*
  * NOTE: Templates may contain at most one block.
  */
 int
 render_template(FILE *fp, const char *filename,
     const struct html_var *vars, size_t nvars,
     const struct html_block *blocks, size_t nblocks)
 {
 	FILE *template;
 	char *text;
 	long size;
 	size_t len;
 	const char *block_start;
 	const char *block_end;
 	const char *p;
 	char block_name[128];
 	size_t block_name_len;
 	const struct html_block *block;
 	size_t i;
 
 	template = fopen(filename, "r");
 	if (template == NULL)
 		return -1;
 
 	if (fseek(template, 0, SEEK_END) == -1) {
 		fclose(template);
 		return -1;
 	}
 
 	size = ftell(template);
 	if (size < 0) {
 		fclose(template);
 		return -1;
 	}
 
 	if (fseek(template, 0, SEEK_SET) == -1) {
 		fclose(template);
 		return -1;
 	}
 
 	len = (size_t)size;
 
 	text = malloc(len + 1);
 	if (text == NULL) {
 		fclose(template);
 		return -1;
 	}
 
 	if (fread(text, 1, len, template) != len) {
 		free(text);
 		fclose(template);
 		return -1;
 	}
 
 	text[len] = '\0';
 
 	fclose(template);
 
 	/*
 	 * Find the first block.
 	 */
 	block_start = strstr(text, "{{#");
 
 	if (block_start == NULL) {
 		/*
 		 * No blocks: render the whole template normally.
 		 */
 		if (render_text(fp, text, len,
 		    vars, nvars,
 		    NULL, 0) == -1) {
 			free(text);
 			return -1;
 		}
 
 		free(text);
 		return 0;
 	}
 
 	/*
 	 * Render text before the block.
 	 */
 	if (render_text(fp,
 	    text,
 	    (size_t)(block_start - text),
 	    vars, nvars,
 	    NULL, 0) == -1) {
 		free(text);
 		return -1;
 	}
 
 	/*
 	 * Find the end of the block name.
 	 */
 	block_end = strstr(block_start + 3, "}}");
 	if (block_end == NULL) {
 		free(text);
 		return -1;
 	}
 
 	block_name_len =
 	    (size_t)(block_end - (block_start + 3));
 
 	if (block_name_len == 0 ||
 	    block_name_len >= sizeof(block_name)) {
 		free(text);
 		return -1;
 	}
 
 	memcpy(block_name,
 	    block_start + 3,
 	    block_name_len);
 	block_name[block_name_len] = '\0';
 
 	block = find_block(block_name, blocks, nblocks);
 	if (block == NULL) {
 		free(text);
 		return -1;
 	}
 
 	/*
 	 * Find the closing block marker.
 	 */
 	p = block_end + 2;
 
 	{
 		char closing[128];
 
 		if (snprintf(closing, sizeof(closing),
 		    "{{/%s}}", block_name) >=
 		    (int)sizeof(closing)) {
 			free(text);
 			return -1;
 		}
 
 		block_start = strstr(p, closing);
 		if (block_start == NULL) {
 			free(text);
 			return -1;
 		}
 
 		block_end = block_start;
 	}
 
 	/*
 	 * Render the block once for every row.
 	 */
 	for (i = 0; i < block->nrows; i++) {
 		const char *row_start = p;
 		size_t row_len =
 		    (size_t)(block_end - row_start);
 
 		if (render_text(fp,
 		    row_start,
 		    row_len,
 		    vars, nvars,
 		    block->rows[i].vars,
 		    block->rows[i].nvars) == -1) {
 			free(text);
 			return -1;
 		}
 	}
 
 	/*
 	 * Render anything after the block.
 	 */
 	p = block_end + strlen(
 	    "{{/");
 
 	p = strstr(p, "}}");
 	if (p == NULL) {
 		free(text);
 		return -1;
 	}
 
 	p += 2;
 
 	if (render_text(fp,
 	    p,
 	    strlen(p),
 	    vars, nvars,
 	    NULL, 0) == -1) {
 		free(text);
 		return -1;
 	}
 
 	free(text);
 	return 0;
 }
 
 static const char *
 find_variable(const char *name,
     const struct html_var * vars, size_t nvars,
     const struct html_var * row_vars, size_t nrowvars)
 {
 	size_t i;
 
 	for (i = 0; i < nrowvars; i++) {
 		if (strcmp(name, row_vars[i].name) == 0)
 			return row_vars[i].value;
 	}
 
 	for (i = 0; i < nvars; i++) {
 		if (strcmp(name, vars[i].name) == 0)
 			return vars[i].value;
 	}
 
 	return NULL;
 }
 
 static int
 render_text(FILE * fp,
     const char *text,
     size_t len,
     const struct html_var * vars,
     size_t nvars,
     const struct html_var * row_vars,
     size_t nrowvars)
 {
 	const char *p;
 	const char *end;
 
 	p = text;
 	end = text + len;
 
 	while (p < end) {
 		const char *start;
 		const char *close;
 		char name[128];
 		size_t namelen;
 		const char *value;
 
 		start = find_marker(p, (size_t)(end - p), "{{");
 
 		if (start == NULL) {
 			if (fwrite(p, 1, (size_t) (end - p), fp) !=
 			    (size_t) (end - p))
 				return -1;
 			break;
 		}
 		if (fwrite(p, 1, (size_t) (start - p), fp) !=
 		    (size_t) (start - p))
 			return -1;
 
 		close = find_marker(start + 2, (size_t)(end - (start + 2)), "}}");
 
 		if (close == NULL)
 			return -1;
 
 		namelen = (size_t) (close - (start + 2));
 
 		if (namelen == 0 || namelen >= sizeof(name))
 			return -1;
 
 		memcpy(name, start + 2, namelen);
 		name[namelen] = '\0';
 
 		value = find_variable(name,
 		    vars, nvars,
 		    row_vars, nrowvars);
 
 		if (value == NULL)
 			return -1;
 
 		html_escape(fp, value);
 
 		p = close + 2;
 	}
 
 	return 0;
 }
 
 static const struct html_block *
 find_block(const char *name,
     const struct html_block *blocks, size_t nblocks)
 {
 	size_t i;
 
 	for (i = 0; i < nblocks; i++) {
 		if (strcmp(name, blocks[i].name) == 0)
 			return &blocks[i];
 	}
 
 	return NULL;
 }
 
 static const char *
 find_marker(const char *text, size_t len, const char marker[2])
 {
 	size_t i;
 
 	if (len < 2)
 		return NULL;
 
 	for (i = 0; i + 1 < len; i++) {
 		if (text[i] == marker[0] &&
 		    text[i + 1] == marker[1])
 			return text + i;
 	}
 
 	return NULL;
 }