1*564dba15Sjsg /* $OpenBSD: krpc_subr.c,v 1.39 2024/05/01 13:15:59 jsg Exp $ */
29611f776Sderaadt /* $NetBSD: krpc_subr.c,v 1.12.4.1 1996/06/07 00:52:26 cgd Exp $ */
3df930be7Sderaadt
4df930be7Sderaadt /*
5df930be7Sderaadt * Copyright (c) 1995 Gordon Ross, Adam Glass
6df930be7Sderaadt * Copyright (c) 1992 Regents of the University of California.
7df930be7Sderaadt * All rights reserved.
8df930be7Sderaadt *
9df930be7Sderaadt * This software was developed by the Computer Systems Engineering group
10df930be7Sderaadt * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
11df930be7Sderaadt * contributed to Berkeley.
12df930be7Sderaadt *
13df930be7Sderaadt * Redistribution and use in source and binary forms, with or without
14df930be7Sderaadt * modification, are permitted provided that the following conditions
15df930be7Sderaadt * are met:
16df930be7Sderaadt * 1. Redistributions of source code must retain the above copyright
17df930be7Sderaadt * notice, this list of conditions and the following disclaimer.
18df930be7Sderaadt * 2. Redistributions in binary form must reproduce the above copyright
19df930be7Sderaadt * notice, this list of conditions and the following disclaimer in the
20df930be7Sderaadt * documentation and/or other materials provided with the distribution.
21df930be7Sderaadt * 3. All advertising materials mentioning features or use of this software
22df930be7Sderaadt * must display the following acknowledgement:
23df930be7Sderaadt * This product includes software developed by the University of
24df930be7Sderaadt * California, Lawrence Berkeley Laboratory and its contributors.
25df930be7Sderaadt * 4. Neither the name of the University nor the names of its contributors
26df930be7Sderaadt * may be used to endorse or promote products derived from this software
27df930be7Sderaadt * without specific prior written permission.
28df930be7Sderaadt *
29df930be7Sderaadt * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30df930be7Sderaadt * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31df930be7Sderaadt * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32df930be7Sderaadt * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33df930be7Sderaadt * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34df930be7Sderaadt * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35df930be7Sderaadt * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36df930be7Sderaadt * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37df930be7Sderaadt * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38df930be7Sderaadt * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39df930be7Sderaadt * SUCH DAMAGE.
40df930be7Sderaadt *
41df930be7Sderaadt * partially based on:
42df930be7Sderaadt * libnetboot/rpc.c
43df930be7Sderaadt * @(#) Header: rpc.c,v 1.12 93/09/28 08:31:56 leres Exp (LBL)
44df930be7Sderaadt */
45df930be7Sderaadt
46df930be7Sderaadt #include <sys/param.h>
47df930be7Sderaadt #include <sys/systm.h>
48df930be7Sderaadt #include <sys/proc.h>
49df930be7Sderaadt #include <sys/mbuf.h>
50df930be7Sderaadt #include <sys/socket.h>
51df930be7Sderaadt #include <sys/socketvar.h>
52df930be7Sderaadt
53df930be7Sderaadt #include <netinet/in.h>
54df930be7Sderaadt
55df930be7Sderaadt #include <nfs/rpcv2.h>
56df930be7Sderaadt #include <nfs/krpc.h>
57df930be7Sderaadt #include <nfs/xdr_subs.h>
58ca6e56f2Sdjm #include <crypto/idgen.h>
59df930be7Sderaadt
60df930be7Sderaadt /*
61df930be7Sderaadt * Kernel support for Sun RPC
62df930be7Sderaadt *
63df930be7Sderaadt * Used currently for bootstrapping in nfs diskless configurations.
64df930be7Sderaadt */
65df930be7Sderaadt
66df930be7Sderaadt /*
67df930be7Sderaadt * Generic RPC headers
68df930be7Sderaadt */
69df930be7Sderaadt
70df930be7Sderaadt struct auth_info {
71df930be7Sderaadt u_int32_t authtype; /* auth type */
72df930be7Sderaadt u_int32_t authlen; /* auth length */
73df930be7Sderaadt };
74df930be7Sderaadt
75df930be7Sderaadt struct auth_unix {
76df930be7Sderaadt int32_t ua_time;
77df930be7Sderaadt int32_t ua_hostname; /* null */
78df930be7Sderaadt int32_t ua_uid;
79df930be7Sderaadt int32_t ua_gid;
80df930be7Sderaadt int32_t ua_gidlist; /* null */
81df930be7Sderaadt };
82df930be7Sderaadt
83df930be7Sderaadt struct rpc_call {
84df930be7Sderaadt u_int32_t rp_xid; /* request transaction id */
85df930be7Sderaadt int32_t rp_direction; /* call direction (0) */
86df930be7Sderaadt u_int32_t rp_rpcvers; /* rpc version (2) */
87df930be7Sderaadt u_int32_t rp_prog; /* program */
88df930be7Sderaadt u_int32_t rp_vers; /* version */
89df930be7Sderaadt u_int32_t rp_proc; /* procedure */
90df930be7Sderaadt struct auth_info rpc_auth;
91df930be7Sderaadt struct auth_unix rpc_unix;
92df930be7Sderaadt struct auth_info rpc_verf;
93df930be7Sderaadt };
94df930be7Sderaadt
95df930be7Sderaadt struct rpc_reply {
96df930be7Sderaadt u_int32_t rp_xid; /* request transaction id */
97df930be7Sderaadt int32_t rp_direction; /* call direction (1) */
98df930be7Sderaadt int32_t rp_astatus; /* accept status (0: accepted) */
99df930be7Sderaadt union {
100df930be7Sderaadt u_int32_t rpu_errno;
101df930be7Sderaadt struct {
102df930be7Sderaadt struct auth_info rok_auth;
103df930be7Sderaadt u_int32_t rok_status;
104df930be7Sderaadt } rpu_rok;
105df930be7Sderaadt } rp_u;
106df930be7Sderaadt };
107df930be7Sderaadt #define rp_errno rp_u.rpu_errno
108df930be7Sderaadt #define rp_auth rp_u.rpu_rok.rok_auth
109df930be7Sderaadt #define rp_status rp_u.rpu_rok.rok_status
110df930be7Sderaadt
111df930be7Sderaadt #define MIN_REPLY_HDR 16 /* xid, dir, astat, errno */
112df930be7Sderaadt
113ca6e56f2Sdjm u_int32_t krpc_get_xid(void);
114ca6e56f2Sdjm
115ca6e56f2Sdjm /*
116ca6e56f2Sdjm * Return an unpredictable XID.
117ca6e56f2Sdjm */
118ca6e56f2Sdjm u_int32_t
krpc_get_xid(void)119ca6e56f2Sdjm krpc_get_xid(void)
120ca6e56f2Sdjm {
121ca6e56f2Sdjm static struct idgen32_ctx krpc_xid_ctx;
122ca6e56f2Sdjm static int called = 0;
123ca6e56f2Sdjm
124ca6e56f2Sdjm if (!called) {
125ca6e56f2Sdjm called = 1;
126ca6e56f2Sdjm idgen32_init(&krpc_xid_ctx);
127ca6e56f2Sdjm }
128ca6e56f2Sdjm return idgen32(&krpc_xid_ctx);
129ca6e56f2Sdjm }
130ca6e56f2Sdjm
131df930be7Sderaadt /*
132df930be7Sderaadt * What is the longest we will wait before re-sending a request?
133df930be7Sderaadt * Note this is also the frequency of "RPC timeout" messages.
134df930be7Sderaadt * The re-send loop count sup linearly to this maximum, so the
135df930be7Sderaadt * first complaint will happen after (1+2+3+4+5)=15 seconds.
136df930be7Sderaadt */
137df930be7Sderaadt #define MAX_RESEND_DELAY 5 /* seconds */
138df930be7Sderaadt
139df930be7Sderaadt /*
140df930be7Sderaadt * Call portmap to lookup a port number for a particular rpc program
141df930be7Sderaadt * Returns non-zero error on failure.
142df930be7Sderaadt */
143df930be7Sderaadt int
krpc_portmap(struct sockaddr_in * sin,u_int prog,u_int vers,u_int16_t * portp)144906a9d53Sjsg krpc_portmap(struct sockaddr_in *sin, u_int prog, u_int vers, u_int16_t *portp)
145df930be7Sderaadt {
146df930be7Sderaadt struct sdata {
147df930be7Sderaadt u_int32_t prog; /* call program */
148df930be7Sderaadt u_int32_t vers; /* call version */
149df930be7Sderaadt u_int32_t proto; /* call protocol */
150df930be7Sderaadt u_int32_t port; /* call port (unused) */
151df930be7Sderaadt } *sdata;
152df930be7Sderaadt struct rdata {
153df930be7Sderaadt u_int16_t pad;
154df930be7Sderaadt u_int16_t port;
155df930be7Sderaadt } *rdata;
156df930be7Sderaadt struct mbuf *m;
157df930be7Sderaadt int error;
158df930be7Sderaadt
159df930be7Sderaadt /* The portmapper port is fixed. */
160df930be7Sderaadt if (prog == PMAPPROG) {
161df930be7Sderaadt *portp = htons(PMAPPORT);
162df930be7Sderaadt return 0;
163df930be7Sderaadt }
164df930be7Sderaadt
165df930be7Sderaadt m = m_get(M_WAIT, MT_DATA);
166df930be7Sderaadt sdata = mtod(m, struct sdata *);
167df930be7Sderaadt m->m_len = sizeof(*sdata);
168df930be7Sderaadt
169df930be7Sderaadt /* Do the RPC to get it. */
170df930be7Sderaadt sdata->prog = txdr_unsigned(prog);
171df930be7Sderaadt sdata->vers = txdr_unsigned(vers);
172df930be7Sderaadt sdata->proto = txdr_unsigned(IPPROTO_UDP);
173df930be7Sderaadt sdata->port = 0;
174df930be7Sderaadt
175df930be7Sderaadt sin->sin_port = htons(PMAPPORT);
176df930be7Sderaadt error = krpc_call(sin, PMAPPROG, PMAPVERS,
177a28bd3cfSmickey PMAPPROC_GETPORT, &m, NULL, -1);
178df930be7Sderaadt if (error)
179df930be7Sderaadt return error;
180df930be7Sderaadt
181df930be7Sderaadt if (m->m_len < sizeof(*rdata)) {
182df930be7Sderaadt m = m_pullup(m, sizeof(*rdata));
183df930be7Sderaadt if (m == NULL)
184df930be7Sderaadt return ENOBUFS;
185df930be7Sderaadt }
186df930be7Sderaadt rdata = mtod(m, struct rdata *);
187df930be7Sderaadt *portp = rdata->port;
188df930be7Sderaadt
189df930be7Sderaadt m_freem(m);
190df930be7Sderaadt return 0;
191df930be7Sderaadt }
192df930be7Sderaadt
193df930be7Sderaadt /*
194df930be7Sderaadt * Do a remote procedure call (RPC) and wait for its reply.
195df930be7Sderaadt * If from_p is non-null, then we are doing broadcast, and
196df930be7Sderaadt * the address from whence the response came is saved there.
197906a9d53Sjsg * data: input/output
198906a9d53Sjsg * from_p: output
199df930be7Sderaadt */
200df930be7Sderaadt int
krpc_call(struct sockaddr_in * sa,u_int prog,u_int vers,u_int func,struct mbuf ** data,struct mbuf ** from_p,int retries)201906a9d53Sjsg krpc_call(struct sockaddr_in *sa, u_int prog, u_int vers, u_int func,
202906a9d53Sjsg struct mbuf **data, struct mbuf **from_p, int retries)
203df930be7Sderaadt {
204df930be7Sderaadt struct socket *so;
205df930be7Sderaadt struct sockaddr_in *sin;
206792875b3Sderaadt struct mbuf *m, *nam, *mhead, *from, *mopt;
207df930be7Sderaadt struct rpc_call *call;
208df930be7Sderaadt struct rpc_reply *reply;
209df930be7Sderaadt struct uio auio;
21084245c07Sclaudio int error, rcvflg, timo, secs, len, authlen;
2110f76c2f7Sangelos static u_int32_t xid = 0;
212bbcf0337Smpi char addr[INET_ADDRSTRLEN];
213792875b3Sderaadt int *ip;
214d6a24d14Sderaadt struct timeval tv;
215df930be7Sderaadt
216df930be7Sderaadt /*
217df930be7Sderaadt * Validate address family.
218df930be7Sderaadt * Sorry, this is INET specific...
219df930be7Sderaadt */
220df930be7Sderaadt if (sa->sin_family != AF_INET)
221df930be7Sderaadt return (EAFNOSUPPORT);
222df930be7Sderaadt
223df930be7Sderaadt /* Free at end if not null. */
224df930be7Sderaadt nam = mhead = NULL;
225df930be7Sderaadt from = NULL;
226df930be7Sderaadt
227df930be7Sderaadt /*
2285b4e4e58Snate * Create socket and set its receive timeout.
229df930be7Sderaadt */
230df930be7Sderaadt if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0)))
231df930be7Sderaadt goto out;
232df930be7Sderaadt
233df930be7Sderaadt m = m_get(M_WAIT, MT_SOOPTS);
234d6a24d14Sderaadt tv.tv_sec = 1;
235d6a24d14Sderaadt tv.tv_usec = 0;
236d6a24d14Sderaadt memcpy(mtod(m, struct timeval *), &tv, sizeof tv);
237d6a24d14Sderaadt m->m_len = sizeof(tv);
238411c4400Smpi error = sosetopt(so, SOL_SOCKET, SO_RCVTIMEO, m);
239e09b1b7cSmpi m_freem(m);
240411c4400Smpi if (error)
241df930be7Sderaadt goto out;
242df930be7Sderaadt
243df930be7Sderaadt /*
244df930be7Sderaadt * Enable broadcast if necessary.
245df930be7Sderaadt */
246df930be7Sderaadt if (from_p) {
2471a14c87fSderaadt int32_t *on;
248df930be7Sderaadt m = m_get(M_WAIT, MT_SOOPTS);
2491a14c87fSderaadt on = mtod(m, int32_t *);
250df930be7Sderaadt m->m_len = sizeof(*on);
251df930be7Sderaadt *on = 1;
252411c4400Smpi error = sosetopt(so, SOL_SOCKET, SO_BROADCAST, m);
253e09b1b7cSmpi m_freem(m);
254411c4400Smpi if (error)
255df930be7Sderaadt goto out;
256df930be7Sderaadt }
257df930be7Sderaadt
258df930be7Sderaadt /*
259df930be7Sderaadt * Bind the local endpoint to a reserved port,
260df930be7Sderaadt * because some NFS servers refuse requests from
261df930be7Sderaadt * non-reserved (non-privileged) ports.
262df930be7Sderaadt */
263792875b3Sderaadt MGET(mopt, M_WAIT, MT_SOOPTS);
264792875b3Sderaadt mopt->m_len = sizeof(int);
265792875b3Sderaadt ip = mtod(mopt, int *);
266792875b3Sderaadt *ip = IP_PORTRANGE_LOW;
267792875b3Sderaadt error = sosetopt(so, IPPROTO_IP, IP_PORTRANGE, mopt);
268e09b1b7cSmpi m_freem(mopt);
269792875b3Sderaadt if (error)
270792875b3Sderaadt goto out;
271792875b3Sderaadt
272792875b3Sderaadt MGET(m, M_WAIT, MT_SONAME);
273792875b3Sderaadt sin = mtod(m, struct sockaddr_in *);
2749c794535Sbluhm memset(sin, 0, sizeof(*sin));
275792875b3Sderaadt sin->sin_len = m->m_len = sizeof(struct sockaddr_in);
276792875b3Sderaadt sin->sin_family = AF_INET;
277792875b3Sderaadt sin->sin_addr.s_addr = INADDR_ANY;
278792875b3Sderaadt sin->sin_port = htons(0);
27984245c07Sclaudio solock(so);
280621c015eSthib error = sobind(so, m, &proc0);
28184245c07Sclaudio sounlock(so);
282df930be7Sderaadt m_freem(m);
283df930be7Sderaadt if (error) {
284df930be7Sderaadt printf("bind failed\n");
285df930be7Sderaadt goto out;
286df930be7Sderaadt }
287df930be7Sderaadt
288792875b3Sderaadt MGET(mopt, M_WAIT, MT_SOOPTS);
289792875b3Sderaadt mopt->m_len = sizeof(int);
290792875b3Sderaadt ip = mtod(mopt, int *);
291792875b3Sderaadt *ip = IP_PORTRANGE_DEFAULT;
292792875b3Sderaadt error = sosetopt(so, IPPROTO_IP, IP_PORTRANGE, mopt);
293e09b1b7cSmpi m_freem(mopt);
294792875b3Sderaadt if (error)
295792875b3Sderaadt goto out;
296792875b3Sderaadt
297df930be7Sderaadt /*
298df930be7Sderaadt * Setup socket address for the server.
299df930be7Sderaadt */
300df930be7Sderaadt nam = m_get(M_WAIT, MT_SONAME);
301df930be7Sderaadt sin = mtod(nam, struct sockaddr_in *);
3020017e6e0Stedu bcopy(sa, sin, (nam->m_len = sa->sin_len));
303df930be7Sderaadt
304df930be7Sderaadt /*
305df930be7Sderaadt * Prepend RPC message header.
306df930be7Sderaadt */
307df930be7Sderaadt mhead = m_gethdr(M_WAIT, MT_DATA);
308df930be7Sderaadt mhead->m_next = *data;
309df930be7Sderaadt call = mtod(mhead, struct rpc_call *);
310df930be7Sderaadt mhead->m_len = sizeof(*call);
311851e11faStedu memset(call, 0, sizeof(*call));
312df930be7Sderaadt /* rpc_call part */
313ca6e56f2Sdjm xid = krpc_get_xid();
314df930be7Sderaadt call->rp_xid = txdr_unsigned(xid);
315df930be7Sderaadt /* call->rp_direction = 0; */
316df930be7Sderaadt call->rp_rpcvers = txdr_unsigned(2);
317df930be7Sderaadt call->rp_prog = txdr_unsigned(prog);
318df930be7Sderaadt call->rp_vers = txdr_unsigned(vers);
319df930be7Sderaadt call->rp_proc = txdr_unsigned(func);
320df930be7Sderaadt /* rpc_auth part (auth_unix as root) */
321df930be7Sderaadt call->rpc_auth.authtype = txdr_unsigned(RPCAUTH_UNIX);
322df930be7Sderaadt call->rpc_auth.authlen = txdr_unsigned(sizeof(struct auth_unix));
323df930be7Sderaadt /* rpc_verf part (auth_null) */
324df930be7Sderaadt call->rpc_verf.authtype = 0;
325df930be7Sderaadt call->rpc_verf.authlen = 0;
326df930be7Sderaadt
327df930be7Sderaadt /*
328df930be7Sderaadt * Setup packet header
329df930be7Sderaadt */
330f02cb2e8Sbluhm m_calchdrlen(mhead);
331fb492c37Smpi mhead->m_pkthdr.ph_ifidx = 0;
332df930be7Sderaadt
333df930be7Sderaadt /*
334df930be7Sderaadt * Send it, repeatedly, until a reply is received,
335df930be7Sderaadt * but delay each re-send by an increasing amount.
336df930be7Sderaadt * If the delay hits the maximum, start complaining.
337df930be7Sderaadt */
338a28bd3cfSmickey for (timo = 0; retries; retries--) {
339df930be7Sderaadt /* Send RPC request (or re-send). */
340df930be7Sderaadt m = m_copym(mhead, 0, M_COPYALL, M_WAIT);
341df930be7Sderaadt if (m == NULL) {
342df930be7Sderaadt error = ENOBUFS;
343df930be7Sderaadt goto out;
344df930be7Sderaadt }
345df930be7Sderaadt error = sosend(so, nam, NULL, m, NULL, 0);
346df930be7Sderaadt if (error) {
347df930be7Sderaadt printf("krpc_call: sosend: %d\n", error);
348df930be7Sderaadt goto out;
349df930be7Sderaadt }
350df930be7Sderaadt m = NULL;
351df930be7Sderaadt
352df930be7Sderaadt /* Determine new timeout. */
353df930be7Sderaadt if (timo < MAX_RESEND_DELAY)
354df930be7Sderaadt timo++;
355df930be7Sderaadt else
3565d8ed58eSderaadt printf("RPC timeout for server %s (0x%x) prog %u\n",
357bbcf0337Smpi inet_ntop(AF_INET, &sin->sin_addr,
358bbcf0337Smpi addr, sizeof(addr)),
3595d8ed58eSderaadt ntohl(sin->sin_addr.s_addr), prog);
360df930be7Sderaadt
361df930be7Sderaadt /*
362df930be7Sderaadt * Wait for up to timo seconds for a reply.
363df930be7Sderaadt * The socket receive timeout was set to 1 second.
364df930be7Sderaadt */
365df930be7Sderaadt secs = timo;
366df930be7Sderaadt while (secs > 0) {
367df930be7Sderaadt m_freem(from);
368df930be7Sderaadt from = NULL;
36909284026Sderaadt
370df930be7Sderaadt m_freem(m);
371df930be7Sderaadt m = NULL;
37209284026Sderaadt
373df930be7Sderaadt auio.uio_resid = len = 1<<16;
37437829a35Smarkus auio.uio_procp = NULL;
375df930be7Sderaadt rcvflg = 0;
37601d36b92Sotto error = soreceive(so, &from, &auio, &m, NULL, &rcvflg,
37701d36b92Sotto 0);
378df930be7Sderaadt if (error == EWOULDBLOCK) {
379df930be7Sderaadt secs--;
380df930be7Sderaadt continue;
381df930be7Sderaadt }
382df930be7Sderaadt if (error)
383df930be7Sderaadt goto out;
384df930be7Sderaadt len -= auio.uio_resid;
385df930be7Sderaadt
386df930be7Sderaadt /* Does the reply contain at least a header? */
387df930be7Sderaadt if (len < MIN_REPLY_HDR)
388df930be7Sderaadt continue;
389df930be7Sderaadt if (m->m_len < MIN_REPLY_HDR)
390df930be7Sderaadt continue;
391df930be7Sderaadt reply = mtod(m, struct rpc_reply *);
392df930be7Sderaadt
393df930be7Sderaadt /* Is it the right reply? */
394df930be7Sderaadt if (reply->rp_direction != txdr_unsigned(RPC_REPLY))
395df930be7Sderaadt continue;
396df930be7Sderaadt
397df930be7Sderaadt if (reply->rp_xid != txdr_unsigned(xid))
398df930be7Sderaadt continue;
399df930be7Sderaadt
400df930be7Sderaadt /* Was RPC accepted? (authorization OK) */
401df930be7Sderaadt if (reply->rp_astatus != 0) {
402df930be7Sderaadt error = fxdr_unsigned(u_int32_t, reply->rp_errno);
403df930be7Sderaadt printf("rpc denied, error=%d\n", error);
404df930be7Sderaadt continue;
405df930be7Sderaadt }
406df930be7Sderaadt
407df930be7Sderaadt /* Did the call succeed? */
408df930be7Sderaadt if (reply->rp_status != 0) {
409df930be7Sderaadt error = fxdr_unsigned(u_int32_t, reply->rp_status);
410df930be7Sderaadt printf("rpc denied, status=%d\n", error);
411df930be7Sderaadt continue;
412df930be7Sderaadt }
413df930be7Sderaadt
414df930be7Sderaadt goto gotreply; /* break two levels */
415df930be7Sderaadt
416df930be7Sderaadt } /* while secs */
417df930be7Sderaadt } /* forever send/receive */
418df930be7Sderaadt
419df930be7Sderaadt error = ETIMEDOUT;
420df930be7Sderaadt goto out;
421df930be7Sderaadt
422df930be7Sderaadt gotreply:
423df930be7Sderaadt
424df930be7Sderaadt /*
425df930be7Sderaadt * Get RPC reply header into first mbuf,
426df930be7Sderaadt * get its length, then strip it off.
427df930be7Sderaadt */
428df930be7Sderaadt len = sizeof(*reply);
429f15c2684Sbluhm KASSERT(m->m_flags & M_PKTHDR);
430f15c2684Sbluhm if (m->m_pkthdr.len < len) {
431f15c2684Sbluhm error = EBADRPC;
432f15c2684Sbluhm goto out;
433f15c2684Sbluhm }
434df930be7Sderaadt if (m->m_len < len) {
435df930be7Sderaadt m = m_pullup(m, len);
436df930be7Sderaadt if (m == NULL) {
437df930be7Sderaadt error = ENOBUFS;
438df930be7Sderaadt goto out;
439df930be7Sderaadt }
440df930be7Sderaadt }
441df930be7Sderaadt reply = mtod(m, struct rpc_reply *);
442df930be7Sderaadt if (reply->rp_auth.authtype != 0) {
443f15c2684Sbluhm authlen = fxdr_unsigned(u_int32_t, reply->rp_auth.authlen);
444f15c2684Sbluhm if (authlen < 0 || authlen > RPCAUTH_MAXSIZ) {
445f15c2684Sbluhm error = EBADRPC;
446f15c2684Sbluhm goto out;
447f15c2684Sbluhm }
448f15c2684Sbluhm len += (authlen + 3) & ~3; /* XXX? */
449f15c2684Sbluhm }
450f15c2684Sbluhm if (len < 0 || m->m_pkthdr.len < len) {
451f15c2684Sbluhm error = EBADRPC;
452f15c2684Sbluhm goto out;
453df930be7Sderaadt }
454df930be7Sderaadt m_adj(m, len);
455df930be7Sderaadt
456df930be7Sderaadt /* result */
457df930be7Sderaadt *data = m;
4587be41cd8Sthib if (from_p && error == 0) {
459df930be7Sderaadt *from_p = from;
460df930be7Sderaadt from = NULL;
461df930be7Sderaadt }
462df930be7Sderaadt
463df930be7Sderaadt out:
46409284026Sderaadt m_freem(nam);
46509284026Sderaadt m_freem(mhead);
46609284026Sderaadt m_freem(from);
4674a4dc3eaSmpi soclose(so, 0);
468df930be7Sderaadt return error;
469df930be7Sderaadt }
470df930be7Sderaadt
471df930be7Sderaadt /*
472df930be7Sderaadt * eXternal Data Representation routines.
473df930be7Sderaadt * (but with non-standard args...)
474df930be7Sderaadt */
475df930be7Sderaadt
476df930be7Sderaadt /*
477df930be7Sderaadt * String representation for RPC.
478df930be7Sderaadt */
479df930be7Sderaadt struct xdr_string {
480df930be7Sderaadt u_int32_t len; /* length without null or padding */
481df930be7Sderaadt char data[4]; /* data (longer, of course) */
482df930be7Sderaadt /* data is padded to a long-word boundary */
483df930be7Sderaadt };
484df930be7Sderaadt
485df930be7Sderaadt struct mbuf *
xdr_string_encode(char * str,int len)486906a9d53Sjsg xdr_string_encode(char *str, int len)
487df930be7Sderaadt {
488df930be7Sderaadt struct mbuf *m;
489df930be7Sderaadt struct xdr_string *xs;
490df930be7Sderaadt int dlen; /* padded string length */
491df930be7Sderaadt int mlen; /* message length */
492df930be7Sderaadt
493df930be7Sderaadt dlen = (len + 3) & ~3;
494df930be7Sderaadt mlen = dlen + 4;
495df930be7Sderaadt
4969611f776Sderaadt if (mlen > MCLBYTES) /* If too big, we just can't do it. */
4979611f776Sderaadt return (NULL);
4989611f776Sderaadt
499df930be7Sderaadt m = m_get(M_WAIT, MT_DATA);
500df930be7Sderaadt if (mlen > MLEN) {
501df930be7Sderaadt MCLGET(m, M_WAIT);
5029611f776Sderaadt if ((m->m_flags & M_EXT) == 0) {
5039611f776Sderaadt (void) m_free(m); /* There can be only one. */
5049611f776Sderaadt return (NULL);
5059611f776Sderaadt }
506df930be7Sderaadt }
507df930be7Sderaadt xs = mtod(m, struct xdr_string *);
508df930be7Sderaadt m->m_len = mlen;
509df930be7Sderaadt xs->len = txdr_unsigned(len);
510df930be7Sderaadt bcopy(str, xs->data, len);
511df930be7Sderaadt return (m);
512df930be7Sderaadt }
513df930be7Sderaadt
514df930be7Sderaadt struct mbuf *
xdr_string_decode(struct mbuf * m,char * str,int * len_p)515906a9d53Sjsg xdr_string_decode(struct mbuf *m, char *str, int *len_p)
516df930be7Sderaadt {
517df930be7Sderaadt struct xdr_string *xs;
518df930be7Sderaadt int mlen; /* message length */
519df930be7Sderaadt int slen; /* string length */
520df930be7Sderaadt
521f15c2684Sbluhm mlen = sizeof(u_int32_t);
522f15c2684Sbluhm KASSERT(m->m_flags & M_PKTHDR);
523f15c2684Sbluhm if (m->m_pkthdr.len < mlen) {
524f15c2684Sbluhm m_freem(m);
525f15c2684Sbluhm return (NULL);
526f15c2684Sbluhm }
527f15c2684Sbluhm if (m->m_len < mlen) {
528f15c2684Sbluhm m = m_pullup(m, mlen);
529df930be7Sderaadt if (m == NULL)
530df930be7Sderaadt return (NULL);
531df930be7Sderaadt }
532df930be7Sderaadt xs = mtod(m, struct xdr_string *);
533df930be7Sderaadt slen = fxdr_unsigned(u_int32_t, xs->len);
534f15c2684Sbluhm if (slen < 0 || slen > INT_MAX - 3 - mlen) {
535f15c2684Sbluhm m_freem(m);
536f15c2684Sbluhm return (NULL);
537f15c2684Sbluhm }
538f15c2684Sbluhm mlen += (slen + 3) & ~3;
539df930be7Sderaadt
540df930be7Sderaadt if (slen > *len_p)
541df930be7Sderaadt slen = *len_p;
542f15c2684Sbluhm if (m->m_pkthdr.len < mlen) {
54359c8e5feSderaadt m_freem(m);
54459c8e5feSderaadt return (NULL);
54559c8e5feSderaadt }
546df930be7Sderaadt m_copydata(m, 4, slen, str);
547df930be7Sderaadt m_adj(m, mlen);
548df930be7Sderaadt
549df930be7Sderaadt str[slen] = '\0';
550df930be7Sderaadt *len_p = slen;
551df930be7Sderaadt
552df930be7Sderaadt return (m);
553df930be7Sderaadt }
554df930be7Sderaadt
555df930be7Sderaadt
556df930be7Sderaadt /*
557df930be7Sderaadt * Inet address in RPC messages
558df930be7Sderaadt * (Note, really four ints, NOT chars. Blech.)
559df930be7Sderaadt */
560df930be7Sderaadt struct xdr_inaddr {
561df930be7Sderaadt u_int32_t atype;
562df930be7Sderaadt u_int32_t addr[4];
563df930be7Sderaadt };
564df930be7Sderaadt
565df930be7Sderaadt struct mbuf *
xdr_inaddr_encode(struct in_addr * ia)566906a9d53Sjsg xdr_inaddr_encode(struct in_addr *ia)
567df930be7Sderaadt {
568df930be7Sderaadt struct mbuf *m;
569df930be7Sderaadt struct xdr_inaddr *xi;
570df930be7Sderaadt u_int8_t *cp;
571df930be7Sderaadt u_int32_t *ip;
572df930be7Sderaadt
573df930be7Sderaadt m = m_get(M_WAIT, MT_DATA);
574df930be7Sderaadt xi = mtod(m, struct xdr_inaddr *);
575df930be7Sderaadt m->m_len = sizeof(*xi);
576df930be7Sderaadt xi->atype = txdr_unsigned(1);
577df930be7Sderaadt ip = xi->addr;
578df930be7Sderaadt cp = (u_int8_t *)&ia->s_addr;
579df930be7Sderaadt *ip++ = txdr_unsigned(*cp++);
580df930be7Sderaadt *ip++ = txdr_unsigned(*cp++);
581df930be7Sderaadt *ip++ = txdr_unsigned(*cp++);
582df930be7Sderaadt *ip++ = txdr_unsigned(*cp++);
583df930be7Sderaadt
584df930be7Sderaadt return (m);
585df930be7Sderaadt }
586df930be7Sderaadt
587df930be7Sderaadt struct mbuf *
xdr_inaddr_decode(struct mbuf * m,struct in_addr * ia)588906a9d53Sjsg xdr_inaddr_decode(struct mbuf *m, struct in_addr *ia)
589df930be7Sderaadt {
590df930be7Sderaadt struct xdr_inaddr *xi;
591df930be7Sderaadt u_int8_t *cp;
592df930be7Sderaadt u_int32_t *ip;
593df930be7Sderaadt
594df930be7Sderaadt if (m->m_len < sizeof(*xi)) {
595df930be7Sderaadt m = m_pullup(m, sizeof(*xi));
596df930be7Sderaadt if (m == NULL)
597df930be7Sderaadt return (NULL);
598df930be7Sderaadt }
599df930be7Sderaadt xi = mtod(m, struct xdr_inaddr *);
600df930be7Sderaadt if (xi->atype != txdr_unsigned(1)) {
601df930be7Sderaadt ia->s_addr = INADDR_ANY;
602df930be7Sderaadt goto out;
603df930be7Sderaadt }
604df930be7Sderaadt ip = xi->addr;
605df930be7Sderaadt cp = (u_int8_t *)&ia->s_addr;
606df930be7Sderaadt *cp++ = fxdr_unsigned(u_int8_t, *ip++);
607df930be7Sderaadt *cp++ = fxdr_unsigned(u_int8_t, *ip++);
608df930be7Sderaadt *cp++ = fxdr_unsigned(u_int8_t, *ip++);
609df930be7Sderaadt *cp++ = fxdr_unsigned(u_int8_t, *ip++);
610df930be7Sderaadt
611df930be7Sderaadt out:
612df930be7Sderaadt m_adj(m, sizeof(*xi));
613df930be7Sderaadt return (m);
614df930be7Sderaadt }
615