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