*/
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.
return sk_write_oob(ps->sub_socket, data, len);
}
-static void sk_proxy_flush (Socket s)
+static void sk_proxy_write_eof (Socket s)
{
Proxy_Socket ps = (Proxy_Socket) s;
if (ps->state != PROXY_STATE_ACTIVE) {
- ps->pending_flush = 1;
+ ps->pending_eof = 1;
return;
}
- sk_flush(ps->sub_socket);
+ sk_write_eof(ps->sub_socket);
}
-static void sk_proxy_set_private_ptr (Socket s, void *ptr)
+static void sk_proxy_flush (Socket s)
{
Proxy_Socket ps = (Proxy_Socket) s;
- sk_set_private_ptr(ps->sub_socket, ptr);
-}
-static void * sk_proxy_get_private_ptr (Socket s)
-{
- Proxy_Socket ps = (Proxy_Socket) s;
- return sk_get_private_ptr(ps->sub_socket);
+ if (ps->state != PROXY_STATE_ACTIVE) {
+ ps->pending_flush = 1;
+ return;
+ }
+ sk_flush(ps->sub_socket);
}
static void sk_proxy_set_frozen (Socket s, int is_frozen)
plug_sent(ps->plug, bufsize);
}
-static int plug_proxy_accepting (Plug p, OSSocket sock)
+static int plug_proxy_accepting(Plug p,
+ accept_fn_t constructor, accept_ctx_t ctx)
{
Proxy_Plug pp = (Proxy_Plug) p;
Proxy_Socket ps = pp->proxy_socket;
if (ps->state != PROXY_STATE_ACTIVE) {
- ps->accepting_sock = sock;
+ ps->accepting_constructor = constructor;
+ ps->accepting_ctx = ctx;
return ps->negotiate(ps, PROXY_CHANGE_ACCEPTING);
}
- return plug_accepting(ps->plug, sock);
+ return plug_accepting(ps->plug, constructor, ctx);
}
/*
* This function can accept a NULL pointer as `addr', in which case
* it will only check the host name.
*/
-static int proxy_for_destination (SockAddr addr, char *hostname, int port,
- Conf *conf)
+int proxy_for_destination (SockAddr addr, const char *hostname,
+ int port, Conf *conf)
{
int s = 0, e = 0;
char hostip[64];
int hostip_len, hostname_len;
const char *exclude_list;
+ /*
+ * Special local connections such as Unix-domain sockets
+ * unconditionally cannot be proxied, even in proxy-localhost
+ * mode. There just isn't any way to ask any known proxy type for
+ * them.
+ */
+ if (addr && sk_address_is_special_local(addr))
+ return 0; /* do not proxy */
+
/*
* Check the host name and IP against the hard-coded
* representations of `localhost'.
sk_proxy_close,
sk_proxy_write,
sk_proxy_write_oob,
+ sk_proxy_write_eof,
sk_proxy_flush,
- sk_proxy_set_private_ptr,
- sk_proxy_get_private_ptr,
sk_proxy_set_frozen,
- sk_proxy_socket_error
+ sk_proxy_socket_error,
+ NULL, /* peer_info */
};
static const struct plug_function_table plug_fn_table = {
ret->error = NULL;
ret->pending_flush = 0;
+ ret->pending_eof = 0;
ret->freeze = 0;
bufchain_init(&ret->pending_input_data);
conf_get_int(conf, CONF_addressfamily));
if (sk_addr_error(proxy_addr) != NULL) {
ret->error = "Proxy error: Unable to resolve proxy host name";
+ sfree(pplug);
+ sk_addr_free(proxy_addr);
return (Socket)ret;
}
sfree(proxy_canonical_name);
* what should we do? close the socket with an appropriate
* error message?
*/
- return plug_accepting(p->plug, p->accepting_sock);
+ return plug_accepting(p->plug,
+ p->accepting_constructor, p->accepting_ctx);
}
if (change == PROXY_CHANGE_RECEIVE) {
type = sk_addrtype(p->remote_addr);
if (type == ADDRTYPE_IPV6) {
- plug_closing(p->plug, "Proxy error: SOCKS version 4 does"
- " not support IPv6", PROXY_ERROR_GENERAL, 0);
+ p->error = "Proxy error: SOCKS version 4 does not support IPv6";
return 1;
} else if (type == ADDRTYPE_IPV4) {
namelen = 0;
* what should we do? close the socket with an appropriate
* error message?
*/
- return plug_accepting(p->plug, p->accepting_sock);
+ return plug_accepting(p->plug,
+ p->accepting_constructor, p->accepting_ctx);
}
if (change == PROXY_CHANGE_RECEIVE) {
* what should we do? close the socket with an appropriate
* error message?
*/
- return plug_accepting(p->plug, p->accepting_sock);
+ return plug_accepting(p->plug,
+ p->accepting_constructor, p->accepting_ctx);
}
if (change == PROXY_CHANGE_RECEIVE) {
* what should we do? close the socket with an appropriate
* error message?
*/
- return plug_accepting(p->plug, p->accepting_sock);
+ return plug_accepting(p->plug,
+ p->accepting_constructor, p->accepting_ctx);
}
if (change == PROXY_CHANGE_RECEIVE) {