We only need to spend CPU computing a new error string IFF there was an error
[deb_libnfs.git] / lib / pdu.c
CommitLineData
84004dbf
RS
1/*
2 Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as published by
6 the Free Software Foundation; either version 2.1 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this program; if not, see <http://www.gnu.org/licenses/>.
16*/
72897005
RS
17#ifdef HAVE_CONFIG_H
18#include "config.h"
19#endif
20
108c622a
RS
21#ifdef AROS
22#include "aros_compat.h"
23#endif
24
a8a1b858
M
25#ifdef WIN32
26#include "win32_compat.h"
bff8fe46 27#endif
6874f61e 28
72897005
RS
29#ifdef HAVE_NETINET_IN_H
30#include <netinet/in.h>
31#endif
32
7057e733
RS
33#ifdef HAVE_SYS_SOCKET_H
34#include <sys/socket.h>
35#endif
36
bff8fe46
RS
37#ifdef HAVE_STRINGS_H
38#include <strings.h>
39#endif
40
6874f61e 41#include <stdio.h>
98f5fee8 42#include <stdlib.h>
763cd6e3 43#include <string.h>
f3a75078 44#include <assert.h>
a669857d 45#include <errno.h>
84004dbf 46#include "slist.h"
763cd6e3 47#include "libnfs-zdr.h"
84004dbf
RS
48#include "libnfs.h"
49#include "libnfs-raw.h"
50#include "libnfs-private.h"
51
763cd6e3 52struct rpc_pdu *rpc_allocate_pdu(struct rpc_context *rpc, int program, int version, int procedure, rpc_cb cb, void *private_data, zdrproc_t zdr_decode_fn, int zdr_decode_bufsize)
84004dbf
RS
53{
54 struct rpc_pdu *pdu;
55 struct rpc_msg msg;
56
f3a75078 57 assert(rpc->magic == RPC_CONTEXT_MAGIC);
84004dbf
RS
58
59 pdu = malloc(sizeof(struct rpc_pdu));
60 if (pdu == NULL) {
1896d37b 61 rpc_set_error(rpc, "Out of memory: Failed to allocate pdu structure");
84004dbf
RS
62 return NULL;
63 }
ea98629a 64 memset(pdu, 0, sizeof(struct rpc_pdu));
84004dbf
RS
65 pdu->xid = rpc->xid++;
66 pdu->cb = cb;
67 pdu->private_data = private_data;
763cd6e3
RS
68 pdu->zdr_decode_fn = zdr_decode_fn;
69 pdu->zdr_decode_bufsize = zdr_decode_bufsize;
84004dbf 70
763cd6e3 71 zdrmem_create(&pdu->zdr, rpc->encodebuf, rpc->encodebuflen, ZDR_ENCODE);
a1992412 72 if (rpc->is_udp == 0) {
763cd6e3 73 zdr_setpos(&pdu->zdr, 4); /* skip past the record marker */
a1992412 74 }
84004dbf 75
ea98629a 76 memset(&msg, 0, sizeof(struct rpc_msg));
aab6538b
RS
77 msg.xid = pdu->xid;
78 msg.direction = CALL;
79 msg.body.cbody.rpcvers = RPC_MSG_VERSION;
80 msg.body.cbody.prog = program;
81 msg.body.cbody.vers = version;
82 msg.body.cbody.proc = procedure;
83 msg.body.cbody.cred = rpc->auth->ah_cred;
84 msg.body.cbody.verf = rpc->auth->ah_verf;
84004dbf 85
f0cb8042
RS
86 if (zdr_callmsg(rpc, &pdu->zdr, &msg) == 0) {
87 rpc_set_error(rpc, "zdr_callmsg failed with %s",
88 rpc_get_error(rpc));
763cd6e3 89 zdr_destroy(&pdu->zdr);
84004dbf
RS
90 free(pdu);
91 return NULL;
92 }
93
94 return pdu;
95}
96
f3a75078 97void rpc_free_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu)
84004dbf 98{
f3a75078
RS
99 assert(rpc->magic == RPC_CONTEXT_MAGIC);
100
84004dbf
RS
101 if (pdu->outdata.data != NULL) {
102 free(pdu->outdata.data);
103 pdu->outdata.data = NULL;
104 }
105
763cd6e3
RS
106 if (pdu->zdr_decode_buf != NULL) {
107 zdr_free(pdu->zdr_decode_fn, pdu->zdr_decode_buf);
108 free(pdu->zdr_decode_buf);
109 pdu->zdr_decode_buf = NULL;
84004dbf
RS
110 }
111
763cd6e3 112 zdr_destroy(&pdu->zdr);
df5af25f 113
84004dbf
RS
114 free(pdu);
115}
116
3b943d2f
RS
117void rpc_set_next_xid(struct rpc_context *rpc, uint32_t xid)
118{
119 rpc->xid = xid;
120}
84004dbf
RS
121
122int rpc_queue_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu)
123{
124 int size, recordmarker;
125
f3a75078
RS
126 assert(rpc->magic == RPC_CONTEXT_MAGIC);
127
763cd6e3 128 size = zdr_getpos(&pdu->zdr);
84004dbf 129
a669857d
RS
130 /* for udp we dont queue, we just send it straight away */
131 if (rpc->is_udp != 0) {
763cd6e3 132// XXX add a rpc->udp_dest_sock_size and get rid of sys/socket.h and netinet/in.h
a669857d
RS
133 if (sendto(rpc->fd, rpc->encodebuf, size, MSG_DONTWAIT, rpc->udp_dest, sizeof(struct sockaddr_in)) < 0) {
134 rpc_set_error(rpc, "Sendto failed with errno %s", strerror(errno));
135 rpc_free_pdu(rpc, pdu);
136 return -1;
137 }
138 SLIST_ADD_END(&rpc->waitpdu, pdu);
139 return 0;
140 }
141
84004dbf 142 /* write recordmarker */
763cd6e3 143 zdr_setpos(&pdu->zdr, 0);
84004dbf 144 recordmarker = (size - 4) | 0x80000000;
763cd6e3 145 zdr_int(&pdu->zdr, &recordmarker);
84004dbf
RS
146
147 pdu->outdata.size = size;
148 pdu->outdata.data = malloc(pdu->outdata.size);
149 if (pdu->outdata.data == NULL) {
150 rpc_set_error(rpc, "Out of memory. Failed to allocate buffer for pdu\n");
151 rpc_free_pdu(rpc, pdu);
152 return -1;
153 }
154
155 memcpy(pdu->outdata.data, rpc->encodebuf, pdu->outdata.size);
156 SLIST_ADD_END(&rpc->outqueue, pdu);
157
158 return 0;
159}
160
161int rpc_get_pdu_size(char *buf)
162{
163 uint32_t size;
164
165 size = ntohl(*(uint32_t *)buf);
166
84004dbf
RS
167 return (size & 0x7fffffff) + 4;
168}
169
763cd6e3 170static int rpc_process_reply(struct rpc_context *rpc, struct rpc_pdu *pdu, ZDR *zdr)
84004dbf
RS
171{
172 struct rpc_msg msg;
173
f3a75078
RS
174 assert(rpc->magic == RPC_CONTEXT_MAGIC);
175
ea98629a 176 memset(&msg, 0, sizeof(struct rpc_msg));
aab6538b 177 msg.body.rbody.reply.areply.verf = _null_auth;
763cd6e3
RS
178 if (pdu->zdr_decode_bufsize > 0) {
179 if (pdu->zdr_decode_buf != NULL) {
180 free(pdu->zdr_decode_buf);
1b9917b8 181 }
763cd6e3
RS
182 pdu->zdr_decode_buf = malloc(pdu->zdr_decode_bufsize);
183 if (pdu->zdr_decode_buf == NULL) {
f0cb8042
RS
184 rpc_set_error(rpc, "Failed to allocate memory for "
185 "zdr_encode_buf in rpc_process_reply");
186 pdu->cb(rpc, RPC_STATUS_ERROR, "Failed to allocate "
187 "buffer for decoding of ZDR reply",
188 pdu->private_data);
84004dbf
RS
189 return 0;
190 }
763cd6e3 191 memset(pdu->zdr_decode_buf, 0, pdu->zdr_decode_bufsize);
84004dbf 192 }
aab6538b
RS
193 msg.body.rbody.reply.areply.reply_data.results.where = pdu->zdr_decode_buf;
194 msg.body.rbody.reply.areply.reply_data.results.proc = pdu->zdr_decode_fn;
84004dbf 195
f0cb8042
RS
196 if (zdr_replymsg(rpc, zdr, &msg) == 0) {
197 rpc_set_error(rpc, "zdr_replymsg failed in rpc_process_reply: "
198 "%s", rpc_get_error(rpc));
199 pdu->cb(rpc, RPC_STATUS_ERROR, "Message rejected by server",
200 pdu->private_data);
763cd6e3
RS
201 if (pdu->zdr_decode_buf != NULL) {
202 free(pdu->zdr_decode_buf);
203 pdu->zdr_decode_buf = NULL;
84004dbf
RS
204 }
205 return 0;
206 }
aab6538b 207 if (msg.body.rbody.stat != MSG_ACCEPTED) {
84004dbf
RS
208 pdu->cb(rpc, RPC_STATUS_ERROR, "RPC Packet not accepted by the server", pdu->private_data);
209 return 0;
210 }
aab6538b 211 switch (msg.body.rbody.reply.areply.stat) {
84004dbf 212 case SUCCESS:
763cd6e3 213 pdu->cb(rpc, RPC_STATUS_SUCCESS, pdu->zdr_decode_buf, pdu->private_data);
84004dbf
RS
214 break;
215 case PROG_UNAVAIL:
216 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Program not available", pdu->private_data);
217 break;
218 case PROG_MISMATCH:
219 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Program version mismatch", pdu->private_data);
220 break;
221 case PROC_UNAVAIL:
222 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Procedure not available", pdu->private_data);
223 break;
224 case GARBAGE_ARGS:
225 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Garbage arguments", pdu->private_data);
226 break;
227 case SYSTEM_ERR:
228 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: System Error", pdu->private_data);
229 break;
230 default:
231 pdu->cb(rpc, RPC_STATUS_ERROR, "Unknown rpc response from server", pdu->private_data);
232 break;
233 }
234
235 return 0;
236}
237
238int rpc_process_pdu(struct rpc_context *rpc, char *buf, int size)
239{
240 struct rpc_pdu *pdu;
763cd6e3 241 ZDR zdr;
d678b73e 242 int pos, recordmarker = 0;
b93082da 243 uint32_t xid;
d678b73e 244 char *reasbuf = NULL;
84004dbf 245
f3a75078
RS
246 assert(rpc->magic == RPC_CONTEXT_MAGIC);
247
763cd6e3 248 memset(&zdr, 0, sizeof(ZDR));
84004dbf 249
763cd6e3 250 zdrmem_create(&zdr, buf, size, ZDR_DECODE);
a669857d 251 if (rpc->is_udp == 0) {
763cd6e3
RS
252 if (zdr_int(&zdr, &recordmarker) == 0) {
253 rpc_set_error(rpc, "zdr_int reading recordmarker failed");
254 zdr_destroy(&zdr);
a669857d
RS
255 return -1;
256 }
d678b73e 257 if (!(recordmarker&0x80000000)) {
763cd6e3 258 zdr_destroy(&zdr);
d678b73e
RS
259 if (rpc_add_fragment(rpc, buf+4, size-4) != 0) {
260 rpc_set_error(rpc, "Failed to queue fragment for reassembly.");
261 return -1;
262 }
263 return 0;
264 }
84004dbf 265 }
d678b73e
RS
266
267 /* reassembly */
268 if (recordmarker != 0 && rpc->fragments != NULL) {
269 struct rpc_fragment *fragment;
574095b9 270 uint32_t total = size - 4;
d678b73e
RS
271 char *ptr;
272
763cd6e3 273 zdr_destroy(&zdr);
d678b73e
RS
274 for (fragment = rpc->fragments; fragment; fragment = fragment->next) {
275 total += fragment->size;
276 }
277
278 reasbuf = malloc(total);
279 if (reasbuf == NULL) {
280 rpc_set_error(rpc, "Failed to reassemble PDU");
281 rpc_free_all_fragments(rpc);
282 return -1;
283 }
284 ptr = reasbuf;
285 for (fragment = rpc->fragments; fragment; fragment = fragment->next) {
286 memcpy(ptr, fragment->data, fragment->size);
287 ptr += fragment->size;
288 }
289 memcpy(ptr, buf + 4, size - 4);
763cd6e3 290 zdrmem_create(&zdr, reasbuf, total, ZDR_DECODE);
d678b73e
RS
291 rpc_free_all_fragments(rpc);
292 }
293
763cd6e3
RS
294 pos = zdr_getpos(&zdr);
295 if (zdr_int(&zdr, (int *)&xid) == 0) {
296 rpc_set_error(rpc, "zdr_int reading xid failed");
297 zdr_destroy(&zdr);
d678b73e
RS
298 if (reasbuf != NULL) {
299 free(reasbuf);
300 }
84004dbf
RS
301 return -1;
302 }
763cd6e3 303 zdr_setpos(&zdr, pos);
84004dbf
RS
304
305 for (pdu=rpc->waitpdu; pdu; pdu=pdu->next) {
306 if (pdu->xid != xid) {
307 continue;
308 }
a669857d
RS
309 if (rpc->is_udp == 0 || rpc->is_broadcast == 0) {
310 SLIST_REMOVE(&rpc->waitpdu, pdu);
311 }
763cd6e3 312 if (rpc_process_reply(rpc, pdu, &zdr) != 0) {
1896d37b 313 rpc_set_error(rpc, "rpc_procdess_reply failed");
84004dbf 314 }
763cd6e3 315 zdr_destroy(&zdr);
a669857d
RS
316 if (rpc->is_udp == 0 || rpc->is_broadcast == 0) {
317 rpc_free_pdu(rpc, pdu);
318 }
d678b73e
RS
319 if (reasbuf != NULL) {
320 free(reasbuf);
321 }
84004dbf
RS
322 return 0;
323 }
1896d37b 324 rpc_set_error(rpc, "No matching pdu found for xid:%d", xid);
763cd6e3 325 zdr_destroy(&zdr);
d678b73e
RS
326 if (reasbuf != NULL) {
327 free(reasbuf);
328 }
84004dbf
RS
329 return -1;
330}
331