自学教程：C++ uv_ip6_addr函数代码示例

void TSockSys::Connect(const uint64& SockId, const PSockHost& SockHost, const int& PortN) {	// make sure it's a valid socket	IAssert(IsSock(SockId));	uv_tcp_t* SockHnd = SockIdToHndH.GetDat(SockId);	// make sure we got a valid socket host	IAssert(SockHost->IsOk());	// get connection handle	uv_connect_t* ConnectHnd = (uv_connect_t*)malloc(sizeof(uv_connect_t));	// special handling for v4 and v6	int ResCd = 0;	if (SockHost->IsIpv4()) {		// get address		struct sockaddr_in Addr = uv_ip4_addr(SockHost->GetIpNum().CStr(), PortN);		// establish connection		ResCd = uv_tcp_connect(ConnectHnd, SockHnd, Addr, TSockSys::OnConnect);	} else if (SockHost->IsIpv6()) {		// get address		struct sockaddr_in6 Addr = uv_ip6_addr(SockHost->GetIpNum().CStr(), PortN);		// establish connection		ResCd = uv_tcp_connect6(ConnectHnd, SockHnd, Addr, TSockSys::OnConnect);	}	// check for errors	if (ResCd != 0) {		// cleanup first		free(SockHnd);		// and throw exception		throw TExcept::New("SockSys.Connect: Error establishing socket connection: " + SockSys.GetLastErr());	}}

static int tcp6_echo_start(int port) {  struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port);  int r;  server = (uv_handle_t*)&tcpServer;  serverType = TCP;  r = uv_tcp_init(&tcpServer);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Socket creation error/n");    return 1;  }  /* IPv6 is optional as not all platforms support it */  r = uv_tcp_bind6(&tcpServer, addr6);  if (r) {    /* show message but return OK */    fprintf(stderr, "IPv6 not supported/n");    return 0;  }  r = uv_listen((uv_network_stream_t*)&tcpServer, 128, on_connection);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Listen error/n");    return 1;  }  return 0;}

/* * Class:     com_oracle_libuv_handles_UDPHandle * Method:    _send6 * Signature: (JLjava/nio/ByteBuffer;[BIIILjava/lang/String;)I */JNIEXPORT jint JNICALL Java_com_oracle_libuv_handles_UDPHandle__1send6  (JNIEnv *env, jobject that, jlong udp, jobject buffer, jbyteArray data, jint offset, jint length, jint port, jstring host, jobject context) {  assert(udp);  uv_udp_t* handle = reinterpret_cast<uv_udp_t*>(udp);  const char* h = env->GetStringUTFChars(host, 0);  sockaddr_in6 addr = uv_ip6_addr(h, port);  jbyte* base = (jbyte*) env->GetPrimitiveArrayCritical(data, NULL);  OOME(env, base);  uv_buf_t buf;  buf.base = reinterpret_cast<char*>(base + offset);  buf.len = length;  uv_udp_send_t* req = new uv_udp_send_t();  req->handle = handle;  ContextHolder* req_data = new ContextHolder(env, context);  req->data = req_data;  int r = uv_udp_send6(req, handle, &buf, 1, addr, _send_cb);  env->ReleasePrimitiveArrayCritical(data, base, 0);  if (r) {    delete req_data;    delete req;    ThrowException(env, handle->loop, "uv_udp_send6", h);  }  env->ReleaseStringUTFChars(host, h);  return r;}

