GitLab

* src/process.c (check_for_dns): If the async DNS request
failed and the associated process is still in "connect" state,
deactivate the process and set status to "failed".

* src/process.c (set_network_socket_coding_system): Pass in
the host/service that's been computed already.

* src/gnutls.c (gnutls_verify_boot): Refactor out into its own
function so that we can call it asynchronously.
(Fgnutls_boot): Use it.

* src/process.c (wait_reading_process_output): Verify the TLS
negotiation.

* src/process.c (wait_reading_process_output): Deactivate the
correct process on failure.

* src/gnutls.c (gnutls_try_handshake): Factor out into its own
function.
(emacs_gnutls_handshake): Use it.
(emacs_gnutls_read): Just return instead of retrying the handshake.

* src/process.c (finish_after_tls_connection): Factor out
into its own function.
(connect_network_socket): Use it.
(wait_reading_process_output): Retry TLS handshakes.
(wait_reading_process_output): Defer sentinel until TLS completes.

* src/process.c (wait_reading_process_output): Simplify the
DNS resolution loop a bit.

* src/process.c: Remove declaration/definition of dns_processes list.
* src/process.c (wait_reading_process_output): Loop over all processes in
Vprocess_alist instead of dns_processes, to check for completed DNS
requests.

* src/process.c (Fset_process_filter): Don't set the socket
masks here, because we may not have a socket yet.
(set_process_filter_masks): New function.
(connect_network_socket): Set the filter masks here.

* src/process.c (free_dns_request): Factor out into own function.
(Fdelete_process): When deleting a process, free any DNS
structures associated with it.
(check_for_dns): Always free all DNS resources.

* src/process.c (set-process-window-size): Explicitly return Qnil when
called with network processes as set_window_size won't work anyway on
socket fds.  As a welcome side effect, this makes the blocking
wait_for_socket_fds call obsolete.

* src/process.c (Fmake_network_process): Set the read/write
coding systems here, so that special bindings work.
(Fmake_network_process): Complete the coding system setup here.

* src/process.c (connect_network_socket): Mark the connection
as failed if the handshake didn't succeed yet.  This should be
reworked later.

* lisp/net/network-stream.el (network-stream-open-tls):
Postpone NSM verification when running async.

* src/process.c (Fset_process_filter): This function doesn't
need to wait.
(connect_network_socket): Set the process status to "run" only
after TLS negotiation.
(wait_for_socket_fds): Take a name parameter for more debugging.
(wait_reading_process_output): Don't change status to "run"
unless TLS negotiation has finished.
(send_process): Wait for the process here instead of
send_process_string.
(connect_network_socket): Call the network security manager.

* doc/lispref/processes.texi (Network Processes): Remove
mention of `dns'.

* lisp/net/network-stream.el (open-network-stream): Remove
mention of `dns'.

* src/process.c (Fset_process_filter)
(Fset_process_window_size, Fprocess_contact)
(Fprocess_datagram_address, Fset_process_datagram_address)
(Fset_network_process_option, Fprocess_send_region)
(Fprocess_send_string, Fset_process_coding_system)
(Fset_process_filter_multibyte): Remove the #ifdef
HAVE_GETADDRINFO_A checks.
(Fprocess_send_string): Wait for TLS negotiation.
(wait_for_tls_negotiation): New function.
(send_process): Remove the TLS boot check.

* src/process.c (Fmake_network_process): Ditto.

* lisp/url/url-gw.el (url-open-stream): Just use :nowait t,
since we're not differentiating.

* src/process.c (set-process-filter, set-process-window-size,
process-contact, process-datagram-address, set-process-datagram-address,
set-network-process-option): Make functions wait (block) on network
process until pending DNS requests have been processed and associated
socket initialized.

* src/process.c (process-send-region, process-send-string,
process-send-eof): Make functions wait (block) while network process is
in connect state.

* src/process.c (conv_lisp_to_sockaddr): AF_INET6 addresses are
converted to a list of 16 bit quantities by
conv_sockaddr_to_lisp(). conv_lisp_to_sockaddr() should follow the
same scheme rather than expecting a (longer) list of 8 bit
quantities.

* test/lisp/net/network-stream-tests.el
(connect-to-tls-ipv6-nowait): Add an ipv6 test, too.

* test/lisp/net/network-stream-tests.el (make-tls-server): Use
gnutls-serv instead of openssh.

* test/lisp/net/network-stream-tests.el (connect-to-tls): Skip
TLS tests if we don't have openssl and GnuTLS.

* test/lisp/net/network-stream-tests.el (connect-to-tls): Add
a TLS connection test.

* test/lisp/net/network-stream-tests.el (echo-server-nowait):
New test.

* test/lisp/net/network-stream-tests.el: New suite of network tests.

* lisp/url/url-gw.el (url-open-stream): Use non-blocking DNS.

* src/process.c (syms_of_process): Add a `dns' subfeature for
make-network-process.

* doc/lispref/processes.texi (Network Processes): Mention the
dns value of :nowait.

* src/process.c (Fmake_network_process): Only do async DNS if
:nowait is `dns'.

* src/process.c (check_for_dns): Disregard processes that have
already been killed.

* doc/lispref/processes.texi (Network Processes): Clarify the
meaning of :tls-parameters.

* lisp/net/gnutls.el (open-gnutls-stream): Clarify :nowait.

* lisp/net/gnutls.el (gnutls-boot-parameters): Factor out into
own function.
(gnutls-negotiate): Use it.
(open-gnutls-stream): Ditto.

* src/eval.c (vformat_string): Refactor out the printing bits
from verror.
(verror): Use it.

* src/gnutls.c (boot_error): Mark failed processes with the
real error message.

* src/lisp.h: Declare vformat_string.

* process.c (check_for_dns): Type fix reported by YAMAMOTO
Mitsuharu.

* process.c (send_process): Fix test for boot parameters noted
by Andy Moreton.

* process.c (connect_network_socket): Return the correct
server port number.

* configure.ac: Make the test for getaddrinfo_a work.

* process.c (connect_network_socket): Mark failed processes
with a better error message.
(check_for_dns): Ditto.

* src/process.c (connect_network_socket): If we have the TLS
parameters, then boot the socket.

* doc/lispref/processes.texi (Network Processes): Mention
:tls-parameters.

* src/process.c (Fmake_network_process): Document the
:tls-parameters parameter.

* lisp/net/gnutls.el (open-gnutls-stream): Pass the TLS
keywords in directly so that they can be used when doing
synchronous DNS on non-synchronous connections.

* lisp/net/network-stream.el (open-network-stream): Allow
passing in the TLS parameters directly.

* src/process.c (conv_numerical_to_lisp): New function to convert
numerical addresses to Lisp.
(Fmake_network_process): Rework the non-HAVE_ADDRINFO code
paths so that they work again.
(syms_of_process): Build fix for non-glibc systems.