int main(int argc, char **argv) { sock_t sock; int err; sock_initialize(); sock = sock_connect("www.google.com", 80); if (sock < 0) { sock_shutdown(); return 1; } err = wait_for_connect(sock); if (err < 0) { sock_close(sock); sock_shutdown(); return 1; } sock_close(sock); sock_shutdown(); return 0; }
void libcfs_sock_abort_accept (cfs_socket_t *sock) { /* * XXX Liang: * * we want to wakeup thread blocked by sock_accept, but we don't * know the address where thread is sleeping on, so we cannot * wakeup it directly. * The thread slept in sock_accept will be waken up while: * 1. interrupt by signal * 2. new connection is coming (sonewconn) * 3. disconnecting of the socket (soisconnected) * * Cause we can't send signal to a thread directly(no KPI), so the * only thing can be done here is disconnect the socket (by * sock_shutdown() or sth else? ). * * Shutdown request of socket with SHUT_WR or SHUT_RDWR will * be issured to the protocol. * sock_shutdown()->tcp_usr_shutdown()->tcp_usrclosed()-> * tcp_close()->soisdisconnected(), it will wakeup thread by * wakeup((caddr_t)&so->so_timeo); */ sock->s_flags |= CFS_SOCK_DOWN; sock_shutdown(C2B_SOCK(sock), SHUT_RDWR); }
static int sock_close(PyObject *sock, int shutdown, PyObject *exc, PyObject *enotconn) { PyObject *func, *tmp; if (shutdown >= 0) { if (sock_shutdown(sock, shutdown, exc, enotconn) == -1) return -1; } else { func = PyObject_GetAttr(sock, closeproperty); Py_DECREF(sock); if (!func) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) return -1; PyErr_Clear(); } else { tmp = PyObject_CallObject(func, NULL); Py_DECREF(func); if (!tmp) return -1; Py_DECREF(tmp); } } return 0; }
void libcfs_sock_release (cfs_socket_t *sock) { if (C2B_SOCK(sock) != NULL) { sock_shutdown(C2B_SOCK(sock), 2); sock_close(C2B_SOCK(sock)); } FREE(sock, M_TEMP); }
/* Shutdown a socket for reading or writing. */ error_t S_socket_shutdown (struct sock_user *user, int what) { if (! user) return EOPNOTSUPP; sock_shutdown (user->sock, (what != 1 ? PFLOCAL_SOCK_SHUTDOWN_READ : 0) | (what != 0 ? PFLOCAL_SOCK_SHUTDOWN_WRITE : 0)); return 0; }
errno_t xi_sock_shutdown(xi_socket_t so, int how) { #ifdef __KPI_SOCKET__ return sock_shutdown(so, how); #else thread_funnel_set(network_flock, TRUE); errno_t error; error = soshutdown(so, how); (void)thread_funnel_set(network_flock, FALSE); return error; #endif }
static void exit_program(int val) { char buf[64]; debug(RPT_DEBUG, "%s(val=%d)", __FUNCTION__, val); /* TODO: These things shouldn't be so interdependent. The order * things are shut down in shouldn't matter... */ if (val > 0) { strncpy(buf, "Server shutting down on ", sizeof(buf)); switch(val) { case 1: strcat(buf, "SIGHUP"); break; case 2: strcat(buf, "SIGINT"); break; case 15: strcat(buf, "SIGTERM"); break; default: snprintf(buf, sizeof(buf), "Server shutting down on signal %d", val); break; /* Other values should not be seen, but just in case.. */ } report(RPT_NOTICE, buf); /* report it */ } /* Set emergency reporting and flush all messages if not done already. */ if (report_level == UNSET_INT) report_level = DEFAULT_REPORTLEVEL; if (report_dest == UNSET_INT) report_dest = DEFAULT_REPORTDEST; set_reporting("LCDd", report_level, report_dest); goodbye_screen(); /* display goodbye screen on LCD display */ drivers_unload_all(); /* release driver memory and file descriptors */ /* Shutdown things if server start was complete */ clients_shutdown(); /* shutdown clients (must come first) */ menuscreens_shutdown(); screenlist_shutdown(); /* shutdown screens (must come after client_shutdown) */ input_shutdown(); /* shutdown key input part */ sock_shutdown(); /* shutdown the sockets server */ report(RPT_INFO, "Exiting."); _exit(EXIT_SUCCESS); }
int system_cloud_disconnect(int flags) { int ret = SYSTEM_ERROR_NONE; if (s_state.socket < 0) { return SYSTEM_ERROR_INVALID_STATE; } if (flags & SYSTEM_CLOUD_DISCONNECT_GRACEFULLY) { /* FIXME: Only TCP sockets can be half-closed */ ret = sock_shutdown(s_state.socket, SHUT_WR); if (!ret) { LOG_DEBUG(TRACE, "Half-closed cloud socket"); if (!spark_protocol_command(sp, ProtocolCommands::DISCONNECT, 0, nullptr)) { /* Wait for an error (which means that the server closed our connection). */ system_tick_t start = millis(); while (millis() - start < CLOUD_SOCKET_HALF_CLOSED_WAIT_TIMEOUT) { if (!spark_protocol_event_loop(system_cloud_protocol_instance())) { break; } } } } else { spark_protocol_command(sp, ProtocolCommands::DISCONNECT, 0, nullptr); } } LOG_DEBUG(TRACE, "Close Attempt"); ret = sock_close(s_state.socket); LOG_DEBUG(TRACE, "sock_close()=%s", (ret ? "fail":"success")); if (!(flags & SYSTEM_CLOUD_DISCONNECT_GRACEFULLY)) { spark_protocol_command(sp, ProtocolCommands::TERMINATE, 0, nullptr); } s_state.socket = -1; return ret; }
static enum blk_eh_timer_return nbd_xmit_timeout(struct request *req, bool reserved) { struct nbd_cmd *cmd = blk_mq_rq_to_pdu(req); struct nbd_device *nbd = cmd->nbd; dev_err(nbd_to_dev(nbd), "Connection timed out, shutting down connection\n"); set_bit(NBD_TIMEDOUT, &nbd->runtime_flags); req->errors++; /* * If our disconnect packet times out then we're already holding the * config_lock and could deadlock here, so just set an error and return, * we'll handle shutting everything down later. */ if (req->cmd_type == REQ_TYPE_DRV_PRIV) return BLK_EH_HANDLED; mutex_lock(&nbd->config_lock); sock_shutdown(nbd); mutex_unlock(&nbd->config_lock); return BLK_EH_HANDLED; }
static void _shutdown_subsystems(void) { fserve_shutdown(); xslt_shutdown(); refbuf_shutdown(); slave_shutdown(); auth_shutdown(); yp_shutdown(); stats_shutdown(); global_shutdown(); connection_shutdown(); config_shutdown(); resolver_shutdown(); sock_shutdown(); thread_shutdown(); /* Now that these are done, we can stop the loggers. */ _stop_logging(); log_shutdown(); xmlCleanupParser(); }
void shutdown_subsystems(void) { connection_shutdown(); slave_shutdown(); fserve_shutdown(); stats_shutdown(); stop_logging(); config_shutdown(); refbuf_shutdown(); resolver_shutdown(); sock_shutdown(); DEBUG0 ("library cleanups"); #ifdef HAVE_CURL curl_global_cleanup(); #endif /* Now that these are done, we can stop the loggers. */ log_shutdown(); xslt_shutdown(); thread_shutdown(); global_shutdown(); }
/* * Send or receive packet. */ static int sock_xmit(struct nbd_device *nbd, int send, void *buf, int size, int msg_flags) { struct socket *sock = nbd->sock; int result; struct msghdr msg; struct kvec iov; sigset_t blocked, oldset; if (unlikely(!sock)) { dev_err(disk_to_dev(nbd->disk), "Attempted %s on closed socket in sock_xmit\n", (send ? "send" : "recv")); return -EINVAL; } /* Allow interception of SIGKILL only * Don't allow other signals to interrupt the transmission */ siginitsetinv(&blocked, sigmask(SIGKILL)); sigprocmask(SIG_SETMASK, &blocked, &oldset); do { sock->sk->sk_allocation = GFP_NOIO; iov.iov_base = buf; iov.iov_len = size; msg.msg_name = NULL; msg.msg_namelen = 0; msg.msg_control = NULL; msg.msg_controllen = 0; msg.msg_flags = msg_flags | MSG_NOSIGNAL; if (send) { struct timer_list ti; if (nbd->xmit_timeout) { init_timer(&ti); ti.function = nbd_xmit_timeout; ti.data = (unsigned long)current; ti.expires = jiffies + nbd->xmit_timeout; add_timer(&ti); } result = kernel_sendmsg(sock, &msg, &iov, 1, size); if (nbd->xmit_timeout) del_timer_sync(&ti); } else result = kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); if (signal_pending(current)) { siginfo_t info; printk(KERN_WARNING "nbd (pid %d: %s) got signal %d\n", task_pid_nr(current), current->comm, dequeue_signal_lock(current, ¤t->blocked, &info)); result = -EINTR; sock_shutdown(nbd, !send); break; } if (result <= 0) { if (result == 0) result = -EPIPE; /* short read */ break; } size -= result; buf += result; } while (size > 0); sigprocmask(SIG_SETMASK, &oldset, NULL); return result; }
/** Shutdown the Strophe library. * * @ingroup Init */ void xmpp_shutdown(void) { tls_shutdown(); sock_shutdown(); }
/* * System call vectors. Since I (RIB) want to rewrite sockets as streams, * we have this level of indirection. Not a lot of overhead, since more of * the work is done via read/write/select directly. */ asmlinkage int sys_socketcall(int call, unsigned long *args) { int er; switch(call) { case SYS_SOCKET: er=verify_area(VERIFY_READ, args, 3 * sizeof(long)); if(er) return er; return(sock_socket(get_fs_long(args+0), get_fs_long(args+1), get_fs_long(args+2))); case SYS_BIND: er=verify_area(VERIFY_READ, args, 3 * sizeof(long)); if(er) return er; return(sock_bind(get_fs_long(args+0), (struct sockaddr *)get_fs_long(args+1), get_fs_long(args+2))); case SYS_CONNECT: er=verify_area(VERIFY_READ, args, 3 * sizeof(long)); if(er) return er; return(sock_connect(get_fs_long(args+0), (struct sockaddr *)get_fs_long(args+1), get_fs_long(args+2))); case SYS_LISTEN: er=verify_area(VERIFY_READ, args, 2 * sizeof(long)); if(er) return er; return(sock_listen(get_fs_long(args+0), get_fs_long(args+1))); case SYS_ACCEPT: er=verify_area(VERIFY_READ, args, 3 * sizeof(long)); if(er) return er; return(sock_accept(get_fs_long(args+0), (struct sockaddr *)get_fs_long(args+1), (int *)get_fs_long(args+2))); case SYS_GETSOCKNAME: er=verify_area(VERIFY_READ, args, 3 * sizeof(long)); if(er) return er; return(sock_getsockname(get_fs_long(args+0), (struct sockaddr *)get_fs_long(args+1), (int *)get_fs_long(args+2))); case SYS_GETPEERNAME: er=verify_area(VERIFY_READ, args, 3 * sizeof(long)); if(er) return er; return(sock_getpeername(get_fs_long(args+0), (struct sockaddr *)get_fs_long(args+1), (int *)get_fs_long(args+2))); case SYS_SOCKETPAIR: er=verify_area(VERIFY_READ, args, 4 * sizeof(long)); if(er) return er; return(sock_socketpair(get_fs_long(args+0), get_fs_long(args+1), get_fs_long(args+2), (unsigned long *)get_fs_long(args+3))); case SYS_SEND: er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long)); if(er) return er; return(sock_send(get_fs_long(args+0), (void *)get_fs_long(args+1), get_fs_long(args+2), get_fs_long(args+3))); case SYS_SENDTO: er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long)); if(er) return er; return(sock_sendto(get_fs_long(args+0), (void *)get_fs_long(args+1), get_fs_long(args+2), get_fs_long(args+3), (struct sockaddr *)get_fs_long(args+4), get_fs_long(args+5))); case SYS_RECV: er=verify_area(VERIFY_READ, args, 4 * sizeof(unsigned long)); if(er) return er; return(sock_recv(get_fs_long(args+0), (void *)get_fs_long(args+1), get_fs_long(args+2), get_fs_long(args+3))); case SYS_RECVFROM: er=verify_area(VERIFY_READ, args, 6 * sizeof(unsigned long)); if(er) return er; return(sock_recvfrom(get_fs_long(args+0), (void *)get_fs_long(args+1), get_fs_long(args+2), get_fs_long(args+3), (struct sockaddr *)get_fs_long(args+4), (int *)get_fs_long(args+5))); case SYS_SHUTDOWN: er=verify_area(VERIFY_READ, args, 2* sizeof(unsigned long)); if(er) return er; return(sock_shutdown(get_fs_long(args+0), get_fs_long(args+1))); case SYS_SETSOCKOPT: er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long)); if(er) return er; return(sock_setsockopt(get_fs_long(args+0), get_fs_long(args+1), get_fs_long(args+2), (char *)get_fs_long(args+3), get_fs_long(args+4))); case SYS_GETSOCKOPT: er=verify_area(VERIFY_READ, args, 5*sizeof(unsigned long)); if(er) return er; return(sock_getsockopt(get_fs_long(args+0), get_fs_long(args+1), get_fs_long(args+2), (char *)get_fs_long(args+3), (int *)get_fs_long(args+4))); default: return(-EINVAL); } }