home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 June / ccd0605.iso / LINUX / gopchop-1.1.7.tar.tar / gopchop-1.1.7.tar / gopchop-1.1.7 / src / Parser.cpp < prev    next >
C/C++ Source or Header  |  2004-02-29  |  9KB  |  420 lines
  1. /*
  2. #
  3. # Creates an in-memory interface to a file, with largefile support.
  4. # Uses mmap to make data available in a user-space memory window.
  5. #
  6. # $Id: Parser.cpp,v 1.17 2004/02/29 11:18:33 nemies Exp $
  7. #
  8. # Copyright (C) 2001-2003 Kees Cook
  9. # kees@outflux.net, http://outflux.net/
  10. # 
  11. # This program is free software; you can redistribute it and/or
  12. # modify it under the terms of the GNU General Public License
  13. # as published by the Free Software Foundation; either version 2
  14. # of the License, or (at your option) any later version.
  15. # 
  16. # This program is distributed in the hope that it will be useful,
  17. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. # GNU General Public License for more details.
  20. # 
  21. # You should have received a copy of the GNU General Public License
  22. # along with this program; if not, write to the Free Software
  23. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  24. # http://www.gnu.org/copyleft/gpl.html
  25. #
  26. */
  27.  
  28. #include "GOPchop.h"
  29. #include "Parser.h"
  30.  
  31. // FIXME: do config.h magic...
  32. #include <stdarg.h>
  33. #include <errno.h>
  34. #include <string.h>
  35.  
  36. #undef MEMORY_UPDATE
  37. #ifdef MEMORY_UPDATE
  38. # define MMAP_PROT    (PROT_READ|PROT_WRITE)
  39. # define OPEN_MODE    (O_RDWR)
  40. #else
  41. # define MMAP_PROT    (PROT_READ)
  42. # define OPEN_MODE    (O_RDONLY)
  43. #endif
  44.  
  45. Parser::Parser(size_t window)
  46. {
  47.     // set passed-in values
  48.     mmap_max = window;
  49.  
  50.     // set detected values
  51.     pagesize = getpagesize();
  52.  
  53.     // set values that "reset" depends on
  54.     filename = NULL;
  55.     fd = -1;
  56.     mmap_ptr = NULL;
  57.     mmap_len = 0;
  58.     mmap_offset = 0;
  59.     error = NULL;
  60.  
  61.     reset();
  62. }
  63.  
  64. void Parser::reset()
  65. {
  66.     if (filename)
  67.     {
  68.         free(filename);
  69.         filename = NULL;
  70.     }
  71.  
  72.     if (fd > -1)
  73.     {
  74.         close(fd);
  75.         fd = -1;
  76.     }
  77.     filesize = 0;
  78.  
  79.     if (mmap_ptr)
  80.     {
  81.         if (munmap(mmap_ptr, mmap_len))
  82.             perror("munmap");
  83.         mmap_ptr = NULL;
  84.         mmap_len = 0;
  85.         mmap_offset = 0;
  86.     }
  87.  
  88.     location = 0;
  89.     start = NULL;
  90.     report_errors = TRUE;
  91.     parsing_state=PARSER_STATE_UNLOADED;
  92.  
  93.     clearError();
  94. }
  95.  
  96. Parser::~Parser()
  97. {
  98.     reset();
  99. }
  100.  
  101. int Parser::getParsingState()
  102. {
  103.     return parsing_state;
  104. }
  105.  
  106. #define MIN(a,b)    ((a)<(b) ? (a) : (b))
  107. int Parser::init(char *pathname, void (*ticker) (char *, float))
  108. {
  109.     struct stat st;
  110.  
  111.     tick = ticker;
  112.  
  113.     // make sure we're not already running
  114.     if (filename || fd > -1 || mmap_ptr)
  115.     {
  116.         reset();
  117.         addError("%s", _("already initialized\n"));
  118.         return FALSE;
  119.     }
  120.  
  121.     // open file
  122.     if ((fd = open(pathname, OPEN_MODE)) < 0)
  123.     {
  124.         reset();
  125.         addError(_("cannot open '%s': %s\n"), pathname, strerror(errno));
  126. #ifdef MEMORY_UPDATE
  127.         addError("%s",
  128.                  _
  129.                  (" (write permissions are needed, but the original file won't be changed.)\n"));
  130. #endif
  131.         return FALSE;
  132.     }
  133.  
  134.     // get file size
  135.     if (fstat(fd, &st))
  136.     {
  137.         reset();
  138.         addError(_("cannot get file size: %s\n"), strerror(errno));
  139.         return FALSE;
  140.     }
  141.  
  142.     if (!S_ISREG(st.st_mode))
  143.     {
  144.         reset();
  145.         addError(_("'%s' is not a file!\n"), pathname);
  146.         return FALSE;
  147.     }
  148.  
  149.     filesize = st.st_size;
  150.  
  151.     mmap_len = MIN(mmap_max, filesize);
  152.  
  153.     if ((mmap_ptr = (uint8_t *) mmap(NULL, mmap_len, MMAP_PROT,
  154.                                      MAP_PRIVATE, fd, 0)) == MAP_FAILED)
  155.     {
  156.         reset();
  157.         addError("%s", _("cannot memory map file\n"));
  158.         return FALSE;
  159.     }
  160.  
  161.     filename = strdup(pathname);
  162.     start = mmap_ptr;
  163.     location = 0;
  164.  
  165.     parsing_state=PARSER_STATE_READY;
  166.  
  167.     return TRUE;
  168. }
  169.  
  170. char *Parser::getFilename()
  171. {
  172.     return filename;
  173. }
  174.  
  175. char *Parser::getError()
  176. {
  177.     return error;
  178. }
  179.  
  180. off_t Parser::getSize()
  181. {
  182.     return filesize;
  183. }
  184.  
  185. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  186.  
  187. uint8_t *Parser::bytesAvail(off_t location, size_t bytes)
  188. {
  189.     off_t pagedloc;
  190.     size_t pagedbytes;
  191.  
  192.     // make sure we're in bounds
  193.     if (!mmap_ptr || location > filesize || location + bytes > filesize)
  194.     {
  195.         /*
  196.            printf("%s",_("out of bounds\n"));
  197.            printf(_("filesize: %llu\n"),filesize);
  198.            printf(_("location: %llu\n"),location);
  199.            printf(_("bytes: %d\n"),bytes);
  200.          */
  201.         return NULL;
  202.     }
  203.  
  204.     // are we inbounds in current mmap region?
  205.     if (mmap_offset <= location && location + bytes <= mmap_offset + mmap_len)
  206.     {
  207.         start = mmap_ptr + (location - mmap_offset);
  208.         return start;
  209.     }
  210.  
  211.     // we're not inbounds, let's realign on page boundry, near "location"
  212.  
  213.     // get page-aligned location
  214.     pagedloc = location / pagesize;
  215.     pagedloc *= pagesize;
  216.  
  217.     // figure out our expected mmap window size
  218.     pagedbytes = MAX(mmap_max, (location - pagedloc) + bytes);
  219.     // mmap area too large
  220.     if (pagedbytes > mmap_max)
  221.     {
  222.         printf(_("mmap area too large (must increase window size!)\n"
  223.                  "pagedbytes: %d mmap_max: %d\n"
  224.                  "location: %llu pagedloc: %llu\n"
  225.                  "bytes: %d\n"),
  226.                pagedbytes, mmap_max, location, pagedloc, bytes);
  227.         return NULL;
  228.     }
  229.  
  230.     // unmmmap or fail
  231.     if (munmap(mmap_ptr, mmap_len))
  232.     {
  233.         printf("%s", _("munmap failed\n"));
  234.         reset();
  235.         addError("%s", _("munmap\n"));
  236.         return NULL;
  237.     }
  238.  
  239.     mmap_len = pagedbytes;
  240.     mmap_offset = pagedloc;
  241.  
  242.     // remmap or fail
  243.     if ((mmap_ptr = (uint8_t *) mmap(NULL, mmap_len, MMAP_PROT,
  244.                                      MAP_PRIVATE, fd,
  245.                                      mmap_offset)) == MAP_FAILED)
  246.     {
  247.         printf("%s", _("mmap failed\n"));
  248.         reset();
  249.         addError("%s", _("cannot memory map file\n"));
  250.         return NULL;
  251.     }
  252.     /*
  253.        fprintf(stderr,_("remapped %d from %llu @ 0x%08x\n"),
  254.        mmap_len, mmap_offset, (unsigned int)mmap_ptr);
  255.      */
  256.  
  257.     start = mmap_ptr + (location - mmap_offset);
  258.     return start;
  259. }
  260.  
  261. void Parser::clearError()
  262. {
  263.     if (error)
  264.     {
  265.         free(error);
  266.         error = NULL;
  267.     }
  268. }
  269.  
  270. void Parser::addError(const char *fmt, ...)
  271. {
  272.     char buf[1024];
  273.     va_list vaptr;
  274.     int len;
  275.     int leftoff = 0;
  276.  
  277.     if (!report_errors)
  278.         return;
  279.  
  280.     buf[0] = '\0';              // preterminate for fun
  281.  
  282.     va_start(vaptr, fmt);
  283.     vsnprintf(buf, 1024, fmt, vaptr);
  284.     va_end(vaptr);
  285.  
  286.     len = strlen(buf) + 1;      // one for NULL
  287.  
  288.     if (error)
  289.     {
  290.         leftoff = strlen(error);
  291.         len += leftoff;
  292.     }
  293.  
  294.     if (!(error = (char *) realloc(error, len)))
  295.     {
  296.         // if we can't get memory for an error, we probably
  297.         // can't do much of anything anyway.
  298.         perror("realloc");
  299.         exit(1);
  300.     }
  301.     error[leftoff] = '\0';      // terminate our (possibly) new memory
  302.  
  303.     // this is safe now, since we used add's len to allocate it
  304.     strcat(error, buf);
  305.  
  306.     // send out the stderr too
  307.     fprintf(stderr, buf);
  308. }
  309.  
  310. int Parser::consume(size_t bytes, uint8_t * match)
  311. {
  312.     // no bytes?  SURE!
  313.     if (!bytes)
  314.         return TRUE;
  315.  
  316.     if (!bytesAvail(location, bytes) || memcmp(start, match, bytes))
  317.         return FALSE;
  318.  
  319.     start += bytes;
  320.     location += bytes;
  321.  
  322.     return TRUE;
  323. }
  324.  
  325. int Parser::verify(uint8_t * source, size_t bytes, uint8_t * match)
  326. {
  327.     // no bytes?  SURE!
  328.     if (!bytes)
  329.         return TRUE;
  330.  
  331.     if (memcmp(source, match, bytes) == 0)
  332.         return TRUE;
  333.     return FALSE;
  334. }
  335.  
  336. // Returns "start" before incrementing by "bytes"
  337. uint8_t *Parser::attach(size_t bytes)
  338. {
  339.     uint8_t *ptr;
  340.  
  341.     if ((ptr = examine(bytes)))
  342.     {
  343.         start += bytes;
  344.         location += bytes;
  345.     }
  346.  
  347.     return ptr;
  348. }
  349.  
  350. // returns points to memory but does not increment
  351. uint8_t *Parser::examine(size_t bytes)
  352. {
  353.     uint8_t *ptr = NULL;
  354.  
  355.     // no bytes? bad...
  356.     if (bytes && bytesAvail(location, bytes))
  357.     {
  358.         ptr = start;
  359.     }
  360.  
  361.     return ptr;
  362. }
  363.  
  364. // Checks for "bytes" many bytes into the future to match "match"
  365. int Parser::forwardMatch(size_t bytes, uint8_t * match)
  366. {
  367.     // no bytes?  SURE!
  368.     if (!bytes)
  369.         return TRUE;
  370.  
  371.     if (bytesAvail(location, bytes) && !memcmp(start, match, bytes))
  372.     {
  373.         return TRUE;
  374.     }
  375.     else
  376.         return FALSE;
  377. }
  378.  
  379. // Checks for up to 8 bits in the next byte, matching "value"
  380. int Parser::forwardBitMatch(int bits, uint8_t value)
  381. {
  382.     uint8_t match;
  383.     uint8_t mask;
  384.  
  385.     // 0 bits?  SURE!
  386.     if (!bits)
  387.         return TRUE;
  388.  
  389.     if (!bytesAvail(location, 1))
  390.         return FALSE;
  391.  
  392.     match = value << (8 - bits);
  393.     mask = (0xFF >> (8 - bits)) << (8 - bits);
  394.  
  395.     /*
  396.        int result=((*start & mask) == match);
  397.        printf(_("*start: %d mask: %d match: %d result: %d\n"),
  398.        *start, mask, match, result);
  399.      */
  400.  
  401.     return ((*start & mask) == match);
  402. }
  403.  
  404. // external access to the parsing state.  This can only be set if 
  405. // Parser is "READY" or "PARSING".  Once set to "FINISHED", it must
  406. // be ->reset to clear it.
  407. void Parser::setParsingState(int state)
  408. {
  409.     if ((parsing_state==PARSER_STATE_READY &&
  410.          state==PARSER_STATE_PARSING) ||
  411.         (parsing_state==PARSER_STATE_PARSING &&
  412.          state==PARSER_STATE_FINISHED))
  413.     {
  414.         parsing_state=state;
  415.     }
  416. }
  417.  
  418.  
  419. /* vi:set ai ts=4 sw=4 expandtab: */
  420.