git.karo-electronics.de Git - linux-beck.git/blob

1 /*

2 * linux/net/sunrpc/auth_gss/auth_gss.c

3 *

4 * RPCSEC_GSS client authentication.

5 *

8 *

9 * Dug Song <dugsong@monkey.org>

10 * Andy Adamson <andros@umich.edu>

11 *

12 * Redistribution and use in source and binary forms, with or without

13 * modification, are permitted provided that the following conditions

14 * are met:

15 *

16 * 1. Redistributions of source code must retain the above copyright

17 * notice, this list of conditions and the following disclaimer.

18 * 2. Redistributions in binary form must reproduce the above copyright

19 * notice, this list of conditions and the following disclaimer in the

20 * documentation and/or other materials provided with the distribution.

21 * 3. Neither the name of the University nor the names of its

22 * contributors may be used to endorse or promote products derived

23 * from this software without specific prior written permission.

24 *

25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED

26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

36 */

39 #include <linux/module.h>

40 #include <linux/init.h>

41 #include <linux/types.h>

42 #include <linux/slab.h>

43 #include <linux/sched.h>

44 #include <linux/pagemap.h>

45 #include <linux/sunrpc/clnt.h>

46 #include <linux/sunrpc/auth.h>

47 #include <linux/sunrpc/auth_gss.h>

48 #include <linux/sunrpc/svcauth_gss.h>

49 #include <linux/sunrpc/gss_err.h>

50 #include <linux/workqueue.h>

51 #include <linux/sunrpc/rpc_pipe_fs.h>

52 #include <linux/sunrpc/gss_api.h>

53 #include <asm/uaccess.h>

54 #include <linux/hashtable.h>

56 #include "../netns.h"

58 static const struct rpc_authops authgss_ops;

60 static const struct rpc_credops gss_credops;

61 static const struct rpc_credops gss_nullops;

63 #define GSS_RETRY_EXPIRED 5

64 static unsigned int gss_expired_cred_retry_delay = GSS_RETRY_EXPIRED;

66 #define GSS_KEY_EXPIRE_TIMEO 240

67 static unsigned int gss_key_expire_timeo = GSS_KEY_EXPIRE_TIMEO;

69 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)

70 # define RPCDBG_FACILITY RPCDBG_AUTH

71 #endif

73 #define GSS_CRED_SLACK (RPC_MAX_AUTH_SIZE * 2)

74 /* length of a krb5 verifier (48), plus data added before arguments when

75 * using integrity (two 4-byte integers): */

76 #define GSS_VERF_SLACK 100

78 static DEFINE_HASHTABLE(gss_auth_hash_table, 4);

79 static DEFINE_SPINLOCK(gss_auth_hash_lock);

81 struct gss_pipe {

82 struct rpc_pipe_dir_object pdo;

83 struct rpc_pipe *pipe;

84 struct rpc_clnt *clnt;

85 const char *name;

86 struct kref kref;

87 };

89 struct gss_auth {

90 struct kref kref;

91 struct hlist_node hash;

92 struct rpc_auth rpc_auth;

93 struct gss_api_mech *mech;

94 enum rpc_gss_svc service;

95 struct rpc_clnt *client;

96 struct net *net;

97 /*

98 * There are two upcall pipes; dentry[1], named "gssd", is used

99 * for the new text-based upcall; dentry[0] is named after the

100 * mechanism (for example, "krb5") and exists for

101 * backwards-compatibility with older gssd's.

102 */

103 struct gss_pipe *gss_pipe[2];

104 const char *target_name;

105 };

106

107 /* pipe_version >= 0 if and only if someone has a pipe open. */

108 static DEFINE_SPINLOCK(pipe_version_lock);

109 static struct rpc_wait_queue pipe_version_rpc_waitqueue;

110 static DECLARE_WAIT_QUEUE_HEAD(pipe_version_waitqueue);

111 static void gss_put_auth(struct gss_auth *gss_auth);

112

113 static void gss_free_ctx(struct gss_cl_ctx *);

114 static const struct rpc_pipe_ops gss_upcall_ops_v0;

115 static const struct rpc_pipe_ops gss_upcall_ops_v1;

116

117 static inline struct gss_cl_ctx *

118 gss_get_ctx(struct gss_cl_ctx *ctx)

119 {

120 atomic_inc(&ctx->count);

121 return ctx;

122 }

123

124 static inline void

125 gss_put_ctx(struct gss_cl_ctx *ctx)

126 {

127 if (atomic_dec_and_test(&ctx->count))

128 gss_free_ctx(ctx);

129 }

130

131 /* gss_cred_set_ctx:

132 * called by gss_upcall_callback and gss_create_upcall in order

133 * to set the gss context. The actual exchange of an old context

134 * and a new one is protected by the pipe->lock.

135 */

136 static void

137 gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx)

138 {

139 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);

140

141 if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags))

142 return;

143 gss_get_ctx(ctx);

144 rcu_assign_pointer(gss_cred->gc_ctx, ctx);

145 set_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);

146 smp_mb__before_atomic();

147 clear_bit(RPCAUTH_CRED_NEW, &cred->cr_flags);

148 }

149

150 static const void *

151 simple_get_bytes(const void *p, const void *end, void *res, size_t len)

152 {

153 const void *q = (const void *)((const char *)p + len);

154 if (unlikely(q > end || q < p))

155 return ERR_PTR(-EFAULT);

156 memcpy(res, p, len);

157 return q;

158 }

159

160 static inline const void *

161 simple_get_netobj(const void *p, const void *end, struct xdr_netobj *dest)

162 {

163 const void *q;

164 unsigned int len;

165

166 p = simple_get_bytes(p, end, &len, sizeof(len));

167 if (IS_ERR(p))

168 return p;

169 q = (const void *)((const char *)p + len);

170 if (unlikely(q > end || q < p))

171 return ERR_PTR(-EFAULT);

172 dest->data = kmemdup(p, len, GFP_NOFS);

173 if (unlikely(dest->data == NULL))

174 return ERR_PTR(-ENOMEM);

175 dest->len = len;

176 return q;

177 }

178

179 static struct gss_cl_ctx *

180 gss_cred_get_ctx(struct rpc_cred *cred)

181 {

182 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);

183 struct gss_cl_ctx *ctx = NULL;

184

185 rcu_read_lock();

186 ctx = rcu_dereference(gss_cred->gc_ctx);

187 if (ctx)

188 gss_get_ctx(ctx);

189 rcu_read_unlock();

190 return ctx;

191 }

192

193 static struct gss_cl_ctx *

194 gss_alloc_context(void)

195 {

196 struct gss_cl_ctx *ctx;

197

198 ctx = kzalloc(sizeof(*ctx), GFP_NOFS);

199 if (ctx != NULL) {

200 ctx->gc_proc = RPC_GSS_PROC_DATA;

201 ctx->gc_seq = 1; /* NetApp 6.4R1 doesn't accept seq. no. 0 */

202 spin_lock_init(&ctx->gc_seq_lock);

203 atomic_set(&ctx->count,1);

204 }

205 return ctx;

206 }

207

208 #define GSSD_MIN_TIMEOUT (60 * 60)

209 static const void *

210 gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct gss_api_mech *gm)

211 {

212 const void *q;

213 unsigned int seclen;

214 unsigned int timeout;

215 unsigned long now = jiffies;

216 u32 window_size;

217 int ret;

218

219 /* First unsigned int gives the remaining lifetime in seconds of the

220 * credential - e.g. the remaining TGT lifetime for Kerberos or

221 * the -t value passed to GSSD.

222 */

223 p = simple_get_bytes(p, end, &timeout, sizeof(timeout));

224 if (IS_ERR(p))

225 goto err;

226 if (timeout == 0)

227 timeout = GSSD_MIN_TIMEOUT;

228 ctx->gc_expiry = now + ((unsigned long)timeout * HZ);

229 /* Sequence number window. Determines the maximum number of

230 * simultaneous requests

231 */

232 p = simple_get_bytes(p, end, &window_size, sizeof(window_size));

233 if (IS_ERR(p))

234 goto err;

235 ctx->gc_win = window_size;

236 /* gssd signals an error by passing ctx->gc_win = 0: */

237 if (ctx->gc_win == 0) {

238 /*

239 * in which case, p points to an error code. Anything other

240 * than -EKEYEXPIRED gets converted to -EACCES.

241 */

242 p = simple_get_bytes(p, end, &ret, sizeof(ret));

243 if (!IS_ERR(p))

244 p = (ret == -EKEYEXPIRED) ? ERR_PTR(-EKEYEXPIRED) :

245 ERR_PTR(-EACCES);

246 goto err;

247 }

248 /* copy the opaque wire context */

249 p = simple_get_netobj(p, end, &ctx->gc_wire_ctx);

250 if (IS_ERR(p))

251 goto err;

252 /* import the opaque security context */

253 p = simple_get_bytes(p, end, &seclen, sizeof(seclen));

254 if (IS_ERR(p))

255 goto err;

256 q = (const void *)((const char *)p + seclen);

257 if (unlikely(q > end || q < p)) {

258 p = ERR_PTR(-EFAULT);

259 goto err;

260 }

261 ret = gss_import_sec_context(p, seclen, gm, &ctx->gc_gss_ctx, NULL, GFP_NOFS);

262 if (ret < 0) {

263 p = ERR_PTR(ret);

264 goto err;

265 }

266

267 /* is there any trailing data? */

268 if (q == end) {

269 p = q;

270 goto done;

271 }

272

273 /* pull in acceptor name (if there is one) */

274 p = simple_get_netobj(q, end, &ctx->gc_acceptor);

275 if (IS_ERR(p))

276 goto err;

277 done:

278 dprintk("RPC: %s Success. gc_expiry %lu now %lu timeout %u acceptor %.*s\n",

279 __func__, ctx->gc_expiry, now, timeout, ctx->gc_acceptor.len,

280 ctx->gc_acceptor.data);

281 return p;

282 err:

283 dprintk("RPC: %s returns error %ld\n", __func__, -PTR_ERR(p));

284 return p;

285 }

