GitLab

* 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.

* process.c (Fmake_network_process): Build fix for systems
without local sockets.

* process.h: All Lisp_Object slots have to come first,
otherwise they won't be protected from gc.

* gnutls.c (boot_error): New function to either signal an
error or return an error code.
(Fgnutls_boot): Don't signal errors when running asynchronously.

* process.h (pset_status): Move here from process.c to be
able to use from gnutls.c.

* process.c (connect_network_socket): Do the TLS boot here
when running asynchronously.
(wait_reading_process_output): Rework the dns_processes
handling for more safety.

* lisp/net/gnutls.el (gnutls-async-sentinel): Remove.

* lisp/net/gnutls.el (open-gnutls-stream): Compute the
gnutls-boot parameters and pass them to the process object.
(gnutls-negotiate): New parameter :return-keywords that won't
connect to anything, just compute the keywords.

* lisp/url/url-http.el (url-http): Revert async TLS sentinel
hack, which is no longer necessary.

* src/gnutls.c (Fgnutls_asynchronous_parameters): Rename from
gnutls-mark-process.

* src/process.c (connect_network_socket): If we're connecting to
an asynchronous TLS socket, complete the GnuTLS boot sequence here.

* src/process.h: New parameter gnutls_async_parameters.

* process.c (check_for_dns): Protect against double free
issues.

* doc/misc/emacs-gnutls.texi (Help For Developers): Mention
the nowait parameter.

* lisp/net/gnutls.el (open-gnutls-stream): Allow asynchronous
connections with the new nowait parameter.

* lisp/net/network-stream.el (network-stream-open-tls): Pass
on :nowait to open-gnutls-stream.

* lisp/url/url-http.el (url-http): Don't overwrite the
sentinel created by open-gnutls-stream.

* src/gnutls.c (Fgnutls_mark_process): New function.

* src/process.c (send_process): Don't write to GnuTLS sockets that
haven't been initialised yed.

* src/process.h: New slot gnutls_wait_p.

* process.c (wait_reading_process_output): Use a list of
process objects instead of looping through an array to check
for name resolution.  This should be much faster.

* src/process.c (check_for_dns): Free even more allocated async stuff.

* process.c (Fmake_network_process): Make stuff work again on
systems with getaddrinfo_a.

* process.c (connect_network_socket): Save the correct contact
info for servers.