nfs-cp: don't leave file_context->url unitialized
[deb_libnfs.git] / lib / pdu.c
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 */
17 #ifdef HAVE_CONFIG_H
18 #include "config.h"
19 #endif
20
21 #ifdef AROS
22 #include "aros_compat.h"
23 #endif
24
25 #ifdef WIN32
26 #include "win32_compat.h"
27 #endif
28
29 #ifdef HAVE_NETINET_IN_H
30 #include <netinet/in.h>
31 #endif
32
33 #ifdef HAVE_SYS_SOCKET_H
34 #include <sys/socket.h>
35 #endif
36
37 #ifdef HAVE_STRINGS_H
38 #include <strings.h>
39 #endif
40
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <assert.h>
45 #include <errno.h>
46 #include "slist.h"
47 #include "libnfs-zdr.h"
48 #include "libnfs.h"
49 #include "libnfs-raw.h"
50 #include "libnfs-private.h"
51
52 struct 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)
53 {
54 struct rpc_pdu *pdu;
55 struct rpc_msg msg;
56
57 assert(rpc->magic == RPC_CONTEXT_MAGIC);
58
59 pdu = malloc(sizeof(struct rpc_pdu));
60 if (pdu == NULL) {
61 rpc_set_error(rpc, "Out of memory: Failed to allocate pdu structure");
62 return NULL;
63 }
64 memset(pdu, 0, sizeof(struct rpc_pdu));
65 pdu->xid = rpc->xid++;
66 pdu->cb = cb;
67 pdu->private_data = private_data;
68 pdu->zdr_decode_fn = zdr_decode_fn;
69 pdu->zdr_decode_bufsize = zdr_decode_bufsize;
70
71 zdrmem_create(&pdu->zdr, rpc->encodebuf, rpc->encodebuflen, ZDR_ENCODE);
72 if (rpc->is_udp == 0) {
73 zdr_setpos(&pdu->zdr, 4); /* skip past the record marker */
74 }
75
76 memset(&msg, 0, sizeof(struct rpc_msg));
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;
85
86 if (zdr_callmsg(&pdu->zdr, &msg) == 0) {
87 rpc_set_error(rpc, "zdr_callmsg failed");
88 zdr_destroy(&pdu->zdr);
89 free(pdu);
90 return NULL;
91 }
92
93 return pdu;
94 }
95
96 void rpc_free_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu)
97 {
98 assert(rpc->magic == RPC_CONTEXT_MAGIC);
99
100 if (pdu->outdata.data != NULL) {
101 free(pdu->outdata.data);
102 pdu->outdata.data = NULL;
103 }
104
105 if (pdu->zdr_decode_buf != NULL) {
106 zdr_free(pdu->zdr_decode_fn, pdu->zdr_decode_buf);
107 free(pdu->zdr_decode_buf);
108 pdu->zdr_decode_buf = NULL;
109 }
110
111 zdr_destroy(&pdu->zdr);
112
113 free(pdu);
114 }
115
116 void rpc_set_next_xid(struct rpc_context *rpc, uint32_t xid)
117 {
118 rpc->xid = xid;
119 }
120
121 int rpc_queue_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu)
122 {
123 int size, recordmarker;
124
125 assert(rpc->magic == RPC_CONTEXT_MAGIC);
126
127 size = zdr_getpos(&pdu->zdr);
128
129 /* for udp we dont queue, we just send it straight away */
130 if (rpc->is_udp != 0) {
131 // XXX add a rpc->udp_dest_sock_size and get rid of sys/socket.h and netinet/in.h
132 if (sendto(rpc->fd, rpc->encodebuf, size, MSG_DONTWAIT, rpc->udp_dest, sizeof(struct sockaddr_in)) < 0) {
133 rpc_set_error(rpc, "Sendto failed with errno %s", strerror(errno));
134 rpc_free_pdu(rpc, pdu);
135 return -1;
136 }
137 SLIST_ADD_END(&rpc->waitpdu, pdu);
138 return 0;
139 }
140
141 /* write recordmarker */
142 zdr_setpos(&pdu->zdr, 0);
143 recordmarker = (size - 4) | 0x80000000;
144 zdr_int(&pdu->zdr, &recordmarker);
145
146 pdu->outdata.size = size;
147 pdu->outdata.data = malloc(pdu->outdata.size);
148 if (pdu->outdata.data == NULL) {
149 rpc_set_error(rpc, "Out of memory. Failed to allocate buffer for pdu\n");
150 rpc_free_pdu(rpc, pdu);
151 return -1;
152 }
153
154 memcpy(pdu->outdata.data, rpc->encodebuf, pdu->outdata.size);
155 SLIST_ADD_END(&rpc->outqueue, pdu);
156
157 return 0;
158 }
159
160 int rpc_get_pdu_size(char *buf)
161 {
162 uint32_t size;
163
164 size = ntohl(*(uint32_t *)buf);
165
166 return (size & 0x7fffffff) + 4;
167 }
168
169 static int rpc_process_reply(struct rpc_context *rpc, struct rpc_pdu *pdu, ZDR *zdr)
170 {
171 struct rpc_msg msg;
172
173 assert(rpc->magic == RPC_CONTEXT_MAGIC);
174
175 memset(&msg, 0, sizeof(struct rpc_msg));
176 msg.body.rbody.reply.areply.verf = _null_auth;
177 if (pdu->zdr_decode_bufsize > 0) {
178 if (pdu->zdr_decode_buf != NULL) {
179 free(pdu->zdr_decode_buf);
180 }
181 pdu->zdr_decode_buf = malloc(pdu->zdr_decode_bufsize);
182 if (pdu->zdr_decode_buf == NULL) {
183 rpc_set_error(rpc, "zdr_replymsg failed in portmap_getport_reply");
184 pdu->cb(rpc, RPC_STATUS_ERROR, "Failed to allocate buffer for decoding of ZDR reply", pdu->private_data);
185 return 0;
186 }
187 memset(pdu->zdr_decode_buf, 0, pdu->zdr_decode_bufsize);
188 }
189 msg.body.rbody.reply.areply.reply_data.results.where = pdu->zdr_decode_buf;
190 msg.body.rbody.reply.areply.reply_data.results.proc = pdu->zdr_decode_fn;
191
192 if (zdr_replymsg(zdr, &msg) == 0) {
193 rpc_set_error(rpc, "zdr_replymsg failed in portmap_getport_reply");
194 pdu->cb(rpc, RPC_STATUS_ERROR, "Message rejected by server", pdu->private_data);
195 if (pdu->zdr_decode_buf != NULL) {
196 free(pdu->zdr_decode_buf);
197 pdu->zdr_decode_buf = NULL;
198 }
199 return 0;
200 }
201 if (msg.body.rbody.stat != MSG_ACCEPTED) {
202 pdu->cb(rpc, RPC_STATUS_ERROR, "RPC Packet not accepted by the server", pdu->private_data);
203 return 0;
204 }
205 switch (msg.body.rbody.reply.areply.stat) {
206 case SUCCESS:
207 pdu->cb(rpc, RPC_STATUS_SUCCESS, pdu->zdr_decode_buf, pdu->private_data);
208 break;
209 case PROG_UNAVAIL:
210 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Program not available", pdu->private_data);
211 break;
212 case PROG_MISMATCH:
213 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Program version mismatch", pdu->private_data);
214 break;
215 case PROC_UNAVAIL:
216 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Procedure not available", pdu->private_data);
217 break;
218 case GARBAGE_ARGS:
219 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Garbage arguments", pdu->private_data);
220 break;
221 case SYSTEM_ERR:
222 pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: System Error", pdu->private_data);
223 break;
224 default:
225 pdu->cb(rpc, RPC_STATUS_ERROR, "Unknown rpc response from server", pdu->private_data);
226 break;
227 }
228
229 return 0;
230 }
231
232 int rpc_process_pdu(struct rpc_context *rpc, char *buf, int size)
233 {
234 struct rpc_pdu *pdu;
235 ZDR zdr;
236 int pos, recordmarker = 0;
237 uint32_t xid;
238 char *reasbuf = NULL;
239
240 assert(rpc->magic == RPC_CONTEXT_MAGIC);
241
242 memset(&zdr, 0, sizeof(ZDR));
243
244 zdrmem_create(&zdr, buf, size, ZDR_DECODE);
245 if (rpc->is_udp == 0) {
246 if (zdr_int(&zdr, &recordmarker) == 0) {
247 rpc_set_error(rpc, "zdr_int reading recordmarker failed");
248 zdr_destroy(&zdr);
249 return -1;
250 }
251 if (!(recordmarker&0x80000000)) {
252 zdr_destroy(&zdr);
253 if (rpc_add_fragment(rpc, buf+4, size-4) != 0) {
254 rpc_set_error(rpc, "Failed to queue fragment for reassembly.");
255 return -1;
256 }
257 return 0;
258 }
259 }
260
261 /* reassembly */
262 if (recordmarker != 0 && rpc->fragments != NULL) {
263 struct rpc_fragment *fragment;
264 uint32_t total = size - 4;
265 char *ptr;
266
267 zdr_destroy(&zdr);
268 for (fragment = rpc->fragments; fragment; fragment = fragment->next) {
269 total += fragment->size;
270 }
271
272 reasbuf = malloc(total);
273 if (reasbuf == NULL) {
274 rpc_set_error(rpc, "Failed to reassemble PDU");
275 rpc_free_all_fragments(rpc);
276 return -1;
277 }
278 ptr = reasbuf;
279 for (fragment = rpc->fragments; fragment; fragment = fragment->next) {
280 memcpy(ptr, fragment->data, fragment->size);
281 ptr += fragment->size;
282 }
283 memcpy(ptr, buf + 4, size - 4);
284 zdrmem_create(&zdr, reasbuf, total, ZDR_DECODE);
285 rpc_free_all_fragments(rpc);
286 }
287
288 pos = zdr_getpos(&zdr);
289 if (zdr_int(&zdr, (int *)&xid) == 0) {
290 rpc_set_error(rpc, "zdr_int reading xid failed");
291 zdr_destroy(&zdr);
292 if (reasbuf != NULL) {
293 free(reasbuf);
294 }
295 return -1;
296 }
297 zdr_setpos(&zdr, pos);
298
299 for (pdu=rpc->waitpdu; pdu; pdu=pdu->next) {
300 if (pdu->xid != xid) {
301 continue;
302 }
303 if (rpc->is_udp == 0 || rpc->is_broadcast == 0) {
304 SLIST_REMOVE(&rpc->waitpdu, pdu);
305 }
306 if (rpc_process_reply(rpc, pdu, &zdr) != 0) {
307 rpc_set_error(rpc, "rpc_procdess_reply failed");
308 }
309 zdr_destroy(&zdr);
310 if (rpc->is_udp == 0 || rpc->is_broadcast == 0) {
311 rpc_free_pdu(rpc, pdu);
312 }
313 if (reasbuf != NULL) {
314 free(reasbuf);
315 }
316 return 0;
317 }
318 rpc_set_error(rpc, "No matching pdu found for xid:%d", xid);
319 zdr_destroy(&zdr);
320 if (reasbuf != NULL) {
321 free(reasbuf);
322 }
323 return -1;
324 }
325