286

287 #define UPCALL_BUF_LEN 128

288

289 struct gss_upcall_msg {

290 atomic_t count;

291 kuid_t uid;

292 struct rpc_pipe_msg msg;

293 struct list_head list;

294 struct gss_auth *auth;

295 struct rpc_pipe *pipe;

296 struct rpc_wait_queue rpc_waitqueue;

297 wait_queue_head_t waitqueue;

298 struct gss_cl_ctx *ctx;

299 char databuf[UPCALL_BUF_LEN];

300 };

301

302 static int get_pipe_version(struct net *net)

303 {

304 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

305 int ret;

306

307 spin_lock(&pipe_version_lock);

308 if (sn->pipe_version >= 0) {

309 atomic_inc(&sn->pipe_users);

310 ret = sn->pipe_version;

311 } else

312 ret = -EAGAIN;

313 spin_unlock(&pipe_version_lock);

314 return ret;

315 }

316

317 static void put_pipe_version(struct net *net)

318 {

319 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

320

321 if (atomic_dec_and_lock(&sn->pipe_users, &pipe_version_lock)) {

322 sn->pipe_version = -1;

323 spin_unlock(&pipe_version_lock);

324 }

325 }

326

327 static void

328 gss_release_msg(struct gss_upcall_msg *gss_msg)

329 {

330 struct net *net = gss_msg->auth->net;

331 if (!atomic_dec_and_test(&gss_msg->count))

332 return;

333 put_pipe_version(net);

334 BUG_ON(!list_empty(&gss_msg->list));

335 if (gss_msg->ctx != NULL)

336 gss_put_ctx(gss_msg->ctx);

337 rpc_destroy_wait_queue(&gss_msg->rpc_waitqueue);

338 gss_put_auth(gss_msg->auth);

339 kfree(gss_msg);

340 }

341

342 static struct gss_upcall_msg *

343 __gss_find_upcall(struct rpc_pipe *pipe, kuid_t uid)

344 {

345 struct gss_upcall_msg *pos;

346 list_for_each_entry(pos, &pipe->in_downcall, list) {

347 if (!uid_eq(pos->uid, uid))

348 continue;

349 atomic_inc(&pos->count);

350 dprintk("RPC: %s found msg %p\n", __func__, pos);

351 return pos;

352 }

353 dprintk("RPC: %s found nothing\n", __func__);

354 return NULL;

355 }

356

357 /* Try to add an upcall to the pipefs queue.

358 * If an upcall owned by our uid already exists, then we return a reference

359 * to that upcall instead of adding the new upcall.

360 */

361 static inline struct gss_upcall_msg *

362 gss_add_msg(struct gss_upcall_msg *gss_msg)

363 {

364 struct rpc_pipe *pipe = gss_msg->pipe;

365 struct gss_upcall_msg *old;

366

367 spin_lock(&pipe->lock);

368 old = __gss_find_upcall(pipe, gss_msg->uid);

369 if (old == NULL) {

370 atomic_inc(&gss_msg->count);

371 list_add(&gss_msg->list, &pipe->in_downcall);

372 } else

373 gss_msg = old;

374 spin_unlock(&pipe->lock);

375 return gss_msg;

376 }

377

378 static void

379 __gss_unhash_msg(struct gss_upcall_msg *gss_msg)

380 {

381 list_del_init(&gss_msg->list);

382 rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);

383 wake_up_all(&gss_msg->waitqueue);

384 atomic_dec(&gss_msg->count);

385 }

386

387 static void

388 gss_unhash_msg(struct gss_upcall_msg *gss_msg)

389 {

390 struct rpc_pipe *pipe = gss_msg->pipe;

391

392 if (list_empty(&gss_msg->list))

393 return;

394 spin_lock(&pipe->lock);

395 if (!list_empty(&gss_msg->list))

396 __gss_unhash_msg(gss_msg);

397 spin_unlock(&pipe->lock);

398 }

399

400 static void

401 gss_handle_downcall_result(struct gss_cred *gss_cred, struct gss_upcall_msg *gss_msg)

402 {

403 switch (gss_msg->msg.errno) {

404 case 0:

405 if (gss_msg->ctx == NULL)

406 break;

407 clear_bit(RPCAUTH_CRED_NEGATIVE, &gss_cred->gc_base.cr_flags);

408 gss_cred_set_ctx(&gss_cred->gc_base, gss_msg->ctx);

409 break;

410 case -EKEYEXPIRED:

411 set_bit(RPCAUTH_CRED_NEGATIVE, &gss_cred->gc_base.cr_flags);

412 }

413 gss_cred->gc_upcall_timestamp = jiffies;

414 gss_cred->gc_upcall = NULL;

415 rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno);

416 }

417

418 static void

419 gss_upcall_callback(struct rpc_task *task)

420 {

421 struct gss_cred *gss_cred = container_of(task->tk_rqstp->rq_cred,

422 struct gss_cred, gc_base);

423 struct gss_upcall_msg *gss_msg = gss_cred->gc_upcall;

424 struct rpc_pipe *pipe = gss_msg->pipe;

425

426 spin_lock(&pipe->lock);

427 gss_handle_downcall_result(gss_cred, gss_msg);

428 spin_unlock(&pipe->lock);

429 task->tk_status = gss_msg->msg.errno;

430 gss_release_msg(gss_msg);

431 }

432

433 static void gss_encode_v0_msg(struct gss_upcall_msg *gss_msg)

434 {

435 uid_t uid = from_kuid(&init_user_ns, gss_msg->uid);

436 memcpy(gss_msg->databuf, &uid, sizeof(uid));

437 gss_msg->msg.data = gss_msg->databuf;

438 gss_msg->msg.len = sizeof(uid);

439

440 BUILD_BUG_ON(sizeof(uid) > sizeof(gss_msg->databuf));

441 }

442

443 static int gss_encode_v1_msg(struct gss_upcall_msg *gss_msg,

444 const char *service_name,

445 const char *target_name)

446 {

447 struct gss_api_mech *mech = gss_msg->auth->mech;

448 char *p = gss_msg->databuf;

449 size_t buflen = sizeof(gss_msg->databuf);

450 int len;

451

452 len = scnprintf(p, buflen, "mech=%s uid=%d ", mech->gm_name,

453 from_kuid(&init_user_ns, gss_msg->uid));

454 buflen -= len;

455 p += len;

456 gss_msg->msg.len = len;

457 if (target_name) {

458 len = scnprintf(p, buflen, "target=%s ", target_name);

459 buflen -= len;

460 p += len;

461 gss_msg->msg.len += len;

462 }

463 if (service_name != NULL) {

464 len = scnprintf(p, buflen, "service=%s ", service_name);

465 buflen -= len;

466 p += len;

467 gss_msg->msg.len += len;

468 }

469 if (mech->gm_upcall_enctypes) {

470 len = scnprintf(p, buflen, "enctypes=%s ",

471 mech->gm_upcall_enctypes);

472 buflen -= len;

473 p += len;

474 gss_msg->msg.len += len;

475 }

476 len = scnprintf(p, buflen, "\n");

477 if (len == 0)

478 goto out_overflow;

479 gss_msg->msg.len += len;

480

481 gss_msg->msg.data = gss_msg->databuf;

482 return 0;

483 out_overflow:

484 WARN_ON_ONCE(1);

485 return -ENOMEM;

486 }

487

488 static struct gss_upcall_msg *

489 gss_alloc_msg(struct gss_auth *gss_auth,

490 kuid_t uid, const char *service_name)

491 {

492 struct gss_upcall_msg *gss_msg;

493 int vers;

494 int err = -ENOMEM;

495

496 gss_msg = kzalloc(sizeof(*gss_msg), GFP_NOFS);

497 if (gss_msg == NULL)

498 goto err;

499 vers = get_pipe_version(gss_auth->net);

500 err = vers;

501 if (err < 0)

502 goto err_free_msg;

503 gss_msg->pipe = gss_auth->gss_pipe[vers]->pipe;

504 INIT_LIST_HEAD(&gss_msg->list);

505 rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq");

506 init_waitqueue_head(&gss_msg->waitqueue);

507 atomic_set(&gss_msg->count, 1);

508 gss_msg->uid = uid;

509 gss_msg->auth = gss_auth;

510 switch (vers) {

511 case 0:

512 gss_encode_v0_msg(gss_msg);

513 break;

514 default:

515 err = gss_encode_v1_msg(gss_msg, service_name, gss_auth->target_name);

516 if (err)

517 goto err_put_pipe_version;

518 };

519 kref_get(&gss_auth->kref);

520 return gss_msg;

521 err_put_pipe_version:

522 put_pipe_version(gss_auth->net);

523 err_free_msg:

524 kfree(gss_msg);

525 err:

526 return ERR_PTR(err);

527 }

528

529 static struct gss_upcall_msg *

530 gss_setup_upcall(struct gss_auth *gss_auth, struct rpc_cred *cred)

