[BACK]Return to roff.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/roff.c between version 1.99 and 1.105

version 1.99, 2010/08/24 12:48:43 version 1.105, 2010/12/01 16:54:25
Line 45 
Line 45 
 #endif  #endif
   
 enum    rofft {  enum    rofft {
           ROFF_ad,
         ROFF_am,          ROFF_am,
         ROFF_ami,          ROFF_ami,
         ROFF_am1,          ROFF_am1,
Line 53  enum rofft {
Line 54  enum rofft {
         ROFF_de1,          ROFF_de1,
         ROFF_ds,          ROFF_ds,
         ROFF_el,          ROFF_el,
           ROFF_hy,
         ROFF_ie,          ROFF_ie,
         ROFF_if,          ROFF_if,
         ROFF_ig,          ROFF_ig,
           ROFF_ne,
           ROFF_nh,
           ROFF_nr,
         ROFF_rm,          ROFF_rm,
           ROFF_so,
         ROFF_tr,          ROFF_tr,
         ROFF_cblock,          ROFF_cblock,
         ROFF_ccond,          ROFF_ccond, /* FIXME: remove this. */
         ROFF_nr,  
         ROFF_MAX          ROFF_MAX
 };  };
   
Line 130  static enum roffrule  roff_evalcond(const char *, int 
Line 135  static enum roffrule  roff_evalcond(const char *, int 
 static  void             roff_freestr(struct roff *);  static  void             roff_freestr(struct roff *);
 static  const char      *roff_getstrn(const struct roff *,  static  const char      *roff_getstrn(const struct roff *,
                                 const char *, size_t);                                  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  enum rofferr     roff_nr(ROFF_ARGS);
 static  int              roff_res(struct roff *,  static  int              roff_res(struct roff *,
                                 char **, size_t *, int);                                  char **, size_t *, int);
 static  void             roff_setstr(struct roff *,  static  void             roff_setstr(struct roff *,
                                 const char *, const char *);                                  const char *, const char *);
   static  enum rofferr     roff_so(ROFF_ARGS);
 static  char            *roff_strdup(const char *);  static  char            *roff_strdup(const char *);
   
 /* See roff_hash_find() */  /* See roff_hash_find() */
Line 147  static char  *roff_strdup(const char *);
Line 154  static char  *roff_strdup(const char *);
 static  struct roffmac  *hash[HASHWIDTH];  static  struct roffmac  *hash[HASHWIDTH];
   
 static  struct roffmac   roffs[ROFF_MAX] = {  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 },          { "am", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "ami", 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 },          { "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
Line 155  static struct roffmac  roffs[ROFF_MAX] = {
Line 163  static struct roffmac  roffs[ROFF_MAX] = {
         { "de1", 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 },          { "ds", roff_ds, NULL, NULL, 0, NULL },
         { "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, 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 },          { "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
         { "if", 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 },          { "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "rm", roff_line, NULL, NULL, 0, NULL },          { "ne", roff_line_ignore, NULL, NULL, 0, NULL },
         { "tr", roff_line, 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_cblock, NULL, NULL, 0, NULL },
         { "\\}", roff_ccond, NULL, NULL, 0, NULL },          { "\\}", roff_ccond, NULL, NULL, 0, NULL },
         { "nr", roff_nr, NULL, NULL, 0, NULL },  
 };  };
   
 static  void             roff_free1(struct roff *);  static  void             roff_free1(struct roff *);
Line 248  roffnode_pop(struct roff *r)
Line 260  roffnode_pop(struct roff *r)
                 if (r->rstackpos > -1)                  if (r->rstackpos > -1)
                         r->rstackpos--;                          r->rstackpos--;
   
           ROFF_DEBUG("roff: popping scope\n");
         r->last = r->last->parent;          r->last = r->last->parent;
         if (p->end)          if (p->end)
                 free(p->end);                  free(p->end);
Line 426  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 439  roff_parseln(struct roff *r, int ln, char **bufp, 
         if (r->last) {          if (r->last) {
                 t = r->last->tok;                  t = r->last->tok;
                 assert(roffs[t].sub);                  assert(roffs[t].sub);
                 ROFF_DEBUG("roff: intercept scoped context: %s\n",                  ROFF_DEBUG("roff: intercept scoped context: %s, [%s]\n",
                                 roffs[t].name);                                  roffs[t].name, &(*bufp)[pos]);
                 return((*roffs[t].sub)                  return((*roffs[t].sub)
                                 (r, t, bufp, szp,                                  (r, t, bufp, szp,
                                  ln, pos, pos, offs));                                   ln, pos, pos, offs));
Line 748  roff_cond_sub(ROFF_ARGS)
Line 761  roff_cond_sub(ROFF_ARGS)
 {  {
         enum rofft       t;          enum rofft       t;
         enum roffrule    rr;          enum roffrule    rr;
         struct roffnode *l;  
   
         ppos = pos;          ppos = pos;
         rr = r->last->rule;          rr = r->last->rule;
Line 758  roff_cond_sub(ROFF_ARGS)
Line 770  roff_cond_sub(ROFF_ARGS)
          * continue.           * continue.
          */           */
   
         l = r->last;  
         roffnode_cleanscope(r);          roffnode_cleanscope(r);
   
         if (l != r->last)          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);                  return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
           }
   
         if (ROFF_MAX == (t = roff_parse(*bufp, &pos)))  
                 return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);  
   
         /*          /*
          * A denied conditional must evaluate its children if and only           * A denied conditional must evaluate its children if and only
          * if they're either structurally required (such as loops and           * if they're either structurally required (such as loops and
Line 797  roff_cond_text(ROFF_ARGS)
Line 810  roff_cond_text(ROFF_ARGS)
          * scope permits us to do so.           * scope permits us to do so.
          */           */
   
           /* FIXME: use roff_ccond? */
   
         st = &(*bufp)[pos];          st = &(*bufp)[pos];
         if (NULL == (ep = strstr(st, "\\}"))) {          if (NULL == (ep = strstr(st, "\\}"))) {
                 roffnode_cleanscope(r);                  roffnode_cleanscope(r);
Line 835  roff_evalcond(const char *v, int *pos)
Line 850  roff_evalcond(const char *v, int *pos)
         return(ROFFRULE_DENY);          return(ROFFRULE_DENY);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
 roff_line(ROFF_ARGS)  roff_line_ignore(ROFF_ARGS)
 {  {
   
         return(ROFF_IGN);          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 */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
 roff_cond(ROFF_ARGS)  roff_cond(ROFF_ARGS)
Line 1035  roff_nr(ROFF_ARGS)
Line 1057  roff_nr(ROFF_ARGS)
         return(ROFF_IGN);          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 *  static char *
 roff_strdup(const char *name)  roff_strdup(const char *name)
Legend:
Removed from v.1.99  
changed lines
  Added in v.1.105
CVSweb