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); }