1
2
3
4
5
6
7
8
9
10
11#ifndef _SUNRPC_XDR_H_
12#define _SUNRPC_XDR_H_
13
14#ifdef __KERNEL__
15
16#include <linux/uio.h>
17#include <asm/byteorder.h>
18#include <asm/unaligned.h>
19#include <linux/scatterlist.h>
20
21struct rpc_rqst;
22
23
24
25
26#define XDR_QUADLEN(l) (((l) + 3) >> 2)
27
28
29
30
31
32#define XDR_MAX_NETOBJ 1024
33struct xdr_netobj {
34 unsigned int len;
35 u8 * data;
36};
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51struct xdr_buf {
52 struct kvec head[1],
53 tail[1];
54
55 struct page ** pages;
56 unsigned int page_base,
57 page_len,
58 flags;
59#define XDRBUF_READ 0x01
60#define XDRBUF_WRITE 0x02
61
62 unsigned int buflen,
63 len;
64};
65
66static inline void
67xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)
68{
69 buf->head[0].iov_base = start;
70 buf->head[0].iov_len = len;
71 buf->tail[0].iov_len = 0;
72 buf->page_len = 0;
73 buf->flags = 0;
74 buf->len = 0;
75 buf->buflen = len;
76}
77
78
79
80
81
82#define xdr_zero cpu_to_be32(0)
83#define xdr_one cpu_to_be32(1)
84#define xdr_two cpu_to_be32(2)
85
86#define rpc_success cpu_to_be32(RPC_SUCCESS)
87#define rpc_prog_unavail cpu_to_be32(RPC_PROG_UNAVAIL)
88#define rpc_prog_mismatch cpu_to_be32(RPC_PROG_MISMATCH)
89#define rpc_proc_unavail cpu_to_be32(RPC_PROC_UNAVAIL)
90#define rpc_garbage_args cpu_to_be32(RPC_GARBAGE_ARGS)
91#define rpc_system_err cpu_to_be32(RPC_SYSTEM_ERR)
92#define rpc_drop_reply cpu_to_be32(RPC_DROP_REPLY)
93
94#define rpc_auth_ok cpu_to_be32(RPC_AUTH_OK)
95#define rpc_autherr_badcred cpu_to_be32(RPC_AUTH_BADCRED)
96#define rpc_autherr_rejectedcred cpu_to_be32(RPC_AUTH_REJECTEDCRED)
97#define rpc_autherr_badverf cpu_to_be32(RPC_AUTH_BADVERF)
98#define rpc_autherr_rejectedverf cpu_to_be32(RPC_AUTH_REJECTEDVERF)
99#define rpc_autherr_tooweak cpu_to_be32(RPC_AUTH_TOOWEAK)
100#define rpcsec_gsserr_credproblem cpu_to_be32(RPCSEC_GSS_CREDPROBLEM)
101#define rpcsec_gsserr_ctxproblem cpu_to_be32(RPCSEC_GSS_CTXPROBLEM)
102#define rpc_autherr_oldseqnum cpu_to_be32(101)
103
104
105
106
107__be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int len);
108__be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int len);
109__be32 *xdr_encode_string(__be32 *p, const char *s);
110__be32 *xdr_decode_string_inplace(__be32 *p, char **sp, unsigned int *lenp,
111 unsigned int maxlen);
112__be32 *xdr_encode_netobj(__be32 *p, const struct xdr_netobj *);
113__be32 *xdr_decode_netobj(__be32 *p, struct xdr_netobj *);
114
115void xdr_inline_pages(struct xdr_buf *, unsigned int,
116 struct page **, unsigned int, unsigned int);
117void xdr_terminate_string(struct xdr_buf *, const u32);
118
119static inline __be32 *xdr_encode_array(__be32 *p, const void *s, unsigned int len)
120{
121 return xdr_encode_opaque(p, s, len);
122}
123
124
125
126
127static inline __be32 *
128xdr_encode_hyper(__be32 *p, __u64 val)
129{
130 put_unaligned_be64(val, p);
131 return p + 2;
132}
133
134static inline __be32 *
135xdr_decode_hyper(__be32 *p, __u64 *valp)
136{
137 *valp = get_unaligned_be64(p);
138 return p + 2;
139}
140
141static inline __be32 *
142xdr_decode_opaque_fixed(__be32 *p, void *ptr, unsigned int len)
143{
144 memcpy(ptr, p, len);
145 return p + XDR_QUADLEN(len);
146}
147
148
149
150
151static inline int
152xdr_adjust_iovec(struct kvec *iov, __be32 *p)
153{
154 return iov->iov_len = ((u8 *) p - (u8 *) iov->iov_base);
155}
156
157
158
159
160extern void xdr_shift_buf(struct xdr_buf *, size_t);
161extern void xdr_buf_from_iov(struct kvec *, struct xdr_buf *);
162extern int xdr_buf_subsegment(struct xdr_buf *, struct xdr_buf *, unsigned int, unsigned int);
163extern void xdr_buf_trim(struct xdr_buf *, unsigned int);
164extern int xdr_buf_read_netobj(struct xdr_buf *, struct xdr_netobj *, unsigned int);
165extern int read_bytes_from_xdr_buf(struct xdr_buf *, unsigned int, void *, unsigned int);
166extern int write_bytes_to_xdr_buf(struct xdr_buf *, unsigned int, void *, unsigned int);
167
168
169
170
171struct xdr_skb_reader {
172 struct sk_buff *skb;
173 unsigned int offset;
174 size_t count;
175 __wsum csum;
176};
177
178typedef size_t (*xdr_skb_read_actor)(struct xdr_skb_reader *desc, void *to, size_t len);
179
180size_t xdr_skb_read_bits(struct xdr_skb_reader *desc, void *to, size_t len);
181extern int csum_partial_copy_to_xdr(struct xdr_buf *, struct sk_buff *);
182extern ssize_t xdr_partial_copy_from_skb(struct xdr_buf *, unsigned int,
183 struct xdr_skb_reader *, xdr_skb_read_actor);
184
185extern int xdr_encode_word(struct xdr_buf *, unsigned int, u32);
186extern int xdr_decode_word(struct xdr_buf *, unsigned int, u32 *);
187
188struct xdr_array2_desc;
189typedef int (*xdr_xcode_elem_t)(struct xdr_array2_desc *desc, void *elem);
190struct xdr_array2_desc {
191 unsigned int elem_size;
192 unsigned int array_len;
193 unsigned int array_maxlen;
194 xdr_xcode_elem_t xcode;
195};
196
197extern int xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
198 struct xdr_array2_desc *desc);
199extern int xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
200 struct xdr_array2_desc *desc);
201extern void _copy_from_pages(char *p, struct page **pages, size_t pgbase,
202 size_t len);
203
204
205
206
207struct xdr_stream {
208 __be32 *p;
209 struct xdr_buf *buf;
210
211 __be32 *end;
212 struct kvec *iov;
213 struct kvec scratch;
214 struct page **page_ptr;
215 unsigned int nwords;
216};
217
218
219
220
221typedef void (*kxdreproc_t)(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
222 const void *obj);
223typedef int (*kxdrdproc_t)(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
224 void *obj);
225
226extern void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p);
227extern __be32 *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
228extern void xdr_commit_encode(struct xdr_stream *xdr);
229extern void xdr_truncate_encode(struct xdr_stream *xdr, size_t len);
230extern int xdr_restrict_buflen(struct xdr_stream *xdr, int newbuflen);
231extern void xdr_write_pages(struct xdr_stream *xdr, struct page **pages,
232 unsigned int base, unsigned int len);
233extern unsigned int xdr_stream_pos(const struct xdr_stream *xdr);
234extern void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p);
235extern void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
236 struct page **pages, unsigned int len);
237extern void xdr_set_scratch_buffer(struct xdr_stream *xdr, void *buf, size_t buflen);
238extern __be32 *xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes);
239extern unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len);
240extern void xdr_enter_page(struct xdr_stream *xdr, unsigned int len);
241extern int xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len, int (*actor)(struct scatterlist *, void *), void *data);
242
243
244
245
246
247
248
249
250static inline size_t
251xdr_stream_remaining(const struct xdr_stream *xdr)
252{
253 return xdr->nwords << 2;
254}
255
256ssize_t xdr_stream_decode_opaque(struct xdr_stream *xdr, void *ptr,
257 size_t size);
258ssize_t xdr_stream_decode_opaque_dup(struct xdr_stream *xdr, void **ptr,
259 size_t maxlen, gfp_t gfp_flags);
260ssize_t xdr_stream_decode_string(struct xdr_stream *xdr, char *str,
261 size_t size);
262ssize_t xdr_stream_decode_string_dup(struct xdr_stream *xdr, char **str,
263 size_t maxlen, gfp_t gfp_flags);
264
265
266
267
268
269
270
271static inline size_t
272xdr_align_size(size_t n)
273{
274 const size_t mask = sizeof(__u32) - 1;
275
276 return (n + mask) & ~mask;
277}
278
279
280
281
282
283
284
285
286
287
288static inline ssize_t
289xdr_stream_encode_u32(struct xdr_stream *xdr, __u32 n)
290{
291 const size_t len = sizeof(n);
292 __be32 *p = xdr_reserve_space(xdr, len);
293
294 if (unlikely(!p))
295 return -EMSGSIZE;
296 *p = cpu_to_be32(n);
297 return len;
298}
299
300
301
302
303
304
305
306
307
308
309static inline ssize_t
310xdr_stream_encode_u64(struct xdr_stream *xdr, __u64 n)
311{
312 const size_t len = sizeof(n);
313 __be32 *p = xdr_reserve_space(xdr, len);
314
315 if (unlikely(!p))
316 return -EMSGSIZE;
317 xdr_encode_hyper(p, n);
318 return len;
319}
320
321
322
323
324
325
326
327
328
329
330
331static inline ssize_t
332xdr_stream_encode_opaque_inline(struct xdr_stream *xdr, void **ptr, size_t len)
333{
334 size_t count = sizeof(__u32) + xdr_align_size(len);
335 __be32 *p = xdr_reserve_space(xdr, count);
336
337 if (unlikely(!p)) {
338 *ptr = NULL;
339 return -EMSGSIZE;
340 }
341 xdr_encode_opaque(p, NULL, len);
342 *ptr = ++p;
343 return count;
344}
345
346
347
348
349
350
351
352
353
354
355
356static inline ssize_t
357xdr_stream_encode_opaque_fixed(struct xdr_stream *xdr, const void *ptr, size_t len)
358{
359 __be32 *p = xdr_reserve_space(xdr, len);
360
361 if (unlikely(!p))
362 return -EMSGSIZE;
363 xdr_encode_opaque_fixed(p, ptr, len);
364 return xdr_align_size(len);
365}
366
367
368
369
370
371
372
373
374
375
376
377static inline ssize_t
378xdr_stream_encode_opaque(struct xdr_stream *xdr, const void *ptr, size_t len)
379{
380 size_t count = sizeof(__u32) + xdr_align_size(len);
381 __be32 *p = xdr_reserve_space(xdr, count);
382
383 if (unlikely(!p))
384 return -EMSGSIZE;
385 xdr_encode_opaque(p, ptr, len);
386 return count;
387}
388
389
390
391
392
393
394
395
396
397
398
399static inline ssize_t
400xdr_stream_encode_uint32_array(struct xdr_stream *xdr,
401 const __u32 *array, size_t array_size)
402{
403 ssize_t ret = (array_size+1) * sizeof(__u32);
404 __be32 *p = xdr_reserve_space(xdr, ret);
405
406 if (unlikely(!p))
407 return -EMSGSIZE;
408 *p++ = cpu_to_be32(array_size);
409 for (; array_size > 0; p++, array++, array_size--)
410 *p = cpu_to_be32p(array);
411 return ret;
412}
413
414
415
416
417
418
419
420
421
422
423static inline ssize_t
424xdr_stream_decode_u32(struct xdr_stream *xdr, __u32 *ptr)
425{
426 const size_t count = sizeof(*ptr);
427 __be32 *p = xdr_inline_decode(xdr, count);
428
429 if (unlikely(!p))
430 return -EBADMSG;
431 *ptr = be32_to_cpup(p);
432 return 0;
433}
434
435
436
437
438
439
440
441
442
443
444
445static inline ssize_t
446xdr_stream_decode_opaque_fixed(struct xdr_stream *xdr, void *ptr, size_t len)
447{
448 __be32 *p = xdr_inline_decode(xdr, len);
449
450 if (unlikely(!p))
451 return -EBADMSG;
452 xdr_decode_opaque_fixed(p, ptr, len);
453 return len;
454}
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472static inline ssize_t
473xdr_stream_decode_opaque_inline(struct xdr_stream *xdr, void **ptr, size_t maxlen)
474{
475 __be32 *p;
476 __u32 len;
477
478 *ptr = NULL;
479 if (unlikely(xdr_stream_decode_u32(xdr, &len) < 0))
480 return -EBADMSG;
481 if (len != 0) {
482 p = xdr_inline_decode(xdr, len);
483 if (unlikely(!p))
484 return -EBADMSG;
485 if (unlikely(len > maxlen))
486 return -EMSGSIZE;
487 *ptr = p;
488 }
489 return len;
490}
491
492
493
494
495
496
497
498
499
500
501
502
503static inline ssize_t
504xdr_stream_decode_uint32_array(struct xdr_stream *xdr,
505 __u32 *array, size_t array_size)
506{
507 __be32 *p;
508 __u32 len;
509 ssize_t retval;
510
511 if (unlikely(xdr_stream_decode_u32(xdr, &len) < 0))
512 return -EBADMSG;
513 p = xdr_inline_decode(xdr, len * sizeof(*p));
514 if (unlikely(!p))
515 return -EBADMSG;
516 if (array == NULL)
517 return len;
518 if (len <= array_size) {
519 if (len < array_size)
520 memset(array+len, 0, (array_size-len)*sizeof(*array));
521 array_size = len;
522 retval = len;
523 } else
524 retval = -EMSGSIZE;
525 for (; array_size > 0; p++, array++, array_size--)
526 *array = be32_to_cpup(p);
527 return retval;
528}
529#endif
530
531#endif
532