void web_server_stop(struct web_server_t* ws) {
mutex_lock(ws->mutex);
if (ws->is_running) {
ws->is_running = false;
if (ws->socket_ipv4 != NULL) {
socket_destroy(ws->socket_ipv4);
ws->socket_ipv4 = NULL;
}
if (ws->socket_ipv6 != NULL) {
socket_destroy(ws->socket_ipv6);
ws->socket_ipv6 = NULL;
}
while (ws->connection_count > 0) {
mutex_unlock(ws->mutex);
socket_destroy(ws->connections[0].socket);
web_server_connection_destroy(ws->connections[0].web_connection);
mutex_lock(ws->mutex);
}
log_message(LOG_INFO, "Server stopped");
} else
log_message(LOG_ERROR, "Cannot stop: Server is not running");
mutex_unlock(ws->mutex);
}
static GSOCKET socket_create(int port)
{
GSOCKET sock;
#ifdef WIN32
{
/* WinSockの初期化 */
int nResult;
WORD wRequireVersion; /* 使用するWinSockのバージョン */
WSADATA lpWSAData; /* WinSock初期化の結果 */
/* WinSock2を使用するWinSockのバージョンとして設定 */
wRequireVersion = MAKEWORD( 2, 0 );
/* WinSockの初期化を行なう */
nResult = WSAStartup( wRequireVersion, &lpWSAData );
if( nResult != 0 )
{
ErrMsg("WinSock initialize failed: %d\n", nResult);
return NULL;
}
/* 初期化したWinSockのバージョンが要求したものか確認 */
if( lpWSAData.wVersion != wRequireVersion )
{
ErrMsg("WinSock version mismatch: %d\n", nResult);
return NULL;
}
}
#endif
sock = (GSOCKET)malloc(sizeof(struct _GSOCKET));
if ((sock->fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
free(sock);
return NULL;
}
memset((char *)&sock->addr, 0, sizeof(sock->addr));
sock->child_fd = -1;
sock->addr.sin_family = AF_INET;
sock->addr.sin_addr.s_addr = INADDR_ANY;
sock->addr.sin_port = htons( (unsigned short) port);
if (bind(sock->fd, (struct sockaddr *)&sock->addr, sizeof(sock->addr)) == -1
|| listen(sock->fd, 1) == -1) {
socket_destroy(sock);
return NULL;
}
#if defined(_WIN32) && !defined(__CYGWIN32__)
{
u_long ulCmdArg;
ulCmdArg = 1;
ioctlsocket(sock->fd, FIONBIO, &ulCmdArg);
}
#endif
return sock;
}
/*-------------------------------------------------------------------------*\
* Closes socket used by object
\*-------------------------------------------------------------------------*/
static int meth_close(lua_State *L)
{
p_unix un = (p_unix) auxiliar_checkgroup(L, "unix{any}", 1);
socket_destroy(&un->sock);
lua_pushnumber(L, 1);
return 1;
}
void _rtp_socket_socket_closed_callback(socket_p socket, void* ctx) {
struct rtp_socket_t* rs = (struct rtp_socket_t*)ctx;
mutex_lock(rs->mutex);
for (uint32_t i = 0 ; i < rs->sockets_count ; i++)
if (rs->sockets[i]->socket == socket) {
socket_destroy(rs->sockets[i]->socket);
free(rs->sockets[i]);
for (uint32_t a = i + 1 ; a < rs->sockets_count ; a++)
rs->sockets[a - 1] = rs->sockets[a];
rs->sockets_count--;
break;
}
mutex_unlock(rs->mutex);
}
void network_exit(void) {
log_debug("Shutting down network subsystem");
array_destroy(&_clients, (ItemDestroyFunction)client_destroy); // might call network_create_zombie
array_destroy(&_zombies, (ItemDestroyFunction)zombie_destroy);
if (_plain_server_socket_open) {
event_remove_source(_plain_server_socket.base.handle, EVENT_SOURCE_TYPE_GENERIC);
socket_destroy(&_plain_server_socket);
}
if (_websocket_server_socket_open) {
event_remove_source(_websocket_server_socket.base.handle, EVENT_SOURCE_TYPE_GENERIC);
socket_destroy(&_websocket_server_socket);
}
}
/**
* Close the connection before the GC collect the object.
*/
static int meth_destroy(lua_State *L)
{
p_ssl ssl = (p_ssl)luaL_checkudata(L, 1, "SSL:Connection");
if (ssl->state == LSEC_STATE_CONNECTED) {
socket_setblocking(&ssl->sock);
SSL_shutdown(ssl->ssl);
}
if (ssl->sock != SOCKET_INVALID) {
socket_destroy(&ssl->sock);
}
ssl->state = LSEC_STATE_CLOSED;
if (ssl->ssl) {
/* Clear the registries */
luaL_getmetatable(L, "SSL:Verify:Registry");
lua_pushlightuserdata(L, (void*)ssl->ssl);
lua_pushnil(L);
lua_settable(L, -3);
luaL_getmetatable(L, "SSL:SNI:Registry");
lua_pushlightuserdata(L, (void*)ssl->ssl);
lua_pushnil(L);
lua_settable(L, -3);
/* Destroy the object */
SSL_free(ssl->ssl);
ssl->ssl = NULL;
}
return 0;
}
static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
int socket_id;
socket_core_t *sock_core;
udp_sockdata_t *socket;
int rc;
log_msg(LVL_DEBUG, "tcp_sock_close()");
socket_id = SOCKET_GET_SOCKET_ID(call);
sock_core = socket_cores_find(&client->sockets, socket_id);
if (sock_core == NULL) {
async_answer_0(callid, ENOTSOCK);
return;
}
socket = (udp_sockdata_t *)sock_core->specific_data;
fibril_mutex_lock(&socket->lock);
rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
udp_free_sock_data);
if (rc != EOK) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, rc);
return;
}
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, EOK);
}
/*-------------------------------------------------------------------------*\
* Closes socket used by object
\*-------------------------------------------------------------------------*/
static int meth_close(lua_State *L)
{
p_tcp tcp = (p_tcp) auxiliar_checkgroup(L, "tcp{any}", 1);
socket_destroy(&tcp->sock);
lua_pushnumber(L, 1);
return 1;
}
void server_destroy ( void )
{
if (g_sock != NULL) {
socket_destroy(g_sock);
g_sock = NULL;
}
return;
}
bool rtp_socket_setup(struct rtp_socket_t* rs, struct sockaddr* local_end_point) {
socket_p udp_socket = socket_create("RTP UDP Socket", true);
socket_p tcp_socket = socket_create("RTP TCP Listen Socket", false);
if (socket_bind(udp_socket, local_end_point) && socket_bind(tcp_socket, local_end_point)) {
_rtp_socket_add_socket(rs, udp_socket, true);
socket_set_receive_callback(udp_socket, _rtp_socket_socket_receive_callback, rs);
_rtp_socket_add_socket(rs, tcp_socket, false);
socket_set_accept_callback(tcp_socket, _rtp_socket_accept_callback, rs);
return true;
}
socket_destroy(udp_socket);
socket_destroy(tcp_socket);
return false;
}
int server_init ( int port )
{
if (g_sock != NULL) socket_destroy(g_sock);
if ((g_sock = socket_create(port)) == NULL) {
return -1;
}
return 1;
}
void client_destroy(Client *client) {
event_remove_source(client->socket, EVENT_SOURCE_TYPE_GENERIC);
socket_destroy(client->socket);
if (client->peer != _unknown_peer_name) {
free(client->peer);
}
array_destroy(&client->pending_requests, NULL);
}
bool web_server_start(struct web_server_t* ws, uint16_t port) {
mutex_lock(ws->mutex);
if (!ws->is_running) {
log_message(LOG_INFO, "Trying port %d", port);
ws->socket_ipv4 = _web_server_bind(ws, port, sockaddr_type_inet_4);
ws->socket_ipv6 = _web_server_bind(ws, port, sockaddr_type_inet_6);
if (((ws->socket_types & sockaddr_type_inet_4) == 0 || ws->socket_ipv4 != NULL) && ((ws->socket_types & sockaddr_type_inet_6) == 0 || ws->socket_ipv6 != NULL)) {
if ((ws->socket_types & sockaddr_type_inet_4) != 0)
socket_set_accept_callback(ws->socket_ipv4, _web_server_socket_accept_callback, ws);
if ((ws->socket_types & sockaddr_type_inet_6) != 0)
socket_set_accept_callback(ws->socket_ipv6, _web_server_socket_accept_callback, ws);
ws->is_running = true;
mutex_unlock(ws->mutex);
return true;
}
if (ws->socket_ipv4 != NULL)
socket_destroy(ws->socket_ipv4);
if (ws->socket_ipv6 != NULL)
socket_destroy(ws->socket_ipv6);
log_message(LOG_INFO, "Server started.");
} else
log_message(LOG_ERROR, "Cannot start: Server is already running");
mutex_unlock(ws->mutex);
return false;
}
/**
* Close the connection before the GC collect the object.
*/
static int meth_destroy(lua_State *L)
{
p_ssl ssl = (p_ssl) lua_touserdata(L, 1);
if (ssl->ssl) {
socket_setblocking(&ssl->sock);
SSL_shutdown(ssl->ssl);
socket_destroy(&ssl->sock);
SSL_free(ssl->ssl);
ssl->ssl = NULL;
}
return 0;
}
static void network_handle_accept(void *opaque) {
Socket *server_socket = opaque;
Socket *client_socket;
struct sockaddr_storage address;
socklen_t length = sizeof(address);
char hostname[NI_MAXHOST];
char port[NI_MAXSERV];
char buffer[NI_MAXHOST + NI_MAXSERV + 4]; // 4 == strlen("[]:") + 1
char *name = "<unknown>";
Client *client;
// accept new client socket
client_socket = socket_accept(server_socket, (struct sockaddr *)&address, &length);
if (client_socket == NULL) {
if (!errno_interrupted()) {
log_error("Could not accept new client socket: %s (%d)",
get_errno_name(errno), errno);
}
return;
}
if (socket_address_to_hostname((struct sockaddr *)&address, length,
hostname, sizeof(hostname),
port, sizeof(port)) < 0) {
log_warn("Could not get hostname and port of client (socket: %d): %s (%d)",
client_socket->base.handle, get_errno_name(errno), errno);
} else {
if (address.ss_family == AF_INET6) {
snprintf(buffer, sizeof(buffer), "[%s]:%s", hostname, port);
} else {
snprintf(buffer, sizeof(buffer), "%s:%s", hostname, port);
}
name = buffer;
}
// create new client
client = network_create_client(name, &client_socket->base);
if (client == NULL) {
socket_destroy(client_socket);
free(client_socket);
return;
}
#ifdef BRICKD_WITH_RED_BRICK
client_send_red_brick_enumerate(client, ENUMERATION_TYPE_CONNECTED);
#endif
}
void mesh_exit(void) {
log_info("Shutting down mesh subsystem");
// Cleanup mesh listen socket.
if (is_mesh_listen_socket_open) {
event_remove_source(mesh_listen_socket.base.handle,
EVENT_SOURCE_TYPE_GENERIC);
socket_destroy(&mesh_listen_socket);
}
// Mesh stack related cleanup is done in mesh_stack_destroy().
array_destroy(&mesh_stacks, (ItemDestroyFunction)mesh_stack_destroy);
}
/**
* close the SACD device and clean up.
*/
static int sacd_net_input_close(sacd_input_t dev)
{
if (!dev)
{
return 0;
}
else
{
ServerRequest request;
ServerResponse response;
pb_istream_t input = pb_istream_from_socket(&dev->fd);
pb_ostream_t output = pb_ostream_from_socket(&dev->fd);
uint8_t zero = 0;
request.type = ServerRequest_Type_DISC_CLOSE;
if (!pb_encode(&output, ServerRequest_fields, &request))
{
goto error;
}
pb_write(&output, &zero, 1);
if (!pb_decode(&input, ServerResponse_fields, &response))
{
goto error;
}
if (response.result == 0 || response.type != ServerResponse_Type_DISC_CLOSED)
{
goto error;
}
}
error:
if(dev)
{
socket_destroy(&dev->fd);
socket_close();
if (dev->input_buffer)
{
free(dev->input_buffer);
dev->input_buffer = 0;
}
free(dev);
dev = 0;
}
return 0;
}
static int global_connect(lua_State *L) {
const char *remoteaddr = luaL_checkstring(L, 1);
const char *remoteserv = luaL_checkstring(L, 2);
const char *localaddr = luaL_optstring(L, 3, NULL);
const char *localserv = luaL_optstring(L, 4, "0");
int family = inet_optfamily(L, 5, "unspec");
p_tcp tcp = (p_tcp) lua_newuserdata(L, sizeof(t_tcp));
struct addrinfo bindhints, connecthints;
const char *err = NULL;
/* initialize tcp structure */
memset(tcp, 0, sizeof(t_tcp));
io_init(&tcp->io, (p_send) socket_send, (p_recv) socket_recv,
(p_error) socket_ioerror, &tcp->sock);
timeout_init(&tcp->tm, -1, -1);
buffer_init(&tcp->buf, &tcp->io, &tcp->tm);
tcp->sock = SOCKET_INVALID;
tcp->family = AF_UNSPEC;
/* allow user to pick local address and port */
memset(&bindhints, 0, sizeof(bindhints));
bindhints.ai_socktype = SOCK_STREAM;
bindhints.ai_family = family;
bindhints.ai_flags = AI_PASSIVE;
if (localaddr) {
err = inet_trybind(&tcp->sock, &tcp->family, localaddr,
localserv, &bindhints);
if (err) {
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
}
/* try to connect to remote address and port */
memset(&connecthints, 0, sizeof(connecthints));
connecthints.ai_socktype = SOCK_STREAM;
/* make sure we try to connect only to the same family */
connecthints.ai_family = tcp->family;
err = inet_tryconnect(&tcp->sock, &tcp->family, remoteaddr, remoteserv,
&tcp->tm, &connecthints);
if (err) {
socket_destroy(&tcp->sock);
lua_pushnil(L);
lua_pushstring(L, err);
return 2;
}
auxiliar_setclass(L, "tcp{client}", -1);
return 1;
}
/*-------------------------------------------------------------------------*\
* Tries to connect to remote address (address, port)
\*-------------------------------------------------------------------------*/
const char *inet_tryconnect(p_socket ps, int *family, const char *address,
const char *serv, p_timeout tm, struct addrinfo *connecthints)
{
#ifdef LUASOCKET_SECURITY_SANDBOX
if (luasocket_ip_allowed(address))
return "connect restricted";
#endif // LUASOCKET_SECURITY_SANDBOX
struct addrinfo *iterator = NULL, *resolved = NULL;
const char *err = NULL;
int current_family = *family;
/* try resolving */
err = socket_gaistrerror(getaddrinfo(address, serv,
connecthints, &resolved));
if (err != NULL) {
if (resolved) freeaddrinfo(resolved);
return err;
}
for (iterator = resolved; iterator; iterator = iterator->ai_next) {
timeout_markstart(tm);
/* create new socket if necessary. if there was no
* bind, we need to create one for every new family
* that shows up while iterating. if there was a
* bind, all families will be the same and we will
* not enter this branch. */
if (current_family != iterator->ai_family || *ps == SOCKET_INVALID) {
socket_destroy(ps);
err = inet_trycreate(ps, iterator->ai_family,
iterator->ai_socktype, iterator->ai_protocol);
if (err) continue;
current_family = iterator->ai_family;
/* set non-blocking before connect */
socket_setnonblocking(ps);
}
/* try connecting to remote address */
err = socket_strerror(socket_connect(ps, (SA *) iterator->ai_addr,
(socklen_t) iterator->ai_addrlen, tm));
/* if success or timeout is zero, break out of loop */
if (err == NULL || timeout_iszero(tm)) {
*family = current_family;
break;
}
}
freeaddrinfo(resolved);
/* here, if err is set, we failed */
return err;
}
void _socket_accept_loop(void* ctx) {
struct socket_t* s = (struct socket_t*)ctx;
mutex_lock(s->mutex);
_socket_set_loop_name(s, "Accept Loop");
s->is_connected = true;
int new_socket_fd = 0;
do {
struct sockaddr_storage client_addr;
socklen_t addr_len = sizeof(client_addr);
mutex_unlock(s->mutex);
new_socket_fd = accept(s->socket, (struct sockaddr*)&client_addr, &addr_len);
mutex_lock(s->mutex);
if (new_socket_fd >= 0) {
struct socket_t* new_socket = (struct socket_t*)malloc(sizeof(struct socket_t));
bzero(new_socket, sizeof(struct socket_t));
new_socket->socket = new_socket_fd;
new_socket->mutex = mutex_create();
new_socket->is_connected = true;
bool accept = false;
if (s->callbacks.accept != NULL) {
mutex_unlock(s->mutex);
accept = s->callbacks.accept(s, new_socket, s->callbacks.ctx.accept);
mutex_lock(s->mutex);
}
if (!accept)
socket_destroy(new_socket);
}
} while (new_socket_fd >= 0);
mutex_unlock(s->mutex);
socket_close(s);
}
static void tcp_sock_close(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
int socket_id;
socket_core_t *sock_core;
tcp_sockdata_t *socket;
tcp_error_t trc;
int rc;
log_msg(LVL_DEBUG, "tcp_sock_close()");
socket_id = SOCKET_GET_SOCKET_ID(call);
sock_core = socket_cores_find(&client->sockets, socket_id);
if (sock_core == NULL) {
async_answer_0(callid, ENOTSOCK);
return;
}
socket = (tcp_sockdata_t *)sock_core->specific_data;
fibril_mutex_lock(&socket->lock);
if (socket->conn != NULL) {
trc = tcp_uc_close(socket->conn);
if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, EBADF);
return;
}
}
/* Grab recv_buffer_lock because of CV wait in tcp_sock_recv_fibril() */
fibril_mutex_lock(&socket->recv_buffer_lock);
socket->sock_core = NULL;
fibril_mutex_unlock(&socket->recv_buffer_lock);
rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
tcp_free_sock_data);
if (rc != EOK) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, rc);
return;
}
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, EOK);
}
/*-------------------------------------------------------------------------*\
* Tries to bind socket to (address, port)
\*-------------------------------------------------------------------------*/
const char *inet_trybind(p_socket ps, const char *address, const char *serv,
struct addrinfo *bindhints)
{
struct addrinfo *iterator = NULL, *resolved = NULL;
const char *err = NULL;
t_socket sock = *ps;
/* translate luasocket special values to C */
if (strcmp(address, "*") == 0) address = NULL;
if (!serv) serv = "0";
/* try resolving */
err = socket_gaistrerror(getaddrinfo(address, serv, bindhints, &resolved));
if (err) {
if (resolved) freeaddrinfo(resolved);
return err;
}
/* iterate over resolved addresses until one is good */
for (iterator = resolved; iterator; iterator = iterator->ai_next) {
if(sock == SOCKET_INVALID) {
err = socket_strerror(socket_create(&sock, iterator->ai_family,
iterator->ai_socktype, iterator->ai_protocol));
if(err)
continue;
}
/* try binding to local address */
err = socket_strerror(socket_bind(&sock,
(SA *) iterator->ai_addr,
(socklen_t) iterator->ai_addrlen));
/* keep trying unless bind succeeded */
if (err) {
if(sock != *ps)
socket_destroy(&sock);
} else {
/* remember what we connected to, particularly the family */
*bindhints = *iterator;
break;
}
}
/* cleanup and return error */
freeaddrinfo(resolved);
*ps = sock;
return err;
}
/**
* Close a client socket.
* @param csock
* Socket to close.
*/
void client_socket_close(client_socket_t *csock)
{
HARD_ASSERT(csock != NULL);
SDL_LockMutex(socket_mutex);
if (csock->sc != NULL) {
socket_destroy(csock->sc);
csock->sc = NULL;
}
abort_thread = 1;
/* Poke anyone waiting at a cond */
SDL_CondSignal(input_buffer_cond);
SDL_CondSignal(output_buffer_cond);
SDL_UnlockMutex(socket_mutex);
}
/*-------------------------------------------------------------------------*\
* Tries to bind socket to (address, port)
\*-------------------------------------------------------------------------*/
const char *inet_trybind(p_socket ps, int *family, const char *address,
const char *serv, struct addrinfo *bindhints) {
#ifdef LUASOCKET_SECURITY_SANDBOX
if (luasocket_ip_allowed(address))
return "bind restricted";
#endif // LUASOCKET_SECURITY_SANDBOX
struct addrinfo *iterator = NULL, *resolved = NULL;
const char *err = NULL;
int current_family = *family;
/* translate luasocket special values to C */
if (strcmp(address, "*") == 0) address = NULL;
if (!serv) serv = "0";
/* try resolving */
err = socket_gaistrerror(getaddrinfo(address, serv, bindhints, &resolved));
if (err) {
if (resolved) freeaddrinfo(resolved);
return err;
}
/* iterate over resolved addresses until one is good */
for (iterator = resolved; iterator; iterator = iterator->ai_next) {
if (current_family != iterator->ai_family || *ps == SOCKET_INVALID) {
socket_destroy(ps);
err = inet_trycreate(ps, iterator->ai_family,
iterator->ai_socktype, iterator->ai_protocol);
if (err) continue;
current_family = iterator->ai_family;
}
/* try binding to local address */
err = socket_strerror(socket_bind(ps, (SA *) iterator->ai_addr,
(socklen_t) iterator->ai_addrlen));
/* keep trying unless bind succeeded */
if (err == NULL) {
*family = current_family;
/* set to non-blocking after bind */
socket_setnonblocking(ps);
break;
}
}
/* cleanup and return error */
freeaddrinfo(resolved);
/* here, if err is set, we failed */
return err;
}
bool _rtp_socket_accept_callback(socket_p socket, socket_p new_socket, void* ctx) {
struct rtp_socket_t* rs = (struct rtp_socket_t*)ctx;
if (new_socket != NULL) {
if (rs->allowed_remote_end_point == NULL || sockaddr_equals_host(socket_get_remote_end_point(new_socket), rs->allowed_remote_end_point)) {
_rtp_socket_add_socket(rs, new_socket, true);
return true;
} else {
socket_close(new_socket);
socket_destroy(new_socket);
}
}
return false;
}
/*-------------------------------------------------------------------------*\
* Binds an object to an address
\*-------------------------------------------------------------------------*/
static const char *unix_trybind(p_unix un, const char *path) {
struct sockaddr_un local;
size_t len = strlen(path);
int err;
if (len >= sizeof(local.sun_path)) return "path too long";
memset(&local, 0, sizeof(local));
strcpy(local.sun_path, path);
local.sun_family = AF_UNIX;
#ifdef UNIX_HAS_SUN_LEN
local.sun_len = sizeof(local.sun_family) + sizeof(local.sun_len)
+ len + 1;
err = socket_bind(&un->sock, (SA *) &local, local.sun_len);
#else
err = socket_bind(&un->sock, (SA *) &local,
sizeof(local.sun_family) + len);
#endif
if (err != IO_DONE) socket_destroy(&un->sock);
return socket_strerror(err);
}
/*-------------------------------------------------------------------------*\
* Tries to connect to remote address (address, port)
\*-------------------------------------------------------------------------*/
const char *inet_tryconnect(p_socket ps, int *family, const char *address,
const char *serv, p_timeout tm, struct addrinfo *connecthints)
{
struct addrinfo *iterator = NULL, *resolved = NULL;
const char *err = NULL;
/* try resolving */
err = socket_gaistrerror(getaddrinfo(address, serv,
connecthints, &resolved));
if (err != NULL) {
if (resolved) freeaddrinfo(resolved);
return err;
}
for (iterator = resolved; iterator; iterator = iterator->ai_next) {
timeout_markstart(tm);
/* create new socket if necessary. if there was no
* bind, we need to create one for every new family
* that shows up while iterating. if there was a
* bind, all families will be the same and we will
* not enter this branch. */
if (*family != iterator->ai_family) {
socket_destroy(ps);
err = socket_strerror(socket_create(ps, iterator->ai_family,
iterator->ai_socktype, iterator->ai_protocol));
if (err != NULL) {
freeaddrinfo(resolved);
return err;
}
*family = iterator->ai_family;
/* all sockets initially non-blocking */
socket_setnonblocking(ps);
}
/* try connecting to remote address */
err = socket_strerror(socket_connect(ps, (SA *) iterator->ai_addr,
(socklen_t) iterator->ai_addrlen, tm));
/* if success, break out of loop */
if (err == NULL) break;
}
freeaddrinfo(resolved);
/* here, if err is set, we failed */
return err;
}
int
ksocket_close(ksocket_t ks, struct cred *cr)
{
struct sonode *so;
so = KSTOSO(ks);
/* All Solaris components should pass a cred for this operation. */
ASSERT(cr != NULL);
mutex_enter(&so->so_lock);
if (!KSOCKET_VALID(ks)) {
mutex_exit(&so->so_lock);
return (ENOTSOCK);
}
so->so_state |= SS_CLOSING;
if (so->so_count > 1) {
mutex_enter(&so->so_acceptq_lock);
cv_broadcast(&so->so_acceptq_cv);
mutex_exit(&so->so_acceptq_lock);
cv_broadcast(&so->so_rcv_cv);
cv_broadcast(&so->so_state_cv);
cv_broadcast(&so->so_single_cv);
cv_broadcast(&so->so_read_cv);
cv_broadcast(&so->so_snd_cv);
cv_broadcast(&so->so_copy_cv);
}
while (so->so_count > 1)
cv_wait(&so->so_closing_cv, &so->so_lock);
mutex_exit(&so->so_lock);
/* Remove callbacks, if any */
(void) ksocket_setcallbacks(ks, NULL, NULL, cr);
(void) socket_close(so, 0, cr);
socket_destroy(so);
return (0);
}
/*-------------------------------------------------------------------------*\
* Tries to bind socket to (address, port)
\*-------------------------------------------------------------------------*/
const char *inet_trybind(p_socket ps, const char *address, unsigned short port)
{
struct sockaddr_in local;
int err;
memset(&local, 0, sizeof(local));
/* address is either wildcard or a valid ip address */
local.sin_addr.s_addr = htonl(INADDR_ANY);
local.sin_port = htons(port);
local.sin_family = AF_INET;
if (strcmp(address, "*") && !inet_aton(address, &local.sin_addr)) {
struct hostent *hp = NULL;
struct in_addr **addr;
err = socket_gethostbyname(address, &hp);
if (err != IO_DONE) return socket_hoststrerror(err);
addr = (struct in_addr **) hp->h_addr_list;
memcpy(&local.sin_addr, *addr, sizeof(struct in_addr));
}
err = socket_bind(ps, (SA *) &local, sizeof(local));
if (err != IO_DONE) socket_destroy(ps);
return socket_strerror(err);
}
/*-------------------------------------------------------------------------*\
* Turns a master unix object into a client object.
\*-------------------------------------------------------------------------*/
static const char *unix_tryconnect(p_unix un, const char *path)
{
struct sockaddr_un remote;
int err;
size_t len = strlen(path);
if (len >= sizeof(remote.sun_path)) return "path too long";
memset(&remote, 0, sizeof(remote));
strcpy(remote.sun_path, path);
remote.sun_family = AF_UNIX;
timeout_markstart(&un->tm);
#ifdef UNIX_HAS_SUN_LEN
remote.sun_len = sizeof(remote.sun_family) + sizeof(remote.sun_len)
+ len + 1;
err = socket_connect(&un->sock, (SA *) &remote, remote.sun_len, &un->tm);
#else
err = socket_connect(&un->sock, (SA *) &remote,
sizeof(remote.sun_family) + len, &un->tm);
#endif
if (err != IO_DONE) socket_destroy(&un->sock);
return socket_strerror(err);
}
