Changeset 97

Show
Ignore:
Timestamp:
02/20/06 20:28:19
Author:
pvanhoof
Message:

gnome vfs stream

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/libtinymail-gnomevfs/Makefile.am

    r96 r97  
    55 
    66libtinymail_gnomevfs_1_0_headers =              \ 
    7         tny-stream-gnomevfs.h 
     7        tny-vfs-stream.h 
    88 
    99libtinymail_gnomevfs_1_0_la_SOURCES =           \ 
    1010        $(libtinymail_gnomevfs_1_0_headers)     \ 
    11         tny-stream-gnomevfs.c 
     11        tny-vfs-stream.c 
    1212 
    1313libtinymail_gnomevfs_1_0_la_LIBADD =            \ 

  • trunk/libtinymail-gnomevfs/tny-vfs-stream.c

    r96 r97  
     1/* libtinymail - The Tiny Mail base library 
     2 * Copyright (C) 2006-2007 Philip Van Hoof <pvanhoof@gnome.org> 
     3 * 
     4 * This library is free software; you can redistribute it and/or 
     5 * modify it under the terms of the GNU Lesser General Public 
     6 * License as published by the Free Software Foundation; either 
     7 * version 2 of the License, or (at your option) any later version. 
     8 * 
     9 * This library is distributed in the hope that it will be useful, 
     10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
     12 * Lesser General Public License for more details. 
     13 * 
     14 * You should have received a copy of the GNU Lesser General Public 
     15 * License along with self library; if not, write to the 
     16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
     17 * Boston, MA 02111-1307, USA. 
     18 */ 
     19 
     20#include <string.h> 
     21#include <stdio.h> 
     22#include <errno.h> 
     23 
     24#include <tny-stream-iface.h> 
     25#include <tny-vfs-stream.h> 
     26 
     27static GObjectClass *parent_class = NULL; 
     28 
     29typedef struct _TnyVfsStreamPriv TnyVfsStreamPriv; 
     30 
     31struct _TnyVfsStreamPriv 
     32{ 
     33        GnomeVFSHandle *handle; 
     34}; 
     35 
     36#define TNY_VFS_STREAM_GET_PRIVATE(o)   \ 
     37        (G_TYPE_INSTANCE_GET_PRIVATE ((o), TNY_VFS_STREAM_TYPE, TnyVfsStreamPriv)) 
     38 
     39 
     40static void 
     41tny_vfs_stream_set_errno (GnomeVFSResult res) 
     42{ 
     43        switch(res) { 
     44        case GNOME_VFS_OK: 
     45                g_warning("tny-vfs-stream: calling set_errno with no error"); 
     46                break; 
     47        case GNOME_VFS_ERROR_NOT_FOUND: 
     48        case GNOME_VFS_ERROR_HOST_NOT_FOUND: 
     49        case GNOME_VFS_ERROR_INVALID_HOST_NAME: 
     50        case GNOME_VFS_ERROR_HOST_HAS_NO_ADDRESS: 
     51        case GNOME_VFS_ERROR_SERVICE_NOT_AVAILABLE: 
     52                errno = ENOENT; 
     53                break; 
     54        case GNOME_VFS_ERROR_GENERIC: 
     55        case GNOME_VFS_ERROR_INTERNAL: 
     56        case GNOME_VFS_ERROR_IO: 
     57        case GNOME_VFS_ERROR_EOF: /* will be caught by read before here anyway */ 
     58        case GNOME_VFS_ERROR_SERVICE_OBSOLETE: 
     59        case GNOME_VFS_ERROR_PROTOCOL_ERROR: 
     60        default: 
     61                errno = EIO; 
     62                break; 
     63        case GNOME_VFS_ERROR_BAD_PARAMETERS: 
     64        case GNOME_VFS_ERROR_NOT_SUPPORTED: 
     65        case GNOME_VFS_ERROR_INVALID_URI: 
     66        case GNOME_VFS_ERROR_NOT_OPEN: 
     67        case GNOME_VFS_ERROR_INVALID_OPEN_MODE: 
     68        case GNOME_VFS_ERROR_NOT_SAME_FILE_SYSTEM: 
     69                errno = EINVAL; 
     70                break; 
     71        case GNOME_VFS_ERROR_CORRUPTED_DATA: /* not sure about these */ 
     72        case GNOME_VFS_ERROR_WRONG_FORMAT: 
     73        case GNOME_VFS_ERROR_BAD_FILE: 
     74                errno = EBADF; 
     75                break; 
     76        case GNOME_VFS_ERROR_TOO_BIG: 
     77                errno = E2BIG; 
     78                break; 
     79        case GNOME_VFS_ERROR_NO_SPACE: 
     80                errno = ENOSPC; 
     81                break; 
     82        case GNOME_VFS_ERROR_READ_ONLY: 
     83        case GNOME_VFS_ERROR_READ_ONLY_FILE_SYSTEM: 
     84                errno = EROFS; 
     85                break; 
     86        case GNOME_VFS_ERROR_TOO_MANY_OPEN_FILES: 
     87                errno = EMFILE; 
     88                break; 
     89        case GNOME_VFS_ERROR_NOT_A_DIRECTORY: 
     90                errno = ENOTDIR; 
     91                break; 
     92        case GNOME_VFS_ERROR_IN_PROGRESS: 
     93                errno = EINPROGRESS; 
     94                break; 
     95        case GNOME_VFS_ERROR_INTERRUPTED: 
     96                errno = EINTR; 
     97                break; 
     98        case GNOME_VFS_ERROR_FILE_EXISTS: 
     99                errno = EEXIST; 
     100        case GNOME_VFS_ERROR_LOOP: 
     101                errno = ELOOP; 
     102                break; 
     103        case GNOME_VFS_ERROR_ACCESS_DENIED: 
     104        case GNOME_VFS_ERROR_NOT_PERMITTED: 
     105        case GNOME_VFS_ERROR_LOGIN_FAILED: 
     106                errno = EPERM; 
     107                break; 
     108        case GNOME_VFS_ERROR_IS_DIRECTORY: 
     109        case GNOME_VFS_ERROR_DIRECTORY_NOT_EMPTY: /* ?? */ 
     110                errno = EISDIR; 
     111                break; 
     112        case GNOME_VFS_ERROR_NO_MEMORY: 
     113                errno = ENOMEM; 
     114                break; 
     115        case GNOME_VFS_ERROR_CANCELLED: 
     116                errno = EINTR; 
     117                break; 
     118        case GNOME_VFS_ERROR_DIRECTORY_BUSY: 
     119                errno = EBUSY; 
     120                break; 
     121        case GNOME_VFS_ERROR_TOO_MANY_LINKS: 
     122                errno = EMLINK; 
     123                break; 
     124        case GNOME_VFS_ERROR_NAME_TOO_LONG: 
     125                errno = ENAMETOOLONG; 
     126                break; 
     127        } 
     128} 
     129 
     130static ssize_t 
     131tny_vfs_stream_write_to_stream (TnyStreamIface *self, TnyStreamIface *output) 
     132{ 
     133        char tmp_buf[4096]; 
     134        ssize_t total = 0; 
     135        ssize_t nb_read; 
     136        ssize_t nb_written; 
     137         
     138        while (!tny_stream_iface_eos (self)) { 
     139                nb_read = tny_stream_iface_read (self, tmp_buf, sizeof (tmp_buf)); 
     140                if (nb_read < 0) 
     141                        return -1; 
     142                else if (nb_read > 0) { 
     143                        nb_written = 0; 
     144         
     145                        while (nb_written < nb_read) { 
     146                                ssize_t len = tny_stream_iface_write (output, tmp_buf + nb_written, 
     147                                                                  nb_read - nb_written); 
     148                                if (len < 0) 
     149                                        return -1; 
     150                                nb_written += len; 
     151                        } 
     152                        total += nb_written; 
     153                } 
     154        } 
     155        return total; 
     156} 
     157 
     158static ssize_t 
     159tny_vfs_stream_read  (TnyStreamIface *self, char *buffer, size_t n) 
     160{ 
     161        TnyVfsStreamPriv *priv = TNY_VFS_STREAM_GET_PRIVATE (self); 
     162        GnomeVFSFileSize count; 
     163        GnomeVFSResult res; 
     164 
     165        if (priv->handle == NULL)  
     166        { 
     167                errno = EINVAL; 
     168                return -1; 
     169        } 
     170 
     171        res = gnome_vfs_read (priv->handle, buffer, n, &count); 
     172 
     173        if (res == GNOME_VFS_OK) 
     174        { 
     175                return (ssize_t)count; 
     176 
     177        } else if (res == GNOME_VFS_ERROR_EOF)  
     178        { 
     179                /* stream->eos = TRUE; */ 
     180                return 0; 
     181        } 
     182 
     183        tny_vfs_stream_set_errno (res); 
     184 
     185        return -1; 
     186} 
     187 
     188static ssize_t 
     189tny_vfs_stream_write (TnyStreamIface *self, const char *buffer, size_t n) 
     190{ 
     191        TnyVfsStreamPriv *priv = TNY_VFS_STREAM_GET_PRIVATE (self); 
     192        GnomeVFSFileSize count; 
     193        GnomeVFSResult res; 
     194 
     195        if (priv->handle == NULL)  
     196        { 
     197                errno = EINVAL; 
     198                return -1; 
     199        } 
     200 
     201        res = gnome_vfs_write (priv->handle, buffer, n, &count); 
     202 
     203        if (res == GNOME_VFS_OK) 
     204                return (ssize_t)count; 
     205 
     206        tny_vfs_stream_set_errno (res); 
     207 
     208        return -1; 
     209 
     210} 
     211 
     212static gint 
     213tny_vfs_stream_close (TnyStreamIface *self) 
     214{ 
     215        TnyVfsStreamPriv *priv = TNY_VFS_STREAM_GET_PRIVATE (self); 
     216        GnomeVFSResult res; 
     217 
     218        if (priv->handle == NULL)  
     219        { 
     220                errno = EINVAL; 
     221                return -1; 
     222        } 
     223 
     224        res = gnome_vfs_close(priv->handle); 
     225 
     226        priv->handle = NULL; 
     227 
     228        if (res == GNOME_VFS_OK) 
     229                return 0; 
     230 
     231        tny_vfs_stream_set_errno (res); 
     232 
     233        return -1; 
     234} 
     235 
     236/* 
     237 
     238static off_t 
     239tny_vfs_stream_seek (TnySeekableStream *stream, off_t offset, TnyStreamSeekPolicy policy) 
     240{ 
     241        TnyVfsStreamPriv *priv = TNY_VFS_STREAM_GET_PRIVATE (self); 
     242        GnomeVFSSeekPosition vpolicy; 
     243        GnomeVFSFileSize pos; 
     244        GnomeVFSResult res; 
     245 
     246        if (priv->handle == NULL)  
     247        { 
     248                errno = EINVAL; 
     249                return -1; 
     250        } 
     251 
     252        switch (policy)  
     253        { 
     254                case TNY_STREAM_SET: 
     255                default: 
     256                        vpolicy = GNOME_VFS_SEEK_START; 
     257                        break; 
     258                case TNY_STREAM_CUR: 
     259                        vpolicy = GNOME_VFS_SEEK_CURRENT; 
     260                        break; 
     261                case TNY_STREAM_END: 
     262                        vpolicy = GNOME_VFS_SEEK_END; 
     263                        break; 
     264        } 
     265 
     266        if ( (res = gnome_vfs_seek (priv->handle, vpolicy, offset)) == GNOME_VFS_OK 
     267             && (res = gnome_vfs_tell(priv->handle, &pos)) == GNOME_VFS_OK) 
     268                return pos; 
     269 
     270        tny_vfs_stream_set_errno (res); 
     271 
     272        return -1; 
     273} 
     274 
     275static off_t 
     276tny_vfs_stream_tell (TnySeekableStream *stream) 
     277{ 
     278        TnyVfsStreamPriv *priv = TNY_VFS_STREAM_GET_PRIVATE (self); 
     279        GnomeVFSFileSize pos; 
     280        GnomeVFSResult res; 
     281 
     282        if (priv->handle == NULL)  
     283        { 
     284                errno = EINVAL; 
     285                return -1; 
     286        } 
     287 
     288        if ((res = gnome_vfs_tell (priv->handle, &pos)) == GNOME_VFS_OK) 
     289                return pos; 
     290 
     291        tny_vfs_stream_set_errno (res); 
     292 
     293        return -1; 
     294} 
     295 
     296*/ 
     297 
     298void 
     299tny_vfs_stream_set_handle (TnyVfsStream *self, GnomeVFSHandle *handle) 
     300{ 
     301        TnyVfsStreamPriv *priv = TNY_VFS_STREAM_GET_PRIVATE (self); 
     302 
     303        if (priv->handle) 
     304                g_object_unref (G_OBJECT (priv->handle)); 
     305 
     306        g_object_ref (G_OBJECT (handle)); 
     307        priv->handle = handle; 
     308 
     309        tny_vfs_stream_reset_priv (priv); 
     310 
     311        return; 
     312} 
     313 
     314 
     315TnyVfsStream* 
     316tny_vfs_stream_new (GnomeVFSHandle *handle) 
     317{ 
     318        TnyVfsStream *self = g_object_new (TNY_VFS_STREAM_TYPE, NULL); 
     319 
     320        tny_vfs_stream_set_handle (self, handle); 
     321 
     322        return self; 
     323} 
     324 
     325static void 
     326tny_vfs_stream_instance_init (GTypeInstance *instance, gpointer g_class) 
     327{ 
     328        TnyVfsStream *self = (TnyVfsStream *)instance; 
     329        TnyVfsStreamPriv *priv = TNY_VFS_STREAM_GET_PRIVATE (self); 
     330 
     331        priv->handle = NULL; 
     332 
     333        return; 
     334} 
     335 
     336static void 
     337tny_vfs_stream_finalize (GObject *object) 
     338{ 
     339        TnyVfsStream *self = (TnyVfsStream *)object;     
     340        TnyVfsStreamPriv *priv = TNY_VFS_STREAM_GET_PRIVATE (self); 
     341 
     342        if (priv->handle) 
     343                gnome_vfs_close (priv->handle); 
     344 
     345        (*parent_class->finalize) (object); 
     346 
     347        return; 
     348} 
     349 
     350static void 
     351tny_stream_iface_init (gpointer g_iface, gpointer iface_data) 
     352{ 
     353        TnyStreamIfaceClass *klass = (TnyStreamIfaceClass *)g_iface; 
     354 
     355        klass->read_func = tny_vfs_stream_read; 
     356        klass->write_func = tny_vfs_stream_write; 
     357        klass->close_func = tny_vfs_stream_close; 
     358        klass->write_to_stream_func = tny_vfs_stream_write_to_stream; 
     359 
     360        return; 
     361} 
     362 
     363static void  
     364tny_vfs_stream_class_init (TnyVfsStreamClass *class) 
     365{ 
     366        GObjectClass *object_class; 
     367 
     368        parent_class = g_type_class_peek_parent (class); 
     369        object_class = (GObjectClass*) class; 
     370 
     371        object_class->finalize = tny_vfs_stream_finalize; 
     372 
     373        g_type_class_add_private (object_class, sizeof (TnyVfsStreamPriv)); 
     374 
     375        return; 
     376} 
     377 
     378GType  
     379tny_vfs_stream_get_type (void) 
     380{ 
     381        static GType type = 0; 
     382 
     383        if (type == 0)  
     384        { 
     385                static const GTypeInfo info =  
     386                { 
     387                  sizeof (TnyVfsStreamClass), 
     388                  NULL,   /* base_init */ 
     389                  NULL,   /* base_finalize */ 
     390                  (GClassInitFunc) tny_vfs_stream_class_init,   /* class_init */ 
     391                  NULL,   /* class_finalize */ 
     392                  NULL,   /* class_data */ 
     393                  sizeof (TnyVfsStream), 
     394                  0,      /* n_preallocs */ 
     395                  tny_vfs_stream_instance_init    /* instance_init */ 
     396                }; 
     397 
     398                static const GInterfaceInfo tny_stream_iface_info =  
     399                { 
     400                  (GInterfaceInitFunc) tny_stream_iface_init, /* interface_init */ 
     401                  NULL,         /* interface_finalize */ 
     402                  NULL          /* interface_data */ 
     403                }; 
     404 
     405                type = g_type_register_static (G_TYPE_OBJECT, 
     406                        "TnyVfsStream", 
     407                        &info, 0); 
     408 
     409                g_type_add_interface_static (type, TNY_STREAM_IFACE_TYPE,  
     410                        &tny_stream_iface_info); 
     411        } 
     412 
     413        return type; 
     414} 

  • trunk/libtinymail-gnomevfs/tny-vfs-stream.h

    r96 r97  
     1#ifndef TNY_VFS_STREAM_H 
     2#define TNY_VFS_STREAM_H 
     3 
     4/* libtinymail - The Tiny Mail base library 
     5 * Copyright (C) 2006-2007 Philip Van Hoof <pvanhoof@gnome.org> 
     6 * 
     7 * This library is free software; you can redistribute it and/or 
     8 * modify it under the terms of the GNU Lesser General Public 
     9 * License as published by the Free Software Foundation; either 
     10 * version 2 of the License, or (at your option) any later version. 
     11 * 
     12 * This library is distributed in the hope that it will be useful, 
     13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
     15 * Lesser General Public License for more details. 
     16 * 
     17 * You should have received a copy of the GNU Lesser General Public 
     18 * License along with self library; if not, write to the 
     19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
     20 * Boston, MA 02111-1307, USA. 
     21 */ 
     22 
     23#include <glib.h> 
     24#include <libgnomevfs/gnome-vfs.h> 
     25#include <glib-object.h> 
     26 
     27#include <tny-stream-iface.h> 
     28 
     29G_BEGIN_DECLS 
     30 
     31#define TNY_VFS_STREAM_TYPE             (tny_vfs_stream_get_type ()) 
     32#define TNY_VFS_STREAM(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), TNY_VFS_STREAM_TYPE, TnyVfsStream)) 
     33#define TNY_VFS_STREAM_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), TNY_VFS_STREAM_TYPE, TnyVfsStreamClass)) 
     34#define TNY_IS_VFS_STREAM(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TNY_VFS_STREAM_TYPE)) 
     35#define TNY_IS_VFS_STREAM_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), TNY_VFS_STREAM_TYPE)) 
     36#define TNY_VFS_STREAM_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), TNY_VFS_STREAM_TYPE, TnyVfsStreamClass)) 
     37 
     38typedef struct _TnyVfsStream TnyVfsStream; 
     39typedef struct _TnyVfsStreamClass TnyVfsStreamClass; 
     40 
     41struct _TnyVfsStream 
     42{ 
     43        GObject parent; 
     44}; 
     45 
     46struct _TnyVfsStreamClass  
     47{ 
     48        GObjectClass parent; 
     49}; 
     50 
     51GType                   tny_vfs_stream_get_type        (void); 
     52TnyVfsStream*           tny_vfs_stream_new             (GnomeVFSHandle *handle); 
     53 
     54void                    tny_vfs_stream_set_handle (TnyVfsStream *self, GnomeVFSHandle *handle); 
     55 
     56G_END_DECLS 
     57 
     58#endif 
     59