-/* $Id: roff.c,v 1.96 2010/07/27 13:16:00 kristaps Exp $ */
+/* $Id: roff.c,v 1.105 2010/12/01 16:54:25 kristaps Exp $ */
/*
* Copyright (c) 2010 Kristaps Dzonsons <kristaps@bsd.lv>
* Copyright (c) 2010 Ingo Schwarze <schwarze@openbsd.org>
#endif
enum rofft {
+ ROFF_ad,
ROFF_am,
ROFF_ami,
ROFF_am1,
ROFF_de1,
ROFF_ds,
ROFF_el,
+ ROFF_hy,
ROFF_ie,
ROFF_if,
ROFF_ig,
+ ROFF_ne,
+ ROFF_nh,
+ ROFF_nr,
ROFF_rm,
+ ROFF_so,
ROFF_tr,
ROFF_cblock,
- ROFF_ccond,
- ROFF_nr,
+ ROFF_ccond, /* FIXME: remove this. */
ROFF_MAX
};
static void roff_freestr(struct roff *);
static const char *roff_getstrn(const struct roff *,
const char *, size_t);
-static enum rofferr roff_line(ROFF_ARGS);
+static enum rofferr roff_line_ignore(ROFF_ARGS);
+static enum rofferr roff_line_error(ROFF_ARGS);
static enum rofferr roff_nr(ROFF_ARGS);
static int roff_res(struct roff *,
char **, size_t *, int);
static void roff_setstr(struct roff *,
const char *, const char *);
+static enum rofferr roff_so(ROFF_ARGS);
+static char *roff_strdup(const char *);
/* See roff_hash_find() */
static struct roffmac *hash[HASHWIDTH];
static struct roffmac roffs[ROFF_MAX] = {
+ { "ad", roff_line_ignore, NULL, NULL, 0, NULL },
{ "am", roff_block, roff_block_text, roff_block_sub, 0, NULL },
{ "ami", roff_block, roff_block_text, roff_block_sub, 0, NULL },
{ "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
{ "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
{ "ds", roff_ds, NULL, NULL, 0, NULL },
{ "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
+ { "hy", roff_line_ignore, NULL, NULL, 0, NULL },
{ "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
{ "if", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
{ "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL },
- { "rm", roff_line, NULL, NULL, 0, NULL },
- { "tr", roff_line, NULL, NULL, 0, NULL },
+ { "ne", roff_line_ignore, NULL, NULL, 0, NULL },
+ { "nh", roff_line_ignore, NULL, NULL, 0, NULL },
+ { "nr", roff_nr, NULL, NULL, 0, NULL },
+ { "rm", roff_line_error, NULL, NULL, 0, NULL },
+ { "so", roff_so, NULL, NULL, 0, NULL },
+ { "tr", roff_line_ignore, NULL, NULL, 0, NULL },
{ ".", roff_cblock, NULL, NULL, 0, NULL },
{ "\\}", roff_ccond, NULL, NULL, 0, NULL },
- { "nr", roff_nr, NULL, NULL, 0, NULL },
};
static void roff_free1(struct roff *);
static enum rofft roff_hash_find(const char *);
static void roff_hash_init(void);
static void roffnode_cleanscope(struct roff *);
-static int roffnode_push(struct roff *,
+static void roffnode_push(struct roff *,
enum rofft, int, int);
static void roffnode_pop(struct roff *);
static enum rofft roff_parse(const char *, int *);
if (r->rstackpos > -1)
r->rstackpos--;
+ ROFF_DEBUG("roff: popping scope\n");
r->last = r->last->parent;
if (p->end)
free(p->end);
* Push a roff node onto the instruction stack. This must later be
* removed with roffnode_pop().
*/
-static int
+static void
roffnode_push(struct roff *r, enum rofft tok, int line, int col)
{
struct roffnode *p;
- if (NULL == (p = calloc(1, sizeof(struct roffnode)))) {
- (*r->msg)(MANDOCERR_MEM, r->data, line, col, NULL);
- return(0);
- }
-
+ p = mandoc_calloc(1, sizeof(struct roffnode));
p->tok = tok;
p->parent = r->last;
p->line = line;
p->rule = p->parent ? p->parent->rule : ROFFRULE_DENY;
r->last = p;
- return(1);
}
struct roff *
-roff_alloc(struct regset *regs, const mandocmsg msg, void *data)
+roff_alloc(struct regset *regs, void *data, const mandocmsg msg)
{
struct roff *r;
- if (NULL == (r = calloc(1, sizeof(struct roff)))) {
- (*msg)(MANDOCERR_MEM, data, 0, 0, NULL);
- return(0);
- }
-
+ r = mandoc_calloc(1, sizeof(struct roff));
r->regs = regs;
r->msg = msg;
r->data = data;
if (r->last) {
t = r->last->tok;
assert(roffs[t].sub);
- ROFF_DEBUG("roff: intercept scoped context: %s\n",
- roffs[t].name);
+ ROFF_DEBUG("roff: intercept scoped context: %s, [%s]\n",
+ roffs[t].name, &(*bufp)[pos]);
return((*roffs[t].sub)
(r, t, bufp, szp,
ln, pos, pos, offs));
pos++;
}
- if ( ! roffnode_push(r, tok, ln, ppos))
- return(ROFF_ERR);
+ roffnode_push(r, tok, ln, ppos);
if ('\0' == (*bufp)[pos])
return(ROFF_IGN);
if (1 == sz && '.' == (*bufp)[sv])
return(ROFF_IGN);
- r->last->end = malloc(sz + 1);
-
- if (NULL == r->last->end) {
- (*r->msg)(MANDOCERR_MEM, r->data, ln, pos, NULL);
- return(ROFF_ERR);
- }
+ r->last->end = mandoc_malloc(sz + 1);
memcpy(r->last->end, *bufp + sv, sz);
r->last->end[(int)sz] = '\0';
{
enum rofft t;
enum roffrule rr;
- struct roffnode *l;
ppos = pos;
rr = r->last->rule;
* continue.
*/
- l = r->last;
roffnode_cleanscope(r);
- if (l != r->last)
- return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
-
- if (ROFF_MAX == (t = roff_parse(*bufp, &pos)))
+ if (ROFF_MAX == (t = roff_parse(*bufp, &pos))) {
+ if ('\\' == (*bufp)[pos] && '}' == (*bufp)[pos + 1])
+ return(roff_ccond
+ (r, ROFF_ccond, bufp, szp,
+ ln, pos, pos + 2, offs));
return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
+ }
/*
* A denied conditional must evaluate its children if and only
* scope permits us to do so.
*/
+ /* FIXME: use roff_ccond? */
+
st = &(*bufp)[pos];
if (NULL == (ep = strstr(st, "\\}"))) {
roffnode_cleanscope(r);
return(ROFFRULE_DENY);
}
-
/* ARGSUSED */
static enum rofferr
-roff_line(ROFF_ARGS)
+roff_line_ignore(ROFF_ARGS)
{
return(ROFF_IGN);
}
+/* ARGSUSED */
+static enum rofferr
+roff_line_error(ROFF_ARGS)
+{
+
+ (*r->msg)(MANDOCERR_REQUEST, r->data, ln, ppos, roffs[tok].name);
+ return(ROFF_IGN);
+}
/* ARGSUSED */
static enum rofferr
return(ROFF_ERR);
}
- if ( ! roffnode_push(r, tok, ln, ppos))
- return(ROFF_ERR);
+ roffnode_push(r, tok, ln, ppos);
r->last->rule = rule;
return(ROFF_IGN);
}
+/* ARGSUSED */
+static enum rofferr
+roff_so(ROFF_ARGS)
+{
+ char *name;
+
+ (*r->msg)(MANDOCERR_SO, r->data, ln, ppos, NULL);
+
+ /*
+ * Handle `so'. Be EXTREMELY careful, as we shouldn't be
+ * opening anything that's not in our cwd or anything beneath
+ * it. Thus, explicitly disallow traversing up the file-system
+ * or using absolute paths.
+ */
+
+ name = *bufp + pos;
+ if ('/' == *name || strstr(name, "../") || strstr(name, "/..")) {
+ (*r->msg)(MANDOCERR_SOPATH, r->data, ln, pos, NULL);
+ return(ROFF_ERR);
+ }
+
+ *offs = pos;
+ return(ROFF_SO);
+}
+
+static char *
+roff_strdup(const char *name)
+{
+ char *namecopy, *sv;
+
+ /*
+ * This isn't a nice simple mandoc_strdup() because we must
+ * handle roff's stupid double-escape rule.
+ */
+ sv = namecopy = mandoc_malloc(strlen(name) + 1);
+ while (*name) {
+ if ('\\' == *name && '\\' == *(name + 1))
+ name++;
+ *namecopy++ = *name++;
+ }
+
+ *namecopy = '\0';
+ return(sv);
+}
+
static void
roff_setstr(struct roff *r, const char *name, const char *string)
} else
free(n->string);
- ROFF_DEBUG("roff: new symbol: [%s] = [%s]\n", name, string);
- n->string = string ? strdup(string) : NULL;
+ /* Don't use mandoc_strdup: clean out double-escapes. */
+ n->string = string ? roff_strdup(string) : NULL;
+ ROFF_DEBUG("roff: new symbol: [%s] = [%s]\n", name, n->string);
}
const struct roffstr *n;
n = r->first_string;
- while (n && (strncmp(name, n->name, len) || '\0' != n->name[len]))
+ while (n && (strncmp(name, n->name, len) || '\0' != n->name[(int)len]))
n = n->next;
return(n ? n->string : NULL);
git.ckatri.com / mandoc.git / blobdiff