static int raw_closing(Plug plug, const char *error_msg, int error_code, int calling_back) { Raw raw = (Raw) plug; if (error_msg) { /* A socket error has occurred. */ if (raw->s) { sk_close(raw->s); raw->s = NULL; notify_remote_exit(raw->frontend); } logevent(raw->frontend, error_msg); connection_fatal(raw->frontend, "%s", error_msg); } else { /* Otherwise, the remote side closed the connection normally. */ if (!raw->sent_console_eof && from_backend_eof(raw->frontend)) { /* * The front end wants us to close the outgoing side of the * connection as soon as we see EOF from the far end. */ if (!raw->sent_socket_eof) { if (raw->s) sk_write_eof(raw->s); raw->sent_socket_eof= TRUE; } } raw->sent_console_eof = TRUE; raw_check_close(raw); } return 0; }
static void sk_proxy_write_eof(Socket s) { Proxy_Socket ps = (Proxy_Socket)s; if (ps->state != PROXY_STATE_ACTIVE) { ps->pending_eof = 1; return; } sk_write_eof(ps->sub_socket); }
static void sk_proxy_write_eof (Socket s) { ProxySocket *ps = FROMFIELD(s, ProxySocket, sockvt); if (ps->state != PROXY_STATE_ACTIVE) { ps->pending_eof = 1; return; } sk_write_eof(ps->sub_socket); }
static void sk_proxy_write_eof (Socket *s) { ProxySocket *ps = container_of(s, ProxySocket, sock); if (ps->state != PROXY_STATE_ACTIVE) { ps->pending_eof = true; return; } sk_write_eof(ps->sub_socket); }
/* * Call this when proxy negotiation is complete, so that this * socket can begin working normally. */ void proxy_activate(Proxy_Socket p) { void *data; int len; long output_before, output_after; p->state = PROXY_STATE_ACTIVE; /* we want to ignore new receive events until we have sent * all of our buffered receive data. */ sk_set_frozen(p->sub_socket, 1); /* how many bytes of output have we buffered? */ output_before = bufchain_size(&p->pending_oob_output_data) + bufchain_size(&p->pending_output_data); /* and keep track of how many bytes do not get sent. */ output_after = 0; /* send buffered OOB writes */ while (bufchain_size(&p->pending_oob_output_data) > 0) { bufchain_prefix(&p->pending_oob_output_data, &data, &len); output_after += sk_write_oob(p->sub_socket, data, len); bufchain_consume(&p->pending_oob_output_data, len); } /* send buffered normal writes */ while (bufchain_size(&p->pending_output_data) > 0) { bufchain_prefix(&p->pending_output_data, &data, &len); output_after += sk_write(p->sub_socket, data, len); bufchain_consume(&p->pending_output_data, len); } /* if we managed to send any data, let the higher levels know. */ if (output_after < output_before) plug_sent(p->plug, output_after); /* if we were asked to flush the output during * the proxy negotiation process, do so now. */ if (p->pending_flush) sk_flush(p->sub_socket); /* if we have a pending EOF to send, send it */ if (p->pending_eof) sk_write_eof(p->sub_socket); /* if the backend wanted the socket unfrozen, try to unfreeze. * our set_frozen handler will flush buffered receive data before * unfreezing the actual underlying socket. */ if (!p->freeze) sk_set_frozen((Socket)p, 0); }
/* * Send raw special codes. We only handle outgoing EOF here. */ static void raw_special(void *handle, Telnet_Special code) { Raw raw = (Raw) handle; if (code == TS_EOF && raw->s) { sk_write_eof(raw->s); raw->sent_socket_eof= TRUE; raw_check_close(raw); } return; }