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 static void uclient_connection_timeout(struct uloop_timeout *timeout)
 145 {
 146         struct uclient *cl = container_of(timeout, struct uclient, connection_timeout);
 147
 148         if (cl->backend->disconnect)
 149                 cl->backend->disconnect(cl);
 150
 151         uclient_backend_set_error(cl, UCLIENT_ERROR_TIMEDOUT);
 152 }
 153
 154 struct uclient *uclient_new(const char *url_str, const char *auth_str, const struct uclient_cb *cb)
 155 {
 156         struct uclient *cl;
 157         struct uclient_url *url;
 158
 159         url = uclient_get_url(url_str, auth_str);
 160         if (!url)
 161                 return NULL;
 162
 163         cl = url->backend->alloc();
 164         if (!cl)
 165                 return NULL;
 166
 167         cl->backend = url->backend;
 168         cl->cb = cb;
 169         cl->url = url;
 170         cl->timeout_msecs = UCLIENT_DEFAULT_TIMEOUT_MS;
 171         cl->connection_timeout.cb = uclient_connection_timeout;
 172
 173         return cl;
 174 }
 175
 176 int uclient_set_url(struct uclient *cl, const char *url_str, const char *auth_str)
 177 {
 178         const struct uclient_backend *backend = cl->backend;
 179         struct uclient_url *url = cl->url;
 180
 181         url = uclient_get_url(url_str, auth_str);
 182         if (!url)
 183                 return -1;
 184
 185         if (url->backend != cl->backend)
 186                 return -1;
 187
 188         free(cl->url);
 189         cl->url = url;
 190
 191         if (backend->update_url)
 192                 backend->update_url(cl);
 193
 194         return 0;
 195 }
 196
 197 int uclient_set_timeout(struct uclient *cl, int msecs)
 198 {
 199         if (msecs <= 0)
 200                 return -EINVAL;
 201
 202         cl->timeout_msecs = msecs;
 203
 204         return 0;
 205 }
 206
 207 int uclient_connect(struct uclient *cl)
 208 {
 209         return cl->backend->connect(cl);
 210 }
 211
 212 void uclient_free(struct uclient *cl)
 213 {
 214         struct uclient_url *url = cl->url;
 215
 216         if (cl->backend->free)
 217                 cl->backend->free(cl);
 218         else
 219                 free(cl);
 220
 221         free(url);
 222 }
 223
 224 int uclient_write(struct uclient *cl, const char *buf, int len)
 225 {
 226         if (!cl->backend->write)
 227                 return -1;
 228
 229         return cl->backend->write(cl, buf, len);
 230 }
 231
 232 int uclient_request(struct uclient *cl)
 233 {
 234         int err;
 235
 236         if (!cl->backend->request)
 237                 return -1;
 238
 239         err = cl->backend->request(cl);
 240         if (err)
 241                 return err;
 242
 243         uloop_timeout_set(&cl->connection_timeout, cl->timeout_msecs);
 244
 245         return 0;
 246 }
 247
 248 int uclient_read(struct uclient *cl, char *buf, int len)
 249 {
 250         if (!cl->backend->read)
 251                 return -1;
 252
 253         return cl->backend->read(cl, buf, len);
 254 }
 255
 256 void uclient_disconnect(struct uclient *cl)
 257 {
 258         uloop_timeout_cancel(&cl->connection_timeout);
 259
 260         if (!cl->backend->disconnect)
 261                 return;
 262
 263         cl->backend->disconnect(cl);
 264 }
 265
 266 static void __uclient_backend_change_state(struct uloop_timeout *timeout)
 267 {
 268         struct uclient *cl = container_of(timeout, struct uclient, timeout);
 269
 270         if (cl->error_code && cl->cb->error)
 271                 cl->cb->error(cl, cl->error_code);
 272         else if (cl->eof && cl->cb->data_eof)
 273                 cl->cb->data_eof(cl);
 274 }
 275
 276 static void uclient_backend_change_state(struct uclient *cl)
 277 {
 278         cl->timeout.cb = __uclient_backend_change_state;
 279         uloop_timeout_set(&cl->timeout, 1);
 280 }
 281
 282 void __hidden uclient_backend_set_error(struct uclient *cl, int code)
 283 {
 284         if (cl->error_code)
 285                 return;
 286
 287         uloop_timeout_cancel(&cl->connection_timeout);
 288         cl->error_code = code;
 289         uclient_backend_change_state(cl);
 290 }
 291
 292 void __hidden uclient_backend_set_eof(struct uclient *cl)
 293 {
 294         if (cl->eof || cl->error_code)
 295                 return;
 296
 297         uloop_timeout_cancel(&cl->connection_timeout);
 298         cl->eof = true;
 299         uclient_backend_change_state(cl);
 300 }
 301
 302 void __hidden uclient_backend_reset_state(struct uclient *cl)
 303 {
 304         cl->data_eof = false;
 305         cl->eof = false;
 306         cl->error_code = 0;
 307         uloop_timeout_cancel(&cl->timeout);
 308 }