mirror of
https://github.com/samba-team/samba.git
synced 2025-01-13 13:18:06 +03:00
r5106: removed a bunch of unused socket functions. We still need
open_socket_out() as its used by the ldap client code (uggh)
(This used to be commit 95d9766be8)
This commit is contained in:
Andrew Tridgell
Gerald (Jerry) Carter
parent
791426317c
commit
003fbe7f64
@ -23,16 +23,6 @@
|
||||
#include "system/network.h"
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
Determine if a file descriptor is in fact a socket.
|
||||
****************************************************************************/
|
||||
BOOL is_a_socket(int fd)
|
||||
{
|
||||
int v,l;
|
||||
l = sizeof(int);
|
||||
return getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0;
|
||||
}
|
||||
|
||||
enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
|
||||
|
||||
typedef struct smb_socket_option {
|
||||
@ -79,28 +69,10 @@ static const smb_socket_option socket_options[] = {
|
||||
#endif
|
||||
{NULL,0,0,0,0}};
|
||||
|
||||
/****************************************************************************
|
||||
Print socket options.
|
||||
****************************************************************************/
|
||||
|
||||
static void print_socket_options(int s)
|
||||
{
|
||||
int value, vlen = 4;
|
||||
const smb_socket_option *p = &socket_options[0];
|
||||
|
||||
for (; p->name != NULL; p++) {
|
||||
if (getsockopt(s, p->level, p->option, (void *)&value, &vlen) == -1) {
|
||||
DEBUG(5,("Could not test socket option %s.\n", p->name));
|
||||
} else {
|
||||
DEBUG(5,("socket option %s = %d\n",p->name,value));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
Set user socket options.
|
||||
****************************************************************************/
|
||||
|
||||
void set_socket_options(int fd, const char *options)
|
||||
{
|
||||
fstring tok;
|
||||
@ -148,43 +120,12 @@ void set_socket_options(int fd, const char *options)
|
||||
if (ret != 0)
|
||||
DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
|
||||
}
|
||||
|
||||
print_socket_options(fd);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
Read from a socket.
|
||||
****************************************************************************/
|
||||
|
||||
ssize_t read_udp_socket(int fd, char *buf, size_t len,
|
||||
struct ipv4_addr *from_addr, int *from_port)
|
||||
{
|
||||
ssize_t ret;
|
||||
struct sockaddr_in sock;
|
||||
socklen_t socklen = sizeof(sock);
|
||||
|
||||
ret = recvfrom(fd,buf,len, 0, (struct sockaddr *)&sock, &socklen);
|
||||
if (ret <= 0) {
|
||||
DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (from_addr) {
|
||||
from_addr->addr = sock.sin_addr.s_addr;
|
||||
}
|
||||
if (from_port) {
|
||||
*from_port = ntohs(sock.sin_port);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
Check the timeout.
|
||||
****************************************************************************/
|
||||
|
||||
static BOOL timeout_until(struct timeval *timeout,
|
||||
const struct timeval *endtime)
|
||||
{
|
||||
@ -206,7 +147,6 @@ static BOOL timeout_until(struct timeval *timeout,
|
||||
/****************************************************************************
|
||||
Read data from the client, reading exactly N bytes, with timeout.
|
||||
****************************************************************************/
|
||||
|
||||
ssize_t read_data_until(int fd,char *buffer,size_t N,
|
||||
const struct timeval *endtime)
|
||||
{
|
||||
@ -247,10 +187,10 @@ ssize_t read_data_until(int fd,char *buffer,size_t N,
|
||||
return (ssize_t)total;
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
Write data to a fd with timeout.
|
||||
****************************************************************************/
|
||||
|
||||
ssize_t write_data_until(int fd,char *buffer,size_t N,
|
||||
const struct timeval *endtime)
|
||||
{
|
||||
@ -290,50 +230,6 @@ ssize_t write_data_until(int fd,char *buffer,size_t N,
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
Open a socket of the specified type, port, and address for incoming data.
|
||||
****************************************************************************/
|
||||
int open_socket_in( int type, int port, int dlevel, uint32_t socket_addr, BOOL rebind )
|
||||
{
|
||||
struct sockaddr_in sock;
|
||||
int res;
|
||||
|
||||
memset( (char *)&sock, '\0', sizeof(sock) );
|
||||
|
||||
#ifdef HAVE_SOCK_SIN_LEN
|
||||
sock.sin_len = sizeof(sock);
|
||||
#endif
|
||||
sock.sin_port = htons( port );
|
||||
sock.sin_family = AF_INET;
|
||||
sock.sin_addr.s_addr = socket_addr;
|
||||
|
||||
res = socket( AF_INET, type, 0 );
|
||||
if( res == -1 ) {
|
||||
DEBUG(0,("open_socket_in(): socket() call failed: %s\n", strerror(errno)));
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
|
||||
{
|
||||
int val = rebind ? 1 : 0;
|
||||
setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val));
|
||||
#ifdef SO_REUSEPORT
|
||||
setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val));
|
||||
#endif
|
||||
}
|
||||
|
||||
/* now we've got a socket - we need to bind it */
|
||||
if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
|
||||
DEBUG(0,("bind failed on port %d - %s\n", port, strerror(errno)));
|
||||
close( res );
|
||||
return( -1 );
|
||||
}
|
||||
|
||||
DEBUG( 10, ( "bind succeeded on port %d\n", port ) );
|
||||
|
||||
return( res );
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
create an outgoing socket. timeout is in milliseconds.
|
||||
@ -401,271 +297,3 @@ connect_again:
|
||||
return res;
|
||||
}
|
||||
|
||||
/*
|
||||
open a connected UDP socket to host on port
|
||||
*/
|
||||
int open_udp_socket(const char *host, int port)
|
||||
{
|
||||
int type = SOCK_DGRAM;
|
||||
struct sockaddr_in sock_out;
|
||||
int res;
|
||||
struct ipv4_addr addr;
|
||||
TALLOC_CTX *mem_ctx;
|
||||
|
||||
mem_ctx = talloc_init("open_udp_socket");
|
||||
if (!mem_ctx) {
|
||||
return -1;
|
||||
}
|
||||
addr = interpret_addr2(host);
|
||||
|
||||
res = socket(PF_INET, type, 0);
|
||||
if (res == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
memset((char *)&sock_out,'\0',sizeof(sock_out));
|
||||
putip((char *)&sock_out.sin_addr,(char *)&addr);
|
||||
sock_out.sin_port = htons(port);
|
||||
sock_out.sin_family = PF_INET;
|
||||
|
||||
talloc_free(mem_ctx);
|
||||
|
||||
if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
|
||||
close(res);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************
|
||||
matchname - determine if host name matches IP address. Used to
|
||||
confirm a hostname lookup to prevent spoof attacks
|
||||
******************************************************************/
|
||||
static BOOL matchname(char *remotehost, struct ipv4_addr addr)
|
||||
{
|
||||
struct hostent *hp;
|
||||
int i;
|
||||
|
||||
if ((hp = sys_gethostbyname(remotehost)) == 0) {
|
||||
DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
|
||||
return False;
|
||||
}
|
||||
|
||||
/*
|
||||
* Make sure that gethostbyname() returns the "correct" host name.
|
||||
* Unfortunately, gethostbyname("localhost") sometimes yields
|
||||
* "localhost.domain". Since the latter host name comes from the
|
||||
* local DNS, we just have to trust it (all bets are off if the local
|
||||
* DNS is perverted). We always check the address list, though.
|
||||
*/
|
||||
|
||||
if (strcasecmp(remotehost, hp->h_name)
|
||||
&& strcasecmp(remotehost, "localhost")) {
|
||||
DEBUG(0,("host name/name mismatch: %s != %s\n",
|
||||
remotehost, hp->h_name));
|
||||
return False;
|
||||
}
|
||||
|
||||
/* Look up the host address in the address list we just got. */
|
||||
for (i = 0; hp->h_addr_list[i]; i++) {
|
||||
if (memcmp(hp->h_addr_list[i], (char *) & addr, sizeof(addr)) == 0)
|
||||
return True;
|
||||
}
|
||||
|
||||
/*
|
||||
* The host name does not map to the original host address. Perhaps
|
||||
* someone has compromised a name server. More likely someone botched
|
||||
* it, but that could be dangerous, too.
|
||||
*/
|
||||
|
||||
DEBUG(0,("host name/address mismatch: %s != %s\n",
|
||||
sys_inet_ntoa(addr), hp->h_name));
|
||||
return False;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************
|
||||
return the DNS name of the remote end of a socket
|
||||
******************************************************************/
|
||||
char *get_socket_name(TALLOC_CTX *mem_ctx, int fd, BOOL force_lookup)
|
||||
{
|
||||
char *name_buf;
|
||||
struct hostent *hp;
|
||||
struct ipv4_addr addr;
|
||||
char *p;
|
||||
|
||||
/* reverse lookups can be *very* expensive, and in many
|
||||
situations won't work because many networks don't link dhcp
|
||||
with dns. To avoid the delay we avoid the lookup if
|
||||
possible */
|
||||
if (!lp_hostname_lookups() && (force_lookup == False)) {
|
||||
return get_socket_addr(mem_ctx, fd);
|
||||
}
|
||||
|
||||
p = get_socket_addr(mem_ctx, fd);
|
||||
|
||||
name_buf = talloc_strdup(mem_ctx, "UNKNOWN");
|
||||
if (fd == -1) return name_buf;
|
||||
|
||||
addr = interpret_addr2(p);
|
||||
|
||||
/* Look up the remote host name. */
|
||||
if ((hp = gethostbyaddr((char *)&addr.addr, sizeof(addr.addr), AF_INET)) == 0) {
|
||||
DEBUG(1,("Gethostbyaddr failed for %s\n",p));
|
||||
name_buf = talloc_strdup(mem_ctx, p);
|
||||
} else {
|
||||
name_buf = talloc_strdup(mem_ctx, (char *)hp->h_name);
|
||||
if (!matchname(name_buf, addr)) {
|
||||
DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
|
||||
name_buf = talloc_strdup(mem_ctx, "UNKNOWN");
|
||||
}
|
||||
}
|
||||
|
||||
alpha_strcpy(name_buf, name_buf, "_-.", strlen(name_buf)+1);
|
||||
if (strstr(name_buf,"..")) {
|
||||
name_buf = talloc_strdup(mem_ctx, "UNKNOWN");
|
||||
}
|
||||
|
||||
return name_buf;
|
||||
}
|
||||
|
||||
/*******************************************************************
|
||||
return the IP addr of the remote end of a socket as a string
|
||||
******************************************************************/
|
||||
char *get_socket_addr(TALLOC_CTX *mem_ctx, int fd)
|
||||
{
|
||||
struct sockaddr sa;
|
||||
struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
|
||||
int length = sizeof(sa);
|
||||
|
||||
if (fd == -1 || getpeername(fd, &sa, &length) == -1) {
|
||||
return talloc_strdup(mem_ctx, "0.0.0.0");
|
||||
}
|
||||
|
||||
return talloc_strdup(mem_ctx, (char *)inet_ntoa(sockin->sin_addr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************
|
||||
this is like socketpair but uses tcp. It is used by the Samba
|
||||
regression test code
|
||||
The function guarantees that nobody else can attach to the socket,
|
||||
or if they do that this function fails and the socket gets closed
|
||||
returns 0 on success, -1 on failure
|
||||
the resulting file descriptors are symmetrical
|
||||
******************************************************************/
|
||||
static int socketpair_tcp(int fd[2])
|
||||
{
|
||||
int listener;
|
||||
struct sockaddr_in sock;
|
||||
struct sockaddr_in sock2;
|
||||
socklen_t socklen = sizeof(sock);
|
||||
int connect_done = 0;
|
||||
|
||||
fd[0] = fd[1] = listener = -1;
|
||||
|
||||
memset(&sock, 0, sizeof(sock));
|
||||
|
||||
if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
|
||||
|
||||
memset(&sock2, 0, sizeof(sock2));
|
||||
#ifdef HAVE_SOCK_SIN_LEN
|
||||
sock2.sin_len = sizeof(sock2);
|
||||
#endif
|
||||
sock2.sin_family = PF_INET;
|
||||
|
||||
bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
|
||||
|
||||
if (listen(listener, 1) != 0) goto failed;
|
||||
|
||||
if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
|
||||
|
||||
if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
|
||||
|
||||
set_blocking(fd[1], 0);
|
||||
|
||||
sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
|
||||
|
||||
if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
|
||||
if (errno != EINPROGRESS) goto failed;
|
||||
} else {
|
||||
connect_done = 1;
|
||||
}
|
||||
|
||||
if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
|
||||
|
||||
close(listener);
|
||||
if (connect_done == 0) {
|
||||
if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
|
||||
&& errno != EISCONN) goto failed;
|
||||
}
|
||||
|
||||
set_blocking(fd[1], 1);
|
||||
|
||||
/* all OK! */
|
||||
return 0;
|
||||
|
||||
failed:
|
||||
if (fd[0] != -1) close(fd[0]);
|
||||
if (fd[1] != -1) close(fd[1]);
|
||||
if (listener != -1) close(listener);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************
|
||||
run a program on a local tcp socket, this is used to launch smbd
|
||||
when regression testing
|
||||
the return value is a socket which is attached to a subprocess
|
||||
running "prog". stdin and stdout are attached. stderr is left
|
||||
attached to the original stderr
|
||||
******************************************************************/
|
||||
int sock_exec(const char *prog)
|
||||
{
|
||||
int fd[2];
|
||||
if (socketpair_tcp(fd) != 0) {
|
||||
DEBUG(0,("socketpair_tcp failed (%s)\n", strerror(errno)));
|
||||
return -1;
|
||||
}
|
||||
if (fork() == 0) {
|
||||
close(fd[0]);
|
||||
close(0);
|
||||
close(1);
|
||||
dup(fd[1]);
|
||||
dup(fd[1]);
|
||||
exit(system(prog));
|
||||
}
|
||||
close(fd[1]);
|
||||
return fd[0];
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
determine if a packet is pending for receive on a socket
|
||||
*/
|
||||
BOOL socket_pending(int fd)
|
||||
{
|
||||
fd_set fds;
|
||||
int selrtn;
|
||||
struct timeval timeout;
|
||||
|
||||
FD_ZERO(&fds);
|
||||
FD_SET(fd,&fds);
|
||||
|
||||
/* immediate timeout */
|
||||
timeout.tv_sec = 0;
|
||||
timeout.tv_usec = 0;
|
||||
|
||||
/* yes, this is supposed to be a normal select not a sys_select() */
|
||||
selrtn = select(fd+1,&fds,NULL,NULL,&timeout);
|
||||
|
||||
if (selrtn == 1) {
|
||||
/* the fd is readable */
|
||||
return True;
|
||||
}
|
||||
|
||||
return False;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user