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 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 } 445
This page was automatically generated by LXR 0.3.1. • OpenWrt