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

enhanced hio_svc_htts_start() to accept multiple binding addresses.

Browse Source 
added hio_skad_init_for_qx()
defined HIO_AF_QX
changed hio-skad to defined HIO_AF_UNIX to a fake value if it's not defined.
fixed skad conversion functions to handle unix addresses  more consistently
This commit is contained in:
hyung-hwan 2021-08-06 03:23:48 +00:00
parent 7710d57968
commit 63cdf7b3bb
9 changed files with 370 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hio/bin/t01.c
View File

@ -1237,7 +1237,7 @@ for (i = 0; i < 5; i++)
HIO_INFO1 (hio, "UNABLE TO START DNC - %js\n", hio_geterrmsg(hio)); HIO_INFO1 (hio, "UNABLE TO START DNC - %js\n", hio_geterrmsg(hio));
} }
htts = hio_svc_htts_start(hio, &htts_bind_info, process_http_request); htts = hio_svc_htts_start(hio, &htts_bind_info, 1, process_http_request);
if (htts) hio_svc_htts_setservernamewithbcstr (htts, "HIO-HTTP"); if (htts) hio_svc_htts_setservernamewithbcstr (htts, "HIO-HTTP");
else HIO_INFO1 (hio, "UNABLE TO START HTTS - %js\n", hio_geterrmsg(hio)); else HIO_INFO1 (hio, "UNABLE TO START HTTS - %js\n", hio_geterrmsg(hio));

69
hio/bin/t06.c
View File

