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