From eb1f8af86bdba4915c63597f6ad69316a047369c Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Thu, 12 Jan 2023 00:41:01 +0900 Subject: [PATCH] renamed rsrc to task in the htts service --- lib/hio-http.h | 36 ++++++++++++------------- lib/http-cgi.c | 40 ++++++++++++++-------------- lib/http-fcgi.c | 28 ++++++++++---------- lib/http-file.c | 36 ++++++++++++------------- lib/http-prv.h | 4 +-- lib/http-svr.c | 70 ++++++++++++++++++++++++------------------------- lib/http-thr.c | 42 ++++++++++++++--------------- lib/http-txt.c | 26 +++++++++--------- 8 files changed, 141 insertions(+), 141 deletions(-) diff --git a/lib/hio-http.h b/lib/hio-http.h index f6ea12a..240e4e2 100644 --- a/lib/hio-http.h +++ b/lib/hio-http.h @@ -81,27 +81,27 @@ typedef struct hio_svc_httc_t hio_svc_httc_t; /* -------------------------------------------------------------- */ -typedef struct hio_svc_htts_rsrc_t hio_svc_htts_rsrc_t; +typedef struct hio_svc_htts_task_t hio_svc_htts_task_t; -typedef void (*hio_svc_htts_rsrc_on_kill_t) ( - hio_svc_htts_rsrc_t* rsrc +typedef void (*hio_svc_htts_task_on_kill_t) ( + hio_svc_htts_task_t* task ); -#define HIO_SVC_HTTS_RSRC_HEADER \ +#define HIO_SVC_HTTS_TASK_HEADER \ hio_svc_htts_t* htts; \ - hio_oow_t rsrc_size; \ - hio_oow_t rsrc_refcnt; \ - hio_svc_htts_rsrc_t* task_prev; \ - hio_svc_htts_rsrc_t* task_next; \ - hio_svc_htts_rsrc_on_kill_t rsrc_on_kill + hio_oow_t task_size; \ + hio_oow_t task_refcnt; \ + hio_svc_htts_task_t* task_prev; \ + hio_svc_htts_task_t* task_next; \ + hio_svc_htts_task_on_kill_t task_on_kill -struct hio_svc_htts_rsrc_t +struct hio_svc_htts_task_t { - HIO_SVC_HTTS_RSRC_HEADER; + HIO_SVC_HTTS_TASK_HEADER; }; -#define HIO_SVC_HTTS_RSRC_REF(rsrc, var) do { (var) = (rsrc); ++(rsrc)->rsrc_refcnt; } while(0) -#define HIO_SVC_HTTS_RSRC_UNREF(rsrc_var) do { if (--(rsrc_var)->rsrc_refcnt == 0) { hio_svc_htts_rsrc_t* __rsrc_tmp = (rsrc_var); (rsrc_var) = HIO_NULL; hio_svc_htts_rsrc_kill(__rsrc_tmp); } else { (rsrc_var) = HIO_NULL; } } while(0) +#define HIO_SVC_HTTS_TASK_REF(task, var) do { (var) = (task); ++(task)->task_refcnt; } while(0) +#define HIO_SVC_HTTS_TASK_UNREF(task_var) do { if (--(task_var)->task_refcnt == 0) { hio_svc_htts_task_t* __task_tmp = (task_var); (task_var) = HIO_NULL; hio_svc_htts_task_kill(__task_tmp); } else { (task_var) = HIO_NULL; } } while(0) /* -------------------------------------------------------------- */ @@ -431,14 +431,14 @@ HIO_EXPORT int hio_svc_htts_dotxt ( int options ); -HIO_EXPORT hio_svc_htts_rsrc_t* hio_svc_htts_rsrc_make ( +HIO_EXPORT hio_svc_htts_task_t* hio_svc_htts_task_make ( hio_svc_htts_t* htts, - hio_oow_t rsrc_size, - hio_svc_htts_rsrc_on_kill_t on_kill + hio_oow_t task_size, + hio_svc_htts_task_on_kill_t on_kill ); -HIO_EXPORT void hio_svc_htts_rsrc_kill ( - hio_svc_htts_rsrc_t* rsrc +HIO_EXPORT void hio_svc_htts_task_kill ( + hio_svc_htts_task_t* task ); diff --git a/lib/http-cgi.c b/lib/http-cgi.c index 652bdea..8184717 100644 --- a/lib/http-cgi.c +++ b/lib/http-cgi.c @@ -56,7 +56,7 @@ typedef enum cgi_res_mode_t cgi_res_mode_t; struct cgi_t { - HIO_SVC_HTTS_RSRC_HEADER; + HIO_SVC_HTTS_TASK_HEADER; int options; hio_oow_t num_pending_writes_to_client; @@ -231,10 +231,10 @@ static HIO_INLINE void cgi_mark_over (cgi_t* cgi, int over_bits) if (cgi->keep_alive && !cgi->client_eof_detected) { /* how to arrange to delete this cgi object and put the socket back to the normal waiting state??? */ - HIO_ASSERT (cgi->htts->hio, cgi->client->rsrc == (hio_svc_htts_rsrc_t*)cgi); + HIO_ASSERT (cgi->htts->hio, cgi->client->task == (hio_svc_htts_task_t*)cgi); -/*printf ("DETACHING FROM THE MAIN CLIENT RSRC... state -> %p\n", cgi->client->rsrc);*/ - HIO_SVC_HTTS_RSRC_UNREF (cgi->client->rsrc); +/*printf ("DETACHING FROM THE MAIN CLIENT TASK... state -> %p\n", cgi->client->task);*/ + HIO_SVC_HTTS_TASK_UNREF (cgi->client->task); /* cgi must not be accessed from here down as it could have been destroyed */ } else @@ -246,9 +246,9 @@ static HIO_INLINE void cgi_mark_over (cgi_t* cgi, int over_bits) } } -static void cgi_on_kill (hio_svc_htts_rsrc_t* rsrc) +static void cgi_on_kill (hio_svc_htts_task_t* task) { - cgi_t* cgi = (cgi_t*)rsrc; + cgi_t* cgi = (cgi_t*)task; hio_t* hio = cgi->htts->hio; HIO_DEBUG2 (hio, "HTTS(%p) - killing cgi client(%p)\n", cgi->htts, cgi->client->sck); @@ -323,8 +323,8 @@ static void peer_on_close (hio_dev_pro_t* pro, hio_dev_pro_sid_t sid) cgi->peer = HIO_NULL; /* clear this peer from the state */ HIO_ASSERT (hio, peer_xtn->cgi != HIO_NULL); -/*printf ("DETACHING FROM CGI PEER DEVICE.....................%p %d\n", peer->cgi, (int)peer->cgi->rsrc_refcnt);*/ - HIO_SVC_HTTS_RSRC_UNREF (peer_xtn->cgi); +/*printf ("DETACHING FROM CGI PEER DEVICE.....................%p %d\n", peer->cgi, (int)peer->cgi->task_refcnt);*/ + HIO_SVC_HTTS_TASK_UNREF (peer_xtn->cgi); if (cgi->peer_htrd) { @@ -332,8 +332,8 @@ static void peer_on_close (hio_dev_pro_t* pro, hio_dev_pro_sid_t sid) * it's safe to detach the extra information attached on the htrd object. */ peer_xtn = hio_htrd_getxtn(cgi->peer_htrd); HIO_ASSERT (hio, peer_xtn->cgi != HIO_NULL); -/*printf ("DETACHING FROM CGI PEER HTRD.....................%p %d\n", peer->cgi, (int)peer->cgi->rsrc_refcnt);*/ - HIO_SVC_HTTS_RSRC_UNREF (peer_xtn->cgi); +/*printf ("DETACHING FROM CGI PEER HTRD.....................%p %d\n", peer->cgi, (int)peer->cgi->task_refcnt);*/ + HIO_SVC_HTTS_TASK_UNREF (peer_xtn->cgi); } break; @@ -588,7 +588,7 @@ static int cgi_client_htrd_poke (hio_htrd_t* htrd, hio_htre_t* req) hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - cgi_t* cgi = (cgi_t*)cli->rsrc; + cgi_t* cgi = (cgi_t*)cli->task; /*printf (">> CLIENT REQUEST COMPLETED\n");*/ @@ -604,7 +604,7 @@ static int cgi_client_htrd_push_content (hio_htrd_t* htrd, hio_htre_t* req, cons hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - cgi_t* cgi = (cgi_t*)cli->rsrc; + cgi_t* cgi = (cgi_t*)cli->task; HIO_ASSERT (sck->hio, cli->sck == sck); return cgi_write_to_peer(cgi, data, dlen); @@ -671,7 +671,7 @@ oops: static void cgi_client_on_disconnect (hio_dev_sck_t* sck) { hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - cgi_t* cgi = (cgi_t*)cli->rsrc; + cgi_t* cgi = (cgi_t*)cli->task; cgi->client_disconnected = 1; cgi->client_org_on_disconnect (sck); } @@ -680,7 +680,7 @@ static int cgi_client_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - cgi_t* cgi = (cgi_t*)cli->rsrc; + cgi_t* cgi = (cgi_t*)cli->task; HIO_ASSERT (hio, sck == cli->sck); @@ -734,7 +734,7 @@ static int cgi_client_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wrc { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - cgi_t* cgi = (cgi_t*)cli->rsrc; + cgi_t* cgi = (cgi_t*)cli->task; if (wrlen <= -1) { @@ -954,7 +954,7 @@ int hio_svc_htts_docgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r mi.on_fork = peer_on_fork; mi.fork_ctx = &fc; - cgi = (cgi_t*)hio_svc_htts_rsrc_make(htts, HIO_SIZEOF(*cgi), cgi_on_kill); + cgi = (cgi_t*)hio_svc_htts_task_make(htts, HIO_SIZEOF(*cgi), cgi_on_kill); if (HIO_UNLIKELY(!cgi)) goto oops; cgi->options = options; @@ -973,8 +973,8 @@ int hio_svc_htts_docgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r csck->on_write = cgi_client_on_write; csck->on_disconnect = cgi_client_on_disconnect; - HIO_ASSERT (hio, cli->rsrc == HIO_NULL); - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)cgi, cli->rsrc); /* cli->rsrc = cgi */ + HIO_ASSERT (hio, cli->task == HIO_NULL); + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)cgi, cli->task); /* cli->task = cgi */ if (access(mi.cmd, X_OK) == -1) { @@ -985,7 +985,7 @@ int hio_svc_htts_docgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r cgi->peer = hio_dev_pro_make(hio, HIO_SIZEOF(*peer_xtn), &mi); if (HIO_UNLIKELY(!cgi->peer)) goto oops; peer_xtn = hio_dev_pro_getxtn(cgi->peer); - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)cgi, peer_xtn->cgi); /* peer->cgi in pro = cgi */ + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)cgi, peer_xtn->cgi); /* peer->cgi in pro = cgi */ cgi->peer_htrd = hio_htrd_open(hio, HIO_SIZEOF(*peer_xtn)); if (HIO_UNLIKELY(!cgi->peer_htrd)) goto oops; @@ -993,7 +993,7 @@ int hio_svc_htts_docgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r hio_htrd_setrecbs (cgi->peer_htrd, &peer_htrd_recbs); peer_xtn = hio_htrd_getxtn(cgi->peer_htrd); - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)cgi, peer_xtn->cgi); /* peer->cgi in htrd = cgi */ + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)cgi, peer_xtn->cgi); /* peer->cgi in htrd = cgi */ #if !defined(CGI_ALLOW_UNLIMITED_REQ_CONTENT_LENGTH) if (cgi->req_content_length_unlimited) diff --git a/lib/http-fcgi.c b/lib/http-fcgi.c index b6535f7..ccb4071 100644 --- a/lib/http-fcgi.c +++ b/lib/http-fcgi.c @@ -24,7 +24,7 @@ typedef enum fcgi_res_mode_t fcgi_res_mode_t; struct fcgi_t { - HIO_SVC_HTTS_RSRC_HEADER; + HIO_SVC_HTTS_TASK_HEADER; hio_oow_t num_pending_writes_to_client; hio_oow_t num_pending_writes_to_peer; @@ -160,10 +160,10 @@ printf (">>>>>>>>>>>> disableing client read watching ...................\n"); if (fcgi->keep_alive) { /* how to arrange to delete this fcgi object and put the socket back to the normal waiting state??? */ - HIO_ASSERT (fcgi->htts->hio, fcgi->client->rsrc == (hio_svc_htts_rsrc_t*)fcgi); + HIO_ASSERT (fcgi->htts->hio, fcgi->client->task == (hio_svc_htts_task_t*)fcgi); -/*printf ("DETACHING FROM THE MAIN CLIENT RSRC... state -> %p\n", fcgi->client->rsrc);*/ - HIO_SVC_HTTS_RSRC_UNREF (fcgi->client->rsrc); +/*printf ("DETACHING FROM THE MAIN CLIENT TASK... state -> %p\n", fcgi->client->task);*/ + HIO_SVC_HTTS_TASK_UNREF (fcgi->client->task); /* fcgi must not be accessed from here down as it could have been destroyed */ } else @@ -221,7 +221,7 @@ static int fcgi_client_htrd_poke (hio_htrd_t* htrd, hio_htre_t* req) hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - fcgi_t* fcgi = (fcgi_t*)cli->rsrc; + fcgi_t* fcgi = (fcgi_t*)cli->task; /* indicate end of STDIN */ if (hio_svc_fcgic_writestdin(fcgi->peer, HIO_NULL, 0) <= -1) return -1; @@ -235,7 +235,7 @@ static int fcgi_client_htrd_push_content (hio_htrd_t* htrd, hio_htre_t* req, con hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - fcgi_t* fcgi = (fcgi_t*)cli->rsrc; + fcgi_t* fcgi = (fcgi_t*)cli->task; HIO_ASSERT (sck->hio, cli->sck == sck); @@ -253,7 +253,7 @@ static hio_htrd_recbs_t fcgi_client_htrd_recbs = static void fcgi_client_on_disconnect (hio_dev_sck_t* sck) { hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - fcgi_t* fcgi = (fcgi_t*)cli->rsrc; + fcgi_t* fcgi = (fcgi_t*)cli->task; fcgi->client_disconnected = 1; printf ("client disconnected ............................\n"); fcgi->client_org_on_disconnect (sck); @@ -263,7 +263,7 @@ static int fcgi_client_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - fcgi_t* fcgi = (fcgi_t*)cli->rsrc; + fcgi_t* fcgi = (fcgi_t*)cli->task; HIO_ASSERT (hio, sck == cli->sck); @@ -320,7 +320,7 @@ static int fcgi_client_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wr { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - fcgi_t* fcgi = (fcgi_t*)cli->rsrc; + fcgi_t* fcgi = (fcgi_t*)cli->task; if (wrlen <= -1) { @@ -371,9 +371,9 @@ printf ("GOT FCGI DATA.............[%.*s]\n", (int)len, buf); return 0; } -static void fcgi_on_kill (hio_svc_htts_rsrc_t* rsrc) +static void fcgi_on_kill (hio_svc_htts_task_t* task) { - fcgi_t* fcgi = (fcgi_t*)rsrc; + fcgi_t* fcgi = (fcgi_t*)task; hio_t* hio = fcgi->htts->hio; HIO_DEBUG2 (hio, "HTTS(%p) - killing fcgi client(%p)\n", fcgi->htts, fcgi->client->sck); @@ -501,7 +501,7 @@ int hio_svc_htts_dofcgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* goto oops; } - fcgi = (fcgi_t*)hio_svc_htts_rsrc_make(htts, HIO_SIZEOF(*fcgi), fcgi_on_kill); + fcgi = (fcgi_t*)hio_svc_htts_task_make(htts, HIO_SIZEOF(*fcgi), fcgi_on_kill); if (HIO_UNLIKELY(!fcgi)) goto oops; fcgi->client = cli; @@ -519,8 +519,8 @@ int hio_svc_htts_dofcgi (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* csck->on_write = fcgi_client_on_write; csck->on_disconnect = fcgi_client_on_disconnect; - HIO_ASSERT (hio, cli->rsrc == HIO_NULL); - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)fcgi, cli->rsrc); /* cli->rsrc = fcgi */ + HIO_ASSERT (hio, cli->task == HIO_NULL); + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)fcgi, cli->task); /* cli->task = fcgi */ /* create a session in in the fcgi client service */ fcgi->peer = hio_svc_fcgic_tie(htts->fcgic, fcgis_addr, fcgi_peer_on_read); diff --git a/lib/http-file.c b/lib/http-file.c index 2e752d2..0bc8171 100644 --- a/lib/http-file.c +++ b/lib/http-file.c @@ -51,7 +51,7 @@ typedef enum file_res_mode_t file_res_mode_t; struct file_t { - HIO_SVC_HTTS_RSRC_HEADER; + HIO_SVC_HTTS_TASK_HEADER; int options; hio_svc_htts_file_cbs_t* cbs; @@ -226,16 +226,16 @@ static void file_mark_over (file_t* file, int over_bits) #endif /* how to arrange to delete this file object and put the socket back to the normal waiting state??? */ - HIO_ASSERT (file->htts->hio, file->client->rsrc == (hio_svc_htts_rsrc_t*)file); - HIO_SVC_HTTS_RSRC_UNREF (file->client->rsrc); - /* the file resource must not be accessed from here down as it could have been destroyed */ + HIO_ASSERT (file->htts->hio, file->client->task == (hio_svc_htts_task_t*)file); + HIO_SVC_HTTS_TASK_UNREF (file->client->task); + /* the file task must not be accessed from here down as it could have been destroyed */ } else { HIO_DEBUG4 (file->htts->hio, "HTTS(%p) - file(c=%d,p=%d) halting client for %hs\n", file->htts, (int)file->client->sck->hnd, file->peer, (file->client_eof_detected? "EOF detected": "no keep-alive")); hio_dev_sck_shutdown (file->client->sck, HIO_DEV_SCK_SHUTDOWN_WRITE); hio_dev_sck_halt (file->client->sck); - /* the file resource will be detached from file->client->rsrc by the upstream disconnect handler in http_svr.c */ + /* the file task will be detached from file->client->task by the upstream disconnect handler in http_svr.c */ } } } @@ -269,9 +269,9 @@ static int file_write_to_peer (file_t* file, const void* data, hio_iolen_t dlen) return 0; } -static void file_on_kill (hio_svc_htts_rsrc_t* rsrc) +static void file_on_kill (hio_svc_htts_task_t* task) { - file_t* file = (file_t*)rsrc; + file_t* file = (file_t*)task; hio_t* hio = file->htts->hio; HIO_DEBUG3 (hio, "HTTS(%p) - file(c=%d,p=%d) on_kill\n", file->htts, (int)file->client->sck->hnd, file->peer); @@ -322,7 +322,7 @@ static void file_client_on_disconnect (hio_dev_sck_t* sck) { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - file_t* file = (file_t*)cli->rsrc; + file_t* file = (file_t*)cli->task; HIO_ASSERT (hio, sck == cli->sck); HIO_ASSERT (hio, sck == file->client->sck); @@ -333,15 +333,15 @@ static void file_client_on_disconnect (hio_dev_sck_t* sck) file->client_org_on_disconnect (sck); /* the original disconnect handler (listener_on_disconnect in http-svr.c) - * frees the file resource attached to the client. so it must not be accessed */ - HIO_ASSERT (hio, cli->rsrc == HIO_NULL); + * frees the file task attached to the client. so it must not be accessed */ + HIO_ASSERT (hio, cli->task == HIO_NULL); } static int file_client_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t len, const hio_skad_t* srcaddr) { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - file_t* file = (file_t*)cli->rsrc; + file_t* file = (file_t*)cli->task; HIO_ASSERT (hio, sck == cli->sck); HIO_ASSERT (hio, sck == file->client->sck); @@ -400,7 +400,7 @@ static int file_client_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wr { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - file_t* file = (file_t*)cli->rsrc; + file_t* file = (file_t*)cli->task; HIO_ASSERT (hio, sck == cli->sck); HIO_ASSERT (hio, sck == file->client->sck); @@ -452,7 +452,7 @@ static int file_client_htrd_poke (hio_htrd_t* htrd, hio_htre_t* req) hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - file_t* file = (file_t*)cli->rsrc; + file_t* file = (file_t*)cli->task; /* indicate EOF to the client peer */ if (file_write_to_peer(file, HIO_NULL, 0) <= -1) return -1; @@ -471,7 +471,7 @@ static int file_client_htrd_push_content (hio_htrd_t* htrd, hio_htre_t* req, con hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - file_t* file = (file_t*)cli->rsrc; + file_t* file = (file_t*)cli->task; HIO_ASSERT (sck->hio, cli->sck == sck); return file_write_to_peer(file, data, dlen); @@ -783,7 +783,7 @@ int hio_svc_htts_dofile (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* actual_file = hio_svc_htts_dupmergepaths(htts, docroot, filepath); if (HIO_UNLIKELY(!actual_file)) goto oops; - file = (file_t*)hio_svc_htts_rsrc_make(htts, HIO_SIZEOF(*file), file_on_kill); + file = (file_t*)hio_svc_htts_task_make(htts, HIO_SIZEOF(*file), file_on_kill); if (HIO_UNLIKELY(!file)) goto oops; file->options = options; @@ -796,7 +796,7 @@ int hio_svc_htts_dofile (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* file->req_method = hio_htre_getqmethodtype(req); file->req_content_length_unlimited = hio_htre_getreqcontentlen(req, &file->req_content_length); file->req_qpath = req_qpath; - req_qpath = HIO_NULL; /* delegated to the file resource */ + req_qpath = HIO_NULL; /* delegated to the file task */ file->req_qpath_ending_with_slash = (hio_htre_getqpathlen(req) > 0 && hio_htre_getqpath(req)[hio_htre_getqpathlen(req) - 1] == '/'); file->req_qpath_is_root = (hio_htre_getqpathlen(req) == 1 && hio_htre_getqpath(req)[0] == '/'); @@ -810,8 +810,8 @@ int hio_svc_htts_dofile (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* file->peer_tmridx = HIO_TMRIDX_INVALID; file->peer = -1; - HIO_ASSERT (hio, cli->rsrc == HIO_NULL); /* you must not call this function while cli->rsrc is not HIO_NULL */ - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)file, cli->rsrc); /* cli->rsrc = file with ref-count up */ + HIO_ASSERT (hio, cli->task == HIO_NULL); /* you must not call this function while cli->task is not HIO_NULL */ + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)file, cli->task); /* cli->task = file with ref-count up */ #if !defined(FILE_ALLOW_UNLIMITED_REQ_CONTENT_LENGTH) diff --git a/lib/http-prv.h b/lib/http-prv.h index 847553c..348a314 100644 --- a/lib/http-prv.h +++ b/lib/http-prv.h @@ -47,7 +47,7 @@ struct hio_svc_htts_cli_t hio_htrd_t* htrd; hio_becs_t* sbuf; /* temporary buffer for status line formatting */ - hio_svc_htts_rsrc_t* rsrc; + hio_svc_htts_task_t* task; hio_ntime_t last_active; }; @@ -72,7 +72,7 @@ struct hio_svc_htts_t hio_svc_fcgic_t* fcgic; hio_svc_htts_cli_t cli; /* list head for client list */ - hio_svc_htts_rsrc_t task; /* list head for task list */ + hio_svc_htts_task_t task; /* list head for task list */ hio_tmridx_t idle_tmridx; hio_bch_t* server_name; diff --git a/lib/http-svr.c b/lib/http-svr.c index f9186f2..3eb6035 100644 --- a/lib/http-svr.c +++ b/lib/http-svr.c @@ -58,7 +58,7 @@ static int init_client (hio_svc_htts_cli_t* cli, hio_dev_sck_t* sck) cli->l_idx = INVALID_LIDX; /* not a listening socket anymore */ cli->htrd = HIO_NULL; cli->sbuf = HIO_NULL; - cli->rsrc = HIO_NULL; + cli->task = HIO_NULL; /* keep this linked regardless of success or failure because the disconnect() callback * will call fini_client(). the error handler code after 'oops:' doesn't get this unlinked */ HIO_SVC_HTTS_CLIL_APPEND_CLI (&cli->htts->cli, cli); @@ -100,11 +100,11 @@ oops: static void fini_client (hio_svc_htts_cli_t* cli) { - HIO_DEBUG5 (cli->sck->hio, "HTTS(%p) - finalizing client(c=%p,sck=%p[%d],rsrc=%p)\n", cli->htts, cli, cli->sck, (int)cli->sck->hnd, cli->rsrc); + HIO_DEBUG5 (cli->sck->hio, "HTTS(%p) - finalizing client(c=%p,sck=%p[%d],task=%p)\n", cli->htts, cli, cli->sck, (int)cli->sck->hnd, cli->task); - if (cli->rsrc) + if (cli->task) { - HIO_SVC_HTTS_RSRC_UNREF (cli->rsrc); + HIO_SVC_HTTS_TASK_UNREF (cli->task); } if (cli->sbuf) @@ -143,10 +143,10 @@ static int listener_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t le HIO_ASSERT (hio, cli->l_idx == INVALID_LIDX); - /* if a resource has been set(cli->rsrc not NULL), the resource must take over + /* if a task has been set(cli->task not NULL) on the client, the task must take over * this handler. this handler is never called unless the the overriding handler * call this. */ - HIO_ASSERT (hio, cli->rsrc == HIO_NULL); + HIO_ASSERT (hio, cli->task == HIO_NULL); if (len <= -1) { @@ -169,7 +169,7 @@ static int listener_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t le if (rem > 0) { - if (cli->rsrc) + if (cli->task) { /* TODO store this to client buffer. once the current resource is completed, arrange to call on_read() with it */ } @@ -193,10 +193,10 @@ static int listener_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wrctx hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); HIO_ASSERT (sck->hio, cli->l_idx == INVALID_LIDX); - /* if a resource has been set(cli->rsrc not NULL), the resource must take over + /* if a resource has been set(cli->task not NULL), the resource must take over * this handler. this handler is never called unless the the overriding handler * call this. */ - HIO_ASSERT (sck->hio, cli->rsrc == HIO_NULL); + HIO_ASSERT (sck->hio, cli->task == HIO_NULL); /* anyways, nothing to do upon write completion */ @@ -308,7 +308,7 @@ static void halt_idle_clients (hio_t* hio, const hio_ntime_t* now, hio_tmrjob_t* for (cli = HIO_SVC_HTTS_CLIL_FIRST_CLI(&htts->cli); !HIO_SVC_HTTS_CLIL_IS_NIL_CLI(&htts->cli, cli); cli = cli->cli_next) { - if (!cli->rsrc) + if (!cli->task) { hio_ntime_t t; HIO_SUB_NTIME(&t, now, &cli->last_active); @@ -541,8 +541,8 @@ void hio_svc_htts_stop (hio_svc_htts_t* htts) while (!HIO_SVC_HTTS_TASKL_IS_EMPTY(&htts->task)) { - hio_svc_htts_rsrc_t* task = HIO_SVC_HTTS_TASKL_FIRST_TASK(&htts->task); - hio_svc_htts_rsrc_kill (task); + hio_svc_htts_task_t* task = HIO_SVC_HTTS_TASKL_FIRST_TASK(&htts->task); + hio_svc_htts_task_kill (task); } HIO_SVCL_UNLINK_SVC (htts); @@ -627,53 +627,53 @@ int hio_svc_htts_getsockaddr (hio_svc_htts_t* htts, hio_oow_t idx, hio_skad_t* s /* ----------------------------------------------------------------- */ -/* rsrc_size must be the total size to allocate including the header. +/* task_size must be the total size to allocate including the header. * - * For instance, if you define a resource like below, + * For instance, if you define a task like below, * - * struct my_rsrc_t + * struct my_task_t * { - * HIO_SVC_HTTS_RSRC_HEADER; + * HIO_SVC_HTTS_TASK_HEADER; * int a; * int b; * }; * - * you can pass sizeof(my_rsrc_t) to hio_svc_htts_rsrc_make() + * you can pass sizeof(my_task_t) to hio_svc_htts_task_make() */ -hio_svc_htts_rsrc_t* hio_svc_htts_rsrc_make (hio_svc_htts_t* htts, hio_oow_t rsrc_size, hio_svc_htts_rsrc_on_kill_t on_kill) +hio_svc_htts_task_t* hio_svc_htts_task_make (hio_svc_htts_t* htts, hio_oow_t task_size, hio_svc_htts_task_on_kill_t on_kill) { hio_t* hio = htts->hio; - hio_svc_htts_rsrc_t* rsrc; + hio_svc_htts_task_t* task; - HIO_DEBUG1 (hio, "HTTS(%p) - allocating resource\n", htts); + HIO_DEBUG1 (hio, "HTTS(%p) - allocating task\n", htts); - rsrc = hio_callocmem(hio, rsrc_size); - if (HIO_UNLIKELY(!rsrc)) + task = hio_callocmem(hio, task_size); + if (HIO_UNLIKELY(!task)) { - HIO_DEBUG1 (hio, "HTTS(%p) - failed to allocate resource\n", htts); + HIO_DEBUG1 (hio, "HTTS(%p) - failed to allocate task\n", htts); return HIO_NULL; } - rsrc->htts = htts; - rsrc->rsrc_size = rsrc_size; - rsrc->rsrc_refcnt = 0; - rsrc->rsrc_on_kill = on_kill; + task->htts = htts; + task->task_size = task_size; + task->task_refcnt = 0; + task->task_on_kill = on_kill; - HIO_DEBUG2 (hio, "HTTS(%p) - allocated resource %p\n", htts, rsrc); - return rsrc; + HIO_DEBUG2 (hio, "HTTS(%p) - allocated task %p\n", htts, task); + return task; } -void hio_svc_htts_rsrc_kill (hio_svc_htts_rsrc_t* rsrc) +void hio_svc_htts_task_kill (hio_svc_htts_task_t* task) { - hio_svc_htts_t* htts = rsrc->htts; + hio_svc_htts_t* htts = task->htts; hio_t* hio = htts->hio; - HIO_DEBUG2 (hio, "HTTS(%p) - destroying resource %p\n", htts, rsrc); + HIO_DEBUG2 (hio, "HTTS(%p) - destroying task %p\n", htts, task); - if (rsrc->rsrc_on_kill) rsrc->rsrc_on_kill (rsrc); - hio_freemem (hio, rsrc); + if (task->task_on_kill) task->task_on_kill (task); + hio_freemem (hio, task); - HIO_DEBUG2 (hio, "HTTS(%p) - destroyed resource %p\n", htts, rsrc); + HIO_DEBUG2 (hio, "HTTS(%p) - destroyed task %p\n", htts, task); } /* ----------------------------------------------------------------- */ diff --git a/lib/http-thr.c b/lib/http-thr.c index 86162c1..7c98c2d 100644 --- a/lib/http-thr.c +++ b/lib/http-thr.c @@ -59,7 +59,7 @@ typedef struct thr_func_start_t thr_func_start_t; struct thr_task_t { - HIO_SVC_HTTS_RSRC_HEADER; + HIO_SVC_HTTS_TASK_HEADER; int options; hio_oow_t num_pending_writes_to_client; @@ -244,8 +244,8 @@ static HIO_INLINE void thr_task_mark_over (thr_task_t* thr_task, int over_bits) if (thr_task->keep_alive && !thr_task->client_eof_detected) { /* how to arrange to delete this thr_task object and put the socket back to the normal waiting state??? */ - HIO_ASSERT (thr_task->htts->hio, thr_task->client->rsrc == (hio_svc_htts_rsrc_t*)thr_task); - HIO_SVC_HTTS_RSRC_UNREF (thr_task->client->rsrc); + HIO_ASSERT (thr_task->htts->hio, thr_task->client->task == (hio_svc_htts_task_t*)thr_task); + HIO_SVC_HTTS_TASK_UNREF (thr_task->client->task); /* IMPORTANT: thr_task must not be accessed from here down as it could have been destroyed */ } else @@ -258,9 +258,9 @@ static HIO_INLINE void thr_task_mark_over (thr_task_t* thr_task, int over_bits) } } -static void thr_task_on_kill (hio_svc_htts_rsrc_t* rsrc) +static void thr_task_on_kill (hio_svc_htts_task_t* task) { - thr_task_t* thr_task = (thr_task_t*)rsrc; + thr_task_t* thr_task = (thr_task_t*)task; hio_t* hio = thr_task->htts->hio; HIO_DEBUG5 (hio, "HTTS(%p) - thr(t=%p,c=%p[%d],p=%p) - killing the task\n", thr_task->htts, thr_task, thr_task->client, (thr_task->csck? thr_task->csck->hnd: -1), thr_task->peer); @@ -271,7 +271,7 @@ static void thr_task_on_kill (hio_svc_htts_rsrc_t* rsrc) if (thr_peer->task) { /* thr_peer->task may not be NULL if the resource is killed regardless of the reference count. - * anyway, don't use HIO_SVC_HTTS_RSRC_UNREF (thr_peer->task) because the resource itself + * anyway, don't use HIO_SVC_HTTS_TASK_UNREF (thr_peer->task) because the resource itself * is already being killed. */ thr_peer->task = HIO_NULL; } @@ -283,7 +283,7 @@ static void thr_task_on_kill (hio_svc_htts_rsrc_t* rsrc) if (thr_task->peer_htrd) { thr_peer_xtn_t* thr_peer = hio_htrd_getxtn(thr_task->peer_htrd); - if (thr_peer->task) thr_peer->task = HIO_NULL; // no HIO_SVC_HTTS_RSRC_UNREF() for the same reason above + if (thr_peer->task) thr_peer->task = HIO_NULL; // no HIO_SVC_HTTS_TASK_UNREF() for the same reason above hio_htrd_close (thr_task->peer_htrd); thr_task->peer_htrd = HIO_NULL; @@ -330,7 +330,7 @@ static void thr_peer_on_close (hio_dev_thr_t* thr, hio_dev_thr_sid_t sid) thr_task->peer = HIO_NULL; /* clear this peer from the state */ HIO_ASSERT (hio, thr_peer->task != HIO_NULL); - HIO_SVC_HTTS_RSRC_UNREF (thr_peer->task); + HIO_SVC_HTTS_TASK_UNREF (thr_peer->task); if (thr_task->peer_htrd) { @@ -338,7 +338,7 @@ static void thr_peer_on_close (hio_dev_thr_t* thr, hio_dev_thr_sid_t sid) * it's safe to detach the extra information attached on the htrd object. */ thr_peer = hio_htrd_getxtn(thr_task->peer_htrd); HIO_ASSERT (hio, thr_peer->task != HIO_NULL); - HIO_SVC_HTTS_RSRC_UNREF (thr_peer->task); + HIO_SVC_HTTS_TASK_UNREF (thr_peer->task); } break; @@ -593,7 +593,7 @@ static int thr_client_htrd_poke (hio_htrd_t* htrd, hio_htre_t* req) hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - thr_task_t* thr_task = (thr_task_t*)cli->rsrc; + thr_task_t* thr_task = (thr_task_t*)cli->task; /* indicate EOF to the client peer */ if (thr_task_write_to_peer(thr_task, HIO_NULL, 0) <= -1) return -1; @@ -607,7 +607,7 @@ static int thr_client_htrd_push_content (hio_htrd_t* htrd, hio_htre_t* req, cons hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - thr_task_t* thr_task = (thr_task_t*)cli->rsrc; + thr_task_t* thr_task = (thr_task_t*)cli->task; HIO_ASSERT (sck->hio, cli->sck == sck); return thr_task_write_to_peer(thr_task, data, dlen); @@ -674,7 +674,7 @@ oops: static void thr_client_on_disconnect (hio_dev_sck_t* sck) { hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - thr_task_t* thr_task = (thr_task_t*)cli->rsrc; + thr_task_t* thr_task = (thr_task_t*)cli->task; hio_svc_htts_t* htts = thr_task->htts; hio_t* hio = sck->hio; @@ -699,7 +699,7 @@ static int thr_client_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - thr_task_t* thr_task = (thr_task_t*)cli->rsrc; + thr_task_t* thr_task = (thr_task_t*)cli->task; HIO_ASSERT (hio, sck == cli->sck); @@ -756,7 +756,7 @@ static int thr_client_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wrc { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - thr_task_t* thr_task = (thr_task_t*)cli->rsrc; + thr_task_t* thr_task = (thr_task_t*)cli->task; if (wrlen <= -1) { @@ -911,7 +911,7 @@ int hio_svc_htts_dothr (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r mi.on_write = thr_peer_on_write; mi.on_close = thr_peer_on_close; - thr_task = (thr_task_t*)hio_svc_htts_rsrc_make(htts, HIO_SIZEOF(*thr_task), thr_task_on_kill); + thr_task = (thr_task_t*)hio_svc_htts_task_make(htts, HIO_SIZEOF(*thr_task), thr_task_on_kill); if (HIO_UNLIKELY(!thr_task)) goto oops; thr_task->options = options; @@ -930,14 +930,14 @@ int hio_svc_htts_dothr (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r csck->on_write = thr_client_on_write; csck->on_disconnect = thr_client_on_disconnect; - /* attach the thr task to the client socket via the rsrc field in the extended space of the socket */ - HIO_ASSERT (hio, cli->rsrc == HIO_NULL); - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)thr_task, cli->rsrc); + /* attach the thr task to the client socket via the task field in the extended space of the socket */ + HIO_ASSERT (hio, cli->task == HIO_NULL); + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)thr_task, cli->task); thr_task->peer = hio_dev_thr_make(hio, HIO_SIZEOF(*thr_peer), &mi); if (HIO_UNLIKELY(!thr_task->peer)) { - /* no need to detach the attached rsrc here because that is handled + /* no need to detach the attached task here because that is handled * in the kill/disconnect callbacks of relevant devices */ HIO_DEBUG3 (hio, "HTTS(%p) - failed to create thread for %p(%d)\n", htts, csck, (int)csck->hnd); goto oops; @@ -947,7 +947,7 @@ int hio_svc_htts_dothr (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r /* attach the thr task to the peer thread device */ thr_peer = hio_dev_thr_getxtn(thr_task->peer); - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)thr_task, thr_peer->task); + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)thr_task, thr_peer->task); thr_task->peer_htrd = hio_htrd_open(hio, HIO_SIZEOF(*thr_peer)); if (HIO_UNLIKELY(!thr_task->peer_htrd)) goto oops; @@ -956,7 +956,7 @@ int hio_svc_htts_dothr (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r /* attach the thr task to the htrd parser set on the peer thread device */ thr_peer = hio_htrd_getxtn(thr_task->peer_htrd); - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)thr_task, thr_peer->task); + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)thr_task, thr_peer->task); #if !defined(THR_ALLOW_UNLIMITED_REQ_CONTENT_LENGTH) if (thr_task->req_content_length_unlimited) diff --git a/lib/http-txt.c b/lib/http-txt.c index 80c2239..f97b714 100644 --- a/lib/http-txt.c +++ b/lib/http-txt.c @@ -31,7 +31,7 @@ struct txt_t { - HIO_SVC_HTTS_RSRC_HEADER; + HIO_SVC_HTTS_TASK_HEADER; int options; hio_oow_t num_pending_writes_to_client; @@ -138,10 +138,10 @@ static HIO_INLINE void txt_mark_over (txt_t* txt, int over_bits) if (txt->keep_alive && !txt->client_eof_detected) { /* how to arrange to delete this txt object and put the socket back to the normal waiting state??? */ - HIO_ASSERT (txt->htts->hio, txt->client->rsrc == (hio_svc_htts_rsrc_t*)txt); + HIO_ASSERT (txt->htts->hio, txt->client->task == (hio_svc_htts_task_t*)txt); -/*printf ("DETACHING FROM THE MAIN CLIENT RSRC... state -> %p\n", txt->client->rsrc);*/ - HIO_SVC_HTTS_RSRC_UNREF (txt->client->rsrc); +/*printf ("DETACHING FROM THE MAIN CLIENT TASK... state -> %p\n", txt->client->task);*/ + HIO_SVC_HTTS_TASK_UNREF (txt->client->task); /* txt must not be access from here down as it could have been destroyed */ } else @@ -153,9 +153,9 @@ static HIO_INLINE void txt_mark_over (txt_t* txt, int over_bits) } } -static void txt_on_kill (hio_svc_htts_rsrc_t* rsrc) +static void txt_on_kill (hio_svc_htts_task_t* task) { - txt_t* txt = (txt_t*)rsrc; + txt_t* txt = (txt_t*)task; hio_t* hio = txt->htts->hio; HIO_DEBUG2 (hio, "HTTS(%p) - killing txt client(%p)\n", txt->htts, txt->client->sck); @@ -203,7 +203,7 @@ static int txt_client_htrd_poke (hio_htrd_t* htrd, hio_htre_t* req) hio_svc_htts_cli_htrd_xtn_t* htrdxtn = (hio_svc_htts_cli_htrd_xtn_t*)hio_htrd_getxtn(htrd); hio_dev_sck_t* sck = htrdxtn->sck; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - txt_t* txt = (txt_t*)cli->rsrc; + txt_t* txt = (txt_t*)cli->task; /*printf (">> CLIENT REQUEST COMPLETED\n");*/ @@ -227,7 +227,7 @@ static hio_htrd_recbs_t txt_client_htrd_recbs = static void txt_client_on_disconnect (hio_dev_sck_t* sck) { hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - txt_t* txt = (txt_t*)cli->rsrc; + txt_t* txt = (txt_t*)cli->task; txt->client_disconnected = 1; txt->client_org_on_disconnect (sck); } @@ -236,7 +236,7 @@ static int txt_client_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - txt_t* txt = (txt_t*)cli->rsrc; + txt_t* txt = (txt_t*)cli->task; HIO_ASSERT (hio, sck == cli->sck); @@ -284,7 +284,7 @@ static int txt_client_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wrc { hio_t* hio = sck->hio; hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); - txt_t* txt = (txt_t*)cli->rsrc; + txt_t* txt = (txt_t*)cli->task; if (wrlen <= -1) { @@ -329,7 +329,7 @@ int hio_svc_htts_dotxt (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r /* ensure that you call this function before any contents is received */ HIO_ASSERT (hio, hio_htre_getcontentlen(req) == 0); - txt = (txt_t*)hio_svc_htts_rsrc_make(htts, HIO_SIZEOF(*txt), txt_on_kill); + txt = (txt_t*)hio_svc_htts_task_make(htts, HIO_SIZEOF(*txt), txt_on_kill); if (HIO_UNLIKELY(!txt)) goto oops; txt->options = options; @@ -345,8 +345,8 @@ int hio_svc_htts_dotxt (hio_svc_htts_t* htts, hio_dev_sck_t* csck, hio_htre_t* r csck->on_write = txt_client_on_write; csck->on_disconnect = txt_client_on_disconnect; - HIO_ASSERT (hio, cli->rsrc == HIO_NULL); - HIO_SVC_HTTS_RSRC_REF ((hio_svc_htts_rsrc_t*)txt, cli->rsrc); + HIO_ASSERT (hio, cli->task == HIO_NULL); + HIO_SVC_HTTS_TASK_REF ((hio_svc_htts_task_t*)txt, cli->task); if (req->flags & HIO_HTRE_ATTR_EXPECT100) {