1 /* 2 * XDR support for nfsd 3 * 4 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> 5 */ 6 7 #include "xdr.h" 8 #include "auth.h" 9 10 #define NFSDDBG_FACILITY NFSDDBG_XDR 11 12 /* 13 * Mapping of S_IF* types to NFS file types 14 */ 15 static u32 nfs_ftypes[] = { 16 NFNON, NFCHR, NFCHR, NFBAD, 17 NFDIR, NFBAD, NFBLK, NFBAD, 18 NFREG, NFBAD, NFLNK, NFBAD, 19 NFSOCK, NFBAD, NFLNK, NFBAD, 20 }; 21 22 23 /* 24 * XDR functions for basic NFS types 25 */ 26 static __be32 * 27 decode_fh(__be32 *p, struct svc_fh *fhp) 28 { 29 fh_init(fhp, NFS_FHSIZE); 30 memcpy(&fhp->fh_handle.fh_base, p, NFS_FHSIZE); 31 fhp->fh_handle.fh_size = NFS_FHSIZE; 32 33 /* FIXME: Look up export pointer here and verify 34 * Sun Secure RPC if requested */ 35 return p + (NFS_FHSIZE >> 2); 36 } 37 38 /* Helper function for NFSv2 ACL code */ 39 __be32 *nfs2svc_decode_fh(__be32 *p, struct svc_fh *fhp) 40 { 41 return decode_fh(p, fhp); 42 } 43 44 static __be32 * 45 encode_fh(__be32 *p, struct svc_fh *fhp) 46 { 47 memcpy(p, &fhp->fh_handle.fh_base, NFS_FHSIZE); 48 return p + (NFS_FHSIZE>> 2); 49 } 50 51 /* 52 * Decode a file name and make sure that the path contains 53 * no slashes or null bytes. 54 */ 55 static __be32 * 56 decode_filename(__be32 *p, char **namp, unsigned int *lenp) 57 { 58 char *name; 59 unsigned int i; 60 61 if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS_MAXNAMLEN)) != NULL) { 62 for (i = 0, name = *namp; i < *lenp; i++, name++) { 63 if (*name == '\0' || *name == '/') 64 return NULL; 65 } 66 } 67 68 return p; 69 } 70 71 static __be32 * 72 decode_pathname(__be32 *p, char **namp, unsigned int *lenp) 73 { 74 char *name; 75 unsigned int i; 76 77 if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS_MAXPATHLEN)) != NULL) { 78 for (i = 0, name = *namp; i < *lenp; i++, name++) { 79 if (*name == '\0') 80 return NULL; 81 } 82 } 83 84 return p; 85 } 86 87 static __be32 * 88 decode_sattr(__be32 *p, struct iattr *iap) 89 { 90 u32 tmp, tmp1; 91 92 iap->ia_valid = 0; 93 94 /* Sun client bug compatibility check: some sun clients seem to 95 * put 0xffff in the mode field when they mean 0xffffffff. 96 * Quoting the 4.4BSD nfs server code: Nah nah nah nah na nah. 97 */ 98 if ((tmp = ntohl(*p++)) != (u32)-1 && tmp != 0xffff) { 99 iap->ia_valid |= ATTR_MODE; 100 iap->ia_mode = tmp; 101 } 102 if ((tmp = ntohl(*p++)) != (u32)-1) { 103 iap->ia_valid |= ATTR_UID; 104 iap->ia_uid = tmp; 105 } 106 if ((tmp = ntohl(*p++)) != (u32)-1) { 107 iap->ia_valid |= ATTR_GID; 108 iap->ia_gid = tmp; 109 } 110 if ((tmp = ntohl(*p++)) != (u32)-1) { 111 iap->ia_valid |= ATTR_SIZE; 112 iap->ia_size = tmp; 113 } 114 tmp = ntohl(*p++); tmp1 = ntohl(*p++); 115 if (tmp != (u32)-1 && tmp1 != (u32)-1) { 116 iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET; 117 iap->ia_atime.tv_sec = tmp; 118 iap->ia_atime.tv_nsec = tmp1 * 1000; 119 } 120 tmp = ntohl(*p++); tmp1 = ntohl(*p++); 121 if (tmp != (u32)-1 && tmp1 != (u32)-1) { 122 iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET; 123 iap->ia_mtime.tv_sec = tmp; 124 iap->ia_mtime.tv_nsec = tmp1 * 1000; 125 /* 126 * Passing the invalid value useconds=1000000 for mtime 127 * is a Sun convention for "set both mtime and atime to 128 * current server time". It's needed to make permissions 129 * checks for the "touch" program across v2 mounts to 130 * Solaris and Irix boxes work correctly. See description of 131 * sattr in section 6.1 of "NFS Illustrated" by 132 * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5 133 */ 134 if (tmp1 == 1000000) 135 iap->ia_valid &= ~(ATTR_ATIME_SET|ATTR_MTIME_SET); 136 } 137 return p; 138 } 139 140 static __be32 * 141 encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, 142 struct kstat *stat) 143 { 144 struct dentry *dentry = fhp->fh_dentry; 145 int type; 146 struct timespec time; 147 u32 f; 148 149 type = (stat->mode & S_IFMT); 150 151 *p++ = htonl(nfs_ftypes[type >> 12]); 152 *p++ = htonl((u32) stat->mode); 153 *p++ = htonl((u32) stat->nlink); 154 *p++ = htonl((u32) nfsd_ruid(rqstp, stat->uid)); 155 *p++ = htonl((u32) nfsd_rgid(rqstp, stat->gid)); 156 157 if (S_ISLNK(type) && stat->size > NFS_MAXPATHLEN) { 158 *p++ = htonl(NFS_MAXPATHLEN); 159 } else { 160 *p++ = htonl((u32) stat->size); 161 } 162 *p++ = htonl((u32) stat->blksize); 163 if (S_ISCHR(type) || S_ISBLK(type)) 164 *p++ = htonl(new_encode_dev(stat->rdev)); 165 else 166 *p++ = htonl(0xffffffff); 167 *p++ = htonl((u32) stat->blocks); 168 switch (fsid_source(fhp)) { 169 default: 170 case FSIDSOURCE_DEV: 171 *p++ = htonl(new_encode_dev(stat->dev)); 172 break; 173 case FSIDSOURCE_FSID: 174 *p++ = htonl((u32) fhp->fh_export->ex_fsid); 175 break; 176 case FSIDSOURCE_UUID: 177 f = ((u32*)fhp->fh_export->ex_uuid)[0]; 178 f ^= ((u32*)fhp->fh_export->ex_uuid)[1]; 179 f ^= ((u32*)fhp->fh_export->ex_uuid)[2]; 180 f ^= ((u32*)fhp->fh_export->ex_uuid)[3]; 181 *p++ = htonl(f); 182 break; 183 } 184 *p++ = htonl((u32) stat->ino); 185 *p++ = htonl((u32) stat->atime.tv_sec); 186 *p++ = htonl(stat->atime.tv_nsec ? stat->atime.tv_nsec / 1000 : 0); 187 lease_get_mtime(dentry->d_inode, &time); 188 *p++ = htonl((u32) time.tv_sec); 189 *p++ = htonl(time.tv_nsec ? time.tv_nsec / 1000 : 0); 190 *p++ = htonl((u32) stat->ctime.tv_sec); 191 *p++ = htonl(stat->ctime.tv_nsec ? stat->ctime.tv_nsec / 1000 : 0); 192 193 return p; 194 } 195 196 /* Helper function for NFSv2 ACL code */ 197 __be32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 198 { 199 struct kstat stat; 200 vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry, &stat); 201 return encode_fattr(rqstp, p, fhp, &stat); 202 } 203 204 /* 205 * XDR decode functions 206 */ 207 int 208 nfssvc_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy) 209 { 210 return xdr_argsize_check(rqstp, p); 211 } 212 213 int 214 nfssvc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args) 215 { 216 if (!(p = decode_fh(p, &args->fh))) 217 return 0; 218 return xdr_argsize_check(rqstp, p); 219 } 220 221 int 222 nfssvc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p, 223 struct nfsd_sattrargs *args) 224 { 225 p = decode_fh(p, &args->fh); 226 if (!p) 227 return 0; 228 p = decode_sattr(p, &args->attrs); 229 230 return xdr_argsize_check(rqstp, p); 231 } 232 233 int 234 nfssvc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p, 235 struct nfsd_diropargs *args) 236 { 237 if (!(p = decode_fh(p, &args->fh)) 238 || !(p = decode_filename(p, &args->name, &args->len))) 239 return 0; 240 241 return xdr_argsize_check(rqstp, p); 242 } 243 244 int 245 nfssvc_decode_readargs(struct svc_rqst *rqstp, __be32 *p, 246 struct nfsd_readargs *args) 247 { 248 unsigned int len; 249 int v; 250 if (!(p = decode_fh(p, &args->fh))) 251 return 0; 252 253 args->offset = ntohl(*p++); 254 len = args->count = ntohl(*p++); 255 p++; /* totalcount - unused */ 256 257 if (len > NFSSVC_MAXBLKSIZE_V2) 258 len = NFSSVC_MAXBLKSIZE_V2; 259 260 /* set up somewhere to store response. 261 * We take pages, put them on reslist and include in iovec 262 */ 263 v=0; 264 while (len > 0) { 265 struct page *p = *(rqstp->rq_next_page++); 266 267 rqstp->rq_vec[v].iov_base = page_address(p); 268 rqstp->rq_vec[v].iov_len = len < PAGE_SIZE?len:PAGE_SIZE; 269 len -= rqstp->rq_vec[v].iov_len; 270 v++; 271 } 272 args->vlen = v; 273 return xdr_argsize_check(rqstp, p); 274 } 275 276 int 277 nfssvc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p, 278 struct nfsd_writeargs *args) 279 { 280 unsigned int len, hdr, dlen; 281 int v; 282 283 if (!(p = decode_fh(p, &args->fh))) 284 return 0; 285 286 p++; /* beginoffset */ 287 args->offset = ntohl(*p++); /* offset */ 288 p++; /* totalcount */ 289 len = args->len = ntohl(*p++); 290 /* 291 * The protocol specifies a maximum of 8192 bytes. 292 */ 293 if (len > NFSSVC_MAXBLKSIZE_V2) 294 return 0; 295 296 /* 297 * Check to make sure that we got the right number of 298 * bytes. 299 */ 300 hdr = (void*)p - rqstp->rq_arg.head[0].iov_base; 301 dlen = rqstp->rq_arg.head[0].iov_len + rqstp->rq_arg.page_len 302 - hdr; 303 304 /* 305 * Round the length of the data which was specified up to 306 * the next multiple of XDR units and then compare that 307 * against the length which was actually received. 308 * Note that when RPCSEC/GSS (for example) is used, the 309 * data buffer can be padded so dlen might be larger 310 * than required. It must never be smaller. 311 */ 312 if (dlen < XDR_QUADLEN(len)*4) 313 return 0; 314 315 rqstp->rq_vec[0].iov_base = (void*)p; 316 rqstp->rq_vec[0].iov_len = rqstp->rq_arg.head[0].iov_len - hdr; 317 v = 0; 318 while (len > rqstp->rq_vec[v].iov_len) { 319 len -= rqstp->rq_vec[v].iov_len; 320 v++; 321 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]); 322 rqstp->rq_vec[v].iov_len = PAGE_SIZE; 323 } 324 rqstp->rq_vec[v].iov_len = len; 325 args->vlen = v + 1; 326 return 1; 327 } 328 329 int 330 nfssvc_decode_createargs(struct svc_rqst *rqstp, __be32 *p, 331 struct nfsd_createargs *args) 332 { 333 if ( !(p = decode_fh(p, &args->fh)) 334 || !(p = decode_filename(p, &args->name, &args->len))) 335 return 0; 336 p = decode_sattr(p, &args->attrs); 337 338 return xdr_argsize_check(rqstp, p); 339 } 340 341 int 342 nfssvc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p, 343 struct nfsd_renameargs *args) 344 { 345 if (!(p = decode_fh(p, &args->ffh)) 346 || !(p = decode_filename(p, &args->fname, &args->flen)) 347 || !(p = decode_fh(p, &args->tfh)) 348 || !(p = decode_filename(p, &args->tname, &args->tlen))) 349 return 0; 350 351 return xdr_argsize_check(rqstp, p); 352 } 353 354 int 355 nfssvc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd_readlinkargs *args) 356 { 357 if (!(p = decode_fh(p, &args->fh))) 358 return 0; 359 args->buffer = page_address(*(rqstp->rq_next_page++)); 360 361 return xdr_argsize_check(rqstp, p); 362 } 363 364 int 365 nfssvc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p, 366 struct nfsd_linkargs *args) 367 { 368 if (!(p = decode_fh(p, &args->ffh)) 369 || !(p = decode_fh(p, &args->tfh)) 370 || !(p = decode_filename(p, &args->tname, &args->tlen))) 371 return 0; 372 373 return xdr_argsize_check(rqstp, p); 374 } 375 376 int 377 nfssvc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p, 378 struct nfsd_symlinkargs *args) 379 { 380 if ( !(p = decode_fh(p, &args->ffh)) 381 || !(p = decode_filename(p, &args->fname, &args->flen)) 382 || !(p = decode_pathname(p, &args->tname, &args->tlen))) 383 return 0; 384 p = decode_sattr(p, &args->attrs); 385 386 return xdr_argsize_check(rqstp, p); 387 } 388 389 int 390 nfssvc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p, 391 struct nfsd_readdirargs *args) 392 { 393 if (!(p = decode_fh(p, &args->fh))) 394 return 0; 395 args->cookie = ntohl(*p++); 396 args->count = ntohl(*p++); 397 if (args->count > PAGE_SIZE) 398 args->count = PAGE_SIZE; 399 400 args->buffer = page_address(*(rqstp->rq_next_page++)); 401 402 return xdr_argsize_check(rqstp, p); 403 } 404 405 /* 406 * XDR encode functions 407 */ 408 int 409 nfssvc_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy) 410 { 411 return xdr_ressize_check(rqstp, p); 412 } 413 414 int 415 nfssvc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p, 416 struct nfsd_attrstat *resp) 417 { 418 p = encode_fattr(rqstp, p, &resp->fh, &resp->stat); 419 return xdr_ressize_check(rqstp, p); 420 } 421 422 int 423 nfssvc_encode_diropres(struct svc_rqst *rqstp, __be32 *p, 424 struct nfsd_diropres *resp) 425 { 426 p = encode_fh(p, &resp->fh); 427 p = encode_fattr(rqstp, p, &resp->fh, &resp->stat); 428 return xdr_ressize_check(rqstp, p); 429 } 430 431 int 432 nfssvc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p, 433 struct nfsd_readlinkres *resp) 434 { 435 *p++ = htonl(resp->len); 436 xdr_ressize_check(rqstp, p); 437 rqstp->rq_res.page_len = resp->len; 438 if (resp->len & 3) { 439 /* need to pad the tail */ 440 rqstp->rq_res.tail[0].iov_base = p; 441 *p = 0; 442 rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3); 443 } 444 return 1; 445 } 446 447 int 448 nfssvc_encode_readres(struct svc_rqst *rqstp, __be32 *p, 449 struct nfsd_readres *resp) 450 { 451 p = encode_fattr(rqstp, p, &resp->fh, &resp->stat); 452 *p++ = htonl(resp->count); 453 xdr_ressize_check(rqstp, p); 454 455 /* now update rqstp->rq_res to reflect data as well */ 456 rqstp->rq_res.page_len = resp->count; 457 if (resp->count & 3) { 458 /* need to pad the tail */ 459 rqstp->rq_res.tail[0].iov_base = p; 460 *p = 0; 461 rqstp->rq_res.tail[0].iov_len = 4 - (resp->count&3); 462 } 463 return 1; 464 } 465 466 int 467 nfssvc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p, 468 struct nfsd_readdirres *resp) 469 { 470 xdr_ressize_check(rqstp, p); 471 p = resp->buffer; 472 *p++ = 0; /* no more entries */ 473 *p++ = htonl((resp->common.err == nfserr_eof)); 474 rqstp->rq_res.page_len = (((unsigned long)p-1) & ~PAGE_MASK)+1; 475 476 return 1; 477 } 478 479 int 480 nfssvc_encode_statfsres(struct svc_rqst *rqstp, __be32 *p, 481 struct nfsd_statfsres *resp) 482 { 483 struct kstatfs *stat = &resp->stats; 484 485 *p++ = htonl(NFSSVC_MAXBLKSIZE_V2); /* max transfer size */ 486 *p++ = htonl(stat->f_bsize); 487 *p++ = htonl(stat->f_blocks); 488 *p++ = htonl(stat->f_bfree); 489 *p++ = htonl(stat->f_bavail); 490 return xdr_ressize_check(rqstp, p); 491 } 492 493 int 494 nfssvc_encode_entry(void *ccdv, const char *name, 495 int namlen, loff_t offset, u64 ino, unsigned int d_type) 496 { 497 struct readdir_cd *ccd = ccdv; 498 struct nfsd_readdirres *cd = container_of(ccd, struct nfsd_readdirres, common); 499 __be32 *p = cd->buffer; 500 int buflen, slen; 501 502 /* 503 dprintk("nfsd: entry(%.*s off %ld ino %ld)\n", 504 namlen, name, offset, ino); 505 */ 506 507 if (offset > ~((u32) 0)) { 508 cd->common.err = nfserr_fbig; 509 return -EINVAL; 510 } 511 if (cd->offset) 512 *cd->offset = htonl(offset); 513 if (namlen > NFS2_MAXNAMLEN) 514 namlen = NFS2_MAXNAMLEN;/* truncate filename */ 515 516 slen = XDR_QUADLEN(namlen); 517 if ((buflen = cd->buflen - slen - 4) < 0) { 518 cd->common.err = nfserr_toosmall; 519 return -EINVAL; 520 } 521 if (ino > ~((u32) 0)) { 522 cd->common.err = nfserr_fbig; 523 return -EINVAL; 524 } 525 *p++ = xdr_one; /* mark entry present */ 526 *p++ = htonl((u32) ino); /* file id */ 527 p = xdr_encode_array(p, name, namlen);/* name length & name */ 528 cd->offset = p; /* remember pointer */ 529 *p++ = htonl(~0U); /* offset of next entry */ 530 531 cd->buflen = buflen; 532 cd->buffer = p; 533 cd->common.err = nfs_ok; 534 return 0; 535 } 536 537 /* 538 * XDR release functions 539 */ 540 int 541 nfssvc_release_fhandle(struct svc_rqst *rqstp, __be32 *p, 542 struct nfsd_fhandle *resp) 543 { 544 fh_put(&resp->fh); 545 return 1; 546 } 547