← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/ipxe/src/include/ipxe/pccrr.h

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/ipxe/src/include/ipxe/pccrr.h
 
1
#ifndef _IPXE_PCCRR_H
 
2
#define _IPXE_PCCRR_H
 
3
 
 
4
/** @file
 
5
 *
 
6
 * Peer Content Caching and Retrieval: Retrieval Protocol [MS-PCCRR]
 
7
 *
 
8
 * All fields are in network byte order.
 
9
 *
 
10
 */
 
11
 
 
12
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
13
 
 
14
#include <stdint.h>
 
15
#include <ipxe/uaccess.h>
 
16
 
 
17
/** Magic retrieval URI path */
 
18
#define PEERDIST_MAGIC_PATH "/116B50EB-ECE2-41ac-8429-9F9E963361B7/"
 
19
 
 
20
/** Retrieval protocol version */
 
21
union peerdist_msg_version {
 
22
        /** Raw version number */
 
23
        uint32_t raw;
 
24
        /** Major:minor version number */
 
25
        struct {
 
26
                /** Minor version number */
 
27
                uint16_t minor;
 
28
                /** Major version number */
 
29
                uint16_t major;
 
30
        } __attribute__ (( packed ));
 
31
} __attribute__ (( packed ));
 
32
 
 
33
/** Retrieval protocol version 1.0 */
 
34
#define PEERDIST_MSG_VERSION_1_0 0x00000001UL
 
35
 
 
36
/** Retrieval protocol version 2.0 */
 
37
#define PEERDIST_MSG_VERSION_2_0 0x00000002UL
 
38
 
 
39
/** Retrieval protocol supported versions */
 
40
struct peerdist_msg_versions {
 
41
        /** Minimum supported protocol version */
 
42
        union peerdist_msg_version min;
 
43
        /** Maximum supported protocol version */
 
44
        union peerdist_msg_version max;
 
45
} __attribute__ (( packed ));
 
46
 
 
47
/** Retrieval protocol block range */
 
48
struct peerdist_msg_range {
 
49
        /** First block in range */
 
50
        uint32_t first;
 
51
        /** Number of blocks in range */
 
52
        uint32_t count;
 
53
} __attribute__ (( packed ));
 
54
 
 
55
/** Retrieval protocol segment ID header */
 
56
struct peerdist_msg_segment {
 
57
        /** Digest size (i.e. length of segment ID) */
 
58
        uint32_t digestsize;
 
59
        /* Followed by a single variable-length ID and padding:
 
60
         *
 
61
         * uint8_t id[digestsize];
 
62
         * uint8_t pad[ (-digestsize) & 0x3 ];
 
63
         */
 
64
} __attribute__ (( packed ));
 
65
 
 
66
/** Retrieval protocol segment ID
 
67
 *
 
68
 * @v digestsize        Digest size
 
69
 */
 
70
#define peerdist_msg_segment_t( digestsize )                            \
 
71
        struct {                                                        \
 
72
                struct peerdist_msg_segment segment;                    \
 
73
                uint8_t id[digestsize];                                 \
 
74
                uint8_t pad[ ( -(digestsize) ) & 0x3 ];                 \
 
75
        } __attribute__ (( packed ))
 
76
 
 
77
/** Retrieval protocol block range list header */
 
78
struct peerdist_msg_ranges {
 
79
        /** Number of ranges */
 
80
        uint32_t count;
 
81
        /* Followed by an array of block ranges:
 
82
         *
 
83
         * struct peerdist_msg_range range[count];
 
84
         */
 
85
} __attribute__ (( packed ));
 
86
 
 
87
/** Retrieval protocol block range list
 
88
 *
 
89
 * @v count             Number of ranges
 
90
 */
 
91
#define peerdist_msg_ranges_t( count )                                  \
 
92
        struct {                                                        \
 
93
                struct peerdist_msg_ranges ranges;                      \
 
94
                struct peerdist_msg_range range[count];                 \
 
95
        } __attribute__ (( packed ))
 
96
 
 
97
/** Retrieval protocol data block header */
 
98
struct peerdist_msg_block {
 
99
        /** Length of data block */
 
100
        uint32_t len;
 
101
        /* Followed by the (encrypted) data block:
 
102
         *
 
103
         * uint8_t data[len];
 
104
         */
 
105
} __attribute__ (( packed ));
 
