dropbear: dbutil.c comparison

comparison dbutil.c @ 579:8c737cd7c1af

merge of '48fdaa8706d1acda35e9d564adc9a1fbc96c18c8' and '658fd03abd21e0da7c4c89b9fff9dc693c72daae'

author	Matt Johnston <matt@ucc.asn.au>
date	Sat, 27 Feb 2010 11:53:18 +0000
parents	005530560594
children	a98a2138364a

comparison

equal deleted inserted replaced

-:69e98c45db7c
+:8c737cd7c1af
 	TRACE(("leave dropbear_listen: success, %d socks bound", nsock))
 	return nsock;
 }
+/* Connect to a given unix socket. The socket is blocking */
+#ifdef ENABLE_CONNECT_UNIX
+int connect_unix(const char* path) {
+	struct sockaddr_un addr;
+	int fd = -1;
+	memset((void*)&addr, 0x0, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	strlcpy(addr.sun_path, path, sizeof(addr.sun_path));
+	fd = socket(PF_UNIX, SOCK_STREAM, 0);
+	if (fd < 0) {
+		TRACE(("Failed to open unix socket"))
+		return -1;
+	}
+	if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+		TRACE(("Failed to connect to '%s' socket", path))
+		return -1;
+	}
+	return fd;
+}
+#endif
 /* Connect via TCP to a host. Connection will try ipv4 or ipv6, will
 * return immediately if nonblocking is set. On failure, if errstring
 * wasn't null, it will be a newly malloced error message */
 /* TODO: maxfd */
 			err = errno;
 			continue;
 		}
 		if (nonblocking) {
-			if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
+			setnonblocking(sock);
-				close(sock);
-				sock = -1;
-				if (errstring != NULL && *errstring == NULL) {
-					*errstring = m_strdup("Failed non-blocking");
-				}
-				TRACE(("Failed non-blocking: %s", strerror(errno)))
-				continue;
-			}
 		}
 		if (connect(sock, res->ai_addr, res->ai_addrlen) < 0) {
 			if (errno == EINPROGRESS && nonblocking) {
 				TRACE(("Connect in progress"))
 	}
 	execv(usershell, argv);
 }
+void get_socket_address(int fd, char **local_host, char **local_port,
+						char **remote_host, char **remote_port, int host_lookup)
+{
+	struct sockaddr_storage addr;
+	socklen_t addrlen;
+	if (local_host || local_port) {
+		addrlen = sizeof(addr);
+		if (getsockname(fd, (struct sockaddr*)&addr, &addrlen) < 0) {
+			dropbear_exit("Failed socket address: %s", strerror(errno));
+		}
+		getaddrstring(&addr, local_host, local_port, host_lookup);
+	}
+	if (remote_host || remote_port) {
+		addrlen = sizeof(addr);
+		if (getpeername(fd, (struct sockaddr*)&addr, &addrlen) < 0) {
+			dropbear_exit("Failed socket address: %s", strerror(errno));
+		}
+		getaddrstring(&addr, remote_host, remote_port, host_lookup);
+	}
+}
 /* Return a string representation of the socket address passed. The return
 * value is allocated with malloc() */
-unsigned char * getaddrstring(struct sockaddr_storage* addr, int withport) {
+void getaddrstring(struct sockaddr_storage* addr,
+			char **ret_host, char **ret_port,
-	char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
+			int host_lookup) {
-	char *retstring = NULL;
+	char host[NI_MAXHOST+1], serv[NI_MAXSERV+1];
+	unsigned int len;
 	int ret;
-	unsigned int len;
+	int flags = NI_NUMERICSERV | NI_NUMERICHOST;
+#ifndef DO_HOST_LOOKUP
+	host_lookup = 0;
+#endif
+	if (host_lookup) {
+		flags = NI_NUMERICSERV;
+	}
 	len = sizeof(struct sockaddr_storage);
 	/* Some platforms such as Solaris 8 require that len is the length
 	 * of the specific structure. Some older linux systems (glibc 2.1.3
 	 * such as debian potato) have sockaddr_storage.__ss_family instead
 		len = sizeof(struct sockaddr_in6);
 	}
 #endif
 #endif
-	ret = getnameinfo((struct sockaddr*)addr, len, hbuf, sizeof(hbuf),
+	ret = getnameinfo((struct sockaddr*)addr, len, host, sizeof(host)-1,
-			sbuf, sizeof(sbuf), NI_NUMERICSERV | NI_NUMERICHOST);
+			serv, sizeof(serv)-1, flags);
 	if (ret != 0) {
-		/* This is a fairly bad failure - it'll fallback to IP if it
+		if (host_lookup) {
-		 * just can't resolve */
+			/* On some systems (Darwin does it) we get EINTR from getnameinfo
-		dropbear_exit("failed lookup (%d, %d)", ret, errno);
+			 * somehow. Eew. So we'll just return the IP, since that doesn't seem
-	}
+			 * to exhibit that behaviour. */
+			getaddrstring(addr, ret_host, ret_port, 0);
-	if (withport) {
+			return;
-		len = strlen(hbuf) + 2 + strlen(sbuf);
+		} else {
-		retstring = (char*)m_malloc(len);
+			/* if we can't do a numeric lookup, something's gone terribly wrong */
-		snprintf(retstring, len, "%s:%s", hbuf, sbuf);
+			dropbear_exit("Failed lookup: %s", gai_strerror(ret));
-	} else {
+		}
-		retstring = m_strdup(hbuf);
+	}
-	}
+	if (ret_host) {
-	return retstring;
+		*ret_host = m_strdup(host);
+	}
-}
+	if (ret_port) {
+		*ret_port = m_strdup(serv);
-/* Get the hostname corresponding to the address addr. On failure, the IP
+	}
-* address is returned. The return value is allocated with strdup() */
-char* getaddrhostname(struct sockaddr_storage * addr) {
-	char hbuf[NI_MAXHOST];
-	char sbuf[NI_MAXSERV];
-	int ret;
-	unsigned int len;
-#ifdef DO_HOST_LOOKUP
-	const int flags = NI_NUMERICSERV;
-#else
-	const int flags = NI_NUMERICHOST | NI_NUMERICSERV;
-#endif
-	len = sizeof(struct sockaddr_storage);
-	/* Some platforms such as Solaris 8 require that len is the length
-	 * of the specific structure. */
-#ifdef HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY
-	if (addr->ss_family == AF_INET) {
-		len = sizeof(struct sockaddr_in);
-	}
-#ifdef AF_INET6
-	if (addr->ss_family == AF_INET6) {
-		len = sizeof(struct sockaddr_in6);
-	}
-#endif
-#endif
-	ret = getnameinfo((struct sockaddr*)addr, len, hbuf, sizeof(hbuf),
-			sbuf, sizeof(sbuf), flags);
-	if (ret != 0) {
-		/* On some systems (Darwin does it) we get EINTR from getnameinfo
-		 * somehow. Eew. So we'll just return the IP, since that doesn't seem
-		 * to exhibit that behaviour. */
-		return getaddrstring(addr, 0);
-	}
-	return m_strdup(hbuf);
 }
 #ifdef DEBUG_TRACE
 void printhex(const char * label, const unsigned char * buf, int len) {

Mercurial > dropbear

comparison dbutil.c @ 579:8c737cd7c1af