tree fbe984d9925ad3770f295ada37b699bd1148fb7a
parent e42d87f3de4c5310e65f52a60e825a8349bf7d8c
author Willy Tarreau <w@1wt.eu> 1599109749 +0200
committer Willy Tarreau <w@1wt.eu> 1600279993 +0200
encoding latin1

MINOR: listener: create a new struct "settings" in bind_conf

There currently is a large inconsistency in how binding parameters are
split between bind_conf and listeners. It happens that for historical
reasons some parameters are available at the listener level but cannot
be configured per-listener but only for a bind_conf, and thus, need to
be replicated. In addition, some of the bind_conf parameters are in fact
for the listening socket itself while others are for the instanciated
sockets.

A previous attempt at splitting listeners into receivers failed because
the boundary between all these settings is not well defined.

This patch introduces a level of listening socket settings in the
bind_conf, that will be detachable later. Such settings that are solely
for the listening socket are:
  - unix socket permissions (used only during binding)
  - interface (used for binding)
  - network namespace (used for binding)
  - process mask and thread mask (used during startup)

The rest seems to be used only to initialize the resulting sockets, or
to control the accept rate. For now, only the unix params (bind_conf->ux)
were moved there.