void test_ip6_addr_scope(const char* ip6_addr,                         const char* device_name,                         unsigned iface_index) {   /* 40 bytes address, 16 bytes device name, plus reserve */  char scoped_addr[128];  struct sockaddr_in6 addr;  /* skip addresses that are not link-local */  if (strncmp(ip6_addr, "fe80::", 6) != 0) return;#ifdef _WIN32  sprintf(scoped_addr, "%s%%%d", ip6_addr, iface_index);#else  sprintf(scoped_addr, "%s%%%s", ip6_addr, device_name);#endif  LOGF("Testing link-local address %s (iface_index: 0x%02x, device_name: %s)/n",       scoped_addr,       iface_index,       device_name);  addr = uv_ip6_addr(scoped_addr, TEST_PORT);  LOGF("Got scope_id 0x%02x/n", addr.sin6_scope_id);  ASSERT(iface_index == addr.sin6_scope_id);}

extern "C" struct sockaddr_in6rust_uv_ip6_addr(const char* ip, int port) {    rust_task* task = rust_get_current_task();    LOG(task, stdlib, "before creating addr_ptr.. ip %s" /        " port %d/n", ip, port);    return uv_ip6_addr(ip, port);}

int luv_tcp_connect6(lua_State* L) {  int before = lua_gettop(L);  uv_tcp_t* handle = (uv_tcp_t*)luv_checkudata(L, 1, "tcp");  const char* ip_address = luaL_checkstring(L, 2);  int port = luaL_checkint(L, 3);  struct sockaddr_in6 address = uv_ip6_addr(ip_address, port);  luv_connect_ref_t* ref = (luv_connect_ref_t*)malloc(sizeof(luv_connect_ref_t));  /* Store a reference to the userdata */  ref->L = L;  lua_pushvalue(L, 1);  ref->r = luaL_ref(L, LUA_REGISTRYINDEX);  /* Give the connect_req access to this */  ref->connect_req.data = ref;  if (uv_tcp_connect6(&ref->connect_req, handle, address, luv_after_connect)) {    uv_err_t err = uv_last_error(luv_get_loop(L));    return luaL_error(L, "tcp_connect6: %s", uv_strerror(err));  }  assert(lua_gettop(L) == before);  return 0;}

int uvplus_tcp::bind6(const char *ipv6, int port) {   struct sockaddr_in6 addr;   int r = uv_ip6_addr(ipv6, port, &addr);   if (r < 0)      return r;   return bind((const sockaddr *)&addr, 0);}

int32_t uv_udp_handle_t::write_handle(request_udp_write_t& request){	int result;	uv_buf_t uv_buf;	write_uv_request_t* uv_request = get_write_cached_request();	uv_request->m_source = request.m_source;	uv_request->m_session = request.m_session;	uv_request->m_length = request.m_length;	if (request.m_length > 0) {		uv_request->m_string = request.m_string;		uv_buf.len = request.m_length;		uv_buf.base = (char*)request.m_string;	} else {		uv_request->m_buffer = request.m_buffer;		uv_buf.len = buffer_data_length(request.m_buffer);		uv_buf.base = buffer_data_ptr(request.m_buffer);	}	if (!request.m_ipv6) {		result = uv_udp_send(&uv_request->m_write_req, (uv_udp_t*)m_handle, &uv_buf, 1, uv_ip4_addr(REQUEST_SPARE_PTR(request), request.m_port), on_write);	} else {		result = uv_udp_send6(&uv_request->m_write_req, (uv_udp_t*)m_handle, &uv_buf, 1, uv_ip6_addr(REQUEST_SPARE_PTR(request), request.m_port), on_write);	}	if (result == 0) return UV_OK;	put_write_cached_request(uv_request);	return singleton_ref(network_t).last_error(); /* write error occurs */}

/* same ping-pong test, but using IPv6 connection */static void tcp_pinger_v6_new(void) {  int r;  struct sockaddr_in6 server_addr;  pinger_t *pinger;  ASSERT(0 ==uv_ip6_addr("::1", TEST_PORT, &server_addr));  pinger = malloc(sizeof(*pinger));  pinger->state = 0;  pinger->pongs = 0;  /* Try to connect to the server and do NUM_PINGS ping-pongs. */  r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);  pinger->stream.tcp.data = pinger;  ASSERT(!r);  /* We are never doing multiple reads/connects at a time anyway. */  /* so these handles can be pre-initialized. */  r = uv_tcp_connect(&pinger->connect_req,                     &pinger->stream.tcp,                     (const struct sockaddr*) &server_addr,                     pinger_on_connect);  ASSERT(!r);  /* Synchronous connect callbacks are not allowed. */  ASSERT(pinger_on_connect_count == 0);}