106
 
 
107
/** Retrieval protocol data block */
 
108
#define peerdist_msg_block_t( len )                                     \
 
109
        struct {                                                        \
 
110
                struct peerdist_msg_block block;                        \
 
111
                uint8_t data[len];                                      \
 
112
        } __attribute__ (( packed ))
 
113
 
 
114
/** Retrieval protocol initialisation vector header */
 
115
struct peerdist_msg_iv {
 
116
        /** Cipher block size */
 
117
        uint32_t blksize;
 
118
        /* Followed by the initialisation vector:
 
119
         *
 
120
         * uint8_t data[blksize];
 
121
         */
 
122
} __attribute__ (( packed ));
 
123
 
 
124
/** Retrieval protocol initialisation vector */
 
125
#define peerdist_msg_iv_t( blksize )                                    \
 
126
        struct {                                                        \
 
127
                struct peerdist_msg_iv iv;                              \
 
128
                uint8_t data[blksize];                                  \
 
129
        } __attribute__ (( packed ))
 
130
 
 
131
/** Retrieval protocol useless VRF data header */
 
132
struct peerdist_msg_useless_vrf {
 
133
        /** Length of useless VRF data */
 
134
        uint32_t len;
 
135
        /* Followed by a variable-length useless VRF data block and
 
136
         * padding:
 
137
         *
 
138
         * uint8_t data[len];
 
139
         * uint8_t pad[ (-len) & 0x3 ];
 
140
         */
 
141
} __attribute__ (( packed ));
 
142
 
 
143
/** Retrieval protocol useless VRF data */
 
144
#define peerdist_msg_useless_vrf_t( vrf_len )                           \
 
145
        struct {                                                        \
 
146
                struct peerdist_msg_useless_vrf vrf;                    \
 
147
                uint8_t data[vrf_len];                                  \
 
148
                uint8_t pad[ ( -(vrf_len) ) & 0x3 ];                    \
 
149
        } __attribute__ (( packed ))
 
150
 
 
151
/** Retrieval protocol message header */
 
152
struct peerdist_msg_header {
 
153
        /** Protocol version
 
154
         *
 
155
         * This is the protocol version in which the message type was
 
156
         * first defined.
 
157
         */
 
158
        union peerdist_msg_version version;
 
159
        /** Message type */
 
160
        uint32_t type;
 
161
        /** Message size (including this header) */
 
162
        uint32_t len;
 
163
        /** Cryptographic algorithm ID */
 
164
        uint32_t algorithm;
 
165
} __attribute__ (( packed ));
 
166
 
 
167
/** Retrieval protocol cryptographic algorithm IDs */
 
168
enum peerdist_msg_algorithm {
 
169
        /** No encryption */
 
170
        PEERDIST_MSG_PLAINTEXT = 0x00000000UL,
 
171
        /** AES-128 in CBC mode */
 
172
        PEERDIST_MSG_AES_128_CBC = 0x00000001UL,
 
173
        /** AES-192 in CBC mode */
 
174
        PEERDIST_MSG_AES_192_CBC = 0x00000002UL,
 
175
        /** AES-256 in CBC mode */
 
176
        PEERDIST_MSG_AES_256_CBC = 0x00000003UL,
 
177
};
 
178
 
 
179
/** Retrieval protocol transport response header */
 
180
struct peerdist_msg_transport_header {
 
181
        /** Length (excluding this header)
 
182
         *
 
183
         * This seems to be identical in both purpose and value to the
 
184
         * length found within the message header, and therefore
 
185
         * serves no useful purpose.
 
186
         */
 
187
        uint32_t len;
 
188
} __attribute__ (( packed ));
 
189
 
 
190
/** Retrieval protocol negotiation request */
 
191
struct peerdist_msg_nego_req {
 
192
        /** Message header */
 
193
        struct peerdist_msg_header hdr;
 
194
        /** Supported versions */
 
195
        struct peerdist_msg_versions versions;
 
196
} __attribute__ (( packed ));
 
197
 
 
198
/** Retrieval protocol negotiation request version */
 
199
#define PEERDIST_MSG_NEGO_REQ_VERSION PEERDIST_MSG_VERSION_1_0
 
200
 
 
201
/** Retrieval protocol negotiation request type */
 
202
#define PEERDIST_MSG_NEGO_REQ_TYPE 0x00000000UL
 
