Moved here.\r\n", | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6714 | (int) location.len, location.p); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6715 | char bhead[150], *phead = bhead; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6716 | mg_asprintf(&phead, sizeof(bhead), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6717 | "Location: %.*s\r\n" | ~~~~~~~~~~~~~~~~~~~~ 6718 | "Content-Type: text/html\r\n" | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6719 | "Content-Length: %d\r\n" | ~~~~~~~~~~~~~~~~~~~~~~~~ 6720 | "Cache-Control: no-cache\r\n" | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6721 | "%.*s%s", | ~~~~~~~~~ 6722 | (int) location.len, location.p, bl, (int) extra_headers.len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6723 | extra_headers.p, (extra_headers.len > 0 ? "\r\n" : "")); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6724 | mg_send_response_line(nc, status_code, phead); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6725 | if (phead != bhead) MG_FREE(phead); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6726 | mg_send(nc, pbody, bl); | ~~~~~~~~~~~~~~~~~~~~~~~ 6727 | if (pbody != bbody) MG_FREE(pbody); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6728 | } | ~ 6729 | | 6730 | void mg_send_head(struct mg_connection *c, int status_code, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6731 | int64_t content_length, const char *extra_headers) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6732 | mg_send_response_line(c, status_code, extra_headers); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6733 | if (content_length < 0) { | ~~~~~~~~~~~~~~~~~~~~~~~~~ 6734 | mg_printf(c, "%s", "Transfer-Encoding: chunked\r\n"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6735 | } else { | ~~~~~~~~ 6736 | mg_printf(c, "Content-Length: %" INT64_FMT "\r\n", content_length); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6737 | } | ~ 6738 | mg_send(c, "\r\n", 2); | ~~~~~~~~~~~~~~~~~~~~~~ 6739 | } | ~ 6740 | | 6741 | void mg_http_send_error(struct mg_connection *nc, int code, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6742 | const char *reason) { | ~~~~~~~~~~~~~~~~~~~~~ 6743 | if (!reason) reason = mg_status_message(code); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6744 | LOG(LL_DEBUG, ("%p %d %s", nc, code, reason)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6745 | mg_send_head(nc, code, strlen(reason), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6746 | "Content-Type: text/plain\r\nConnection: close"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6747 | mg_send(nc, reason, strlen(reason)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6748 | nc->flags |= MG_F_SEND_AND_CLOSE; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6749 | } | ~ 6750 | | 6751 | #if MG_ENABLE_FILESYSTEM | ~~~~~~~~~~~~~~~~~~~~~~~~ 6752 | static void mg_http_construct_etag(char *buf, size_t buf_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6753 | const cs_stat_t *st) { | ~~~~~~~~~~~~~~~~~~~~~~ 6754 | snprintf(buf, buf_len, "\"%lx.%" INT64_FMT "\"", (unsigned long) st->st_mtime, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6755 | (int64_t) st->st_size); | ~~~~~~~~~~~~~~~~~~~~~~~ 6756 | } | ~ 6757 | | 6758 | #ifndef WINCE | ~~~~~~~~~~~~~ 6759 | static void mg_gmt_time_string(char *buf, size_t buf_len, time_t *t) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6760 | strftime(buf, buf_len, "%a, %d %b %Y %H:%M:%S GMT", gmtime(t)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6761 | } | ~ 6762 | #else | ~~~~~ 6763 | /* Look wince_lib.c for WindowsCE implementation */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6764 | static void mg_gmt_time_string(char *buf, size_t buf_len, time_t *t); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6765 | #endif | ~~~~~~ 6766 | | 6767 | static int mg_http_parse_range_header(const struct mg_str *header, int64_t *a, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6768 | int64_t *b) { | ~~~~~~~~~~~~~ 6769 | /* | ~~ 6770 | * There is no snscanf. Headers are not guaranteed to be NUL-terminated, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6771 | * so we have this. Ugh. | ~~~~~~~~~~~~~~~~~~~~~~~ 6772 | */ | ~~ 6773 | int result; | ~~~~~~~~~~~ 6774 | char *p = (char *) MG_MALLOC(header->len + 1); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6775 | if (p == NULL) return 0; | ~~~~~~~~~~~~~~~~~~~~~~~~ 6776 | memcpy(p, header->p, header->len); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6777 | p[header->len] = '\0'; | ~~~~~~~~~~~~~~~~~~~~~~ 6778 | result = sscanf(p, "bytes=%" INT64_FMT "-%" INT64_FMT, a, b); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6779 | MG_FREE(p); | ~~~~~~~~~~~ 6780 | return result; | ~~~~~~~~~~~~~~ 6781 | } | ~ 6782 | | 6783 | void mg_http_serve_file(struct mg_connection *nc, struct http_message *hm, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6784 | const char *path, const struct mg_str mime_type, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6785 | const struct mg_str extra_headers) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6786 | struct mg_http_proto_data *pd = mg_http_get_proto_data(nc); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6787 | cs_stat_t st; | ~~~~~~~~~~~~~ 6788 | LOG(LL_DEBUG, ("%p [%s] %.*s", nc, path, (int) mime_type.len, mime_type.p)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6789 | if (mg_stat(path, &st) != 0 || (pd->file.fp = mg_fopen(path, "rb")) == NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6790 | int code, err = mg_get_errno(); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6791 | switch (err) { | ~~~~~~~~~~~~~~ 6792 | case EACCES: | ~~~~~~~~~~~~ 6793 | code = 403; | ~~~~~~~~~~~ 6794 | break; | ~~~~~~ 6795 | case ENOENT: | ~~~~~~~~~~~~ 6796 | code = 404; | ~~~~~~~~~~~ 6797 | break; | ~~~~~~ 6798 | default: | ~~~~~~~~ 6799 | code = 500; | ~~~~~~~~~~~ 6800 | }; | ~~ 6801 | mg_http_send_error(nc, code, "Open failed"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6802 | } else { | ~~~~~~~~ 6803 | char etag[50], current_time[50], last_modified[50], range[70]; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6804 | time_t t = (time_t) mg_time(); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6805 | int64_t r1 = 0, r2 = 0, cl = st.st_size; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6806 | struct mg_str *range_hdr = mg_get_http_header(hm, "Range"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6807 | int n, status_code = 200; | ~~~~~~~~~~~~~~~~~~~~~~~~~ 6808 | | 6809 | /* Handle Range header */ | ~~~~~~~~~~~~~~~~~~~~~~~~~ 6810 | range[0] = '\0'; | ~~~~~~~~~~~~~~~~ 6811 | if (range_hdr != NULL && | ~~~~~~~~~~~~~~~~~~~~~~~~ 6812 | (n = mg_http_parse_range_header(range_hdr, &r1, &r2)) > 0 && r1 >= 0 && | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6813 | r2 >= 0) { | ~~~~~~~~~~ 6814 | /* If range is specified like "400-", set second limit to content len */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6815 | if (n == 1) { | ~~~~~~~~~~~~~ 6816 | r2 = cl - 1; | ~~~~~~~~~~~~ 6817 | } | ~ 6818 | if (r1 > r2 || r2 >= cl) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 6819 | status_code = 416; | ~~~~~~~~~~~~~~~~~~ 6820 | cl = 0; | ~~~~~~~ 6821 | snprintf(range, sizeof(range), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6822 | "Content-Range: bytes */%" INT64_FMT "\r\n", | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6823 | (int64_t) st.st_size); | ~~~~~~~~~~~~~~~~~~~~~~ 6824 | } else { | ~~~~~~~~ 6825 | status_code = 206; | ~~~~~~~~~~~~~~~~~~ 6826 | cl = r2 - r1 + 1; | ~~~~~~~~~~~~~~~~~ 6827 | snprintf(range, sizeof(range), "Content-Range: bytes %" INT64_FMT | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6828 | "-%" INT64_FMT "/%" INT64_FMT "\r\n", | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6829 | r1, r1 + cl - 1, (int64_t) st.st_size); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6830 | #if _FILE_OFFSET_BITS == 64 || _POSIX_C_SOURCE >= 200112L || \ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6831 | _XOPEN_SOURCE >= 600 | ~~~~~~~~~~~~~~~~~~~~ 6832 | fseeko(pd->file.fp, r1, SEEK_SET); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6833 | #else | ~~~~~ 6834 | fseek(pd->file.fp, (long) r1, SEEK_SET); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6835 | #endif | ~~~~~~ 6836 | } | ~ 6837 | } | ~ 6838 | | 6839 | #if !MG_DISABLE_HTTP_KEEP_ALIVE | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6840 | { | ~ 6841 | struct mg_str *conn_hdr = mg_get_http_header(hm, "Connection"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6842 | if (conn_hdr != NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~ 6843 | pd->file.keepalive = (mg_vcasecmp(conn_hdr, "keep-alive") == 0); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6844 | } else { | ~~~~~~~~ 6845 | pd->file.keepalive = (mg_vcmp(&hm->proto, "HTTP/1.1") == 0); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6846 | } | ~ 6847 | } | ~ 6848 | #endif | ~~~~~~ 6849 | | 6850 | mg_http_construct_etag(etag, sizeof(etag), &st); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6851 | mg_gmt_time_string(current_time, sizeof(current_time), &t); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6852 | mg_gmt_time_string(last_modified, sizeof(last_modified), &st.st_mtime); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6853 | /* | ~~ 6854 | * Content length casted to size_t because: | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6855 | * 1) that's the maximum buffer size anyway | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6856 | * 2) ESP8266 RTOS SDK newlib vprintf cannot contain a 64bit arg at non-last | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6857 | * position | ~~~~~~~~~~~~~ 6858 | * TODO(mkm): fix ESP8266 RTOS SDK | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6859 | */ | ~~ 6860 | mg_send_response_line_s(nc, status_code, extra_headers); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6861 | mg_printf(nc, | ~~~~~~~~~~~~~ 6862 | "Date: %s\r\n" | ~~~~~~~~~~~~~~ 6863 | "Last-Modified: %s\r\n" | ~~~~~~~~~~~~~~~~~~~~~~~ 6864 | "Accept-Ranges: bytes\r\n" | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 6865 | "Content-Type: %.*s\r\n" | ~~~~~~~~~~~~~~~~~~~~~~~~ 6866 | "Connection: %s\r\n" | ~~~~~~~~~~~~~~~~~~~~ 6867 | "Content-Length: %" SIZE_T_FMT | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6868 | "\r\n" | ~~~~~~ 6869 | "%sEtag: %s\r\n\r\n", | ~~~~~~~~~~~~~~~~~~~~~ 6870 | current_time, last_modified, (int) mime_type.len, mime_type.p, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6871 | (pd->file.keepalive ? "keep-alive" : "close"), (size_t) cl, range, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6872 | etag); | ~~~~~~ 6873 | | 6874 | pd->file.cl = cl; | ~~~~~~~~~~~~~~~~~ 6875 | pd->file.type = DATA_FILE; | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 6876 | mg_http_transfer_file_data(nc); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6877 | } | ~ 6878 | } | ~ 6879 | | 6880 | static void mg_http_serve_file2(struct mg_connection *nc, const char *path, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6881 | struct http_message *hm, | ~~~~~~~~~~~~~~~~~~~~~~~~ 6882 | struct mg_serve_http_opts *opts) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6883 | #if MG_ENABLE_HTTP_SSI | ~~~~~~~~~~~~~~~~~~~~~~ 6884 | if (mg_match_prefix(opts->ssi_pattern, strlen(opts->ssi_pattern), path) > 0) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6885 | mg_handle_ssi_request(nc, hm, path, opts); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6886 | return; | ~~~~~~~ 6887 | } | ~ 6888 | #endif | ~~~~~~ 6889 | mg_http_serve_file(nc, hm, path, mg_get_mime_type(path, "text/plain", opts), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6890 | mg_mk_str(opts->extra_headers)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6891 | } | ~ 6892 | | 6893 | #endif | ~~~~~~ 6894 | | 6895 | int mg_url_decode(const char *src, int src_len, char *dst, int dst_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6896 | int is_form_url_encoded) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 6897 | int i, j, a, b; | ~~~~~~~~~~~~~~~ 6898 | #define HEXTOI(x) (isdigit(x) ? x - '0' : x - 'W') | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6899 | | 6900 | for (i = j = 0; i < src_len && j < dst_len - 1; i++, j++) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6901 | if (src[i] == '%') { | ~~~~~~~~~~~~~~~~~~~~ 6902 | if (i < src_len - 2 && isxdigit(*(const unsigned char *) (src + i + 1)) && | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6903 | isxdigit(*(const unsigned char *) (src + i + 2))) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6904 | a = tolower(*(const unsigned char *) (src + i + 1)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6905 | b = tolower(*(const unsigned char *) (src + i + 2)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6906 | dst[j] = (char) ((HEXTOI(a) << 4) | HEXTOI(b)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6907 | i += 2; | ~~~~~~~ 6908 | } else { | ~~~~~~~~ 6909 | return -1; | ~~~~~~~~~~ 6910 | } | ~ 6911 | } else if (is_form_url_encoded && src[i] == '+') { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6912 | dst[j] = ' '; | ~~~~~~~~~~~~~ 6913 | } else { | ~~~~~~~~ 6914 | dst[j] = src[i]; | ~~~~~~~~~~~~~~~~ 6915 | } | ~ 6916 | } | ~ 6917 | | 6918 | dst[j] = '\0'; /* Null-terminate the destination */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6919 | | 6920 | return i >= src_len ? j : -1; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6921 | } | ~ 6922 | | 6923 | int mg_get_http_var(const struct mg_str *buf, const char *name, char *dst, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6924 | size_t dst_len) { | ~~~~~~~~~~~~~~~~~ 6925 | const char *p, *e, *s; | ~~~~~~~~~~~~~~~~~~~~~~ 6926 | size_t name_len; | ~~~~~~~~~~~~~~~~ 6927 | int len; | ~~~~~~~~ 6928 | | 6929 | /* | ~~ 6930 | * According to the documentation function returns negative | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6931 | * value in case of error. For debug purposes it returns: | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6932 | * -1 - src is wrong (NUUL) | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 6933 | * -2 - dst is wrong (NULL) | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 6934 | * -3 - failed to decode url or dst is to small | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6935 | * -4 - name does not exist | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 6936 | */ | ~~ 6937 | if (dst == NULL || dst_len == 0) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6938 | len = -2; | ~~~~~~~~~ 6939 | } else if (buf->p == NULL || name == NULL || buf->len == 0) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6940 | len = -1; | ~~~~~~~~~ 6941 | dst[0] = '\0'; | ~~~~~~~~~~~~~~ 6942 | } else { | ~~~~~~~~ 6943 | name_len = strlen(name); | ~~~~~~~~~~~~~~~~~~~~~~~~ 6944 | e = buf->p + buf->len; | ~~~~~~~~~~~~~~~~~~~~~~ 6945 | len = -4; | ~~~~~~~~~ 6946 | dst[0] = '\0'; | ~~~~~~~~~~~~~~ 6947 | | 6948 | for (p = buf->p; p + name_len < e; p++) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6949 | if ((p == buf->p || p[-1] == '&') && p[name_len] == '=' && | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6950 | !mg_ncasecmp(name, p, name_len)) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6951 | p += name_len + 1; | ~~~~~~~~~~~~~~~~~~ 6952 | s = (const char *) memchr(p, '&', (size_t)(e - p)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6953 | if (s == NULL) { | ~~~~~~~~~~~~~~~~ 6954 | s = e; | ~~~~~~ 6955 | } | ~ 6956 | len = mg_url_decode(p, (size_t)(s - p), dst, dst_len, 1); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6957 | /* -1 means: failed to decode or dst is too small */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6958 | if (len == -1) { | ~~~~~~~~~~~~~~~~ 6959 | len = -3; | ~~~~~~~~~ 6960 | } | ~ 6961 | break; | ~~~~~~ 6962 | } | ~ 6963 | } | ~ 6964 | } | ~ 6965 | | 6966 | return len; | ~~~~~~~~~~~ 6967 | } | ~ 6968 | | 6969 | void mg_send_http_chunk(struct mg_connection *nc, const char *buf, size_t len) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6970 | char chunk_size[50]; | ~~~~~~~~~~~~~~~~~~~~ 6971 | int n; | ~~~~~~ 6972 | | 6973 | n = snprintf(chunk_size, sizeof(chunk_size), "%lX\r\n", (unsigned long) len); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6974 | mg_send(nc, chunk_size, n); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6975 | mg_send(nc, buf, len); | ~~~~~~~~~~~~~~~~~~~~~~ 6976 | mg_send(nc, "\r\n", 2); | ~~~~~~~~~~~~~~~~~~~~~~~ 6977 | } | ~ 6978 | | 6979 | void mg_printf_http_chunk(struct mg_connection *nc, const char *fmt, ...) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6980 | char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6981 | int len; | ~~~~~~~~ 6982 | va_list ap; | ~~~~~~~~~~~ 6983 | | 6984 | va_start(ap, fmt); | ~~~~~~~~~~~~~~~~~~ 6985 | len = mg_avprintf(&buf, sizeof(mem), fmt, ap); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6986 | va_end(ap); | ~~~~~~~~~~~ 6987 | | 6988 | if (len >= 0) { | ~~~~~~~~~~~~~~~ 6989 | mg_send_http_chunk(nc, buf, len); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6990 | } | ~ 6991 | | 6992 | /* LCOV_EXCL_START */ | ~~~~~~~~~~~~~~~~~~~~~ 6993 | if (buf != mem && buf != NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6994 | MG_FREE(buf); | ~~~~~~~~~~~~~ 6995 | } | ~ 6996 | /* LCOV_EXCL_STOP */ | ~~~~~~~~~~~~~~~~~~~~ 6997 | } | ~ 6998 | | 6999 | void mg_printf_html_escape(struct mg_connection *nc, const char *fmt, ...) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7000 | char mem[MG_VPRINTF_BUFFER_SIZE], *buf = mem; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7001 | int i, j, len; | ~~~~~~~~~~~~~~ 7002 | va_list ap; | ~~~~~~~~~~~ 7003 | | 7004 | va_start(ap, fmt); | ~~~~~~~~~~~~~~~~~~ 7005 | len = mg_avprintf(&buf, sizeof(mem), fmt, ap); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7006 | va_end(ap); | ~~~~~~~~~~~ 7007 | | 7008 | if (len >= 0) { | ~~~~~~~~~~~~~~~ 7009 | for (i = j = 0; i < len; i++) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7010 | if (buf[i] == '<' || buf[i] == '>') { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7011 | mg_send(nc, buf + j, i - j); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7012 | mg_send(nc, buf[i] == '<' ? "<" : ">", 4); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7013 | j = i + 1; | ~~~~~~~~~~ 7014 | } | ~ 7015 | } | ~ 7016 | mg_send(nc, buf + j, i - j); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7017 | } | ~ 7018 | | 7019 | /* LCOV_EXCL_START */ | ~~~~~~~~~~~~~~~~~~~~~ 7020 | if (buf != mem && buf != NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7021 | MG_FREE(buf); | ~~~~~~~~~~~~~ 7022 | } | ~ 7023 | /* LCOV_EXCL_STOP */ | ~~~~~~~~~~~~~~~~~~~~ 7024 | } | ~ 7025 | | 7026 | static void mg_http_parse_header_internal(struct mg_str *hdr, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7027 | const char *var_name, | ~~~~~~~~~~~~~~~~~~~~~ 7028 | struct altbuf *ab) { | ~~~~~~~~~~~~~~~~~~~~ 7029 | int ch = ' ', ch1 = ',', n = strlen(var_name); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7030 | const char *p, *end = hdr ? hdr->p + hdr->len : NULL, *s = NULL; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7031 | | 7032 | /* Find where variable starts */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7033 | for (s = hdr->p; s != NULL && s + n < end; s++) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7034 | if ((s == hdr->p || s[-1] == ch || s[-1] == ch1 || s[-1] == ';') && | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7035 | s[n] == '=' && !strncmp(s, var_name, n)) | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7036 | break; | ~~~~~~ 7037 | } | ~ 7038 | | 7039 | if (s != NULL && &s[n + 1] < end) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7040 | s += n + 1; | ~~~~~~~~~~~ 7041 | if (*s == '"' || *s == '\'') { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7042 | ch = ch1 = *s++; | ~~~~~~~~~~~~~~~~ 7043 | } | ~ 7044 | p = s; | ~~~~~~ 7045 | while (p < end && p[0] != ch && p[0] != ch1) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7046 | if (ch != ' ' && p[0] == '\\' && p[1] == ch) p++; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7047 | altbuf_append(ab, *p++); | ~~~~~~~~~~~~~~~~~~~~~~~~ 7048 | } | ~ 7049 | | 7050 | if (ch != ' ' && *p != ch) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7051 | altbuf_reset(ab); | ~~~~~~~~~~~~~~~~~ 7052 | } | ~ 7053 | } | ~ 7054 | | 7055 | /* If there is some data, append a NUL. */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7056 | if (ab->len > 0) { | ~~~~~~~~~~~~~~~~~~ 7057 | altbuf_append(ab, '\0'); | ~~~~~~~~~~~~~~~~~~~~~~~~ 7058 | } | ~ 7059 | } | ~ 7060 | | 7061 | int mg_http_parse_header2(struct mg_str *hdr, const char *var_name, char **buf, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7062 | size_t buf_size) { | ~~~~~~~~~~~~~~~~~~ 7063 | struct altbuf ab; | ~~~~~~~~~~~~~~~~~ 7064 | altbuf_init(&ab, *buf, buf_size); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7065 | if (hdr == NULL) return 0; | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 7066 | if (*buf != NULL && buf_size > 0) *buf[0] = '\0'; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7067 | | 7068 | mg_http_parse_header_internal(hdr, var_name, &ab); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7069 | | 7070 | /* | ~~ 7071 | * Get a (trimmed) buffer, and return a len without a NUL byte which might | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7072 | * have been added. | ~~~~~~~~~~~~~~~~~~ 7073 | */ | ~~ 7074 | *buf = altbuf_get_buf(&ab, 1 /* trim */); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7075 | return ab.len > 0 ? ab.len - 1 : 0; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7076 | } | ~ 7077 | | 7078 | int mg_http_parse_header(struct mg_str *hdr, const char *var_name, char *buf, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7079 | size_t buf_size) { | ~~~~~~~~~~~~~~~~~~ 7080 | char *buf2 = buf; | ~~~~~~~~~~~~~~~~~ 7081 | | 7082 | int len = mg_http_parse_header2(hdr, var_name, &buf2, buf_size); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7083 | | 7084 | if (buf2 != buf) { | ~~~~~~~~~~~~~~~~~~ 7085 | /* Buffer was not enough and was reallocated: free it and just return 0 */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7086 | MG_FREE(buf2); | ~~~~~~~~~~~~~~ 7087 | return 0; | ~~~~~~~~~ 7088 | } | ~ 7089 | | 7090 | return len; | ~~~~~~~~~~~ 7091 | } | ~ 7092 | | 7093 | int mg_get_http_basic_auth(struct http_message *hm, char *user, size_t user_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7094 | char *pass, size_t pass_len) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7095 | struct mg_str *hdr = mg_get_http_header(hm, "Authorization"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7096 | if (hdr == NULL) return -1; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7097 | return mg_parse_http_basic_auth(hdr, user, user_len, pass, pass_len); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7098 | } | ~ 7099 | | 7100 | int mg_parse_http_basic_auth(struct mg_str *hdr, char *user, size_t user_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7101 | char *pass, size_t pass_len) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7102 | char *buf = NULL; | ~~~~~~~~~~~~~~~~~ 7103 | char fmt[64]; | ~~~~~~~~~~~~~ 7104 | int res = 0; | ~~~~~~~~~~~~ 7105 | | 7106 | if (mg_strncmp(*hdr, mg_mk_str("Basic "), 6) != 0) return -1; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7107 | | 7108 | buf = (char *) MG_MALLOC(hdr->len); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7109 | cs_base64_decode((unsigned char *) hdr->p + 6, hdr->len, buf, NULL); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7110 | | 7111 | /* e.g. "%123[^:]:%321[^\n]" */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7112 | snprintf(fmt, sizeof(fmt), "%%%" SIZE_T_FMT "[^:]:%%%" SIZE_T_FMT "[^\n]", | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7113 | user_len - 1, pass_len - 1); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7114 | if (sscanf(buf, fmt, user, pass) == 0) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7115 | res = -1; | ~~~~~~~~~ 7116 | } | ~ 7117 | | 7118 | MG_FREE(buf); | ~~~~~~~~~~~~~ 7119 | return res; | ~~~~~~~~~~~ 7120 | } | ~ 7121 | | 7122 | #if MG_ENABLE_FILESYSTEM | ~~~~~~~~~~~~~~~~~~~~~~~~ 7123 | static int mg_is_file_hidden(const char *path, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7124 | const struct mg_serve_http_opts *opts, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7125 | int exclude_specials) { | ~~~~~~~~~~~~~~~~~~~~~~~ 7126 | const char *p1 = opts->per_directory_auth_file; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7127 | const char *p2 = opts->hidden_file_pattern; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7128 | | 7129 | /* Strip directory path from the file name */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7130 | const char *pdir = strrchr(path, DIRSEP); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7131 | if (pdir != NULL) { | ~~~~~~~~~~~~~~~~~~~ 7132 | path = pdir + 1; | ~~~~~~~~~~~~~~~~ 7133 | } | ~ 7134 | | 7135 | return (exclude_specials && (!strcmp(path, ".") || !strcmp(path, ".."))) || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7136 | (p1 != NULL && mg_match_prefix(p1, strlen(p1), path) == strlen(p1)) || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7137 | (p2 != NULL && mg_match_prefix(p2, strlen(p2), path) > 0); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7138 | } | ~ 7139 | | 7140 | #if !MG_DISABLE_HTTP_DIGEST_AUTH | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7141 | | 7142 | #ifndef MG_EXT_MD5 | ~~~~~~~~~~~~~~~~~~ 7143 | void mg_hash_md5_v(size_t num_msgs, const uint8_t *msgs[], | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7144 | const size_t *msg_lens, uint8_t *digest) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7145 | size_t i; | ~~~~~~~~~ 7146 | cs_md5_ctx md5_ctx; | ~~~~~~~~~~~~~~~~~~~ 7147 | cs_md5_init(&md5_ctx); | ~~~~~~~~~~~~~~~~~~~~~~ 7148 | for (i = 0; i < num_msgs; i++) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7149 | cs_md5_update(&md5_ctx, msgs[i], msg_lens[i]); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7150 | } | ~ 7151 | cs_md5_final(digest, &md5_ctx); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7152 | } | ~ 7153 | #else | ~~~~~ 7154 | extern void mg_hash_md5_v(size_t num_msgs, const uint8_t *msgs[], | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7155 | const size_t *msg_lens, uint8_t *digest); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7156 | #endif | ~~~~~~ 7157 | | 7158 | void cs_md5(char buf[33], ...) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7159 | unsigned char hash[16]; | ~~~~~~~~~~~~~~~~~~~~~~~ 7160 | const uint8_t *msgs[20], *p; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7161 | size_t msg_lens[20]; | ~~~~~~~~~~~~~~~~~~~~ 7162 | size_t num_msgs = 0; | ~~~~~~~~~~~~~~~~~~~~ 7163 | va_list ap; | ~~~~~~~~~~~ 7164 | | 7165 | va_start(ap, buf); | ~~~~~~~~~~~~~~~~~~ 7166 | while ((p = va_arg(ap, const unsigned char *) ) != NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7167 | msgs[num_msgs] = p; | ~~~~~~~~~~~~~~~~~~~ 7168 | msg_lens[num_msgs] = va_arg(ap, size_t); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7169 | num_msgs++; | ~~~~~~~~~~~ 7170 | } | ~ 7171 | va_end(ap); | ~~~~~~~~~~~ 7172 | | 7173 | mg_hash_md5_v(num_msgs, msgs, msg_lens, hash); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7174 | cs_to_hex(buf, hash, sizeof(hash)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7175 | } | ~ 7176 | | 7177 | static void mg_mkmd5resp(const char *method, size_t method_len, const char *uri, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7178 | size_t uri_len, const char *ha1, size_t ha1_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7179 | const char *nonce, size_t nonce_len, const char *nc, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7180 | size_t nc_len, const char *cnonce, size_t cnonce_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7181 | const char *qop, size_t qop_len, char *resp) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7182 | static const char colon[] = ":"; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7183 | static const size_t one = 1; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7184 | char ha2[33]; | ~~~~~~~~~~~~~ 7185 | cs_md5(ha2, method, method_len, colon, one, uri, uri_len, NULL); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7186 | cs_md5(resp, ha1, ha1_len, colon, one, nonce, nonce_len, colon, one, nc, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7187 | nc_len, colon, one, cnonce, cnonce_len, colon, one, qop, qop_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7188 | colon, one, ha2, sizeof(ha2) - 1, NULL); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7189 | } | ~ 7190 | | 7191 | int mg_http_create_digest_auth_header(char *buf, size_t buf_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7192 | const char *method, const char *uri, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7193 | const char *auth_domain, const char *user, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7194 | const char *passwd, const char *nonce) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7195 | static const char colon[] = ":", qop[] = "auth"; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7196 | static const size_t one = 1; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7197 | char ha1[33], resp[33], cnonce[40]; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7198 | | 7199 | snprintf(cnonce, sizeof(cnonce), "%lx", (unsigned long) mg_time()); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7200 | cs_md5(ha1, user, (size_t) strlen(user), colon, one, auth_domain, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7201 | (size_t) strlen(auth_domain), colon, one, passwd, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7202 | (size_t) strlen(passwd), NULL); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7203 | mg_mkmd5resp(method, strlen(method), uri, strlen(uri), ha1, sizeof(ha1) - 1, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7204 | nonce, strlen(nonce), "1", one, cnonce, strlen(cnonce), qop, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7205 | sizeof(qop) - 1, resp); | ~~~~~~~~~~~~~~~~~~~~~~~ 7206 | return snprintf(buf, buf_len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7207 | "Authorization: Digest username=\"%s\"," | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7208 | "realm=\"%s\",uri=\"%s\",qop=%s,nc=1,cnonce=%s," | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7209 | "nonce=%s,response=%s\r\n", | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7210 | user, auth_domain, uri, qop, cnonce, nonce, resp); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7211 | } | ~ 7212 | | 7213 | /* | ~~ 7214 | * Check for authentication timeout. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7215 | * Clients send time stamp encoded in nonce. Make sure it is not too old, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7216 | * to prevent replay attacks. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7217 | * Assumption: nonce is a hexadecimal number of seconds since 1970. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7218 | */ | ~~ 7219 | static int mg_check_nonce(const char *nonce) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7220 | unsigned long now = (unsigned long) mg_time(); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7221 | unsigned long val = (unsigned long) strtoul(nonce, NULL, 16); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7222 | return (now >= val) && (now - val < 60 * 60); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7223 | } | ~ 7224 | | 7225 | int mg_http_check_digest_auth(struct http_message *hm, const char *auth_domain, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7226 | FILE *fp) { | ~~~~~~~~~~~ 7227 | int ret = 0; | ~~~~~~~~~~~~ 7228 | struct mg_str *hdr; | ~~~~~~~~~~~~~~~~~~~ 7229 | char username_buf[50], cnonce_buf[64], response_buf[40], uri_buf[200], | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7230 | qop_buf[20], nc_buf[20], nonce_buf[16]; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7231 | | 7232 | char *username = username_buf, *cnonce = cnonce_buf, *response = response_buf, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7233 | *uri = uri_buf, *qop = qop_buf, *nc = nc_buf, *nonce = nonce_buf; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7234 | | 7235 | /* Parse "Authorization:" header, fail fast on parse error */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7236 | if (hm == NULL || fp == NULL || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7237 | (hdr = mg_get_http_header(hm, "Authorization")) == NULL || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7238 | mg_http_parse_header2(hdr, "username", &username, sizeof(username_buf)) == | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7239 | 0 || | ~~~~ 7240 | mg_http_parse_header2(hdr, "cnonce", &cnonce, sizeof(cnonce_buf)) == 0 || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7241 | mg_http_parse_header2(hdr, "response", &response, sizeof(response_buf)) == | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7242 | 0 || | ~~~~ 7243 | mg_http_parse_header2(hdr, "uri", &uri, sizeof(uri_buf)) == 0 || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7244 | mg_http_parse_header2(hdr, "qop", &qop, sizeof(qop_buf)) == 0 || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7245 | mg_http_parse_header2(hdr, "nc", &nc, sizeof(nc_buf)) == 0 || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7246 | mg_http_parse_header2(hdr, "nonce", &nonce, sizeof(nonce_buf)) == 0 || | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7247 | mg_check_nonce(nonce) == 0) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7248 | ret = 0; | ~~~~~~~~ 7249 | goto clean; | ~~~~~~~~~~~ 7250 | } | ~ 7251 | | 7252 | /* NOTE(lsm): due to a bug in MSIE, we do not compare URIs */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7253 | | 7254 | ret = mg_check_digest_auth( | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7255 | hm->method, | ~~~~~~~~~~~ 7256 | mg_mk_str_n( | ~~~~~~~~~~~~ 7257 | hm->uri.p, | ~~~~~~~~~~ 7258 | hm->uri.len + (hm->query_string.len ? hm->query_string.len + 1 : 0)), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7259 | mg_mk_str(username), mg_mk_str(cnonce), mg_mk_str(response), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7260 | mg_mk_str(qop), mg_mk_str(nc), mg_mk_str(nonce), mg_mk_str(auth_domain), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7261 | fp); | ~~~~ 7262 | | 7263 | clean: | ~~~~~~ 7264 | if (username != username_buf) MG_FREE(username); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7265 | if (cnonce != cnonce_buf) MG_FREE(cnonce); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7266 | if (response != response_buf) MG_FREE(response); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7267 | if (uri != uri_buf) MG_FREE(uri); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7268 | if (qop != qop_buf) MG_FREE(qop); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7269 | if (nc != nc_buf) MG_FREE(nc); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7270 | if (nonce != nonce_buf) MG_FREE(nonce); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7271 | | 7272 | return ret; | ~~~~~~~~~~~ 7273 | } | ~ 7274 | | 7275 | int mg_check_digest_auth(struct mg_str method, struct mg_str uri, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7276 | struct mg_str username, struct mg_str cnonce, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7277 | struct mg_str response, struct mg_str qop, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7278 | struct mg_str nc, struct mg_str nonce, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7279 | struct mg_str auth_domain, FILE *fp) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7280 | char buf[128], f_user[sizeof(buf)], f_ha1[sizeof(buf)], f_domain[sizeof(buf)]; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7281 | char expected_response[33]; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7282 | | 7283 | /* | ~~ 7284 | * Read passwords file line by line. If should have htdigest format, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7285 | * i.e. each line should be a colon-separated sequence: | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7286 | * USER_NAME:DOMAIN_NAME:HA1_HASH_OF_USER_DOMAIN_AND_PASSWORD | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7287 | */ | ~~ 7288 | while (fgets(buf, sizeof(buf), fp) != NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7289 | if (sscanf(buf, "%[^:]:%[^:]:%s", f_user, f_domain, f_ha1) == 3 && | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7290 | mg_vcmp(&username, f_user) == 0 && | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7291 | mg_vcmp(&auth_domain, f_domain) == 0) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7292 | /* Username and domain matched, check the password */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7293 | mg_mkmd5resp(method.p, method.len, uri.p, uri.len, f_ha1, strlen(f_ha1), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7294 | nonce.p, nonce.len, nc.p, nc.len, cnonce.p, cnonce.len, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7295 | qop.p, qop.len, expected_response); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7296 | LOG(LL_DEBUG, | ~~~~~~~~~~~~~ 7297 | ("%.*s %s %.*s %s", (int) username.len, username.p, f_domain, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7298 | (int) response.len, response.p, expected_response)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7299 | return mg_ncasecmp(response.p, expected_response, response.len) == 0; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7300 | } | ~ 7301 | } | ~ 7302 | | 7303 | /* None of the entries in the passwords file matched - return failure */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7304 | return 0; | ~~~~~~~~~ 7305 | } | ~ 7306 | | 7307 | int mg_http_is_authorized(struct http_message *hm, struct mg_str path, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7308 | const char *domain, const char *passwords_file, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7309 | int flags) { | ~~~~~~~~~~~~ 7310 | char buf[MG_MAX_PATH]; | ~~~~~~~~~~~~~~~~~~~~~~ 7311 | const char *p; | ~~~~~~~~~~~~~~ 7312 | FILE *fp; | ~~~~~~~~~ 7313 | int authorized = 1; | ~~~~~~~~~~~~~~~~~~~ 7314 | | 7315 | if (domain != NULL && passwords_file != NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7316 | if (flags & MG_AUTH_FLAG_IS_GLOBAL_PASS_FILE) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7317 | fp = mg_fopen(passwords_file, "r"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7318 | } else if (flags & MG_AUTH_FLAG_IS_DIRECTORY) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7319 | snprintf(buf, sizeof(buf), "%.*s%c%s", (int) path.len, path.p, DIRSEP, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7320 | passwords_file); | ~~~~~~~~~~~~~~~~ 7321 | fp = mg_fopen(buf, "r"); | ~~~~~~~~~~~~~~~~~~~~~~~~ 7322 | } else { | ~~~~~~~~ 7323 | p = strrchr(path.p, DIRSEP); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7324 | if (p == NULL) p = path.p; | ~~~~~~~~~~~~~~~~~~~~~~~~~~ 7325 | snprintf(buf, sizeof(buf), "%.*s%c%s", (int) (p - path.p), path.p, DIRSEP, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7326 | passwords_file); | ~~~~~~~~~~~~~~~~ 7327 | fp = mg_fopen(buf, "r"); | ~~~~~~~~~~~~~~~~~~~~~~~~ 7328 | } | ~ 7329 | | 7330 | if (fp != NULL) { | ~~~~~~~~~~~~~~~~~ 7331 | authorized = mg_http_check_digest_auth(hm, domain, fp); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7332 | fclose(fp); | ~~~~~~~~~~~ 7333 | } else if (!(flags & MG_AUTH_FLAG_ALLOW_MISSING_FILE)) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7334 | authorized = 0; | ~~~~~~~~~~~~~~~ 7335 | } | ~ 7336 | } | ~ 7337 | | 7338 | LOG(LL_DEBUG, ("%.*s %s %x %d", (int) path.len, path.p, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7339 | passwords_file ? passwords_file : "", flags, authorized)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7340 | return authorized; | ~~~~~~~~~~~~~~~~~~ 7341 | } | ~ 7342 | #else | ~~~~~ 7343 | int mg_http_is_authorized(struct http_message *hm, const struct mg_str path, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7344 | const char *domain, const char *passwords_file, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7345 | int flags) { | ~~~~~~~~~~~~ 7346 | (void) hm; | ~~~~~~~~~~ 7347 | (void) path; | ~~~~~~~~~~~~ 7348 | (void) domain; | ~~~~~~~~~~~~~~ 7349 | (void) passwords_file; | ~~~~~~~~~~~~~~~~~~~~~~ 7350 | (void) flags; | ~~~~~~~~~~~~~ 7351 | return 1; | ~~~~~~~~~ 7352 | } | ~ 7353 | #endif | ~~~~~~ 7354 | | 7355 | #if MG_ENABLE_DIRECTORY_LISTING | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7356 | static void mg_escape(const char *src, char *dst, size_t dst_len) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7357 | size_t n = 0; | ~~~~~~~~~~~~~ 7358 | while (*src != '\0' && n + 5 < dst_len) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7359 | unsigned char ch = *(unsigned char *) src++; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7360 | if (ch == '<') { | ~~~~~~~~~~~~~~~~ 7361 | n += snprintf(dst + n, dst_len - n, "%s", "<"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7362 | } else { | ~~~~~~~~ 7363 | dst[n++] = ch; | ~~~~~~~~~~~~~~ 7364 | } | ~ 7365 | } | ~ 7366 | dst[n] = '\0'; | ~~~~~~~~~~~~~~ 7367 | } | ~ 7368 | | 7369 | static void mg_print_dir_entry(struct mg_connection *nc, const char *file_name, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7370 | cs_stat_t *stp) { | ~~~~~~~~~~~~~~~~~ 7371 | char size[64], mod[64], path[MG_MAX_PATH]; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7372 | int64_t fsize = stp->st_size; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7373 | int is_dir = S_ISDIR(stp->st_mode); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7374 | const char *slash = is_dir ? "/" : ""; | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7375 | struct mg_str href; | ~~~~~~~~~~~~~~~~~~~ 7376 | | 7377 | if (is_dir) { | ~~~~~~~~~~~~~ 7378 | snprintf(size, sizeof(size), "%s", "[DIRECTORY]"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7379 | } else { | ~~~~~~~~ 7380 | /* | ~~ 7381 | * We use (double) cast below because MSVC 6 compiler cannot | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7382 | * convert unsigned __int64 to double. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7383 | */ | ~~ 7384 | if (fsize < 1024) { | ~~~~~~~~~~~~~~~~~~~ 7385 | snprintf(size, sizeof(size), "%d", (int) fsize); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7386 | } else if (fsize < 0x100000) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7387 | snprintf(size, sizeof(size), "%.1fk", (double) fsize / 1024.0); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7388 | } else if (fsize < 0x40000000) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7389 | snprintf(size, sizeof(size), "%.1fM", (double) fsize / 1048576); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7390 | } else { | ~~~~~~~~ 7391 | snprintf(size, sizeof(size), "%.1fG", (double) fsize / 1073741824); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7392 | } | ~ 7393 | } | ~ 7394 | strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", localtime(&stp->st_mtime)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7395 | mg_escape(file_name, path, sizeof(path)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7396 | href = mg_url_encode(mg_mk_str(file_name)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7397 | mg_printf_http_chunk(nc, | ~~~~~~~~~~~~~~~~~~~~~~~~ 7398 | "%s%s" | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7399 | "%s%s\n", | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7400 | href.p, slash, path, slash, mod, is_dir ? -1 : fsize, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7401 | size); | ~~~~~~ 7402 | free((void *) href.p); | ~~~~~~~~~~~~~~~~~~~~~~ 7403 | } | ~ 7404 | | 7405 | static void mg_scan_directory(struct mg_connection *nc, const char *dir, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7406 | const struct mg_serve_http_opts *opts, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7407 | void (*func)(struct mg_connection *, const char *, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7408 | cs_stat_t *)) { | ~~~~~~~~~~~~~~~ 7409 | char path[MG_MAX_PATH]; | ~~~~~~~~~~~~~~~~~~~~~~~ 7410 | cs_stat_t st; | ~~~~~~~~~~~~~ 7411 | struct dirent *dp; | ~~~~~~~~~~~~~~~~~~ 7412 | DIR *dirp; | ~~~~~~~~~~ 7413 | | 7414 | LOG(LL_DEBUG, ("%p [%s]", nc, dir)); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7415 | if ((dirp = (opendir(dir))) != NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7416 | while ((dp = readdir(dirp)) != NULL) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7417 | /* Do not show current dir and hidden files */ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7418 | if (mg_is_file_hidden((const char *) dp->d_name, opts, 1)) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7419 | continue; | ~~~~~~~~~ 7420 | } | ~ 7421 | snprintf(path, sizeof(path), "%s/%s", dir, dp->d_name); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7422 | if (mg_stat(path, &st) == 0) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7423 | func(nc, (const char *) dp->d_name, &st); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7424 | } | ~ 7425 | } | ~ 7426 | closedir(dirp); | ~~~~~~~~~~~~~~~ 7427 | } else { | ~~~~~~~~ 7428 | LOG(LL_DEBUG, ("%p opendir(%s) -> %d", nc, dir, mg_get_errno())); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7429 | } | ~ 7430 | } | ~ 7431 | | 7432 | static void mg_send_directory_listing(struct mg_connection *nc, const char *dir, | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7433 | struct http_message *hm, | ~~~~~~~~~~~~~~~~~~~~~~~~ 7434 | struct mg_serve_http_opts *opts) { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7435 | static const char *sort_js_code = | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7436 | ""; | ~~~~~~~~~~~~ 7458 | | 7459 | mg_send_response_line(nc, 200, opts->extra_headers); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7460 | mg_printf(nc, "%s: %s\r\n%s: %s\r\n\r\n", "Transfer-Encoding", "chunked", | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7461 | "Content-Type", "text/html; charset=utf-8"); | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7462 | | 7463 | mg_printf_http_chunk( | ~~~~~~~~~~~~~~~~~~~~~ 7464 | nc, | ~~~ 7465 | "%s%s" | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7466 | "\n" | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7468 | "

Index of %.*s