static int luv_udp_send(lua_State* L) {    uv_udp_t* handle = luv_check_udp(L, 1);    uv_udp_send_t* req;    uv_buf_t buf;    int ret, port, ref;    const char* host;    struct sockaddr_storage addr;    luv_check_buf(L, 2, &buf);    host = luaL_checkstring(L, 3);    port = luaL_checkinteger(L, 4);    if (uv_ip4_addr(host, port, (struct sockaddr_in*)&addr) &&            uv_ip6_addr(host, port, (struct sockaddr_in6*)&addr)) {        return luaL_error(L, "Invalid IP address or port [%s:%d]", host, port);    }    ref = luv_check_continuation(L, 5);    req = (uv_udp_send_t*)lua_newuserdata(L, sizeof(*req));    req->data = luv_setup_req(L, ref);    ret = uv_udp_send(req, handle, &buf, 1, (struct sockaddr*)&addr, luv_udp_send_cb);    if (ret < 0) {        luv_cleanup_req(L, (luv_req_t*)req->data);        lua_pop(L, 1);        return luv_error(L, ret);    }    return 1;}

static PyObject *UDP_func_bind(UDP *self, PyObject *args){    int r, bind_port, address_type;    char *bind_ip;    RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);    if (!PyArg_ParseTuple(args, "(si):bind", &bind_ip, &bind_port)) {        return NULL;    }    if (bind_port < 0 || bind_port > 65535) {        PyErr_SetString(PyExc_ValueError, "port must be between 0 and 65535");        return NULL;    }    if (pyuv_guess_ip_family(bind_ip, &address_type)) {        PyErr_SetString(PyExc_ValueError, "invalid IP address");        return NULL;    }    if (address_type == AF_INET) {        r = uv_udp_bind((uv_udp_t *)UV_HANDLE(self), uv_ip4_addr(bind_ip, bind_port), 0);    } else {        r = uv_udp_bind6((uv_udp_t *)UV_HANDLE(self), uv_ip6_addr(bind_ip, bind_port), UV_UDP_IPV6ONLY);    }    if (r != 0) {        RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError);        return NULL;    }    Py_RETURN_NONE;}

static int luv__udp_bind(lua_State *L, int family) {  uv_udp_t* handle = (uv_udp_t*)luv_checkudata(L, 1, "udp");  const char* host = luaL_checkstring(L, 2);  int port = luaL_checkint(L, 3);  int flags = 0;  int rc = 0;  switch (family) {  case AF_INET:    rc = uv_udp_bind(handle, uv_ip4_addr(host, port), flags);    break;  case AF_INET6:    rc = uv_udp_bind6(handle, uv_ip6_addr(host, port), flags);    break;  default:    assert(0 && "unexpected family type");    abort();  }  if (rc) {    uv_err_t err = uv_last_error(luv_get_loop(L));    return luaL_error(L, "udp_bind: %s", uv_strerror(err));  }  return 0;}

static int luv_udp_bind(lua_State* L) {    uv_udp_t* handle = luv_check_udp(L, 1);    const char* host = luaL_checkstring(L, 2);    int port = luaL_checkinteger(L, 3);    unsigned int flags = 0;    struct sockaddr_storage addr;    int ret;    if (uv_ip4_addr(host, port, (struct sockaddr_in*)&addr) &&            uv_ip6_addr(host, port, (struct sockaddr_in6*)&addr)) {        return luaL_error(L, "Invalid IP address or port [%s:%d]", host, port);    }    if (lua_type(L, 4) == LUA_TTABLE) {        luaL_checktype(L, 4, LUA_TTABLE);        lua_getfield(L, 4, "reuseaddr");        if (lua_toboolean(L, -1)) flags |= UV_UDP_REUSEADDR;        lua_pop(L, 1);        lua_getfield(L, 4, "ipv6only");        if (lua_toboolean(L, -1)) flags |= UV_UDP_IPV6ONLY;        lua_pop(L, 1);    }    ret = uv_udp_bind(handle, (struct sockaddr*)&addr, flags);    if (ret < 0) return luv_error(L, ret);    lua_pushinteger(L, ret);    return 1;}

