1 /*
2 * Copyright (c) 2014 DeNA Co., Ltd.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to
6 * deal in the Software without restriction, including without limitation the
7 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
8 * sell copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
20 * IN THE SOFTWARE.
21 */
22 #include <assert.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include "khash.h"
26 #include "h2o.h"
27
KHASH_MAP_INIT_STR(extmap,h2o_mimemap_type_t *)28 KHASH_MAP_INIT_STR(extmap, h2o_mimemap_type_t *)
29
30 static inline khint_t hash_mimemap_type(h2o_mimemap_type_t *mimetype)
31 {
32 khint_t h = 0;
33 size_t i;
34 for (i = 0; i != mimetype->data.mimetype.len; ++i)
35 h = (h << 5) - h + (khint_t)mimetype->data.mimetype.base[i];
36 return h;
37 }
38
mimemap_type_equals(h2o_mimemap_type_t * x,h2o_mimemap_type_t * y)39 static inline int mimemap_type_equals(h2o_mimemap_type_t *x, h2o_mimemap_type_t *y)
40 {
41 return h2o_memis(x->data.mimetype.base, x->data.mimetype.len, y->data.mimetype.base, y->data.mimetype.len);
42 }
43
44 KHASH_INIT(typeset, h2o_mimemap_type_t *, char, 0, hash_mimemap_type, mimemap_type_equals)
45
46 h2o_mime_attributes_t h2o_mime_attributes_as_is;
47
48 struct st_h2o_mimemap_t {
49 khash_t(extmap) * extmap;
50 khash_t(typeset) * typeset; /* refs point to the entries in extmap */
51 h2o_mimemap_type_t *default_type;
52 size_t num_dynamic;
53 };
54
dupref(const char * s)55 static h2o_iovec_t dupref(const char *s)
56 {
57 h2o_iovec_t ret;
58 ret.len = strlen(s);
59 ret.base = h2o_mem_alloc_shared(NULL, ret.len + 1, NULL);
60 memcpy(ret.base, s, ret.len + 1);
61 return ret;
62 }
63
on_dispose(void * _mimemap)64 static void on_dispose(void *_mimemap)
65 {
66 h2o_mimemap_t *mimemap = _mimemap;
67 const char *ext;
68 h2o_mimemap_type_t *type;
69
70 kh_destroy(typeset, mimemap->typeset);
71 kh_foreach(mimemap->extmap, ext, type, {
72 h2o_mem_release_shared((char *)ext);
73 h2o_mem_release_shared(type);
74 });
75 kh_destroy(extmap, mimemap->extmap);
76 h2o_mem_release_shared(mimemap->default_type);
77 }
78
on_unlink(h2o_mimemap_t * mimemap,h2o_mimemap_type_t * type)79 static void on_unlink(h2o_mimemap_t *mimemap, h2o_mimemap_type_t *type)
80 {
81 switch (type->type) {
82 case H2O_MIMEMAP_TYPE_MIMETYPE:
83 break;
84 case H2O_MIMEMAP_TYPE_DYNAMIC:
85 --mimemap->num_dynamic;
86 break;
87 }
88 }
89
on_link(h2o_mimemap_t * mimemap,h2o_mimemap_type_t * type)90 static void on_link(h2o_mimemap_t *mimemap, h2o_mimemap_type_t *type)
91 {
92 switch (type->type) {
93 case H2O_MIMEMAP_TYPE_MIMETYPE:
94 break;
95 case H2O_MIMEMAP_TYPE_DYNAMIC:
96 ++mimemap->num_dynamic;
97 break;
98 }
99 }
100
rebuild_typeset(h2o_mimemap_t * mimemap)101 static void rebuild_typeset(h2o_mimemap_t *mimemap)
102 {
103 kh_clear(typeset, mimemap->typeset);
104
105 const char *ext;
106 h2o_mimemap_type_t *mime;
107 kh_foreach(mimemap->extmap, ext, mime, {
108 if (mime->type == H2O_MIMEMAP_TYPE_MIMETYPE) {
109 khiter_t iter = kh_get(typeset, mimemap->typeset, mime);
110 if (iter == kh_end(mimemap->typeset)) {
111 int r;
112 kh_put(typeset, mimemap->typeset, mime, &r);
113 }
114 }
115 });
116 }
117
create_extension_type(const char * mime,h2o_mime_attributes_t * attr)118 static h2o_mimemap_type_t *create_extension_type(const char *mime, h2o_mime_attributes_t *attr)
119 {
120 h2o_mimemap_type_t *type = h2o_mem_alloc_shared(NULL, sizeof(*type) + strlen(mime) + 1, NULL);
121 size_t i;
122
123 memset(type, 0, sizeof(*type));
124
125 type->type = H2O_MIMEMAP_TYPE_MIMETYPE;
126
127 /* normalize-copy type->data.mimetype */
128 type->data.mimetype.base = (char *)type + sizeof(*type);
129 for (i = 0; mime[i] != '\0' && mime[i] != ';'; ++i)
130 type->data.mimetype.base[i] = h2o_tolower(mime[i]);
131 for (; mime[i] != '\0'; ++i)
132 type->data.mimetype.base[i] = mime[i];
133 type->data.mimetype.base[i] = '\0';
134 type->data.mimetype.len = i;
135
136 if (attr != NULL) {
137 type->data.attr = *attr;
138 } else {
139 h2o_mimemap_get_default_attributes(mime, &type->data.attr);
140 }
141
142 return type;
143 }
144
dispose_dynamic_type(h2o_mimemap_type_t * type)145 static void dispose_dynamic_type(h2o_mimemap_type_t *type)
146 {
147 h2o_config_dispose_pathconf(&type->data.dynamic.pathconf);
148 }
149
create_dynamic_type(h2o_globalconf_t * globalconf,h2o_mimemap_t * mimemap)150 static h2o_mimemap_type_t *create_dynamic_type(h2o_globalconf_t *globalconf, h2o_mimemap_t *mimemap)
151 {
152 h2o_mimemap_type_t *type = h2o_mem_alloc_shared(NULL, sizeof(*type), (void (*)(void *))dispose_dynamic_type);
153
154 type->type = H2O_MIMEMAP_TYPE_DYNAMIC;
155 memset(&type->data.dynamic, 0, sizeof(type->data.dynamic));
156 h2o_config_init_pathconf(&type->data.dynamic.pathconf, globalconf, NULL, mimemap);
157
158 return type;
159 }
160
h2o_mimemap_create()161 h2o_mimemap_t *h2o_mimemap_create()
162 {
163 h2o_mimemap_t *mimemap = h2o_mem_alloc_shared(NULL, sizeof(*mimemap), on_dispose);
164
165 mimemap->extmap = kh_init(extmap);
166 mimemap->typeset = kh_init(typeset);
167 mimemap->default_type = create_extension_type("application/octet-stream", NULL);
168 mimemap->num_dynamic = 0;
169 on_link(mimemap, mimemap->default_type);
170
171 { /* setup the tiny default */
172 static const char *default_types[] = {
173 #define MIMEMAP(ext, mime) ext, mime,
174 #include "mimemap/defaults.c.h"
175 #undef MIMEMAP
176 NULL};
177 const char **p;
178 for (p = default_types; *p != NULL; p += 2)
179 h2o_mimemap_define_mimetype(mimemap, p[0], p[1], NULL);
180 }
181 rebuild_typeset(mimemap);
182
183 return mimemap;
184 }
185
h2o_mimemap_clone(h2o_mimemap_t * src)186 h2o_mimemap_t *h2o_mimemap_clone(h2o_mimemap_t *src)
187 {
188 h2o_mimemap_t *dst = h2o_mem_alloc_shared(NULL, sizeof(*dst), on_dispose);
189 const char *ext;
190 h2o_mimemap_type_t *type;
191
192 dst->extmap = kh_init(extmap);
193 dst->typeset = kh_init(typeset);
194 kh_foreach(src->extmap, ext, type, {
195 int r;
196 khiter_t iter = kh_put(extmap, dst->extmap, ext, &r);
197 kh_val(dst->extmap, iter) = type;
198 h2o_mem_addref_shared((char *)ext);
199 h2o_mem_addref_shared(type);
200 on_link(dst, type);
201 });
202 dst->default_type = src->default_type;
203 h2o_mem_addref_shared(dst->default_type);
204 on_link(dst, dst->default_type);
205 rebuild_typeset(dst);
206
207 return dst;
208 }
209
210 #define FOREACH_TYPE(mimemap, block) \
211 do { \
212 const char *ext; \
213 h2o_mimemap_type_t *type; \
214 type = mimemap->default_type; \
215 {block}; \
216 kh_foreach(mimemap->extmap, ext, type, {block}); \
217 } while (0)
218
h2o_mimemap_on_context_init(h2o_mimemap_t * mimemap,h2o_context_t * ctx)219 void h2o_mimemap_on_context_init(h2o_mimemap_t *mimemap, h2o_context_t *ctx)
220 {
221 FOREACH_TYPE(mimemap, {
222 switch (type->type) {
223 case H2O_MIMEMAP_TYPE_DYNAMIC:
224 h2o_context_init_pathconf_context(ctx, &type->data.dynamic.pathconf);
225 break;
226 case H2O_MIMEMAP_TYPE_MIMETYPE:
227 break;
228 }
229 });
230 }
231
h2o_mimemap_on_context_dispose(h2o_mimemap_t * mimemap,h2o_context_t * ctx)232 void h2o_mimemap_on_context_dispose(h2o_mimemap_t *mimemap, h2o_context_t *ctx)
233 {
234 FOREACH_TYPE(mimemap, {
235 switch (type->type) {
236 case H2O_MIMEMAP_TYPE_DYNAMIC:
237 h2o_context_dispose_pathconf_context(ctx, &type->data.dynamic.pathconf);
238 break;
239 case H2O_MIMEMAP_TYPE_MIMETYPE:
240 break;
241 }
242 });
243 }
244
245 #undef FOREACH_TYPE
246
h2o_mimemap_has_dynamic_type(h2o_mimemap_t * mimemap)247 int h2o_mimemap_has_dynamic_type(h2o_mimemap_t *mimemap)
248 {
249 return mimemap->num_dynamic != 0;
250 }
251
set_default_type(h2o_mimemap_t * mimemap,h2o_mimemap_type_t * type)252 void set_default_type(h2o_mimemap_t *mimemap, h2o_mimemap_type_t *type)
253 {
254 /* unlink the old one */
255 on_unlink(mimemap, mimemap->default_type);
256 h2o_mem_release_shared(mimemap->default_type);
257
258 /* update */
259 h2o_mem_addref_shared(type);
260 mimemap->default_type = type;
261 on_link(mimemap, type);
262 rebuild_typeset(mimemap);
263 }
264
h2o_mimemap_set_default_type(h2o_mimemap_t * mimemap,const char * mime,h2o_mime_attributes_t * attr)265 void h2o_mimemap_set_default_type(h2o_mimemap_t *mimemap, const char *mime, h2o_mime_attributes_t *attr)
266 {
267 h2o_mimemap_type_t *new_type;
268
269 /* obtain or create new type */
270 if ((new_type = h2o_mimemap_get_type_by_mimetype(mimemap, h2o_iovec_init(mime, strlen(mime)), 1)) != NULL &&
271 (attr == NULL || memcmp(&new_type->data.attr, attr, sizeof(*attr)) == 0)) {
272 h2o_mem_addref_shared(new_type);
273 } else {
274 new_type = create_extension_type(mime, attr);
275 }
276
277 set_default_type(mimemap, new_type);
278 h2o_mem_release_shared(new_type);
279 }
280
set_type(h2o_mimemap_t * mimemap,const char * ext,h2o_mimemap_type_t * type)281 static void set_type(h2o_mimemap_t *mimemap, const char *ext, h2o_mimemap_type_t *type)
282 {
283 /* obtain key, and remove the old value */
284 khiter_t iter = kh_get(extmap, mimemap->extmap, ext);
285 if (iter != kh_end(mimemap->extmap)) {
286 h2o_mimemap_type_t *oldtype = kh_val(mimemap->extmap, iter);
287 on_unlink(mimemap, oldtype);
288 h2o_mem_release_shared(oldtype);
289 } else {
290 int ret;
291 iter = kh_put(extmap, mimemap->extmap, dupref(ext).base, &ret);
292 assert(iter != kh_end(mimemap->extmap));
293 }
294
295 /* update */
296 h2o_mem_addref_shared(type);
297 kh_val(mimemap->extmap, iter) = type;
298 on_link(mimemap, type);
299 rebuild_typeset(mimemap);
300 }
301
h2o_mimemap_define_mimetype(h2o_mimemap_t * mimemap,const char * ext,const char * mime,h2o_mime_attributes_t * attr)302 void h2o_mimemap_define_mimetype(h2o_mimemap_t *mimemap, const char *ext, const char *mime, h2o_mime_attributes_t *attr)
303 {
304 h2o_mimemap_type_t *new_type;
305
306 if ((new_type = h2o_mimemap_get_type_by_mimetype(mimemap, h2o_iovec_init(mime, strlen(mime)), 1)) != NULL &&
307 (attr == NULL || memcmp(&new_type->data.attr, attr, sizeof(*attr)) == 0)) {
308 h2o_mem_addref_shared(new_type);
309 } else {
310 new_type = create_extension_type(mime, attr);
311 }
312 set_type(mimemap, ext, new_type);
313 h2o_mem_release_shared(new_type);
314 }
315
h2o_mimemap_define_dynamic(h2o_mimemap_t * mimemap,const char ** exts,h2o_globalconf_t * globalconf)316 h2o_mimemap_type_t *h2o_mimemap_define_dynamic(h2o_mimemap_t *mimemap, const char **exts, h2o_globalconf_t *globalconf)
317 {
318 /* FIXME: fix memory leak introduced by this a cyclic link (mimemap -> new_type -> mimemap)
319 * note also that we may want to update the reference from the dynamic type to the mimemap as we clone the mimemap,
320 * but doing so naively would cause unnecessary copies of fastcgi.spawns... */
321 h2o_mimemap_type_t *new_type = create_dynamic_type(globalconf, mimemap);
322 size_t i;
323
324 for (i = 0; exts[i] != NULL; ++i) {
325 if (exts[i][0] == '\0') {
326 /* empty string means default */
327 set_default_type(mimemap, new_type);
328 } else {
329 set_type(mimemap, exts[i], new_type);
330 }
331 }
332 h2o_mem_release_shared(new_type);
333 return new_type;
334 }
335
h2o_mimemap_remove_type(h2o_mimemap_t * mimemap,const char * ext)336 void h2o_mimemap_remove_type(h2o_mimemap_t *mimemap, const char *ext)
337 {
338 khiter_t iter = kh_get(extmap, mimemap->extmap, ext);
339 if (iter != kh_end(mimemap->extmap)) {
340 const char *key = kh_key(mimemap->extmap, iter);
341 h2o_mimemap_type_t *type = kh_val(mimemap->extmap, iter);
342 on_unlink(mimemap, type);
343 h2o_mem_release_shared(type);
344 kh_del(extmap, mimemap->extmap, iter);
345 h2o_mem_release_shared((char *)key);
346 rebuild_typeset(mimemap);
347 }
348 }
349
h2o_mimemap_clear_types(h2o_mimemap_t * mimemap)350 void h2o_mimemap_clear_types(h2o_mimemap_t *mimemap)
351 {
352 khiter_t iter;
353
354 for (iter = kh_begin(mimemap->extmap); iter != kh_end(mimemap->extmap); ++iter) {
355 if (!kh_exist(mimemap->extmap, iter))
356 continue;
357 const char *key = kh_key(mimemap->extmap, iter);
358 h2o_mimemap_type_t *type = kh_val(mimemap->extmap, iter);
359 on_unlink(mimemap, type);
360 h2o_mem_release_shared(type);
361 kh_del(extmap, mimemap->extmap, iter);
362 h2o_mem_release_shared((char *)key);
363 }
364 rebuild_typeset(mimemap);
365 }
366
h2o_mimemap_get_default_type(h2o_mimemap_t * mimemap)367 h2o_mimemap_type_t *h2o_mimemap_get_default_type(h2o_mimemap_t *mimemap)
368 {
369 return mimemap->default_type;
370 }
371
h2o_mimemap_get_type_by_extension(h2o_mimemap_t * mimemap,h2o_iovec_t ext)372 h2o_mimemap_type_t *h2o_mimemap_get_type_by_extension(h2o_mimemap_t *mimemap, h2o_iovec_t ext)
373 {
374 char lcbuf[256];
375
376 if (0 < ext.len && ext.len < sizeof(lcbuf)) {
377 memcpy(lcbuf, ext.base, ext.len);
378 h2o_strtolower(lcbuf, ext.len);
379 lcbuf[ext.len] = '\0';
380 khiter_t iter = kh_get(extmap, mimemap->extmap, lcbuf);
381 if (iter != kh_end(mimemap->extmap))
382 return kh_val(mimemap->extmap, iter);
383 }
384 return mimemap->default_type;
385 }
386
h2o_mimemap_get_type_by_mimetype(h2o_mimemap_t * mimemap,h2o_iovec_t mime,int exact_match_only)387 h2o_mimemap_type_t *h2o_mimemap_get_type_by_mimetype(h2o_mimemap_t *mimemap, h2o_iovec_t mime, int exact_match_only)
388 {
389 h2o_mimemap_type_t key = {H2O_MIMEMAP_TYPE_MIMETYPE};
390 khiter_t iter;
391 size_t type_end_at;
392
393 /* exact match */
394 key.data.mimetype = mime;
395 if ((iter = kh_get(typeset, mimemap->typeset, &key)) != kh_end(mimemap->typeset))
396 return kh_key(mimemap->typeset, iter);
397
398 if (!exact_match_only) {
399 /* determine the end of the type */
400 for (type_end_at = 0; type_end_at != mime.len; ++type_end_at)
401 if (mime.base[type_end_at] == ';' || mime.base[type_end_at] == ' ')
402 goto HasAttributes;
403 }
404 return NULL;
405
406 HasAttributes:
407 /* perform search without attributes */
408 key.data.mimetype.len = type_end_at;
409 if ((iter = kh_get(typeset, mimemap->typeset, &key)) != kh_end(mimemap->typeset))
410 return kh_key(mimemap->typeset, iter);
411
412 return NULL;
413 }
414
h2o_mimemap_get_default_attributes(const char * mime,h2o_mime_attributes_t * attr)415 void h2o_mimemap_get_default_attributes(const char *mime, h2o_mime_attributes_t *attr)
416 {
417 size_t mime_len;
418
419 for (mime_len = 0; !(mime[mime_len] == '\0' || mime[mime_len] == ';'); ++mime_len)
420 ;
421
422 *attr = (h2o_mime_attributes_t){0};
423
424 #define MIME_IS(x) h2o_memis(mime, mime_len, H2O_STRLIT(x))
425 #define MIME_STARTS_WITH(x) (mime_len >= sizeof(x) - 1 && memcmp(mime, x, sizeof(x) - 1) == 0)
426 #define MIME_ENDS_WITH(x) (mime_len >= sizeof(x) - 1 && memcmp(mime + mime_len - (sizeof(x) - 1), x, sizeof(x) - 1) == 0)
427
428 if (MIME_IS("text/css") || MIME_IS("application/ecmascript") || MIME_IS("application/javascript") ||
429 MIME_IS("text/ecmascript") || MIME_IS("text/javascript")) {
430 attr->is_compressible = 1;
431 attr->priority = H2O_MIME_ATTRIBUTE_PRIORITY_HIGHEST;
432 } else if (MIME_IS("application/json") || MIME_IS("application/xml") || MIME_STARTS_WITH("text/") || MIME_ENDS_WITH("+json") ||
433 MIME_ENDS_WITH("+xml")) {
434 attr->is_compressible = 1;
435 }
436
437 #undef MIME_IS
438 #undef MIME_STARTS_WITH
439 #undef MIME_ENDS_WITH
440 }
441