531 {

532 struct gss_cred *gss_cred = container_of(cred,

533 struct gss_cred, gc_base);

534 struct gss_upcall_msg *gss_new, *gss_msg;

535 kuid_t uid = cred->cr_uid;

536

537 gss_new = gss_alloc_msg(gss_auth, uid, gss_cred->gc_principal);

538 if (IS_ERR(gss_new))

539 return gss_new;

540 gss_msg = gss_add_msg(gss_new);

541 if (gss_msg == gss_new) {

542 int res = rpc_queue_upcall(gss_new->pipe, &gss_new->msg);

543 if (res) {

544 gss_unhash_msg(gss_new);

545 gss_msg = ERR_PTR(res);

546 }

547 } else

548 gss_release_msg(gss_new);

549 return gss_msg;

550 }

551

552 static void warn_gssd(void)

553 {

554 dprintk("AUTH_GSS upcall failed. Please check user daemon is running.\n");

555 }

556

557 static inline int

558 gss_refresh_upcall(struct rpc_task *task)

559 {

560 struct rpc_cred *cred = task->tk_rqstp->rq_cred;

561 struct gss_auth *gss_auth = container_of(cred->cr_auth,

562 struct gss_auth, rpc_auth);

563 struct gss_cred *gss_cred = container_of(cred,

564 struct gss_cred, gc_base);

565 struct gss_upcall_msg *gss_msg;

566 struct rpc_pipe *pipe;

567 int err = 0;

568

569 dprintk("RPC: %5u %s for uid %u\n",

570 task->tk_pid, __func__, from_kuid(&init_user_ns, cred->cr_uid));

571 gss_msg = gss_setup_upcall(gss_auth, cred);

572 if (PTR_ERR(gss_msg) == -EAGAIN) {

573 /* XXX: warning on the first, under the assumption we

574 * shouldn't normally hit this case on a refresh. */

575 warn_gssd();

576 task->tk_timeout = 15*HZ;

577 rpc_sleep_on(&pipe_version_rpc_waitqueue, task, NULL);

578 return -EAGAIN;

579 }

580 if (IS_ERR(gss_msg)) {

581 err = PTR_ERR(gss_msg);

582 goto out;

583 }

584 pipe = gss_msg->pipe;

585 spin_lock(&pipe->lock);

586 if (gss_cred->gc_upcall != NULL)

587 rpc_sleep_on(&gss_cred->gc_upcall->rpc_waitqueue, task, NULL);

588 else if (gss_msg->ctx == NULL && gss_msg->msg.errno >= 0) {

589 task->tk_timeout = 0;

590 gss_cred->gc_upcall = gss_msg;

591 /* gss_upcall_callback will release the reference to gss_upcall_msg */

592 atomic_inc(&gss_msg->count);

593 rpc_sleep_on(&gss_msg->rpc_waitqueue, task, gss_upcall_callback);

594 } else {

595 gss_handle_downcall_result(gss_cred, gss_msg);

596 err = gss_msg->msg.errno;

597 }

598 spin_unlock(&pipe->lock);

599 gss_release_msg(gss_msg);

600 out:

601 dprintk("RPC: %5u %s for uid %u result %d\n",

602 task->tk_pid, __func__,

603 from_kuid(&init_user_ns, cred->cr_uid), err);

604 return err;

605 }

606

607 static inline int

608 gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)

609 {

610 struct net *net = gss_auth->net;

611 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

612 struct rpc_pipe *pipe;

613 struct rpc_cred *cred = &gss_cred->gc_base;

614 struct gss_upcall_msg *gss_msg;

615 DEFINE_WAIT(wait);

616 int err;

617

618 dprintk("RPC: %s for uid %u\n",

619 __func__, from_kuid(&init_user_ns, cred->cr_uid));

620 retry:

621 err = 0;

622 /* if gssd is down, just skip upcalling altogether */

623 if (!gssd_running(net)) {

624 warn_gssd();

625 return -EACCES;

626 }

627 gss_msg = gss_setup_upcall(gss_auth, cred);

628 if (PTR_ERR(gss_msg) == -EAGAIN) {

629 err = wait_event_interruptible_timeout(pipe_version_waitqueue,

630 sn->pipe_version >= 0, 15 * HZ);

631 if (sn->pipe_version < 0) {

632 warn_gssd();

633 err = -EACCES;

634 }

635 if (err < 0)

636 goto out;

637 goto retry;

638 }

639 if (IS_ERR(gss_msg)) {

640 err = PTR_ERR(gss_msg);

641 goto out;

642 }

643 pipe = gss_msg->pipe;

644 for (;;) {

645 prepare_to_wait(&gss_msg->waitqueue, &wait, TASK_KILLABLE);

646 spin_lock(&pipe->lock);

647 if (gss_msg->ctx != NULL || gss_msg->msg.errno < 0) {

648 break;

649 }

650 spin_unlock(&pipe->lock);

651 if (fatal_signal_pending(current)) {

652 err = -ERESTARTSYS;

653 goto out_intr;

654 }

655 schedule();

656 }

657 if (gss_msg->ctx)

658 gss_cred_set_ctx(cred, gss_msg->ctx);

659 else

660 err = gss_msg->msg.errno;

661 spin_unlock(&pipe->lock);

662 out_intr:

663 finish_wait(&gss_msg->waitqueue, &wait);

664 gss_release_msg(gss_msg);

665 out:

666 dprintk("RPC: %s for uid %u result %d\n",

667 __func__, from_kuid(&init_user_ns, cred->cr_uid), err);

668 return err;

669 }

670

671 #define MSG_BUF_MAXSIZE 1024

672

673 static ssize_t

674 gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)

675 {

676 const void *p, *end;

677 void *buf;

678 struct gss_upcall_msg *gss_msg;

679 struct rpc_pipe *pipe = RPC_I(file_inode(filp))->pipe;

680 struct gss_cl_ctx *ctx;

681 uid_t id;

682 kuid_t uid;

683 ssize_t err = -EFBIG;

684

685 if (mlen > MSG_BUF_MAXSIZE)

686 goto out;

687 err = -ENOMEM;

688 buf = kmalloc(mlen, GFP_NOFS);

689 if (!buf)

690 goto out;

691

692 err = -EFAULT;

693 if (copy_from_user(buf, src, mlen))

694 goto err;

695

696 end = (const void *)((char *)buf + mlen);

697 p = simple_get_bytes(buf, end, &id, sizeof(id));

698 if (IS_ERR(p)) {

699 err = PTR_ERR(p);

700 goto err;

701 }

702

703 uid = make_kuid(&init_user_ns, id);

704 if (!uid_valid(uid)) {

705 err = -EINVAL;

706 goto err;

707 }

708

709 err = -ENOMEM;

710 ctx = gss_alloc_context();

711 if (ctx == NULL)

712 goto err;

713

714 err = -ENOENT;

715 /* Find a matching upcall */

716 spin_lock(&pipe->lock);

717 gss_msg = __gss_find_upcall(pipe, uid);

718 if (gss_msg == NULL) {

719 spin_unlock(&pipe->lock);

720 goto err_put_ctx;

721 }

722 list_del_init(&gss_msg->list);

723 spin_unlock(&pipe->lock);

724

725 p = gss_fill_context(p, end, ctx, gss_msg->auth->mech);

726 if (IS_ERR(p)) {

727 err = PTR_ERR(p);

728 switch (err) {

729 case -EACCES:

730 case -EKEYEXPIRED:

731 gss_msg->msg.errno = err;

732 err = mlen;

733 break;

734 case -EFAULT:

735 case -ENOMEM:

736 case -EINVAL:

737 case -ENOSYS:

738 gss_msg->msg.errno = -EAGAIN;

739 break;

740 default:

741 printk(KERN_CRIT "%s: bad return from "

742 "gss_fill_context: %zd\n", __func__, err);

743 BUG();

744 }

745 goto err_release_msg;

746 }

747 gss_msg->ctx = gss_get_ctx(ctx);

748 err = mlen;

749

750 err_release_msg:

751 spin_lock(&pipe->lock);

752 __gss_unhash_msg(gss_msg);

753 spin_unlock(&pipe->lock);

754 gss_release_msg(gss_msg);

755 err_put_ctx:

756 gss_put_ctx(ctx);

757 err:

758 kfree(buf);

759 out:

760 dprintk("RPC: %s returning %Zd\n", __func__, err);

761 return err;

762 }

763

764 static int gss_pipe_open(struct inode *inode, int new_version)

765 {

766 struct net *net = inode->i_sb->s_fs_info;

767 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

768 int ret = 0;

769

770 spin_lock(&pipe_version_lock);

771 if (sn->pipe_version < 0) {

772 /* First open of any gss pipe determines the version: */

773 sn->pipe_version = new_version;

774 rpc_wake_up(&pipe_version_rpc_waitqueue);

775 wake_up(&pipe_version_waitqueue);

776 } else if (sn->pipe_version != new_version) {

777 /* Trying to open a pipe of a different version */

778 ret = -EBUSY;

779 goto out;

780 }

781 atomic_inc(&sn->pipe_users);

782 out:

783 spin_unlock(&pipe_version_lock);

784 return ret;

785

786 }

787

788 static int gss_pipe_open_v0(struct inode *inode)

789 {

790 return gss_pipe_open(inode, 0);

791 }

792

793 static int gss_pipe_open_v1(struct inode *inode)

794 {

795 return gss_pipe_open(inode, 1);

796 }

797

798 static void

799 gss_pipe_release(struct inode *inode)

800 {

801 struct net *net = inode->i_sb->s_fs_info;

802 struct rpc_pipe *pipe = RPC_I(inode)->pipe;

803 struct gss_upcall_msg *gss_msg;

804

805 restart:

806 spin_lock(&pipe->lock);

807 list_for_each_entry(gss_msg, &pipe->in_downcall, list) {

808

809 if (!list_empty(&gss_msg->msg.list))

810 continue;

811 gss_msg->msg.errno = -EPIPE;

812 atomic_inc(&gss_msg->count);

813 __gss_unhash_msg(gss_msg);

814 spin_unlock(&pipe->lock);

815 gss_release_msg(gss_msg);

816 goto restart;

817 }

818 spin_unlock(&pipe->lock);

819

820 put_pipe_version(net);

821 }

