sysadmin/ipxe
1
0
Fork 0
mirror of https://github.com/ipxe/ipxe synced 2025-12-27 10:02:42 +03:00
Code Issues Packages Projects Releases Wiki Activity

[interface] Convert all data-xfer interfaces to generic interfaces

Browse Source 
Remove data-xfer as an interface type, and replace data-xfer
interfaces with generic interfaces supporting the data-xfer methods.

Filter interfaces (as used by the TLS layer) are handled using the
generic pass-through interface capability.  A side-effect of this is
that deliver_raw() no longer exists as a data-xfer method.  (In
practice this doesn't lose any efficiency, since there are no
instances within the current codebase where xfer_deliver_raw() is used
to pass data to an interface supporting the deliver_raw() method.)

Signed-off-by: Michael Brown <mcb30@ipxe.org>
This commit is contained in:
Michael Brown
2010-06-16 01:31:29 +01:00
parent 7b4fbd93a5
commit 4327d5d39f
31 changed files with 764 additions and 1511 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/core/downloader.c
View File

@@ -21,6 +21,7 @@ FILE_LICENCE ( GPL2_OR_LATER );
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <ipxe/iobuf.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/job.h>
@@ -43,7 +44,7 @@ struct downloader {
/** Job control interface */
struct interface job;
/** Data transfer interface */
struct xfer_interface xfer;
struct interface xfer;
/** Image to contain downloaded file */
struct image *image;
@@ -79,8 +80,7 @@ static void downloader_finished ( struct downloader *downloader, int rc ) {
rc = downloader->register_image ( downloader->image );
/* Shut down interfaces */
xfer_nullify ( &downloader->xfer );
xfer_close ( &downloader->xfer, rc );
intf_shutdown ( &downloader->xfer, rc );
intf_shutdown ( &downloader->job, rc );
}
@@ -145,18 +145,16 @@ static void downloader_progress ( struct downloader *downloader,
*/
/**
* Handle deliver_raw() event received via data transfer interface
* Handle received data
*
* @v xfer Downloader data transfer interface
* @v downloader Downloader
* @v iobuf Datagram I/O buffer
* @v meta Data transfer metadata
* @ret rc Return status code
*/
static int downloader_xfer_deliver_iob ( struct xfer_interface *xfer,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
struct downloader *downloader =
container_of ( xfer, struct downloader, xfer );
static int downloader_xfer_deliver ( struct downloader *downloader,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
size_t len;
size_t max;
int rc;
@@ -184,30 +182,16 @@ static int downloader_xfer_deliver_iob ( struct xfer_interface *xfer,
return rc;
}
/**
* 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 );
/* Terminate download */
downloader_finished ( downloader, rc );
}
/** Downloader data transfer interface operations */
static struct xfer_interface_operations downloader_xfer_operations = {
.close = downloader_xfer_close,
.vredirect = xfer_vreopen,
.window = unlimited_xfer_window,
.alloc_iob = default_xfer_alloc_iob,
.deliver_iob = downloader_xfer_deliver_iob,
.deliver_raw = xfer_deliver_as_iob,
static struct interface_operation downloader_xfer_operations[] = {
INTF_OP ( xfer_deliver, struct downloader *, downloader_xfer_deliver ),
INTF_OP ( intf_close, struct downloader *, downloader_finished ),
};
/** Downloader data transfer interface descriptor */
static struct interface_descriptor downloader_xfer_desc =
INTF_DESC ( struct downloader, xfer, downloader_xfer_operations );
/****************************************************************************
*
* Job control interface
@@ -258,7 +242,7 @@ int create_downloader ( struct interface *job, struct image *image,
ref_init ( &downloader->refcnt, downloader_free );
intf_init ( &downloader->job, &downloader_job_desc,
&downloader->refcnt );
xfer_init ( &downloader->xfer, &downloader_xfer_operations,
intf_init ( &downloader->xfer, &downloader_xfer_desc,
&downloader->refcnt );
downloader->image = image_get ( image );
downloader->register_image = register_image;

74
src/core/filter.c
View File

@@ -1,74 +0,0 @@
/*
* 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.
*/
FILE_LICENCE ( GPL2_OR_LATER );
#include <ipxe/xfer.h>
#include <ipxe/filter.h>
/** @file
*
* Data transfer filters
*
*/
/*
* Pass-through methods to be used by filters which don't want to
* intercept all events.
*
*/
void filter_close ( struct xfer_interface *xfer, int rc ) {
struct xfer_interface *other = filter_other_half ( xfer );
xfer_close ( other, rc );
}
int filter_vredirect ( struct xfer_interface *xfer, int type,
va_list args ) {
struct xfer_interface *other = filter_other_half ( xfer );
return xfer_vredirect ( other, type, args );
}
size_t filter_window ( struct xfer_interface *xfer ) {
struct xfer_interface *other = filter_other_half ( xfer );
return xfer_window ( other );
}
struct io_buffer * filter_alloc_iob ( struct xfer_interface *xfer,
size_t len ) {
struct xfer_interface *other = filter_other_half ( xfer );
return xfer_alloc_iob ( other, len );
}
int filter_deliver_iob ( struct xfer_interface *xfer, struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
struct xfer_interface *other = filter_other_half ( xfer );
return xfer_deliver_iob_meta ( other, iobuf, meta );
}
int filter_deliver_raw ( struct xfer_interface *xfer, const void *data,
size_t len ) {
struct xfer_interface *other = filter_other_half ( xfer );
return xfer_deliver_raw ( other, data, len );
}

29
src/core/hw.c
View File

@@ -15,33 +15,24 @@
struct hw {
struct refcnt refcnt;
struct xfer_interface xfer;
struct interface xfer;
struct process process;
};
static const char hw_msg[] = "Hello world!\n";
static void hw_finished ( struct hw *hw, int rc ) {
xfer_nullify ( &hw->xfer );
xfer_close ( &hw->xfer, rc );
intf_shutdown ( &hw->xfer, rc );
process_del ( &hw->process );
}
static void hw_xfer_close ( struct xfer_interface *xfer, int rc ) {
struct hw *hw = container_of ( xfer, struct hw, xfer );
hw_finished ( hw, rc );
}
static struct xfer_interface_operations hw_xfer_operations = {
.close = hw_xfer_close,
.vredirect = ignore_xfer_vredirect,
.window = unlimited_xfer_window,
.alloc_iob = default_xfer_alloc_iob,
.deliver_iob = xfer_deliver_as_raw,
.deliver_raw = ignore_xfer_deliver_raw,
static struct interface_operation hw_xfer_operations[] = {
INTF_OP ( intf_close, struct hw *, hw_finished ),
};
static struct interface_descriptor hw_xfer_desc =
INTF_DESC ( struct hw, xfer, hw_xfer_operations );
static void hw_step ( struct process *process ) {
struct hw *hw = container_of ( process, struct hw, process );
int rc;
@@ -52,7 +43,7 @@ static void hw_step ( struct process *process ) {
}
}
static int hw_open ( struct xfer_interface *xfer, struct uri *uri __unused ) {
static int hw_open ( struct interface *xfer, struct uri *uri __unused ) {
struct hw *hw;
/* Allocate and initialise structure */
@@ -60,11 +51,11 @@ static int hw_open ( struct xfer_interface *xfer, struct uri *uri __unused ) {
if ( ! hw )
return -ENOMEM;
ref_init ( &hw->refcnt, NULL );
xfer_init ( &hw->xfer, &hw_xfer_operations, &hw->refcnt );
intf_init ( &hw->xfer, &hw_xfer_desc, &hw->refcnt );
process_init ( &hw->process, hw_step, &hw->refcnt );
/* Attach parent interface, mortalise self, and return */
xfer_plug_plug ( &hw->xfer, xfer );
intf_plug_plug ( &hw->xfer, xfer );
ref_put ( &hw->refcnt );
return 0;
}

69
src/core/open.c
View File

@@ -35,14 +35,14 @@ FILE_LICENCE ( GPL2_OR_LATER );
/**
* Open URI
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v uri URI
* @ret rc Return status code
*
* The URI will be regarded as being relative to the current working
* URI (see churi()).
*/
int xfer_open_uri ( struct xfer_interface *xfer, struct uri *uri ) {
int xfer_open_uri ( struct interface *intf, struct uri *uri ) {
struct uri_opener *opener;
struct uri *resolved_uri;
int rc = -ENOTSUP;
@@ -55,14 +55,16 @@ int xfer_open_uri ( struct xfer_interface *xfer, struct uri *uri ) {
/* Find opener which supports this URI scheme */
for_each_table_entry ( opener, URI_OPENERS ) {
if ( strcmp ( resolved_uri->scheme, opener->scheme ) == 0 ) {
DBGC ( xfer, "XFER %p opening %s URI\n",
xfer, opener->scheme );
rc = opener->open ( xfer, resolved_uri );
DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT
" opening %s URI\n", INTF_DBG ( intf ),
resolved_uri->scheme );
rc = opener->open ( intf, resolved_uri );
goto done;
}
}
DBGC ( xfer, "XFER %p attempted to open unsupported URI scheme "
"\"%s\"\n", xfer, resolved_uri->scheme );
DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " attempted to open "
"unsupported URI scheme \"%s\"\n",
INTF_DBG ( intf ), resolved_uri->scheme );
done:
uri_put ( resolved_uri );
@@ -72,25 +74,26 @@ int xfer_open_uri ( struct xfer_interface *xfer, struct uri *uri ) {
/**
* Open URI string
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v uri_string URI string (e.g. "http://ipxe.org/kernel")
* @ret rc Return status code
*
* The URI will be regarded as being relative to the current working
* URI (see churi()).
*/
int xfer_open_uri_string ( struct xfer_interface *xfer,
int xfer_open_uri_string ( struct interface *intf,
const char *uri_string ) {
struct uri *uri;
int rc;
DBGC ( xfer, "XFER %p opening URI %s\n", xfer, uri_string );
DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " opening URI %s\n",
INTF_DBG ( intf ), uri_string );
uri = parse_uri ( uri_string );
if ( ! uri )
return -ENOMEM;
rc = xfer_open_uri ( xfer, uri );
rc = xfer_open_uri ( intf, uri );
uri_put ( uri );
return rc;
@@ -99,29 +102,30 @@ int xfer_open_uri_string ( struct xfer_interface *xfer,
/**
* Open socket
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v semantics Communication semantics (e.g. SOCK_STREAM)
* @v peer Peer socket address
* @v local Local socket address, or NULL
* @ret rc Return status code
*/
int xfer_open_socket ( struct xfer_interface *xfer, int semantics,
int xfer_open_socket ( struct interface *intf, int semantics,
struct sockaddr *peer, struct sockaddr *local ) {
struct socket_opener *opener;
DBGC ( xfer, "XFER %p opening (%s,%s) socket\n", xfer,
socket_semantics_name ( semantics ),
DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " opening (%s,%s) socket\n",
INTF_DBG ( intf ), socket_semantics_name ( semantics ),
socket_family_name ( peer->sa_family ) );
for_each_table_entry ( opener, SOCKET_OPENERS ) {
if ( ( opener->semantics == semantics ) &&
( opener->family == peer->sa_family ) ) {
return opener->open ( xfer, peer, local );
return opener->open ( intf, peer, local );
}
}
DBGC ( xfer, "XFER %p attempted to open unsupported socket type "
"(%s,%s)\n", xfer, socket_semantics_name ( semantics ),
DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " attempted to open "
"unsupported socket type (%s,%s)\n",
INTF_DBG ( intf ), socket_semantics_name ( semantics ),
socket_family_name ( peer->sa_family ) );
return -ENOTSUP;
}
@@ -129,30 +133,31 @@ int xfer_open_socket ( struct xfer_interface *xfer, int semantics,
/**
* Open location
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v type Location type
* @v args Remaining arguments depend upon location type
* @ret rc Return status code
*/
int xfer_vopen ( struct xfer_interface *xfer, int type, va_list args ) {
int xfer_vopen ( struct interface *intf, int type, va_list args ) {
switch ( type ) {
case LOCATION_URI_STRING: {
const char *uri_string = va_arg ( args, const char * );
return xfer_open_uri_string ( xfer, uri_string ); }
return xfer_open_uri_string ( intf, uri_string ); }
case LOCATION_URI: {
struct uri *uri = va_arg ( args, struct uri * );
return xfer_open_uri ( xfer, uri ); }
return xfer_open_uri ( intf, uri ); }
case LOCATION_SOCKET: {
int semantics = va_arg ( args, int );
struct sockaddr *peer = va_arg ( args, struct sockaddr * );
struct sockaddr *local = va_arg ( args, struct sockaddr * );
return xfer_open_socket ( xfer, semantics, peer, local ); }
return xfer_open_socket ( intf, semantics, peer, local ); }
default:
DBGC ( xfer, "XFER %p attempted to open unsupported location "
"type %d\n", xfer, type );
DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " attempted to "
"open unsupported location type %d\n",
INTF_DBG ( intf ), type );
return -ENOTSUP;
}
}
@@ -160,17 +165,17 @@ int xfer_vopen ( struct xfer_interface *xfer, int type, va_list args ) {
/**
* Open location
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v type Location type
* @v ... Remaining arguments depend upon location type
* @ret rc Return status code
*/
int xfer_open ( struct xfer_interface *xfer, int type, ... ) {
int xfer_open ( struct interface *intf, int type, ... ) {
va_list args;
int rc;
va_start ( args, type );
rc = xfer_vopen ( xfer, type, args );
rc = xfer_vopen ( intf, type, args );
va_end ( args );
return rc;
}
@@ -178,7 +183,7 @@ int xfer_open ( struct xfer_interface *xfer, int type, ... ) {
/**
* Reopen location
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v type Location type
* @v args Remaining arguments depend upon location type
* @ret rc Return status code
@@ -187,11 +192,11 @@ int xfer_open ( struct xfer_interface *xfer, int type, ... ) {
* using xfer_vopen(). It is intended to be used as a .vredirect
* method handler.
*/
int xfer_vreopen ( struct xfer_interface *xfer, int type, va_list args ) {
int xfer_vreopen ( struct interface *intf, int type, va_list args ) {
/* Close existing connection */
xfer_close ( xfer, 0 );
intf_restart ( intf, 0 );
/* Open new location */
return xfer_vopen ( xfer, type, args );
return xfer_vopen ( intf, type, args );
}

47
src/core/posix_io.c
View File

@@ -22,6 +22,7 @@ FILE_LICENCE ( GPL2_OR_LATER );
#include <string.h>
#include <errno.h>
#include <ipxe/list.h>
#include <ipxe/iobuf.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/process.h>
@@ -50,7 +51,7 @@ struct posix_file {
*/
int rc;
/** Data transfer interface */
struct xfer_interface xfer;
struct interface xfer;
/** Current seek position */
size_t pos;
/** File size */
@@ -87,38 +88,21 @@ static void posix_file_free ( struct refcnt *refcnt ) {
* @v rc Reason for termination
*/
static void posix_file_finished ( struct posix_file *file, int rc ) {
xfer_nullify ( &file->xfer );
xfer_close ( &file->xfer, rc );
intf_shutdown ( &file->xfer, rc );
file->rc = rc;
}
/**
* Handle close() event
*
* @v xfer POSIX file data transfer interface
* @v rc Reason for close
*/
static void posix_file_xfer_close ( struct xfer_interface *xfer, int rc ) {
struct posix_file *file =
container_of ( xfer, struct posix_file, xfer );
posix_file_finished ( file, rc );
}
/**
* Handle deliver_iob() event
*
* @v xfer POSIX file data transfer interface
* @v file POSIX file
* @v iobuf I/O buffer
* @v meta Data transfer metadata
* @ret rc Return status code
*/
static int
posix_file_xfer_deliver_iob ( struct xfer_interface *xfer,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
struct posix_file *file =
container_of ( xfer, struct posix_file, xfer );
static int posix_file_xfer_deliver ( struct posix_file *file,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
/* Keep track of file position solely for the filesize */
if ( meta->whence != SEEK_CUR )
@@ -137,15 +121,15 @@ posix_file_xfer_deliver_iob ( struct xfer_interface *xfer,
}
/** POSIX file data transfer interface operations */
static struct xfer_interface_operations posix_file_xfer_operations = {
.close = posix_file_xfer_close,
.vredirect = xfer_vreopen,
.window = unlimited_xfer_window,
.alloc_iob = default_xfer_alloc_iob,
.deliver_iob = posix_file_xfer_deliver_iob,
.deliver_raw = xfer_deliver_as_iob,
static struct interface_operation posix_file_xfer_operations[] = {
INTF_OP ( xfer_deliver, struct posix_file *, posix_file_xfer_deliver ),
INTF_OP ( intf_close, struct posix_file *, posix_file_finished ),
};
/** POSIX file data transfer interface descriptor */
static struct interface_descriptor posix_file_xfer_desc =
INTF_DESC ( struct posix_file, xfer, posix_file_xfer_operations );
/**
* Identify file by file descriptor
*
@@ -201,8 +185,7 @@ int open ( const char *uri_string ) {
ref_init ( &file->refcnt, posix_file_free );
file->fd = fd;
file->rc = -EINPROGRESS;
xfer_init ( &file->xfer, &posix_file_xfer_operations,
&file->refcnt );
intf_init ( &file->xfer, &posix_file_xfer_desc, &file->refcnt );
INIT_LIST_HEAD ( &file->data );
/* Open URI on data transfer interface */

43
src/core/resolv.c
View File

@@ -299,7 +299,7 @@ struct named_socket {
/** Reference counter */
struct refcnt refcnt;
/** Data transfer interface */
struct xfer_interface xfer;
struct interface xfer;
/** Name resolution interface */
struct interface resolv;
/** Communication semantics (e.g. SOCK_STREAM) */
@@ -319,33 +319,30 @@ struct named_socket {
static void named_close ( struct named_socket *named, int rc ) {
/* Shut down interfaces */
intf_shutdown ( &named->resolv, rc );
xfer_nullify ( &named->xfer );
xfer_close ( &named->xfer, rc );
intf_shutdown ( &named->xfer, rc );
}
/**
* Handle close() event
* Check flow control window
*
* @v xfer Data transfer interface
* @v rc Reason for close
* @v named Named socket
* @ret len Length of window
*/
static void named_xfer_close ( struct xfer_interface *xfer, int rc ) {
struct named_socket *named =
container_of ( xfer, struct named_socket, xfer );
named_close ( named, rc );
static size_t named_window ( struct named_socket *named __unused ) {
/* Not ready for data until we have redirected away */
return 0;
}
/** Named socket opener data transfer interface operations */
static struct xfer_interface_operations named_xfer_ops = {
.close = named_xfer_close,
.vredirect = ignore_xfer_vredirect,
.window = no_xfer_window,
.alloc_iob = default_xfer_alloc_iob,
.deliver_iob = xfer_deliver_as_raw,
.deliver_raw = ignore_xfer_deliver_raw,
static struct interface_operation named_xfer_ops[] = {
INTF_OP ( xfer_window, struct named_socket *, named_window ),
INTF_OP ( intf_close, struct named_socket *, named_close ),
};
/** Named socket opener data transfer interface descriptor */
static struct interface_descriptor named_xfer_desc =
INTF_DESC ( struct named_socket, xfer, named_xfer_ops );
/**
* Name resolved
*
@@ -357,7 +354,7 @@ static void named_resolv_done ( struct named_socket *named,
int rc;
/* Nullify data transfer interface */
xfer_nullify ( &named->xfer );
intf_nullify ( &named->xfer );
/* Redirect data-xfer interface */
if ( ( rc = xfer_redirect ( &named->xfer, LOCATION_SOCKET,
@@ -370,7 +367,7 @@ static void named_resolv_done ( struct named_socket *named,
} else {
/* Redirection succeeded - unplug data-xfer interface */
DBGC ( named, "NAMED %p redirected successfully\n", named );
xfer_unplug ( &named->xfer );
intf_unplug ( &named->xfer );
}
/* Terminate named socket opener */
@@ -396,7 +393,7 @@ static struct interface_descriptor named_resolv_desc =
* @v local Local socket address, or NULL
* @ret rc Return status code
*/
int xfer_open_named_socket ( struct xfer_interface *xfer, int semantics,
int xfer_open_named_socket ( struct interface *xfer, int semantics,
struct sockaddr *peer, const char *name,
struct sockaddr *local ) {
struct named_socket *named;
@@ -407,7 +404,7 @@ int xfer_open_named_socket ( struct xfer_interface *xfer, int semantics,
if ( ! named )
return -ENOMEM;
ref_init ( &named->refcnt, NULL );
xfer_init ( &named->xfer, &named_xfer_ops, &named->refcnt );
intf_init ( &named->xfer, &named_xfer_desc, &named->refcnt );
intf_init ( &named->resolv, &named_resolv_desc, &named->refcnt );
named->semantics = semantics;
if ( local ) {
@@ -423,7 +420,7 @@ int xfer_open_named_socket ( struct xfer_interface *xfer, int semantics,
goto err;
/* Attach parent interface, mortalise self, and return */
xfer_plug_plug ( &named->xfer, xfer );
intf_plug_plug ( &named->xfer, xfer );
ref_put ( &named->refcnt );
return 0;

371
src/core/xfer.c
View File

@@ -21,7 +21,9 @@ FILE_LICENCE ( GPL2_OR_LATER );
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <ipxe/iobuf.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
/** @file
*
@@ -37,178 +39,206 @@ FILE_LICENCE ( GPL2_OR_LATER );
*/
static struct xfer_metadata dummy_metadata;
/**
* Close data transfer interface
/*****************************************************************************
*
* Data transfer interface operations
*
* @v xfer Data transfer interface
* @v rc Reason for close
*/
void xfer_close ( struct xfer_interface *xfer, int rc ) {
struct xfer_interface *dest = xfer_get_dest ( xfer );
struct xfer_interface_operations *op = xfer->op;
DBGC ( xfer, "XFER %p->%p close\n", xfer, dest );
xfer_unplug ( xfer );
xfer_nullify ( xfer );
dest->op->close ( dest, rc );
xfer->op = op;
xfer_put ( dest );
}
/**
* Send redirection event
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v type New location type
* @v args Remaining arguments depend upon location type
* @ret rc Return status code
*/
int xfer_vredirect ( struct xfer_interface *xfer, int type, va_list args ) {
struct xfer_interface *dest = xfer_get_dest ( xfer );
int xfer_vredirect ( struct interface *intf, int type, va_list args ) {
struct interface *dest;
xfer_vredirect_TYPE ( void * ) *op =
intf_get_dest_op ( intf, xfer_vredirect, &dest );
void *object = intf_object ( dest );
int rc;
DBGC ( xfer, "XFER %p->%p redirect\n", xfer, dest );
DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " redirect\n",
INTF_INTF_DBG ( intf, dest ) );
rc = dest->op->vredirect ( dest, type, args );
if ( op ) {
rc = op ( object, type, args );
} else {
/* Default is to reopen the interface as instructed */
rc = xfer_vreopen ( dest, type, args );
}
if ( rc != 0 ) {
DBGC ( xfer, "XFER %p<-%p redirect: %s\n", xfer, dest,
DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " redirect "
"failed: %s\n", INTF_INTF_DBG ( intf, dest ),
strerror ( rc ) );
}
xfer_put ( dest );
return rc;
}
/**
* Send redirection event
*
* @v xfer Data transfer interface
* @v type New location type
* @v ... Remaining arguments depend upon location type
* @ret rc Return status code
*/
int xfer_redirect ( struct xfer_interface *xfer, int type, ... ) {
va_list args;
int rc;
va_start ( args, type );
rc = xfer_vredirect ( xfer, type, args );
va_end ( args );
intf_put ( dest );
return rc;
}
/**
* Check flow control window
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @ret len Length of window
*/
size_t xfer_window ( struct xfer_interface *xfer ) {
struct xfer_interface *dest = xfer_get_dest ( xfer );
size_t xfer_window ( struct interface *intf ) {
struct interface *dest;
xfer_window_TYPE ( void * ) *op =
intf_get_dest_op ( intf, xfer_window, &dest );
void *object = intf_object ( dest );
size_t len;
len = dest->op->window ( dest );
if ( op ) {
len = op ( object );
} else {
/* Default is to provide an unlimited window */
len = ~( ( size_t ) 0 );
}
xfer_put ( dest );
intf_put ( dest );
return len;
}
/**
* Allocate I/O buffer
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v len I/O buffer payload length
* @ret iobuf I/O buffer
*/
struct io_buffer * xfer_alloc_iob ( struct xfer_interface *xfer, size_t len ) {
struct xfer_interface *dest = xfer_get_dest ( xfer );
struct io_buffer * xfer_alloc_iob ( struct interface *intf, size_t len ) {
struct interface *dest;
xfer_alloc_iob_TYPE ( void * ) *op =
intf_get_dest_op ( intf, xfer_alloc_iob, &dest );
void *object = intf_object ( dest );
struct io_buffer *iobuf;
DBGC ( xfer, "XFER %p->%p alloc_iob %zd\n", xfer, dest, len );
DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " alloc_iob %zd\n",
INTF_INTF_DBG ( intf, dest ), len );
iobuf = dest->op->alloc_iob ( dest, len );
if ( op ) {
iobuf = op ( object, len );
} else {
/* Default is to allocate an I/O buffer with no
* reserved space.
*/
iobuf = alloc_iob ( len );
}
if ( ! iobuf ) {
DBGC ( xfer, "XFER %p<-%p alloc_iob failed\n", xfer, dest );
DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " alloc_iob "
"failed\n", INTF_INTF_DBG ( intf, dest ) );
}
xfer_put ( dest );
intf_put ( dest );
return iobuf;
}
/**
* Deliver datagram as I/O buffer with metadata
* Deliver datagram
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v iobuf Datagram I/O buffer
* @v meta Data transfer metadata
* @ret rc Return status code
*/
int xfer_deliver_iob_meta ( struct xfer_interface *xfer,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
struct xfer_interface *dest = xfer_get_dest ( xfer );
int xfer_deliver ( struct interface *intf,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
struct interface *dest;
xfer_deliver_TYPE ( void * ) *op =
intf_get_dest_op ( intf, xfer_deliver, &dest );
void *object = intf_object ( dest );
int rc;
DBGC ( xfer, "XFER %p->%p deliver_iob %zd\n", xfer, dest,
iob_len ( iobuf ) );
DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " deliver %zd\n",
INTF_INTF_DBG ( intf, dest ), iob_len ( iobuf ) );
rc = dest->op->deliver_iob ( dest, iobuf, meta );
if ( op ) {
rc = op ( object, iobuf, meta );
} else {
/* Default is to discard the I/O buffer */
free_iob ( iobuf );
rc = -EPIPE;
}
if ( rc != 0 ) {
DBGC ( xfer, "XFER %p<-%p deliver_iob: %s\n", xfer, dest,
strerror ( rc ) );
DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT
" deliver failed: %s\n",
INTF_INTF_DBG ( intf, dest ), strerror ( rc ) );
}
xfer_put ( dest );
intf_put ( dest );
return rc;
}
/*****************************************************************************
*
* Data transfer interface helper functions
*
*/
/**
* Send redirection event
*
* @v intf Data transfer interface
* @v type New location type
* @v ... Remaining arguments depend upon location type
* @ret rc Return status code
*/
int xfer_redirect ( struct interface *intf, int type, ... ) {
va_list args;
int rc;
va_start ( args, type );
rc = xfer_vredirect ( intf, type, args );
va_end ( args );
return rc;
}
/**
* Deliver datagram as I/O buffer with metadata
* Deliver datagram as I/O buffer without metadata
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v iobuf Datagram I/O buffer
* @ret rc Return status code
*/
int xfer_deliver_iob ( struct xfer_interface *xfer,
struct io_buffer *iobuf ) {
return xfer_deliver_iob_meta ( xfer, iobuf, &dummy_metadata );
int xfer_deliver_iob ( struct interface *intf, struct io_buffer *iobuf ) {
return xfer_deliver ( intf, iobuf, &dummy_metadata );
}
/**
* Deliver datagram as raw data
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v iobuf Datagram I/O buffer
* @ret rc Return status code
*/
int xfer_deliver_raw ( struct xfer_interface *xfer,
const void *data, size_t len ) {
struct xfer_interface *dest = xfer_get_dest ( xfer );
int rc;
int xfer_deliver_raw ( struct interface *intf, const void *data, size_t len ) {
struct io_buffer *iobuf;
DBGC ( xfer, "XFER %p->%p deliver_raw %p+%zd\n", xfer, dest,
data, len );
iobuf = xfer_alloc_iob ( intf, len );
if ( ! iobuf )
return -ENOMEM;
rc = dest->op->deliver_raw ( dest, data, len );
if ( rc != 0 ) {
DBGC ( xfer, "XFER %p<-%p deliver_raw: %s\n", xfer, dest,
strerror ( rc ) );
}
xfer_put ( dest );
return rc;
memcpy ( iob_put ( iobuf, len ), data, len );
return xfer_deliver_iob ( intf, iobuf );
}
/**
* Deliver formatted string
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v format Format string
* @v args Arguments corresponding to the format string
* @ret rc Return status code
*/
int xfer_vprintf ( struct xfer_interface *xfer, const char *format,
int xfer_vprintf ( struct interface *intf, const char *format,
va_list args ) {
size_t len;
va_list args_tmp;
@@ -219,24 +249,24 @@ int xfer_vprintf ( struct xfer_interface *xfer, const char *format,
char buf[len + 1];
vsnprintf ( buf, sizeof ( buf ), format, args_tmp );
va_end ( args_tmp );
return xfer_deliver_raw ( xfer, buf, len );
return xfer_deliver_raw ( intf, buf, len );
}
}
/**
* Deliver formatted string
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v format Format string
* @v ... Arguments corresponding to the format string
* @ret rc Return status code
*/
int xfer_printf ( struct xfer_interface *xfer, const char *format, ... ) {
int xfer_printf ( struct interface *intf, const char *format, ... ) {
va_list args;
int rc;
va_start ( args, format );
rc = xfer_vprintf ( xfer, format, args );
rc = xfer_vprintf ( intf, format, args );
va_end ( args );
return rc;
}
@@ -244,174 +274,25 @@ int xfer_printf ( struct xfer_interface *xfer, const char *format, ... ) {
/**
* Seek to position
*
* @v xfer Data transfer interface
* @v intf Data transfer interface
* @v offset Offset to new position
* @v whence Basis for new position
* @ret rc Return status code
*/
int xfer_seek ( struct xfer_interface *xfer, off_t offset, int whence ) {
int xfer_seek ( struct interface *intf, off_t offset, int whence ) {
struct io_buffer *iobuf;
struct xfer_metadata meta = {
.offset = offset,
.whence = whence,
};
DBGC ( xfer, "XFER %p seek %s+%ld\n", xfer,
whence_text ( whence ), offset );
DBGC ( INTF_COL ( intf ), "INTF " INTF_FMT " seek %s+%ld\n",
INTF_DBG ( intf ), whence_text ( whence ), offset );
/* Allocate and send a zero-length data buffer */
iobuf = xfer_alloc_iob ( xfer, 0 );
if ( ! iobuf )
return -ENOMEM;
return xfer_deliver_iob_meta ( xfer, iobuf, &meta );
}
/****************************************************************************
*
* Helper methods
*
* These functions are designed to be used as methods in the
* xfer_interface_operations table.
*
*/
/**
* Ignore close() event
*
* @v xfer Data transfer interface
* @v rc Reason for close
*/
void ignore_xfer_close ( struct xfer_interface *xfer __unused,
int rc __unused ) {
/* Nothing to do */
}
/**
* Ignore vredirect() event
*
* @v xfer Data transfer interface
* @v type New location type
* @v args Remaining arguments depend upon location type
* @ret rc Return status code
*/
int ignore_xfer_vredirect ( struct xfer_interface *xfer __unused,
int type __unused, va_list args __unused ) {
return 0;
}
/**
* Unlimited flow control window
*
* @v xfer Data transfer interface
* @ret len Length of window
*
* This handler indicates that the interface is always ready to accept
* data.
*/
size_t unlimited_xfer_window ( struct xfer_interface *xfer __unused ) {
return ~( ( size_t ) 0 );
}
/**
* No flow control window
*
* @v xfer Data transfer interface
* @ret len Length of window
*
* This handler indicates that the interface is never ready to accept
* data.
*/
size_t no_xfer_window ( struct xfer_interface *xfer __unused ) {
return 0;
}
/**
* Allocate I/O buffer
*
* @v xfer Data transfer interface
* @v len I/O buffer payload length
* @ret iobuf I/O buffer
*/
struct io_buffer *
default_xfer_alloc_iob ( struct xfer_interface *xfer __unused, size_t len ) {
return alloc_iob ( len );
}
/**
* Deliver datagram as raw data
*
* @v xfer Data transfer interface
* @v iobuf Datagram I/O buffer
* @v meta Data transfer metadata
* @ret rc Return status code
*
* This function is intended to be used as the deliver() method for
* data transfer interfaces that prefer to handle raw data.
*/
int xfer_deliver_as_raw ( struct xfer_interface *xfer,
struct io_buffer *iobuf,
struct xfer_metadata *meta __unused ) {
int rc;
rc = xfer->op->deliver_raw ( xfer, iobuf->data, iob_len ( iobuf ) );
free_iob ( iobuf );
return rc;
}
/**
* Deliver datagram as I/O buffer
*
* @v xfer Data transfer interface
* @v data Data buffer
* @v len Length of data buffer
* @ret rc Return status code
*
* This function is intended to be used as the deliver_raw() method
* for data transfer interfaces that prefer to handle I/O buffers.
*/
int xfer_deliver_as_iob ( struct xfer_interface *xfer,
const void *data, size_t len ) {
struct io_buffer *iobuf;
iobuf = xfer->op->alloc_iob ( xfer, len );
iobuf = xfer_alloc_iob ( intf, 0 );
if ( ! iobuf )
return -ENOMEM;
memcpy ( iob_put ( iobuf, len ), data, len );
return xfer->op->deliver_iob ( xfer, iobuf, &dummy_metadata );
return xfer_deliver ( intf, iobuf, &meta );
}
/**
* Ignore datagram as raw data event
*
* @v xfer Data transfer interface
* @v data Data buffer
* @v len Length of data buffer
* @ret rc Return status code
*/
int ignore_xfer_deliver_raw ( struct xfer_interface *xfer,
const void *data __unused, size_t len ) {
DBGC ( xfer, "XFER %p %zd bytes delivered %s\n", xfer, len,
( ( xfer == &null_xfer ) ?
"before connection" : "after termination" ) );
return 0;
}
/** Null data transfer interface operations */
struct xfer_interface_operations null_xfer_ops = {
.close = ignore_xfer_close,
.vredirect = ignore_xfer_vredirect,
.window = unlimited_xfer_window,
.alloc_iob = default_xfer_alloc_iob,
.deliver_iob = xfer_deliver_as_raw,
.deliver_raw = ignore_xfer_deliver_raw,
};
/**
* Null data transfer interface
*
* This is the interface to which data transfer interfaces are
* connected when unplugged. It will never generate messages, and
* will silently absorb all received messages.
*/
struct xfer_interface null_xfer = XFER_INIT ( &null_xfer_ops );