History

SUNRPC: Use struct xdr_stream when decoding RPC Reply header

Modernize and harden the code path that parses an RPC Reply message.

Chuck Lever committed 7 years ago

Commit a0584ee1 parent 7f5667a7 files · +243 −201Browse files

Unified · Split

7 files
  1. include/linux/sunrpc/auth.h +10 −5
  2. include/linux/sunrpc/xdr.h +1 −0
  3. net/sunrpc/auth.c +41 −22
  4. net/sunrpc/auth_gss/auth_gss.c +110 −94
  5. net/sunrpc/auth_null.c +13 −18
  6. net/sunrpc/auth_unix.c +23 −19
  7. net/sunrpc/clnt.c +45 −43
include/linux/sunrpc/auth.h+10−5
@@ -134,11 +134,12 @@ struct rpc_credops { · 133 unmodified lines
134134 int (*crmarshal)(struct rpc_task *task,
135135 struct xdr_stream *xdr);
136136 int (*crrefresh)(struct rpc_task *);
137− __be32 * (*crvalidate)(struct rpc_task *, __be32 *);
137+ int (*crvalidate)(struct rpc_task *task,
138+ struct xdr_stream *xdr);
138139 int (*crwrap_req)(struct rpc_task *task,
139140 struct xdr_stream *xdr);
140− int (*crunwrap_resp)(struct rpc_task *, kxdrdproc_t,
141− void *, __be32 *, void *);
141+ int (*crunwrap_resp)(struct rpc_task *task,
142+ struct xdr_stream *xdr);
142143 int (*crkey_timeout)(struct rpc_cred *);
143144 char * (*crstringify_acceptor)(struct rpc_cred *);
144145 bool (*crneed_reencode)(struct rpc_task *);
@@ -168,12 +169,16 @@ struct rpc_cred * rpcauth_lookupcred(struct rpc_auth *, int); · 23 unmodified lines
168169 void put_rpccred(struct rpc_cred *);
169170 int rpcauth_marshcred(struct rpc_task *task,
170171 struct xdr_stream *xdr);
171−__be32 * rpcauth_checkverf(struct rpc_task *, __be32 *);
172+int rpcauth_checkverf(struct rpc_task *task,
173+ struct xdr_stream *xdr);
172174 int rpcauth_wrap_req_encode(struct rpc_task *task,
173175 struct xdr_stream *xdr);
174176 int rpcauth_wrap_req(struct rpc_task *task,
175177 struct xdr_stream *xdr);
176−int rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp, __be32 *data, void *obj);
178+int rpcauth_unwrap_resp_decode(struct rpc_task *task,
179+ struct xdr_stream *xdr);
180+int rpcauth_unwrap_resp(struct rpc_task *task,
181+ struct xdr_stream *xdr);
177182 bool rpcauth_xmit_need_reencode(struct rpc_task *task);
178183 int rpcauth_refreshcred(struct rpc_task *);
179184 void rpcauth_invalcred(struct rpc_task *);
include/linux/sunrpc/xdr.h+1−0
@@ -89,6 +89,7 @@ xdr_buf_init(struct xdr_buf *buf, void *start, size_t len) · 88 unmodified lines
8989
9090 #define rpc_auth_null cpu_to_be32(RPC_AUTH_NULL)
9191 #define rpc_auth_unix cpu_to_be32(RPC_AUTH_UNIX)
92+#define rpc_auth_short cpu_to_be32(RPC_AUTH_SHORT)
9293 #define rpc_auth_gss cpu_to_be32(RPC_AUTH_GSS)
9394
9495 #define rpc_call cpu_to_be32(RPC_CALL)
net/sunrpc/auth.c+41−22
@@ -17,6 +17,8 @@ · 16 unmodified lines
1717 #include <linux/sunrpc/gss_api.h>
1818 #include <linux/spinlock.h>
1919
20+#include <trace/events/sunrpc.h>
21+
2022 #define RPC_CREDCACHE_DEFAULT_HASHBITS (4)
2123 struct rpc_cred_cache {
2224 struct hlist_head *hashtable;
@@ -773,14 +775,6 @@ int rpcauth_marshcred(struct rpc_task *task, struct xdr_stream *xdr) · 750 unmodified lines
773775 return ops->crmarshal(task, xdr);
774776 }
775777
776−__be32 *
777−rpcauth_checkverf(struct rpc_task *task, __be32 *p)
778−{
779− struct rpc_cred *cred = task->tk_rqstp->rq_cred;
780−
781− return cred->cr_ops->crvalidate(task, p);
782−}
783−
784778 /**
785779 * rpcauth_wrap_req_encode - XDR encode the RPC procedure
786780 * @task: controlling RPC task
@@ -814,27 +808,52 @@ int rpcauth_wrap_req(struct rpc_task *task, struct xdr_stream *xdr) · 27 unmodified lines
814808 return ops->crwrap_req(task, xdr);
815809 }
816810
817−static int
818−rpcauth_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp,
819− __be32 *data, void *obj)
811+/**
812+ * rpcauth_checkverf - Validate verifier in RPC Reply header
813+ * @task: controlling RPC task
814+ * @xdr: xdr_stream containing RPC Reply header
815+ *
816+ * On success, @xdr is updated to point past the verifier and
817+ * zero is returned. Otherwise, @xdr is in an undefined state
818+ * and a negative errno is returned.
819+ */
820+int
821+rpcauth_checkverf(struct rpc_task *task, struct xdr_stream *xdr)
820822 {
821− struct xdr_stream xdr;
823+ const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops;
822824
823− xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, data, rqstp);
824− return decode(rqstp, &xdr, obj);
825+ return ops->crvalidate(task, xdr);
825826 }
826827
828+/**
829+ * rpcauth_unwrap_resp_decode - Invoke XDR decode function
830+ * @task: controlling RPC task
831+ * @xdr: stream where the Reply message resides
832+ *
833+ * Returns zero on success; otherwise a negative errno is returned.
834+ */
827835 int
828−rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp,
829− __be32 *data, void *obj)
836+rpcauth_unwrap_resp_decode(struct rpc_task *task, struct xdr_stream *xdr)
830837 {
831− struct rpc_cred *cred = task->tk_rqstp->rq_cred;
838+ kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode;
839+
840+ return decode(task->tk_rqstp, xdr, task->tk_msg.rpc_resp);
841+}
842+EXPORT_SYMBOL_GPL(rpcauth_unwrap_resp_decode);
843+
844+/**
845+ * rpcauth_unwrap_resp - Invoke unwrap and decode function for the cred
846+ * @task: controlling RPC task
847+ * @xdr: stream where the Reply message resides
848+ *
849+ * Returns zero on success; otherwise a negative errno is returned.
850+ */
851+int
852+rpcauth_unwrap_resp(struct rpc_task *task, struct xdr_stream *xdr)
853+{
854+ const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops;
832855
833− if (cred->cr_ops->crunwrap_resp)
834− return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
835− data, obj);
836− /* By default, we decode the arguments normally. */
837− return rpcauth_unwrap_req_decode(decode, rqstp, data, obj);
856+ return ops->crunwrap_resp(task, xdr);
838857 }
839858
840859 bool
net/sunrpc/auth_gss/auth_gss.c+110−94
@@ -1671,59 +1671,62 @@ gss_refresh_null(struct rpc_task *task) · 1670 unmodified lines
16711671 return 0;
16721672 }
16731673
1674−static __be32 *
1675−gss_validate(struct rpc_task *task, __be32 *p)
1674+static int
1675+gss_validate(struct rpc_task *task, struct xdr_stream *xdr)
16761676 {
16771677 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
16781678 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
1679− __be32 *seq = NULL;
1679+ __be32 *p, *seq = NULL;
16801680 struct kvec iov;
16811681 struct xdr_buf verf_buf;
16821682 struct xdr_netobj mic;
1683− u32 flav,len;
1684− u32 maj_stat;
1685− __be32 *ret = ERR_PTR(-EIO);
1683+ u32 len, maj_stat;
1684+ int status;
16861685
1687− dprintk("RPC: %5u %s\n", task->tk_pid, __func__);
1686+ p = xdr_inline_decode(xdr, 2 * sizeof(*p));
1687+ if (!p)
1688+ goto validate_failed;
1689+ if (*p++ != rpc_auth_gss)
1690+ goto validate_failed;
1691+ len = be32_to_cpup(p);
1692+ if (len > RPC_MAX_AUTH_SIZE)
1693+ goto validate_failed;
1694+ p = xdr_inline_decode(xdr, len);
1695+ if (!p)
1696+ goto validate_failed;
16881697
1689− flav = ntohl(*p++);
1690− if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE)
1691− goto out_bad;
1692− if (flav != RPC_AUTH_GSS)
1693− goto out_bad;
16941698 seq = kmalloc(4, GFP_NOFS);
16951699 if (!seq)
1696− goto out_bad;
1697− *seq = htonl(task->tk_rqstp->rq_seqno);
1700+ goto validate_failed;
1701+ *seq = cpu_to_be32(task->tk_rqstp->rq_seqno);
16981702 iov.iov_base = seq;
16991703 iov.iov_len = 4;
17001704 xdr_buf_from_iov(&iov, &verf_buf);
17011705 mic.data = (u8 *)p;
17021706 mic.len = len;
1703−
1704− ret = ERR_PTR(-EACCES);
17051707 maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &verf_buf, &mic);
17061708 if (maj_stat == GSS_S_CONTEXT_EXPIRED)
17071709 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
1708− if (maj_stat) {
1709− dprintk("RPC: %5u %s: gss_verify_mic returned error 0x%08x\n",
1710− task->tk_pid, __func__, maj_stat);
1711− goto out_bad;
1712− }
1710+ if (maj_stat)
1711+ goto bad_mic;
1712+
17131713 /* We leave it to unwrap to calculate au_rslack. For now we just
17141714 * calculate the length of the verifier: */
17151715 cred->cr_auth->au_verfsize = XDR_QUADLEN(len) + 2;
1716+ status = 0;
1717+out:
17161718 gss_put_ctx(ctx);
1717− dprintk("RPC: %5u %s: gss_verify_mic succeeded.\n",
1718− task->tk_pid, __func__);
1719− kfree(seq);
1720− return p + XDR_QUADLEN(len);
1721−out_bad:
1722− gss_put_ctx(ctx);
1723− dprintk("RPC: %5u %s failed ret %ld.\n", task->tk_pid, __func__,
1724− PTR_ERR(ret));
17251719 kfree(seq);
1726− return ret;
1720+ return status;
1721+
1722+validate_failed:
1723+ status = -EIO;
1724+ goto out;
1725+bad_mic:
1726+ dprintk("RPC: %5u %s: gss_verify_mic returned error 0x%08x\n",
1727+ task->tk_pid, __func__, maj_stat);
1728+ status = -EACCES;
1729+ goto out;
17271730 }
17281731
17291732 static int gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
@@ -1921,79 +1924,98 @@ out: · 191 unmodified lines
19211924 return status;
19221925 }
19231926
1924−static inline int
1927+static int
1928+gss_unwrap_resp_auth(struct rpc_cred *cred)
1929+{
1930+ cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize;
1931+ return 0;
1932+}
1933+
1934+static int
19251935 gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
1926− struct rpc_rqst *rqstp, __be32 **p)
1936+ struct rpc_rqst *rqstp, struct xdr_stream *xdr)
19271937 {
1928− struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;
1929− struct xdr_buf integ_buf;
1938+ struct xdr_buf integ_buf, *rcv_buf = &rqstp->rq_rcv_buf;
1939+ u32 data_offset, mic_offset, integ_len, maj_stat;
19301940 struct xdr_netobj mic;
1931− u32 data_offset, mic_offset;
1932− u32 integ_len;
1933− u32 maj_stat;
1934− int status = -EIO;
1941+ __be32 *p;
19351942
1936− integ_len = ntohl(*(*p)++);
1943+ p = xdr_inline_decode(xdr, 2 * sizeof(*p));
1944+ if (unlikely(!p))
1945+ goto unwrap_failed;
1946+ integ_len = be32_to_cpup(p++);
19371947 if (integ_len & 3)
1938− return status;
1939− data_offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;
1948+ goto unwrap_failed;
1949+ data_offset = (u8 *)(p) - (u8 *)rcv_buf->head[0].iov_base;
19401950 mic_offset = integ_len + data_offset;
19411951 if (mic_offset > rcv_buf->len)
1942− return status;
1943− if (ntohl(*(*p)++) != rqstp->rq_seqno)
1944− return status;
1945−
1946− if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset,
1947− mic_offset - data_offset))
1948− return status;
1952+ goto unwrap_failed;
1953+ if (be32_to_cpup(p) != rqstp->rq_seqno)
1954+ goto unwrap_failed;
19491955
1956+ if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset, integ_len))
1957+ goto unwrap_failed;
19501958 if (xdr_buf_read_netobj(rcv_buf, &mic, mic_offset))
1951− return status;
1952−
1959+ goto unwrap_failed;
19531960 maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &integ_buf, &mic);
19541961 if (maj_stat == GSS_S_CONTEXT_EXPIRED)
19551962 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
19561963 if (maj_stat != GSS_S_COMPLETE)
1957− return status;
1964+ goto bad_mic;
1965+
1966+ cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + 2 +
1967+ 1 + XDR_QUADLEN(mic.len);
19581968 return 0;
1969+unwrap_failed:
1970+ return -EIO;
1971+bad_mic:
1972+ dprintk("RPC: %s: gss_verify_mic returned error 0x%08x\n",
1973+ __func__, maj_stat);
1974+ return -EIO;
19591975 }
19601976
1961−static inline int
1977+static int
19621978 gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
1963− struct rpc_rqst *rqstp, __be32 **p)
1964−{
1965− struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;
1966− u32 offset;
1967− u32 opaque_len;
1968− u32 maj_stat;
1969− int status = -EIO;
1970−
1971− opaque_len = ntohl(*(*p)++);
1972− offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base;
1979+ struct rpc_rqst *rqstp, struct xdr_stream *xdr)
1980+{
1981+ struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf;
1982+ struct kvec *head = rqstp->rq_rcv_buf.head;
1983+ unsigned int savedlen = rcv_buf->len;
1984+ u32 offset, opaque_len, maj_stat;
1985+ __be32 *p;
1986+
1987+ p = xdr_inline_decode(xdr, 2 * sizeof(*p));
1988+ if (unlikely(!p))
1989+ goto unwrap_failed;
1990+ opaque_len = be32_to_cpup(p++);
1991+ offset = (u8 *)(p) - (u8 *)head->iov_base;
19731992 if (offset + opaque_len > rcv_buf->len)
1974− return status;
1975− /* remove padding: */
1993+ goto unwrap_failed;
19761994 rcv_buf->len = offset + opaque_len;
19771995
19781996 maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, rcv_buf);
19791997 if (maj_stat == GSS_S_CONTEXT_EXPIRED)
19801998 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
19811999 if (maj_stat != GSS_S_COMPLETE)
1982− return status;
1983− if (ntohl(*(*p)++) != rqstp->rq_seqno)
1984− return status;
1985−
1986− return 0;
1987−}
2000+ goto bad_unwrap;
2001+ /* gss_unwrap decrypted the sequence number */
2002+ if (be32_to_cpup(p++) != rqstp->rq_seqno)
2003+ goto unwrap_failed;
19882004
1989−static int
1990−gss_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp,
1991− __be32 *p, void *obj)
1992−{
1993− struct xdr_stream xdr;
2005+ /* gss_unwrap redacts the opaque blob from the head iovec.
2006+ * rcv_buf has changed, thus the stream needs to be reset.
2007+ */
2008+ xdr_init_decode(xdr, rcv_buf, p, rqstp);
19942009
1995− xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p, rqstp);
1996− return decode(rqstp, &xdr, obj);
2010+ cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + 2 +
2011+ XDR_QUADLEN(savedlen - rcv_buf->len);
2012+ return 0;
2013+unwrap_failed:
2014+ return -EIO;
2015+bad_unwrap:
2016+ dprintk("RPC: %s: gss_unwrap returned error 0x%08x\n",
2017+ __func__, maj_stat);
2018+ return -EIO;
19972019 }
19982020
19992021 static bool
@@ -2037,39 +2059,33 @@ out: · 37 unmodified lines
20372059 }
20382060
20392061 static int
2040−gss_unwrap_resp(struct rpc_task *task,
2041− kxdrdproc_t decode, void *rqstp, __be32 *p, void *obj)
2062+gss_unwrap_resp(struct rpc_task *task, struct xdr_stream *xdr)
20422063 {
2043− struct rpc_cred *cred = task->tk_rqstp->rq_cred;
2064+ struct rpc_rqst *rqstp = task->tk_rqstp;
2065+ struct rpc_cred *cred = rqstp->rq_cred;
20442066 struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
20452067 gc_base);
20462068 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred);
2047− __be32 *savedp = p;
2048− struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head;
2049− int savedlen = head->iov_len;
2050− int status = -EIO;
2069+ int status = -EIO;
20512070
20522071 if (ctx->gc_proc != RPC_GSS_PROC_DATA)
20532072 goto out_decode;
20542073 switch (gss_cred->gc_service) {
20552074 case RPC_GSS_SVC_NONE:
2075+ status = gss_unwrap_resp_auth(cred);
20562076 break;
20572077 case RPC_GSS_SVC_INTEGRITY:
2058− status = gss_unwrap_resp_integ(cred, ctx, rqstp, &p);
2059− if (status)
2060− goto out;
2078+ status = gss_unwrap_resp_integ(cred, ctx, rqstp, xdr);
20612079 break;
20622080 case RPC_GSS_SVC_PRIVACY:
2063− status = gss_unwrap_resp_priv(cred, ctx, rqstp, &p);
2064− if (status)
2065− goto out;
2081+ status = gss_unwrap_resp_priv(cred, ctx, rqstp, xdr);
20662082 break;
20672083 }
2068− /* take into account extra slack for integrity and privacy cases: */
2069− cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + (p - savedp)
2070− + (savedlen - head->iov_len);
2084+ if (status)
2085+ goto out;
2086+
20712087 out_decode:
2072− status = gss_unwrap_req_decode(decode, rqstp, p, obj);
2088+ status = rpcauth_unwrap_resp_decode(task, xdr);
20732089 out:
20742090 gss_put_ctx(ctx);
20752091 dprintk("RPC: %5u %s returning %d\n",
net/sunrpc/auth_null.c+13−18
@@ -86,25 +86,19 @@ nul_refresh(struct rpc_task *task) · 85 unmodified lines
8686 return 0;
8787 }
8888
89−static __be32 *
90−nul_validate(struct rpc_task *task, __be32 *p)
89+static int
90+nul_validate(struct rpc_task *task, struct xdr_stream *xdr)
9191 {
92− rpc_authflavor_t flavor;
93− u32 size;
94−
95− flavor = ntohl(*p++);
96− if (flavor != RPC_AUTH_NULL) {
97− printk("RPC: bad verf flavor: %u\n", flavor);
98− return ERR_PTR(-EIO);
99− }
100−
101− size = ntohl(*p++);
102− if (size != 0) {
103− printk("RPC: bad verf size: %u\n", size);
104− return ERR_PTR(-EIO);
105− }
106−
107− return p;
92+ __be32 *p;
93+
94+ p = xdr_inline_decode(xdr, 2 * sizeof(*p));
95+ if (!p)
96+ return -EIO;
97+ if (*p++ != rpc_auth_null)
98+ return -EIO;
99+ if (*p != xdr_zero)
100+ return -EIO;
101+ return 0;
108102 }
109103
110104 const struct rpc_authops authnull_ops = {
@@ -134,6 +128,7 @@ const struct rpc_credops null_credops = { · 23 unmodified lines
134128 .crwrap_req = rpcauth_wrap_req_encode,
135129 .crrefresh = nul_refresh,
136130 .crvalidate = nul_validate,
131+ .crunwrap_resp = rpcauth_unwrap_resp_decode,
137132 };
138133
139134 static
net/sunrpc/auth_unix.c+23−19
@@ -160,29 +160,32 @@ unx_refresh(struct rpc_task *task) · 159 unmodified lines
160160 return 0;
161161 }
162162
163−static __be32 *
164−unx_validate(struct rpc_task *task, __be32 *p)
163+static int
164+unx_validate(struct rpc_task *task, struct xdr_stream *xdr)
165165 {
166− rpc_authflavor_t flavor;
167− u32 size;
168−
169− flavor = ntohl(*p++);
170− if (flavor != RPC_AUTH_NULL &&
171− flavor != RPC_AUTH_UNIX &&
172− flavor != RPC_AUTH_SHORT) {
173− printk("RPC: bad verf flavor: %u\n", flavor);
174− return ERR_PTR(-EIO);
175− }
166+ __be32 *p;
167+ u32 size;
176168
177− size = ntohl(*p++);
178− if (size > RPC_MAX_AUTH_SIZE) {
179− printk("RPC: giant verf size: %u\n", size);
180− return ERR_PTR(-EIO);
169+ p = xdr_inline_decode(xdr, 2 * sizeof(*p));
170+ if (!p)
171+ return -EIO;
172+ switch (*p++) {
173+ case rpc_auth_null:
174+ case rpc_auth_unix:
175+ case rpc_auth_short:
176+ break;
177+ default:
178+ return -EIO;
181179 }
182− task->tk_rqstp->rq_cred->cr_auth->au_rslack = (size >> 2) + 2;
183− p += (size >> 2);
180+ size = be32_to_cpup(p);
181+ if (size > RPC_MAX_AUTH_SIZE)
182+ return -EIO;
183+ p = xdr_inline_decode(xdr, size);
184+ if (!p)
185+ return -EIO;
184186
185− return p;
187+ task->tk_rqstp->rq_cred->cr_auth->au_rslack = (size >> 2) + 2;
188+ return 0;
186189 }
187190
188191 int __init rpc_init_authunix(void)
@@ -223,4 +226,5 @@ const struct rpc_credops unix_credops = { · 34 unmodified lines
223226 .crwrap_req = rpcauth_wrap_req_encode,
224227 .crrefresh = unx_refresh,
225228 .crvalidate = unx_validate,
229+ .crunwrap_resp = rpcauth_unwrap_resp_decode,
226230 };
net/sunrpc/clnt.c+45−43
@@ -79,7 +79,8 @@ static void call_connect_status(struct rpc_task *task); · 78 unmodified lines
7979
8080 static int rpc_encode_header(struct rpc_task *task,
8181 struct xdr_stream *xdr);
82−static __be32 *rpc_decode_header(struct rpc_task *task);
82+static int rpc_decode_header(struct rpc_task *task,
83+ struct xdr_stream *xdr);
8384 static int rpc_ping(struct rpc_clnt *clnt);
8485
8586 static void rpc_register_client(struct rpc_clnt *clnt)
@@ -2251,12 +2252,11 @@ call_decode(struct rpc_task *task) · 2165 unmodified lines
22512252 {
22522253 struct rpc_clnt *clnt = task->tk_client;
22532254 struct rpc_rqst *req = task->tk_rqstp;
2254− kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode;
2255− __be32 *p;
2255+ struct xdr_stream xdr;
22562256
22572257 dprint_status(task);
22582258
2259− if (!decode) {
2259+ if (!task->tk_msg.rpc_proc->p_decode) {
22602260 task->tk_action = rpc_exit_task;
22612261 return;
22622262 }
@@ -2292,29 +2292,27 @@ call_decode(struct rpc_task *task) · 29 unmodified lines
22922292 goto out_retry;
22932293 }
22942294
2295− p = rpc_decode_header(task);
2296− if (IS_ERR(p)) {
2297− if (p == ERR_PTR(-EAGAIN))
2298− goto out_retry;
2295+ xdr_init_decode(&xdr, &req->rq_rcv_buf,
2296+ req->rq_rcv_buf.head[0].iov_base, req);
2297+ switch (rpc_decode_header(task, &xdr)) {
2298+ case 0:
2299+ task->tk_action = rpc_exit_task;
2300+ task->tk_status = rpcauth_unwrap_resp(task, &xdr);
2301+ dprintk("RPC: %5u %s result %d\n",
2302+ task->tk_pid, __func__, task->tk_status);
22992303 return;
2300− }
2301− task->tk_action = rpc_exit_task;
2302−
2303− task->tk_status = rpcauth_unwrap_resp(task, decode, req, p,
2304− task->tk_msg.rpc_resp);
2305−
2306− dprintk("RPC: %5u call_decode result %d\n", task->tk_pid,
2307− task->tk_status);
2308− return;
2304+ case -EAGAIN:
23092305 out_retry:
2310− task->tk_status = 0;
2311− /* Note: rpc_decode_header() may have freed the RPC slot */
2312− if (task->tk_rqstp == req) {
2313− xdr_free_bvec(&req->rq_rcv_buf);
2314− req->rq_reply_bytes_recvd = req->rq_rcv_buf.len = 0;
2315− if (task->tk_client->cl_discrtry)
2316− xprt_conditional_disconnect(req->rq_xprt,
2317− req->rq_connect_cookie);
2306+ task->tk_status = 0;
2307+ /* Note: rpc_decode_header() may have freed the RPC slot */
2308+ if (task->tk_rqstp == req) {
2309+ xdr_free_bvec(&req->rq_rcv_buf);
2310+ req->rq_reply_bytes_recvd = 0;
2311+ req->rq_rcv_buf.len = 0;
2312+ if (task->tk_client->cl_discrtry)
2313+ xprt_conditional_disconnect(req->rq_xprt,
2314+ req->rq_connect_cookie);
2315+ }
23182316 }
23192317 }
23202318
@@ -2347,14 +2345,12 @@ out_fail: · 26 unmodified lines
23472345 return error;
23482346 }
23492347
2350−static noinline __be32 *
2351−rpc_decode_header(struct rpc_task *task)
2348+static noinline int
2349+rpc_decode_header(struct rpc_task *task, struct xdr_stream *xdr)
23522350 {
23532351 struct rpc_clnt *clnt = task->tk_client;
2354− struct kvec *iov = &task->tk_rqstp->rq_rcv_buf.head[0];
2355− int len = task->tk_rqstp->rq_rcv_buf.len >> 2;
2356− __be32 *p = iov->iov_base;
23572352 int error = -EACCES;
2353+ __be32 *p;
23582354
23592355 /* RFC-1014 says that the representation of XDR data must be a
23602356 * multiple of four bytes
@@ -2363,25 +2359,26 @@ rpc_decode_header(struct rpc_task *task) · 2 unmodified lines
23632359 */
23642360 if (task->tk_rqstp->rq_rcv_buf.len & 3)
23652361 goto out_badlen;
2366− if ((len -= 3) < 0)
2367− goto out_unparsable;
23682362
2363+ p = xdr_inline_decode(xdr, 3 * sizeof(*p));
2364+ if (!p)
2365+ goto out_unparsable;
23692366 p++; /* skip XID */
23702367 if (*p++ != rpc_reply)
23712368 goto out_unparsable;
23722369 if (*p++ != rpc_msg_accepted)
23732370 goto out_msg_denied;
23742371
2375− p = rpcauth_checkverf(task, p);
2376− if (IS_ERR(p))
2372+ error = rpcauth_checkverf(task, xdr);
2373+ if (error)
23772374 goto out_verifier;
23782375
2379− len = p - (__be32 *)iov->iov_base - 1;
2380− if (len < 0)
2376+ p = xdr_inline_decode(xdr, sizeof(*p));
2377+ if (!p)
23812378 goto out_unparsable;
2382− switch (*p++) {
2379+ switch (*p) {
23832380 case rpc_success:
2384− return p;
2381+ return 0;
23852382 case rpc_prog_unavail:
23862383 trace_rpc__prog_unavail(task);
23872384 error = -EPFNOSUPPORT;
@@ -2406,11 +2403,11 @@ out_garbage: · 18 unmodified lines
24062403 if (task->tk_garb_retry) {
24072404 task->tk_garb_retry--;
24082405 task->tk_action = call_encode;
2409− return ERR_PTR(-EAGAIN);
2406+ return -EAGAIN;
24102407 }
24112408 out_err:
24122409 rpc_exit(task, error);
2413− return ERR_PTR(error);
2410+ return error;
24142411
24152412 out_badlen:
24162413 trace_rpc__unparsable(task);
@@ -2424,10 +2421,12 @@ out_unparsable: · 7 unmodified lines
24242421
24252422 out_verifier:
24262423 trace_rpc_bad_verifier(task);
2427− error = PTR_ERR(p);
24282424 goto out_garbage;
24292425
24302426 out_msg_denied:
2427+ p = xdr_inline_decode(xdr, sizeof(*p));
2428+ if (!p)
2429+ goto out_unparsable;
24312430 switch (*p++) {
24322431 case rpc_auth_error:
24332432 break;
@@ -2441,6 +2440,9 @@ out_msg_denied: · 7 unmodified lines
24412440 goto out_err;
24422441 }
24432442
2443+ p = xdr_inline_decode(xdr, sizeof(*p));
2444+ if (!p)
2445+ goto out_unparsable;
24442446 switch (*p++) {
24452447 case rpc_autherr_rejectedcred:
24462448 case rpc_autherr_rejectedverf:
@@ -2454,7 +2456,7 @@ out_msg_denied: · 7 unmodified lines
24542456 /* Ensure we obtain a new XID! */
24552457 xprt_release(task);
24562458 task->tk_action = call_reserve;
2457− return ERR_PTR(-EAGAIN);
2459+ return -EAGAIN;
24582460 case rpc_autherr_badcred:
24592461 case rpc_autherr_badverf:
24602462 /* possibly garbled cred/verf? */
@@ -2463,7 +2465,7 @@ out_msg_denied: · 2 unmodified lines
24632465 task->tk_garb_retry--;
24642466 trace_rpc__bad_creds(task);
24652467 task->tk_action = call_encode;
2466− return ERR_PTR(-EAGAIN);
2468+ return -EAGAIN;
24672469 case rpc_autherr_tooweak:
24682470 trace_rpc__auth_tooweak(task);
24692471 pr_warn("RPC: server %s requires stronger authentication.\n",

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t