开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
TypeRules.c++
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：13k
源码类别：

传真(Fax)编程

开发平台：

C/C++

TypeRules.c++：源码内容
  1. /* $Id: TypeRules.c++,v 1.7 2008/01/04 23:24:31 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1990-1996 Sam Leffler
  4.  * Copyright (c) 1991-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26. #include <ctype.h>
  28. #include "Array.h"
  29. #include "TypeRules.h"
  30. #include "PageSize.h"
  31. #include "config.h"
  33. #include <string.h>
  34. #include <stdlib.h>
  36. #ifdef _XOPEN_SOURCE_EXTENDED
  37. #include <arpa/inet.h>
  38. #else
  39. extern "C" {
  40. #include <netinet/in.h>
  41. }
  42. #endif
  44. #ifndef TRUE
  45. #define TRUE 1
  46. #endif
  48. #ifndef FALSE
  49. #define FALSE 0
  50. #endif
  52. TypeRule::TypeRule() {}
  53. TypeRule::~TypeRule() {}
  54. TypeRule::TypeRule(const TypeRule& other)
  55.     : fxObj(other)
  56.     , cmd(other.cmd)
  57. {
  58.     off = other.off;
  59.     cont = other.cont;
  60.     type = other.type;
  61.     op = other.op;
  62.     value.v = other.value.v;
  63.     result = other.result;
  64. }
  66. static const char* typeNames[] =
  67.     { "ascii", "asciiesc", "string", "istring", "address", "byte", "short", "long" };
  68. static const char* opNames[] =
  69.     { "<any>", "=", "!=", "<", "<=", ">", ">=", "&", "^", "!" };
  70. static const char* resultNames[] = { "tiff", "postscript", "pdf", "pcl", "error" };
  72. fxStr
  73. quoted(const fxStr& s)
  74. {
  75.     fxStr q;
  76.     q.append(" '");
  77.     for (u_int i = 0; i < s.length(); i++) {
  78. if (s[i] == ''') q.append("'\'");
  79. q.append(s[i]);
  80.     }
  81.     q.append("'");
  82.     return (q);
  83. }
  86. bool
  87. TypeRule::match(const void* data, size_t size, bool verbose) const
  88. {
  89.     if (verbose) {
  90. printf("rule: %soffset %#lx %s %s",
  91.     cont ? ">" : "",
  92.     (u_long) off,
  93.     typeNames[type],
  94.     opNames[op]
  95. );
  96. if (type == STRING || type == ISTRING)
  97.     printf(" "%s"", value.s);
  98. else if (type != ASCII && type != ASCIIESC) {
  99.     if (op == ANY)
  100. printf(" <any value>");
  101.     else
  102. printf(" %#llx", (long long) value.v);
  103. }
  104. printf(" -- ");
  105.     }
  106.     if (off > (off_t)size) {
  107. if (verbose)
  108.     printf("failed (offset past data)n");
  109. return (false);
  110.     }
  111.     bool ok = false;
  112.     long v = 0;
  113.     const u_char* cp = (const u_char*) data;
  114.     switch (type) {
  115.     case ASCII:
  116. {
  117. u_int i;
  118. for (i = 0; i < size; i++)
  119.     if (!isprint(cp[i]) && !isspace(cp[i])) {
  120. if (verbose)
  121.     printf("failed (unprintable char %#x)n", cp[i]);
  122. return (false);
  123.     }
  124. ok = true;
  125. goto done;
  126. }
  127.     case ASCIIESC:
  128. {
  129. u_int i;
  130. for (i = 0; i < size; i++)
  131.     if (!isprint(cp[i]) && !isspace(cp[i]) && cp[i] != '33') {
  132. if (verbose)
  133.     printf("failed (unprintable char %#x)n", cp[i]);
  134. return (FALSE);
  135.     }
  136. ok = TRUE;
  137. goto done;
  138. }
  139.     case STRING:
  140. ok = (strncmp((const char*)(cp+off), value.s,
  141.     fxmin((u_int) strlen(value.s), (u_int)(size-off))) == 0);
  142. goto done;
  143.     case ISTRING:
  144. ok = (strncasecmp((const char*)(cp+off), value.s,
  145.     fxmin((u_int) strlen(value.s), (u_int)(size-off))) == 0);
  146. goto done;
  147.     case ADDR:
  148. v = (u_long) off;
  149. break;
  150.     case BYTE:
  151. v = *cp;
  152. break;
  153.     case SHORT:
  154. if (off + 2 < (off_t)size) {
  155.     u_short w;
  156.     memcpy(&w, cp+off, 2);
  157.     v = ntohs(w);
  158.     break;
  159. }
  160. if (verbose)
  161.     printf("failed (insufficient data)n");
  162. return (false);
  163.     case LONG:
  164. if (off + 4 < (off_t)size) {
  165.     memcpy(&v, cp+off, 4);
  166.     v = ntohl(v);
  167.     break;
  168. }
  169. if (verbose)
  170.     printf("failed (insufficient data)n");
  171. return (false);
  172.     }
  173.     /*
  174.      * Numeric value, use operation.
  175.      */
  176.     switch (op) {
  177.     case ANY: ok = true; break;
  178.     case EQ: ok = (v == value.v); break;
  179.     case NE: ok = (v != value.v); break;
  180.     case LT: ok = (v  < value.v); break;
  181.     case LE: ok = (v <= value.v); break;
  182.     case GT: ok = (v  > value.v); break;
  183.     case GE: ok = (v >= value.v); break;
  184.     case AND: ok = ((v&value.v) == value.v); break;
  185.     case NOT: ok = ((v&value.v) != value.v); break;
  186.     case XOR: ok = ((v^value.v) != 0); break;
  187.     }
  188. done:
  189.     if (verbose) {
  190. if (ok)
  191.     printf("success (result %s, rule "%s")n",
  192. resultNames[result], (const char*) cmd);
  193. else
  194.     printf("failed (comparison)n");
  195.     }
  196.     return (ok);
  197. }
  199. /*
  200.  * rule:  a string passed to the shell to convert the input file
  201.  *   to the result format (suitable for sending as facsimile).
  202.  *   The rule string is a printf-like string that should use the
  203.  *   following "%" escapes:
  204.  * %i input file name
  205.  * %o output file name
  206.  * %r output horizontal resolution in pixels/mm
  207.  * %R output horizontal resolution in pixels/inch
  208.  * %v output vertical resolution in lines/mm
  209.  * %V output vertical resolution in lines/inch
  210.  * %f data format, 1 for 1-d encoding or 2 for 2-d encoding
  211.  * %w page width in pixels
  212.  * %W page width in mm
  213.  * %l page length in pixels
  214.  * %L page length in mm
  215.  * %s page size by name
  216.  * %F the pathname of the fax library (e.g./usr/local/lib/fax)
  217.  * %<x> the <x> character (e.g. ``%%'' results in ``%''
  218.  */
  219. fxStr
  220. TypeRule::getFmtdCmd(
  221.     const fxStr& input, const fxStr& output,
  222.     float hr, float vr, const fxStr& df, const fxStr& pname) const
  223. {
  224.     fxStr fmtd;
  225.     const PageSizeInfo* info = PageSizeInfo::getPageSizeByName(pname);
  226.     float pw = info->width();
  227.     float pl = info->height();
  229.     for (u_int i = 0, n = cmd.length(); i < n; i++) {
  230. char c = cmd[i];
  231. if (c == '%' && i+1 < n) {
  232.     i++;
  233.     switch (c = cmd[i]) {
  234.     case 'i': fmtd.append(quoted(input));   continue;
  235.     case 'o': fmtd.append(quoted(output));   continue;
  236.     case 'R': fmtd.append(fxStr(hr, "%.2f"));   continue;
  237.     case 'r': fmtd.append(fxStr(hr/25.4, "%.2g"));   continue;
  238.     case 'V': fmtd.append(fxStr(vr, "%.2f"));   continue;
  239.     case 'v': fmtd.append(fxStr(vr/25.4, "%.2g"));   continue;
  240.     case 'f': fmtd.append(df);   continue;
  241.     case 'W': fmtd.append(fxStr(pw, "%.4g"));   continue;
  242.     case 'w': fmtd.append(fxStr(pw*hr/25.4, "%.0f"));   continue;
  243.     case 'L': fmtd.append(fxStr(pl, "%.4g"));   continue;
  244.     case 'l': fmtd.append(fxStr(pl*vr/25.4, "%.0f"));   continue;
  245.     case 'F': fmtd.append(fxStr(FAX_LIBEXEC));   continue;
  246.     case 's': fmtd.append(pname);   continue;
  247.     }
  248. }
  249. fmtd.append(c);
  250.     }
  251.     return fmtd;
  252. }
  254. fxDECLARE_ObjArray(TypeRuleArray, TypeRule)
  255. fxIMPLEMENT_ObjArray(TypeRuleArray, TypeRule)
  257. TypeRules::TypeRules()
  258. {
  259.     verbose = false;
  260.     rules = new TypeRuleArray;
  261. }
  263. TypeRules::~TypeRules()
  264. {
  265.     delete rules;
  266. }
  268. void
  269. TypeRules::setVerbose(bool b)
  270. {
  271.     verbose = b;
  272. }
  274. #include <ctype.h>
  276. static bool
  277. appendLine(fxStr& s, const char* line)
  278. {
  279.     const char* cp = line;
  280.     for (; isspace(*cp); cp++)
  281. ;
  282.     if (cp > line) // put back one bit of white space
  283. cp--;
  284.     const char* cmd = cp;
  285.     if (*cp != '' && *cp != 'n' && *cp != '#') {
  286. do {
  287.     cp++;
  288.     if (cp[-1] == '\') {
  289. if (*cp == 'n') { // continue cmd string on next line
  290.     s.append(cmd, cp-1 - cmd);
  291.     return (true);
  292. } else if (*cp) // accept anything but \0
  293.     cp++;
  294.     }
  295. } while (*cp != '' && *cp != 'n' && *cp != '#');
  296. s.append(fxStr(cmd, cp-cmd));
  297.     }
  298.     return (false);
  299. }
  301. #include <stdarg.h>
  303. static void
  304. parseError(const char* file, u_int lineno, const char* fmt ...)
  305. {
  306.     va_list ap;
  307.     va_start(ap, fmt);
  308.     fprintf(stderr, "%s: line %u: ", file, lineno); 
  309.     vfprintf(stderr, fmt, ap);
  310.     va_end(ap);
  311. }
  313. TypeRules*
  314. TypeRules::read(const fxStr& file)
  315. {
  316.     FILE* fp;
  318.     fp = fopen(file, "r");
  319.     if (fp == NULL) {
  320. fprintf(stderr, "%s: Can not open type rules file.n",
  321.     (const char*) file);
  322. return NULL;
  323.     }
  324.     TypeRules* tr = new TypeRules;
  325.     char line[256];
  326.     u_int lineno = 0;
  327.     while (fgets(line, sizeof (line), fp) != NULL) {
  328. lineno++;
  329. char* cp = line;
  330. if (*cp == 'n' || *cp == '#')
  331.     continue;
  332. TypeRule rule;
  333. if (*cp == '>') { // continuation
  334.     rule.cont = true;
  335.     cp++;
  336. } else
  337.     rule.cont = false;
  338. const char *op = cp;
  339. rule.off = strtoul(op, &cp, 0); // file offset
  340. if (cp == op) {
  341.     parseError(file, lineno, "Missing file offset");
  342.     continue;
  343. }
  344. while (isspace(*cp))
  345.     cp++;
  346. const char* tp = cp;
  347. while (*cp && !isspace(*cp)) // data type
  348.     cp++;
  349. if (strncasecmp(tp, "byte", cp-tp) == 0)
  350.     rule.type = TypeRule::BYTE;
  351. else if (strncasecmp(tp, "short", cp-tp) == 0)
  352.     rule.type = TypeRule::SHORT;
  353. else if (strncasecmp(tp, "long", cp-tp) == 0)
  354.     rule.type = TypeRule::LONG;
  355. else if (strncasecmp(tp, "string", cp-tp) == 0)
  356.     rule.type = TypeRule::STRING;
  357. else if (strncasecmp(tp, "istring", cp-tp) == 0)
  358.     rule.type = TypeRule::ISTRING;
  359. else if (strncasecmp(tp, "ascii", cp-tp) == 0)
  360.     rule.type = TypeRule::ASCII;
  361. else if (strncasecmp(tp, "asciiesc", cp-tp) == 0)
  362.     rule.type = TypeRule::ASCIIESC;
  363. else if (strncasecmp(tp, "addr", cp-tp) == 0)
  364.     rule.type = TypeRule::ADDR;
  365. else {
  366.     parseError(file, lineno, "Unknown datatype "%.*s"", cp-tp, tp);
  367.     continue; // bad type
  368. }
  369. while (isspace(*cp))
  370.     cp++;
  371. rule.op = TypeRule::EQ; // default is '='
  372. const char* vp = cp;
  373. if (rule.type != TypeRule::STRING && rule.type != TypeRule::ISTRING
  374. && rule.type != TypeRule::ASCII && rule.type != TypeRule::ASCIIESC) {
  375.     // numeric value
  376.     switch (*vp) {
  377.     case '=': rule.op = TypeRule::EQ; cp++; break;
  378.     case '^': rule.op = TypeRule::XOR; cp++; break;
  379.     case '&': rule.op = TypeRule::AND; cp++; break;
  380.     case 'x': rule.op = TypeRule::ANY; cp++; break;
  381.     case '>':
  382. if (cp[1] == '=') {
  383.     rule.op = TypeRule::GE; cp++;
  384. } else
  385.     rule.op = TypeRule::GT;
  386. cp++;
  387. break;
  388.     case '<':
  389. if (cp[1] == '=') {
  390.     rule.op = TypeRule::LE; cp++;
  391. } else
  392.     rule.op = TypeRule::LT;
  393. cp++;
  394. break;
  395.     case '!':
  396. if (cp[1] == '=') {
  397.     rule.op = TypeRule::NE; cp++;
  398. } else
  399.     rule.op = TypeRule::NOT;
  400. cp++;
  401. break;
  402.     }
  403.     if (rule.op != TypeRule::ANY) {
  404. const char* vp = cp;
  405. rule.value.v = strtol(vp, &cp, 0);
  406. if (vp == cp) {
  407.     parseError(file, lineno, "Missing match value");
  408.     continue;
  409. }
  410.     }
  411. } else { // string value
  412.     while (*cp != '' && *cp != 't') // NB: accept blanks
  413. cp++;
  414.     if (*cp != 't')
  415. continue;
  416.     u_int len = cp-vp;
  417.     rule.value.s = (char*) malloc(len+1); // +1 for 
  418.     memcpy(rule.value.s, vp, len);
  419.     rule.value.s[len] = '';
  420. }
  421. while (isspace(*cp))
  422.     cp++;
  423. const char* rp = cp;
  424. while (isalpha(*cp))
  425.     cp++;
  426. if (strncasecmp(rp, "tiff", cp-rp) == 0)
  427.     rule.result = TypeRule::TIFF;
  428. else if (strncasecmp(rp, "ps", cp-rp) == 0)
  429.     rule.result = TypeRule::POSTSCRIPT;
  430. else if (strncasecmp(rp, "pdf", cp-rp) == 0)
  431.     rule.result = TypeRule::PDF;
  432. else if (strncasecmp(rp, "pcl", cp-rp) == 0)
  433.     rule.result = TypeRule::PCL;
  434. else if (strncasecmp(rp, "error", cp-rp) == 0)
  435.     rule.result = TypeRule::ERROR;
  436. else {
  437.     parseError(file, lineno, "Unknown result "%.*s"", cp-rp, rp);
  438.     continue;
  439. }
  440. while (isspace(*cp))
  441.     cp++;
  442. const char* cmd = cp; // collect cmd string
  443. if (*cp != '' && *cp != 'n' && *cp != '#') {
  444.     bool done = false; // XXX workaround compiler limitation
  445.     do {
  446. cp++;
  447. if (cp[-1] == '\') {
  448.     if (*cp == 'n') { // continue cmd string on next line
  449. rule.cmd = fxStr(cmd, cp-1 - cmd);
  450. while (fgets(line, sizeof (line), fp) != NULL &&
  451.   appendLine(rule.cmd, line))
  452.     ;
  453. done = true;
  454.     } else if (*cp) // accept anything but \0
  455. cp++;
  456. }
  457.     } while (!done && *cp != '' && *cp != 'n' && *cp != '#');
  458.     if (!done)
  459. rule.cmd = fxStr(cmd, cp-cmd);
  460. }
  461. tr->rules->append(rule);
  462.     }
  463.     (void) fclose(fp);
  464.     return (tr);
  465. }
  467. /*
  468.  * Check secondary matching rules after a primary match.
  469.  */
  470. u_int
  471. TypeRules::match2(u_int base, const void* data, u_int size, bool verb) const
  472. {
  473.     for (u_int i = 1, n = (*rules).length() - base; i < n; i++) {
  474. TypeRule& rule = (*rules)[base+i];
  475. if (!rule.isContinuation())
  476.     break;
  477. if (rule.match(data, size, verb))
  478.     return (i);
  479.     }
  480.     return 0;
  481. }
  483. const TypeRule*
  484. TypeRules::match(const void* data, u_int size) const
  485. {
  486.     if (verbose)
  487. printf("match against (..., %u)n", size);
  488.     for (u_int i = 0, n = (*rules).length(); i < n; i++) {
  489. TypeRule& rule = (*rules)[i];
  490. if (!rule.isContinuation() && rule.match(data, size, verbose))
  491.     return (&(*rules)[i + match2(i, data, size, verbose)]);
  492.     }
  493.     if (verbose)
  494. printf("no matchn");
  495.     return (NULL);
  496. }