822

823 static void

824 gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)

825 {

826 struct gss_upcall_msg *gss_msg = container_of(msg, struct gss_upcall_msg, msg);

827

828 if (msg->errno < 0) {

829 dprintk("RPC: %s releasing msg %p\n",

830 __func__, gss_msg);

831 atomic_inc(&gss_msg->count);

832 gss_unhash_msg(gss_msg);

833 if (msg->errno == -ETIMEDOUT)

834 warn_gssd();

835 gss_release_msg(gss_msg);

836 }

837 }

838

839 static void gss_pipe_dentry_destroy(struct dentry *dir,

840 struct rpc_pipe_dir_object *pdo)

841 {

842 struct gss_pipe *gss_pipe = pdo->pdo_data;

843 struct rpc_pipe *pipe = gss_pipe->pipe;

844

845 if (pipe->dentry != NULL) {

846 rpc_unlink(pipe->dentry);

847 pipe->dentry = NULL;

848 }

849 }

850

851 static int gss_pipe_dentry_create(struct dentry *dir,

852 struct rpc_pipe_dir_object *pdo)

853 {

854 struct gss_pipe *p = pdo->pdo_data;

855 struct dentry *dentry;

856

857 dentry = rpc_mkpipe_dentry(dir, p->name, p->clnt, p->pipe);

858 if (IS_ERR(dentry))

859 return PTR_ERR(dentry);

860 p->pipe->dentry = dentry;

861 return 0;

862 }

863

864 static const struct rpc_pipe_dir_object_ops gss_pipe_dir_object_ops = {

865 .create = gss_pipe_dentry_create,

866 .destroy = gss_pipe_dentry_destroy,

867 };

868

869 static struct gss_pipe *gss_pipe_alloc(struct rpc_clnt *clnt,

870 const char *name,

871 const struct rpc_pipe_ops *upcall_ops)

872 {

873 struct gss_pipe *p;

874 int err = -ENOMEM;

875

876 p = kmalloc(sizeof(*p), GFP_KERNEL);

877 if (p == NULL)

878 goto err;

879 p->pipe = rpc_mkpipe_data(upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);

880 if (IS_ERR(p->pipe)) {

881 err = PTR_ERR(p->pipe);

882 goto err_free_gss_pipe;

883 }

884 p->name = name;

885 p->clnt = clnt;

886 kref_init(&p->kref);

887 rpc_init_pipe_dir_object(&p->pdo,

888 &gss_pipe_dir_object_ops,

889 p);

890 return p;

891 err_free_gss_pipe:

892 kfree(p);

893 err:

894 return ERR_PTR(err);

895 }

896

897 struct gss_alloc_pdo {

898 struct rpc_clnt *clnt;

899 const char *name;

900 const struct rpc_pipe_ops *upcall_ops;

901 };

902

903 static int gss_pipe_match_pdo(struct rpc_pipe_dir_object *pdo, void *data)

904 {

905 struct gss_pipe *gss_pipe;

906 struct gss_alloc_pdo *args = data;

907

908 if (pdo->pdo_ops != &gss_pipe_dir_object_ops)

909 return 0;

910 gss_pipe = container_of(pdo, struct gss_pipe, pdo);

911 if (strcmp(gss_pipe->name, args->name) != 0)

912 return 0;

913 if (!kref_get_unless_zero(&gss_pipe->kref))

914 return 0;

915 return 1;

916 }

917

918 static struct rpc_pipe_dir_object *gss_pipe_alloc_pdo(void *data)

919 {

920 struct gss_pipe *gss_pipe;

921 struct gss_alloc_pdo *args = data;

922

923 gss_pipe = gss_pipe_alloc(args->clnt, args->name, args->upcall_ops);

924 if (!IS_ERR(gss_pipe))

925 return &gss_pipe->pdo;

926 return NULL;

927 }

928

929 static struct gss_pipe *gss_pipe_get(struct rpc_clnt *clnt,

930 const char *name,

931 const struct rpc_pipe_ops *upcall_ops)

932 {

933 struct net *net = rpc_net_ns(clnt);

934 struct rpc_pipe_dir_object *pdo;

935 struct gss_alloc_pdo args = {

936 .clnt = clnt,

937 .name = name,

938 .upcall_ops = upcall_ops,

939 };

940

941 pdo = rpc_find_or_alloc_pipe_dir_object(net,

942 &clnt->cl_pipedir_objects,

943 gss_pipe_match_pdo,

944 gss_pipe_alloc_pdo,

945 &args);

946 if (pdo != NULL)

947 return container_of(pdo, struct gss_pipe, pdo);

948 return ERR_PTR(-ENOMEM);

949 }

950

951 static void __gss_pipe_free(struct gss_pipe *p)

952 {

953 struct rpc_clnt *clnt = p->clnt;

954 struct net *net = rpc_net_ns(clnt);

955

956 rpc_remove_pipe_dir_object(net,

957 &clnt->cl_pipedir_objects,

958 &p->pdo);

959 rpc_destroy_pipe_data(p->pipe);

960 kfree(p);

961 }

962

963 static void __gss_pipe_release(struct kref *kref)

964 {

965 struct gss_pipe *p = container_of(kref, struct gss_pipe, kref);

966

967 __gss_pipe_free(p);

968 }

969

970 static void gss_pipe_free(struct gss_pipe *p)

971 {

972 if (p != NULL)

973 kref_put(&p->kref, __gss_pipe_release);

974 }

975

976 /*

977 * NOTE: we have the opportunity to use different

978 * parameters based on the input flavor (which must be a pseudoflavor)

979 */

980 static struct gss_auth *

981 gss_create_new(struct rpc_auth_create_args *args, struct rpc_clnt *clnt)

982 {

983 rpc_authflavor_t flavor = args->pseudoflavor;

984 struct gss_auth *gss_auth;

985 struct gss_pipe *gss_pipe;

986 struct rpc_auth * auth;

987 int err = -ENOMEM; /* XXX? */

988

989 dprintk("RPC: creating GSS authenticator for client %p\n", clnt);

990

991 if (!try_module_get(THIS_MODULE))

992 return ERR_PTR(err);

993 if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL)))

994 goto out_dec;

995 INIT_HLIST_NODE(&gss_auth->hash);

996 gss_auth->target_name = NULL;

997 if (args->target_name) {

998 gss_auth->target_name = kstrdup(args->target_name, GFP_KERNEL);

999 if (gss_auth->target_name == NULL)

1000 goto err_free;

1001 }

1002 gss_auth->client = clnt;

1003 gss_auth->net = get_net(rpc_net_ns(clnt));

1004 err = -EINVAL;

1005 gss_auth->mech = gss_mech_get_by_pseudoflavor(flavor);

1006 if (!gss_auth->mech) {

1007 dprintk("RPC: Pseudoflavor %d not found!\n", flavor);

1008 goto err_put_net;

1009 }

1010 gss_auth->service = gss_pseudoflavor_to_service(gss_auth->mech, flavor);

1011 if (gss_auth->service == 0)

1012 goto err_put_mech;

1013 if (!gssd_running(gss_auth->net))

1014 goto err_put_mech;

1015 auth = &gss_auth->rpc_auth;

1016 auth->au_cslack = GSS_CRED_SLACK >> 2;

1017 auth->au_rslack = GSS_VERF_SLACK >> 2;

1018 auth->au_ops = &authgss_ops;

1019 auth->au_flavor = flavor;

1020 atomic_set(&auth->au_count, 1);

1021 kref_init(&gss_auth->kref);

1022

1023 err = rpcauth_init_credcache(auth);

1024 if (err)

1025 goto err_put_mech;

1026 /*

1027 * Note: if we created the old pipe first, then someone who

1028 * examined the directory at the right moment might conclude

1029 * that we supported only the old pipe. So we instead create

1030 * the new pipe first.

1031 */

1032 gss_pipe = gss_pipe_get(clnt, "gssd", &gss_upcall_ops_v1);

1033 if (IS_ERR(gss_pipe)) {

1034 err = PTR_ERR(gss_pipe);

1035 goto err_destroy_credcache;

1036 }

1037 gss_auth->gss_pipe[1] = gss_pipe;

1038

1039 gss_pipe = gss_pipe_get(clnt, gss_auth->mech->gm_name,

1040 &gss_upcall_ops_v0);

1041 if (IS_ERR(gss_pipe)) {

1042 err = PTR_ERR(gss_pipe);

1043 goto err_destroy_pipe_1;

1044 }

1045 gss_auth->gss_pipe[0] = gss_pipe;

1046

1047 return gss_auth;

1048 err_destroy_pipe_1:

1049 gss_pipe_free(gss_auth->gss_pipe[1]);

1050 err_destroy_credcache:

1051 rpcauth_destroy_credcache(auth);

1052 err_put_mech:

1053 gss_mech_put(gss_auth->mech);

1054 err_put_net:

1055 put_net(gss_auth->net);

1056 err_free:

1057 kfree(gss_auth->target_name);

1058 kfree(gss_auth);

1059 out_dec:

1060 module_put(THIS_MODULE);

1061 return ERR_PTR(err);

1062 }

1063

1064 static void

1065 gss_free(struct gss_auth *gss_auth)

1066 {

1067 gss_pipe_free(gss_auth->gss_pipe[0]);

1068 gss_pipe_free(gss_auth->gss_pipe[1]);

1069 gss_mech_put(gss_auth->mech);

1070 put_net(gss_auth->net);

1071 kfree(gss_auth->target_name);

1072

1073 kfree(gss_auth);

1074 module_put(THIS_MODULE);

1075 }

