tree bac2f081ae4c30a1bff69d2ef3ae3d407ac399f8
parent 273e27905c38400d8ef1af4f5aecff0af654063b
author Javier Tia <javier.tia@linaro.org> 1731227319 +0200
committer Tom Rini <trini@konsulko.com> 1731460192 -0600

net: lwip: Add Support Server Name Indication support

SNI, or Server Name Indication, is an addition to the TLS encryption
protocol that enables a client device to specify the domain name it is
trying to reach in the first step of the TLS handshake, preventing
common name mismatch errors and not reaching to HTTPS server that
enforce this condition. Since most of the websites require it nowadays
add support for it.

It's worth noting that this is already sent to lwIP [0]

[0] https://github.com/lwip-tcpip/lwip/pull/47

Signed-off-by: Javier Tia <javier.tia@linaro.org>
Reviewed-by: Jerome Forissier <jerome.forissier@linaro.org>
Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
