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 95d9766be8b08b7ca52c24d4ed3313e147edb159)

1 files changed, 1 insertions, 373 deletions

diff --git a/source4/lib/util_sock.c b/source4/lib/util_sock.c
index 7fe42f7ffc..1859aef4d7 100644
--- a/source4/lib/util_sock.c
+++ b/source4/lib/util_sock.c
@@ -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;
-}