static int tcp6_echo_start(int port) {  struct sockaddr_in6 addr6;  int r;  ASSERT(0 == uv_ip6_addr("::1", port, &addr6));  server = (uv_handle_t*)&tcpServer;  serverType = TCP;  r = uv_tcp_init(loop, &tcpServer);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Socket creation error/n");    return 1;  }  /* IPv6 is optional as not all platforms support it */  r = uv_tcp_bind(&tcpServer, (const struct sockaddr*) &addr6, 0);  if (r) {    /* show message but return OK */    fprintf(stderr, "IPv6 not supported/n");    return 0;  }  r = uv_listen((uv_stream_t*)&tcpServer, SOMAXCONN, on_connection);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Listen error/n");    return 1;  }  return 0;}

int network_listen(struct network *net, const char *addr, uint16_t port, uint32_t flags){	if (net == NULL || addr == 0 || port == 0) {		return kr_error(EINVAL);	}	/* Parse address. */	int ret = 0;	struct sockaddr_storage sa;	if (strchr(addr, ':') != NULL) {		ret = uv_ip6_addr(addr, port, (struct sockaddr_in6 *)&sa);	} else {		ret = uv_ip4_addr(addr, port, (struct sockaddr_in *)&sa);	}	if (ret != 0) {		return ret;	}	/* Bind interfaces */	struct endpoint *ep = malloc(sizeof(*ep));	memset(ep, 0, sizeof(*ep));	ep->flags = NET_DOWN;	ep->port = port;	ret = open_endpoint(net, ep, (struct sockaddr *)&sa, flags);	if (ret == 0) {		ret = insert_endpoint(net, addr, ep);	}	if (ret != 0) {		close_endpoint(ep);	}	return ret;}

extern "C" struct sockaddr_in6*rust_uv_ip6_addrp(const char* ip, int port) {  struct sockaddr_in6 addr = uv_ip6_addr(ip, port);  struct sockaddr_in6 *addrp = (sockaddr_in6*)malloc(sizeof(struct sockaddr_in6));  assert(addrp);  memcpy(addrp, &addr, sizeof(struct sockaddr_in6));  return addrp;}

 inline ip6_addr to_ip6_addr(const std::string& ip, int port) {      ip6_addr result;     int res = 0;     if ((res = uv_ip6_addr(ip.c_str(), port, &result)) != 0)         throw exception(fs("uv_ip6_addr error: " << error(res).str()));     return result; }

int uv__udp_set_membership6(uv_udp_t* handle,                            const struct sockaddr_in6* multicast_addr,                            const char* interface_addr,                            uv_membership membership) {  int optname;  int err;  struct ipv6_mreq mreq;  struct sockaddr_in6 addr6;  if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))    return UV_EINVAL;  err = uv_udp_maybe_bind(handle,                          (const struct sockaddr*) &uv_addr_ip6_any_,                          sizeof(uv_addr_ip6_any_),                          UV_UDP_REUSEADDR);  if (err)    return uv_translate_sys_error(err);  memset(&mreq, 0, sizeof(mreq));  if (interface_addr) {    if (uv_ip6_addr(interface_addr, 0, &addr6))      return UV_EINVAL;    mreq.ipv6mr_interface = addr6.sin6_scope_id;  } else {    mreq.ipv6mr_interface = 0;  }  mreq.ipv6mr_multiaddr = multicast_addr->sin6_addr;  switch (membership) {  case UV_JOIN_GROUP:    optname = IPV6_ADD_MEMBERSHIP;    break;  case UV_LEAVE_GROUP:    optname = IPV6_DROP_MEMBERSHIP;    break;  default:    return UV_EINVAL;  }  if (setsockopt(handle->socket,                 IPPROTO_IPV6,                 optname,                 (char*) &mreq,                 sizeof mreq) == SOCKET_ERROR) {    return uv_translate_sys_error(WSAGetLastError());  }  return 0;}

