/* //////////////////////////////////////////////////////////////////////////////////////
* interfaces
*/
tb_iterator_t tb_iterator_init_mem(tb_pointer_t data, tb_size_t size, tb_size_t step)
{
// check
tb_assert(data && size);
// the ptr iterator
tb_iterator_t ptr = tb_iterator_init_ptr((tb_pointer_t*)data, size);
// init
tb_iterator_t itor = {0};
itor.mode = TB_ITERATOR_MODE_FORWARD | TB_ITERATOR_MODE_REVERSE | TB_ITERATOR_MODE_RACCESS | TB_ITERATOR_MODE_MUTABLE;
itor.data = (tb_pointer_t)data;
itor.priv = tb_u2p(size);
itor.step = step;
itor.size = ptr.size;
itor.head = ptr.head;
itor.tail = ptr.tail;
itor.prev = ptr.prev;
itor.next = ptr.next;
itor.item = tb_iterator_init_mem_item;
itor.copy = tb_iterator_init_mem_copy;
itor.comp = tb_iterator_init_mem_comp;
// ok
return itor;
}
static tb_pointer_t tb_element_uint8_data(tb_element_ref_t element, tb_cpointer_t buff)
{
// check
tb_assert_and_check_return_val(buff, tb_null);
// the element data
return tb_u2p(*((tb_uint8_t*)buff));
}
static tb_pointer_t tb_item_func_uint16_data(tb_item_func_t* func, tb_cpointer_t buff)
{
// check
tb_assert_and_check_return_val(buff, tb_null);
// the item data
return tb_u2p(*((tb_uint16_t*)buff));
}
static tb_long_t tb_aiop_rtor_epoll_wait(tb_aiop_rtor_impl_t* rtor, tb_aioe_ref_t list, tb_size_t maxn, tb_long_t timeout)
{
// check
tb_aiop_rtor_epoll_impl_t* impl = (tb_aiop_rtor_epoll_impl_t*)rtor;
tb_assert_and_check_return_val(impl && impl->epfd > 0, -1);
// the aiop
tb_aiop_impl_t* aiop = rtor->aiop;
tb_assert_and_check_return_val(aiop, -1);
// init grow
tb_size_t grow = tb_align8((rtor->aiop->maxn >> 3) + 1);
// init events
if (!impl->evts)
{
impl->evtn = grow;
impl->evts = tb_nalloc0(impl->evtn, sizeof(struct epoll_event));
tb_assert_and_check_return_val(impl->evts, -1);
}
// wait events
tb_long_t evtn = epoll_wait(impl->epfd, impl->evts, impl->evtn, timeout);
// interrupted?(for gdb?) continue it
if (evtn < 0 && errno == EINTR) return 0;
// check error?
tb_assert_and_check_return_val(evtn >= 0 && evtn <= impl->evtn, -1);
// timeout?
tb_check_return_val(evtn, 0);
// grow it if events is full
if (evtn == impl->evtn)
{
// grow size
impl->evtn += grow;
if (impl->evtn > rtor->aiop->maxn) impl->evtn = rtor->aiop->maxn;
// grow data
impl->evts = tb_ralloc(impl->evts, impl->evtn * sizeof(struct epoll_event));
tb_assert_and_check_return_val(impl->evts, -1);
}
tb_assert(evtn <= impl->evtn);
// limit
evtn = tb_min(evtn, maxn);
// sync
tb_size_t i = 0;
tb_size_t wait = 0;
for (i = 0; i < evtn; i++)
{
// the aioo
tb_aioo_impl_t* aioo = (tb_aioo_impl_t*)tb_u2p(impl->evts[i].data.u64);
tb_assert_and_check_return_val(aioo, -1);
// the sock
tb_socket_ref_t sock = aioo->sock;
tb_assert_and_check_return_val(sock, -1);
// the events
tb_size_t events = impl->evts[i].events;
// spak?
if (sock == aiop->spak[1] && (events & EPOLLIN))
{
// read spak
tb_char_t spak = '\0';
if (1 != tb_socket_recv(aiop->spak[1], (tb_byte_t*)&spak, 1)) return -1;
// killed?
if (spak == 'k') return -1;
// continue it
continue ;
}
// skip spak
tb_check_continue(sock != aiop->spak[1]);
// save aioe
tb_aioe_ref_t aioe = &list[wait++];
aioe->code = TB_AIOE_CODE_NONE;
aioe->priv = aioo->priv;
aioe->aioo = (tb_aioo_ref_t)aioo;
if (events & EPOLLIN)
{
aioe->code |= TB_AIOE_CODE_RECV;
if (aioo->code & TB_AIOE_CODE_ACPT) aioe->code |= TB_AIOE_CODE_ACPT;
}
if (events & EPOLLOUT)
{
aioe->code |= TB_AIOE_CODE_SEND;
if (aioo->code & TB_AIOE_CODE_CONN) aioe->code |= TB_AIOE_CODE_CONN;
}
if (events & (EPOLLHUP | EPOLLERR) && !(aioe->code & (TB_AIOE_CODE_RECV | TB_AIOE_CODE_SEND)))
aioe->code |= TB_AIOE_CODE_RECV | TB_AIOE_CODE_SEND;
// oneshot? clear it
if (aioo->code & TB_AIOE_CODE_ONESHOT)
{
// clear code
aioo->code = TB_AIOE_CODE_NONE;
aioo->priv = tb_null;
// clear events manually if no epoll oneshot
#ifndef EPOLLONESHOT
struct epoll_event e = {0};
if (epoll_ctl(impl->epfd, EPOLL_CTL_DEL, tb_sock2fd(aioo->sock), &e) < 0)
{
// trace
tb_trace_e("clear aioo[%p] failed manually for oneshot, error: %d", aioo, errno);
}
#endif
}
}
// ok
return wait;
}
static tb_void_t tb_ifaddrs_interface_done_hwaddr(tb_list_ref_t interfaces, tb_hash_map_ref_t names, struct nlmsghdr* response)
{
// check
tb_assert_and_check_return(interfaces && names && response);
// the info
struct ifaddrmsg* info = (struct ifaddrmsg *)NLMSG_DATA(response);
// attempt to find the interface name
tb_bool_t owner = tb_false;
tb_char_t* name = (tb_char_t*)tb_hash_map_get(names, tb_u2p(info->ifa_index));
if (!name)
{
// get the interface name
struct rtattr* rta = tb_null;
tb_size_t rta_size = NLMSG_PAYLOAD(response, sizeof(struct ifaddrmsg));
for(rta = IFLA_RTA(info); RTA_OK(rta, rta_size); rta = RTA_NEXT(rta, rta_size))
{
// done
tb_pointer_t rta_data = RTA_DATA(rta);
tb_size_t rta_data_size = RTA_PAYLOAD(rta);
switch(rta->rta_type)
{
case IFLA_IFNAME:
{
// make name
name = (tb_char_t*)tb_ralloc(name, rta_data_size + 1);
tb_assert_and_check_break(name);
// copy name
tb_strlcpy(name, rta_data, rta_data_size + 1);
// save name
tb_hash_map_insert(names, tb_u2p(info->ifa_index), name);
owner = tb_true;
}
break;
default:
break;
}
}
}
// check
tb_check_return(name);
// done
struct rtattr* rta = tb_null;
tb_size_t rta_size = NLMSG_PAYLOAD(response, sizeof(struct ifaddrmsg));
for(rta = IFLA_RTA(info); RTA_OK(rta, rta_size); rta = RTA_NEXT(rta, rta_size))
{
/* attempt to get the interface from the cached interfaces
* and make a new interface if no the cached interface
*/
tb_ifaddrs_interface_t interface_new = {0};
tb_ifaddrs_interface_ref_t interface = tb_ifaddrs_interface_find((tb_iterator_ref_t)interfaces, name);
if (!interface) interface = &interface_new;
// check
tb_assert(interface == &interface_new || interface->name);
// done
tb_pointer_t rta_data = RTA_DATA(rta);
tb_size_t rta_data_size = RTA_PAYLOAD(rta);
switch(rta->rta_type)
{
case IFLA_ADDRESS:
{
// no hwaddr?
if (!(interface->flags & TB_IFADDRS_INTERFACE_FLAG_HAVE_HWADDR))
{
// check
tb_check_break(rta_data_size == sizeof(interface->hwaddr.u8));
// save flags
interface->flags |= TB_IFADDRS_INTERFACE_FLAG_HAVE_HWADDR;
if (info->ifa_flags & IFF_LOOPBACK) interface->flags |= TB_IFADDRS_INTERFACE_FLAG_IS_LOOPBACK;
// save hwaddr
tb_memcpy(interface->hwaddr.u8, rta_data, sizeof(interface->hwaddr.u8));
// trace
tb_trace_d("name: %s, hwaddr: %{hwaddr}", name, &interface->hwaddr);
// new interface? save it
if (interface == &interface_new)
{
// save interface name
interface->name = tb_strdup(name);
tb_assert(interface->name);
// save interface
tb_list_insert_tail(interfaces, interface);
}
}
}
break;
case IFLA_IFNAME:
case IFLA_BROADCAST:
case IFLA_STATS:
break;
default:
break;
}
}
// exit name
if (name && owner) tb_free(name);
name = tb_null;
}
static tb_void_t tb_ifaddrs_interface_done_ipaddr(tb_list_ref_t interfaces, tb_hash_map_ref_t names, struct nlmsghdr* response)
{
// check
tb_assert_and_check_return(interfaces && names && response);
// the info
struct ifaddrmsg* info = (struct ifaddrmsg *)NLMSG_DATA(response);
// must be not link
tb_assert_and_check_return(info->ifa_family != AF_PACKET);
// attempt to find the interface name
tb_bool_t owner = tb_false;
tb_char_t* name = (tb_char_t*)tb_hash_map_get(names, tb_u2p(info->ifa_index));
if (!name)
{
// get the interface name
struct rtattr* rta = tb_null;
tb_size_t rta_size = NLMSG_PAYLOAD(response, sizeof(struct ifaddrmsg));
for(rta = IFA_RTA(info); RTA_OK(rta, rta_size); rta = RTA_NEXT(rta, rta_size))
{
// done
tb_pointer_t rta_data = RTA_DATA(rta);
tb_size_t rta_data_size = RTA_PAYLOAD(rta);
switch(rta->rta_type)
{
case IFA_LABEL:
{
// make name
name = (tb_char_t*)tb_ralloc(name, rta_data_size + 1);
tb_assert_and_check_break(name);
// copy name
tb_strlcpy(name, rta_data, rta_data_size + 1);
// save name
tb_hash_map_insert(names, tb_u2p(info->ifa_index), name);
owner = tb_true;
}
break;
default:
break;
}
}
}
// check
tb_check_return(name);
// done
struct rtattr* rta = tb_null;
tb_size_t rta_size = NLMSG_PAYLOAD(response, sizeof(struct ifaddrmsg));
for(rta = IFA_RTA(info); RTA_OK(rta, rta_size); rta = RTA_NEXT(rta, rta_size))
{
/* attempt to get the interface from the cached interfaces
* and make a new interface if no the cached interface
*/
tb_ifaddrs_interface_t interface_new = {0};
tb_ifaddrs_interface_ref_t interface = tb_ifaddrs_interface_find((tb_iterator_ref_t)interfaces, name);
if (!interface) interface = &interface_new;
// check
tb_assert(interface == &interface_new || interface->name);
// done
tb_pointer_t rta_data = RTA_DATA(rta);
switch(rta->rta_type)
{
case IFA_LOCAL:
case IFA_ADDRESS:
{
// make ipaddr
tb_ipaddr_t ipaddr;
if (!tb_ifaddrs_netlink_ipaddr_save(&ipaddr, info->ifa_family, info->ifa_index, rta_data)) break;
// save flags
if ((info->ifa_flags & IFF_LOOPBACK) || tb_ipaddr_ip_is_loopback(&ipaddr))
interface->flags |= TB_IFADDRS_INTERFACE_FLAG_IS_LOOPBACK;
// save ipaddr
switch (tb_ipaddr_family(&ipaddr))
{
case TB_IPADDR_FAMILY_IPV4:
{
interface->flags |= TB_IFADDRS_INTERFACE_FLAG_HAVE_IPADDR4;
interface->ipaddr4 = ipaddr.u.ipv4;
}
break;
case TB_IPADDR_FAMILY_IPV6:
{
interface->flags |= TB_IFADDRS_INTERFACE_FLAG_HAVE_IPADDR6;
interface->ipaddr6 = ipaddr.u.ipv6;
}
break;
default:
break;
}
// trace
tb_trace_d("name: %s, ipaddr: %{ipaddr}", name, &ipaddr);
// new interface? save it
if (tb_ipaddr_family(&ipaddr) && interface == &interface_new)
{
// save interface name
interface->name = tb_strdup(name);
tb_assert(interface->name);
// save interface
tb_list_insert_tail(interfaces, interface);
}
}
break;
case IFA_LABEL:
case IFA_BROADCAST:
break;
default:
break;
}
}
// exit name
if (name && owner) tb_free(name);
name = tb_null;
}
static tb_void_t tb_test_heap_min_func()
{
// init heap
tb_heap_ref_t heap = tb_heap_init(16, tb_element_uint32());
tb_assert_and_check_return(heap);
// clear rand
tb_random_clear(tb_null);
// make heap
tb_size_t i = 0;
for (i = 0; i < 100; i++)
{
// the value
tb_uint32_t val = tb_random_range(tb_null, 0, 50);
// trace
// tb_trace_i("heap_min: put: %u", val);
// put it
tb_heap_put(heap, tb_u2p(val));
}
// clear rand
tb_random_clear(tb_null);
// remove some values
for (i = 0; i < 100; i++)
{
// the value
tb_uint32_t val = tb_random_range(tb_null, 0, 50);
// remove it?
if (!(i & 3))
{
tb_size_t itor = tb_find_all(heap, tb_u2p(val));
if (itor != tb_iterator_tail(heap)) tb_heap_remove(heap, itor);
}
}
// append heap
for (i = 0; i < 30; i++)
{
// the value
tb_uint32_t val = tb_random_range(tb_null, 0, 50);
// put it
tb_heap_put(heap, tb_u2p(val));
}
// trace
tb_trace_i("");
// dump heap
while (tb_heap_size(heap))
{
// put it
tb_uint32_t val = (tb_uint32_t)(tb_size_t)tb_heap_top(heap);
// trace
tb_trace_i("heap_min: pop: %u", val);
// pop it
tb_heap_pop(heap);
}
// exit heap
tb_heap_exit(heap);
}