203
 
 
204
/** Retrieval protocol negotiation response */
 
205
struct peerdist_msg_nego_resp {
 
206
        /** Message header */
 
207
        struct peerdist_msg_header hdr;
 
208
        /** Supported versions */
 
209
        struct peerdist_msg_versions versions;
 
210
} __attribute__ (( packed ));
 
211
 
 
212
/** Retrieval protocol negotiation response version */
 
213
#define PEERDIST_MSG_NEGO_RESP_VERSION PEERDIST_MSG_VERSION_1_0
 
214
 
 
215
/** Retrieval protocol negotiation response type */
 
216
#define PEERDIST_MSG_NEGO_RESP_TYPE 0x00000001UL
 
217
 
 
218
/** Retrieval protocol block list request header */
 
219
struct peerdist_msg_getblklist {
 
220
        /** Message header */
 
221
        struct peerdist_msg_header hdr;
 
222
        /* Followed by a segment ID and a block range list:
 
223
         *
 
224
         * peerdist_msg_segment_t(digestsize) segment;
 
225
         * peerdist_msg_ranges_t(count) ranges;
 
226
         */
 
227
} __attribute__ (( packed ));
 
228
 
 
229
/** Retrieval protocol block list request
 
230
 *
 
231
 * @v digestsize        Digest size
 
232
 * @v count             Block range count
 
233
 */
 
234
#define peerdist_msg_getblklist_t( digestsize, count )                  \
 
235
        struct {                                                        \
 
236
                struct peerdist_msg_getblklist getblklist;              \
 
237
                peerdist_msg_segment_t ( digestsize ) segment;          \
 
238
                peerdist_msg_ranges_t ( count ) ranges;                 \
 
239
        } __attribute__ (( packed ))
 
240
 
 
241
/** Retrieval protocol block list request version */
 
242
#define PEERDIST_MSG_GETBLKLIST_VERSION PEERDIST_MSG_VERSION_1_0
 
243
 
 
244
/** Retrieval protocol block list request type */
 
245
#define PEERDIST_MSG_GETBLKLIST_TYPE 0x00000002UL
 
246
 
 
247
/** Retrieval protocol block fetch request header */
 
248
struct peerdist_msg_getblks {
 
249
        /** Message header */
 
250
        struct peerdist_msg_header hdr;
 
251
        /* Followed by a segment ID, a block range list, and a useless
 
252
         * VRF block:
 
253
         *
 
254
         * peerdist_msg_segment_t(digestsize) segment;
 
255
         * peerdist_msg_ranges_t(count) ranges;
 
256
         * peerdist_msg_vrf_t(vrf_len) vrf;
 
257
         */
 
258
} __attribute__ (( packed ));
 
259
 
 
260
/** Retrieval protocol block fetch request
 
261
 *
 
262
 * @v digestsize        Digest size
 
263
 * @v count             Block range count
 
264
 * @v vrf_len           Length of uselessness
 
265
 */
 
266
#define peerdist_msg_getblks_t( digestsize, count, vrf_len )            \
 
267
        struct {                                                        \
 
268
                struct peerdist_msg_getblks getblks;                    \
 
269
                peerdist_msg_segment_t ( digestsize ) segment;          \
 
270
                peerdist_msg_ranges_t ( count ) ranges;                 \
 
271
                peerdist_msg_useless_vrf_t ( vrf_len );                 \
 
272
        } __attribute__ (( packed ))
 
273
 
 
274
/** Retrieval protocol block fetch request version */
 
275
#define PEERDIST_MSG_GETBLKS_VERSION PEERDIST_MSG_VERSION_1_0
 
276
 
 
277
/** Retrieval protocol block fetch request type */
 
278
#define PEERDIST_MSG_GETBLKS_TYPE 0x00000003UL
 
279
 
 
280
/** Retrieval protocol block list response header */
 
281
struct peerdist_msg_blklist {
 
282
        /** Message header */
 
283
        struct peerdist_msg_header hdr;
 
284
        /* Followed by a segment ID, a block range list, and a next
 
285
         * block index:
 
286
         *
 
287
         * peerdist_msg_segment_t(digestsize) segment;
 
288
         * peerdist_msg_ranges_t(count) ranges;
 
289
         * uint32_t next;
 
290
         */
 
291
} __attribute__ (( packed ));
 