static PyObject *DNSResolver_func_getnameinfo(DNSResolver *self, PyObject *args, PyObject *kwargs){    char *addr;    int port, flags, length;    struct in_addr addr4;    struct in6_addr addr6;    struct sockaddr *sa;    struct sockaddr_in sa4;    struct sockaddr_in6 sa6;    ares_cb_data_t *cb_data;    PyObject *callback;    if (!PyArg_ParseTuple(args, "(si)iO:getnameinfo", &addr, &port, &flags, &callback)) {        return NULL;    }    if (!PyCallable_Check(callback)) {        PyErr_SetString(PyExc_TypeError, "a callable is required");        return NULL;    }    if (port < 0 || port > 65536) {        PyErr_SetString(PyExc_ValueError, "port must be between 0 and 65536");        return NULL;    }    if (uv_inet_pton(AF_INET, addr, &addr4) == 1) {        sa4 = uv_ip4_addr(addr, port);        sa = (struct sockaddr *)&sa4;        length = sizeof(struct sockaddr_in);    } else if (uv_inet_pton(AF_INET6, addr, &addr6) == 1) {        sa6 = uv_ip6_addr(addr, port);        sa = (struct sockaddr *)&sa6;        length = sizeof(struct sockaddr_in6);    } else {        PyErr_SetString(PyExc_ValueError, "invalid IP address");        return NULL;    }    cb_data = (ares_cb_data_t*) PyMem_Malloc(sizeof *cb_data);    if (!cb_data) {        return PyErr_NoMemory();    }    Py_INCREF(callback);    cb_data->resolver = self;    cb_data->cb = callback;    ares_getnameinfo(self->channel, sa, length, flags, &nameinfo_cb, (void *)cb_data);    Py_RETURN_NONE;}

int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {  struct sockaddr_storage addr_st;  struct sockaddr_in* addr4;  struct sockaddr_in6* addr6;  addr4 = (struct sockaddr_in*) &addr_st;  addr6 = (struct sockaddr_in6*) &addr_st;  if (!interface_addr) {    memset(&addr_st, 0, sizeof addr_st);    if (handle->flags & UV_HANDLE_IPV6) {      addr_st.ss_family = AF_INET6;      addr6->sin6_scope_id = 0;    } else {      addr_st.ss_family = AF_INET;      addr4->sin_addr.s_addr = htonl(INADDR_ANY);    }  } else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {    /* nothing, address was parsed */  } else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {    /* nothing, address was parsed */  } else {    return UV_EINVAL;  }  if (handle->socket == INVALID_SOCKET)    return UV_EBADF;  if (addr_st.ss_family == AF_INET) {    if (setsockopt(handle->socket,                   IPPROTO_IP,                   IP_MULTICAST_IF,                   (char*) &addr4->sin_addr,                   sizeof(addr4->sin_addr)) == SOCKET_ERROR) {      return uv_translate_sys_error(WSAGetLastError());    }  } else if (addr_st.ss_family == AF_INET6) {    if (setsockopt(handle->socket,                   IPPROTO_IPV6,                   IPV6_MULTICAST_IF,                   (char*) &addr6->sin6_scope_id,                   sizeof(addr6->sin6_scope_id)) == SOCKET_ERROR) {      return uv_translate_sys_error(WSAGetLastError());    }  } else {    assert(0 && "unexpected address family");    abort();  }  return 0;}

int uv_udp_set_membership(uv_udp_t* handle,                          const char* multicast_addr,                          const char* interface_addr,                          uv_membership membership) {  struct sockaddr_in addr4;  struct sockaddr_in6 addr6;  if (uv_ip4_addr(multicast_addr, 0, &addr4) == 0)    return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);  else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0)    return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);  else    return UV_EINVAL;}

int luv_tcp_bind6(lua_State* L) {  uv_tcp_t* handle = (uv_tcp_t*)luv_checkudata(L, 1, "tcp");  const char* host = luaL_checkstring(L, 2);  int port = luaL_checkint(L, 3);  struct sockaddr_in6 address = uv_ip6_addr(host, port);  if (uv_tcp_bind6(handle, address)) {    uv_err_t err = uv_last_error(luv_get_loop(L));    return luaL_error(L, "tcp_bind6: %s", uv_strerror(err));  }  return 0;}

