1/* copyright (c) 2022 - 2025 grunfink et al. / MIT license */
  2
  3#ifndef _XS_URL_H
  4
  5#define _XS_URL_H
  6
  7xs_str *xs_url_dec(const char *str);
  8xs_str *xs_url_enc(const char *str);
  9xs_dict *xs_url_vars(const char *str);
 10xs_dict *xs_multipart_form_data(const char *payload, int p_size, const char *header);
 11
 12#ifdef XS_IMPLEMENTATION
 13
 14char *xs_url_dec_in(char *str, int qs)
 15{
 16    char *w = str;
 17    char *r;
 18
 19    for (r = str; *r != '\0'; r++) {
 20        switch (*r) {
 21        case '%': {
 22            unsigned hex;
 23            if (!r[1] || !r[2])
 24                return NULL;
 25            if (sscanf(r + 1, "%2x", &hex) != 1)
 26                return NULL;
 27            *w++ = hex;
 28            r += 2;
 29            break;
 30        }
 31
 32        case '+':
 33            if (qs) {
 34                *w++ = ' ';
 35                break;
 36            }
 37            /* fall-through */
 38        default:
 39            *w++ = *r;
 40        }
 41    }
 42
 43    *w++ = '\0';
 44    return str;
 45}
 46
 47xs_str *xs_url_dec(const char *str)
 48/* decodes an URL */
 49{
 50    xs_str *s = xs_str_new(NULL);
 51
 52    while (*str) {
 53        if (!xs_is_string(str))
 54            break;
 55
 56        if (*str == '%') {
 57            unsigned int i;
 58
 59            if (sscanf(str + 1, "%02x", &i) == 1) {
 60                unsigned char uc = i;
 61
 62                if (!xs_is_string((char *)&uc))
 63                    break;
 64
 65                s = xs_append_m(s, (char *)&uc, 1);
 66                str += 2;
 67            }
 68        }
 69        else
 70        if (*str == '+')
 71            s = xs_append_m(s, " ", 1);
 72        else
 73            s = xs_append_m(s, str, 1);
 74
 75        str++;
 76    }
 77
 78    return s;
 79}
 80
 81
 82xs_str *xs_url_enc(const char *str)
 83/* URL-encodes a string (RFC 3986) */
 84{
 85    xs_str *s = xs_str_new(NULL);
 86
 87    while (*str) {
 88        if (isalnum(*str) || strchr("-._~", *str)) {
 89            s = xs_append_m(s, str, 1);
 90        }
 91        else {
 92            char tmp[8];
 93            snprintf(tmp, sizeof(tmp), "%%%02X", (unsigned char)*str);
 94            s = xs_append_m(s, tmp, 3);
 95        }
 96
 97        str++;
 98    }
 99
100    return s;
101}
102
103
104xs_dict *xs_url_vars(const char *str)
105/* parse url variables */
106{
107    xs_dict *vars;
108
109    vars = xs_dict_new();
110
111    if (xs_is_string(str)) {
112        xs *dup = xs_dup(str);
113        char *k;
114        char *saveptr;
115        for (k = strtok_r(dup, "&", &saveptr);
116             k;
117             k = strtok_r(NULL, "&", &saveptr)) {
118            char *v = strchr(k, '=');
119            if (!v)
120                continue;
121            *v++ = '\0';
122            k = xs_url_dec_in(k, 1);
123            v = xs_url_dec_in(v, 1);
124            if (!xs_is_string(k) || !xs_is_string(v))
125                continue;
126
127            const char *pv  = xs_dict_get(vars, k);
128            if (!xs_is_null(pv)) {
129                /* there is a previous value: convert to a list and append */
130                xs *vlist = NULL;
131                if (xs_type(pv) == XSTYPE_LIST)
132                    vlist = xs_dup(pv);
133                else {
134                    vlist = xs_list_new();
135                    vlist = xs_list_append(vlist, pv);
136                }
137
138                vlist = xs_list_append(vlist, v);
139                vars  = xs_dict_set(vars, k, vlist);
140            }
141            else {
142                /* ends with []? force to always be a list */
143                if (xs_endswith(k, "[]")) {
144                    xs *vlist = xs_list_new();
145                    vlist = xs_list_append(vlist, v);
146                    vars = xs_dict_append(vars, k, vlist);
147                }
148                else
149                    vars = xs_dict_append(vars, k, v);
150            }
151        }
152    }
153
154    return vars;
155}
156
157
158xs_dict *xs_multipart_form_data(const char *payload, int p_size, const char *header)
159/* parses a multipart/form-data payload */
160{
161    xs *boundary = NULL;
162    int offset = 0;
163    int bsz;
164    char *p;
165
166    /* build the boundary string */
167    {
168        xs *l1 = xs_split(header, "=");
169
170        if (xs_list_len(l1) != 2)
171            return NULL;
172
173        xs *t_boundary = xs_dup(xs_list_get(l1, 1));
174
175        /* Tokodon sends the boundary header with double quotes surrounded */
176        if (xs_between("\"", t_boundary, "\"") != 0)
177            t_boundary = xs_strip_chars_i(t_boundary, "\"");
178
179        boundary = xs_fmt("--%s", t_boundary);
180    }
181
182    bsz = strlen(boundary);
183
184    xs_dict *p_vars = xs_dict_new();
185
186    /* iterate searching the boundaries */
187    while ((p = xs_memmem(payload + offset, p_size - offset, boundary, bsz)) != NULL) {
188        xs *vn = NULL;
189        xs *fn = NULL;
190        xs *ct = NULL;
191        char *q;
192        int po, ps;
193
194        /* final boundary? */
195        p += bsz;
196
197        if ((p - payload) + 2 > p_size || (p[0] == '-' && p[1] == '-'))
198            break;
199
200        /* skip the \r\n */
201        p += 2;
202
203        /* Tokodon sends also a Content-Type headers,
204           let's use it to determine the file type */
205        do {
206            xs *s1 = NULL;
207            xs *l1 = NULL;
208            if (p[0] == '\r' && p[1] == '\n')
209                break;
210            q = memchr(p, '\r', p_size - (p - payload));
211
212            /* unexpected formatting, fail immediately */
213            if (q == NULL)
214                return p_vars;
215
216            s1 = xs_realloc(NULL, q - p + 1);
217            memcpy(s1, p, q - p);
218            s1[q - p] = '\0';
219
220            if (xs_startswith(s1, "Content-Disposition") || xs_startswith(s1, "content-disposition")) {
221                /* split by " like a primitive man */
222                l1 = xs_split(s1, "\"");
223
224                /* get the variable name */
225                vn = xs_dup(xs_list_get(l1, 1));
226
227                /* is it an attached file? */
228                if (xs_list_len(l1) >= 4 && strcmp(xs_list_get(l1, 2), "; filename=") == 0) {
229                    /* get the file name */
230                    fn = xs_dup(xs_list_get(l1, 3));
231                }
232            }
233            else
234            if (xs_startswith(s1, "Content-Type") || xs_startswith(s1, "content-type")) {
235                l1 = xs_split(s1, ":");
236
237                if (xs_list_len(l1) >= 2) {
238                    ct = xs_lstrip_chars_i(xs_dup(xs_list_get(l1, 1)), " ");
239                }
240            }
241
242            p += (q - p);
243            p += 2; // Skip /r/n
244        } while (1);
245
246        /* find the start of the part content */
247        if ((p = xs_memmem(p, p_size - (p - payload), "\r\n", 2)) == NULL)
248            break;
249
250        p += 2; // Skip empty line
251
252        /* find the next boundary */
253        if ((q = xs_memmem(p, p_size - (p - payload), boundary, bsz)) == NULL)
254            break;
255
256        po = p - payload;
257        ps = q - p - 2;     /* - 2 because the final \r\n */
258
259        /* is it a filename? */
260        if (fn != NULL) {
261            /* p_var value is a list */
262            /* if filename has no extension and content-type is image, attach extension to the filename */
263            if (strchr(fn, '.') == NULL && ct && xs_startswith(ct, "image/")) {
264                char *ext = strchr(ct, '/');
265                ext++;
266                fn = xs_str_cat(xs_str_new(""), fn, ".", ext);
267            }
268
269            xs *l1 = xs_list_new();
270            xs *vpo = xs_number_new(po);
271            xs *vps = xs_number_new(ps);
272
273            l1 = xs_list_append(l1, fn);
274            l1 = xs_list_append(l1, vpo);
275            l1 = xs_list_append(l1, vps);
276
277            if (xs_is_string(vn))
278                p_vars = xs_dict_append(p_vars, vn, l1);
279        }
280        else {
281            /* regular variable; just copy */
282            xs *vc = xs_realloc(NULL, ps + 1);
283            memcpy(vc, payload + po, ps);
284            vc[ps] = '\0';
285
286            if (xs_is_string(vn) && xs_is_string(vc))
287                p_vars = xs_dict_append(p_vars, vn, vc);
288        }
289
290        /* move on */
291        offset = q - payload;
292    }
293
294    return p_vars;
295}
296
297
298#endif /* XS_IMPLEMENTATION */
299
300#endif /* XS_URL_H */