|
@@ -0,0 +1,286 @@
|
|
1
|
+/*
|
|
2
|
+ * Copyright (C) 2015 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 (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
17
|
+ * 02110-1301, USA.
|
|
18
|
+ *
|
|
19
|
+ * You can also choose to distribute this program under the terms of
|
|
20
|
+ * the Unmodified Binary Distribution Licence (as given in the file
|
|
21
|
+ * COPYING.UBDL), provided that you have satisfied its requirements.
|
|
22
|
+ */
|
|
23
|
+
|
|
24
|
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
|
|
25
|
+
|
|
26
|
+#include <stddef.h>
|
|
27
|
+#include <stdlib.h>
|
|
28
|
+#include <stdio.h>
|
|
29
|
+#include <string.h>
|
|
30
|
+#include <ctype.h>
|
|
31
|
+#include <errno.h>
|
|
32
|
+#include <assert.h>
|
|
33
|
+#include <ipxe/pccrd.h>
|
|
34
|
+
|
|
35
|
+/** @file
|
|
36
|
+ *
|
|
37
|
+ * Peer Content Caching and Retrieval: Discovery Protocol [MS-PCCRD]
|
|
38
|
+ *
|
|
39
|
+ * This protocol manages to ingeniously combine the excessive
|
|
40
|
+ * verbosity of XML with a paucity of actual information. For
|
|
41
|
+ * example: even in version 2.0 of the protocol it is still not
|
|
42
|
+ * possible to discover which peers hold a specific block within a
|
|
43
|
+ * given segment.
|
|
44
|
+ *
|
|
45
|
+ * For added bonus points, version 1.0 of the protocol is specified to
|
|
46
|
+ * use a case-sensitive string comparison (for SHA2 digest values) but
|
|
47
|
+ * nothing specifies whether the strings in question should be in
|
|
48
|
+ * upper or lower case. There are example strings given in the
|
|
49
|
+ * specification, but the author skilfully manages to leave the issue
|
|
50
|
+ * unresolved by using the somewhat implausible digest value of
|
|
51
|
+ * "0200000000000000000000000000000000000000000000000000000000000000".
|
|
52
|
+ *
|
|
53
|
+ * Just in case you were thinking that the silver lining of the choice
|
|
54
|
+ * to use an XML-based protocol would be the ability to generate and
|
|
55
|
+ * process messages with standard tools, version 2.0 of the protocol
|
|
56
|
+ * places most of the critical information inside a Base64-encoded
|
|
57
|
+ * custom binary data structure. Within an XML element, naturally.
|
|
58
|
+ *
|
|
59
|
+ * I hereby announce this specification to be the 2015 winner of the
|
|
60
|
+ * prestigious "UEFI HII API" award for incompetent design.
|
|
61
|
+ */
|
|
62
|
+
|
|
63
|
+/** Discovery request format */
|
|
64
|
+#define PEERDIST_DISCOVERY_REQUEST \
|
|
65
|
+ "<?xml version=\"1.0\" encoding=\"utf-8\"?>" \
|
|
66
|
+ "<soap:Envelope " \
|
|
67
|
+ "xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" " \
|
|
68
|
+ "xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" " \
|
|
69
|
+ "xmlns:wsd=\"http://schemas.xmlsoap.org/ws/2005/04/discovery\" " \
|
|
70
|
+ "xmlns:PeerDist=\"http://schemas.microsoft.com/p2p/" \
|
|
71
|
+ "2007/09/PeerDistributionDiscovery\">" \
|
|
72
|
+ "<soap:Header>" \
|
|
73
|
+ "<wsa:To>" \
|
|
74
|
+ "urn:schemas-xmlsoap-org:ws:2005:04:discovery" \
|
|
75
|
+ "</wsa:To>" \
|
|
76
|
+ "<wsa:Action>" \
|
|
77
|
+ "http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe" \
|
|
78
|
+ "</wsa:Action>" \
|
|
79
|
+ "<wsa:MessageID>" \
|
|
80
|
+ "urn:uuid:%s" \
|
|
81
|
+ "</wsa:MessageID>" \
|
|
82
|
+ "</soap:Header>" \
|
|
83
|
+ "<soap:Body>" \
|
|
84
|
+ "<wsd:Probe>" \
|
|
85
|
+ "<wsd:Types>" \
|
|
86
|
+ "PeerDist:PeerDistData" \
|
|
87
|
+ "</wsd:Types>" \
|
|
88
|
+ "<wsd:Scopes MatchBy=\"http://schemas.xmlsoap.org/ws/" \
|
|
89
|
+ "2005/04/discovery/strcmp0\">" \
|
|
90
|
+ "%s" \
|
|
91
|
+ "</wsd:Scopes>" \
|
|
92
|
+ "</wsd:Probe>" \
|
|
93
|
+ "</soap:Body>" \
|
|
94
|
+ "</soap:Envelope>"
|
|
95
|
+
|
|
96
|
+/**
|
|
97
|
+ * Construct discovery request
|
|
98
|
+ *
|
|
99
|
+ * @v uuid Message UUID string
|
|
100
|
+ * @v id Segment identifier string
|
|
101
|
+ * @ret request Discovery request, or NULL on failure
|
|
102
|
+ *
|
|
103
|
+ * The request is dynamically allocated; the caller must eventually
|
|
104
|
+ * free() the request.
|
|
105
|
+ */
|
|
106
|
+char * peerdist_discovery_request ( const char *uuid, const char *id ) {
|
|
107
|
+ char *request;
|
|
108
|
+ int len;
|
|
109
|
+
|
|
110
|
+ /* Construct request */
|
|
111
|
+ len = asprintf ( &request, PEERDIST_DISCOVERY_REQUEST, uuid, id );
|
|
112
|
+ if ( len < 0 )
|
|
113
|
+ return NULL;
|
|
114
|
+
|
|
115
|
+ return request;
|
|
116
|
+}
|
|
117
|
+
|
|
118
|
+/**
|
|
119
|
+ * Locate discovery reply tag
|
|
120
|
+ *
|
|
121
|
+ * @v data Reply data (not NUL-terminated)
|
|
122
|
+ * @v len Length of reply data
|
|
123
|
+ * @v tag XML tag
|
|
124
|
+ * @ret found Found tag (or NULL if not found)
|
|
125
|
+ */
|
|
126
|
+static char * peerdist_discovery_reply_tag ( char *data, size_t len,
|
|
127
|
+ const char *tag ) {
|
|
128
|
+ size_t tag_len = strlen ( tag );
|
|
129
|
+
|
|
130
|
+ /* Search, allowing for the fact that the reply data is not
|
|
131
|
+ * cleanly NUL-terminated and may contain embedded NULs due to
|
|
132
|
+ * earlier parsing.
|
|
133
|
+ */
|
|
134
|
+ for ( ; len >= tag_len ; data++, len-- ) {
|
|
135
|
+ if ( strncmp ( data, tag, tag_len ) == 0 )
|
|
136
|
+ return data;
|
|
137
|
+ }
|
|
138
|
+ return NULL;
|
|
139
|
+}
|
|
140
|
+
|
|
141
|
+/**
|
|
142
|
+ * Locate discovery reply values
|
|
143
|
+ *
|
|
144
|
+ * @v data Reply data (not NUL-terminated, will be modified)
|
|
145
|
+ * @v len Length of reply data
|
|
146
|
+ * @v name XML tag name
|
|
147
|
+ * @ret values Tag values (or NULL if not found)
|
|
148
|
+ *
|
|
149
|
+ * The reply data is modified by adding NULs and moving characters as
|
|
150
|
+ * needed to produce a NUL-separated list of values, terminated with a
|
|
151
|
+ * zero-length string.
|
|
152
|
+ *
|
|
153
|
+ * This is not supposed to be a full XML parser; it's supposed to
|
|
154
|
+ * include just enough functionality to allow PeerDist discovery to
|
|
155
|
+ * work with existing implementations.
|
|
156
|
+ */
|
|
157
|
+static char * peerdist_discovery_reply_values ( char *data, size_t len,
|
|
158
|
+ const char *name ) {
|
|
159
|
+ char buf[ 2 /* "</" */ + strlen ( name ) + 1 /* ">" */ + 1 /* NUL */ ];
|
|
160
|
+ char *open;
|
|
161
|
+ char *close;
|
|
162
|
+ char *start;
|
|
163
|
+ char *end;
|
|
164
|
+ char *in;
|
|
165
|
+ char *out;
|
|
166
|
+ char c;
|
|
167
|
+
|
|
168
|
+ /* Locate opening tag */
|
|
169
|
+ snprintf ( buf, sizeof ( buf ), "<%s>", name );
|
|
170
|
+ open = peerdist_discovery_reply_tag ( data, len, buf );
|
|
171
|
+ if ( ! open )
|
|
172
|
+ return NULL;
|
|
173
|
+ start = ( open + strlen ( buf ) );
|
|
174
|
+ len -= ( start - data );
|
|
175
|
+ data = start;
|
|
176
|
+
|
|
177
|
+ /* Locate closing tag */
|
|
178
|
+ snprintf ( buf, sizeof ( buf ), "</%s>", name );
|
|
179
|
+ close = peerdist_discovery_reply_tag ( data, len, buf );
|
|
180
|
+ if ( ! close )
|
|
181
|
+ return NULL;
|
|
182
|
+ assert ( close >= open );
|
|
183
|
+ end = close;
|
|
184
|
+
|
|
185
|
+ /* Strip initial whitespace, convert other whitespace
|
|
186
|
+ * sequences to single NULs, add terminating pair of NULs.
|
|
187
|
+ * This will probably overwrite part of the closing tag.
|
|
188
|
+ */
|
|
189
|
+ for ( in = start, out = start ; in < end ; in++ ) {
|
|
190
|
+ c = *in;
|
|
191
|
+ if ( isspace ( c ) ) {
|
|
192
|
+ if ( ( out > start ) && ( out[-1] != '\0' ) )
|
|
193
|
+ *(out++) = '\0';
|
|
194
|
+ } else {
|
|
195
|
+ *(out++) = c;
|
|
196
|
+ }
|
|
197
|
+ }
|
|
198
|
+ *(out++) = '\0';
|
|
199
|
+ *(out++) = '\0';
|
|
200
|
+ assert ( out < ( close + strlen ( buf ) ) );
|
|
201
|
+
|
|
202
|
+ return start;
|
|
203
|
+}
|
|
204
|
+
|
|
205
|
+/**
|
|
206
|
+ * Parse discovery reply
|
|
207
|
+ *
|
|
208
|
+ * @v data Reply data (not NUL-terminated, will be modified)
|
|
209
|
+ * @v len Length of reply data
|
|
210
|
+ * @v reply Discovery reply to fill in
|
|
211
|
+ * @ret rc Return status code
|
|
212
|
+ *
|
|
213
|
+ * The discovery reply includes pointers to strings within the
|
|
214
|
+ * modified reply data.
|
|
215
|
+ */
|
|
216
|
+int peerdist_discovery_reply ( char *data, size_t len,
|
|
217
|
+ struct peerdist_discovery_reply *reply ) {
|
|
218
|
+ static const struct peerdist_discovery_block_count zcount = {
|
|
219
|
+ .hex = "00000000",
|
|
220
|
+ };
|
|
221
|
+ struct peerdist_discovery_block_count *count;
|
|
222
|
+ unsigned int max;
|
|
223
|
+ unsigned int i;
|
|
224
|
+ char *scopes;
|
|
225
|
+ char *xaddrs;
|
|
226
|
+ char *blockcount;
|
|
227
|
+ char *in;
|
|
228
|
+ char *out;
|
|
229
|
+ size_t skip;
|
|
230
|
+
|
|
231
|
+ /* Find <wsd:Scopes> tag */
|
|
232
|
+ scopes = peerdist_discovery_reply_values ( data, len, "wsd:Scopes" );
|
|
233
|
+ if ( ! scopes ) {
|
|
234
|
+ DBGC ( reply, "PCCRD %p missing <wsd:Scopes> tag\n", reply );
|
|
235
|
+ return -ENOENT;
|
|
236
|
+ }
|
|
237
|
+
|
|
238
|
+ /* Find <wsd:XAddrs> tag */
|
|
239
|
+ xaddrs = peerdist_discovery_reply_values ( data, len, "wsd:XAddrs" );
|
|
240
|
+ if ( ! xaddrs ) {
|
|
241
|
+ DBGC ( reply, "PCCRD %p missing <wsd:XAddrs> tag\n", reply );
|
|
242
|
+ return -ENOENT;
|
|
243
|
+ }
|
|
244
|
+
|
|
245
|
+ /* Find <PeerDist:BlockCount> tag */
|
|
246
|
+ blockcount = peerdist_discovery_reply_values ( data, len,
|
|
247
|
+ "PeerDist:BlockCount" );
|
|
248
|
+ if ( ! blockcount ) {
|
|
249
|
+ DBGC ( reply, "PCCRD %p missing <PeerDist:BlockCount> tag\n",
|
|
250
|
+ reply );
|
|
251
|
+ return -ENOENT;
|
|
252
|
+ }
|
|
253
|
+
|
|
254
|
+ /* Determine maximum number of segments (according to number
|
|
255
|
+ * of entries in the block count list).
|
|
256
|
+ */
|
|
257
|
+ max = ( strlen ( blockcount ) / sizeof ( *count ) );
|
|
258
|
+ count = container_of ( blockcount,
|
|
259
|
+ struct peerdist_discovery_block_count, hex[0] );
|
|
260
|
+
|
|
261
|
+ /* Eliminate any segments with a zero block count */
|
|
262
|
+ for ( i = 0, in = scopes, out = scopes ; *in ; i++, in += skip ) {
|
|
263
|
+
|
|
264
|
+ /* Fail if we have overrun the maximum number of segments */
|
|
265
|
+ if ( i >= max ) {
|
|
266
|
+ DBGC ( reply, "PCCRD %p too many segment IDs\n",
|
|
267
|
+ reply );
|
|
268
|
+ return -EPROTO;
|
|
269
|
+ }
|
|
270
|
+
|
|
271
|
+ /* Delete segment if block count is zero */
|
|
272
|
+ skip = ( strlen ( in ) + 1 /* NUL */ );
|
|
273
|
+ if ( memcmp ( count[i].hex, zcount.hex,
|
|
274
|
+ sizeof ( zcount.hex ) ) == 0 )
|
|
275
|
+ continue;
|
|
276
|
+ strcpy ( out, in );
|
|
277
|
+ out += skip;
|
|
278
|
+ }
|
|
279
|
+ out[0] = '\0'; /* Ensure list is terminated with a zero-length string */
|
|
280
|
+
|
|
281
|
+ /* Fill in discovery reply */
|
|
282
|
+ reply->ids = scopes;
|
|
283
|
+ reply->locations = xaddrs;
|
|
284
|
+
|
|
285
|
+ return 0;
|
|
286
|
+}
|