1076

1077 static void

1078 gss_free_callback(struct kref *kref)

1079 {

1080 struct gss_auth *gss_auth = container_of(kref, struct gss_auth, kref);

1081

1082 gss_free(gss_auth);

1083 }

1084

1085 static void

1086 gss_put_auth(struct gss_auth *gss_auth)

1087 {

1088 kref_put(&gss_auth->kref, gss_free_callback);

1089 }

1090

1091 static void

1092 gss_destroy(struct rpc_auth *auth)

1093 {

1094 struct gss_auth *gss_auth = container_of(auth,

1095 struct gss_auth, rpc_auth);

1096

1097 dprintk("RPC: destroying GSS authenticator %p flavor %d\n",

1098 auth, auth->au_flavor);

1099

1100 if (hash_hashed(&gss_auth->hash)) {

1101 spin_lock(&gss_auth_hash_lock);

1102 hash_del(&gss_auth->hash);

1103 spin_unlock(&gss_auth_hash_lock);

1104 }

1105

1106 gss_pipe_free(gss_auth->gss_pipe[0]);

1107 gss_auth->gss_pipe[0] = NULL;

1108 gss_pipe_free(gss_auth->gss_pipe[1]);

1109 gss_auth->gss_pipe[1] = NULL;

1110 rpcauth_destroy_credcache(auth);

1111

1112 gss_put_auth(gss_auth);

1113 }

1114

1115 /*

1116 * Auths may be shared between rpc clients that were cloned from a

1117 * common client with the same xprt, if they also share the flavor and

1118 * target_name.

1119 *

1120 * The auth is looked up from the oldest parent sharing the same

1121 * cl_xprt, and the auth itself references only that common parent

1122 * (which is guaranteed to last as long as any of its descendants).

1123 */

1124 static struct gss_auth *

1125 gss_auth_find_or_add_hashed(struct rpc_auth_create_args *args,

1126 struct rpc_clnt *clnt,

1127 struct gss_auth *new)

1128 {

1129 struct gss_auth *gss_auth;

1130 unsigned long hashval = (unsigned long)clnt;

1131

1132 spin_lock(&gss_auth_hash_lock);

1133 hash_for_each_possible(gss_auth_hash_table,

1134 gss_auth,

1135 hash,

1136 hashval) {

1137 if (gss_auth->client != clnt)

1138 continue;

1139 if (gss_auth->rpc_auth.au_flavor != args->pseudoflavor)

1140 continue;

1141 if (gss_auth->target_name != args->target_name) {

1142 if (gss_auth->target_name == NULL)

1143 continue;

1144 if (args->target_name == NULL)

1145 continue;

1146 if (strcmp(gss_auth->target_name, args->target_name))

1147 continue;

1148 }

1149 if (!atomic_inc_not_zero(&gss_auth->rpc_auth.au_count))

1150 continue;

1151 goto out;

1152 }

1153 if (new)

1154 hash_add(gss_auth_hash_table, &new->hash, hashval);

1155 gss_auth = new;

1156 out:

1157 spin_unlock(&gss_auth_hash_lock);

1158 return gss_auth;

1159 }

1160

1161 static struct gss_auth *

1162 gss_create_hashed(struct rpc_auth_create_args *args, struct rpc_clnt *clnt)

1163 {

1164 struct gss_auth *gss_auth;

1165 struct gss_auth *new;

1166

1167 gss_auth = gss_auth_find_or_add_hashed(args, clnt, NULL);

1168 if (gss_auth != NULL)

1169 goto out;

1170 new = gss_create_new(args, clnt);

1171 if (IS_ERR(new))

1172 return new;

1173 gss_auth = gss_auth_find_or_add_hashed(args, clnt, new);

1174 if (gss_auth != new)

1175 gss_destroy(&new->rpc_auth);

1176 out:

1177 return gss_auth;

1178 }

1179

1180 static struct rpc_auth *

1181 gss_create(struct rpc_auth_create_args *args, struct rpc_clnt *clnt)

1182 {

1183 struct gss_auth *gss_auth;

1184 struct rpc_xprt *xprt = rcu_access_pointer(clnt->cl_xprt);

1185

1186 while (clnt != clnt->cl_parent) {

1187 struct rpc_clnt *parent = clnt->cl_parent;

1188 /* Find the original parent for this transport */

1189 if (rcu_access_pointer(parent->cl_xprt) != xprt)

1190 break;

1191 clnt = parent;

1192 }

1193

1194 gss_auth = gss_create_hashed(args, clnt);

1195 if (IS_ERR(gss_auth))

1196 return ERR_CAST(gss_auth);

1197 return &gss_auth->rpc_auth;

1198 }

1199

1200 /*

1201 * gss_destroying_context will cause the RPCSEC_GSS to send a NULL RPC call

1202 * to the server with the GSS control procedure field set to

1203 * RPC_GSS_PROC_DESTROY. This should normally cause the server to release

1204 * all RPCSEC_GSS state associated with that context.

1205 */

1206 static int

1207 gss_destroying_context(struct rpc_cred *cred)

1208 {

1209 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);

1210 struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth);

1211 struct gss_cl_ctx *ctx = rcu_dereference_protected(gss_cred->gc_ctx, 1);

1212 struct rpc_task *task;

1213

1214 if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) == 0)

1215 return 0;

1216

1217 ctx->gc_proc = RPC_GSS_PROC_DESTROY;

1218 cred->cr_ops = &gss_nullops;

1219

1220 /* Take a reference to ensure the cred will be destroyed either

1221 * by the RPC call or by the put_rpccred() below */

1222 get_rpccred(cred);

1223

1224 task = rpc_call_null(gss_auth->client, cred, RPC_TASK_ASYNC|RPC_TASK_SOFT);

1225 if (!IS_ERR(task))

1226 rpc_put_task(task);

1227

1228 put_rpccred(cred);

1229 return 1;

1230 }

1231

1232 /* gss_destroy_cred (and gss_free_ctx) are used to clean up after failure

1233 * to create a new cred or context, so they check that things have been

1234 * allocated before freeing them. */

1235 static void

1236 gss_do_free_ctx(struct gss_cl_ctx *ctx)

1237 {

1238 dprintk("RPC: %s\n", __func__);

1239

1240 gss_delete_sec_context(&ctx->gc_gss_ctx);

1241 kfree(ctx->gc_wire_ctx.data);

1242 kfree(ctx->gc_acceptor.data);

1243 kfree(ctx);

1244 }

1245

1246 static void

1247 gss_free_ctx_callback(struct rcu_head *head)

1248 {

1249 struct gss_cl_ctx *ctx = container_of(head, struct gss_cl_ctx, gc_rcu);

1250 gss_do_free_ctx(ctx);

1251 }

1252

1253 static void

1254 gss_free_ctx(struct gss_cl_ctx *ctx)

1255 {

1256 call_rcu(&ctx->gc_rcu, gss_free_ctx_callback);

1257 }

1258

1259 static void

1260 gss_free_cred(struct gss_cred *gss_cred)

1261 {

1262 dprintk("RPC: %s cred=%p\n", __func__, gss_cred);

1263 kfree(gss_cred);

1264 }

1265

1266 static void

1267 gss_free_cred_callback(struct rcu_head *head)

1268 {

1269 struct gss_cred *gss_cred = container_of(head, struct gss_cred, gc_base.cr_rcu);

1270 gss_free_cred(gss_cred);

1271 }

1272

1273 static void

1274 gss_destroy_nullcred(struct rpc_cred *cred)

1275 {

1276 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);

1277 struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth);

1278 struct gss_cl_ctx *ctx = rcu_dereference_protected(gss_cred->gc_ctx, 1);

1279

1280 RCU_INIT_POINTER(gss_cred->gc_ctx, NULL);

1281 call_rcu(&cred->cr_rcu, gss_free_cred_callback);

1282 if (ctx)

1283 gss_put_ctx(ctx);

1284 gss_put_auth(gss_auth);

1285 }

1286

1287 static void

1288 gss_destroy_cred(struct rpc_cred *cred)

1289 {

1290

1291 if (gss_destroying_context(cred))

1292 return;

1293 gss_destroy_nullcred(cred);

1294 }

1295

1296 /*

1297 * Lookup RPCSEC_GSS cred for the current process

1298 */

1299 static struct rpc_cred *

1300 gss_lookup_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)

1301 {

1302 return rpcauth_lookup_credcache(auth, acred, flags);

1303 }

1304

1305 static struct rpc_cred *

1306 gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)

1307 {

1308 struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);

1309 struct gss_cred *cred = NULL;

1310 int err = -ENOMEM;

1311

1312 dprintk("RPC: %s for uid %d, flavor %d\n",

1313 __func__, from_kuid(&init_user_ns, acred->uid),

1314 auth->au_flavor);

1315

1316 if (!(cred = kzalloc(sizeof(*cred), GFP_NOFS)))

1317 goto out_err;

1318

1319 rpcauth_init_cred(&cred->gc_base, acred, auth, &gss_credops);

1320 /*

1321 * Note: in order to force a call to call_refresh(), we deliberately

1322 * fail to flag the credential as RPCAUTH_CRED_UPTODATE.

1323 */

1324 cred->gc_base.cr_flags = 1UL << RPCAUTH_CRED_NEW;

1325 cred->gc_service = gss_auth->service;

1326 cred->gc_principal = NULL;

1327 if (acred->machine_cred)

1328 cred->gc_principal = acred->principal;

1329 kref_get(&gss_auth->kref);

