2007-05-01 02:09:19 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
|
|
* License, or any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
2009-05-01 16:41:06 +02:00
|
|
|
FILE_LICENCE ( GPL2_OR_LATER );
|
|
|
|
|
2007-05-01 02:09:19 +02:00
|
|
|
#include <stdlib.h>
|
2007-06-09 18:42:46 +02:00
|
|
|
#include <stdarg.h>
|
2007-05-01 02:09:19 +02:00
|
|
|
#include <errno.h>
|
|
|
|
#include <gpxe/xfer.h>
|
|
|
|
#include <gpxe/open.h>
|
|
|
|
#include <gpxe/job.h>
|
|
|
|
#include <gpxe/uaccess.h>
|
|
|
|
#include <gpxe/umalloc.h>
|
|
|
|
#include <gpxe/image.h>
|
|
|
|
#include <gpxe/downloader.h>
|
|
|
|
|
|
|
|
/** @file
|
|
|
|
*
|
|
|
|
* Image downloader
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/** A downloader */
|
|
|
|
struct downloader {
|
|
|
|
/** Reference count for this object */
|
|
|
|
struct refcnt refcnt;
|
|
|
|
|
|
|
|
/** Job control interface */
|
|
|
|
struct job_interface job;
|
|
|
|
/** Data transfer interface */
|
|
|
|
struct xfer_interface xfer;
|
|
|
|
|
|
|
|
/** Image to contain downloaded file */
|
|
|
|
struct image *image;
|
|
|
|
/** Current position within image buffer */
|
|
|
|
size_t pos;
|
|
|
|
/** Image registration routine */
|
|
|
|
int ( * register_image ) ( struct image *image );
|
|
|
|
};
|
|
|
|
|
2007-05-15 18:53:46 +02:00
|
|
|
/**
|
|
|
|
* Free downloader object
|
|
|
|
*
|
|
|
|
* @v refcnt Downloader reference counter
|
|
|
|
*/
|
|
|
|
static void downloader_free ( struct refcnt *refcnt ) {
|
|
|
|
struct downloader *downloader =
|
|
|
|
container_of ( refcnt, struct downloader, refcnt );
|
|
|
|
|
|
|
|
image_put ( downloader->image );
|
|
|
|
free ( downloader );
|
|
|
|
}
|
|
|
|
|
2007-05-01 02:09:19 +02:00
|
|
|
/**
|
|
|
|
* Terminate download
|
|
|
|
*
|
|
|
|
* @v downloader Downloader
|
|
|
|
* @v rc Reason for termination
|
|
|
|
*/
|
|
|
|
static void downloader_finished ( struct downloader *downloader, int rc ) {
|
|
|
|
|
|
|
|
/* Block further incoming messages */
|
|
|
|
job_nullify ( &downloader->job );
|
|
|
|
xfer_nullify ( &downloader->xfer );
|
|
|
|
|
|
|
|
/* Free resources and close interfaces */
|
|
|
|
xfer_close ( &downloader->xfer, rc );
|
|
|
|
job_done ( &downloader->job, rc );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Ensure that download buffer is large enough for the specified size
|
|
|
|
*
|
|
|
|
* @v downloader Downloader
|
|
|
|
* @v len Required minimum size
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
|
|
|
static int downloader_ensure_size ( struct downloader *downloader,
|
|
|
|
size_t len ) {
|
|
|
|
userptr_t new_buffer;
|
|
|
|
|
|
|
|
/* If buffer is already large enough, do nothing */
|
|
|
|
if ( len <= downloader->image->len )
|
|
|
|
return 0;
|
|
|
|
|
2008-01-08 17:46:55 +01:00
|
|
|
DBGC ( downloader, "Downloader %p extending to %zd bytes\n",
|
|
|
|
downloader, len );
|
|
|
|
|
2007-05-01 02:09:19 +02:00
|
|
|
/* Extend buffer */
|
|
|
|
new_buffer = urealloc ( downloader->image->data, len );
|
|
|
|
if ( ! new_buffer ) {
|
|
|
|
DBGC ( downloader, "Downloader %p could not extend buffer to "
|
|
|
|
"%zd bytes\n", downloader, len );
|
|
|
|
return -ENOBUFS;
|
|
|
|
}
|
|
|
|
downloader->image->data = new_buffer;
|
|
|
|
downloader->image->len = len;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* Job control interface
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle kill() event received via job control interface
|
|
|
|
*
|
|
|
|
* @v job Downloader job control interface
|
|
|
|
*/
|
|
|
|
static void downloader_job_kill ( struct job_interface *job ) {
|
2009-08-31 20:33:55 +02:00
|
|
|
struct downloader *downloader =
|
2007-05-01 02:09:19 +02:00
|
|
|
container_of ( job, struct downloader, job );
|
|
|
|
|
|
|
|
/* Terminate download */
|
|
|
|
downloader_finished ( downloader, -ECANCELED );
|
|
|
|
}
|
|
|
|
|
2009-08-31 20:33:55 +02:00
|
|
|
/**
|
|
|
|
* Report progress of download job
|
|
|
|
*
|
|
|
|
* @v job Downloader job control interface
|
|
|
|
* @v progress Progress report to fill in
|
|
|
|
*/
|
|
|
|
static void downloader_job_progress ( struct job_interface *job,
|
|
|
|
struct job_progress *progress ) {
|
|
|
|
struct downloader *downloader =
|
|
|
|
container_of ( job, struct downloader, job );
|
|
|
|
|
|
|
|
/* This is not entirely accurate, since downloaded data may
|
|
|
|
* arrive out of order (e.g. with multicast protocols), but
|
|
|
|
* it's a reasonable first approximation.
|
|
|
|
*/
|
|
|
|
progress->completed = downloader->pos;
|
|
|
|
progress->total = downloader->image->len;
|
|
|
|
}
|
|
|
|
|
2007-05-01 02:09:19 +02:00
|
|
|
/** Downloader job control interface operations */
|
|
|
|
static struct job_interface_operations downloader_job_operations = {
|
|
|
|
.done = ignore_job_done,
|
|
|
|
.kill = downloader_job_kill,
|
2009-08-31 20:33:55 +02:00
|
|
|
.progress = downloader_job_progress,
|
2007-05-01 02:09:19 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* Data transfer interface
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle deliver_raw() event received via data transfer interface
|
|
|
|
*
|
|
|
|
* @v xfer Downloader data transfer interface
|
2008-01-08 17:46:55 +01:00
|
|
|
* @v iobuf Datagram I/O buffer
|
|
|
|
* @v meta Data transfer metadata
|
2007-05-01 02:09:19 +02:00
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
2008-01-08 17:46:55 +01:00
|
|
|
static int downloader_xfer_deliver_iob ( struct xfer_interface *xfer,
|
|
|
|
struct io_buffer *iobuf,
|
|
|
|
struct xfer_metadata *meta ) {
|
2007-05-01 02:09:19 +02:00
|
|
|
struct downloader *downloader =
|
|
|
|
container_of ( xfer, struct downloader, xfer );
|
2008-01-08 17:46:55 +01:00
|
|
|
size_t len;
|
2007-05-01 02:09:19 +02:00
|
|
|
size_t max;
|
|
|
|
int rc;
|
|
|
|
|
2008-01-08 17:46:55 +01:00
|
|
|
/* Calculate new buffer position */
|
|
|
|
if ( meta->whence != SEEK_CUR )
|
|
|
|
downloader->pos = 0;
|
|
|
|
downloader->pos += meta->offset;
|
|
|
|
|
2007-05-01 02:09:19 +02:00
|
|
|
/* Ensure that we have enough buffer space for this data */
|
2008-01-08 17:46:55 +01:00
|
|
|
len = iob_len ( iobuf );
|
2007-05-01 02:09:19 +02:00
|
|
|
max = ( downloader->pos + len );
|
|
|
|
if ( ( rc = downloader_ensure_size ( downloader, max ) ) != 0 )
|
2008-01-08 17:46:55 +01:00
|
|
|
goto done;
|
2007-05-01 02:09:19 +02:00
|
|
|
|
|
|
|
/* Copy data to buffer */
|
2008-01-08 17:46:55 +01:00
|
|
|
copy_to_user ( downloader->image->data, downloader->pos,
|
|
|
|
iobuf->data, len );
|
2007-05-01 02:09:19 +02:00
|
|
|
|
|
|
|
/* Update current buffer position */
|
|
|
|
downloader->pos += len;
|
|
|
|
|
2008-01-08 17:46:55 +01:00
|
|
|
done:
|
|
|
|
free_iob ( iobuf );
|
|
|
|
return rc;
|
2007-05-01 02:09:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle close() event received via data transfer interface
|
|
|
|
*
|
|
|
|
* @v xfer Downloader data transfer interface
|
|
|
|
* @v rc Reason for close
|
|
|
|
*/
|
|
|
|
static void downloader_xfer_close ( struct xfer_interface *xfer, int rc ) {
|
|
|
|
struct downloader *downloader =
|
|
|
|
container_of ( xfer, struct downloader, xfer );
|
|
|
|
|
|
|
|
/* Register image if download was successful */
|
|
|
|
if ( rc == 0 )
|
|
|
|
rc = downloader->register_image ( downloader->image );
|
|
|
|
|
|
|
|
/* Terminate download */
|
|
|
|
downloader_finished ( downloader, rc );
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Downloader data transfer interface operations */
|
|
|
|
static struct xfer_interface_operations downloader_xfer_operations = {
|
|
|
|
.close = downloader_xfer_close,
|
2009-03-30 14:24:56 +02:00
|
|
|
.vredirect = xfer_vreopen,
|
2007-07-08 15:11:07 +02:00
|
|
|
.window = unlimited_xfer_window,
|
2008-01-08 17:46:55 +01:00
|
|
|
.alloc_iob = default_xfer_alloc_iob,
|
|
|
|
.deliver_iob = downloader_xfer_deliver_iob,
|
|
|
|
.deliver_raw = xfer_deliver_as_iob,
|
2007-05-01 02:09:19 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
*
|
|
|
|
* Instantiator
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Instantiate a downloader
|
|
|
|
*
|
|
|
|
* @v job Job control interface
|
|
|
|
* @v image Image to fill with downloaded file
|
|
|
|
* @v register_image Image registration routine
|
2007-06-09 18:42:46 +02:00
|
|
|
* @v type Location type to pass to xfer_open()
|
|
|
|
* @v ... Remaining arguments to pass to xfer_open()
|
2007-05-01 02:09:19 +02:00
|
|
|
* @ret rc Return status code
|
|
|
|
*
|
|
|
|
* Instantiates a downloader object to download the specified URI into
|
|
|
|
* the specified image object. If the download is successful, the
|
|
|
|
* image registration routine @c register_image() will be called.
|
|
|
|
*/
|
2007-06-09 18:42:46 +02:00
|
|
|
int create_downloader ( struct job_interface *job, struct image *image,
|
|
|
|
int ( * register_image ) ( struct image *image ),
|
|
|
|
int type, ... ) {
|
2007-05-01 02:09:19 +02:00
|
|
|
struct downloader *downloader;
|
2007-06-09 18:42:46 +02:00
|
|
|
va_list args;
|
2007-05-01 02:09:19 +02:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* Allocate and initialise structure */
|
2007-06-18 01:24:41 +02:00
|
|
|
downloader = zalloc ( sizeof ( *downloader ) );
|
2007-05-01 02:09:19 +02:00
|
|
|
if ( ! downloader )
|
|
|
|
return -ENOMEM;
|
2007-05-15 18:53:46 +02:00
|
|
|
downloader->refcnt.free = downloader_free;
|
2007-05-01 02:09:19 +02:00
|
|
|
job_init ( &downloader->job, &downloader_job_operations,
|
|
|
|
&downloader->refcnt );
|
|
|
|
xfer_init ( &downloader->xfer, &downloader_xfer_operations,
|
|
|
|
&downloader->refcnt );
|
|
|
|
downloader->image = image_get ( image );
|
|
|
|
downloader->register_image = register_image;
|
2007-06-09 18:42:46 +02:00
|
|
|
va_start ( args, type );
|
2007-05-01 02:09:19 +02:00
|
|
|
|
|
|
|
/* Instantiate child objects and attach to our interfaces */
|
2007-06-09 18:42:46 +02:00
|
|
|
if ( ( rc = xfer_vopen ( &downloader->xfer, type, args ) ) != 0 )
|
2007-05-01 02:09:19 +02:00
|
|
|
goto err;
|
|
|
|
|
2007-05-15 18:53:46 +02:00
|
|
|
/* Attach parent interface, mortalise self, and return */
|
2007-05-01 02:09:19 +02:00
|
|
|
job_plug_plug ( &downloader->job, job );
|
2007-05-15 18:53:46 +02:00
|
|
|
ref_put ( &downloader->refcnt );
|
2007-06-09 18:42:46 +02:00
|
|
|
va_end ( args );
|
2007-05-01 02:09:19 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
downloader_finished ( downloader, rc );
|
2007-05-15 18:53:46 +02:00
|
|
|
ref_put ( &downloader->refcnt );
|
2007-06-09 18:42:46 +02:00
|
|
|
va_end ( args );
|
2007-05-01 02:09:19 +02:00
|
|
|
return rc;
|
|
|
|
}
|