static PyObject *
UDP_func_getsockname(UDP *self)
{
int r, namelen;
char ip[INET6_ADDRSTRLEN];
struct sockaddr sockname;
struct sockaddr_in *addr4;
struct sockaddr_in6 *addr6;
namelen = sizeof(sockname);
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
r = uv_udp_getsockname((uv_udp_t *)UV_HANDLE(self), &sockname, &namelen);
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError);
return NULL;
}
if (sockname.sa_family == AF_INET) {
addr4 = (struct sockaddr_in*)&sockname;
uv_ip4_name(addr4, ip, INET_ADDRSTRLEN);
return Py_BuildValue("si", ip, ntohs(addr4->sin_port));
} else if (sockname.sa_family == AF_INET6) {
addr6 = (struct sockaddr_in6*)&sockname;
uv_ip6_name(addr6, ip, INET6_ADDRSTRLEN);
return Py_BuildValue("si", ip, ntohs(addr6->sin6_port));
} else {
PyErr_SetString(PyExc_UDPError, "unknown address type detected");
return NULL;
}
}
static void udp_recv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
unsigned flags) {
struct sockaddr sockname;
int namelen;
int r;
ASSERT(nread >= 0);
if (nread == 0) {
free(buf.base);
return;
}
memset(&sockname, -1, sizeof sockname);
namelen = sizeof(sockname);
r = uv_udp_getsockname(&udp, &sockname, &namelen);
ASSERT(r == 0);
check_sockname(&sockname, "0.0.0.0", 0, "udp receiving socket");
getsocknamecount++;
uv_close((uv_handle_t*) &udp, NULL);
uv_close((uv_handle_t*) handle, NULL);
}
static int udp_listener() {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
struct sockaddr sockname;
int namelen;
int r;
r = uv_udp_init(loop, &udpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
return 1;
}
r = uv_udp_bind(&udpServer, addr, 0);
if (r) {
fprintf(stderr, "Bind error\n");
return 1;
}
memset(&sockname, -1, sizeof sockname);
namelen = sizeof sockname;
r = uv_udp_getsockname(&udpServer, &sockname, &namelen);
ASSERT(r == 0);
check_sockname(&sockname, "0.0.0.0", server_port, "udp listener socket");
getsocknamecount++;
r = uv_udp_recv_start(&udpServer, alloc, udp_recv);
ASSERT(r == 0);
return 0;
}
int luv_udp_getsockname(lua_State* L) {
uv_udp_t* handle = (uv_udp_t*)luv_checkudata(L, 1, "udp");
int family;
int port = 0;
char ip[INET6_ADDRSTRLEN];
struct sockaddr_storage address;
int addrlen = sizeof(address);
if (uv_udp_getsockname(handle, (struct sockaddr*)(&address), &addrlen)) {
uv_err_t err = uv_last_error(luv_get_loop(L));
return luaL_error(L, "udp_getsockname: %s", uv_strerror(err));
}
family = address.ss_family;
if (family == AF_INET) {
struct sockaddr_in* addrin = (struct sockaddr_in*)&address;
uv_inet_ntop(AF_INET, &(addrin->sin_addr), ip, INET6_ADDRSTRLEN);
port = ntohs(addrin->sin_port);
} else if (family == AF_INET6) {
struct sockaddr_in6* addrin6 = (struct sockaddr_in6*)&address;
uv_inet_ntop(AF_INET6, &(addrin6->sin6_addr), ip, INET6_ADDRSTRLEN);
port = ntohs(addrin6->sin6_port);
}
lua_newtable(L);
lua_pushnumber(L, port);
lua_setfield(L, -2, "port");
lua_pushnumber(L, family);
lua_setfield(L, -2, "family");
lua_pushstring(L, ip);
lua_setfield(L, -2, "address");
return 1;
}
extern "C" int
rust_uv_udp_getsockname
(uv_udp_t* handle, sockaddr_storage* name) {
// sockaddr_storage is big enough to hold either
// sockaddr_in or sockaddr_in6
int namelen = sizeof(sockaddr_storage);
return uv_udp_getsockname(handle, (sockaddr*)name, &namelen);
}
static int luv_udp_getsockname(lua_State* L) {
uv_udp_t* handle = luv_check_udp(L, 1);
struct sockaddr_storage address;
int addrlen = sizeof(address);
int ret = uv_udp_getsockname(handle, (struct sockaddr*)&address, &addrlen);
if (ret < 0) return luv_error(L, ret);
parse_sockaddr(L, &address, addrlen);
return 1;
}
static int lluv_udp_getsockname(lua_State *L){
lluv_handle_t *handle = lluv_check_udp(L, 1, LLUV_FLAG_OPEN);
struct sockaddr_storage sa; int sa_len = sizeof(sa);
int err = uv_udp_getsockname(LLUV_H(handle, uv_udp_t), (struct sockaddr*)&sa, &sa_len);
lua_settop(L, 1);
if(err < 0){
return lluv_fail(L, handle->flags, LLUV_ERR_UV, err, NULL);
}
return lluv_push_addr(L, &sa);
}
int uv_getsockname(uv_handle_t* handle, struct sockaddr* name, int* namelen) {
switch (handle->type) {
case UV_TCP:
return uv_tcp_getsockname((uv_tcp_t*) handle, name, namelen);
case UV_UDP:
return uv_udp_getsockname((uv_udp_t*) handle, name, namelen);
default:
uv_set_sys_error(WSAENOTSOCK);
return -1;
}
}
net::Address UDPSocket::address() const
{
if (!active())
return net::Address();
//throw std::runtime_error("Invalid UDP socket: No address");
struct sockaddr address;
int addrlen = sizeof(address);
int r = uv_udp_getsockname(ptr<uv_udp_t>(), &address, &addrlen);
if (r)
return net::Address();
//throwLastError("Invalid UDP socket: No address");
return Address(&address, addrlen);
}
/*
* Class: com_oracle_libuv_handles_UDPHandle
* Method: _address
* Signature: (J)Lcom/oracle/libuv/Address;
*/
JNIEXPORT jobject JNICALL Java_com_oracle_libuv_handles_UDPHandle__1address
(JNIEnv *env, jobject that, jlong udp) {
assert(udp);
uv_udp_t* handle = reinterpret_cast<uv_udp_t*>(udp);
struct sockaddr_storage address;
sockaddr* sock = reinterpret_cast<sockaddr*>(&address);
int addrlen = sizeof(address);
int r = uv_udp_getsockname(handle, sock, &addrlen);
if (r) {
ThrowException(env, handle->loop, "uv_udp_getsockname");
return NULL;
}
const sockaddr* addr = reinterpret_cast<const sockaddr*>(&address);
return StreamCallbacks::_address_to_js(env, addr);
}
static int64_t HHVM_METHOD(UVUdp, getSockport) {
auto* data = Native::data<UVUdpData>(this_);
struct sockaddr addr;
int addrlen;
if(data->udp_handle->sockPort == 0){
addrlen = sizeof addr;
if(uv_udp_getsockname(data->udp_handle, &addr, &addrlen)){
return -1;
}
data->udp_handle->sockAddr = sock_addr(&addr);
data->udp_handle->sockPort = sock_port(&addr);
}
return data->udp_handle->sockPort;
}
static PyObject *
UDP_func_getsockname(UDP *self)
{
int err, namelen;
struct sockaddr_storage sockname;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
namelen = sizeof(sockname);
err = uv_udp_getsockname(&self->udp_h, (struct sockaddr *)&sockname, &namelen);
if (err < 0) {
RAISE_UV_EXCEPTION(err, PyExc_UDPError);
return NULL;
}
return makesockaddr((struct sockaddr *)&sockname, namelen);
}
int UvUdpSocket::getSockname(struct sockaddr_in* name)
{
int size = sizeof sockaddr_in;
return uv_udp_getsockname(m_uv_udp, (sockaddr*)name, &size);
}
