Make seek information part of the xfer metadata, rather than an entirely
[people/mcb30/gpxe.git] / src / core / downloader.c
1 /*
2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stdlib.h>
20 #include <stdarg.h>
21 #include <errno.h>
22 #include <gpxe/xfer.h>
23 #include <gpxe/open.h>
24 #include <gpxe/job.h>
25 #include <gpxe/uaccess.h>
26 #include <gpxe/umalloc.h>
27 #include <gpxe/image.h>
28 #include <gpxe/downloader.h>
29
30 /** @file
31  *
32  * Image downloader
33  *
34  */
35
36 /** A downloader */
37 struct downloader {
38         /** Reference count for this object */
39         struct refcnt refcnt;
40
41         /** Job control interface */
42         struct job_interface job;
43         /** Data transfer interface */
44         struct xfer_interface xfer;
45
46         /** Image to contain downloaded file */
47         struct image *image;
48         /** Current position within image buffer */
49         size_t pos;
50         /** Image registration routine */
51         int ( * register_image ) ( struct image *image );
52 };
53
54 /**
55  * Free downloader object
56  *
57  * @v refcnt            Downloader reference counter
58  */
59 static void downloader_free ( struct refcnt *refcnt ) {
60         struct downloader *downloader =
61                 container_of ( refcnt, struct downloader, refcnt );
62
63         image_put ( downloader->image );
64         free ( downloader );
65 }
66
67 /**
68  * Terminate download
69  *
70  * @v downloader        Downloader
71  * @v rc                Reason for termination
72  */
73 static void downloader_finished ( struct downloader *downloader, int rc ) {
74
75         /* Block further incoming messages */
76         job_nullify ( &downloader->job );
77         xfer_nullify ( &downloader->xfer );
78
79         /* Free resources and close interfaces */
80         xfer_close ( &downloader->xfer, rc );
81         job_done ( &downloader->job, rc );
82 }
83
84 /**
85  * Ensure that download buffer is large enough for the specified size
86  *
87  * @v downloader        Downloader
88  * @v len               Required minimum size
89  * @ret rc              Return status code
90  */
91 static int downloader_ensure_size ( struct downloader *downloader,
92                                     size_t len ) {
93         userptr_t new_buffer;
94
95         /* If buffer is already large enough, do nothing */
96         if ( len <= downloader->image->len )
97                 return 0;
98
99         DBGC ( downloader, "Downloader %p extending to %zd bytes\n",
100                downloader, len );
101
102         /* Extend buffer */
103         new_buffer = urealloc ( downloader->image->data, len );
104         if ( ! new_buffer ) {
105                 DBGC ( downloader, "Downloader %p could not extend buffer to "
106                        "%zd bytes\n", downloader, len );
107                 return -ENOBUFS;
108         }
109         downloader->image->data = new_buffer;
110         downloader->image->len = len;
111
112         return 0;
113 }
114
115 /****************************************************************************
116  *
117  * Job control interface
118  *
119  */
120
121 /**
122  * Handle kill() event received via job control interface
123  *
124  * @v job               Downloader job control interface
125  */
126 static void downloader_job_kill ( struct job_interface *job ) {
127         struct downloader *downloader = 
128                 container_of ( job, struct downloader, job );
129
130         /* Terminate download */
131         downloader_finished ( downloader, -ECANCELED );
132 }
133
134 /** Downloader job control interface operations */
135 static struct job_interface_operations downloader_job_operations = {
136         .done           = ignore_job_done,
137         .kill           = downloader_job_kill,
138         .progress       = ignore_job_progress,
139 };
140
141 /****************************************************************************
142  *
143  * Data transfer interface
144  *
145  */
146
147 /**
148  * Handle deliver_raw() event received via data transfer interface
149  *
150  * @v xfer              Downloader data transfer interface
151  * @v iobuf             Datagram I/O buffer
152  * @v meta              Data transfer metadata
153  * @ret rc              Return status code
154  */
155 static int downloader_xfer_deliver_iob ( struct xfer_interface *xfer,
156                                          struct io_buffer *iobuf,
157                                          struct xfer_metadata *meta ) {
158         struct downloader *downloader =
159                 container_of ( xfer, struct downloader, xfer );
160         size_t len;
161         size_t max;
162         int rc;
163
164         /* Calculate new buffer position */
165         if ( meta->whence != SEEK_CUR )
166                 downloader->pos = 0;
167         downloader->pos += meta->offset;
168
169         /* Ensure that we have enough buffer space for this data */
170         len = iob_len ( iobuf );
171         max = ( downloader->pos + len );
172         if ( ( rc = downloader_ensure_size ( downloader, max ) ) != 0 )
173                 goto done;
174
175         /* Copy data to buffer */
176         copy_to_user ( downloader->image->data, downloader->pos,
177                        iobuf->data, len );
178
179         /* Update current buffer position */
180         downloader->pos += len;
181
182  done:
183         free_iob ( iobuf );
184         return rc;
185 }
186
187 /**
188  * Handle close() event received via data transfer interface
189  *
190  * @v xfer              Downloader data transfer interface
191  * @v rc                Reason for close
192  */
193 static void downloader_xfer_close ( struct xfer_interface *xfer, int rc ) {
194         struct downloader *downloader =
195                 container_of ( xfer, struct downloader, xfer );
196
197         /* Register image if download was successful */
198         if ( rc == 0 )
199                 rc = downloader->register_image ( downloader->image );
200
201         /* Terminate download */
202         downloader_finished ( downloader, rc );
203 }
204
205 /** Downloader data transfer interface operations */
206 static struct xfer_interface_operations downloader_xfer_operations = {
207         .close          = downloader_xfer_close,
208         .vredirect      = xfer_vopen,
209         .window         = unlimited_xfer_window,
210         .alloc_iob      = default_xfer_alloc_iob,
211         .deliver_iob    = downloader_xfer_deliver_iob,
212         .deliver_raw    = xfer_deliver_as_iob,
213 };
214
215 /****************************************************************************
216  *
217  * Instantiator
218  *
219  */
220
221 /**
222  * Instantiate a downloader
223  *
224  * @v job               Job control interface
225  * @v image             Image to fill with downloaded file
226  * @v register_image    Image registration routine
227  * @v type              Location type to pass to xfer_open()
228  * @v ...               Remaining arguments to pass to xfer_open()
229  * @ret rc              Return status code
230  *
231  * Instantiates a downloader object to download the specified URI into
232  * the specified image object.  If the download is successful, the
233  * image registration routine @c register_image() will be called.
234  */
235 int create_downloader ( struct job_interface *job, struct image *image,
236                         int ( * register_image ) ( struct image *image ),
237                         int type, ... ) {
238         struct downloader *downloader;
239         va_list args;
240         int rc;
241
242         /* Allocate and initialise structure */
243         downloader = zalloc ( sizeof ( *downloader ) );
244         if ( ! downloader )
245                 return -ENOMEM;
246         downloader->refcnt.free = downloader_free;
247         job_init ( &downloader->job, &downloader_job_operations,
248                    &downloader->refcnt );
249         xfer_init ( &downloader->xfer, &downloader_xfer_operations,
250                     &downloader->refcnt );
251         downloader->image = image_get ( image );
252         downloader->register_image = register_image;
253         va_start ( args, type );
254
255         /* Instantiate child objects and attach to our interfaces */
256         if ( ( rc = xfer_vopen ( &downloader->xfer, type, args ) ) != 0 )
257                 goto err;
258
259         /* Attach parent interface, mortalise self, and return */
260         job_plug_plug ( &downloader->job, job );
261         ref_put ( &downloader->refcnt );
262         va_end ( args );
263         return 0;
264
265  err:
266         downloader_finished ( downloader, rc );
267         ref_put ( &downloader->refcnt );
268         va_end ( args );
269         return rc;
270 }