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 }