@ -11,7 +11,6 @@
#include <stdlib.h> #include <stdlib.h>
#define MAX_NUM_THRS 256 #define MAX_NUM_THRS 256
static int g_reuse_port = 0;
static int g_num_thrs = 2; static int g_num_thrs = 2;
static hio_svc_htts_t* g_htts[MAX_NUM_THRS]; static hio_svc_htts_t* g_htts[MAX_NUM_THRS];
static int g_htts_no = 0; static int g_htts_no = 0;
@ -216,7 +215,7 @@ void* thr_func (void* arg)
{ {
hio_t* hio = HIO_NULL; hio_t* hio = HIO_NULL;
hio_svc_htts_t* htts = HIO_NULL; hio_svc_htts_t* htts = HIO_NULL;
hio_dev_sck_bind_t htts_bind_info; hio_dev_sck_bind_t htts_bind_info[2];
int htts_no = -1; int htts_no = -1;
hio = hio_open(HIO_NULL, 0, HIO_NULL, HIO_FEATURE_ALL, 512, HIO_NULL); hio = hio_open(HIO_NULL, 0, HIO_NULL, HIO_FEATURE_ALL, 512, HIO_NULL);
@ -229,16 +228,17 @@ void* thr_func (void* arg)
hio_setoption (hio, HIO_LOG_TARGET_BCSTR, "/dev/stderr"); hio_setoption (hio, HIO_LOG_TARGET_BCSTR, "/dev/stderr");
memset (&htts_bind_info, 0, HIO_SIZEOF(htts_bind_info)); memset (&htts_bind_info, 0, HIO_SIZEOF(htts_bind_info));
if (g_reuse_port) hio_skad_init_for_qx (&htts_bind_info[0].localaddr);
{
hio_bcstrtoskad (hio, "0.0.0.0:9987", &htts_bind_info.localaddr);
htts_bind_info.options = HIO_DEV_SCK_BIND_REUSEADDR | HIO_DEV_SCK_BIND_REUSEPORT | HIO_DEV_SCK_BIND_IGNERR;
//htts_bind_info.options |= HIO_DEV_SCK_BIND_SSL;
htts_bind_info.ssl_certfile = "localhost.crt";
htts_bind_info.ssl_keyfile = "localhost.key";
}
htts = hio_svc_htts_start(hio, &htts_bind_info, process_http_request); hio_bcstrtoskad (hio, "0.0.0.0:9988", &htts_bind_info[1].localaddr);
htts_bind_info[1].options = HIO_DEV_SCK_BIND_REUSEADDR | HIO_DEV_SCK_BIND_REUSEPORT | HIO_DEV_SCK_BIND_IGNERR;
#if 0
htts_bind_info[1].options |= HIO_DEV_SCK_BIND_SSL;
htts_bind_info[1].ssl_certfile = "localhost.crt";
htts_bind_info[1].ssl_keyfile = "localhost.key";
#endif
htts = hio_svc_htts_start(hio, &htts_bind_info, HIO_COUNTOF(htts_bind_info), process_http_request);
if (!htts) if (!htts)
{ {
printf ("Unable to start htts\n"); printf ("Unable to start htts\n");
@ -251,9 +251,7 @@ void* thr_func (void* arg)
g_htts_no = (g_htts_no + 1) % g_num_thrs; g_htts_no = (g_htts_no + 1) % g_num_thrs;
pthread_mutex_unlock (&g_htts_mutex); pthread_mutex_unlock (&g_htts_mutex);
printf ("entering the loop for %d\n", htts_no);
hio_loop (hio); hio_loop (hio);
printf ("exiting the loop for %d\n", htts_no);
oops: oops:
pthread_mutex_lock (&g_htts_mutex); pthread_mutex_lock (&g_htts_mutex);
@ -387,7 +385,7 @@ static int try_to_accept (hio_dev_sck_t* sck, hio_dev_sck_qxmsg_t* qxmsg, int in
g_htts_no = (g_htts_no + 1) % g_num_thrs; g_htts_no = (g_htts_no + 1) % g_num_thrs;
pthread_mutex_unlock (&g_htts_mutex); pthread_mutex_unlock (&g_htts_mutex);
if (hio_svc_htts_writetosidechan(htts, qxmsg, HIO_SIZEOF(*qxmsg)) <= -1) if (hio_svc_htts_writetosidechan(htts, 0, qxmsg, HIO_SIZEOF(*qxmsg)) <= -1)
{ {
hio_bch_t buf[128]; hio_bch_t buf[128];
@ -470,6 +468,7 @@ static int add_listener (hio_t* hio, hio_bch_t* addrstr)
hio_dev_sck_t* tcp; hio_dev_sck_t* tcp;
hio_dev_sck_bind_t bi; hio_dev_sck_bind_t bi;
hio_dev_sck_listen_t li; hio_dev_sck_listen_t li;
int f;
memset (&bi, 0, HIO_SIZEOF(bi)); memset (&bi, 0, HIO_SIZEOF(bi));
if (hio_bcstrtoskad(hio, addrstr, &bi.localaddr) <= -1) if (hio_bcstrtoskad(hio, addrstr, &bi.localaddr) <= -1)
@ -485,7 +484,16 @@ static int add_listener (hio_t* hio, hio_bch_t* addrstr)
#endif #endif
memset (&mi, 0, HIO_SIZEOF(mi)); memset (&mi, 0, HIO_SIZEOF(mi));
mi.type = (hio_skad_family(&bi.localaddr) == HIO_AF_INET? HIO_DEV_SCK_TCP4: HIO_DEV_SCK_TCP6); f = hio_skad_family(&bi.localaddr);
if (f == HIO_AF_INET) mi.type = HIO_DEV_SCK_TCP4;
else if (f == HIO_AF_INET6) mi.type = HIO_DEV_SCK_TCP6;
else if (f == HIO_AF_UNIX) mi.type = HIO_DEV_SCK_UNIX;
else
{
HIO_INFO1 (hio, "unsupported address type - %hs\n", addrstr);
return -1;
}
mi.options = HIO_DEV_SCK_MAKE_LENIENT; mi.options = HIO_DEV_SCK_MAKE_LENIENT;
mi.on_write = tcp_sck_on_write; mi.on_write = tcp_sck_on_write;
mi.on_read = tcp_sck_on_read; mi.on_read = tcp_sck_on_read;
@ -496,27 +504,32 @@ static int add_listener (hio_t* hio, hio_bch_t* addrstr)
tcp = hio_dev_sck_make(hio, 0, &mi); tcp = hio_dev_sck_make(hio, 0, &mi);
if (!tcp) if (!tcp)
{ {
HIO_INFO1 (hio, "Cannot make tcp - %js\n", hio_geterrmsg(hio)); HIO_INFO2 (hio, "Cannot make tcp for %hs - %js\n", addrstr, hio_geterrmsg(hio));
return -1; return -1;
} }
if (!g_reuse_port)
{
if (hio_dev_sck_bind(tcp, &bi) <= -1) if (hio_dev_sck_bind(tcp, &bi) <= -1)
{ {
HIO_INFO1 (hio, "tcp hio_dev_sck_bind() failed - %js\n", hio_geterrmsg(hio)); HIO_INFO2 (hio, "tcp hio_dev_sck_bind() failed with %hs - %js\n", addrstr, hio_geterrmsg(hio));
return -1; return -1;
} }
}
memset (&li, 0, HIO_SIZEOF(li)); memset (&li, 0, HIO_SIZEOF(li));
li.backlogs = 4096; li.backlogs = 4096;
HIO_INIT_NTIME (&li.accept_tmout, 5, 1); HIO_INIT_NTIME (&li.accept_tmout, 5, 1);
if (hio_dev_sck_listen(tcp, &li) <= -1) if (hio_dev_sck_listen(tcp, &li) <= -1)
{ {
HIO_INFO1 (hio, "tcp[2] hio_dev_sck_listen() failed - %js\n", hio_geterrmsg(hio)); HIO_INFO2 (hio, "tcp hio_dev_sck_listen() failed on %hs - %js\n", addrstr, hio_geterrmsg(hio));
return -1; return -1;
} }
else
{
hio_skad_t skad;
hio_bch_t buf[HIO_SKAD_IP_STRLEN + 1];
hio_dev_sck_getsockaddr (tcp, &skad);
hio_skadtobcstr (hio, &skad, buf, HIO_COUNTOF(buf), HIO_SKAD_TO_BCSTR_ADDR | HIO_SKAD_TO_BCSTR_PORT);
HIO_INFO1 (hio, "main listener on %hs\n", buf);
}
return 0; return 0;
} }
@ -540,12 +553,7 @@ int main (int argc, char* argv[])
// TODO: use getopt() or something similar // TODO: use getopt() or something similar
for (i = 1; i < argc; ) for (i = 1; i < argc; )
{ {
if (strcmp(argv[i], "-r") == 0) if (strcmp(argv[i], "-t") == 0)
{
g_reuse_port = 1;
i++;
}
else if (strcmp(argv[i], "-t") == 0)
{ {
i++; i++;
if (i < argc) if (i < argc)
@ -602,9 +610,12 @@ int main (int argc, char* argv[])
if (add_listener(hio, "[::]:9987") <= -1 || if (add_listener(hio, "[::]:9987") <= -1 ||
add_listener(hio, "0.0.0.0:9987") <= -1) goto oops; add_listener(hio, "0.0.0.0:9987") <= -1) goto oops;
printf ("entering the main loop\n"); /* add a unix socket listener.
* don't check for an error to continue without it in case it fails. */
unlink ("t06.sck");
add_listener(hio, "@t06.sck");
hio_loop (hio); hio_loop (hio);
printf ("exiting the main loop\n");
xret = 0; xret = 0;

18
hio/lib/hio-http.h
View File

@ -250,7 +250,8 @@ HIO_EXPORT int hio_scan_http_qparam (
HIO_EXPORT hio_svc_htts_t* hio_svc_htts_start ( HIO_EXPORT hio_svc_htts_t* hio_svc_htts_start (
hio_t* hio, hio_t* hio,
hio_dev_sck_bind_t* sck_bind, hio_dev_sck_bind_t* binds,
hio_oow_t nbinds,
hio_svc_htts_proc_req_t proc_req hio_svc_htts_proc_req_t proc_req
); );
@ -266,6 +267,7 @@ static HIO_INLINE hio_t* hio_svc_htts_gethio(hio_svc_htts_t* svc) { return hio_s
HIO_EXPORT int hio_svc_htts_writetosidechan ( HIO_EXPORT int hio_svc_htts_writetosidechan (
hio_svc_htts_t* htts, hio_svc_htts_t* htts,
hio_oow_t idx, /* listener index */
const void* dptr, const void* dptr,
hio_oow_t dlen hio_oow_t dlen
); );
@ -275,8 +277,22 @@ HIO_EXPORT int hio_svc_htts_setservernamewithbcstr (
const hio_bch_t* server_name const hio_bch_t* server_name
); );
/* return the listening device at the given position.
* not all devices may be up and running */
HIO_EXPORT hio_dev_sck_t* hio_svc_htts_getlistendev (
hio_svc_htts_t* htts,
hio_oow_t idx
);
/* return the total number of listening devices requested to start.
* not all devices may be up and running */
HIO_EXPORT hio_oow_t hio_sv_htts_getnlistendevs (
hio_svc_htts_t* htts
);
HIO_EXPORT int hio_svc_htts_getsockaddr ( HIO_EXPORT int hio_svc_htts_getsockaddr (
hio_svc_htts_t* htts, hio_svc_htts_t* htts,
hio_oow_t idx, /* listener index */
hio_skad_t* skad hio_skad_t* skad
); );

2
hio/lib/hio-sck.h
View File

@ -262,7 +262,7 @@ typedef void (*hio_dev_sck_on_raw_accept_t) (
enum hio_dev_sck_type_t enum hio_dev_sck_type_t
{ {
HIO_DEV_SCK_QX, HIO_DEV_SCK_QX,
HIO_DEV_SCK_UNIX,
HIO_DEV_SCK_TCP4, HIO_DEV_SCK_TCP4,
HIO_DEV_SCK_TCP6, HIO_DEV_SCK_TCP6,

11
hio/lib/hio-skad.h
View File

@ -52,6 +52,13 @@
# define HIO_SIZEOF_SKAD_T HIO_SIZEOF_STRUCT_SOCKADDR_UN # define HIO_SIZEOF_SKAD_T HIO_SIZEOF_STRUCT_SOCKADDR_UN
#endif #endif
#if !defined(HIO_AF_UNIX)
/* this is a fake value */
# define HIO_AF_UNIX (65534)
#endif
/* this is HIO specific. No AF_XXXX definitions must overlap with this */
#define HIO_AF_QX (65530)
struct hio_skad_t struct hio_skad_t
{ {
hio_uint8_t data[HIO_SIZEOF_SKAD_T]; hio_uint8_t data[HIO_SIZEOF_SKAD_T];
@ -173,6 +180,10 @@ HIO_EXPORT void hio_skad_init_for_eth (
hio_ethad_t* ethad hio_ethad_t* ethad
); );
HIO_EXPORT void hio_skad_init_for_qx (
hio_skad_t* skad
);
HIO_EXPORT int hio_skad_family ( HIO_EXPORT int hio_skad_family (
const hio_skad_t* skad const hio_skad_t* skad
); );

11
hio/lib/http-prv.h
View File

@ -38,10 +38,11 @@ struct hio_svc_htts_cli_t
hio_svc_htts_cli_t* cli_prev; hio_svc_htts_cli_t* cli_prev;
hio_svc_htts_cli_t* cli_next; hio_svc_htts_cli_t* cli_next;
/* a listener socket sets htts and sck fields only */ /* a listener socket sets htts, sck, and l_idx fields only */
/* a client sockets uses all the fields in this struct */ /* a client sockets uses all the fields in this struct */
hio_svc_htts_t* htts; hio_svc_htts_t* htts;
hio_dev_sck_t* sck; hio_dev_sck_t* sck;
hio_oow_t l_idx; /* listening socket: < htts->l.count, client socket: >= htts->l.count */
hio_htrd_t* htrd; hio_htrd_t* htrd;
hio_becs_t* sbuf; /* temporary buffer for status line formatting */ hio_becs_t* sbuf; /* temporary buffer for status line formatting */
@ -62,7 +63,13 @@ struct hio_svc_htts_t
hio_svc_htts_proc_req_t proc_req; hio_svc_htts_proc_req_t proc_req;
hio_dev_sck_t* lsck; struct
{
hio_dev_sck_t** sck;
hio_oow_t count;
} l;
/*hio_dev_sck_t* lsck;*/
hio_svc_htts_cli_t cli; /* list head for client list */ hio_svc_htts_cli_t cli; /* list head for client list */
hio_tmridx_t idle_tmridx; hio_tmridx_t idle_tmridx;

202
hio/lib/http-svr.c
View File

@ -48,10 +48,11 @@ static int init_client (hio_svc_htts_cli_t* cli, hio_dev_sck_t* sck)
/* the htts field must be filled with the same field in the listening socket upon accept() */ /* the htts field must be filled with the same field in the listening socket upon accept() */
HIO_ASSERT (sck->hio, cli->htts != HIO_NULL); HIO_ASSERT (sck->hio, cli->htts != HIO_NULL);
HIO_ASSERT (sck->hio, cli->sck == cli->htts->lsck); /* the field should still point to the listner socket */ //HIO_ASSERT (sck->hio, cli->sck == cli->htts->lsck); /* the field should still point to the listner socket */
HIO_ASSERT (sck->hio, sck->hio == cli->htts->hio); HIO_ASSERT (sck->hio, sck->hio == cli->htts->hio);
cli->sck = sck; cli->sck = sck;
cli->l_idx = HIO_TYPE_MAX(hio_oow_t);
cli->htrd = HIO_NULL; cli->htrd = HIO_NULL;
cli->sbuf = HIO_NULL; cli->sbuf = HIO_NULL;
cli->rsrc = HIO_NULL; cli->rsrc = HIO_NULL;
@ -138,7 +139,7 @@ static int listener_on_read (hio_dev_sck_t* sck, const void* buf, hio_iolen_t le
hio_oow_t rem; hio_oow_t rem;
int x; int x;
HIO_ASSERT (hio, sck != cli->htts->lsck); //HIO_ASSERT (hio, sck != cli->htts->lsck);
HIO_ASSERT (hio, cli->rsrc == HIO_NULL); /* if a resource has been set, the resource must take over this handler */ HIO_ASSERT (hio, cli->rsrc == HIO_NULL); /* if a resource has been set, the resource must take over this handler */
if (len <= -1) if (len <= -1)
@ -182,7 +183,7 @@ oops:
static int listener_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wrctx, const hio_skad_t* dstaddr) static int listener_on_write (hio_dev_sck_t* sck, hio_iolen_t wrlen, void* wrctx, const hio_skad_t* dstaddr)
{ {
hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck);
HIO_ASSERT (sck->hio, sck != cli->htts->lsck); //HIO_ASSERT (sck->hio, sck != cli->htts->lsck);
HIO_ASSERT (sck->hio, cli->rsrc == HIO_NULL); /* if a resource has been set, the resource must take over this handler */ HIO_ASSERT (sck->hio, cli->rsrc == HIO_NULL); /* if a resource has been set, the resource must take over this handler */
return 0; return 0;
} }
@ -214,7 +215,7 @@ static void listener_on_connect (hio_dev_sck_t* sck)
static void listener_on_disconnect (hio_dev_sck_t* sck) static void listener_on_disconnect (hio_dev_sck_t* sck)
{ {
hio_t* hio = sck->hio; hio_t* hio = sck->hio;
hio_svc_htts_cli_t* cli = hio_dev_sck_getxtn(sck); hio_svc_htts_cli_t* xtn = hio_dev_sck_getxtn(sck);
switch (HIO_DEV_SCK_GET_PROGRESS(sck)) switch (HIO_DEV_SCK_GET_PROGRESS(sck))
{ {
@ -241,8 +242,8 @@ static void listener_on_disconnect (hio_dev_sck_t* sck)
/* this progress code indicates that the ssl-level accept failed. /* this progress code indicates that the ssl-level accept failed.
* on_disconnected() with this code is called without corresponding on_connect(). * on_disconnected() with this code is called without corresponding on_connect().
* the cli extension are is not initialized yet */ * the cli extension are is not initialized yet */
HIO_ASSERT (hio, sck != cli->sck); HIO_ASSERT (hio, sck != xtn->sck);
HIO_ASSERT (hio, cli->sck == cli->htts->lsck); /* the field is a copy of the extension are of the listener socket. so it should point to the listner socket */ //HIO_ASSERT (hio, cli->sck == cli->htts->lsck); /* the field is a copy of the extension are of the listener socket. so it should point to the listner socket */
HIO_DEBUG2 (hio, "LISTENER UNABLE TO SSL-ACCEPT CLIENT %p(%d) ....%p\n", sck, (int)sck->hnd); HIO_DEBUG2 (hio, "LISTENER UNABLE TO SSL-ACCEPT CLIENT %p(%d) ....%p\n", sck, (int)sck->hnd);
return; return;
@ -257,21 +258,21 @@ static void listener_on_disconnect (hio_dev_sck_t* sck)
break; break;
} }
if (sck == cli->htts->lsck) if (xtn->l_idx < xtn->htts->l.count)
{ {
/* the listener socket has these fields set to NULL */ /* the listener socket has these fields set to NULL */
HIO_ASSERT (hio, cli->htrd == HIO_NULL); HIO_ASSERT (hio, xtn->htrd == HIO_NULL);
HIO_ASSERT (hio, cli->sbuf == HIO_NULL); HIO_ASSERT (hio, xtn->sbuf == HIO_NULL);
HIO_DEBUG2 (hio, "HTTS(%p) - listener socket disconnect %p\n", cli->htts, sck); HIO_DEBUG2 (hio, "HTTS(%p) - listener socket disconnect %p\n", xtn->htts, sck);
cli->htts->lsck = HIO_NULL; /* let the htts service forget about this listening socket */ xtn->htts->l.sck[xtn->l_idx] = HIO_NULL; /* let the htts service forget about this listening socket */
} }
else else
{ {
/* client socket */ /* client socket */
HIO_DEBUG2 (hio, "HTTS(%p) - client socket disconnect %p\n", cli->htts, sck); HIO_DEBUG2 (hio, "HTTS(%p) - client socket disconnect %p\n", xtn->htts, sck);
HIO_ASSERT (hio, cli->sck == sck); HIO_ASSERT (hio, xtn->sck == sck);
fini_client (cli); fini_client (xtn);
} }
} }
@ -315,7 +316,7 @@ static void halt_idle_clients (hio_t* hio, const hio_ntime_t* now, hio_tmrjob_t*
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
hio_svc_htts_t* hio_svc_htts_start (hio_t* hio, hio_dev_sck_bind_t* sck_bind, hio_svc_htts_proc_req_t proc_req) hio_svc_htts_t* hio_svc_htts_start (hio_t* hio, hio_dev_sck_bind_t* binds, hio_oow_t nbinds, hio_svc_htts_proc_req_t proc_req)
{ {
hio_svc_htts_t* htts = HIO_NULL; hio_svc_htts_t* htts = HIO_NULL;
union union
@ -324,17 +325,34 @@ hio_svc_htts_t* hio_svc_htts_start (hio_t* hio, hio_dev_sck_bind_t* sck_bind, hi
hio_dev_sck_listen_t l; hio_dev_sck_listen_t l;
} info; } info;
hio_svc_htts_cli_t* cli; hio_svc_htts_cli_t* cli;
hio_oow_t i, noks;
if (HIO_UNLIKELY(nbinds <= 0))
{
hio_seterrnum (hio, HIO_EINVAL);
goto oops;
}
htts = (hio_svc_htts_t*)hio_callocmem(hio, HIO_SIZEOF(*htts)); htts = (hio_svc_htts_t*)hio_callocmem(hio, HIO_SIZEOF(*htts));
if (HIO_UNLIKELY(!htts)) goto oops; if (HIO_UNLIKELY(!htts)) goto oops;
HIO_DEBUG1 (hio, "HTTS - STARTING SERVICE %p\n", htts);
htts->hio = hio; htts->hio = hio;
htts->svc_stop = hio_svc_htts_stop; htts->svc_stop = hio_svc_htts_stop;
htts->proc_req = proc_req; htts->proc_req = proc_req;
htts->idle_tmridx = HIO_TMRIDX_INVALID; htts->idle_tmridx = HIO_TMRIDX_INVALID;
htts->l.sck = (hio_dev_sck_t**)hio_callocmem(hio, HIO_SIZEOF(*htts->l.sck) * nbinds);
if (HIO_UNLIKELY(!htts->l.sck)) goto oops;
htts->l.count = nbinds;
for (i = 0, noks = 0; i < nbinds; i++)
{
hio_dev_sck_t* sck;
HIO_MEMSET (&info, 0, HIO_SIZEOF(info)); HIO_MEMSET (&info, 0, HIO_SIZEOF(info));
switch (hio_skad_family(&sck_bind->localaddr)) switch (hio_skad_family(&binds[i].localaddr))
{ {
case HIO_AF_INET: case HIO_AF_INET:
info.m.type = HIO_DEV_SCK_TCP4; info.m.type = HIO_DEV_SCK_TCP4;
@ -344,48 +362,93 @@ hio_svc_htts_t* hio_svc_htts_start (hio_t* hio, hio_dev_sck_bind_t* sck_bind, hi
info.m.type = HIO_DEV_SCK_TCP6; info.m.type = HIO_DEV_SCK_TCP6;
break; break;
default: #if defined(HIO_AF_UNIX)
/*hio_seterrnum (hio, HIO_EINVAL); case HIO_AF_UNIX:
goto oops;*/ info.m.type = HIO_DEV_SCK_UNIX;
break;
#endif
case HIO_AF_QX:
info.m.type = HIO_DEV_SCK_QX; info.m.type = HIO_DEV_SCK_QX;
break; break;
default:
/* ignore this */
continue;
} }
info.m.options = HIO_DEV_SCK_MAKE_LENIENT; info.m.options = HIO_DEV_SCK_MAKE_LENIENT;
info.m.on_write = listener_on_write; info.m.on_write = listener_on_write;
info.m.on_read = listener_on_read; info.m.on_read = listener_on_read;
info.m.on_connect = listener_on_connect; info.m.on_connect = listener_on_connect;
info.m.on_disconnect = listener_on_disconnect; info.m.on_disconnect = listener_on_disconnect;
htts->lsck = hio_dev_sck_make(hio, HIO_SIZEOF(*cli), &info.m); sck = hio_dev_sck_make(hio, HIO_SIZEOF(*cli), &info.m);
if (HIO_UNLIKELY(!htts->lsck)) goto oops; if (HIO_UNLIKELY(!sck)) continue;
/* the name 'cli' for the listening socket is awkward. /* the name 'cli' for the listening socket is awkward.
* the listening socket will use the htts and sck fields for tracking only. * the listening socket will use the htts, sck, and listening fields for tracking only.
* each accepted client socket gets the extension size for this size as well. * each accepted client socket gets the extension size for this size as well.
* most of other fields are used for client management */ * most of other fields are used for client management. init_client() will set
cli = (hio_svc_htts_cli_t*)hio_dev_sck_getxtn(htts->lsck); * the sck field to the client socket and the listening field to 0. */
cli = (hio_svc_htts_cli_t*)hio_dev_sck_getxtn(sck);
cli->htts = htts; cli->htts = htts;
cli->sck = htts->lsck; cli->sck = sck;
cli->l_idx = i;
if (htts->lsck->type != HIO_DEV_SCK_QX) if (sck->type != HIO_DEV_SCK_QX)
{ {
if (hio_dev_sck_bind(htts->lsck, sck_bind) <= -1) goto oops; if (hio_dev_sck_bind(sck, &binds[i]) <= -1)
{
if (HIO_LOG_ENABLED(hio, HIO_LOG_DEBUG))
{
hio_bch_t tmpbuf[HIO_SKAD_IP_STRLEN + 1];
hio_skadtobcstr(hio, &binds[i].localaddr, tmpbuf, HIO_COUNTOF(tmpbuf), HIO_SKAD_TO_BCSTR_ADDR | HIO_SKAD_TO_BCSTR_PORT);
HIO_DEBUG3 (hio, "HTTS(%p) - [%zd] unable to bind to %hs\n", htts, i, tmpbuf);
}
hio_dev_sck_kill (sck);
continue;
}
HIO_MEMSET (&info, 0, HIO_SIZEOF(info)); HIO_MEMSET (&info, 0, HIO_SIZEOF(info));
info.l.backlogs = 4096; /* TODO: use configuration? */ info.l.backlogs = 4096; /* TODO: use configuration? */
HIO_INIT_NTIME (&info.l.accept_tmout, 5, 1); /* usedd for ssl accept */ HIO_INIT_NTIME (&info.l.accept_tmout, 5, 1); /* usedd for ssl accept */
if (hio_dev_sck_listen(htts->lsck, &info.l) <= -1) goto oops; if (hio_dev_sck_listen(sck, &info.l) <= -1)
{
if (HIO_LOG_ENABLED(hio, HIO_LOG_DEBUG))
{
hio_bch_t tmpbuf[HIO_SKAD_IP_STRLEN + 1];
hio_skadtobcstr(hio, &binds[i].localaddr, tmpbuf, HIO_COUNTOF(tmpbuf), HIO_SKAD_TO_BCSTR_ADDR | HIO_SKAD_TO_BCSTR_PORT);
HIO_DEBUG3 (hio, "HTTS(%p) - [%zd] unable to bind to %hs\n", htts, i, tmpbuf);
} }
hio_dev_sck_kill (sck);
goto oops;
}
}
if (HIO_LOG_ENABLED(hio, HIO_LOG_DEBUG))
{
hio_skad_t tmpad;
hio_bch_t tmpbuf[HIO_SKAD_IP_STRLEN + 1];
hio_dev_sck_getsockaddr(sck, &tmpad);
hio_skadtobcstr(hio, &tmpad, tmpbuf, HIO_COUNTOF(tmpbuf), HIO_SKAD_TO_BCSTR_ADDR | HIO_SKAD_TO_BCSTR_PORT);
HIO_DEBUG3 (hio, "HTTS(%p) - [%zd] listening on %hs\n", htts, i, tmpbuf);
}
htts->l.sck[i] = sck;
noks++;
}
if (noks <= 0) goto oops;
hio_fmttobcstr (htts->hio, htts->server_name_buf, HIO_COUNTOF(htts->server_name_buf), "%s-%d.%d.%d", hio_fmttobcstr (htts->hio, htts->server_name_buf, HIO_COUNTOF(htts->server_name_buf), "%s-%d.%d.%d",
HIO_PACKAGE_NAME, (int)HIO_PACKAGE_VERSION_MAJOR, (int)HIO_PACKAGE_VERSION_MINOR, (int)HIO_PACKAGE_VERSION_PATCH); HIO_PACKAGE_NAME, (int)HIO_PACKAGE_VERSION_MAJOR, (int)HIO_PACKAGE_VERSION_MINOR, (int)HIO_PACKAGE_VERSION_PATCH);
htts->server_name = htts->server_name_buf; htts->server_name = htts->server_name_buf;
HIO_SVCL_APPEND_SVC (&hio->actsvc, (hio_svc_t*)htts); HIO_SVCL_APPEND_SVC (&hio->actsvc, (hio_svc_t*)htts);
HIO_SVC_HTTS_CLIL_INIT (&htts->cli); HIO_SVC_HTTS_CLIL_INIT (&htts->cli);
HIO_DEBUG3 (hio, "HTTS - STARTED SERVICE %p - LISTENER SOCKET %p(%d)\n", htts, htts->lsck, (int)htts->lsck->hnd); HIO_DEBUG1 (hio, "HTTS - STARTED SERVICE %p\n", htts);
{ {
hio_ntime_t t; hio_ntime_t t;
@ -403,7 +466,13 @@ hio_svc_htts_t* hio_svc_htts_start (hio_t* hio, hio_dev_sck_bind_t* sck_bind, hi
oops: oops:
if (htts) if (htts)
{ {
if (htts->lsck) hio_dev_sck_kill (htts->lsck); if (htts->l.sck)
{
for (i = 0; i < htts->l.count; i++)
hio_dev_sck_kill (htts->l.sck[i]);
hio_freemem (hio, htts->l.sck);
}
hio_freemem (hio, htts); hio_freemem (hio, htts);
} }
return HIO_NULL; return HIO_NULL;
@ -412,12 +481,17 @@ oops:
void hio_svc_htts_stop (hio_svc_htts_t* htts) void hio_svc_htts_stop (hio_svc_htts_t* htts)
{ {
hio_t* hio = htts->hio; hio_t* hio = htts->hio;
hio_oow_t i;
HIO_DEBUG3 (hio, "HTTS - STOPPING SERVICE %p - LISTENER SOCKET %p(%d)\n", htts, htts->lsck, (int)(htts->lsck? htts->lsck->hnd: -1)); HIO_DEBUG1 (hio, "HTTS - STOPPING SERVICE %p\n", htts);
/* htts->lsck may be null if the socket has been destroyed for operational error and for (i = 0; i < htts->l.count; i++)
* forgotten in the disconnect callback thereafter */ {
if (htts->lsck) hio_dev_sck_kill (htts->lsck); /* the socket may be null:
* if it has been destroyed for operation errors and forgotten in the disconnect callback thereafter
* if it has never been created successfully */
if (htts->l.sck[i]) hio_dev_sck_kill (htts->l.sck[i]);
}
while (!HIO_SVC_HTTS_CLIL_IS_EMPTY(&htts->cli)) while (!HIO_SVC_HTTS_CLIL_IS_EMPTY(&htts->cli))
{ {
@ -430,6 +504,7 @@ void hio_svc_htts_stop (hio_svc_htts_t* htts)
if (htts->idle_tmridx != HIO_TMRIDX_INVALID) hio_deltmrjob (hio, htts->idle_tmridx); if (htts->idle_tmridx != HIO_TMRIDX_INVALID) hio_deltmrjob (hio, htts->idle_tmridx);
if (htts->l.sck) hio_freemem (hio, htts->l.sck);
hio_freemem (hio, htts); hio_freemem (hio, htts);
} }
@ -453,10 +528,47 @@ int hio_svc_htts_setservernamewithbcstr (hio_svc_htts_t* htts, const hio_bch_t*
return 0; return 0;
} }
int hio_svc_htts_getsockaddr (hio_svc_htts_t* htts, hio_skad_t* skad) hio_dev_sck_t* hio_svc_htts_getlistendev (hio_svc_htts_t* htts, hio_oow_t idx)
{
if (idx >= htts->l.count)
{
hio_seterrbfmt (htts->hio, HIO_EINVAL, "index out of range");
return HIO_NULL;
}
if (!htts->l.sck[idx])
{
hio_seterrbfmt (htts->hio, HIO_EINVAL, "no listener at the given index");
return HIO_NULL;
}
return htts->l.sck[idx];
}
hio_oow_t hio_svc_htts_getnlistendevs (hio_svc_htts_t* htts)
{
/* return the total number of listening socket devices.
* not all devices may be up and working */
return htts->l.count;
}
int hio_svc_htts_getsockaddr (hio_svc_htts_t* htts, hio_oow_t idx, hio_skad_t* skad)
{ {
/* return the socket address of the listening socket. */ /* return the socket address of the listening socket. */
return hio_dev_sck_getsockaddr(htts->lsck, skad);
if (idx >= htts->l.count)
{
hio_seterrbfmt (htts->hio, HIO_EINVAL, "index out of range");
return -1;
}
if (!htts->l.sck[idx])
{
hio_seterrbfmt (htts->hio, HIO_EINVAL, "no listener at the given index");
return -1;
}
return hio_dev_sck_getsockaddr(htts->l.sck[idx], skad);
} }
/* ----------------------------------------------------------------- */ /* ----------------------------------------------------------------- */
@ -550,9 +662,21 @@ hio_bch_t* hio_svc_htts_dupmergepaths (hio_svc_htts_t* htts, const hio_bch_t* ba
return xpath; return xpath;
} }
int hio_svc_htts_writetosidechan (hio_svc_htts_t* htts, const void* dptr, hio_oow_t dlen) int hio_svc_htts_writetosidechan (hio_svc_htts_t* htts, hio_oow_t idx, const void* dptr, hio_oow_t dlen)
{ {
return hio_dev_sck_writetosidechan(htts->lsck, dptr, dlen); if (idx >= htts->l.count)
{
hio_seterrbfmt (htts->hio, HIO_EINVAL, "index out of range");
return -1;
}
if (!htts->l.sck[idx])
{
hio_seterrbfmt (htts->hio, HIO_EINVAL, "no listener at the given index");
return -1;
}
return hio_dev_sck_writetosidechan(htts->l.sck[idx], dptr, dlen);
} }

24
hio/lib/sck.c
View File

@ -224,13 +224,18 @@ struct sck_type_map_t
int extra_dev_cap; int extra_dev_cap;
}; };
#define __AF_QX 999999
#define __AF_BPF 999998 #define __AF_BPF 999998
static struct sck_type_map_t sck_type_map[] = static struct sck_type_map_t sck_type_map[] =
{ {
/* HIO_DEV_SCK_QX */ /* HIO_DEV_SCK_QX */
{ __AF_QX, 0, 0, 0 }, { HIO_AF_QX, 0, 0, 0 },
#if defined(AF_UNIX)
{ AF_UNIX, SOCK_STREAM, 0, HIO_DEV_CAP_STREAM },
#else
{ -1, 0, 0, 0 },
#endif
/* HIO_DEV_SCK_TCP4 */ /* HIO_DEV_SCK_TCP4 */
{ AF_INET, SOCK_STREAM, 0, HIO_DEV_CAP_STREAM }, { AF_INET, SOCK_STREAM, 0, HIO_DEV_CAP_STREAM },
@ -278,7 +283,6 @@ static struct sck_type_map_t sck_type_map[] =
{ -1, 0, 0, 0 }, { -1, 0, 0, 0 },
#endif #endif
/* HIO_DEV_SCK_BPF - arp */ /* HIO_DEV_SCK_BPF - arp */
{ __AF_BPF, 0, 0, 0 } /* not implemented yet */ { __AF_BPF, 0, 0, 0 } /* not implemented yet */
}; };
@ -397,7 +401,7 @@ static int dev_sck_make (hio_dev_t* dev, void* ctx)
goto oops; goto oops;
} }
if (HIO_UNLIKELY(sck_type_map[arg->type].domain == __AF_QX)) if (HIO_UNLIKELY(sck_type_map[arg->type].domain == HIO_AF_QX))
{ {
hnd = open_async_qx(hio, &side_chan); hnd = open_async_qx(hio, &side_chan);
if (hnd == HIO_SYSHND_INVALID) goto oops; if (hnd == HIO_SYSHND_INVALID) goto oops;
@ -2200,7 +2204,11 @@ int hio_dev_sck_getsockopt (hio_dev_sck_t* dev, int level, int optname, void* op
int hio_dev_sck_getsockaddr (hio_dev_sck_t* dev, hio_skad_t* skad) int hio_dev_sck_getsockaddr (hio_dev_sck_t* dev, hio_skad_t* skad)
{ {
hio_scklen_t addrlen = HIO_SIZEOF(*skad); hio_scklen_t addrlen = HIO_SIZEOF(*skad);
if (getsockname(dev->hnd, (struct sockaddr*)skad, &addrlen) <= -1) if (dev->type == HIO_DEV_SCK_QX)
{
hio_skad_init_for_qx (skad);
}
else if (getsockname(dev->hnd, (struct sockaddr*)skad, &addrlen) <= -1)
{ {
hio_seterrwithsyserr (dev->hio, 0, errno); hio_seterrwithsyserr (dev->hio, 0, errno);
return -1; return -1;
@ -2211,7 +2219,11 @@ int hio_dev_sck_getsockaddr (hio_dev_sck_t* dev, hio_skad_t* skad)
int hio_dev_sck_getpeeraddr (hio_dev_sck_t* dev, hio_skad_t* skad) int hio_dev_sck_getpeeraddr (hio_dev_sck_t* dev, hio_skad_t* skad)
{ {
hio_scklen_t addrlen = HIO_SIZEOF(*skad); hio_scklen_t addrlen = HIO_SIZEOF(*skad);
if (getpeername(dev->hnd, (struct sockaddr*)skad, &addrlen) <= -1) if (dev->type == HIO_DEV_SCK_QX)
{
hio_skad_init_for_qx (skad);
}
else if (getpeername(dev->hnd, (struct sockaddr*)skad, &addrlen) <= -1)
{ {
hio_seterrwithsyserr (dev->hio, 0, errno); hio_seterrwithsyserr (dev->hio, 0, errno);
return -1; return -1;

103
hio/lib/skad.c
View File

@ -382,17 +382,30 @@ int hio_ucharstoskad (hio_t* hio, const hio_uch_t* str, hio_oow_t len, hio_skad_
/* use HIO_SIZEOF(*_skad) instead of HIO_SIZEOF(*skad) in case they are different */ /* use HIO_SIZEOF(*_skad) instead of HIO_SIZEOF(*skad) in case they are different */
HIO_MEMSET (skad, 0, HIO_SIZEOF(*_skad)); HIO_MEMSET (skad, 0, HIO_SIZEOF(*_skad));
#if defined(AF_UNIX) if (p[0] == '<' && p[1] == 'q' && p[2] == 'x' && p[3] == '>' && p[4] == '\0')
if (*p == '/' && len >= 2)
{ {
hio_oow_t dstlen; /* this is HIO specific. the rest isn't important */
skad->sa.sa_family = HIO_AF_QX;
return 0;
}
if (*p == '@')
{
#if defined(AF_UNIX) && (HIO_SIZEOF_STRUCT_SOCKADDR_UN > 0)
/* @aaa, @/tmp/aaa ... */
hio_oow_t srclen, dstlen;
dstlen = HIO_COUNTOF(skad->un.sun_path) - 1; dstlen = HIO_COUNTOF(skad->un.sun_path) - 1;
if (hio_convutobchars(hio, p, &len, skad->un.sun_path, &dstlen) <= -1) return -1; srclen = len - 1;
if (hio_convutobchars(hio, p + 1, &srclen, skad->un.sun_path, &dstlen) <= -1) return -1;
skad->un.sun_path[dstlen] = '\0'; skad->un.sun_path[dstlen] = '\0';
skad->un.sun_family = AF_UNIX; skad->un.sun_family = AF_UNIX;
return 0; return 0;
} #else
hio_seterrbfmt (hio, HIO_ENOIMPL, "unix address not supported");
return -1;
#endif #endif
}
#if (HIO_SIZEOF_STRUCT_SOCKADDR_IN6 > 0) #if (HIO_SIZEOF_STRUCT_SOCKADDR_IN6 > 0)
if (*p == '[') if (*p == '[')
@ -596,14 +609,25 @@ int hio_bcharstoskad (hio_t* hio, const hio_bch_t* str, hio_oow_t len, hio_skad_
/* use HIO_SIZEOF(*_skad) instead of HIO_SIZEOF(*skad) in case they are different */ /* use HIO_SIZEOF(*_skad) instead of HIO_SIZEOF(*skad) in case they are different */
HIO_MEMSET (skad, 0, HIO_SIZEOF(*_skad)); HIO_MEMSET (skad, 0, HIO_SIZEOF(*_skad));
#if defined(AF_UNIX) if (p[0] == '<' && p[1] == 'q' && p[2] == 'x' && p[3] == '>' && p[4] == '\0')
if (*p == '/' && len >= 2)
{ {
hio_copy_bcstr (skad->un.sun_path, HIO_COUNTOF(skad->un.sun_path), str); /* this is HIO specific. the rest isn't important */
skad->un.sun_family = AF_UNIX; skad->sa.sa_family = HIO_AF_QX;
return 0; return 0;
} }
if (*p == '@')
{
#if defined(AF_UNIX) && (HIO_SIZEOF_STRUCT_SOCKADDR_UN > 0)
/* @aaa, @/tmp/aaa ... */
hio_copy_bchars_to_bcstr (skad->un.sun_path, HIO_COUNTOF(skad->un.sun_path), str + 1, len - 1);
skad->un.sun_family = HIO_AF_UNIX;
return 0;
#else
hio_seterrbfmt (hio, HIO_ENOIMPL, "unix address not supported");
return -1;
#endif #endif
}
#if (HIO_SIZEOF_STRUCT_SOCKADDR_IN6 > 0) #if (HIO_SIZEOF_STRUCT_SOCKADDR_IN6 > 0)
if (*p == '[') if (*p == '[')
@ -959,17 +983,17 @@ hio_oow_t hio_skadtoucstr (hio_t* hio, const hio_skad_t* _skad, hio_uch_t* buf,
switch (hio_skad_family(_skad)) switch (hio_skad_family(_skad))
{ {
case HIO_AF_INET: case HIO_AF_INET:
if (flags & HIO_SKAD_TO_BCSTR_ADDR) if (flags & HIO_SKAD_TO_UCSTR_ADDR)
{ {
if (xlen + 1 >= len) goto done; if (xlen + 1 >= len) goto done;
xlen += ip4ad_to_ucstr(&skad->in4.sin_addr, buf, len); xlen += ip4ad_to_ucstr(&skad->in4.sin_addr, buf, len);
} }
if (flags & HIO_SKAD_TO_BCSTR_PORT) if (flags & HIO_SKAD_TO_UCSTR_PORT)
{ {
if (!(flags & HIO_SKAD_TO_BCSTR_ADDR) || skad->in4.sin_port != 0) if (!(flags & HIO_SKAD_TO_UCSTR_ADDR) || skad->in4.sin_port != 0)
{ {
if (flags & HIO_SKAD_TO_BCSTR_ADDR) if (flags & HIO_SKAD_TO_UCSTR_ADDR)
{ {
if (xlen + 1 >= len) goto done; if (xlen + 1 >= len) goto done;
buf[xlen++] = ':'; buf[xlen++] = ':';
@ -982,11 +1006,11 @@ hio_oow_t hio_skadtoucstr (hio_t* hio, const hio_skad_t* _skad, hio_uch_t* buf,
break; break;
case HIO_AF_INET6: case HIO_AF_INET6:
if (flags & HIO_SKAD_TO_BCSTR_PORT) if (flags & HIO_SKAD_TO_UCSTR_PORT)
{ {
if (!(flags & HIO_SKAD_TO_BCSTR_ADDR) || skad->in6.sin6_port != 0) if (!(flags & HIO_SKAD_TO_UCSTR_ADDR) || skad->in6.sin6_port != 0)
{ {
if (flags & HIO_SKAD_TO_BCSTR_ADDR) if (flags & HIO_SKAD_TO_UCSTR_ADDR)
{ {
if (xlen + 1 >= len) goto done; if (xlen + 1 >= len) goto done;
buf[xlen++] = '['; buf[xlen++] = '[';
@ -994,7 +1018,7 @@ hio_oow_t hio_skadtoucstr (hio_t* hio, const hio_skad_t* _skad, hio_uch_t* buf,
} }
} }
if (flags & HIO_SKAD_TO_BCSTR_ADDR) if (flags & HIO_SKAD_TO_UCSTR_ADDR)
{ {
if (xlen + 1 >= len) goto done; if (xlen + 1 >= len) goto done;
xlen += ip6ad_to_ucstr(&skad->in6.sin6_addr, &buf[xlen], len - xlen); xlen += ip6ad_to_ucstr(&skad->in6.sin6_addr, &buf[xlen], len - xlen);
@ -1017,11 +1041,11 @@ hio_oow_t hio_skadtoucstr (hio_t* hio, const hio_skad_t* _skad, hio_uch_t* buf,
} }
} }
if (flags & HIO_SKAD_TO_BCSTR_PORT) if (flags & HIO_SKAD_TO_UCSTR_PORT)
{ {
if (!(flags & HIO_SKAD_TO_BCSTR_ADDR) || skad->in6.sin6_port != 0) if (!(flags & HIO_SKAD_TO_UCSTR_ADDR) || skad->in6.sin6_port != 0)
{ {
if (flags & HIO_SKAD_TO_BCSTR_ADDR) if (flags & HIO_SKAD_TO_UCSTR_ADDR)
{ {
if (xlen + 1 >= len) goto done; if (xlen + 1 >= len) goto done;
buf[xlen++] = ']'; buf[xlen++] = ']';
@ -1038,7 +1062,7 @@ hio_oow_t hio_skadtoucstr (hio_t* hio, const hio_skad_t* _skad, hio_uch_t* buf,
break; break;
case HIO_AF_UNIX: case HIO_AF_UNIX:
if (flags & HIO_SKAD_TO_BCSTR_ADDR) if (flags & HIO_SKAD_TO_UCSTR_ADDR)
{ {
if (xlen + 1 >= len) goto done; if (xlen + 1 >= len) goto done;
buf[xlen++] = '@'; buf[xlen++] = '@';
@ -1053,6 +1077,21 @@ hio_oow_t hio_skadtoucstr (hio_t* hio, const hio_skad_t* _skad, hio_uch_t* buf,
} }
} }
break;
case HIO_AF_QX:
if (flags & HIO_SKAD_TO_UCSTR_ADDR)
{
if (xlen + 1 >= len) goto done;
buf[xlen++] = '<';
if (xlen + 1 >= len) goto done;
buf[xlen++] = 'q';
if (xlen + 1 >= len) goto done;
buf[xlen++] = 'x';
if (xlen + 1 >= len) goto done;
buf[xlen++] = '>';
}
break; break;
} }
@ -1294,6 +1333,21 @@ hio_oow_t hio_skadtobcstr (hio_t* hio, const hio_skad_t* _skad, hio_bch_t* buf,
xlen += hio_copy_bcstr(&buf[xlen], len - xlen, skad->un.sun_path); xlen += hio_copy_bcstr(&buf[xlen], len - xlen, skad->un.sun_path);
} }
break;
case HIO_AF_QX:
if (flags & HIO_SKAD_TO_BCSTR_ADDR)
{
if (xlen + 1 >= len) goto done;
buf[xlen++] = '<';
if (xlen + 1 >= len) goto done;
buf[xlen++] = 'q';
if (xlen + 1 >= len) goto done;
buf[xlen++] = 'x';
if (xlen + 1 >= len) goto done;
buf[xlen++] = '>';
}
break; break;
} }
@ -1454,6 +1508,13 @@ void hio_skad_init_for_eth (hio_skad_t* skad, int ifindex, hio_ethad_t* ethad)
#endif #endif
} }
void hio_skad_init_for_qx (hio_skad_t* _skad)
{
hio_skad_alt_t* skad = (hio_skad_alt_t*)_skad;
HIO_MEMSET (skad, 0, HIO_SIZEOF(*_skad));
skad->sa.sa_family = HIO_AF_QX;
}
void hio_clear_skad (hio_skad_t* _skad) void hio_clear_skad (hio_skad_t* _skad)
{ {
hio_skad_alt_t* skad = (hio_skad_alt_t*)_skad; hio_skad_alt_t* skad = (hio_skad_alt_t*)_skad;