1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
/*
* 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.
*/
#include <string.h>
#include <errno.h>
#include <gpxe/xfer.h>
/** @file
*
* Data transfer interfaces
*
*/
/**
* Close data transfer interface
*
* @v xfer Data transfer interface
* @v rc Reason for close
*/
void close ( struct xfer_interface *xfer, int rc ) {
struct xfer_interface *dest = xfer_dest ( xfer );
dest->op->close ( dest, rc );
xfer_unplug ( xfer );
}
/**
* Seek to position
*
* @v xfer Data transfer interface
* @v pos New position
* @ret rc Return status code
*/
int seek ( struct xfer_interface *xfer, size_t pos ) {
struct xfer_interface *dest = xfer_dest ( xfer );
return dest->op->seek ( dest, pos );
}
/**
* Send redirection 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 vredirect ( struct xfer_interface *xfer, int type, va_list args ) {
struct xfer_interface *dest = xfer_dest ( xfer );
return dest->op->vredirect ( dest, type, args );
}
/**
* 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 redirect ( struct xfer_interface *xfer, int type, ... ) {
va_list args;
int rc;
va_start ( args, type );
rc = vredirect ( xfer, type, args );
va_end ( args );
return rc;
}
/**
* Deliver datagram
*
* @v xfer Data transfer interface
* @v iobuf Datagram I/O buffer
* @ret rc Return status code
*/
int deliver ( struct xfer_interface *xfer, struct io_buffer *iobuf ) {
struct xfer_interface *dest = xfer_dest ( xfer );
return dest->op->deliver ( dest, iobuf );
}
/**
* Deliver datagram as raw data
*
* @v xfer Data transfer interface
* @v iobuf Datagram I/O buffer
* @ret rc Return status code
*/
int deliver_raw ( struct xfer_interface *xfer, const void *data, size_t len ) {
struct xfer_interface *dest = xfer_dest ( xfer );
return dest->op->deliver_raw ( dest, data, len );
}
/****************************************************************************
*
* Helper methods
*
* These functions are designed to be used as methods in the
* xfer_interface_operations table.
*
*/
/**
* Ignore close()
*
* @v xfer Data transfer interface
* @v rc Reason for close
*/
void ignore_close ( struct xfer_interface *xfer __unused, int rc __unused ) {
/* Nothing to do */
}
/**
* Ignore vredirect()
*
* @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_vredirect ( struct xfer_interface *xfer __unused,
int type __unused, va_list args __unused ) {
return 0;
}
/**
* Ignore seek()
*
* @v xfer Data transfer interface
* @v pos New position
* @ret rc Return status code
*/
int ignore_seek ( struct xfer_interface *xfer __unused, size_t pos __unused ) {
return 0;
}
/**
* Deliver datagram as raw data
*
* @v xfer Data transfer interface
* @v iobuf Datagram I/O buffer
* @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 deliver_as_raw ( struct xfer_interface *xfer,
struct io_buffer *iobuf ) {
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 deliver_as_iobuf ( struct xfer_interface *xfer,
const void *data, size_t len ) {
struct io_buffer *iobuf;
iobuf = alloc_iob ( len );
if ( ! iobuf )
return -ENOMEM;
memcpy ( iob_put ( iobuf, len ), data, len );
return xfer->op->deliver ( xfer, iobuf );
}
/**
* Ignore datagram as raw data
*
* @v xfer Data transfer interface
* @v data Data buffer
* @v len Length of data buffer
* @ret rc Return status code
*/
int ignore_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_close,
.vredirect = ignore_vredirect,
.seek = ignore_seek,
.deliver = deliver_as_raw,
.deliver_raw = ignore_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 = {
.intf = {
.dest = &null_xfer.intf,
.refcnt = null_refcnt,
},
.op = &null_xfer_ops,
};
|
