Main Page | Modules | Data Structures | Directories | File List | Data Fields | Globals

iomem.c

Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2005, 2006 by KoanLogic s.r.l. <http://www.koanlogic.com>
00003  * All rights reserved.
00004  *
00005  * This file is part of KLone, and as such it is subject to the license stated
00006  * in the LICENSE file which you have received as part of this distribution.
00007  *
00008  * $Id: iomem.c,v 1.8 2006/01/09 12:38:38 tat Exp $
00009  */
00010 
00011 #include "klone_conf.h"
00012 #include <unistd.h>
00013 #include <u/libu.h>
00014 #include <klone/io.h>
00015 #include <klone/io.h>
00016 #include <klone/ioprv.h>
00017 
00018 struct io_mem_s
00019 {
00020     struct io_s io; /* must be the first item */
00021     char *buf;
00022     size_t size;
00023     size_t off;
00024     int flags;
00025 };
00026 
00027 typedef struct io_mem_s io_mem_t;
00028 
00029 static ssize_t io_mem_read(io_mem_t *io, char *buf, size_t size);
00030 static ssize_t io_mem_write(io_mem_t *io, const char *buf, size_t size);
00031 static ssize_t io_mem_seek(io_mem_t *io, size_t off);
00032 static ssize_t io_mem_tell(io_mem_t *im);
00033 static int io_mem_term(io_mem_t *io);
00034 
00035 static ssize_t io_mem_tell(io_mem_t *im)
00036 {
00037     dbg_return_if (im == NULL, -1);
00038 
00039     return im->off;
00040 }
00041 
00042 static ssize_t io_mem_seek(io_mem_t *im, size_t off)
00043 {
00044     dbg_return_if (im == NULL, -1);
00045     
00046     if(off >= im->size)
00047         return -1;
00048 
00049     im->off = off;
00050 
00051     return off;
00052 }
00053 
00054 static ssize_t io_mem_read(io_mem_t *im, char *buf, size_t size)
00055 {
00056     char *ptr;
00057     size_t sz;
00058 
00059     dbg_return_if (im == NULL, -1);
00060     dbg_return_if (buf == NULL, -1);
00061 
00062     sz = MIN(size, im->size - im->off);
00063     if(sz)
00064     {
00065         ptr = im->buf + im->off; 
00066         memcpy(buf, ptr, sz);
00067         im->off += sz;
00068     }
00069 
00070     return sz;
00071 }
00072 
00073 static ssize_t io_mem_write(io_mem_t *im, const char *buf, size_t size)
00074 {
00075     char *ptr;
00076     size_t sz;
00077 
00078     dbg_return_if (im == NULL, -1);
00079     dbg_return_if (buf == NULL, -1);
00080 
00081     sz = MIN(size, im->size - im->off);
00082     if(sz)
00083     {
00084         ptr = im->buf + im->off; 
00085         memcpy(ptr, buf, sz);
00086         im->off += sz;
00087     }
00088 
00089     return sz;
00090 }
00091 
00092 static int io_mem_term(io_mem_t *im)
00093 {
00094     dbg_return_if (im == NULL, ~0);
00095 
00096     if(im->flags & IO_MEM_FREE_BUF)
00097     {
00098         U_FREE(im->buf);
00099         im->buf = NULL;
00100         im->size = im->off = 0;
00101     }
00102 
00103     return 0;
00104 }
00105 
00106 int io_mem_create(char *buf, size_t size, int flags, io_t **pio)
00107 {
00108     io_mem_t *im = NULL;
00109 
00110     dbg_err_if (buf == NULL);
00111     dbg_err_if (pio == NULL);
00112     
00113     dbg_err_if(io_create(io_mem_t, (io_t**)&im));
00114 
00115     im->buf = buf;
00116     im->size = size;
00117     im->flags = flags;
00118     im->off = 0;
00119     im->io.read = (io_read_op) io_mem_read;
00120     im->io.write = (io_write_op) io_mem_write;
00121     im->io.seek = (io_seek_op) io_mem_seek;
00122     im->io.tell = (io_tell_op) io_mem_tell;
00123     im->io.term = (io_term_op) io_mem_term; 
00124 
00125     *pio = (io_t*)im;
00126 
00127     return 0;
00128 err:
00129     if(im)
00130         io_free((io_t *)im);
00131     return ~0;
00132 }

←Products
© 2005-2006 - KoanLogic S.r.l. - All rights reserved