Merge branch 'for-3.10' of git://linux-nfs.org/~bfields/linux
[linux-3.10.git] / net / sunrpc / auth_gss / gss_rpc_xdr.c
1 /*
2  * GSS Proxy upcall module
3  *
4  *  Copyright (C) 2012 Simo Sorce <simo@redhat.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 #include <linux/sunrpc/svcauth.h>
22 #include "gss_rpc_xdr.h"
23
24 static bool gssx_check_pointer(struct xdr_stream *xdr)
25 {
26         __be32 *p;
27
28         p = xdr_reserve_space(xdr, 4);
29         if (unlikely(p == NULL))
30                 return -ENOSPC;
31         return *p?true:false;
32 }
33
34 static int gssx_enc_bool(struct xdr_stream *xdr, int v)
35 {
36         __be32 *p;
37
38         p = xdr_reserve_space(xdr, 4);
39         if (unlikely(p == NULL))
40                 return -ENOSPC;
41         *p = v ? xdr_one : xdr_zero;
42         return 0;
43 }
44
45 static int gssx_dec_bool(struct xdr_stream *xdr, u32 *v)
46 {
47         __be32 *p;
48
49         p = xdr_inline_decode(xdr, 4);
50         if (unlikely(p == NULL))
51                 return -ENOSPC;
52         *v = be32_to_cpu(*p);
53         return 0;
54 }
55
56 static int gssx_enc_buffer(struct xdr_stream *xdr,
57                            gssx_buffer *buf)
58 {
59         __be32 *p;
60
61         p = xdr_reserve_space(xdr, sizeof(u32) + buf->len);
62         if (!p)
63                 return -ENOSPC;
64         xdr_encode_opaque(p, buf->data, buf->len);
65         return 0;
66 }
67
68 static int gssx_enc_in_token(struct xdr_stream *xdr,
69                              struct gssp_in_token *in)
70 {
71         __be32 *p;
72
73         p = xdr_reserve_space(xdr, 4);
74         if (!p)
75                 return -ENOSPC;
76         *p = cpu_to_be32(in->page_len);
77
78         /* all we need to do is to write pages */
79         xdr_write_pages(xdr, in->pages, in->page_base, in->page_len);
80
81         return 0;
82 }
83
84
85 static int gssx_dec_buffer(struct xdr_stream *xdr,
86                            gssx_buffer *buf)
87 {
88         u32 length;
89         __be32 *p;
90
91         p = xdr_inline_decode(xdr, 4);
92         if (unlikely(p == NULL))
93                 return -ENOSPC;
94
95         length = be32_to_cpup(p);
96         p = xdr_inline_decode(xdr, length);
97         if (unlikely(p == NULL))
98                 return -ENOSPC;
99
100         if (buf->len == 0) {
101                 /* we intentionally are not interested in this buffer */
102                 return 0;
103         }
104         if (length > buf->len)
105                 return -ENOSPC;
106
107         if (!buf->data) {
108                 buf->data = kmemdup(p, length, GFP_KERNEL);
109                 if (!buf->data)
110                         return -ENOMEM;
111         } else {
112                 memcpy(buf->data, p, length);
113         }
114         buf->len = length;
115         return 0;
116 }
117
118 static int gssx_enc_option(struct xdr_stream *xdr,
119                            struct gssx_option *opt)
120 {
121         int err;
122
123         err = gssx_enc_buffer(xdr, &opt->option);
124         if (err)
125                 return err;
126         err = gssx_enc_buffer(xdr, &opt->value);
127         return err;
128 }
129
130 static int gssx_dec_option(struct xdr_stream *xdr,
131                            struct gssx_option *opt)
132 {
133         int err;
134
135         err = gssx_dec_buffer(xdr, &opt->option);
136         if (err)
137                 return err;
138         err = gssx_dec_buffer(xdr, &opt->value);
139         return err;
140 }
141
142 static int dummy_enc_opt_array(struct xdr_stream *xdr,
143                                 struct gssx_option_array *oa)
144 {
145         __be32 *p;
146
147         if (oa->count != 0)
148                 return -EINVAL;
149
150         p = xdr_reserve_space(xdr, 4);
151         if (!p)
152                 return -ENOSPC;
153         *p = 0;
154
155         return 0;
156 }
157
158 static int dummy_dec_opt_array(struct xdr_stream *xdr,
159                                 struct gssx_option_array *oa)
160 {
161         struct gssx_option dummy;
162         u32 count, i;
163         __be32 *p;
164
165         p = xdr_inline_decode(xdr, 4);
166         if (unlikely(p == NULL))
167                 return -ENOSPC;
168         count = be32_to_cpup(p++);
169         memset(&dummy, 0, sizeof(dummy));
170         for (i = 0; i < count; i++) {
171                 gssx_dec_option(xdr, &dummy);
172         }
173
174         oa->count = 0;
175         oa->data = NULL;
176         return 0;
177 }
178
179 static int get_s32(void **p, void *max, s32 *res)
180 {
181         void *base = *p;
182         void *next = (void *)((char *)base + sizeof(s32));
183         if (unlikely(next > max || next < base))
184                 return -EINVAL;
185         memcpy(res, base, sizeof(s32));
186         *p = next;
187         return 0;
188 }
189
190 static int gssx_dec_linux_creds(struct xdr_stream *xdr,
191                                 struct svc_cred *creds)
192 {
193         u32 length;
194         __be32 *p;
195         void *q, *end;
196         s32 tmp;
197         int N, i, err;
198
199         p = xdr_inline_decode(xdr, 4);
200         if (unlikely(p == NULL))
201                 return -ENOSPC;
202
203         length = be32_to_cpup(p);
204
205         /* FIXME: we do not want to use the scratch buffer for this one
206          * may need to use functions that allows us to access an io vector
207          * directly */
208         p = xdr_inline_decode(xdr, length);
209         if (unlikely(p == NULL))
210                 return -ENOSPC;
211
212         q = p;
213         end = q + length;
214
215         /* uid */
216         err = get_s32(&q, end, &tmp);
217         if (err)
218                 return err;
219         creds->cr_uid = make_kuid(&init_user_ns, tmp);
220
221         /* gid */
222         err = get_s32(&q, end, &tmp);
223         if (err)
224                 return err;
225         creds->cr_gid = make_kgid(&init_user_ns, tmp);
226
227         /* number of additional gid's */
228         err = get_s32(&q, end, &tmp);
229         if (err)
230                 return err;
231         N = tmp;
232         creds->cr_group_info = groups_alloc(N);
233         if (creds->cr_group_info == NULL)
234                 return -ENOMEM;
235
236         /* gid's */
237         for (i = 0; i < N; i++) {
238                 kgid_t kgid;
239                 err = get_s32(&q, end, &tmp);
240                 if (err)
241                         goto out_free_groups;
242                 err = -EINVAL;
243                 kgid = make_kgid(&init_user_ns, tmp);
244                 if (!gid_valid(kgid))
245                         goto out_free_groups;
246                 GROUP_AT(creds->cr_group_info, i) = kgid;
247         }
248
249         return 0;
250 out_free_groups:
251         groups_free(creds->cr_group_info);
252         return err;
253 }
254
255 static int gssx_dec_option_array(struct xdr_stream *xdr,
256                                  struct gssx_option_array *oa)
257 {
258         struct svc_cred *creds;
259         u32 count, i;
260         __be32 *p;
261         int err;
262
263         p = xdr_inline_decode(xdr, 4);
264         if (unlikely(p == NULL))
265                 return -ENOSPC;
266         count = be32_to_cpup(p++);
267         if (count != 0) {
268                 /* we recognize only 1 currently: CREDS_VALUE */
269                 oa->count = 1;
270
271                 oa->data = kmalloc(sizeof(struct gssx_option), GFP_KERNEL);
272                 if (!oa->data)
273                         return -ENOMEM;
274
275                 creds = kmalloc(sizeof(struct svc_cred), GFP_KERNEL);
276                 if (!creds) {
277                         kfree(oa->data);
278                         return -ENOMEM;
279                 }
280
281                 oa->data[0].option.data = CREDS_VALUE;
282                 oa->data[0].option.len = sizeof(CREDS_VALUE);
283                 oa->data[0].value.data = (void *)creds;
284                 oa->data[0].value.len = 0;
285         }
286         for (i = 0; i < count; i++) {
287                 gssx_buffer dummy = { 0, NULL };
288                 u32 length;
289
290                 /* option buffer */
291                 p = xdr_inline_decode(xdr, 4);
292                 if (unlikely(p == NULL))
293                         return -ENOSPC;
294
295                 length = be32_to_cpup(p);
296                 p = xdr_inline_decode(xdr, length);
297                 if (unlikely(p == NULL))
298                         return -ENOSPC;
299
300                 if (length == sizeof(CREDS_VALUE) &&
301                     memcmp(p, CREDS_VALUE, sizeof(CREDS_VALUE)) == 0) {
302                         /* We have creds here. parse them */
303                         err = gssx_dec_linux_creds(xdr, creds);
304                         if (err)
305                                 return err;
306                         oa->data[0].value.len = 1; /* presence */
307                 } else {
308                         /* consume uninteresting buffer */
309                         err = gssx_dec_buffer(xdr, &dummy);
310                         if (err)
311                                 return err;
312                 }
313         }
314         return 0;
315 }
316
317 static int gssx_dec_status(struct xdr_stream *xdr,
318                            struct gssx_status *status)
319 {
320         __be32 *p;
321         int err;
322
323         /* status->major_status */
324         p = xdr_inline_decode(xdr, 8);
325         if (unlikely(p == NULL))
326                 return -ENOSPC;
327         p = xdr_decode_hyper(p, &status->major_status);
328
329         /* status->mech */
330         err = gssx_dec_buffer(xdr, &status->mech);
331         if (err)
332                 return err;
333
334         /* status->minor_status */
335         p = xdr_inline_decode(xdr, 8);
336         if (unlikely(p == NULL))
337                 return -ENOSPC;
338         p = xdr_decode_hyper(p, &status->minor_status);
339
340         /* status->major_status_string */
341         err = gssx_dec_buffer(xdr, &status->major_status_string);
342         if (err)
343                 return err;
344
345         /* status->minor_status_string */
346         err = gssx_dec_buffer(xdr, &status->minor_status_string);
347         if (err)
348                 return err;
349
350         /* status->server_ctx */
351         err = gssx_dec_buffer(xdr, &status->server_ctx);
352         if (err)
353                 return err;
354
355         /* we assume we have no options for now, so simply consume them */
356         /* status->options */
357         err = dummy_dec_opt_array(xdr, &status->options);
358
359         return err;
360 }
361
362 static int gssx_enc_call_ctx(struct xdr_stream *xdr,
363                              struct gssx_call_ctx *ctx)
364 {
365         struct gssx_option opt;
366         __be32 *p;
367         int err;
368
369         /* ctx->locale */
370         err = gssx_enc_buffer(xdr, &ctx->locale);
371         if (err)
372                 return err;
373
374         /* ctx->server_ctx */
375         err = gssx_enc_buffer(xdr, &ctx->server_ctx);
376         if (err)
377                 return err;
378
379         /* we always want to ask for lucid contexts */
380         /* ctx->options */
381         p = xdr_reserve_space(xdr, 4);
382         *p = cpu_to_be32(2);
383
384         /* we want a lucid_v1 context */
385         opt.option.data = LUCID_OPTION;
386         opt.option.len = sizeof(LUCID_OPTION);
387         opt.value.data = LUCID_VALUE;
388         opt.value.len = sizeof(LUCID_VALUE);
389         err = gssx_enc_option(xdr, &opt);
390
391         /* ..and user creds */
392         opt.option.data = CREDS_OPTION;
393         opt.option.len = sizeof(CREDS_OPTION);
394         opt.value.data = CREDS_VALUE;
395         opt.value.len = sizeof(CREDS_VALUE);
396         err = gssx_enc_option(xdr, &opt);
397
398         return err;
399 }
400
401 static int gssx_dec_name_attr(struct xdr_stream *xdr,
402                              struct gssx_name_attr *attr)
403 {
404         int err;
405
406         /* attr->attr */
407         err = gssx_dec_buffer(xdr, &attr->attr);
408         if (err)
409                 return err;
410
411         /* attr->value */
412         err = gssx_dec_buffer(xdr, &attr->value);
413         if (err)
414                 return err;
415
416         /* attr->extensions */
417         err = dummy_dec_opt_array(xdr, &attr->extensions);
418
419         return err;
420 }
421
422 static int dummy_enc_nameattr_array(struct xdr_stream *xdr,
423                                     struct gssx_name_attr_array *naa)
424 {
425         __be32 *p;
426
427         if (naa->count != 0)
428                 return -EINVAL;
429
430         p = xdr_reserve_space(xdr, 4);
431         if (!p)
432                 return -ENOSPC;
433         *p = 0;
434
435         return 0;
436 }
437
438 static int dummy_dec_nameattr_array(struct xdr_stream *xdr,
439                                     struct gssx_name_attr_array *naa)
440 {
441         struct gssx_name_attr dummy;
442         u32 count, i;
443         __be32 *p;
444
445         p = xdr_inline_decode(xdr, 4);
446         if (unlikely(p == NULL))
447                 return -ENOSPC;
448         count = be32_to_cpup(p++);
449         for (i = 0; i < count; i++) {
450                 gssx_dec_name_attr(xdr, &dummy);
451         }
452
453         naa->count = 0;
454         naa->data = NULL;
455         return 0;
456 }
457
458 static struct xdr_netobj zero_netobj = {};
459
460 static struct gssx_name_attr_array zero_name_attr_array = {};
461
462 static struct gssx_option_array zero_option_array = {};
463
464 static int gssx_enc_name(struct xdr_stream *xdr,
465                          struct gssx_name *name)
466 {
467         int err;
468
469         /* name->display_name */
470         err = gssx_enc_buffer(xdr, &name->display_name);
471         if (err)
472                 return err;
473
474         /* name->name_type */
475         err = gssx_enc_buffer(xdr, &zero_netobj);
476         if (err)
477                 return err;
478
479         /* name->exported_name */
480         err = gssx_enc_buffer(xdr, &zero_netobj);
481         if (err)
482                 return err;
483
484         /* name->exported_composite_name */
485         err = gssx_enc_buffer(xdr, &zero_netobj);
486         if (err)
487                 return err;
488
489         /* leave name_attributes empty for now, will add once we have any
490          * to pass up at all */
491         /* name->name_attributes */
492         err = dummy_enc_nameattr_array(xdr, &zero_name_attr_array);
493         if (err)
494                 return err;
495
496         /* leave options empty for now, will add once we have any options
497          * to pass up at all */
498         /* name->extensions */
499         err = dummy_enc_opt_array(xdr, &zero_option_array);
500
501         return err;
502 }
503
504 static int gssx_dec_name(struct xdr_stream *xdr,
505                          struct gssx_name *name)
506 {
507         struct xdr_netobj dummy_netobj;
508         struct gssx_name_attr_array dummy_name_attr_array;
509         struct gssx_option_array dummy_option_array;
510         int err;
511
512         /* name->display_name */
513         err = gssx_dec_buffer(xdr, &name->display_name);
514         if (err)
515                 return err;
516
517         /* name->name_type */
518         err = gssx_dec_buffer(xdr, &dummy_netobj);
519         if (err)
520                 return err;
521
522         /* name->exported_name */
523         err = gssx_dec_buffer(xdr, &dummy_netobj);
524         if (err)
525                 return err;
526
527         /* name->exported_composite_name */
528         err = gssx_dec_buffer(xdr, &dummy_netobj);
529         if (err)
530                 return err;
531
532         /* we assume we have no attributes for now, so simply consume them */
533         /* name->name_attributes */
534         err = dummy_dec_nameattr_array(xdr, &dummy_name_attr_array);
535         if (err)
536                 return err;
537
538         /* we assume we have no options for now, so simply consume them */
539         /* name->extensions */
540         err = dummy_dec_opt_array(xdr, &dummy_option_array);
541
542         return err;
543 }
544
545 static int dummy_enc_credel_array(struct xdr_stream *xdr,
546                                   struct gssx_cred_element_array *cea)
547 {
548         __be32 *p;
549
550         if (cea->count != 0)
551                 return -EINVAL;
552
553         p = xdr_reserve_space(xdr, 4);
554         if (!p)
555                 return -ENOSPC;
556         *p = 0;
557
558         return 0;
559 }
560
561 static int gssx_enc_cred(struct xdr_stream *xdr,
562                          struct gssx_cred *cred)
563 {
564         int err;
565
566         /* cred->desired_name */
567         err = gssx_enc_name(xdr, &cred->desired_name);
568         if (err)
569                 return err;
570
571         /* cred->elements */
572         err = dummy_enc_credel_array(xdr, &cred->elements);
573
574         /* cred->cred_handle_reference */
575         err = gssx_enc_buffer(xdr, &cred->cred_handle_reference);
576         if (err)
577                 return err;
578
579         /* cred->needs_release */
580         err = gssx_enc_bool(xdr, cred->needs_release);
581
582         return err;
583 }
584
585 static int gssx_enc_ctx(struct xdr_stream *xdr,
586                         struct gssx_ctx *ctx)
587 {
588         __be32 *p;
589         int err;
590
591         /* ctx->exported_context_token */
592         err = gssx_enc_buffer(xdr, &ctx->exported_context_token);
593         if (err)
594                 return err;
595
596         /* ctx->state */
597         err = gssx_enc_buffer(xdr, &ctx->state);
598         if (err)
599                 return err;
600
601         /* ctx->need_release */
602         err = gssx_enc_bool(xdr, ctx->need_release);
603         if (err)
604                 return err;
605
606         /* ctx->mech */
607         err = gssx_enc_buffer(xdr, &ctx->mech);
608         if (err)
609                 return err;
610
611         /* ctx->src_name */
612         err = gssx_enc_name(xdr, &ctx->src_name);
613         if (err)
614                 return err;
615
616         /* ctx->targ_name */
617         err = gssx_enc_name(xdr, &ctx->targ_name);
618         if (err)
619                 return err;
620
621         /* ctx->lifetime */
622         p = xdr_reserve_space(xdr, 8+8);
623         if (!p)
624                 return -ENOSPC;
625         p = xdr_encode_hyper(p, ctx->lifetime);
626
627         /* ctx->ctx_flags */
628         p = xdr_encode_hyper(p, ctx->ctx_flags);
629
630         /* ctx->locally_initiated */
631         err = gssx_enc_bool(xdr, ctx->locally_initiated);
632         if (err)
633                 return err;
634
635         /* ctx->open */
636         err = gssx_enc_bool(xdr, ctx->open);
637         if (err)
638                 return err;
639
640         /* leave options empty for now, will add once we have any options
641          * to pass up at all */
642         /* ctx->options */
643         err = dummy_enc_opt_array(xdr, &ctx->options);
644
645         return err;
646 }
647
648 static int gssx_dec_ctx(struct xdr_stream *xdr,
649                         struct gssx_ctx *ctx)
650 {
651         __be32 *p;
652         int err;
653
654         /* ctx->exported_context_token */
655         err = gssx_dec_buffer(xdr, &ctx->exported_context_token);
656         if (err)
657                 return err;
658
659         /* ctx->state */
660         err = gssx_dec_buffer(xdr, &ctx->state);
661         if (err)
662                 return err;
663
664         /* ctx->need_release */
665         err = gssx_dec_bool(xdr, &ctx->need_release);
666         if (err)
667                 return err;
668
669         /* ctx->mech */
670         err = gssx_dec_buffer(xdr, &ctx->mech);
671         if (err)
672                 return err;
673
674         /* ctx->src_name */
675         err = gssx_dec_name(xdr, &ctx->src_name);
676         if (err)
677                 return err;
678
679         /* ctx->targ_name */
680         err = gssx_dec_name(xdr, &ctx->targ_name);
681         if (err)
682                 return err;
683
684         /* ctx->lifetime */
685         p = xdr_inline_decode(xdr, 8+8);
686         if (unlikely(p == NULL))
687                 return -ENOSPC;
688         p = xdr_decode_hyper(p, &ctx->lifetime);
689
690         /* ctx->ctx_flags */
691         p = xdr_decode_hyper(p, &ctx->ctx_flags);
692
693         /* ctx->locally_initiated */
694         err = gssx_dec_bool(xdr, &ctx->locally_initiated);
695         if (err)
696                 return err;
697
698         /* ctx->open */
699         err = gssx_dec_bool(xdr, &ctx->open);
700         if (err)
701                 return err;
702
703         /* we assume we have no options for now, so simply consume them */
704         /* ctx->options */
705         err = dummy_dec_opt_array(xdr, &ctx->options);
706
707         return err;
708 }
709
710 static int gssx_enc_cb(struct xdr_stream *xdr, struct gssx_cb *cb)
711 {
712         __be32 *p;
713         int err;
714
715         /* cb->initiator_addrtype */
716         p = xdr_reserve_space(xdr, 8);
717         if (!p)
718                 return -ENOSPC;
719         p = xdr_encode_hyper(p, cb->initiator_addrtype);
720
721         /* cb->initiator_address */
722         err = gssx_enc_buffer(xdr, &cb->initiator_address);
723         if (err)
724                 return err;
725
726         /* cb->acceptor_addrtype */
727         p = xdr_reserve_space(xdr, 8);
728         if (!p)
729                 return -ENOSPC;
730         p = xdr_encode_hyper(p, cb->acceptor_addrtype);
731
732         /* cb->acceptor_address */
733         err = gssx_enc_buffer(xdr, &cb->acceptor_address);
734         if (err)
735                 return err;
736
737         /* cb->application_data */
738         err = gssx_enc_buffer(xdr, &cb->application_data);
739
740         return err;
741 }
742
743 void gssx_enc_accept_sec_context(struct rpc_rqst *req,
744                                  struct xdr_stream *xdr,
745                                  struct gssx_arg_accept_sec_context *arg)
746 {
747         int err;
748
749         err = gssx_enc_call_ctx(xdr, &arg->call_ctx);
750         if (err)
751                 goto done;
752
753         /* arg->context_handle */
754         if (arg->context_handle) {
755                 err = gssx_enc_ctx(xdr, arg->context_handle);
756                 if (err)
757                         goto done;
758         } else {
759                 err = gssx_enc_bool(xdr, 0);
760         }
761
762         /* arg->cred_handle */
763         if (arg->cred_handle) {
764                 err = gssx_enc_cred(xdr, arg->cred_handle);
765                 if (err)
766                         goto done;
767         } else {
768                 err = gssx_enc_bool(xdr, 0);
769         }
770
771         /* arg->input_token */
772         err = gssx_enc_in_token(xdr, &arg->input_token);
773         if (err)
774                 goto done;
775
776         /* arg->input_cb */
777         if (arg->input_cb) {
778                 err = gssx_enc_cb(xdr, arg->input_cb);
779                 if (err)
780                         goto done;
781         } else {
782                 err = gssx_enc_bool(xdr, 0);
783         }
784
785         err = gssx_enc_bool(xdr, arg->ret_deleg_cred);
786         if (err)
787                 goto done;
788
789         /* leave options empty for now, will add once we have any options
790          * to pass up at all */
791         /* arg->options */
792         err = dummy_enc_opt_array(xdr, &arg->options);
793
794 done:
795         if (err)
796                 dprintk("RPC:       gssx_enc_accept_sec_context: %d\n", err);
797 }
798
799 int gssx_dec_accept_sec_context(struct rpc_rqst *rqstp,
800                                 struct xdr_stream *xdr,
801                                 struct gssx_res_accept_sec_context *res)
802 {
803         int err;
804
805         /* res->status */
806         err = gssx_dec_status(xdr, &res->status);
807         if (err)
808                 return err;
809
810         /* res->context_handle */
811         if (gssx_check_pointer(xdr)) {
812                 err = gssx_dec_ctx(xdr, res->context_handle);
813                 if (err)
814                         return err;
815         } else {
816                 res->context_handle = NULL;
817         }
818
819         /* res->output_token */
820         if (gssx_check_pointer(xdr)) {
821                 err = gssx_dec_buffer(xdr, res->output_token);
822                 if (err)
823                         return err;
824         } else {
825                 res->output_token = NULL;
826         }
827
828         /* res->delegated_cred_handle */
829         if (gssx_check_pointer(xdr)) {
830                 /* we do not support upcall servers sending this data. */
831                 return -EINVAL;
832         }
833
834         /* res->options */
835         err = gssx_dec_option_array(xdr, &res->options);
836
837         return err;
838 }