void melo_get_sock_addr(const char* ip, int port, melo_sockaddr_t * sockaddr){    MELO_ASSERT(NULL != ip, "ip pointer is null");    MELO_ASSERT(NULL != sockaddr, "sockaddr pointer is null");    if(strchr(ip, ':'))    {        uv_ip6_addr(ip, port, (struct sockaddr_in6*)&(sockaddr->addr6));    }    else    {        uv_ip4_addr(ip, port, (struct sockaddr_in*)&(sockaddr->addr4));    }}

bool Settings::IsBindableIP(const std::string &ip, int family, int* _bind_err) {	MS_TRACE();	struct sockaddr_storage bind_addr;	int bind_socket;	int err = 0;	bool bind_ok;	switch (family) {		case AF_INET:			err = uv_ip4_addr(ip.c_str(), 0, (struct sockaddr_in*)&bind_addr);			if (err)				MS_ABORT("uv_ipv4_addr() failed: %s", uv_strerror(err));			bind_socket = socket(AF_INET, SOCK_DGRAM, 0);			if (bind_socket == -1)				MS_ABORT("socket() failed: %s", std::strerror(errno));			err = bind(bind_socket, (const struct sockaddr*)&bind_addr, sizeof(struct sockaddr_in));			break;		case AF_INET6:			uv_ip6_addr(ip.c_str(), 0, (struct sockaddr_in6*)&bind_addr);			if (err)				MS_ABORT("uv_ipv6_addr() failed: %s", uv_strerror(err));			bind_socket = socket(AF_INET6, SOCK_DGRAM, 0);			if (bind_socket == -1)				MS_ABORT("socket() failed: %s", std::strerror(errno));			err = bind(bind_socket, (const struct sockaddr*)&bind_addr, sizeof(struct sockaddr_in6));			break;		default:			MS_ABORT("unknown family");	}	if (err == 0) {		bind_ok = true;	}	else {		bind_ok = false;		*_bind_err = errno;	}	err = close(bind_socket);	if (err)		MS_ABORT("close() failed: %s", std::strerror(errno));	return bind_ok;}

static int echo_start(int port) {  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);  struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port);  int r;  r = uv_tcp_init(&server);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Socket creation error/n");    return 1;  }  r = uv_tcp_bind(&server, addr);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Bind error/n");    return 1;  }  r = uv_tcp_listen(&server, 128, on_connection);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Listen error/n");    return 1;  }  r = uv_tcp_init(&server6);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Socket creation error/n");    return 1;  }  /* IPv6 is optional as not all platforms support it */  r = uv_tcp_bind6(&server6, addr6);  if (r) {    /* show message but return OK */    fprintf(stderr, "IPv6 not supported/n");    return 0;  }  r = uv_tcp_listen(&server6, 128, on_connection);  if (r) {    /* TODO: Error codes */    fprintf(stderr, "Listen error on IPv6/n");    return 1;  }  return 0;}

int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {  struct sockaddr_storage addr_st;  struct sockaddr_in* addr4;  struct sockaddr_in6* addr6;  addr4 = (struct sockaddr_in*) &addr_st;  addr6 = (struct sockaddr_in6*) &addr_st;  if (!interface_addr) {    memset(&addr_st, 0, sizeof addr_st);    if (handle->flags & UV_HANDLE_IPV6) {      addr_st.ss_family = AF_INET6;      addr6->sin6_scope_id = 0;    } else {      addr_st.ss_family = AF_INET;      addr4->sin_addr.s_addr = htonl(INADDR_ANY);    }  } else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {    /* nothing, address was parsed */  } else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {    /* nothing, address was parsed */  } else {    return -EINVAL;  }  if (addr_st.ss_family == AF_INET) {    if (setsockopt(handle->io_watcher.fd,                   IPPROTO_IP,                   IP_MULTICAST_IF,                   (void*) &addr4->sin_addr,                   sizeof(addr4->sin_addr)) == -1) {      return -errno;    }  } else if (addr_st.ss_family == AF_INET6) {    if (setsockopt(handle->io_watcher.fd,                   IPPROTO_IPV6,                   IPV6_MULTICAST_IF,                   &addr6->sin6_scope_id,                   sizeof(addr6->sin6_scope_id)) == -1) {      return -errno;    }  } else {    assert(0 && "unexpected address family");    abort();  }  return 0;}