1330 return &cred->gc_base;

1331

1332 out_err:

1333 dprintk("RPC: %s failed with error %d\n", __func__, err);

1334 return ERR_PTR(err);

1335 }

1336

1337 static int

1338 gss_cred_init(struct rpc_auth *auth, struct rpc_cred *cred)

1339 {

1340 struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth);

1341 struct gss_cred *gss_cred = container_of(cred,struct gss_cred, gc_base);

1342 int err;

1343

1344 do {

1345 err = gss_create_upcall(gss_auth, gss_cred);

1346 } while (err == -EAGAIN);

1347 return err;

1348 }

1349

1350 static char *

1351 gss_stringify_acceptor(struct rpc_cred *cred)

1352 {

1353 char *string = NULL;

1354 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base);

1355 struct gss_cl_ctx *ctx;

1356 unsigned int len;

1357 struct xdr_netobj *acceptor;

1358

1359 rcu_read_lock();

1360 ctx = rcu_dereference(gss_cred->gc_ctx);

1361 if (!ctx)

1362 goto out;

1363

1364 len = ctx->gc_acceptor.len;

1365 rcu_read_unlock();

1366

1367 /* no point if there's no string */

1368 if (!len)

1369 return NULL;

1370 realloc:

1371 string = kmalloc(len + 1, GFP_KERNEL);

1372 if (!string)

1373 return NULL;

1374

1375 rcu_read_lock();

1376 ctx = rcu_dereference(gss_cred->gc_ctx);

1377

1378 /* did the ctx disappear or was it replaced by one with no acceptor? */

1379 if (!ctx || !ctx->gc_acceptor.len) {

1380 kfree(string);

1381 string = NULL;

1382 goto out;

1383 }

1384

1385 acceptor = &ctx->gc_acceptor;

1386

1387 /*

1388 * Did we find a new acceptor that's longer than the original? Allocate

1389 * a longer buffer and try again.

1390 */

1391 if (len < acceptor->len) {

1392 len = acceptor->len;

1393 rcu_read_unlock();

1394 kfree(string);

1395 goto realloc;

1396 }

1397

1398 memcpy(string, acceptor->data, acceptor->len);

1399 string[acceptor->len] = '\0';

1400 out:

1401 rcu_read_unlock();

1402 return string;

1403 }

1404

1405 /*

1406 * Returns -EACCES if GSS context is NULL or will expire within the

1407 * timeout (miliseconds)

1408 */

1409 static int

1410 gss_key_timeout(struct rpc_cred *rc)

1411 {

1412 struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base);

1413 struct gss_cl_ctx *ctx;

1414 unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ);

1415 int ret = 0;

1416

1417 rcu_read_lock();

1418 ctx = rcu_dereference(gss_cred->gc_ctx);

1419 if (!ctx || time_after(timeout, ctx->gc_expiry))

1420 ret = -EACCES;

1421 rcu_read_unlock();

1422

1423 return ret;

1424 }

1425

1426 static int

1427 gss_match(struct auth_cred *acred, struct rpc_cred *rc, int flags)

1428 {

1429 struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base);

1430 struct gss_cl_ctx *ctx;

1431 int ret;

1432

1433 if (test_bit(RPCAUTH_CRED_NEW, &rc->cr_flags))

1434 goto out;

1435 /* Don't match with creds that have expired. */

1436 rcu_read_lock();

1437 ctx = rcu_dereference(gss_cred->gc_ctx);

1438 if (!ctx || time_after(jiffies, ctx->gc_expiry)) {

1439 rcu_read_unlock();

1440 return 0;

1441 }

1442 rcu_read_unlock();

1443 if (!test_bit(RPCAUTH_CRED_UPTODATE, &rc->cr_flags))

1444 return 0;

1445 out:

1446 if (acred->principal != NULL) {

1447 if (gss_cred->gc_principal == NULL)

1448 return 0;

1449 ret = strcmp(acred->principal, gss_cred->gc_principal) == 0;

1450 goto check_expire;

1451 }

1452 if (gss_cred->gc_principal != NULL)

1453 return 0;

1454 ret = uid_eq(rc->cr_uid, acred->uid);

1455

1456 check_expire:

1457 if (ret == 0)

1458 return ret;

1459

1460 /* Notify acred users of GSS context expiration timeout */

1461 if (test_bit(RPC_CRED_NOTIFY_TIMEOUT, &acred->ac_flags) &&

1462 (gss_key_timeout(rc) != 0)) {

1463 /* test will now be done from generic cred */

1464 test_and_clear_bit(RPC_CRED_NOTIFY_TIMEOUT, &acred->ac_flags);

1465 /* tell NFS layer that key will expire soon */

1466 set_bit(RPC_CRED_KEY_EXPIRE_SOON, &acred->ac_flags);

1467 }

1468 return ret;

1469 }

1470

1471 /*

1472 * Marshal credentials.

1473 * Maybe we should keep a cached credential for performance reasons.

1474 */

1475 static __be32 *

1476 gss_marshal(struct rpc_task *task, __be32 *p)

1477 {

1478 struct rpc_rqst *req = task->tk_rqstp;

1479 struct rpc_cred *cred = req->rq_cred;

1480 struct gss_cred *gss_cred = container_of(cred, struct gss_cred,

1481 gc_base);

1482 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);

1483 __be32 *cred_len;

1484 u32 maj_stat = 0;

1485 struct xdr_netobj mic;

1486 struct kvec iov;

1487 struct xdr_buf verf_buf;

1488

1489 dprintk("RPC: %5u %s\n", task->tk_pid, __func__);

1490

1491 *p++ = htonl(RPC_AUTH_GSS);

1492 cred_len = p++;

1493

1494 spin_lock(&ctx->gc_seq_lock);

1495 req->rq_seqno = ctx->gc_seq++;

1496 spin_unlock(&ctx->gc_seq_lock);

1497

1498 *p++ = htonl((u32) RPC_GSS_VERSION);

1499 *p++ = htonl((u32) ctx->gc_proc);

1500 *p++ = htonl((u32) req->rq_seqno);

1501 *p++ = htonl((u32) gss_cred->gc_service);

1502 p = xdr_encode_netobj(p, &ctx->gc_wire_ctx);

1503 *cred_len = htonl((p - (cred_len + 1)) << 2);

1504

1505 /* We compute the checksum for the verifier over the xdr-encoded bytes

1506 * starting with the xid and ending at the end of the credential: */

1507 iov.iov_base = xprt_skip_transport_header(req->rq_xprt,

1508 req->rq_snd_buf.head[0].iov_base);

1509 iov.iov_len = (u8 *)p - (u8 *)iov.iov_base;

1510 xdr_buf_from_iov(&iov, &verf_buf);

1511

1512 /* set verifier flavor*/

1513 *p++ = htonl(RPC_AUTH_GSS);

1514

1515 mic.data = (u8 *)(p + 1);

1516 maj_stat = gss_get_mic(ctx->gc_gss_ctx, &verf_buf, &mic);

1517 if (maj_stat == GSS_S_CONTEXT_EXPIRED) {

1518 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);

1519 } else if (maj_stat != 0) {

1520 printk("gss_marshal: gss_get_mic FAILED (%d)\n", maj_stat);

1521 goto out_put_ctx;

1522 }

1523 p = xdr_encode_opaque(p, NULL, mic.len);

1524 gss_put_ctx(ctx);

1525 return p;

1526 out_put_ctx:

1527 gss_put_ctx(ctx);

1528 return NULL;

1529 }

1530

1531 static int gss_renew_cred(struct rpc_task *task)

1532 {

1533 struct rpc_cred *oldcred = task->tk_rqstp->rq_cred;

1534 struct gss_cred *gss_cred = container_of(oldcred,

1535 struct gss_cred,

1536 gc_base);

1537 struct rpc_auth *auth = oldcred->cr_auth;

1538 struct auth_cred acred = {

1539 .uid = oldcred->cr_uid,

1540 .principal = gss_cred->gc_principal,

1541 .machine_cred = (gss_cred->gc_principal != NULL ? 1 : 0),

1542 };

1543 struct rpc_cred *new;

1544

1545 new = gss_lookup_cred(auth, &acred, RPCAUTH_LOOKUP_NEW);

1546 if (IS_ERR(new))

1547 return PTR_ERR(new);

1548 task->tk_rqstp->rq_cred = new;

1549 put_rpccred(oldcred);

1550 return 0;

1551 }

1552

1553 static int gss_cred_is_negative_entry(struct rpc_cred *cred)

1554 {

1555 if (test_bit(RPCAUTH_CRED_NEGATIVE, &cred->cr_flags)) {

1556 unsigned long now = jiffies;

1557 unsigned long begin, expire;

1558 struct gss_cred *gss_cred;

1559

1560 gss_cred = container_of(cred, struct gss_cred, gc_base);

1561 begin = gss_cred->gc_upcall_timestamp;

1562 expire = begin + gss_expired_cred_retry_delay * HZ;

1563

1564 if (time_in_range_open(now, begin, expire))

1565 return 1;

1566 }

1567 return 0;

1568 }

1569

1570 /*

1571 * Refresh credentials. XXX - finish

1572 */

1573 static int

1574 gss_refresh(struct rpc_task *task)

1575 {

1576 struct rpc_cred *cred = task->tk_rqstp->rq_cred;

1577 int ret = 0;

1578

1579 if (gss_cred_is_negative_entry(cred))

1580 return -EKEYEXPIRED;

1581

1582 if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&

1583 !test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags)) {

1584 ret = gss_renew_cred(task);

1585 if (ret < 0)

1586 goto out;

1587 cred = task->tk_rqstp->rq_cred;

1588 }

