From cf47cb41ec5766e4d4ec10596671fc6af9e35468 Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Mon, 2 Jan 2023 15:36:14 +0000 Subject: [PATCH] enhanced the directory listing handler in bin/webs.c --- bin/webs.c | 141 ++++++++++++++++++++++++++----- lib/hio-http.h | 44 +++++++--- lib/http.c | 219 +++++++++++++++++++++++++++++++++++-------------- 3 files changed, 309 insertions(+), 95 deletions(-) diff --git a/bin/webs.c b/bin/webs.c index b5a30c0..9776b13 100644 --- a/bin/webs.c +++ b/bin/webs.c @@ -27,8 +27,16 @@ struct htts_ext_t }; typedef struct htts_ext_t htts_ext_t; +struct buff_t +{ + hio_uint8_t buf[4096]; + hio_oow_t len; +}; +typedef struct buff_t buff_t; -void untar (hio_t* hio, hio_dev_thr_iopair_t* iop, hio_svc_htts_thr_func_info_t* tfi, void* ctx) +/* ------------------------------------------------------------------------- */ + +static void untar (hio_t* hio, hio_dev_thr_iopair_t* iop, hio_svc_htts_thr_func_info_t* tfi, void* ctx) { FILE* wfp = HIO_NULL; htts_ext_t* ext; @@ -82,6 +90,70 @@ done: } } +/* ------------------------------------------------------------------------- */ + +static hio_oow_t write_all_to_fd (int fd, const hio_uint8_t* ptr, hio_oow_t len) +{ + hio_oow_t rem = len; + + while (rem > 0) + { + hio_ooi_t n; + n = write(fd, ptr, rem); + if (n <= -1) break; + rem -= n; + ptr += n; + } + + return len - rem; /* return the number of bytes written */ +} + +static HIO_INLINE void init_buff (buff_t* buf) +{ + buf->len = 0; +} + +static int flush_buff_to_fd (int fd, buff_t* buf) +{ + if (buf->len > 0) + { + hio_oow_t n; + n = write_all_to_fd(fd, buf->buf, buf->len); + buf->len -= n; + if (buf->len > 0) return -1; + } + return 0; +} + +static int write_buff_to_fd (int fd, buff_t* buf, const void* ptr, hio_oow_t len) +{ + hio_oow_t rcapa; + + rcapa = HIO_COUNTOF(buf->buf) - buf->len; + if (len >= HIO_COUNTOF(buf->buf) + rcapa) + { + if (flush_buff_to_fd(fd, buf) <= -1) return -1; + if (write_all_to_fd(fd, (const hio_uint8_t*)ptr, len) != len) return -1; + } + else if (len >= rcapa) + { + HIO_MEMCPY (&buf->buf[buf->len], ptr, rcapa); + buf->len += rcapa; + if (flush_buff_to_fd(fd, buf) <= -1) return -1; + HIO_MEMCPY (buf->buf, (const hio_uint8_t*)ptr + rcapa, len - rcapa); + buf->len = len - rcapa; + } + else + { + HIO_MEMCPY (&buf->buf[buf->len], ptr, len); + buf->len += len; + } + + return 0; +} + +/* ------------------------------------------------------------------------- */ + static const hio_bch_t* file_get_mime_type (hio_svc_htts_t* htts, const hio_bch_t* qpath, const hio_bch_t* file_path, void* ctx) { const hio_bch_t* mt = HIO_NULL; @@ -99,6 +171,7 @@ static int file_open_dir_list (hio_svc_htts_t* htts, const hio_bch_t* qpath, con hio_bch_t file_path[] = "/tmp/.XXXXXX"; int fd = -1; struct dirent* de; + buff_t buf; if (ext->ai->file_load_index_page) { @@ -134,42 +207,66 @@ static int file_open_dir_list (hio_svc_htts_t* htts, const hio_bch_t* qpath, con unlink (file_path); - write (fd, "", 12); - if (!(qpath[0] == '\0' || (qpath[0] == '/' && qpath[1] == '\0'))) - write (fd, "
  • ..", 23); + buf.len = 0; + init_buff (&buf); + + if (write_buff_to_fd(fd, &buf, "", 12) <= -1) goto oops; + if (!(qpath[0] == '\0' || (qpath[0] == '/' && qpath[1] == '\0')) && + write_buff_to_fd(fd, &buf,"
  • ..", 23) <= -1) goto oops; -/* TODO: sorting, other informatino like size, */ -/* TODO: error handling of write() error */ while ((de = readdir(dp))) { struct stat st; - hio_bch_t* tmp_path; + hio_bch_t* tptr, * dend; + hio_bch_t tmp[1024]; /* this must be at least 5 characters large for html escaping */ + hio_oow_t tml; int n; if ((de->d_name[0] == '.' && de->d_name[1] == '\0') || (de->d_name[0] == '.' && de->d_name[1] == '.' && de->d_name[2] == '\0')) continue; - tmp_path = hio_svc_htts_dupmergepaths(htts, dir_path, de->d_name); - if (HIO_UNLIKELY(!tmp_path)) continue; - n = stat(tmp_path, &st); - hio_freemem (hio, tmp_path); + tptr = hio_svc_htts_dupmergepaths(htts, dir_path, de->d_name); + if (HIO_UNLIKELY(!tptr)) continue; + n = stat(tptr, &st); + hio_freemem (hio, tptr); if (HIO_UNLIKELY(n <= -1)) continue; - write (fd, "
  • d_name + strlen(de->d_name); + + if (write_buff_to_fd(fd, &buf, "
  • d_name; tptr < dend; ) { - char tmp[1000]; /* TODO:use dynamic buffer?? */ - hio_perenc_http_bcstr(0, de->d_name, tmp, HIO_NULL); /* url encoding */ - //write (fd, de->d_name, strlen(de->d_name)); - write (fd, tmp, strlen(tmp)); + hio_oow_t dlen = dend - tptr; + if (dlen > HIO_COUNTOF(tmp) / 3) dlen = HIO_COUNTOF(tmp) / 3; /* it can grow upto 3 folds */ + HIO_ASSERT (hio, dlen >= 1); + tml = hio_perenc_http_bchars(tptr, dlen, tmp, HIO_COUNTOF(tmp), 0); /* feed a chunk that won't overflow the buffer */ + HIO_ASSERT (hio, tml <= HIO_COUNTOF(tmp)); /* the buffer 'tmp' must be large enough */ + if (write_buff_to_fd(fd, &buf, tmp, tml) <= -1) goto oops; + tptr += dlen; } - if (S_ISDIR(st.st_mode)) write (fd, "/", 1); - write (fd, "\">", 2); - write (fd, de->d_name, strlen(de->d_name)); /* TODO: html entity encoding */ - if (S_ISDIR(st.st_mode)) write (fd, "/", 1); - write (fd, "", 4); + + if (S_ISDIR(st.st_mode) && write_buff_to_fd(fd, &buf, "/", 1) <= -1) goto oops; + if (write_buff_to_fd(fd, &buf, "\">", 2) <= -1) goto oops; + + dend = de->d_name + strlen(de->d_name); + for (tptr = de->d_name; tptr < dend; ) + { + hio_oow_t dlen = dend - tptr; + if (dlen > HIO_COUNTOF(tmp) / 5) dlen = HIO_COUNTOF(tmp) / 5; /* it can grow upto 5 folds */ + HIO_ASSERT (hio, dlen >= 1); + tml = hio_escape_html_bchars(tptr, dlen, tmp, HIO_COUNTOF(tmp)); /* feed a chunk that won't overflow the buffer */ + HIO_ASSERT (hio, tml <= HIO_COUNTOF(tmp)); /* the buffer 'tmp' must be large enough */ + if (write_buff_to_fd(fd, &buf, tmp, tml) <= -1) goto oops; + tptr += dlen; + } + + if (S_ISDIR(st.st_mode) && write_buff_to_fd(fd, &buf, "/", 1) <= -1) goto oops; + if (write_buff_to_fd(fd, &buf, "", 4) <= -1) goto oops; } - write (fd, "\n", 15); + if (write_buff_to_fd(fd, &buf, "\n", 15) <= -1) goto oops; + if (flush_buff_to_fd(fd, &buf) <= -1) goto oops; closedir (dp); lseek (fd, SEEK_SET, 0); diff --git a/lib/hio-http.h b/lib/hio-http.h index 4cf8f04..45f9ca4 100644 --- a/lib/hio-http.h +++ b/lib/hio-http.h @@ -257,26 +257,32 @@ HIO_EXPORT hio_oow_t hio_perdec_http_bcs ( /** * The hio_perenc_http_bcstr() function performs percent-encoding over a string. - * The caller must ensure that the output buffer \a buf is large enough. - * If \a nencs is not #HIO_NULL, it is set to the number of characters - * encoded. 0 means no characters in the input string required encoding. - * \return the length of the output string. + * It returns the length of the encoded string if \a len is long enough to hold + * the resulting string and the terminating null. If the return value is equal to + * or greater than \a len, the buffer pointed to by \a buf of the length \a len + * is not large enough. + * \return the length of the output string encoded on success or the number of encoded + * string that would have been written if the buffer has been large enough. */ HIO_EXPORT hio_oow_t hio_perenc_http_bcstr ( - int opt, /**< 0 or bitwise-OR'ed of #hio_perenc_http_bcstr_opt_t */ const hio_bch_t* str, hio_bch_t* buf, - hio_oow_t* nencs + hio_oow_t len, + int opt /**< 0 or bitwise-OR'ed of #hio_perenc_http_bcstr_opt_t */ ); -#if 0 -/* TODO: rename this function according to the naming convension */ -HIO_EXPORT hio_bch_t* hio_perenc_http_bcstrdup ( - int opt, /**< 0 or bitwise-OR'ed of #hio_perenc_http_bcstr_opt_t */ - const hio_bch_t* str, - hio_mmgr_t* mmgr +/** + * The hio_perenc_http_bchars() function performs percent-ending over a length-bound string. + * It doesn't null-terminate the result. The buffer requirement is less than hio_perenc_http_bcstr() + * by 1. + */ +HIO_EXPORT hio_oow_t hio_perenc_http_bchars ( + const hio_bch_t* str, + hio_oow_t sln, + hio_bch_t* buf, + hio_oow_t len, + int opt /**< 0 or bitwise-OR'ed of #hio_perenc_http_bcstr_opt_t */ ); -#endif HIO_EXPORT int hio_scan_http_qparam ( hio_bch_t* qparam, @@ -284,6 +290,18 @@ HIO_EXPORT int hio_scan_http_qparam ( void* ctx ); +HIO_EXPORT hio_oow_t hio_escape_html_bchars ( + const hio_bch_t* str, + hio_oow_t sln, + hio_bch_t* buf, + hio_oow_t len +); + +HIO_EXPORT hio_oow_t hio_escape_html_bcstr ( + const hio_bch_t* str, + hio_bch_t* buf, + hio_oow_t len +); /* ------------------------------------------------------------------------- */ /* HTTP SERVER SERVICE */ /* ------------------------------------------------------------------------- */ diff --git a/lib/http.c b/lib/http.c index d0a969a..abef080 100644 --- a/lib/http.c +++ b/lib/http.c @@ -499,87 +499,73 @@ hio_oow_t hio_perdec_http_bcs (const hio_bcs_t* str, hio_bch_t* buf, hio_oow_t* #define TO_HEX(v) ("0123456789ABCDEF"[(v) & 15]) -hio_oow_t hio_perenc_http_bcstr (int opt, const hio_bch_t* str, hio_bch_t* buf, hio_oow_t* nencs) +hio_oow_t hio_perenc_http_bchars (const hio_bch_t* str, hio_oow_t sln, hio_bch_t* buf, hio_oow_t len, int opt) { - const hio_bch_t* p = str; + const hio_bch_t* ptr, * end = str + sln; hio_bch_t* out = buf; - hio_oow_t enc_count = 0; + hio_bch_t slash; + hio_oow_t reqlen = 0; - /* this function doesn't accept the size of the buffer. the caller must - * ensure that the buffer is large enough */ + slash = (opt & HIO_PERENC_HTTP_KEEP_SLASH)? '/': '\0'; - if (opt & HIO_PERENC_HTTP_KEEP_SLASH) + for (ptr = str; ptr < end; ptr++) { - while (*p != '\0') + reqlen += (IS_UNRESERVED(*ptr) || *ptr == slash)? 1: 3; + } + + if (len >= reqlen) + { + ptr = str; + while (ptr < end) { - if (IS_UNRESERVED(*p) || *p == '/') *out++ = *p; + if (IS_UNRESERVED(*ptr) || *ptr == slash) *out++ = *ptr; else { *out++ = '%'; - *out++ = TO_HEX (*p >> 4); - *out++ = TO_HEX (*p & 15); - enc_count++; + *out++ = TO_HEX(*ptr >> 4); + *out++ = TO_HEX(*ptr & 15); } - p++; + ptr++; } } - else - { - while (*p != '\0') - { - if (IS_UNRESERVED(*p)) *out++ = *p; - else - { - *out++ = '%'; - *out++ = TO_HEX (*p >> 4); - *out++ = TO_HEX (*p & 15); - enc_count++; - } - p++; - } - } - *out = '\0'; - if (nencs) *nencs = enc_count; - return out - buf; + + return reqlen; } -#if 0 -hio_bch_t* hio_perenc_http_bcstrdup (int opt, const hio_bch_t* str, hio_mmgr_t* mmgr) +hio_oow_t hio_perenc_http_bcstr (const hio_bch_t* str, hio_bch_t* buf, hio_oow_t len, int opt) { - hio_bch_t* buf; - hio_oow_t len = 0; - hio_oow_t count = 0; - - /* count the number of characters that should be encoded */ - if (opt & HIO_PERENC_HTTP_KEEP_SLASH) + const hio_bch_t* ptr = str; + hio_bch_t* out = buf; + hio_bch_t slash; + hio_oow_t reqlen = 0; + + slash = (opt & HIO_PERENC_HTTP_KEEP_SLASH)? '/': '\0'; + + for (ptr = str; *ptr != '\0'; ptr++) { - for (len = 0; str[len] != '\0'; len++) - { - if (!IS_UNRESERVED(str[len]) && str[len] != '/') count++; - } - } - else - { - for (len = 0; str[len] != '\0'; len++) - { - if (!IS_UNRESERVED(str[len])) count++; - } + reqlen += (IS_UNRESERVED(*ptr) || *ptr == slash)? 1: 3; } - /* if there are no characters to escape, just return the original string */ - if (count <= 0) return (hio_bch_t*)str; + if (len > reqlen) + { + ptr = str; + while (*ptr != '\0') + { + if (IS_UNRESERVED(*ptr) || *ptr == slash) *out++ = *ptr; + else + { + *out++ = '%'; + *out++ = TO_HEX(*ptr >> 4); + *out++ = TO_HEX(*ptr & 15); + } + ptr++; + } - /* allocate a buffer of an optimal size for escaping, otherwise */ - buf = HIO_MMGR_ALLOC(mmgr, (len + (count * 2) + 1) * HIO_SIZEOF(*buf)); - if (!buf) return HIO_NULL; + *out = '\0'; + } - /* perform actual escaping */ - hio_perenc_http_bcstr (opt, str, buf, HIO_NULL); - - return buf; + return reqlen; } -#endif - int hio_scan_http_qparam (hio_bch_t* qparam, int (*qparamcb) (hio_bcs_t* key, hio_bcs_t* val, void* ctx), void* ctx) { @@ -638,3 +624,116 @@ int hio_scan_http_qparam (hio_bch_t* qparam, int (*qparamcb) (hio_bcs_t* key, hi return 0; } + +hio_oow_t hio_escape_html_bchars (const hio_bch_t* str, hio_oow_t sln, hio_bch_t* buf, hio_oow_t len) +{ + hio_bch_t* ptr, * end = str + sln; + hio_oow_t reqlen = 0; + + for (ptr = (hio_bch_t*)str; ptr < end; ptr++) + { + switch (*ptr) + { + case '<': + case '>': + reqlen += 4; + break; + + case '&': + reqlen += 5; + break; + + default: + reqlen++; + break; + } + } + + if (len >= reqlen) + { + /* the buffer is large enough */ + ptr = buf; + while (str < end) + { + switch (*str) + { + case '<': + *ptr++ = '&'; *ptr++ = 'l'; *ptr++ = 't'; *ptr++ = ';'; + break; + + case '>': + *ptr++ = '&'; *ptr++ = 'g'; *ptr++ = 't'; *ptr++ = ';'; + break; + + case '&': + *ptr++ = '&'; *ptr++ = 'a'; *ptr++ = 'm'; *ptr++ = 'p'; *ptr++ = ';'; + break; + + default: + *ptr++ = *str; + break; + } + str++; + } + } + + /* NOTE no null termination */ + return reqlen; +} + +hio_oow_t hio_escape_html_bcstr (const hio_bch_t* str, hio_bch_t* buf, hio_oow_t len) +{ + hio_bch_t* ptr; + hio_oow_t reqlen = 0; + + for (ptr = (hio_bch_t*)str; *ptr != '\0'; ptr++) + { + switch (*ptr) + { + case '<': + case '>': + reqlen += 4; + break; + + case '&': + reqlen += 5; + break; + + default: + reqlen++; + break; + } + } + + if (len > reqlen) + { + /* the buffer is large enough */ + ptr = buf; + while (*str != '\0') + { + switch (*str) + { + case '<': + *ptr++ = '&'; *ptr++ = 'l'; *ptr++ = 't'; *ptr++ = ';'; + break; + + case '>': + *ptr++ = '&'; *ptr++ = 'g'; *ptr++ = 't'; *ptr++ = ';'; + break; + + case '&': + *ptr++ = '&'; *ptr++ = 'a'; *ptr++ = 'm'; *ptr++ = 'p'; *ptr++ = ';'; + break; + + default: + *ptr++ = *str; + break; + } + str++; + } + + *ptr = '\0'; + } + + return reqlen; +}