void TCPClient::ReconnectTimer(uv_timer_t* handle){    TCPClient* theclass = (TCPClient*)handle->data;    if (!theclass->isreconnecting_) {        return;    }    LOG(INFO)<<"start reconnect.../n";    do {        int iret = uv_tcp_init(&theclass->loop_, &theclass->client_handle_->tcphandle);        if (iret) {            LOG(ERROR)<<(GetUVError(iret));            break;        }        theclass->client_handle_->tcphandle.data = theclass->client_handle_;        theclass->client_handle_->parent_server = theclass;        struct sockaddr* pAddr;        if (theclass->isIPv6_) {            struct sockaddr_in6 bind_addr;            int iret = uv_ip6_addr(theclass->connectip_.c_str(), theclass->connectport_, &bind_addr);            if (iret) {                LOG(ERROR)<<(GetUVError(iret));                uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL);                break;            }            pAddr = (struct sockaddr*)&bind_addr;        } else {            struct sockaddr_in bind_addr;            int iret = uv_ip4_addr(theclass->connectip_.c_str(), theclass->connectport_, &bind_addr);            if (iret) {                LOG(ERROR)<<(GetUVError(iret));                uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL);                break;            }            pAddr = (struct sockaddr*)&bind_addr;        }        iret = uv_tcp_connect(&theclass->connect_req_, &theclass->client_handle_->tcphandle, (const sockaddr*)pAddr, AfterConnect);        if (iret) {            LOG(ERROR)<<(GetUVError(iret));            uv_close((uv_handle_t*)&theclass->client_handle_->tcphandle, NULL);            break;        }        return;    } while (0);    //reconnect failure, restart timer to trigger reconnect.    uv_timer_stop(handle);    theclass->repeat_time_ *= 2;    uv_timer_start(handle, TCPClient::ReconnectTimer, theclass->repeat_time_, theclass->repeat_time_);}

static int luv_udp__send(lua_State* L, int family) {  uv_buf_t buf;  uv_udp_t* handle = (uv_udp_t*)luv_checkudata(L, 1, "udp");  size_t len;  const char* chunk = luaL_checklstring(L, 2, &len);  luv_udp_ref_t *ref;  uv_udp_send_t* req = (uv_udp_send_t*)malloc(sizeof(uv_udp_send_t));  int port = luaL_checkint(L, 3);  const char* host = luaL_checkstring(L, 4);  struct sockaddr_in dest;  struct sockaddr_in6 dest6;  int rc;  /* Store a reference to the callback */  lua_pushvalue(L, 5);  ref = malloc(sizeof(*ref));  ref->ref = luaL_ref(L, LUA_REGISTRYINDEX);  req->data = ref;  luv_handle_ref(L, handle->data, 1);  /* Store the chunk   * TODO: this is probably unsafe, should investigate   */  buf = uv_buf_init((char*)chunk, len);  switch(family) {  case AF_INET:    dest = uv_ip4_addr(host, port);    rc = uv_udp_send(req, handle, &buf, 1, dest, luv_on_udp_send);    break;  case AF_INET6:    dest6 = uv_ip6_addr(host, port);    rc = uv_udp_send6(req, handle, &buf, 1, dest6, luv_on_udp_send);    break;  default:    assert(0 && "unexpected family type");    abort();  }  if (rc) {    uv_err_t err = uv_last_error(luv_get_loop(L));    return luaL_error(L, "udp_send: %s", uv_strerror(err));  }  return 0;}