292
 
 
293
/** Retrieval protocol block list response
 
294
 *
 
295
 * @v digestsize        Digest size
 
296
 * @v count             Block range count
 
297
 */
 
298
#define peerdist_msg_blklist_t( digestsize, count )                     \
 
299
        struct {                                                        \
 
300
                struct peerdist_msg_blklist blklist;                    \
 
301
                peerdist_msg_segment_t ( digestsize ) segment;          \
 
302
                peerdist_msg_ranges_t ( count ) ranges;                 \
 
303
                uint32_t next;                                          \
 
304
        } __attribute__ (( packed ))
 
305
 
 
306
/** Retrieval protocol block list response version */
 
307
#define PEERDIST_MSG_BLKLIST_VERSION PEERDIST_MSG_VERSION_1_0
 
308
 
 
309
/** Retrieval protocol block list response type */
 
310
#define PEERDIST_MSG_BLKLIST_TYPE 0x00000004UL
 
311
 
 
312
/** Retrieval protocol block fetch response header */
 
313
struct peerdist_msg_blk {
 
314
        /** Message header */
 
315
        struct peerdist_msg_header hdr;
 
316
        /* Followed by a segment ID, a block index, a next block
 
317
         * index, a data block, a useless VRF block, and an
 
318
         * initialisation vector:
 
319
         *
 
320
         * peerdist_msg_segment_t(digestsize) segment;
 
321
         * uint32_t index;
 
322
         * uint32_t next;
 
323
         * peerdist_msg_block_t(len) data;
 
324
         * peerdist_msg_useless_vrf_t(vrf_len) vrf;
 
325
         * peerdist_msg_iv_t(blksize) iv;
 
326
         */
 
327
} __attribute__ (( packed ));
 
328
 
 
329
/** Retrieval protocol block fetch response
 
330
 *
 
331
 * @v digestsize        Digest size
 
332
 * @v len               Data block length
 
333
 * @v vrf_len           Length of uselessness
 
334
 * @v blksize           Cipher block size
 
335
 */
 
336
#define peerdist_msg_blk_t( digestsize, len, vrf_len, blksize )         \
 
337
        struct {                                                        \
 
338
                struct peerdist_msg_blk blk;                            \
 
339
                peerdist_msg_segment_t ( digestsize ) segment;          \
 
340
                uint32_t index;                                         \
 
341
                uint32_t next;                                          \
 
342
                peerdist_msg_block_t ( len ) block;                     \
 
343
                peerdist_msg_useless_vrf_t ( vrf_len ) vrf;             \
 
344
                peerdist_msg_iv_t ( blksize ) iv;                       \
 
345
        } __attribute__ (( packed ))
 
346
 
 
347
/** Retrieval protocol block fetch response version */
 
348
#define PEERDIST_MSG_BLK_VERSION PEERDIST_MSG_VERSION_1_0
 
349
 
 
350
/** Retrieval protocol block fetch response type */
 
351
#define PEERDIST_MSG_BLK_TYPE 0x00000005UL
 
352
 
 
353
/**
 
354
 * Parse retrieval protocol block fetch response
 
355
 *
 
356
 * @v raw               Raw data
 
357
 * @v raw_len           Length of raw data
 
358
 * @v digestsize        Digest size
 
359
 * @v blksize           Cipher block size
 
360
 * @v blk               Structure to fill in
 
361
 * @ret rc              Return status code
 
362
 */
 
363
#define peerdist_msg_blk( raw, raw_len, digestsize, blksize, blk ) ( {  \
 
364
        assert ( sizeof ( (blk)->segment.id ) == (digestsize) );        \
 
365
        assert ( sizeof ( (blk)->block.data ) == 0 );                   \
 
366
        assert ( sizeof ( (blk)->vrf.data ) == 0 );                     \
 
367
        assert ( sizeof ( (blk)->iv.data ) == blksize );                \
 
368
        peerdist_msg_blk_untyped ( (raw), (raw_len), (digestsize),      \
 
369
                                   (blksize), blk );                    \
 
370
        } )
 
371
 
 
372
extern int peerdist_msg_blk_untyped ( userptr_t raw, size_t raw_len,
 
373
                                      size_t digestsize, size_t blksize,
 
374
                                      void *out );
 
375
 
 
376
#endif /* _IPXE_PCCRR_H */