1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-22 13:34:15 +03:00
samba-mirror/lib/util/util_net.c
Volker Lendecke fe8895c83c lib: Use talloc_asprintf_addbuf() in print_socket_options()
With the proper NULL checks we don't need the stackframe,
use a passed in context instead.

Signed-off-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>
2022-12-14 04:32:34 +00:00

1139 lines
24 KiB
C

/*
Unix SMB/CIFS implementation.
Samba utility functions
Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
Copyright (C) Andrew Tridgell 1992-1998
Copyright (C) Jeremy Allison 1992-2007
Copyright (C) Simo Sorce 2001
Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2003.
Copyright (C) James J Myers 2003
Copyright (C) Tim Potter 2000-2001
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "system/network.h"
#include "system/locale.h"
#include "system/filesys.h"
#include "lib/util/util_net.h"
#undef strcasecmp
#undef strncasecmp
/*******************************************************************
Set an address to INADDR_ANY.
******************************************************************/
void zero_sockaddr(struct sockaddr_storage *pss)
{
/* Ensure we're at least a valid sockaddr-storage. */
*pss = (struct sockaddr_storage) { .ss_family = AF_INET };
}
static char *normalize_ipv6_literal(const char *str, char *buf, size_t *_len)
{
#define IPv6_LITERAL_NET ".ipv6-literal.net"
const size_t llen = sizeof(IPv6_LITERAL_NET) - 1;
size_t len = *_len;
int cmp;
size_t i;
size_t idx_chars = 0;
size_t cnt_delimiter = 0;
size_t cnt_chars = 0;
if (len <= llen) {
return NULL;
}
/* ignore a trailing '.' */
if (str[len - 1] == '.') {
len -= 1;
}
len -= llen;
if (len >= INET6_ADDRSTRLEN) {
return NULL;
}
if (len < 2) {
return NULL;
}
cmp = strncasecmp(&str[len], IPv6_LITERAL_NET, llen);
if (cmp != 0) {
return NULL;
}
for (i = 0; i < len; i++) {
if (idx_chars != 0) {
break;
}
switch (str[i]) {
case '-':
buf[i] = ':';
cnt_chars = 0;
cnt_delimiter += 1;
break;
case 's':
buf[i] = SCOPE_DELIMITER;
idx_chars += 1;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'a':
case 'A':
case 'b':
case 'B':
case 'c':
case 'C':
case 'd':
case 'D':
case 'e':
case 'E':
case 'f':
case 'F':
buf[i] = str[i];
cnt_chars += 1;
break;
default:
return NULL;
}
if (cnt_chars > 4) {
return NULL;
}
if (cnt_delimiter > 7) {
return NULL;
}
}
if (cnt_delimiter < 2) {
return NULL;
}
for (; idx_chars != 0 && i < len; i++) {
switch (str[i]) {
case SCOPE_DELIMITER:
case ':':
return NULL;
default:
buf[i] = str[i];
idx_chars += 1;
break;
}
}
if (idx_chars == 1) {
return NULL;
}
buf[i] = '\0';
*_len = len;
return buf;
}
/**
* Wrap getaddrinfo...
*/
bool interpret_string_addr_internal(struct addrinfo **ppres,
const char *str, int flags)
{
int ret;
struct addrinfo hints;
#if defined(HAVE_IPV6)
char addr[INET6_ADDRSTRLEN*2] = { 0, };
unsigned int scope_id = 0;
size_t len = strlen(str);
#endif
ZERO_STRUCT(hints);
/* By default make sure it supports TCP. */
hints.ai_socktype = SOCK_STREAM;
/* always try as a numeric host first. This prevents unnecessary name
* lookups, and also ensures we accept IPv6 addresses */
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
#if defined(HAVE_IPV6)
if (len < sizeof(addr)) {
char *p = NULL;
p = normalize_ipv6_literal(str, addr, &len);
if (p != NULL) {
hints.ai_family = AF_INET6;
str = p;
}
}
if (strchr_m(str, ':')) {
char *p = strchr_m(str, SCOPE_DELIMITER);
/*
* Cope with link-local.
* This is IP:v6:addr%ifname.
*/
if (p && (p > str) && ((scope_id = if_nametoindex(p+1)) != 0)) {
/* Length of string we want to copy.
This is IP:v6:addr (removing the %ifname).
*/
len = PTR_DIFF(p,str);
if (len+1 > sizeof(addr)) {
/* string+nul too long for array. */
return false;
}
if (str != addr) {
memcpy(addr, str, len);
}
addr[len] = '\0';
str = addr;
}
}
#endif
ret = getaddrinfo(str, NULL, &hints, ppres);
if (ret == 0) {
#if defined(HAVE_IPV6)
struct sockaddr_in6 *ps6 = NULL;
if (scope_id == 0) {
return true;
}
if (ppres == NULL) {
return true;
}
if ((*ppres) == NULL) {
return true;
}
if ((*ppres)->ai_addr->sa_family != AF_INET6) {
return true;
}
ps6 = (struct sockaddr_in6 *)(*ppres)->ai_addr;
if (IN6_IS_ADDR_LINKLOCAL(&ps6->sin6_addr) &&
ps6->sin6_scope_id == 0) {
ps6->sin6_scope_id = scope_id;
}
#endif
return true;
}
hints.ai_flags = flags;
/* Linux man page on getaddrinfo() says port will be
uninitialized when service string is NULL */
ret = getaddrinfo(str, NULL,
&hints,
ppres);
if (ret) {
DEBUG(3, ("interpret_string_addr_internal: "
"getaddrinfo failed for name %s (flags %d) [%s]\n",
str, flags, gai_strerror(ret)));
return false;
}
return true;
}
/*******************************************************************
Map a text hostname or IP address (IPv4 or IPv6) into a
struct sockaddr_storage. Takes a flag which allows it to
prefer an IPv4 address (needed for DC's).
******************************************************************/
static bool interpret_string_addr_pref(struct sockaddr_storage *pss,
const char *str,
int flags,
bool prefer_ipv4)
{
struct addrinfo *res = NULL;
int int_flags;
zero_sockaddr(pss);
if (flags & AI_NUMERICHOST) {
int_flags = flags;
} else {
int_flags = flags|AI_ADDRCONFIG;
}
if (!interpret_string_addr_internal(&res, str, int_flags)) {
return false;
}
if (!res) {
return false;
}
if (prefer_ipv4) {
struct addrinfo *p;
for (p = res; p; p = p->ai_next) {
if (p->ai_family == AF_INET) {
memcpy(pss, p->ai_addr, p->ai_addrlen);
break;
}
}
if (p == NULL) {
/* Copy the first sockaddr. */
memcpy(pss, res->ai_addr, res->ai_addrlen);
}
} else {
/* Copy the first sockaddr. */
memcpy(pss, res->ai_addr, res->ai_addrlen);
}
freeaddrinfo(res);
return true;
}
/*******************************************************************
Map a text hostname or IP address (IPv4 or IPv6) into a
struct sockaddr_storage. Address agnostic version.
******************************************************************/
bool interpret_string_addr(struct sockaddr_storage *pss,
const char *str,
int flags)
{
return interpret_string_addr_pref(pss,
str,
flags,
false);
}
/*******************************************************************
Map a text hostname or IP address (IPv4 or IPv6) into a
struct sockaddr_storage. Version that prefers IPv4.
******************************************************************/
bool interpret_string_addr_prefer_ipv4(struct sockaddr_storage *pss,
const char *str,
int flags)
{
return interpret_string_addr_pref(pss,
str,
flags,
true);
}
/**
* Interpret an internet address or name into an IP address in 4 byte form.
* RETURNS IN NETWORK BYTE ORDER (big endian).
*/
uint32_t interpret_addr(const char *str)
{
uint32_t ret;
/* If it's in the form of an IP address then
* get the lib to interpret it */
if (is_ipaddress_v4(str)) {
struct in_addr dest;
if (inet_pton(AF_INET, str, &dest) <= 0) {
/* Error - this shouldn't happen ! */
DEBUG(0,("interpret_addr: inet_pton failed "
"host %s\n",
str));
return 0;
}
ret = dest.s_addr; /* NETWORK BYTE ORDER ! */
} else {
/* Otherwise assume it's a network name of some sort and use
getaddrinfo. */
struct addrinfo *res = NULL;
struct addrinfo *res_list = NULL;
if (!interpret_string_addr_internal(&res_list,
str,
AI_ADDRCONFIG)) {
DEBUG(3,("interpret_addr: Unknown host. %s\n",str));
return 0;
}
/* Find the first IPv4 address. */
for (res = res_list; res; res = res->ai_next) {
if (res->ai_family != AF_INET) {
continue;
}
if (res->ai_addr == NULL) {
continue;
}
break;
}
if(res == NULL) {
DEBUG(3,("interpret_addr: host address is "
"invalid for host %s\n",str));
if (res_list) {
freeaddrinfo(res_list);
}
return 0;
}
memcpy((char *)&ret,
&((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr,
sizeof(ret));
if (res_list) {
freeaddrinfo(res_list);
}
}
/* This is so bogus - all callers need fixing... JRA. */
if (ret == (uint32_t)-1) {
return 0;
}
return ret;
}
/**
A convenient addition to interpret_addr().
**/
_PUBLIC_ struct in_addr interpret_addr2(const char *str)
{
struct in_addr ret;
uint32_t a = interpret_addr(str);
ret.s_addr = a;
return ret;
}
/**
Check if an IP is the 0.0.0.0.
**/
_PUBLIC_ bool is_zero_ip_v4(struct in_addr ip)
{
return ip.s_addr == 0;
}
/**
Are two IPs on the same subnet?
**/
_PUBLIC_ bool same_net_v4(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
{
uint32_t net1,net2,nmask;
nmask = ntohl(mask.s_addr);
net1 = ntohl(ip1.s_addr);
net2 = ntohl(ip2.s_addr);
return((net1 & nmask) == (net2 & nmask));
}
/**
* Return true if a string could be an IPv4 address.
*/
bool is_ipaddress_v4(const char *str)
{
int ret = -1;
struct in_addr dest;
ret = inet_pton(AF_INET, str, &dest);
if (ret > 0) {
return true;
}
return false;
}
bool is_ipv6_literal(const char *str)
{
#if defined(HAVE_IPV6)
char buf[INET6_ADDRSTRLEN*2] = { 0, };
size_t len = strlen(str);
char *p = NULL;
if (len >= sizeof(buf)) {
return false;
}
p = normalize_ipv6_literal(str, buf, &len);
if (p == NULL) {
return false;
}
return true;
#else
return false;
#endif
}
/**
* Return true if a string could be a IPv6 address.
*/
bool is_ipaddress_v6(const char *str)
{
#if defined(HAVE_IPV6)
int ret = -1;
char *p = NULL;
char buf[INET6_ADDRSTRLEN] = { 0, };
size_t len;
const char *addr = str;
const char *idxs = NULL;
unsigned int idx = 0;
struct in6_addr ip6;
p = strchr_m(str, ':');
if (p == NULL) {
return is_ipv6_literal(str);
}
p = strchr_m(str, SCOPE_DELIMITER);
if (p && (p > str)) {
len = PTR_DIFF(p, str);
idxs = p + 1;
} else {
len = strlen(str);
}
if (len >= sizeof(buf)) {
return false;
}
if (idxs != NULL) {
strncpy(buf, str, len);
addr = buf;
}
/*
* Cope with link-local.
* This is IP:v6:addr%ifidx.
*/
if (idxs != NULL) {
char c;
ret = sscanf(idxs, "%5u%c", &idx, &c);
if (ret != 1) {
idx = 0;
}
if (idx > 0 && idx < UINT16_MAX) {
/* a valid index */
idxs = NULL;
}
}
/*
* Cope with link-local.
* This is IP:v6:addr%ifname.
*/
if (idxs != NULL) {
idx = if_nametoindex(idxs);
if (idx > 0) {
/* a valid index */
idxs = NULL;
}
}
if (idxs != NULL) {
return false;
}
ret = inet_pton(AF_INET6, addr, &ip6);
if (ret <= 0) {
return false;
}
return true;
#else
return false;
#endif
}
/**
* Return true if a string could be an IPv4 or IPv6 address.
*/
bool is_ipaddress(const char *str)
{
return is_ipaddress_v4(str) || is_ipaddress_v6(str);
}
/**
* Is a sockaddr a broadcast address ?
*/
bool is_broadcast_addr(const struct sockaddr *pss)
{
#if defined(HAVE_IPV6)
if (pss->sa_family == AF_INET6) {
const struct in6_addr *sin6 =
&((const struct sockaddr_in6 *)pss)->sin6_addr;
return IN6_IS_ADDR_MULTICAST(sin6);
}
#endif
if (pss->sa_family == AF_INET) {
uint32_t addr =
ntohl(((const struct sockaddr_in *)pss)->sin_addr.s_addr);
return addr == INADDR_BROADCAST;
}
return false;
}
/**
* Check if an IPv7 is 127.0.0.1
*/
bool is_loopback_ip_v4(struct in_addr ip)
{
struct in_addr a;
a.s_addr = htonl(INADDR_LOOPBACK);
return(ip.s_addr == a.s_addr);
}
/**
* Check if a struct sockaddr is the loopback address.
*/
bool is_loopback_addr(const struct sockaddr *pss)
{
#if defined(HAVE_IPV6)
if (pss->sa_family == AF_INET6) {
const struct in6_addr *pin6 =
&((const struct sockaddr_in6 *)pss)->sin6_addr;
return IN6_IS_ADDR_LOOPBACK(pin6);
}
#endif
if (pss->sa_family == AF_INET) {
const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
return is_loopback_ip_v4(*pin);
}
return false;
}
/**
* Check if a struct sockaddr has an unspecified address.
*/
bool is_zero_addr(const struct sockaddr_storage *pss)
{
#if defined(HAVE_IPV6)
if (pss->ss_family == AF_INET6) {
const struct in6_addr *pin6 =
&((const struct sockaddr_in6 *)pss)->sin6_addr;
return IN6_IS_ADDR_UNSPECIFIED(pin6);
}
#endif
if (pss->ss_family == AF_INET) {
const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
return is_zero_ip_v4(*pin);
}
return false;
}
/**
* Set an IP to 0.0.0.0.
*/
void zero_ip_v4(struct in_addr *ip)
{
ZERO_STRUCTP(ip);
}
bool is_linklocal_addr(const struct sockaddr_storage *pss)
{
#ifdef HAVE_IPV6
if (pss->ss_family == AF_INET6) {
const struct in6_addr *pin6 =
&((const struct sockaddr_in6 *)pss)->sin6_addr;
return IN6_IS_ADDR_LINKLOCAL(pin6);
}
#endif
if (pss->ss_family == AF_INET) {
const struct in_addr *pin =
&((const struct sockaddr_in *)pss)->sin_addr;
struct in_addr ll_addr;
struct in_addr mask_addr;
/* 169.254.0.0/16, is link local, see RFC 3927 */
ll_addr.s_addr = 0xa9fe0000;
mask_addr.s_addr = 0xffff0000;
return same_net_v4(*pin, ll_addr, mask_addr);
}
return false;
}
/**
* Convert an IPv4 struct in_addr to a struct sockaddr_storage.
*/
void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
struct in_addr ip)
{
struct sockaddr_in *sa = (struct sockaddr_in *)ss;
ZERO_STRUCTP(ss);
sa->sin_family = AF_INET;
sa->sin_addr = ip;
}
#if defined(HAVE_IPV6)
/**
* Convert an IPv6 struct in_addr to a struct sockaddr_storage.
*/
void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
struct in6_addr ip)
{
struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss;
memset(ss, '\0', sizeof(*ss));
sa->sin6_family = AF_INET6;
sa->sin6_addr = ip;
}
#endif
/**
* Are two IPs on the same subnet?
*/
bool same_net(const struct sockaddr *ip1,
const struct sockaddr *ip2,
const struct sockaddr *mask)
{
if (ip1->sa_family != ip2->sa_family) {
/* Never on the same net. */
return false;
}
#if defined(HAVE_IPV6)
if (ip1->sa_family == AF_INET6) {
struct sockaddr_in6 ip1_6 = *(const struct sockaddr_in6 *)ip1;
struct sockaddr_in6 ip2_6 = *(const struct sockaddr_in6 *)ip2;
struct sockaddr_in6 mask_6 = *(const struct sockaddr_in6 *)mask;
char *p1 = (char *)&ip1_6.sin6_addr;
char *p2 = (char *)&ip2_6.sin6_addr;
char *m = (char *)&mask_6.sin6_addr;
size_t i;
for (i = 0; i < sizeof(struct in6_addr); i++) {
*p1++ &= *m;
*p2++ &= *m;
m++;
}
return (memcmp(&ip1_6.sin6_addr,
&ip2_6.sin6_addr,
sizeof(struct in6_addr)) == 0);
}
#endif
if (ip1->sa_family == AF_INET) {
return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr,
((const struct sockaddr_in *)ip2)->sin_addr,
((const struct sockaddr_in *)mask)->sin_addr);
}
return false;
}
/**
* Are two sockaddr 's the same family and address ? Ignore port etc.
*/
bool sockaddr_equal(const struct sockaddr *ip1,
const struct sockaddr *ip2)
{
if (ip1->sa_family != ip2->sa_family) {
/* Never the same. */
return false;
}
#if defined(HAVE_IPV6)
if (ip1->sa_family == AF_INET6) {
return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr,
&((const struct sockaddr_in6 *)ip2)->sin6_addr,
sizeof(struct in6_addr)) == 0);
}
#endif
if (ip1->sa_family == AF_INET) {
return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr,
&((const struct sockaddr_in *)ip2)->sin_addr,
sizeof(struct in_addr)) == 0);
}
return false;
}
/**
* Is an IP address the INADDR_ANY or in6addr_any value ?
*/
bool is_address_any(const struct sockaddr *psa)
{
#if defined(HAVE_IPV6)
if (psa->sa_family == AF_INET6) {
const struct sockaddr_in6 *si6 = (const struct sockaddr_in6 *)psa;
if (memcmp(&in6addr_any,
&si6->sin6_addr,
sizeof(in6addr_any)) == 0) {
return true;
}
return false;
}
#endif
if (psa->sa_family == AF_INET) {
const struct sockaddr_in *si = (const struct sockaddr_in *)psa;
if (si->sin_addr.s_addr == INADDR_ANY) {
return true;
}
return false;
}
return false;
}
void set_sockaddr_port(struct sockaddr *psa, uint16_t port)
{
#if defined(HAVE_IPV6)
if (psa->sa_family == AF_INET6) {
((struct sockaddr_in6 *)psa)->sin6_port = htons(port);
}
#endif
if (psa->sa_family == AF_INET) {
((struct sockaddr_in *)psa)->sin_port = htons(port);
}
}
/****************************************************************************
Get a port number in host byte order from a sockaddr_storage.
****************************************************************************/
uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
{
uint16_t port = 0;
if (pss->ss_family != AF_INET) {
#if defined(HAVE_IPV6)
/* IPv6 */
const struct sockaddr_in6 *sa6 =
(const struct sockaddr_in6 *)pss;
port = ntohs(sa6->sin6_port);
#endif
} else {
const struct sockaddr_in *sa =
(const struct sockaddr_in *)pss;
port = ntohs(sa->sin_port);
}
return port;
}
/****************************************************************************
Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
****************************************************************************/
char *print_sockaddr_len(char *dest,
size_t destlen,
const struct sockaddr *psa,
socklen_t psalen)
{
if (destlen > 0) {
dest[0] = '\0';
}
(void)sys_getnameinfo(psa,
psalen,
dest, destlen,
NULL, 0,
NI_NUMERICHOST);
return dest;
}
/****************************************************************************
Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
****************************************************************************/
char *print_sockaddr(char *dest,
size_t destlen,
const struct sockaddr_storage *psa)
{
return print_sockaddr_len(dest, destlen, (const struct sockaddr *)psa,
sizeof(struct sockaddr_storage));
}
/****************************************************************************
Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
****************************************************************************/
char *print_canonical_sockaddr(TALLOC_CTX *ctx,
const struct sockaddr_storage *pss)
{
char addr[INET6_ADDRSTRLEN];
char *dest = NULL;
int ret;
/* Linux getnameinfo() man pages says port is uninitialized if
service name is NULL. */
ret = sys_getnameinfo((const struct sockaddr *)pss,
sizeof(struct sockaddr_storage),
addr, sizeof(addr),
NULL, 0,
NI_NUMERICHOST);
if (ret != 0) {
return NULL;
}
if (pss->ss_family != AF_INET) {
#if defined(HAVE_IPV6)
dest = talloc_asprintf(ctx, "[%s]", addr);
#else
return NULL;
#endif
} else {
dest = talloc_asprintf(ctx, "%s", addr);
}
return dest;
}
enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
typedef struct smb_socket_option {
const char *name;
int level;
int option;
int value;
int opttype;
} smb_socket_option;
static const smb_socket_option socket_options[] = {
{"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
{"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
{"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
#ifdef TCP_NODELAY
{"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
#endif
#ifdef TCP_KEEPCNT
{"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
#endif
#ifdef TCP_KEEPIDLE
{"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
#endif
#ifdef TCP_KEEPINTVL
{"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
#endif
#ifdef IPTOS_LOWDELAY
{"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
#endif
#ifdef IPTOS_THROUGHPUT
{"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
#endif
#ifdef SO_REUSEPORT
{"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
#endif
#ifdef SO_SNDBUF
{"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
#endif
#ifdef SO_RCVBUF
{"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
#endif
#ifdef SO_SNDLOWAT
{"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
#endif
#ifdef SO_RCVLOWAT
{"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
#endif
#ifdef SO_SNDTIMEO
{"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
#endif
#ifdef SO_RCVTIMEO
{"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
#endif
#ifdef TCP_FASTACK
{"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
#endif
#ifdef TCP_QUICKACK
{"TCP_QUICKACK", IPPROTO_TCP, TCP_QUICKACK, 0, OPT_BOOL},
#endif
#ifdef TCP_NODELAYACK
{"TCP_NODELAYACK", IPPROTO_TCP, TCP_NODELAYACK, 0, OPT_BOOL},
#endif
#ifdef TCP_KEEPALIVE_THRESHOLD
{"TCP_KEEPALIVE_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, 0, OPT_INT},
#endif
#ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
{"TCP_KEEPALIVE_ABORT_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, 0, OPT_INT},
#endif
#ifdef TCP_DEFER_ACCEPT
{"TCP_DEFER_ACCEPT", IPPROTO_TCP, TCP_DEFER_ACCEPT, 0, OPT_INT},
#endif
#ifdef TCP_USER_TIMEOUT
{"TCP_USER_TIMEOUT", IPPROTO_TCP, TCP_USER_TIMEOUT, 0, OPT_INT},
#endif
{NULL,0,0,0,0}};
/****************************************************************************
Print socket options.
****************************************************************************/
static void print_socket_options(TALLOC_CTX *ctx, int s)
{
const smb_socket_option *p = &socket_options[0];
char *str = NULL;
if (DEBUGLEVEL < 5) {
return;
}
str = talloc_strdup(ctx, "");
if (str == NULL) {
DBG_WARNING("talloc failed\n");
goto done;
}
for (; p->name != NULL; p++) {
int ret, val;
socklen_t vlen = sizeof(val);
ret = getsockopt(s, p->level, p->option, (void *)&val, &vlen);
if (ret == -1) {
DBG_INFO("Could not test socket option %s: %s.\n",
p->name, strerror(errno));
continue;
}
talloc_asprintf_addbuf(
&str,
"%s%s=%d",
str[0] != '\0' ? ", " : "",
p->name,
val);
}
DEBUG(5, ("socket options: %s\n", str));
done:
TALLOC_FREE(str);
}
/****************************************************************************
Set user socket options.
****************************************************************************/
void set_socket_options(int fd, const char *options)
{
TALLOC_CTX *ctx = talloc_new(NULL);
char *tok;
while (next_token_talloc(ctx, &options, &tok," \t,")) {
int ret=0,i;
int value = 1;
char *p;
bool got_value = false;
if ((p = strchr_m(tok,'='))) {
*p = 0;
value = atoi(p+1);
got_value = true;
}
for (i=0;socket_options[i].name;i++)
if (strequal(socket_options[i].name,tok))
break;
if (!socket_options[i].name) {
DEBUG(0,("Unknown socket option %s\n",tok));
continue;
}
switch (socket_options[i].opttype) {
case OPT_BOOL:
case OPT_INT:
ret = setsockopt(fd,socket_options[i].level,
socket_options[i].option,
(char *)&value,sizeof(int));
break;
case OPT_ON:
if (got_value)
DEBUG(0,("syntax error - %s "
"does not take a value\n",tok));
{
int on = socket_options[i].value;
ret = setsockopt(fd,socket_options[i].level,
socket_options[i].option,
(char *)&on,sizeof(int));
}
break;
}
if (ret != 0) {
/* be aware that some systems like Solaris return
* EINVAL to a setsockopt() call when the client
* sent a RST previously - no need to worry */
DEBUG(2,("Failed to set socket option %s (Error %s)\n",
tok, strerror(errno) ));
}
}
print_socket_options(ctx, fd);
TALLOC_FREE(ctx);
}
/*
* Utility function that copes only with AF_INET and AF_INET6
* as that's all we're going to get out of DNS / NetBIOS / WINS
* name resolution functions.
*/
bool sockaddr_storage_to_samba_sockaddr(
struct samba_sockaddr *sa, const struct sockaddr_storage *ss)
{
sa->u.ss = *ss;
switch (ss->ss_family) {
case AF_INET:
sa->sa_socklen = sizeof(struct sockaddr_in);
break;
#ifdef HAVE_IPV6
case AF_INET6:
sa->sa_socklen = sizeof(struct sockaddr_in6);
break;
#endif
default:
return false;
}
return true;
}
bool samba_sockaddr_set_port(struct samba_sockaddr *sa, uint16_t port)
{
if (sa->u.sa.sa_family == AF_INET) {
sa->u.in.sin_port = htons(port);
return true;
}
#ifdef HAVE_IPV6
if (sa->u.sa.sa_family == AF_INET6) {
sa->u.in6.sin6_port = htons(port);
return true;
}
#endif
return false;
}
bool samba_sockaddr_get_port(const struct samba_sockaddr *sa, uint16_t *port)
{
if (sa->u.sa.sa_family == AF_INET) {
*port = ntohs(sa->u.in.sin_port);
return true;
}
#ifdef HAVE_IPV6
if (sa->u.sa.sa_family == AF_INET6) {
*port = ntohs(sa->u.in6.sin6_port);
return true;
}
#endif
return false;
}