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