1589

1590 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags))

1591 ret = gss_refresh_upcall(task);

1592 out:

1593 return ret;

1594 }

1595

1596 /* Dummy refresh routine: used only when destroying the context */

1597 static int

1598 gss_refresh_null(struct rpc_task *task)

1599 {

1600 return 0;

1601 }

1602

1603 static __be32 *

1604 gss_validate(struct rpc_task *task, __be32 *p)

1605 {

1606 struct rpc_cred *cred = task->tk_rqstp->rq_cred;

1607 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);

1608 __be32 seq;

1609 struct kvec iov;

1610 struct xdr_buf verf_buf;

1611 struct xdr_netobj mic;

1612 u32 flav,len;

1613 u32 maj_stat;

1614 __be32 *ret = ERR_PTR(-EIO);

1615

1616 dprintk("RPC: %5u %s\n", task->tk_pid, __func__);

1617

1618 flav = ntohl(*p++);

1619 if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE)

1620 goto out_bad;

1621 if (flav != RPC_AUTH_GSS)

1622 goto out_bad;

1623 seq = htonl(task->tk_rqstp->rq_seqno);

1624 iov.iov_base = &seq;

1625 iov.iov_len = sizeof(seq);

1626 xdr_buf_from_iov(&iov, &verf_buf);

1627 mic.data = (u8 *)p;

1628 mic.len = len;

1629

1630 ret = ERR_PTR(-EACCES);

1631 maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &verf_buf, &mic);

1632 if (maj_stat == GSS_S_CONTEXT_EXPIRED)

1633 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);

1634 if (maj_stat) {

1635 dprintk("RPC: %5u %s: gss_verify_mic returned error 0x%08x\n",

1636 task->tk_pid, __func__, maj_stat);

1637 goto out_bad;

1638 }

1639 /* We leave it to unwrap to calculate au_rslack. For now we just

1640 * calculate the length of the verifier: */

1641 cred->cr_auth->au_verfsize = XDR_QUADLEN(len) + 2;

1642 gss_put_ctx(ctx);

1643 dprintk("RPC: %5u %s: gss_verify_mic succeeded.\n",

1644 task->tk_pid, __func__);

1645 return p + XDR_QUADLEN(len);

1646 out_bad:

1647 gss_put_ctx(ctx);

1648 dprintk("RPC: %5u %s failed ret %ld.\n", task->tk_pid, __func__,

1649 PTR_ERR(ret));

1650 return ret;

1651 }

1652

1653 static void gss_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp,

1654 __be32 *p, void *obj)

1655 {

1656 struct xdr_stream xdr;

1657

1658 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, p);

1659 encode(rqstp, &xdr, obj);

1660 }

1661

1662 static inline int

1663 gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,

1664 kxdreproc_t encode, struct rpc_rqst *rqstp,

1665 __be32 *p, void *obj)

1666 {

1667 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;

1668 struct xdr_buf integ_buf;

1669 __be32 *integ_len = NULL;

1670 struct xdr_netobj mic;

1671 u32 offset;

1672 __be32 *q;

1673 struct kvec *iov;

1674 u32 maj_stat = 0;

1675 int status = -EIO;

1676

1677 integ_len = p++;

1678 offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;

1679 *p++ = htonl(rqstp->rq_seqno);

1680

1681 gss_wrap_req_encode(encode, rqstp, p, obj);

1682

1683 if (xdr_buf_subsegment(snd_buf, &integ_buf,

1684 offset, snd_buf->len - offset))

1685 return status;

1686 *integ_len = htonl(integ_buf.len);

1687

1688 /* guess whether we're in the head or the tail: */

1689 if (snd_buf->page_len || snd_buf->tail[0].iov_len)

1690 iov = snd_buf->tail;

1691 else

1692 iov = snd_buf->head;

1693 p = iov->iov_base + iov->iov_len;

1694 mic.data = (u8 *)(p + 1);

1695

1696 maj_stat = gss_get_mic(ctx->gc_gss_ctx, &integ_buf, &mic);

1697 status = -EIO; /* XXX? */

1698 if (maj_stat == GSS_S_CONTEXT_EXPIRED)

1699 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);

1700 else if (maj_stat)

1701 return status;

1702 q = xdr_encode_opaque(p, NULL, mic.len);

1703

1704 offset = (u8 *)q - (u8 *)p;

1705 iov->iov_len += offset;

1706 snd_buf->len += offset;

1707 return 0;

1708 }

1709

1710 static void

1711 priv_release_snd_buf(struct rpc_rqst *rqstp)

1712 {

1713 int i;

1714

1715 for (i=0; i < rqstp->rq_enc_pages_num; i++)

1716 __free_page(rqstp->rq_enc_pages[i]);

1717 kfree(rqstp->rq_enc_pages);

1718 }

1719

1720 static int

1721 alloc_enc_pages(struct rpc_rqst *rqstp)

1722 {

1723 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;

1724 int first, last, i;

1725

1726 if (snd_buf->page_len == 0) {

1727 rqstp->rq_enc_pages_num = 0;

1728 return 0;

1729 }

1730

1731 first = snd_buf->page_base >> PAGE_CACHE_SHIFT;

1732 last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_CACHE_SHIFT;

1733 rqstp->rq_enc_pages_num = last - first + 1 + 1;

1734 rqstp->rq_enc_pages

1735 = kmalloc(rqstp->rq_enc_pages_num * sizeof(struct page *),

1736 GFP_NOFS);

1737 if (!rqstp->rq_enc_pages)

1738 goto out;

1739 for (i=0; i < rqstp->rq_enc_pages_num; i++) {

1740 rqstp->rq_enc_pages[i] = alloc_page(GFP_NOFS);

1741 if (rqstp->rq_enc_pages[i] == NULL)

1742 goto out_free;

1743 }

1744 rqstp->rq_release_snd_buf = priv_release_snd_buf;

1745 return 0;

1746 out_free:

1747 rqstp->rq_enc_pages_num = i;

1748 priv_release_snd_buf(rqstp);

1749 out:

1750 return -EAGAIN;

1751 }

1752

1753 static inline int

1754 gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,

1755 kxdreproc_t encode, struct rpc_rqst *rqstp,

1756 __be32 *p, void *obj)

1757 {

1758 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;

1759 u32 offset;

1760 u32 maj_stat;

1761 int status;

1762 __be32 *opaque_len;

1763 struct page **inpages;

1764 int first;

1765 int pad;

1766 struct kvec *iov;

1767 char *tmp;

1768

1769 opaque_len = p++;

1770 offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;

1771 *p++ = htonl(rqstp->rq_seqno);

1772

1773 gss_wrap_req_encode(encode, rqstp, p, obj);

1774

1775 status = alloc_enc_pages(rqstp);

1776 if (status)

1777 return status;

1778 first = snd_buf->page_base >> PAGE_CACHE_SHIFT;

1779 inpages = snd_buf->pages + first;

1780 snd_buf->pages = rqstp->rq_enc_pages;

1781 snd_buf->page_base -= first << PAGE_CACHE_SHIFT;

1782 /*

1783 * Give the tail its own page, in case we need extra space in the

1784 * head when wrapping:

1785 *

1786 * call_allocate() allocates twice the slack space required

1787 * by the authentication flavor to rq_callsize.

1788 * For GSS, slack is GSS_CRED_SLACK.

1789 */

1790 if (snd_buf->page_len || snd_buf->tail[0].iov_len) {

1791 tmp = page_address(rqstp->rq_enc_pages[rqstp->rq_enc_pages_num - 1]);

1792 memcpy(tmp, snd_buf->tail[0].iov_base, snd_buf->tail[0].iov_len);

1793 snd_buf->tail[0].iov_base = tmp;

1794 }

1795 maj_stat = gss_wrap(ctx->gc_gss_ctx, offset, snd_buf, inpages);

1796 /* slack space should prevent this ever happening: */

1797 BUG_ON(snd_buf->len > snd_buf->buflen);

1798 status = -EIO;

1799 /* We're assuming that when GSS_S_CONTEXT_EXPIRED, the encryption was

1800 * done anyway, so it's safe to put the request on the wire: */

1801 if (maj_stat == GSS_S_CONTEXT_EXPIRED)

1802 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);

1803 else if (maj_stat)

1804 return status;

1805

1806 *opaque_len = htonl(snd_buf->len - offset);

1807 /* guess whether we're in the head or the tail: */

1808 if (snd_buf->page_len || snd_buf->tail[0].iov_len)

1809 iov = snd_buf->tail;

1810 else

1811 iov = snd_buf->head;

1812 p = iov->iov_base + iov->iov_len;

1813 pad = 3 - ((snd_buf->len - offset - 1) & 3);

1814 memset(p, 0, pad);

1815 iov->iov_len += pad;

1816 snd_buf->len += pad;

1817

1818 return 0;

1819 }

1820

1821 static int

1822 gss_wrap_req(struct rpc_task *task,

1823 kxdreproc_t encode, void *rqstp, __be32 *p, void *obj)

1824 {

1825 struct rpc_cred *cred = task->tk_rqstp->rq_cred;

1826 struct gss_cred *gss_cred = container_of(cred, struct gss_cred,

1827 gc_base);

1828 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);

1829 int status = -EIO;

1830

1831 dprintk("RPC: %5u %s\n", task->tk_pid, __func__);

1832 if (ctx->gc_proc != RPC_GSS_PROC_DATA) {

1833 /* The spec seems a little ambiguous here, but I think that not

1834 * wrapping context destruction requests makes the most sense.

1835 */

1836 gss_wrap_req_encode(encode, rqstp, p, obj);

1837 status = 0;

1838 goto out;

1839 }

