Fix extra compiler warnings
[project/uclient.git] / uclient.c
1 /*
2 * uclient - ustream based protocol client library
3 *
4 * Copyright (C) 2014 Felix Fietkau <nbd@openwrt.org>
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 #include <arpa/inet.h>
19 #include <libubox/ustream-ssl.h>
20 #include "uclient.h"
21 #include "uclient-utils.h"
22 #include "uclient-backend.h"
23
24 char *uclient_get_addr(char *dest, int *port, union uclient_addr *a)
25 {
26 int portval;
27 void *ptr;
28
29 switch(a->sa.sa_family) {
30 case AF_INET:
31 ptr = &a->sin.sin_addr;
32 portval = a->sin.sin_port;
33 break;
34 case AF_INET6:
35 ptr = &a->sin6.sin6_addr;
36 portval = a->sin6.sin6_port;
37 break;
38 default:
39 return strcpy(dest, "Unknown");
40 }
41
42 inet_ntop(a->sa.sa_family, ptr, dest, INET6_ADDRSTRLEN);
43 if (port)
44 *port = ntohs(portval);
45
46 return dest;
47 }
48
49 static struct uclient_url *
50 __uclient_get_url(const struct uclient_backend *backend,
51 const char *host, int host_len,
52 const char *location, const char *auth_str)
53 {
54 struct uclient_url *url;
55 char *host_buf, *uri_buf, *auth_buf, *next;
56
57 url = calloc_a(sizeof(*url),
58 &host_buf, host_len + 1,
59 &uri_buf, strlen(location) + 1,
60 &auth_buf, auth_str ? strlen(auth_str) + 1 : 0);
61
62 if (!url)
63 return NULL;
64
65 url->backend = backend;
66 url->location = strcpy(uri_buf, location);
67 if (host)
68 url->host = strncpy(host_buf, host, host_len);
69
70 next = strchr(host_buf, '@');
71 if (next) {
72 *next = 0;
73 url->host = next + 1;
74
75 if (uclient_urldecode(host_buf, host_buf, false) < 0)
76 goto free;
77
78 url->auth = host_buf;
79 }
80
81 if (!url->auth && auth_str)
82 url->auth = strcpy(auth_buf, auth_str);
83
84 /* Literal IPv6 address */
85 if (*url->host == '[') {
86 url->host++;
87 next = strrchr(url->host, ']');
88 if (!next)
89 goto free;
90
91 *(next++) = 0;
92 if (*next == ':')
93 url->port = next + 1;
94 } else {
95 next = strrchr(url->host, ':');
96 if (next) {
97 *next = 0;
98 url->port = next + 1;
99 }
100 }
101
102 return url;
103
104 free:
105 free(url);
106 return NULL;
107 }
108
109 static const char *
110 uclient_split_host(const char *base, int *host_len)
111 {
112 char *next, *location;
113
114 next = strchr(base, '/');
115 if (next) {
116 location = next;
117 *host_len = next - base;
118 } else {
119 location = "/";
120 *host_len = strlen(base);
121 }
122
123 return location;
124 }
125
126 struct uclient_url __hidden *
127 uclient_get_url_location(struct uclient_url *url, const char *location)
128 {
129 struct uclient_url *new_url;
130 char *host_buf, *uri_buf, *auth_buf, *port_buf;
131 int host_len = strlen(url->host) + 1;
132 int auth_len = url->auth ? strlen(url->auth) + 1 : 0;
133 int port_len = url->port ? strlen(url->port) + 1 : 0;
134 int uri_len;
135
136 if (strstr(location, "://"))
137 return uclient_get_url(location, url->auth);
138
139 if (location[0] == '/')
140 uri_len = strlen(location) + 1;
141 else
142 uri_len = strlen(url->location) + strlen(location) + 2;
143
144 new_url = calloc_a(sizeof(*url),
145 &host_buf, host_len,
146 &port_buf, port_len,
147 &uri_buf, uri_len,
148 &auth_buf, auth_len);
149
150 if (!new_url)
151 return NULL;
152
153 new_url->backend = url->backend;
154 new_url->prefix = url->prefix;
155 new_url->host = strcpy(host_buf, url->host);
156 if (url->port)
157 new_url->port = strcpy(port_buf, url->port);
158 if (url->auth)
159 new_url->auth = strcpy(auth_buf, url->auth);
160
161 new_url->location = uri_buf;
162 if (location[0] == '/')
163 strcpy(uri_buf, location);
164 else {
165 int len = strcspn(url->location, "?#");
166 char *buf = uri_buf;
167
168 memcpy(buf, url->location, len);
169 if (buf[len - 1] != '/') {
170 buf[len] = '/';
171 len++;
172 }
173
174 buf += len;
175 strcpy(buf, location);
176 }
177
178 return new_url;
179 }
180
181 struct uclient_url __hidden *
182 uclient_get_url(const char *url_str, const char *auth_str)
183 {
184 static const struct uclient_backend *backends[] = {
185 &uclient_backend_http,
186 };
187
188 const struct uclient_backend *backend;
189 const char * const *prefix = NULL;
190 struct uclient_url *url;
191 const char *location;
192 int host_len;
193 unsigned int i;
194
195 for (i = 0; i < ARRAY_SIZE(backends); i++) {
196 int prefix_len = 0;
197
198 for (prefix = backends[i]->prefix; *prefix; prefix++) {
199 prefix_len = strlen(*prefix);
200
201 if (!strncmp(url_str, *prefix, prefix_len))
202 break;
203 }
204
205 if (!*prefix)
206 continue;
207
208 url_str += prefix_len;
209 backend = backends[i];
210 break;
211 }
212
213 if (!*prefix)
214 return NULL;
215
216 location = uclient_split_host(url_str, &host_len);
217 url = __uclient_get_url(backend, url_str, host_len, location, auth_str);
218 if (!url)
219 return NULL;
220
221 url->prefix = prefix - backend->prefix;
222 return url;
223 }
224
225 static void uclient_connection_timeout(struct uloop_timeout *timeout)
226 {
227 struct uclient *cl = container_of(timeout, struct uclient, connection_timeout);
228
229 if (cl->backend->disconnect)
230 cl->backend->disconnect(cl);
231
232 uclient_backend_set_error(cl, UCLIENT_ERROR_TIMEDOUT);
233 }
234
235 struct uclient *uclient_new(const char *url_str, const char *auth_str, const struct uclient_cb *cb)
236 {
237 struct uclient *cl;
238 struct uclient_url *url;
239
240 url = uclient_get_url(url_str, auth_str);
241 if (!url)
242 return NULL;
243
244 cl = url->backend->alloc();
245 if (!cl)
246 return NULL;
247
248 cl->backend = url->backend;
249 cl->cb = cb;
250 cl->url = url;
251 cl->timeout_msecs = UCLIENT_DEFAULT_TIMEOUT_MS;
252 cl->connection_timeout.cb = uclient_connection_timeout;
253
254 return cl;
255 }
256
257 int uclient_set_proxy_url(struct uclient *cl, const char *url_str, const char *auth_str)
258 {
259 const struct uclient_backend *backend = cl->backend;
260 struct uclient_url *url;
261 int host_len;
262 char *next, *host;
263
264 if (!backend->update_proxy_url)
265 return -1;
266
267 next = strstr(url_str, "://");
268 if (!next)
269 return -1;
270
271 host = next + 3;
272 uclient_split_host(host, &host_len);
273
274 url = __uclient_get_url(NULL, host, host_len, url_str, auth_str);
275 if (!url)
276 return -1;
277
278 free(cl->proxy_url);
279 cl->proxy_url = url;
280
281 if (backend->update_proxy_url)
282 backend->update_proxy_url(cl);
283
284 return 0;
285 }
286
287 int uclient_set_url(struct uclient *cl, const char *url_str, const char *auth_str)
288 {
289 const struct uclient_backend *backend = cl->backend;
290 struct uclient_url *url = cl->url;
291
292 url = uclient_get_url(url_str, auth_str);
293 if (!url)
294 return -1;
295
296 if (url->backend != cl->backend) {
297 free(url);
298 return -1;
299 }
300
301 free(cl->proxy_url);
302 cl->proxy_url = NULL;
303
304 free(cl->url);
305 cl->url = url;
306
307 if (backend->update_url)
308 backend->update_url(cl);
309
310 return 0;
311 }
312
313 int uclient_set_timeout(struct uclient *cl, int msecs)
314 {
315 if (msecs <= 0)
316 return -EINVAL;
317
318 cl->timeout_msecs = msecs;
319
320 return 0;
321 }
322
323 int uclient_connect(struct uclient *cl)
324 {
325 return cl->backend->connect(cl);
326 }
327
328 void uclient_free(struct uclient *cl)
329 {
330 struct uclient_url *url = cl->url;
331
332 if (cl->backend->free)
333 cl->backend->free(cl);
334 else
335 free(cl);
336
337 free(url);
338 }
339
340 int uclient_write(struct uclient *cl, const char *buf, int len)
341 {
342 if (!cl->backend->write)
343 return -1;
344
345 return cl->backend->write(cl, buf, len);
346 }
347
348 int uclient_request(struct uclient *cl)
349 {
350 int err;
351
352 if (!cl->backend->request)
353 return -1;
354
355 err = cl->backend->request(cl);
356 if (err)
357 return err;
358
359 uloop_timeout_set(&cl->connection_timeout, cl->timeout_msecs);
360
361 return 0;
362 }
363
364 int uclient_read(struct uclient *cl, char *buf, int len)
365 {
366 if (!cl->backend->read)
367 return -1;
368
369 return cl->backend->read(cl, buf, len);
370 }
371
372 void uclient_disconnect(struct uclient *cl)
373 {
374 uloop_timeout_cancel(&cl->connection_timeout);
375
376 if (!cl->backend->disconnect)
377 return;
378
379 cl->backend->disconnect(cl);
380 }
381
382 static void __uclient_backend_change_state(struct uloop_timeout *timeout)
383 {
384 struct uclient *cl = container_of(timeout, struct uclient, timeout);
385
386 if (cl->error_code && cl->cb->error)
387 cl->cb->error(cl, cl->error_code);
388 else if (cl->eof && cl->cb->data_eof)
389 cl->cb->data_eof(cl);
390 }
391
392 static void uclient_backend_change_state(struct uclient *cl)
393 {
394 cl->timeout.cb = __uclient_backend_change_state;
395 uloop_timeout_set(&cl->timeout, 1);
396 }
397
398 void __hidden uclient_backend_set_error(struct uclient *cl, int code)
399 {
400 if (cl->error_code)
401 return;
402
403 uloop_timeout_cancel(&cl->connection_timeout);
404 cl->error_code = code;
405 uclient_backend_change_state(cl);
406 }
407
408 void __hidden uclient_backend_set_eof(struct uclient *cl)
409 {
410 if (cl->eof || cl->error_code)
411 return;
412
413 uloop_timeout_cancel(&cl->connection_timeout);
414 cl->eof = true;
415 uclient_backend_change_state(cl);
416 }
417
418 void __hidden uclient_backend_reset_state(struct uclient *cl)
419 {
420 cl->data_eof = false;
421 cl->eof = false;
422 cl->error_code = 0;
423 uloop_timeout_cancel(&cl->timeout);
424 }
425
426 const char * uclient_strerror(unsigned err)
427 {
428 switch (err) {
429 case UCLIENT_ERROR_UNKNOWN:
430 return "unknown error";
431 case UCLIENT_ERROR_CONNECT:
432 return "connect failed";
433 case UCLIENT_ERROR_TIMEDOUT:
434 return "timeout";
435 case UCLIENT_ERROR_SSL_INVALID_CERT:
436 return "ssl invalid cert";
437 case UCLIENT_ERROR_SSL_CN_MISMATCH:
438 return "ssl cn mismatch";
439 case UCLIENT_ERROR_MISSING_SSL_CONTEXT:
440 return "missing ssl context";
441 default:
442 return "invalid error code";
443 }
444 }