5bc4d77a8feafc58875292d36a44c105a5d72596
[captive.git] / src / client / libcaptive-gnomevfs / giognomevfs.c
1 /* $Id$
2  * glib GIOChannel interface over gnome-vfs GnomeVFSURI for libcaptive
3  * Copyright (C) 2002 Jan Kratochvil <project-captive@jankratochvil.net>
4  * 
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; exactly version 2 of June 1991 is required
8  * 
9  * This program 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
12  * GNU General Public License for more details.
13  * 
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  */
18
19
20 #include "config.h"
21
22 #include "captive/macros.h"
23 #include <libgnomevfs/gnome-vfs-method.h>
24 #include <libgnomevfs/gnome-vfs-ops.h>
25 #include <glib/gmessages.h>
26 #include "captive/client.h"
27 #include "gnome-vfs-module.h"
28
29
30 /* FIXME: fill 'err' */
31
32 struct captive_gnomevfs_giognomevfs {
33         GIOChannel iochannel;
34         GnomeVFSHandle *gnomevfshandle;
35         };
36
37 G_LOCK_DEFINE_STATIC(giochannel_funcs);
38 static GIOFuncs giochannel_funcs;
39
40
41 static gboolean validate_giognomevfs(struct captive_gnomevfs_giognomevfs *giognomevfs)
42 {
43         g_return_val_if_fail(giognomevfs!=NULL,FALSE);
44         g_return_val_if_fail(giognomevfs->gnomevfshandle!=NULL,FALSE);
45
46         return TRUE;
47 }
48
49
50 static GIOStatus captive_gnomevfs_giognomevfs_io_read
51                 (GIOChannel *channel,gchar *buf,gsize count,gsize *bytes_read,GError **err)
52 {
53 struct captive_gnomevfs_giognomevfs *giognomevfs=(struct captive_gnomevfs_giognomevfs *)channel;
54 GnomeVFSResult errvfsresult;
55 GnomeVFSFileSize bytes_read_local;
56
57         g_return_val_if_fail(validate_giognomevfs(giognomevfs),G_IO_STATUS_ERROR);
58         g_return_val_if_fail(buf!=NULL,G_IO_STATUS_ERROR);
59         g_return_val_if_fail(bytes_read!=NULL,G_IO_STATUS_ERROR);
60
61         errvfsresult=gnome_vfs_read(
62                         giognomevfs->gnomevfshandle,    /* handle */
63                         buf,    /* buffer */
64                         count,  /* bytes */
65                         &bytes_read_local);     /* bytes_read */
66         g_return_val_if_fail((errvfsresult==GNOME_VFS_OK || errvfsresult==GNOME_VFS_ERROR_EOF),G_IO_STATUS_ERROR);
67
68         *bytes_read=bytes_read_local;
69         return (errvfsresult==GNOME_VFS_ERROR_EOF ? G_IO_STATUS_EOF : G_IO_STATUS_NORMAL);
70 }
71
72
73 static GIOStatus captive_gnomevfs_giognomevfs_io_write
74                 (GIOChannel *channel,const gchar *buf,gsize count,gsize *bytes_written,GError **err)
75 {
76 struct captive_gnomevfs_giognomevfs *giognomevfs=(struct captive_gnomevfs_giognomevfs *)channel;
77 GnomeVFSResult errvfsresult;
78 GnomeVFSFileSize bytes_written_local;
79
80         g_return_val_if_fail(validate_giognomevfs(giognomevfs),G_IO_STATUS_ERROR);
81         g_return_val_if_fail(buf!=NULL,G_IO_STATUS_ERROR);
82         g_return_val_if_fail(bytes_written!=NULL,G_IO_STATUS_ERROR);
83
84         errvfsresult=gnome_vfs_write(
85                         giognomevfs->gnomevfshandle,    /* handle */
86                         buf,    /* buffer */
87                         count,  /* bytes */
88                         &bytes_written_local);  /* bytes_written */
89         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,G_IO_STATUS_ERROR);
90
91         *bytes_written=bytes_written_local;
92         return G_IO_STATUS_NORMAL;
93 }
94
95
96 static GIOStatus captive_gnomevfs_giognomevfs_io_seek(GIOChannel *channel,gint64 offset,GSeekType type,GError **err)
97 {
98 struct captive_gnomevfs_giognomevfs *giognomevfs=(struct captive_gnomevfs_giognomevfs *)channel;
99 GnomeVFSSeekPosition whence;
100 GnomeVFSResult errvfsresult;
101
102         g_return_val_if_fail(validate_giognomevfs(giognomevfs),G_IO_STATUS_ERROR);
103
104         switch (type) {
105                 case G_SEEK_CUR: whence=GNOME_VFS_SEEK_CURRENT; break;
106                 case G_SEEK_SET: whence=GNOME_VFS_SEEK_START;   break;
107                 case G_SEEK_END: whence=GNOME_VFS_SEEK_END;     break;
108                 default: g_return_val_if_reached(G_IO_STATUS_ERROR);
109                 }
110         errvfsresult=gnome_vfs_seek(giognomevfs->gnomevfshandle,whence,offset);
111         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,G_IO_STATUS_ERROR);
112
113         return G_IO_STATUS_NORMAL;
114 }
115
116
117 static GIOStatus captive_gnomevfs_giognomevfs_io_close(GIOChannel *channel,GError **err)
118 {
119 struct captive_gnomevfs_giognomevfs *giognomevfs=(struct captive_gnomevfs_giognomevfs *)channel;
120
121         g_return_val_if_fail(validate_giognomevfs(giognomevfs),G_IO_STATUS_ERROR);
122
123         gnome_vfs_close(giognomevfs->gnomevfshandle);
124
125         return G_IO_STATUS_NORMAL;
126 }
127
128
129 static GSource* captive_gnomevfs_giognomevfs_io_create_watch(GIOChannel *channel,GIOCondition condition)
130 {
131 struct captive_gnomevfs_giognomevfs *giognomevfs=(struct captive_gnomevfs_giognomevfs *)channel;
132
133         g_return_val_if_fail(validate_giognomevfs(giognomevfs),NULL);
134
135         g_return_val_if_reached(NULL);  /* FIXME: NOT IMPLEMENTED YET */
136 }
137
138
139 static void captive_gnomevfs_giognomevfs_io_free(GIOChannel *channel)
140 {
141 struct captive_gnomevfs_giognomevfs *giognomevfs=(struct captive_gnomevfs_giognomevfs *)channel;
142
143         g_return_if_fail(validate_giognomevfs(giognomevfs));
144
145         g_free(giognomevfs);
146 }
147
148
149 static GIOStatus captive_gnomevfs_giognomevfs_io_set_flags(GIOChannel *channel,GIOFlags flags,GError **err)
150 {
151 struct captive_gnomevfs_giognomevfs *giognomevfs=(struct captive_gnomevfs_giognomevfs *)channel;
152
153         g_return_val_if_fail(validate_giognomevfs(giognomevfs),G_IO_STATUS_ERROR);
154
155         /* no G_IO_FLAG_APPEND and no G_IO_FLAG_NONBLOCK */
156         g_return_val_if_fail((flags&G_IO_FLAG_SET_MASK)==0,G_IO_STATUS_ERROR);
157
158         return G_IO_STATUS_NORMAL;
159 }
160
161
162 static GIOFlags captive_gnomevfs_giognomevfs_io_get_flags(GIOChannel *channel)
163 {
164 struct captive_gnomevfs_giognomevfs *giognomevfs=(struct captive_gnomevfs_giognomevfs *)channel;
165
166         g_return_val_if_fail(validate_giognomevfs(giognomevfs),0);
167
168         return 0;       /* | !G_IO_FLAG_APPEND | !G_IO_FLAG_NONBLOCK */
169 }
170
171
172 GnomeVFSResult captive_gnomevfs_giognomevfs_new(struct captive_gnomevfs_giognomevfs **giognomevfsp,
173                 const gchar *captive_args,GnomeVFSURI *uri)
174 {
175 GnomeVFSHandle *handle;
176 struct captive_gnomevfs_giognomevfs *giognomevfs;
177 GnomeVFSResult errvfsresult;
178 gboolean errbool;
179
180         g_return_val_if_fail(giognomevfsp!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
181         g_return_val_if_fail(uri!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
182
183         errvfsresult=gnome_vfs_open_uri(&handle,uri,GNOME_VFS_OPEN_READ);
184         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
185
186         G_LOCK(giochannel_funcs);
187         giochannel_funcs.io_read        =captive_gnomevfs_giognomevfs_io_read;
188         giochannel_funcs.io_write       =captive_gnomevfs_giognomevfs_io_write;
189         giochannel_funcs.io_seek        =captive_gnomevfs_giognomevfs_io_seek;
190         giochannel_funcs.io_close       =captive_gnomevfs_giognomevfs_io_close;
191         giochannel_funcs.io_create_watch=captive_gnomevfs_giognomevfs_io_create_watch;
192         giochannel_funcs.io_free        =captive_gnomevfs_giognomevfs_io_free;
193         giochannel_funcs.io_set_flags   =captive_gnomevfs_giognomevfs_io_set_flags;
194         giochannel_funcs.io_get_flags   =captive_gnomevfs_giognomevfs_io_get_flags;
195         G_UNLOCK(giochannel_funcs);
196
197         captive_new(giognomevfs);
198         g_assert(G_STRUCT_OFFSET(struct captive_gnomevfs_giognomevfs,iochannel)==0);    /* safely re-type-able */
199         g_io_channel_init(&giognomevfs->iochannel);
200         giognomevfs->iochannel.funcs=&giochannel_funcs;
201         giognomevfs->iochannel.is_seekable=TRUE;
202         giognomevfs->iochannel.is_readable=TRUE;
203         giognomevfs->iochannel.is_writeable=TRUE;
204         giognomevfs->gnomevfshandle=handle;
205
206         G_LOCK(libcaptive);
207         errbool=captive_init(
208                         captive_args,   /* captive_args */
209                         (GIOChannel *)giognomevfs);     /* image_iochannel */
210         G_UNLOCK(libcaptive);
211         g_assert(errbool==TRUE);
212
213         *giognomevfsp=giognomevfs;
214         return GNOME_VFS_OK;
215 }