add uclient_get_url_filename helper function
[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
50 struct uclient_url __hidden *
51 uclient_get_url(const char *url_str, const char *auth_str)
52 {
53         static const struct uclient_backend *backends[] = {
54                 &uclient_backend_http,
55         };
56
57         const struct uclient_backend *backend;
58         const char * const *prefix = NULL;
59         struct uclient_url *url;
60         const char *location;
61         char *host_buf, *uri_buf, *auth_buf, *next;
62         int i, host_len;
63
64         for (i = 0; i < ARRAY_SIZE(backends); i++) {
65                 int prefix_len = 0;
66
67                 for (prefix = backends[i]->prefix; *prefix; prefix++) {
68                         prefix_len = strlen(*prefix);
69
70                         if (!strncmp(url_str, *prefix, prefix_len))
71                                 break;
72                 }
73
74                 if (!*prefix)
75                         continue;
76
77                 url_str += prefix_len;
78                 backend = backends[i];
79                 break;
80         }
81
82         if (!*prefix)
83                 return NULL;
84
85         next = strchr(url_str, '/');
86         if (next) {
87                 location = next;
88                 host_len = next - url_str;
89         } else {
90                 location = "/";
91                 host_len = strlen(url_str);
92         }
93
94         url = calloc_a(sizeof(*url),
95                 &host_buf, host_len + 1,
96                 &uri_buf, strlen(location) + 1,
97                 &auth_buf, auth_str ? strlen(auth_str) + 1 : 0);
98
99         url->backend = backend;
100         url->location = strcpy(uri_buf, location);
101         url->prefix = prefix - backend->prefix;
102
103         url->host = strncpy(host_buf, url_str, host_len);
104
105         next = strchr(host_buf, '@');
106         if (next) {
107                 *next = 0;
108                 url->host = next + 1;
109
110                 if (uclient_urldecode(host_buf, host_buf, false) < 0)
111                         goto free;
112
113                 url->auth = host_buf;
114         }
115
116         if (!url->auth && auth_str)
117                 url->auth = strcpy(auth_buf, auth_str);
118
119         /* Literal IPv6 address */
120         if (*url->host == '[') {
121                 url->host++;
122                 next = strrchr(url->host, ']');
123                 if (!next)
124                         goto free;
125
126                 *(next++) = 0;
127                 if (*next == ':')
128                         url->port = next + 1;
129         } else {
130                 next = strrchr(url->host, ':');
131                 if (next) {
132                         *next = 0;
133                         url->port = next + 1;
134                 }
135         }
136
137         return url;
138
139 free:
140         free(url);
141         return NULL;
142 }
143
144 struct uclient *uclient_new(const char *url_str, const char *auth_str, const struct uclient_cb *cb)
145 {
146         struct uclient *cl;
147         struct uclient_url *url;
148
149         url = uclient_get_url(url_str, auth_str);
150         if (!url)
151                 return NULL;
152
153         cl = url->backend->alloc();
154         if (!cl)
155                 return NULL;
156
157         cl->backend = url->backend;
158         cl->cb = cb;
159         cl->url = url;
160
161         return cl;
162 }
163
164 int uclient_set_url(struct uclient *cl, const char *url_str, const char *auth_str)
165 {
166         const struct uclient_backend *backend = cl->backend;
167         struct uclient_url *url = cl->url;
168
169         url = uclient_get_url(url_str, auth_str);
170         if (!url)
171                 return -1;
172
173         if (url->backend != cl->backend)
174                 return -1;
175
176         free(cl->url);
177         cl->url = url;
178
179         if (backend->update_url)
180                 backend->update_url(cl);
181
182         return 0;
183 }
184
185 int uclient_connect(struct uclient *cl)
186 {
187         return cl->backend->connect(cl);
188 }
189
190 void uclient_free(struct uclient *cl)
191 {
192         struct uclient_url *url = cl->url;
193
194         if (cl->backend->free)
195                 cl->backend->free(cl);
196         else
197                 free(cl);
198
199         free(url);
200 }
201
202 int uclient_write(struct uclient *cl, char *buf, int len)
203 {
204         if (!cl->backend->write)
205                 return -1;
206
207         return cl->backend->write(cl, buf, len);
208 }
209
210 int uclient_request(struct uclient *cl)
211 {
212         if (!cl->backend->request)
213                 return -1;
214
215         return cl->backend->request(cl);
216 }
217
218 int uclient_read(struct uclient *cl, char *buf, int len)
219 {
220         if (!cl->backend->read)
221                 return -1;
222
223         return cl->backend->read(cl, buf, len);
224 }
225
226 void uclient_disconnect(struct uclient *cl)
227 {
228         if (!cl->backend->disconnect)
229                 return;
230
231         cl->backend->disconnect(cl);
232 }
233
234 static void __uclient_backend_change_state(struct uloop_timeout *timeout)
235 {
236         struct uclient *cl = container_of(timeout, struct uclient, timeout);
237
238         if (cl->error_code && cl->cb->error)
239                 cl->cb->error(cl, cl->error_code);
240         else if (cl->eof && cl->cb->data_eof)
241                 cl->cb->data_eof(cl);
242 }
243
244 static void uclient_backend_change_state(struct uclient *cl)
245 {
246         cl->timeout.cb = __uclient_backend_change_state;
247         uloop_timeout_set(&cl->timeout, 1);
248 }
249
250 void __hidden uclient_backend_set_error(struct uclient *cl, int code)
251 {
252         if (cl->error_code)
253                 return;
254
255         cl->error_code = code;
256         uclient_backend_change_state(cl);
257 }
258
259 void __hidden uclient_backend_set_eof(struct uclient *cl)
260 {
261         if (cl->eof || cl->error_code)
262                 return;
263
264         cl->eof = true;
265         uclient_backend_change_state(cl);
266 }
267
268 void __hidden uclient_backend_reset_state(struct uclient *cl)
269 {
270         cl->eof = false;
271         cl->error_code = 0;
272         uloop_timeout_cancel(&cl->timeout);
273 }