utils.c

   1 /*
   2  * uhttpd - Tiny single-threaded httpd
   3  *
   4  *   Copyright (C) 2010-2012 Jo-Philipp Wich <xm@subsignal.org>
   5  *   Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
   6  *
   7  *  Licensed under the Apache License, Version 2.0 (the "License");
   8  *  you may not use this file except in compliance with the License.
   9  *  You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  *  Unless required by applicable law or agreed to in writing, software
  14  *  distributed under the License is distributed on an "AS IS" BASIS,
  15  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  *  See the License for the specific language governing permissions and
  17  *  limitations under the License.
  18  */
  19
  20 #include <ctype.h>
  21 #include "uhttpd.h"
  22
  23 bool uh_use_chunked(struct client *cl)
  24 {
  25         if (cl->request.version != UH_HTTP_VER_1_1)
  26                 return false;
  27
  28         if (cl->request.method == UH_HTTP_MSG_HEAD)
  29                 return false;
  30
  31         return true;
  32 }
  33
  34 void uh_chunk_write(struct client *cl, const void *data, int len)
  35 {
  36         bool chunked = uh_use_chunked(cl);
  37
  38         uloop_timeout_set(&cl->timeout, conf.network_timeout * 1000);
  39         if (chunked)
  40                 ustream_printf(cl->us, "%X\r\n", len);
  41         ustream_write(cl->us, data, len, true);
  42         if (chunked)
  43                 ustream_printf(cl->us, "\r\n", len);
  44 }
  45
  46 void uh_chunk_vprintf(struct client *cl, const char *format, va_list arg)
  47 {
  48         char buf[256];
  49         va_list arg2;
  50         int len;
  51
  52         uloop_timeout_set(&cl->timeout, conf.network_timeout * 1000);
  53         if (!uh_use_chunked(cl)) {
  54                 ustream_vprintf(cl->us, format, arg);
  55                 return;
  56         }
  57
  58         va_copy(arg2, arg);
  59         len = vsnprintf(buf, sizeof(buf), format, arg2);
  60         va_end(arg2);
  61
  62         ustream_printf(cl->us, "%X\r\n", len);
  63         if (len < sizeof(buf))
  64                 ustream_write(cl->us, buf, len, true);
  65         else
  66                 ustream_vprintf(cl->us, format, arg);
  67         ustream_printf(cl->us, "\r\n", len);
  68 }
  69
  70 void uh_chunk_printf(struct client *cl, const char *format, ...)
  71 {
  72         va_list arg;
  73
  74         va_start(arg, format);
  75         uh_chunk_vprintf(cl, format, arg);
  76         va_end(arg);
  77 }
  78
  79 void uh_chunk_eof(struct client *cl)
  80 {
  81         if (!uh_use_chunked(cl))
  82                 return;
  83
  84         ustream_printf(cl->us, "0\r\n\r\n");
  85 }
  86
  87 /* blen is the size of buf; slen is the length of src.  The input-string need
  88 ** not be, and the output string will not be, null-terminated.  Returns the
  89 ** length of the decoded string, -1 on buffer overflow, -2 on malformed string. */
  90 int uh_urldecode(char *buf, int blen, const char *src, int slen)
  91 {
  92         int i;
  93         int len = 0;
  94
  95 #define hex(x) \
  96         (((x) <= '9') ? ((x) - '0') : \
  97                 (((x) <= 'F') ? ((x) - 'A' + 10) : \
  98                         ((x) - 'a' + 10)))
  99
 100         for (i = 0; (i < slen) && (len < blen); i++)
 101         {
 102                 if (src[i] != '%') {
 103                         buf[len++] = src[i];
 104                         continue;
 105                 }
 106
 107                 if (i + 2 >= slen || !isxdigit(src[i + 1]) || !isxdigit(src[i + 2]))
 108                         return -2;
 109
 110                 buf[len++] = (char)(16 * hex(src[i+1]) + hex(src[i+2]));
 111                 i += 2;
 112         }
 113         buf[len] = 0;
 114
 115         return (i == slen) ? len : -1;
 116 }
 117
 118 /* blen is the size of buf; slen is the length of src.  The input-string need
 119 ** not be, and the output string will not be, null-terminated.  Returns the
 120 ** length of the encoded string, or -1 on error (buffer overflow) */
 121 int uh_urlencode(char *buf, int blen, const char *src, int slen)
 122 {
 123         int i;
 124         int len = 0;
 125         static const char hex[] = "0123456789abcdef";
 126
 127         for (i = 0; (i < slen) && (len < blen); i++)
 128         {
 129                 if( isalnum(src[i]) || (src[i] == '-') || (src[i] == '_') ||
 130                     (src[i] == '.') || (src[i] == '~') )
 131                 {
 132                         buf[len++] = src[i];
 133                 }
 134                 else if ((len+3) <= blen)
 135                 {
 136                         buf[len++] = '%';
 137                         buf[len++] = hex[(src[i] >> 4) & 15];
 138                         buf[len++] = hex[ src[i]       & 15];
 139                 }
 140                 else
 141                 {
 142                         len = -1;
 143                         break;
 144                 }
 145         }
 146
 147         return (i == slen) ? len : -1;
 148 }
 149
 150 int uh_b64decode(char *buf, int blen, const void *src, int slen)
 151 {
 152         const unsigned char *str = src;
 153         unsigned int cout = 0;
 154         unsigned int cin  = 0;
 155         int len = 0;
 156         int i = 0;
 157
 158         for (i = 0; (i <= slen) && (str[i] != 0); i++)
 159         {
 160                 cin = str[i];
 161
 162                 if ((cin >= '0') && (cin <= '9'))
 163                         cin = cin - '0' + 52;
 164                 else if ((cin >= 'A') && (cin <= 'Z'))
 165                         cin = cin - 'A';
 166                 else if ((cin >= 'a') && (cin <= 'z'))
 167                         cin = cin - 'a' + 26;
 168                 else if (cin == '+')
 169                         cin = 62;
 170                 else if (cin == '/')
 171                         cin = 63;
 172                 else if (cin == '=')
 173                         cin = 0;
 174                 else
 175                         continue;
 176
 177                 cout = (cout << 6) | cin;
 178
 179                 if ((i % 4) != 3)
 180                         continue;
 181
 182                 if ((len + 3) >= blen)
 183                         break;
 184
 185                 buf[len++] = (char)(cout >> 16);
 186                 buf[len++] = (char)(cout >> 8);
 187                 buf[len++] = (char)(cout);
 188         }
 189
 190         buf[len++] = 0;
 191         return len;
 192 }
 193
 194 bool uh_path_match(const char *prefix, const char *url)
 195 {
 196         int len = strlen(prefix);
 197
 198         if (strncmp(url, prefix, len) != 0)
 199                 return false;
 200
 201         return url[len] == '/' || url[len] == 0;
 202 }
 203
 204 char *uh_split_header(char *str)
 205 {
 206         char *val;
 207
 208         val = strchr(str, ':');
 209         if (!val)
 210                 return NULL;
 211
 212         *val = 0;
 213         val++;
 214
 215         while (isspace(*val))
 216                 val++;
 217
 218         return val;
 219 }
 220
 221 bool uh_addr_rfc1918(struct uh_addr *addr)
 222 {
 223         uint32_t a;
 224
 225         if (addr->family != AF_INET)
 226                 return false;
 227
 228         a = htonl(addr->in.s_addr);
 229         return ((a >= 0x0A000000) && (a <= 0x0AFFFFFF)) ||
 230                ((a >= 0xAC100000) && (a <= 0xAC1FFFFF)) ||
 231                ((a >= 0xC0A80000) && (a <= 0xC0A8FFFF));
 232
 233         return 0;
 234 }