From 6eee6bc9eb0098e2c835aaa49b88ac38ab4aeb98 Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Sun, 21 Apr 2024 16:29:55 +0900 Subject: [PATCH] code clean-up of xproto code. added ifname to ifindex conversion code --- bin/main-c.c | 2 - configure | 101 ++++++++++++++++++++++++++++++++++++ configure.ac | 8 +++ lib/hcl-cfg.h.in | 12 +++++ lib/hcl-x.c | 130 +++++++++++++++++++++++++++++++++++++---------- lib/hcl-x.h | 33 ++++++++++-- lib/std.c | 2 +- lib/xutl-sa.h | 69 +++++++++++++++++++++---- lib/xutl.c | 16 ++++++ 9 files changed, 330 insertions(+), 43 deletions(-) diff --git a/bin/main-c.c b/bin/main-c.c index de62ed2..cd9dff0 100644 --- a/bin/main-c.c +++ b/bin/main-c.c @@ -684,8 +684,6 @@ static int handle_request (hcl_client_t* client, const char* ipaddr, const char* goto oops; } - - /* TODO: create hcl_xproto_open... */ memset (proto, 0, HCL_SIZEOF(*proto)); proto->hcl = hcl_openstdwithmmgr(hcl_client_getmmgr(client), 0, HCL_NULL); // TODO: diff --git a/configure b/configure index 1781449..2dc1bb9 100755 --- a/configure +++ b/configure @@ -1872,6 +1872,66 @@ fi } # ac_fn_c_try_run +# ac_fn_c_check_member LINENO AGGR MEMBER VAR INCLUDES +# ---------------------------------------------------- +# Tries to find if the field MEMBER exists in type AGGR, after including +# INCLUDES, setting cache variable VAR accordingly. +ac_fn_c_check_member () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 +printf %s "checking for $2.$3... " >&6; } +if eval test \${$4+y} +then : + printf %s "(cached) " >&6 +else $as_nop + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$5 +int +main (void) +{ +static $2 ac_aggr; +if (ac_aggr.$3) +return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + eval "$4=yes" +else $as_nop + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$5 +int +main (void) +{ +static $2 ac_aggr; +if (sizeof ac_aggr.$3) +return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + eval "$4=yes" +else $as_nop + eval "$4=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +fi +eval ac_res=\$$4 + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf "%s\n" "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_member + # ac_fn_c_compute_int LINENO EXPR VAR INCLUDES # -------------------------------------------- # Tries to find the compile-time value of EXPR in a program that includes @@ -15514,6 +15574,19 @@ then : fi +ac_fn_c_check_header_compile "$LINENO" "sys/ioctl.h" "ac_cv_header_sys_ioctl_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_ioctl_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_IOCTL_H 1" >>confdefs.h + +fi +ac_fn_c_check_header_compile "$LINENO" "net/if.h" "ac_cv_header_net_if_h" "$ac_includes_default" +if test "x$ac_cv_header_net_if_h" = xyes +then : + printf "%s\n" "#define HAVE_NET_IF_H 1" >>confdefs.h + +fi + ac_fn_c_check_func "$LINENO" "gettimeofday" "ac_cv_func_gettimeofday" @@ -16101,6 +16174,34 @@ rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ fi +ac_fn_c_check_member "$LINENO" "struct ifreq" "ifr_ifindex" "ac_cv_member_struct_ifreq_ifr_ifindex" "#include + #include + #ifdef HAVE_NET_IF_H + #include + #endif +" +if test "x$ac_cv_member_struct_ifreq_ifr_ifindex" = xyes +then : + +printf "%s\n" "#define HAVE_STRUCT_IFREQ_IFR_IFINDEX 1" >>confdefs.h + + +fi +ac_fn_c_check_member "$LINENO" "struct ifreq" "ifr_mtu" "ac_cv_member_struct_ifreq_ifr_mtu" "#include + #include + #ifdef HAVE_NET_IF_H + #include + #endif +" +if test "x$ac_cv_member_struct_ifreq_ifr_mtu" = xyes +then : + +printf "%s\n" "#define HAVE_STRUCT_IFREQ_IFR_MTU 1" >>confdefs.h + + +fi + + # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. diff --git a/configure.ac b/configure.ac index d3c8992..73f53cb 100644 --- a/configure.ac +++ b/configure.ac @@ -112,6 +112,7 @@ AC_CHECK_HEADERS([time.h sys/time.h utime.h spawn.h execinfo.h ucontext.h]) AC_CHECK_HEADERS([dlfcn.h ltdl.h sys/mman.h sys/uio.h]) AC_CHECK_HEADERS([sys/devpoll.h sys/epoll.h poll.h]) AC_CHECK_HEADERS([libunwind.h quadmath.h]) +AC_CHECK_HEADERS([sys/ioctl.h net/if.h]) dnl check data types dnl AC_CHECK_TYPE([wchar_t], @@ -217,6 +218,13 @@ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include ]) +AC_CHECK_MEMBERS([struct ifreq.ifr_ifindex, struct ifreq.ifr_mtu], [], [], + [#include + #include + #ifdef HAVE_NET_IF_H + #include + #endif]) + dnl check the size of primitive data types AC_CHECK_SIZEOF(char,,[[]]) AC_CHECK_SIZEOF(short,,[[]]) diff --git a/lib/hcl-cfg.h.in b/lib/hcl-cfg.h.in index f6dce83..000128f 100644 --- a/lib/hcl-cfg.h.in +++ b/lib/hcl-cfg.h.in @@ -123,6 +123,9 @@ /* Define to 1 if you have the `nanosleep' function. */ #undef HAVE_NANOSLEEP +/* Define to 1 if you have the header file. */ +#undef HAVE_NET_IF_H + /* Define to 1 if you have the `pipe2' function. */ #undef HAVE_PIPE2 @@ -207,6 +210,12 @@ /* Define to 1 if you have the `strtoflt128' function. */ #undef HAVE_STRTOFLT128 +/* Define to 1 if `ifr_ifindex' is a member of `struct ifreq'. */ +#undef HAVE_STRUCT_IFREQ_IFR_IFINDEX + +/* Define to 1 if `ifr_mtu' is a member of `struct ifreq'. */ +#undef HAVE_STRUCT_IFREQ_IFR_MTU + /* Define to 1 if you have the `swapcontext' function. */ #undef HAVE_SWAPCONTEXT @@ -216,6 +225,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_SYS_EPOLL_H +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_IOCTL_H + /* Define to 1 if you have the header file. */ #undef HAVE_SYS_MMAN_H diff --git a/lib/hcl-x.c b/lib/hcl-x.c index 623575c..a3c35bd 100644 --- a/lib/hcl-x.c +++ b/lib/hcl-x.c @@ -89,6 +89,12 @@ struct bb_t }; typedef struct bb_t bb_t; +struct proto_xtn_t +{ + hcl_server_worker_t* worker; +}; +typedef struct proto_xtn_t proto_xtn_t; + struct worker_hcl_xtn_t { hcl_server_worker_t* worker; @@ -113,7 +119,8 @@ typedef enum hcl_xproto_rcv_state_t hcl_xproto_rcv_state_t; struct hcl_xproto_t { - hcl_server_worker_t* worker; + hcl_oow_t _instsize; + hcl_mmgr_t* _mmgr; hcl_tmr_index_t exec_runtime_event_index; struct @@ -724,12 +731,14 @@ static void exec_runtime_handler (hcl_tmr_t* tmr, const hcl_ntime_t* now, hcl_tm hcl_xproto_t* proto; hcl_server_worker_t* worker; + proto_xtn_t* prtxtn; proto = (hcl_xproto_t*)evt->ctx; - worker = proto->worker; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; /* TODO: can we use worker->hcl for logging before abort?? */ - HCL_LOG1 (worker->server->dummy_hcl, SERVER_LOGMASK_INFO, "Aborting script execution for max_actor_runtime exceeded [%zu]\n", proto->worker->wid); + HCL_LOG1 (worker->server->dummy_hcl, SERVER_LOGMASK_INFO, "Aborting script execution for max_actor_runtime exceeded [%zu]\n", worker->wid); hcl_abort (worker->hcl); } @@ -740,9 +749,11 @@ static void exec_runtime_updater (hcl_tmr_t* tmr, hcl_tmr_index_t old_index, hcl hcl_xproto_t* proto; hcl_server_worker_t* worker; + proto_xtn_t* prtxtn; proto = (hcl_xproto_t*)evt->ctx; - worker = proto->worker; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; HCL_ASSERT (worker->hcl, proto->exec_runtime_event_index == old_index); /* the event is being removed by hcl_tmr_fire() or by hcl_tmr_delete() @@ -756,10 +767,12 @@ static int insert_exec_timer (hcl_xproto_t* proto, const hcl_ntime_t* tmout) hcl_tmr_event_t event; hcl_tmr_index_t index; + proto_xtn_t* prtxtn; hcl_server_worker_t* worker; hcl_server_t* server; - worker = proto->worker; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; server = worker->server; HCL_ASSERT (worker->hcl, proto->exec_runtime_event_index == HCL_TMR_INVALID_INDEX); @@ -789,10 +802,12 @@ static void delete_exec_timer (hcl_xproto_t* proto) /* [NOTE] this is executed in the worker thread. if the event has been fired * in the server thread, proto->exec_runtime_event_index should be * HCL_TMR_INVALID_INDEX as set by exec_runtime_handler */ + proto_xtn_t* prtxtn; hcl_server_worker_t* worker; hcl_server_t* server; - worker = proto->worker; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; server = worker->server; pthread_mutex_lock (&server->tmr_mutex); @@ -812,10 +827,12 @@ static int execute_script (hcl_xproto_t* proto, const hcl_bch_t* trigger) { hcl_oop_t obj; const hcl_ooch_t* failmsg = HCL_NULL; + proto_xtn_t* prtxtn; hcl_server_worker_t* worker; hcl_server_t* server; - worker = proto->worker; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; server = worker->server; #if 0 @@ -888,32 +905,46 @@ static void reformat_synerr (hcl_t* hcl) static void send_proto_hcl_error (hcl_xproto_t* proto) { - hcl_server_worker_t* worker = proto->worker; + proto_xtn_t* prtxtn; + hcl_server_worker_t* worker; + + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; + if (HCL_ERRNUM(worker->hcl) == HCL_ESYNERR) reformat_synerr (worker->hcl); send_error_message (proto, hcl_geterrmsg(worker->hcl)); } static void show_server_workers (hcl_xproto_t* proto) { + proto_xtn_t* prtxtn; + hcl_server_worker_t* worker, * w; hcl_server_t* server; - hcl_server_worker_t* w; - server = proto->worker->server; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; + server = worker->server; + pthread_mutex_lock (&server->worker_mutex); for (w = server->worker_list[HCL_SERVER_WORKER_STATE_ALIVE].head; w; w = w->next_worker) { /* TODO: implement this better... */ - hcl_prbfmt (proto->worker->hcl, "%zu %d %d\n", w->wid, w->sck, 1000); + hcl_prbfmt (worker->hcl, "%zu %d %d\n", w->wid, w->sck, 1000); } pthread_mutex_unlock (&server->worker_mutex); } static int kill_server_worker (hcl_xproto_t* proto, hcl_oow_t wid) { + proto_xtn_t* prtxtn; + hcl_server_worker_t* worker; hcl_server_t* server; int xret = 0; - server = proto->worker->server; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; + server = worker->server; + pthread_mutex_lock (&server->worker_mutex); if (wid >= server->wid_map.capa) { @@ -950,7 +981,13 @@ static int kill_server_worker (hcl_xproto_t* proto, hcl_oow_t wid) static int handle_packet (hcl_xproto_t* proto, hcl_xpkt_type_t type, void* data, hcl_oow_t len) { - hcl_t* hcl = proto->worker->hcl; + proto_xtn_t* prtxtn; + hcl_server_worker_t* worker; + hcl_t* hcl; + + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; + hcl = worker->hcl; printf ("HANDLE PACKET TYPE => %d\n", type); switch (type) @@ -1023,7 +1060,6 @@ static int send_iov (int sck, struct iovec* iov, int count) msg.msg_iov = (struct iovec*)&iov[index]; msg.msg_iovlen = count - index; nwritten = sendmsg(sck, &msg, 0); - /*nwritten = writev(proto->worker->sck, (const struct iovec*)&iov[index], count - index);*/ if (nwritten <= -1) { /* error occurred inside the worker thread shouldn't affect the error information @@ -1046,11 +1082,16 @@ static int send_iov (int sck, struct iovec* iov, int count) static int send_stdout_bytes (hcl_xproto_t* proto, const hcl_bch_t* data, hcl_oow_t len) { + proto_xtn_t* prtxtn; + hcl_server_worker_t* worker; hcl_xpkt_hdr_t hdr; struct iovec iov[2]; const hcl_bch_t* ptr, * cur, * end; hcl_uint16_t seglen; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; + ptr = cur = data; end = data + len; @@ -1070,7 +1111,7 @@ printf ("SENDING BYTES [%.*s]\n", (int)len, data); iov[1].iov_base = ptr; iov[1].iov_len = seglen; - if (send_iov(proto->worker->sck, iov, 2) <= -1) + if (send_iov(worker->sck, iov, 2) <= -1) { /* TODO: error message */ return -1; @@ -1085,12 +1126,16 @@ printf ("SENDING BYTES [%.*s]\n", (int)len, data); #if defined(HCL_OOCH_IS_UCH) static int send_stdout_chars (hcl_xproto_t* proto, const hcl_ooch_t* data, hcl_oow_t len) { - hcl_server_worker_t* worker = proto->worker; + proto_xtn_t* prtxtn; + hcl_server_worker_t* worker; const hcl_ooch_t* ptr, * end; hcl_bch_t tmp[256]; hcl_oow_t tln, pln; int n; + prtxtn = (proto_xtn_t*)hcl_xproto_getxtn(proto); + worker = prtxtn->worker; + ptr = data; end = data + len; @@ -1112,15 +1157,16 @@ static int send_stdout_chars (hcl_xproto_t* proto, const hcl_ooch_t* data, hcl_o /* ========================================================================= */ -hcl_xproto_t* hcl_xproto_open (hcl_oow_t xtnsize, hcl_server_worker_t* worker) +hcl_xproto_t* hcl_xproto_open (hcl_mmgr_t* mmgr, hcl_oow_t xtnsize) { hcl_xproto_t* proto; - proto = (hcl_xproto_t*)hcl_server_allocmem(worker->server, HCL_SIZEOF(*proto)); + proto = (hcl_xproto_t*)HCL_MMGR_ALLOC(mmgr, HCL_SIZEOF(*proto) + xtnsize); if (HCL_UNLIKELY(!proto)) return HCL_NULL; HCL_MEMSET (proto, 0, HCL_SIZEOF(*proto)); - proto->worker = worker; + proto->_instsize = HCL_SIZEOF(*proto); + proto->_mmgr = mmgr; proto->exec_runtime_event_index = HCL_TMR_INVALID_INDEX; proto->rcv.state = HCL_XPROTO_RCV_HDR; proto->rcv.len_needed = HCL_XPKT_HDR_LEN; @@ -1131,7 +1177,32 @@ hcl_xproto_t* hcl_xproto_open (hcl_oow_t xtnsize, hcl_server_worker_t* worker) void hcl_xproto_close (hcl_xproto_t* proto) { - hcl_server_freemem (proto->worker->server, proto); + HCL_MMGR_FREE (proto->_mmgr, proto); +} + +void* hcl_xproto_getxtn (hcl_xproto_t* proto) +{ + return (proto + 1); +} + +int hcl_xprpto_feed (hcl_xproto_t* proto, const void* data, hcl_oow_t len) +{ +} + +hcl_uint8_t* hcl_xproto_getbuf (hcl_xproto_t* proto, hcl_oow_t* capa) +{ + *capa = HCL_COUNTOF(proto->rcv.buf) - proto->rcv.len; + return &proto->rcv.buf[proto->rcv.len]; +} + +void hcl_xproto_seteof (hcl_xproto_t* proto, int v) +{ + proto->rcv.eof = v; +} + +void hcl_xproto_advbuf (hcl_xproto_t* proto, hcl_oow_t inc) +{ + proto->rcv.len += inc; } int hcl_xproto_ready (hcl_xproto_t* proto) @@ -1140,7 +1211,7 @@ int hcl_xproto_ready (hcl_xproto_t* proto) return proto->rcv.len >= proto->rcv.len_needed; } -static int hcl_xproto_process (hcl_xproto_t* proto) +int hcl_xproto_process (hcl_xproto_t* proto) { int n; hcl_xpkt_hdr_t* hdr; @@ -1601,7 +1672,11 @@ static int worker_step (hcl_server_worker_t* worker) if (pfd.revents & POLLIN) { - x = recv(worker->sck, &proto->rcv.buf[proto->rcv.len], HCL_COUNTOF(proto->rcv.buf) - proto->rcv.len, 0); + hcl_oow_t bcap; + hcl_uint8_t* bptr; + + bptr = hcl_xproto_getbuf(proto, &bcap);; + x = recv(worker->sck, bptr, bcap, 0); if (x <= -1) { if (errno == EINTR) goto carry_on; /* didn't read read */ @@ -1610,9 +1685,8 @@ static int worker_step (hcl_server_worker_t* worker) return -1; } - if (x == 0) proto->rcv.eof = 1; - proto->rcv.len += x; - + if (x == 0) hcl_xproto_seteof(proto, 1); + hcl_xproto_advbuf (proto, x); } } @@ -1704,10 +1778,14 @@ static void fini_worker_hcl (hcl_server_worker_t* worker) static int init_worker_proto (hcl_server_worker_t* worker) { hcl_xproto_t* proto; + proto_xtn_t* xtn; - proto = hcl_xproto_open(0, worker); + proto = hcl_xproto_open(hcl_server_getmmgr(worker->server), HCL_SIZEOF(*xtn)); if (HCL_UNLIKELY(!proto)) return -1; + xtn = hcl_xproto_getxtn(proto); + xtn->worker = worker; + worker->proto = proto; return 0; } diff --git a/lib/hcl-x.h b/lib/hcl-x.h index eaff2ae..7f80c2e 100644 --- a/lib/hcl-x.h +++ b/lib/hcl-x.h @@ -400,12 +400,39 @@ HCL_EXPORT void hcl_client_freemem ( /* ---------------------------------------------------------------------- */ HCL_EXPORT hcl_xproto_t* hcl_xproto_open ( - hcl_oow_t xtnsize, - hcl_server_worker_t* worker + hcl_mmgr_t* mmgr, + hcl_oow_t xtnsize ); HCL_EXPORT void hcl_xproto_close ( - hcl_xproto_t* proto + hcl_xproto_t* proto +); + +HCL_EXPORT void* hcl_xproto_getxtn ( + hcl_xproto_t* proto +); + +hcl_uint8_t* hcl_xproto_getbuf ( + hcl_xproto_t* proto, + hcl_oow_t* capa +); + +void hcl_xproto_seteof ( + hcl_xproto_t* proto, + int v +); + +void hcl_xproto_advbuf ( + hcl_xproto_t* proto, + hcl_oow_t inc +); + +int hcl_xproto_ready ( + hcl_xproto_t* proto +); + +int hcl_xproto_process ( + hcl_xproto_t* proto ); #if defined(__cplusplus) diff --git a/lib/std.c b/lib/std.c index 79e27f2..bc55e36 100644 --- a/lib/std.c +++ b/lib/std.c @@ -3697,7 +3697,7 @@ static HCL_INLINE int open_udo_stream (hcl_t* hcl, hcl_io_udoarg_t* arg) if (xtn->udo_path) hcl_seterrbfmtwithsyserr (hcl, 0, errno, "unable to open udo stream '%hs'", xtn->udo_path); else - hcl_seterrbfmtwithsyserr (hcl, 0, errno, "unable to open udo stream", xtn->udo_path); + hcl_seterrbfmtwithsyserr (hcl, 0, errno, "unable to open udo stream"); return -1; } diff --git a/lib/xutl-sa.h b/lib/xutl-sa.h index 420c4c2..bd6126b 100644 --- a/lib/xutl-sa.h +++ b/lib/xutl-sa.h @@ -176,6 +176,59 @@ static int str_to_ipv6 (const ooch_t* src, hcl_oow_t len, struct in6_addr* inadd } #endif +static int str_to_ifindex (hcl_t* hcl, const ooch_t* ptr, hcl_oow_t len, unsigned int* ifindex) +{ +#if defined(SIOCGIFINDEX) + int h, x; + struct ifreq ifr; + + /* use AF_INET6 because str_to_ifindex is called for ipv6 only in this file */ + h = socket(AF_INET6, SOCK_DGRAM, 0); + if (h <= -1) + { + hcl_seterrbfmtwithsyserr (hcl, 0, errno, "unable to open socket for if_nametoindex conversion"); + return -1; + } + + HCL_MEMSET (&ifr, 0, HCL_SIZEOF(ifr)); + +#if (ooch_mode == 2) + hcl_oow_t ucslen, bcslen; + ucslen = len; + bcslen = HCL_COUNTOF(ifr.ifr_name) - 1; + if (hcl_convutobchars(hcl, ptr, &ucslen, ifr.ifr_name, &bcslen) <= -1) + { + close (h); + return -1; + } + ifr.ifr_name[bcslen] = '\0'; +#else + if (hcl_copy_bchars_to_bcstr(ifr.ifr_name, HCL_COUNTOF(ifr.ifr_name), ptr, len) < len) + { + close (h); + return -1; + } +#endif + + x = ioctl(h, SIOCGIFINDEX, &ifr); + close (h); + + if (x >= 0) + { + #if defined(HAVE_STRUCT_IFREQ_IFR_IFINDEX) + *ifindex = ifr.ifr_ifindex; + #else + *ifindex = ifr.ifr_index; + #endif + } + + return x; +#else +/* TODO: use if_nametoindex()? */ + hcl_seterrbfmt (hcl, HCL_ENOIMPL, "ifname to ifindex conversion not implemented"); + return -1; +#endif +} int str_to_sockaddr (hcl_t* hcl, const ooch_t* str, hcl_oow_t len, hcl_sckaddr_t* sckaddr, hcl_scklen_t* scklen) { @@ -235,19 +288,16 @@ int str_to_sockaddr (hcl_t* hcl, const ooch_t* str, hcl_oow_t len, hcl_sckaddr_t p++; } while (p < end && *p >= '0' && *p <= '9'); - //nwad->in6.sin6_scope_id = y; + nwad->in6.sin6_scope_id = y; } else { -#if 0 -TODO: /* interface name as a scope id? */ const ooch_t* stmp = p; unsigned int index; do p++; while (p < end && *p != ']'); - if (hcl_nwifwcsntoindex(stmp, p - stmp, &index) <= -1) return -1; - tmpad.u.in6.scope = index; -#endif + if (str_to_ifindex(hcl, stmp, p - stmp, &index) <= -1) return -1; + nwad->in6.sin6_scope_id = index; } if (p >= end || *p != ']') goto no_rbrack; @@ -311,19 +361,16 @@ TODO: p++; } while (p < end && *p >= '0' && *p <= '9'); - //nwad->in6.sin6_scope_id = y; + nwad->in6.sin6_scope_id = y; } else { -#if 0 -TODO /* interface name as a scope id? */ const ooch_t* stmp = p; unsigned int index; do p++; while (p < end); - if (hcl_nwifwcsntoindex(stmp, p - stmp, &index) <= -1) return -1; + if (str_to_ifindex(hcl, stmp, p - stmp, &index) <= -1) return -1; nwad->in6.sin6_scope_id = index; -#endif } } diff --git a/lib/xutl.c b/lib/xutl.c index cd084c9..f79723d 100644 --- a/lib/xutl.c +++ b/lib/xutl.c @@ -37,7 +37,15 @@ # include # include #else +# if defined(HAVE_SYS_IOCTL_H) +# include +# endif +# if defined(HAVE_NET_IF_H) +# include +# endif # include +# include +# include #endif union sockaddr_t @@ -52,29 +60,37 @@ union sockaddr_t }; typedef union sockaddr_t sockaddr_t; +#undef ooch_mode #undef ooch_t #undef oocs_t #undef str_to_ipv4 #undef str_to_ipv6 #undef str_to_sockaddr +#undef str_to_ifindex +#define ooch_mode (1) #define ooch_t hcl_bch_t #define oocs_t hcl_bcs_t #define str_to_ipv4 bchars_to_ipv4 #define str_to_ipv6 bchars_to_ipv6 +#define str_to_ifindex bchars_to_ifindex #define str_to_sockaddr hcl_bcharstosckaddr #include "xutl-sa.h" +#undef ooch_mode #undef ooch_t #undef oocs_t #undef str_to_ipv4 #undef str_to_ipv6 +#undef str_to_ifindex #undef str_to_sockaddr +#define ooch_mode (2) #define ooch_t hcl_uch_t #define oocs_t hcl_ucs_t #define str_to_ipv4 uchars_to_ipv4 #define str_to_ipv6 uchars_to_ipv6 +#define str_to_ifindex uchars_to_ifindex #define str_to_sockaddr hcl_ucharstosckaddr #include "xutl-sa.h"