1840 switch (gss_cred->gc_service) {

1841 case RPC_GSS_SVC_NONE:

1842 gss_wrap_req_encode(encode, rqstp, p, obj);

1843 status = 0;

1844 break;

1845 case RPC_GSS_SVC_INTEGRITY:

1846 status = gss_wrap_req_integ(cred, ctx, encode, rqstp, p, obj);

1847 break;

1848 case RPC_GSS_SVC_PRIVACY:

1849 status = gss_wrap_req_priv(cred, ctx, encode, rqstp, p, obj);

1850 break;

1851 }

1852 out:

1853 gss_put_ctx(ctx);

1854 dprintk("RPC: %5u %s returning %d\n", task->tk_pid, __func__, status);

1855 return status;

1856 }

1857

1858 static inline int

1859 gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,

1860 struct rpc_rqst *rqstp, __be32 **p)

1861 {

1862 struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;

1863 struct xdr_buf integ_buf;

1864 struct xdr_netobj mic;

1865 u32 data_offset, mic_offset;

1866 u32 integ_len;

1867 u32 maj_stat;

1868 int status = -EIO;

1869

1870 integ_len = ntohl(*(*p)++);

1871 if (integ_len & 3)

1872 return status;

1873 data_offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;

1874 mic_offset = integ_len + data_offset;

1875 if (mic_offset > rcv_buf->len)

1876 return status;

1877 if (ntohl(*(*p)++) != rqstp->rq_seqno)

1878 return status;

1879

1880 if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset,

1881 mic_offset - data_offset))

1882 return status;

1883

1884 if (xdr_buf_read_netobj(rcv_buf, &mic, mic_offset))

1885 return status;

1886

1887 maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &integ_buf, &mic);

1888 if (maj_stat == GSS_S_CONTEXT_EXPIRED)

1889 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);

1890 if (maj_stat != GSS_S_COMPLETE)

1891 return status;

1892 return 0;

1893 }

1894

1895 static inline int

1896 gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,

1897 struct rpc_rqst *rqstp, __be32 **p)

1898 {

1899 struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;

1900 u32 offset;

1901 u32 opaque_len;

1902 u32 maj_stat;

1903 int status = -EIO;

1904

1905 opaque_len = ntohl(*(*p)++);

1906 offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;

1907 if (offset + opaque_len > rcv_buf->len)

1908 return status;

1909 /* remove padding: */

1910 rcv_buf->len = offset + opaque_len;

1911

1912 maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, rcv_buf);

1913 if (maj_stat == GSS_S_CONTEXT_EXPIRED)

1914 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);

1915 if (maj_stat != GSS_S_COMPLETE)

1916 return status;

1917 if (ntohl(*(*p)++) != rqstp->rq_seqno)

1918 return status;

1919

1920 return 0;

1921 }

1922

1923 static int

1924 gss_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp,

1925 __be32 *p, void *obj)

1926 {

1927 struct xdr_stream xdr;

1928

1929 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);

1930 return decode(rqstp, &xdr, obj);

1931 }

1932

1933 static int

1934 gss_unwrap_resp(struct rpc_task *task,

1935 kxdrdproc_t decode, void *rqstp, __be32 *p, void *obj)

1936 {

1937 struct rpc_cred *cred = task->tk_rqstp->rq_cred;

1938 struct gss_cred *gss_cred = container_of(cred, struct gss_cred,

1939 gc_base);

1940 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);

1941 __be32 *savedp = p;

1942 struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head;

1943 int savedlen = head->iov_len;

1944 int status = -EIO;

1945

1946 if (ctx->gc_proc != RPC_GSS_PROC_DATA)

1947 goto out_decode;

1948 switch (gss_cred->gc_service) {

1949 case RPC_GSS_SVC_NONE:

1950 break;

1951 case RPC_GSS_SVC_INTEGRITY:

1952 status = gss_unwrap_resp_integ(cred, ctx, rqstp, &p);

1953 if (status)

1954 goto out;

1955 break;

1956 case RPC_GSS_SVC_PRIVACY:

1957 status = gss_unwrap_resp_priv(cred, ctx, rqstp, &p);

1958 if (status)

1959 goto out;

1960 break;

1961 }

1962 /* take into account extra slack for integrity and privacy cases: */

1963 cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + (p - savedp)

1964 + (savedlen - head->iov_len);

1965 out_decode:

1966 status = gss_unwrap_req_decode(decode, rqstp, p, obj);

1967 out:

1968 gss_put_ctx(ctx);

1969 dprintk("RPC: %5u %s returning %d\n",

1970 task->tk_pid, __func__, status);

1971 return status;

1972 }

1973

1974 static const struct rpc_authops authgss_ops = {

1975 .owner = THIS_MODULE,

1976 .au_flavor = RPC_AUTH_GSS,

1977 .au_name = "RPCSEC_GSS",

1978 .create = gss_create,

1979 .destroy = gss_destroy,

1980 .lookup_cred = gss_lookup_cred,

1981 .crcreate = gss_create_cred,

1982 .list_pseudoflavors = gss_mech_list_pseudoflavors,

1983 .info2flavor = gss_mech_info2flavor,

1984 .flavor2info = gss_mech_flavor2info,

1985 };

1986

1987 static const struct rpc_credops gss_credops = {

1988 .cr_name = "AUTH_GSS",

1989 .crdestroy = gss_destroy_cred,

1990 .cr_init = gss_cred_init,

1991 .crbind = rpcauth_generic_bind_cred,

1992 .crmatch = gss_match,

1993 .crmarshal = gss_marshal,

1994 .crrefresh = gss_refresh,

1995 .crvalidate = gss_validate,

1996 .crwrap_req = gss_wrap_req,

1997 .crunwrap_resp = gss_unwrap_resp,

1998 .crkey_timeout = gss_key_timeout,

1999 .crstringify_acceptor = gss_stringify_acceptor,

2000 };

2001

2002 static const struct rpc_credops gss_nullops = {

2003 .cr_name = "AUTH_GSS",

2004 .crdestroy = gss_destroy_nullcred,

2005 .crbind = rpcauth_generic_bind_cred,

2006 .crmatch = gss_match,

2007 .crmarshal = gss_marshal,

2008 .crrefresh = gss_refresh_null,

2009 .crvalidate = gss_validate,

2010 .crwrap_req = gss_wrap_req,

2011 .crunwrap_resp = gss_unwrap_resp,

2012 .crstringify_acceptor = gss_stringify_acceptor,

2013 };

2014

2015 static const struct rpc_pipe_ops gss_upcall_ops_v0 = {

2016 .upcall = rpc_pipe_generic_upcall,

2017 .downcall = gss_pipe_downcall,

2018 .destroy_msg = gss_pipe_destroy_msg,

2019 .open_pipe = gss_pipe_open_v0,

2020 .release_pipe = gss_pipe_release,

2021 };

2022

2023 static const struct rpc_pipe_ops gss_upcall_ops_v1 = {

2024 .upcall = rpc_pipe_generic_upcall,

2025 .downcall = gss_pipe_downcall,

2026 .destroy_msg = gss_pipe_destroy_msg,

2027 .open_pipe = gss_pipe_open_v1,

2028 .release_pipe = gss_pipe_release,

2029 };

2030

2031 static __net_init int rpcsec_gss_init_net(struct net *net)

2032 {

2033 return gss_svc_init_net(net);

2034 }

2035

2036 static __net_exit void rpcsec_gss_exit_net(struct net *net)

2037 {

2038 gss_svc_shutdown_net(net);

2039 }

2040

2041 static struct pernet_operations rpcsec_gss_net_ops = {

2042 .init = rpcsec_gss_init_net,

2043 .exit = rpcsec_gss_exit_net,

2044 };

2045

2046 /*

2047 * Initialize RPCSEC_GSS module

2048 */

2049 static int __init init_rpcsec_gss(void)

2050 {

2051 int err = 0;

2052

2053 err = rpcauth_register(&authgss_ops);

2054 if (err)

2055 goto out;

2056 err = gss_svc_init();

2057 if (err)

2058 goto out_unregister;

2059 err = register_pernet_subsys(&rpcsec_gss_net_ops);

2060 if (err)

2061 goto out_svc_exit;

2062 rpc_init_wait_queue(&pipe_version_rpc_waitqueue, "gss pipe version");

2063 return 0;

2064 out_svc_exit:

2065 gss_svc_shutdown();

2066 out_unregister:

2067 rpcauth_unregister(&authgss_ops);

2068 out:

2069 return err;

2070 }

2071

2072 static void __exit exit_rpcsec_gss(void)

2073 {

2074 unregister_pernet_subsys(&rpcsec_gss_net_ops);

2075 gss_svc_shutdown();

2076 rpcauth_unregister(&authgss_ops);

2077 rcu_barrier(); /* Wait for completion of call_rcu()'s */

2078 }

2079

2080 MODULE_ALIAS("rpc-auth-6");

2081 MODULE_LICENSE("GPL");

2082 module_param_named(expired_cred_retry_delay,

2083 gss_expired_cred_retry_delay,

2084 uint, 0644);

2085 MODULE_PARM_DESC(expired_cred_retry_delay, "Timeout (in seconds) until "

2086 "the RPC engine retries an expired credential");

2087

2088 module_param_named(key_expire_timeo,

2089 gss_key_expire_timeo,

2090 uint, 0644);

2091 MODULE_PARM_DESC(key_expire_timeo, "Time (in seconds) at the end of a "

2092 "credential keys lifetime where the NFS layer cleans up "

2093 "prior to key expiration");

2094

2095 module_init(init_rpcsec_gss)

2096 module_exit(exit_rpcsec_gss)