add tcp-syncnt URL param to adjust TCP_SYNCNT sockopt
[deb_libnfs.git] / lib / init.c
1 /*
2 Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
3
4
5
6 This program is distributed in the hope that it will be useful,
7 but WITHOUT ANY WARRANTY; without even the implied warranty of
8 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9 GNU Lesser General Public License for more details.
10
11 You should have received a copy of the GNU Lesser General Public License
12 along with this program; if not, see <http://www.gnu.org/licenses/>.
13 */
14 #ifdef HAVE_CONFIG_H
15 #include "config.h"
16 #endif
17
18 #ifdef AROS
19 #include "aros_compat.h"
20 #endif
21
22 #ifdef WIN32
23 #include "win32_compat.h"
24 #endif
25
26 #define _GNU_SOURCE
27
28 #ifdef HAVE_UNISTD_H
29 #include <unistd.h>
30 #endif
31
32 #ifdef HAVE_STRINGS_H
33 #include <strings.h>
34 #endif
35
36 #include <stdio.h>
37 #include <stdarg.h>
38 #include <string.h>
39 #include <stdlib.h>
40 #include <assert.h>
41 #include <time.h>
42 #include "slist.h"
43 #include "libnfs-zdr.h"
44 #include "libnfs.h"
45 #include "libnfs-raw.h"
46 #include "libnfs-private.h"
47
48 struct rpc_context *rpc_init_context(void)
49 {
50 struct rpc_context *rpc;
51 static uint32_t salt = 0;
52
53 rpc = malloc(sizeof(struct rpc_context));
54 if (rpc == NULL) {
55 return NULL;
56 }
57 memset(rpc, 0, sizeof(struct rpc_context));
58
59 rpc->magic = RPC_CONTEXT_MAGIC;
60 rpc->encodebuflen = 65536;
61 rpc->encodebuf = malloc(rpc->encodebuflen);
62 if (rpc->encodebuf == NULL) {
63 free(rpc);
64 return NULL;
65 }
66
67 rpc->auth = authunix_create_default();
68 if (rpc->auth == NULL) {
69 free(rpc->encodebuf);
70 free(rpc);
71 return NULL;
72 }
73 rpc->xid = salt + time(NULL) + getpid() << 16;
74 salt += 0x01000000;
75 rpc->fd = -1;
76 rpc->tcp_syncnt = RPC_PARAM_UNDEFINED;
77
78 return rpc;
79 }
80
81
82 struct rpc_context *rpc_init_udp_context(void)
83 {
84 struct rpc_context *rpc;
85
86 rpc = rpc_init_context();
87 if (rpc != NULL) {
88 rpc->is_udp = 1;
89 }
90
91 return rpc;
92 }
93
94 void rpc_set_auth(struct rpc_context *rpc, struct AUTH *auth)
95 {
96 assert(rpc->magic == RPC_CONTEXT_MAGIC);
97
98 if (rpc->auth != NULL) {
99 auth_destroy(rpc->auth);
100 }
101 rpc->auth = auth;
102 }
103
104
105 void rpc_set_error(struct rpc_context *rpc, char *error_string, ...)
106 {
107 va_list ap;
108
109 assert(rpc->magic == RPC_CONTEXT_MAGIC);
110
111 if (rpc->error_string != NULL) {
112 free(rpc->error_string);
113 }
114 va_start(ap, error_string);
115 rpc->error_string = malloc(1024);
116 vsnprintf(rpc->error_string, 1024, error_string, ap);
117 va_end(ap);
118 }
119
120 char *rpc_get_error(struct rpc_context *rpc)
121 {
122 assert(rpc->magic == RPC_CONTEXT_MAGIC);
123
124 return rpc->error_string;
125 }
126
127 void rpc_error_all_pdus(struct rpc_context *rpc, char *error)
128 {
129 struct rpc_pdu *pdu;
130
131 assert(rpc->magic == RPC_CONTEXT_MAGIC);
132
133 while((pdu = rpc->outqueue) != NULL) {
134 pdu->cb(rpc, RPC_STATUS_ERROR, error, pdu->private_data);
135 SLIST_REMOVE(&rpc->outqueue, pdu);
136 rpc_free_pdu(rpc, pdu);
137 }
138 while((pdu = rpc->waitpdu) != NULL) {
139 pdu->cb(rpc, RPC_STATUS_ERROR, error, pdu->private_data);
140 SLIST_REMOVE(&rpc->waitpdu, pdu);
141 rpc_free_pdu(rpc, pdu);
142 }
143 }
144
145 static void rpc_free_fragment(struct rpc_fragment *fragment)
146 {
147 if (fragment->data != NULL) {
148 free(fragment->data);
149 }
150 free(fragment);
151 }
152
153 void rpc_free_all_fragments(struct rpc_context *rpc)
154 {
155 assert(rpc->magic == RPC_CONTEXT_MAGIC);
156
157 while (rpc->fragments != NULL) {
158 struct rpc_fragment *fragment = rpc->fragments;
159
160 SLIST_REMOVE(&rpc->fragments, fragment);
161 rpc_free_fragment(fragment);
162 }
163 }
164
165 int rpc_add_fragment(struct rpc_context *rpc, char *data, uint64_t size)
166 {
167 struct rpc_fragment *fragment;
168
169 assert(rpc->magic == RPC_CONTEXT_MAGIC);
170
171 fragment = malloc(sizeof(struct rpc_fragment));
172 if (fragment == NULL) {
173 return -1;
174 }
175
176 fragment->size = size;
177 fragment->data = malloc(fragment->size);
178 if(fragment->data == NULL) {
179 free(fragment);
180 return -1;
181 }
182
183 memcpy(fragment->data, data, fragment->size);
184 SLIST_ADD_END(&rpc->fragments, fragment);
185 return 0;
186 }
187
188 void rpc_destroy_context(struct rpc_context *rpc)
189 {
190 struct rpc_pdu *pdu;
191
192 assert(rpc->magic == RPC_CONTEXT_MAGIC);
193
194 while((pdu = rpc->outqueue) != NULL) {
195 pdu->cb(rpc, RPC_STATUS_CANCEL, NULL, pdu->private_data);
196 SLIST_REMOVE(&rpc->outqueue, pdu);
197 rpc_free_pdu(rpc, pdu);
198 }
199 while((pdu = rpc->waitpdu) != NULL) {
200 pdu->cb(rpc, RPC_STATUS_CANCEL, NULL, pdu->private_data);
201 SLIST_REMOVE(&rpc->waitpdu, pdu);
202 rpc_free_pdu(rpc, pdu);
203 }
204
205 rpc_free_all_fragments(rpc);
206
207 auth_destroy(rpc->auth);
208 rpc->auth =NULL;
209
210 if (rpc->fd != -1) {
211 close(rpc->fd);
212 }
213
214 if (rpc->encodebuf != NULL) {
215 free(rpc->encodebuf);
216 rpc->encodebuf = NULL;
217 }
218
219 if (rpc->error_string != NULL) {
220 free(rpc->error_string);
221 rpc->error_string = NULL;
222 }
223
224 if (rpc->udp_dest != NULL) {
225 free(rpc->udp_dest);
226 rpc->udp_dest = NULL;
227 }
228
229 rpc->magic = 0;
230 free(rpc);
231 }
232
233