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