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 }