Return to iso9660_read.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / iso9660

Annotation of qemu/roms/openbios/fs/iso9660/iso9660_read.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *
                      3:  * (c) 2005-2009 Laurent Vivier <[email protected]>
                      4:  *
                      5:  * This file has been copied from EMILE, http://emile.sf.net
                      6:  *
                      7:  */
                      8: 
                      9: #include "libiso9660.h"
                     10: #include "libopenbios/bindings.h"
                     11: #include "libc/diskio.h"
                     12: 
                     13: size_t iso9660_read(iso9660_FILE *_file, char *buf, size_t count)
                     14: {
                     15:        iso9660_FILE *file = (iso9660_FILE*)_file;
                     16:        size_t read = 0;
                     17: 
                     18:        if ( count > (file->size  - file->offset) )
                     19:                count = file->size  - file->offset;
                     20: 
                     21:        while (count > 0)
                     22:        {
                     23:                size_t part;
                     24:                int offset_extent;
                     25:                int offset_index;
                     26: 
                     27:                offset_extent = file->base +
                     28:                                    (file->offset / ISOFS_BLOCK_SIZE);
                     29:                offset_index = file->offset % ISOFS_BLOCK_SIZE;
                     30: 
                     31:                if (file->current != offset_extent)
                     32:                {
                     33:                        if ( (offset_index == 0) &&
                     34:                             (count >= ISOFS_BLOCK_SIZE) )
                     35:                        {
                     36:                                /* direct i/o */
                     37: 
                     38:                                int extents_nb;
                     39: 
                     40:                                extents_nb = count / ISOFS_BLOCK_SIZE;
                     41: 
                     42:                                part = extents_nb * ISOFS_BLOCK_SIZE;
                     43: 
                     44:                                seek_io(file->volume->fd,
                     45:                                        offset_extent * ISOFS_BLOCK_SIZE);
                     46:                                read_io(file->volume->fd, buf + read, part);
                     47: 
                     48:                                file->offset += part;
                     49:                                count -= part;
                     50:                                read += part;
                     51: 
                     52:                                continue;
                     53:                        }
                     54: 
                     55:                        file->current = offset_extent;
                     56:                        seek_io(file->volume->fd,
                     57:                                offset_extent * ISOFS_BLOCK_SIZE);
                     58:                        read_io(file->volume->fd, file->buffer,
                     59:                                ISOFS_BLOCK_SIZE);
                     60:                }
                     61: 
                     62:                part = ISOFS_BLOCK_SIZE - offset_index;
                     63:                if (count < part)
                     64:                        part = count;
                     65: 
                     66:                memcpy(buf + read, file->buffer + offset_index, part);
                     67: 
                     68:                file->offset += part;
                     69:                count -= part;
                     70:                read += part;
                     71:        }
                     72: 
                     73:        return read;
                     74: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.