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 / file_buffer.c < prev    next >
C/C++ Source or Header  |  2003-08-25  |  6KB  |  235 lines
  1. /*
  2. #
  3. # Utilities for seeking around in a file stream
  4. #
  5. # $Id: file_buffer.c,v 1.2 2003/08/25 08:17:41 nemies Exp $
  6. #
  7. # Copyright (C) 2001-2003 Kees Cook
  8. # kees@outflux.net, http://outflux.net/
  9. # 
  10. # This program is free software; you can redistribute it and/or
  11. # modify it under the terms of the GNU General Public License
  12. # as published by the Free Software Foundation; either version 2
  13. # of the License, or (at your option) any later version.
  14. # 
  15. # This program is distributed in the hope that it will be useful,
  16. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. # GNU General Public License for more details.
  19. # 
  20. # You should have received a copy of the GNU General Public License
  21. # along with this program; if not, write to the Free Software
  22. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23. # http://www.gnu.org/copyleft/gpl.html
  24. #
  25. */
  26.  
  27. /*
  28.  * buffer management inspired by mplayer
  29.  */
  30. #include "file_buffer.h"
  31. #include <sys/types.h>
  32. #include <sys/stat.h>
  33. #include <unistd.h>
  34.  
  35. struct file_buf_t
  36. {
  37.     char * filename;
  38.     FILE *fp;
  39.     uint8_t * buffer;
  40.     off_t offset;
  41.     size_t buffer_min;
  42.     size_t buffer_max;
  43.     size_t buffer_malloc;
  44. };
  45.  
  46. off_t buffer_tell(struct file_buf_t *fb)
  47. {
  48.     if (!fb) return 0;
  49.     return fb->offset - fb->buffer_max + fb->buffer_min;
  50. }
  51.  
  52. off_t buffer_file_size(struct file_buf_t *fb)
  53. {
  54.     struct stat info;
  55.  
  56.     if (!fb) return 0;
  57.     if (!(fstat(fileno(fb->fp), &info))<0) {
  58.         perror("fstat");
  59.         exit(1);
  60.     }
  61.     return info.st_size;
  62. }
  63.  
  64. // can point to a file offset to refill from
  65. int buffer_refill(struct file_buf_t *fb)
  66. {
  67.     size_t got;
  68.  
  69.     if (!fb)
  70.         return FILE_BUF_ERR_NULL_STRUCT;
  71.  
  72.     //fprintf(stderr,"filling...\n");
  73.  
  74.     if (fb->buffer_min < fb->buffer_max)
  75.     {
  76.         memmove(fb->buffer, fb->buffer + fb->buffer_min,
  77.                             fb->buffer_max - fb->buffer_min);
  78.     }
  79.     fb->buffer_max -= fb->buffer_min;
  80.     fb->buffer_min = 0;
  81.  
  82.     got =
  83.         fread(fb->buffer + fb->buffer_max, sizeof(uint8_t),
  84.               fb->buffer_malloc - fb->buffer_max, fb->fp);
  85.     if (got < 0)
  86.         return FILE_BUF_ERR_READ;
  87.  
  88.     fb->offset += got;
  89.     fb->buffer_max += got;
  90.  
  91.     //fprintf(stderr,"bump %d more\n",got);
  92.     return FILE_BUF_OKAY;
  93. }
  94.  
  95. int buffer_seek(struct file_buf_t *fb, off_t location)
  96. {
  97.     if (!fb)
  98.         return FILE_BUF_ERR_NULL_STRUCT;
  99.  
  100.     // is this location within our current buffer?
  101.     if (location < fb->offset && location >= buffer_tell(fb)) {
  102.         fb->buffer_min += location - buffer_tell(fb);
  103.     }
  104.     else {
  105.         // outside: clear the buffer 
  106.         fb->buffer_min = fb->buffer_max = 0;    // clear buffer
  107.         fb->offset = location;
  108.         if (FSEEK(fb->fp, fb->offset, SEEK_SET) < 0) {
  109.             return FILE_BUF_ERR_SEEK;
  110.         }
  111.     }
  112.     //don't do this... way too slow
  113.     //buffer_refill();
  114.     return FILE_BUF_OKAY;
  115. }
  116.  
  117. // A null return from "buffer_start" indicates that errno has been set,
  118. // and calls to "perror" and the like are valid.
  119. struct file_buf_t * buffer_start(struct file_buf_t *fb, char *filename,
  120.                                  size_t size)
  121. {
  122.     FILE * fp=NULL;
  123.     uint8_t * buffer=NULL;
  124.  
  125.     // check for fopen first, before dealing with memory allocation or
  126.     // making changes to the passed-in structure
  127.     if (!(fp = fopen(filename, "r"))) {
  128.         goto err_out;
  129.     }
  130.     if (!fb || fb->buffer_malloc != size) {
  131.         if (!(buffer=(uint8_t*)calloc(size,sizeof(uint8_t)))) {
  132.             goto err_out;
  133.         }
  134.     }
  135.     // create a buffer if it doesn't already exist
  136.     if (!fb) {
  137.         if (!(fb=(struct file_buf_t*)calloc(1,sizeof(*fb)))) {
  138.             goto err_out;
  139.         }
  140.     }
  141.     // swap out the new file handle
  142.     if (fb->fp)
  143.         fclose(fb->fp);
  144.     fb->fp = fp;
  145.  
  146.     // swap out the new buffer
  147.     if (buffer) {
  148.         // drop the old buffer if we have a new one
  149.         if (fb->buffer)
  150.             free(fb->buffer);
  151.         fb->buffer = buffer;
  152.     }
  153.     // record our buffer size
  154.     fb->buffer_malloc = size;
  155.  
  156.     // clear our counters
  157.     fb->offset = 0;
  158.     fb->buffer_min = 0;
  159.     fb->buffer_max = 0;
  160.  
  161.     return fb;
  162.  
  163. err_out:
  164.     if (buffer)
  165.         free(buffer);
  166.     if (fp)
  167.         fclose(fp);
  168.     buffer_end(fb); // hm: well I guess I *will* muck with the passed in one
  169.     return NULL;
  170. }
  171.  
  172. int buffer_end(struct file_buf_t *fb)
  173. {
  174.     if (!fb)
  175.         return FILE_BUF_ERR_NULL_STRUCT;
  176.  
  177.     if (fb->fp)
  178.         fclose(fb->fp);
  179.     if (fb->buffer)
  180.         free(fb->buffer);
  181.     free(fb);
  182.  
  183.     return FILE_BUF_OKAY;
  184. }
  185.  
  186. int buffer_get_byte(struct file_buf_t *fb, uint8_t * byte)
  187. {
  188.     int ret;
  189.  
  190.     if (!fb)
  191.         return FILE_BUF_ERR_NULL_STRUCT;
  192.     if (!byte)
  193.         return FILE_BUF_ERR_NULL_ARG;
  194.  
  195.     if (fb->buffer_min == fb->buffer_max) {
  196.         if ((ret=buffer_refill(fb))!=FILE_BUF_OKAY)
  197.             return ret;
  198.     }
  199.     if (fb->buffer_min == fb->buffer_max)
  200.         return FILE_BUF_ERR_PAST_END;
  201.  
  202.     //fprintf(stderr,"getting %" OFF_T_FORMAT "\n",buffer_tell(fb));
  203.     *byte = fb->buffer[fb->buffer_min++];
  204.     return FILE_BUF_OKAY;
  205. }
  206.  
  207. int buffer_look_ahead(struct file_buf_t *fb, uint8_t * bytes, size_t count)
  208. {
  209.     if (!fb)
  210.         return FILE_BUF_ERR_NULL_STRUCT;
  211.     if (!bytes)
  212.         return FILE_BUF_ERR_NULL_ARG;
  213.     if (count >= fb->buffer_malloc)
  214.         return FILE_BUF_ERR_COUNT_EXCEEDS_BUFFER_SIZE;
  215.  
  216.     if (fb->buffer_min + count > fb->buffer_max)
  217.         buffer_refill(fb);
  218.     if (fb->buffer_min + count > fb->buffer_max)
  219.         return FILE_BUF_ERR_PAST_END;
  220.  
  221.     memcpy(bytes,fb->buffer+fb->buffer_min,count);
  222.     /*
  223.      * for debugging:
  224.     for (i = 0; i < count; i++)
  225.     {
  226.         *(bytes++) = fb->buffer[fb->buffer_min + i];
  227.         //fprintf(stderr,"\tsaw: 0x%02X\n",buffer[buffer_min+i]);
  228.     }
  229.     */
  230.  
  231.     return FILE_BUF_OKAY;
  232. }
  233.  
  234. /* vi:set ai ts=4 sw=4 expandtab: */
  235.