mdw@git.distorted.org.uk Git - qmail/blob - token822.c

   1 #include "stralloc.h"
   2 #include "alloc.h"
   3 #include "str.h"
   4 #include "token822.h"
   5 #include "gen_allocdefs.h"
   6
   7 static struct token822 comma = { TOKEN822_COMMA };
   8
   9 void token822_reverse(ta)
  10 token822_alloc *ta;
  11 {
  12  int i;
  13  int n;
  14  struct token822 temp;
  15
  16  n = ta->len - 1;
  17  for (i = 0;i + i < n;++i)
  18   {
  19    temp = ta->t[i];
  20    ta->t[i] = ta->t[n - i];
  21    ta->t[n - i] = temp;
  22   }
  23 }
  24
  25 GEN_ALLOC_ready(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_ready)
  26 GEN_ALLOC_readyplus(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_readyplus)
  27 GEN_ALLOC_append(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_readyplus,token822_append)
  28
  29 static int needspace(t1,t2)
  30 int t1;
  31 int t2;
  32 {
  33  if (!t1) return 0;
  34  if (t1 == TOKEN822_COLON) return 1;
  35  if (t1 == TOKEN822_COMMA) return 1;
  36  if (t2 == TOKEN822_LEFT) return 1;
  37  switch(t1)
  38   {
  39    case TOKEN822_ATOM: case TOKEN822_LITERAL:
  40    case TOKEN822_QUOTE: case TOKEN822_COMMENT:
  41      switch(t2)
  42       {
  43        case TOKEN822_ATOM: case TOKEN822_LITERAL:
  44        case TOKEN822_QUOTE: case TOKEN822_COMMENT:
  45          return 1;
  46       }
  47   }
  48  return 0;
  49 }
  50
  51 static int atomok(ch)
  52 char ch;
  53 {
  54  switch(ch)
  55   {
  56    case ' ': case '\t': case '\r': case '\n':
  57    case '(': case '[': case '"':
  58    case '<': case '>': case ';': case ':':
  59    case '@': case ',': case '.':
  60      return 0;
  61   }
  62  return 1;
  63 }
  64
  65 static void atomcheck(t)
  66 struct token822 *t;
  67 {
  68  int i;
  69  char ch;
  70  for (i = 0;i < t->slen;++i)
  71   {
  72    ch = t->s[i];
  73    if ((ch < 32) || (ch > 126) || (ch == ')') || (ch == ']') || (ch == '\\'))
  74     {
  75      t->type = TOKEN822_QUOTE;
  76      return;
  77     }
  78   }
  79 }
  80
  81 int token822_unparse(sa,ta,linelen)
  82 stralloc *sa;
  83 token822_alloc *ta;
  84 unsigned int linelen;
  85 {
  86  struct token822 *t;
  87  int len;
  88  int ch;
  89  int i;
  90  int j;
  91  int lasttype;
  92  int newtype;
  93  char *s;
  94  char *lineb;
  95  char *linee;
  96
  97  len = 0;
  98  lasttype = 0;
  99  for (i = 0;i < ta->len;++i)
 100   {
 101    t = ta->t + i;
 102    newtype = t->type;
 103    if (needspace(lasttype,newtype))
 104      ++len;
 105    lasttype = newtype;
 106    switch(newtype)
 107     {
 108      case TOKEN822_COMMA:
 109        len += 3; break;
 110      case TOKEN822_AT: case TOKEN822_DOT: case TOKEN822_LEFT: case TOKEN822_RIGHT:
 111      case TOKEN822_SEMI: case TOKEN822_COLON:
 112        ++len; break;
 113      case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL: case TOKEN822_COMMENT:
 114        if (t->type != TOKEN822_ATOM) len += 2;
 115        for (j = 0;j < t->slen;++j)
 116          switch(ch = t->s[j])
 117           {
 118            case '"': case '[': case ']': case '(': case ')':
 119            case '\\': case '\r': case '\n': ++len;
 120            default: ++len;
 121           }
 122        break;
 123     }
 124   }
 125  len += 2;
 126
 127  if (!stralloc_ready(sa,len))
 128    return -1;
 129
 130  s = sa->s;
 131  lineb = s;
 132  linee = 0;
 133
 134  lasttype = 0;
 135  for (i = 0;i < ta->len;++i)
 136   {
 137    t = ta->t + i;
 138    newtype = t->type;
 139    if (needspace(lasttype,newtype))
 140      *s++ = ' ';
 141    lasttype = newtype;
 142    switch(newtype)
 143     {
 144      case TOKEN822_COMMA:
 145        *s++ = ',';
 146 #define NSUW \
 147  s[0] = '\n'; s[1] = ' '; \
 148  if (linee && (!linelen || (s - lineb <= linelen))) \
 149   { while (linee < s) { linee[0] = linee[2]; ++linee; } linee -= 2; } \
 150  else { if (linee) lineb = linee + 1; linee = s; s += 2; }
 151        NSUW
 152        break;
 153      case TOKEN822_AT: *s++ = '@'; break;
 154      case TOKEN822_DOT: *s++ = '.'; break;
 155      case TOKEN822_LEFT: *s++ = '<'; break;
 156      case TOKEN822_RIGHT: *s++ = '>'; break;
 157      case TOKEN822_SEMI: *s++ = ';'; break;
 158      case TOKEN822_COLON: *s++ = ':'; break;
 159      case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL: case TOKEN822_COMMENT:
 160        if (t->type == TOKEN822_QUOTE) *s++ = '"';
 161        if (t->type == TOKEN822_LITERAL) *s++ = '[';
 162        if (t->type == TOKEN822_COMMENT) *s++ = '(';
 163        for (j = 0;j < t->slen;++j)
 164          switch(ch = t->s[j])
 165           {
 166            case '"': case '[': case ']': case '(': case ')':
 167            case '\\': case '\r': case '\n': *s++ = '\\';
 168            default: *s++ = ch;
 169           }
 170        if (t->type == TOKEN822_QUOTE) *s++ = '"';
 171        if (t->type == TOKEN822_LITERAL) *s++ = ']';
 172        if (t->type == TOKEN822_COMMENT) *s++ = ')';
 173        break;
 174     }
 175   }
 176  NSUW
 177  --s;
 178  sa->len = s - sa->s;
 179  return 1;
 180 }
 181
 182 int token822_unquote(sa,ta)
 183 stralloc *sa;
 184 token822_alloc *ta;
 185 {
 186  struct token822 *t;
 187  int len;
 188  int i;
 189  int j;
 190  char *s;
 191
 192  len = 0;
 193  for (i = 0;i < ta->len;++i)
 194   {
 195    t = ta->t + i;
 196    switch(t->type)
 197     {
 198      case TOKEN822_COMMA: case TOKEN822_AT: case TOKEN822_DOT: case TOKEN822_LEFT:
 199      case TOKEN822_RIGHT: case TOKEN822_SEMI: case TOKEN822_COLON:
 200        ++len; break;
 201      case TOKEN822_LITERAL:
 202        len += 2;
 203      case TOKEN822_ATOM: case TOKEN822_QUOTE:
 204        len += t->slen;
 205     }
 206   }
 207
 208  if (!stralloc_ready(sa,len))
 209    return -1;
 210
 211  s = sa->s;
 212
 213  for (i = 0;i < ta->len;++i)
 214   {
 215    t = ta->t + i;
 216    switch(t->type)
 217     {
 218      case TOKEN822_COMMA: *s++ = ','; break;
 219      case TOKEN822_AT: *s++ = '@'; break;
 220      case TOKEN822_DOT: *s++ = '.'; break;
 221      case TOKEN822_LEFT: *s++ = '<'; break;
 222      case TOKEN822_RIGHT: *s++ = '>'; break;
 223      case TOKEN822_SEMI: *s++ = ';'; break;
 224      case TOKEN822_COLON: *s++ = ':'; break;
 225      case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL:
 226        if (t->type == TOKEN822_LITERAL) *s++ = '[';
 227        for (j = 0;j < t->slen;++j)
 228          *s++ = t->s[j];
 229        if (t->type == TOKEN822_LITERAL) *s++ = ']';
 230        break;
 231      case TOKEN822_COMMENT: break;
 232     }
 233   }
 234  sa->len = s - sa->s;
 235  return 1;
 236 }
 237
 238 int token822_parse(ta,sa,buf)
 239 token822_alloc *ta;
 240 stralloc *sa;
 241 stralloc *buf;
 242 {
 243  int i;
 244  int salen;
 245  int level;
 246  struct token822 *t;
 247  int numtoks;
 248  int numchars;
 249  char *cbuf;
 250
 251  salen = sa->len;
 252
 253  numchars = 0;
 254  numtoks = 0;
 255  for (i = 0;i < salen;++i)
 256    switch(sa->s[i])
 257     {
 258      case '.': case ',': case '@': case '<': case '>': case ':': case ';':
 259        ++numtoks; break;
 260      case ' ': case '\t': case '\r': case '\n': break;
 261      case ')': case ']': return 0;
 262      /* other control chars and non-ASCII chars are also bad, in theory */
 263      case '(':
 264        level = 1;
 265        while (level)
 266         {
 267          if (++i >= salen) return 0;
 268          switch(sa->s[i])
 269           {
 270            case '(': ++level; break;
 271            case ')': --level; break;
 272            case '\\': if (++i >= salen) return 0;
 273            default: ++numchars;
 274           }
 275         }
 276        ++numtoks;
 277        break;
 278      case '"':
 279        level = 1;
 280        while (level)
 281         {
 282          if (++i >= salen) return 0;
 283          switch(sa->s[i])
 284           {
 285            case '"': --level; break;
 286            case '\\': if (++i >= salen) return 0;
 287            default: ++numchars;
 288           }
 289         }
 290        ++numtoks;
 291        break;
 292      case '[':
 293        level = 1;
 294        while (level)
 295         {
 296          if (++i >= salen) return 0;
 297          switch(sa->s[i])
 298           {
 299            case ']': --level; break;
 300            case '\\': if (++i >= salen) return 0;
 301            default: ++numchars;
 302           }
 303         }
 304        ++numtoks;
 305        break;
 306      default:
 307        do
 308         {
 309          if (sa->s[i] == '\\') if (++i >= salen) break;
 310          ++numchars;
 311          if (++i >= salen)
 312            break;
 313         }
 314        while (atomok(sa->s[i]));
 315        --i;
 316        ++numtoks;
 317     }
 318
 319  if (!token822_ready(ta,numtoks))
 320    return -1;
 321  if (!stralloc_ready(buf,numchars))
 322    return -1;
 323  cbuf = buf->s;
 324  ta->len = numtoks;
 325
 326  t = ta->t;
 327  for (i = 0;i < salen;++i)
 328    switch(sa->s[i])
 329     {
 330      case '.': t->type = TOKEN822_DOT; ++t; break;
 331      case ',': t->type = TOKEN822_COMMA; ++t; break;
 332      case '@': t->type = TOKEN822_AT; ++t; break;
 333      case '<': t->type = TOKEN822_LEFT; ++t; break;
 334      case '>': t->type = TOKEN822_RIGHT; ++t; break;
 335      case ':': t->type = TOKEN822_COLON; ++t; break;
 336      case ';': t->type = TOKEN822_SEMI; ++t; break;
 337      case ' ': case '\t': case '\r': case '\n': break;
 338      case '(':
 339        t->type = TOKEN822_COMMENT; t->s = cbuf; t->slen = 0;
 340        level = 1;
 341        while (level)
 342         {
 343          ++i; /* assert: < salen */
 344          switch(sa->s[i])
 345           {
 346            case '(': ++level; break;
 347            case ')': --level; break;
 348            case '\\': ++i; /* assert: < salen */
 349            default: *cbuf++ = sa->s[i]; ++t->slen;
 350           }
 351         }
 352        ++t;
 353        break;
 354      case '"':
 355        t->type = TOKEN822_QUOTE; t->s = cbuf; t->slen = 0;
 356        level = 1;
 357        while (level)
 358         {
 359          ++i; /* assert: < salen */
 360          switch(sa->s[i])
 361           {
 362            case '"': --level; break;
 363            case '\\': ++i; /* assert: < salen */
 364            default: *cbuf++ = sa->s[i]; ++t->slen;
 365           }
 366         }
 367        ++t;
 368        break;
 369      case '[':
 370        t->type = TOKEN822_LITERAL; t->s = cbuf; t->slen = 0;
 371        level = 1;
 372        while (level)
 373         {
 374          ++i; /* assert: < salen */
 375          switch(sa->s[i])
 376           {
 377            case ']': --level; break;
 378            case '\\': ++i; /* assert: < salen */
 379            default: *cbuf++ = sa->s[i]; ++t->slen;
 380           }
 381         }
 382        ++t;
 383        break;
 384      default:
 385        t->type = TOKEN822_ATOM; t->s = cbuf; t->slen = 0;
 386        do
 387         {
 388          if (sa->s[i] == '\\') if (++i >= salen) break;
 389          *cbuf++ = sa->s[i]; ++t->slen;
 390          if (++i >= salen)
 391            break;
 392         }
 393        while (atomok(sa->s[i]));
 394        atomcheck(t);
 395        --i;
 396        ++t;
 397     }
 398  return 1;
 399 }
 400
 401 static int gotaddr(taout,taaddr,callback)
 402 token822_alloc *taout;
 403 token822_alloc *taaddr;
 404 int (*callback)();
 405 {
 406  int i;
 407
 408  if (callback(taaddr) != 1)
 409    return 0;
 410
 411  if (!token822_readyplus(taout,taaddr->len))
 412    return 0;
 413
 414  for (i = 0;i < taaddr->len;++i)
 415    taout->t[taout->len++] = taaddr->t[i];
 416
 417  taaddr->len = 0;
 418  return 1;
 419 }
 420
 421 int token822_addrlist(taout,taaddr,ta,callback)
 422 token822_alloc *taout;
 423 token822_alloc *taaddr;
 424 token822_alloc *ta;
 425 int (*callback)();
 426 {
 427  struct token822 *t;
 428  struct token822 *beginning;
 429  int ingroup;
 430  int wordok;
 431
 432  taout->len = 0;
 433  taaddr->len = 0;
 434
 435  if (!token822_readyplus(taout,1)) return -1;
 436  if (!token822_readyplus(taaddr,1)) return -1;
 437
 438  ingroup = 0;
 439  wordok = 1;
 440
 441  beginning = ta->t + 2;
 442  t = ta->t + ta->len - 1;
 443
 444  /* rfc 822 address lists are easy to parse from right to left */
 445
 446 #define FLUSH if (taaddr->len) if (!gotaddr(taout,taaddr,callback)) return -1;
 447 #define FLUSHCOMMA if (taaddr->len) { \
 448 if (!gotaddr(taout,taaddr,callback)) return -1; \
 449 if (!token822_append(taout,&comma)) return -1; }
 450 #define ADDRLEFT if (!token822_append(taaddr,t--)) return -1;
 451 #define OUTLEFT if (!token822_append(taout,t--)) return -1;
 452
 453  while (t >= beginning)
 454   {
 455    switch(t->type)
 456     {
 457      case TOKEN822_SEMI:
 458        FLUSHCOMMA
 459        if (ingroup) return 0;
 460        ingroup = 1;
 461        wordok = 1;
 462        break;
 463      case TOKEN822_COLON:
 464        FLUSH
 465        if (!ingroup) return 0;
 466        ingroup = 0;
 467        while ((t >= beginning) && (t->type != TOKEN822_COMMA))
 468          OUTLEFT
 469        if (t >= beginning)
 470          OUTLEFT
 471        wordok = 1;
 472        continue;
 473      case TOKEN822_RIGHT:
 474        FLUSHCOMMA
 475        OUTLEFT
 476        while ((t >= beginning) && (t->type != TOKEN822_LEFT))
 477          ADDRLEFT
 478        /* important to use address here even if it's empty: <> */
 479        if (!gotaddr(taout,taaddr,callback)) return -1;
 480        if (t < beginning) return 0;
 481        OUTLEFT
 482        while ((t >= beginning) && ((t->type == TOKEN822_COMMENT) || (t->type == TOKEN822_ATOM) || (t->type == TOKEN822_QUOTE) || (t->type == TOKEN822_AT) || (t->type == TOKEN822_DOT)))
 483          OUTLEFT
 484        wordok = 0;
 485        continue;
 486      case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL:
 487        if (!wordok)
 488          FLUSHCOMMA
 489        wordok = 0;
 490        ADDRLEFT
 491        continue;
 492      case TOKEN822_COMMENT:
 493        /* comment is lexically a space; shouldn't affect wordok */
 494        break;
 495      case TOKEN822_COMMA:
 496        FLUSH
 497        wordok = 1;
 498        break;
 499      default:
 500        wordok = 1;
 501        ADDRLEFT
 502        continue;
 503     }
 504    OUTLEFT
 505   }
 506  FLUSH
 507  ++t;
 508  while (t > ta->t)
 509    if (!token822_append(taout,--t)) return -1;
 510
 511  token822_reverse(taout);
 512  return 1;
 513 }