src/core/xfer.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 <string.h>
  20 #include <errno.h>
  21 #include <gpxe/xfer.h>
  22
  23 /** @file
  24  *
  25  * Data transfer interfaces
  26  *
  27  */
  28
  29 /**
  30  * Close data transfer interface
  31  *
  32  * @v xfer              Data transfer interface
  33  * @v rc                Reason for close
  34  */
  35 void xfer_close ( struct xfer_interface *xfer, int rc ) {
  36         struct xfer_interface *dest = xfer_dest ( xfer );
  37
  38         dest->op->close ( dest, rc );
  39         xfer_unplug ( xfer );
  40 }
  41
  42 /**
  43  * Seek to position
  44  *
  45  * @v xfer              Data transfer interface
  46  * @v pos               New position
  47  * @ret rc              Return status code
  48  */
  49 int xfer_seek ( struct xfer_interface *xfer, size_t pos ) {
  50         struct xfer_interface *dest = xfer_dest ( xfer );
  51
  52         return dest->op->seek ( dest, pos );
  53 }
  54
  55 /**
  56  * Send redirection event
  57  *
  58  * @v xfer              Data transfer interface
  59  * @v type              New location type
  60  * @v args              Remaining arguments depend upon location type
  61  * @ret rc              Return status code
  62  */
  63 int xfer_vredirect ( struct xfer_interface *xfer, int type, va_list args ) {
  64         struct xfer_interface *dest = xfer_dest ( xfer );
  65
  66         return dest->op->vredirect ( dest, type, args );
  67 }
  68
  69 /**
  70  * Send redirection event
  71  *
  72  * @v xfer              Data transfer interface
  73  * @v type              New location type
  74  * @v ...               Remaining arguments depend upon location type
  75  * @ret rc              Return status code
  76  */
  77 int xfer_redirect ( struct xfer_interface *xfer, int type, ... ) {
  78         va_list args;
  79         int rc;
  80
  81         va_start ( args, type );
  82         rc = xfer_vredirect ( xfer, type, args );
  83         va_end ( args );
  84         return rc;
  85 }
  86
  87 /**
  88  * Deliver datagram
  89  *
  90  * @v xfer              Data transfer interface
  91  * @v iobuf             Datagram I/O buffer
  92  * @ret rc              Return status code
  93  */
  94 int xfer_deliver ( struct xfer_interface *xfer, struct io_buffer *iobuf ) {
  95         struct xfer_interface *dest = xfer_dest ( xfer );
  96
  97         return dest->op->deliver ( dest, iobuf );
  98 }
  99
 100 /**
 101  * Deliver datagram as raw data
 102  *
 103  * @v xfer              Data transfer interface
 104  * @v iobuf             Datagram I/O buffer
 105  * @ret rc              Return status code
 106  */
 107 int xfer_deliver_raw ( struct xfer_interface *xfer,
 108                        const void *data, size_t len ) {
 109         struct xfer_interface *dest = xfer_dest ( xfer );
 110
 111         return dest->op->deliver_raw ( dest, data, len );
 112 }
 113
 114 /****************************************************************************
 115  *
 116  * Helper methods
 117  *
 118  * These functions are designed to be used as methods in the
 119  * xfer_interface_operations table.
 120  *
 121  */
 122
 123 /**
 124  * Ignore start() event
 125  *
 126  * @v xfer              Data transfer interface
 127  */
 128 void ignore_xfer_start ( struct xfer_interface *xfer __unused ) {
 129         /* Nothing to do */
 130 }
 131
 132 /**
 133  * Ignore close() event
 134  *
 135  * @v xfer              Data transfer interface
 136  * @v rc                Reason for close
 137  */
 138 void ignore_xfer_close ( struct xfer_interface *xfer __unused,
 139                          int rc __unused ) {
 140         /* Nothing to do */
 141 }
 142
 143 /**
 144  * Ignore vredirect() event
 145  *
 146  * @v xfer              Data transfer interface
 147  * @v type              New location type
 148  * @v args              Remaining arguments depend upon location type
 149  * @ret rc              Return status code
 150  */
 151 int ignore_xfer_vredirect ( struct xfer_interface *xfer __unused,
 152                             int type __unused, va_list args __unused ) {
 153         return 0;
 154 }
 155
 156 /**
 157  * Ignore seek() event
 158  *
 159  * @v xfer              Data transfer interface
 160  * @v pos               New position
 161  * @ret rc              Return status code
 162  */
 163 int ignore_xfer_seek ( struct xfer_interface *xfer __unused,
 164                        size_t pos __unused ) {
 165         return 0;
 166 }
 167
 168 /**
 169  * Deliver datagram as raw data
 170  *
 171  * @v xfer              Data transfer interface
 172  * @v iobuf             Datagram I/O buffer
 173  * @ret rc              Return status code
 174  *
 175  * This function is intended to be used as the deliver() method for
 176  * data transfer interfaces that prefer to handle raw data.
 177  */
 178 int xfer_deliver_as_raw ( struct xfer_interface *xfer,
 179                           struct io_buffer *iobuf ) {
 180         int rc;
 181
 182         rc = xfer->op->deliver_raw ( xfer, iobuf->data, iob_len ( iobuf ) );
 183         free_iob ( iobuf );
 184         return rc;
 185 }
 186
 187 /**
 188  * Deliver datagram as I/O buffer
 189  *
 190  * @v xfer              Data transfer interface
 191  * @v data              Data buffer
 192  * @v len               Length of data buffer
 193  * @ret rc              Return status code
 194  *
 195  * This function is intended to be used as the deliver_raw() method
 196  * for data transfer interfaces that prefer to handle I/O buffers.
 197  */
 198 int xfer_deliver_as_iobuf ( struct xfer_interface *xfer,
 199                             const void *data, size_t len ) {
 200         struct io_buffer *iobuf;
 201
 202         iobuf = alloc_iob ( len );
 203         if ( ! iobuf )
 204                 return -ENOMEM;
 205
 206         memcpy ( iob_put ( iobuf, len ), data, len );
 207         return xfer->op->deliver ( xfer, iobuf );
 208 }
 209
 210 /**
 211  * Ignore datagram as raw data event
 212  *
 213  * @v xfer              Data transfer interface
 214  * @v data              Data buffer
 215  * @v len               Length of data buffer
 216  * @ret rc              Return status code
 217  */
 218 int ignore_xfer_deliver_raw ( struct xfer_interface *xfer,
 219                               const void *data __unused, size_t len ) {
 220         DBGC ( xfer, "XFER %p %zd bytes delivered %s\n", xfer, len,
 221                ( ( xfer == &null_xfer ) ?
 222                  "before connection" : "after termination" ) );
 223         return 0;
 224 }
 225
 226 /** Null data transfer interface operations */
 227 struct xfer_interface_operations null_xfer_ops = {
 228         .start          = ignore_xfer_start,
 229         .close          = ignore_xfer_close,
 230         .vredirect      = ignore_xfer_vredirect,
 231         .seek           = ignore_xfer_seek,
 232         .deliver        = xfer_deliver_as_raw,
 233         .deliver_raw    = ignore_xfer_deliver_raw,
 234 };
 235
 236 /**
 237  * Null data transfer interface
 238  *
 239  * This is the interface to which data transfer interfaces are
 240  * connected when unplugged.  It will never generate messages, and
 241  * will silently absorb all received messages.
 242  */
 243 struct xfer_interface null_xfer = {
 244         .intf = {
 245                 .dest = &null_xfer.intf,
 246                 .refcnt = NULL,
 247         },
 248         .op = &null_xfer_ops,
 249 };