hyung-hwan/hio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

enhanced the directory listing handler in bin/webs.c

Browse Source
This commit is contained in:
hyung-hwan 2023-01-02 15:36:14 +00:00
parent b864800a71
commit cf47cb41ec
3 changed files with 309 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
bin/webs.c
View File

@ -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, "<html><body>", 12);
if (!(qpath[0] == '\0' || (qpath[0] == '/' && qpath[1] == '\0')))
write (fd, "<li><a href=\"..\">..</a>", 23);
buf.len = 0;
init_buff (&buf);
if (write_buff_to_fd(fd, &buf, "<html><body>", 12) <= -1) goto oops;
if (!(qpath[0] == '\0' || (qpath[0] == '/' && qpath[1] == '\0')) &&
write_buff_to_fd(fd, &buf,"<li><a href=\"..\">..</a>", 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, "<li><a href=\"", 13);
dend = de->d_name + strlen(de->d_name);
if (write_buff_to_fd(fd, &buf, "<li><a href=\"", 13) <= -1) goto oops;
for (tptr = de->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));
}
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, "</a>", 4);
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;
}
write (fd, "</body></html>\n", 15);
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, "</a>", 4) <= -1) goto oops;
}
if (write_buff_to_fd(fd, &buf, "</body></html>\n", 15) <= -1) goto oops;
if (flush_buff_to_fd(fd, &buf) <= -1) goto oops;
closedir (dp);
lseek (fd, SEEK_SET, 0);

42
lib/hio-http.h
View File

@ -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 */
/**
* 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_mmgr_t* mmgr
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 */
/* ------------------------------------------------------------------------- */

215
lib/http.c
View File

@ -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)
{
if (IS_UNRESERVED(*p) || *p == '/') *out++ = *p;
ptr = str;
while (ptr < end)
{
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
return reqlen;
}
hio_oow_t hio_perenc_http_bcstr (const hio_bch_t* str, hio_bch_t* buf, hio_oow_t len, int opt)
{
while (*p != '\0')
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++)
{
if (IS_UNRESERVED(*p)) *out++ = *p;
reqlen += (IS_UNRESERVED(*ptr) || *ptr == slash)? 1: 3;
}
if (len > reqlen)
{
ptr = str;
while (*ptr != '\0')
{
if (IS_UNRESERVED(*ptr) || *ptr == slash) *out++ = *ptr;
else
{
*out++ = '%';
*out++ = TO_HEX (*p >> 4);
*out++ = TO_HEX (*p & 15);
enc_count++;
}
p++;
*out++ = TO_HEX(*ptr >> 4);
*out++ = TO_HEX(*ptr & 15);
}
ptr++;
}
*out = '\0';
if (nencs) *nencs = enc_count;
return out - buf;
}
#if 0
hio_bch_t* hio_perenc_http_bcstrdup (int opt, const hio_bch_t* str, hio_mmgr_t* mmgr)
{
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)
{
for (len = 0; str[len] != '\0'; len++)
{
if (!IS_UNRESERVED(str[len]) && str[len] != '/') count++;
return reqlen;
}
}
else
{
for (len = 0; str[len] != '\0'; len++)
{
if (!IS_UNRESERVED(str[len])) count++;
}
}
/* if there are no characters to escape, just return the original string */
if (count <= 0) return (hio_bch_t*)str;
/* 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;
/* perform actual escaping */
hio_perenc_http_bcstr (opt, str, buf, HIO_NULL);
return buf;
}
#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;
}