/*
- * Copyright (C) 2005-2013 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2005-2014 Andre Noll <maan@systemlinux.org>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
}
}
-static void flowopt_cleanup(struct flowopts *fo)
+/**
+ * Deallocate all resources of a flowopts structure.
+ *
+ * \param fo A pointer as returned from flowopt_new().
+ *
+ * It's OK to pass \p NULL here in which case the function does nothing.
+ */
+void flowopt_cleanup(struct flowopts *fo)
{
struct pre_conn_opt *cur, *next;
free(fo);
}
-/*
+/**
* Resolve an IPv4/IPv6 address.
*
* \param l4type The layer-4 type (\p IPPROTO_xxx).
*
* \sa getaddrinfo(3).
*/
-static int lookup_address(unsigned l4type, bool passive, const char *host,
+int lookup_address(unsigned l4type, bool passive, const char *host,
int port_number, struct addrinfo **result)
{
int ret;
return 1;
}
-/*
+/**
* Create an active or passive socket.
*
* \param l4type \p IPPROTO_TCP, \p IPPROTO_UDP, or \p IPPROTO_DCCP.
*
* bind(2) is called on passive sockets, and connect(2) on active sockets. The
* algorithm tries all possible address combinations until it succeeds. If \a
- * fo is supplied, options are set and cleanup is performed.
+ * fo is supplied, options are set but cleanup must be performed in the caller.
*
* \return File descriptor on success, \p E_MAKESOCK on errors.
*
* \sa \ref lookup_address(), \ref makesock(), ip(7), ipv6(7), bind(2),
* connect(2).
*/
-static int makesock_addrinfo(unsigned l4type, bool passive, struct addrinfo *ai,
+int makesock_addrinfo(unsigned l4type, bool passive, struct addrinfo *ai,
struct flowopts *fo)
{
- int ret = -E_MAKESOCK, on = 1, sockfd = -1;
+ int ret = -E_MAKESOCK, on = 1;
for (; ai; ai = ai->ai_next) {
+ int fd;
ret = socket(ai->ai_family, sock_type(l4type), l4type);
if (ret < 0)
continue;
- sockfd = ret;
- flowopt_setopts(sockfd, fo);
- if (passive) {
- /*
- * Reuse the address on passive sockets to avoid
- * failure on restart (protocols using listen()) and
- * when creating multiple listener instances (UDP
- * multicast).
- */
- if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on,
- sizeof(on)) == -1) {
- ret = -ERRNO_TO_PARA_ERROR(errno);
- close(sockfd);
- PARA_ERROR_LOG("can not set SO_REUSEADDR: %s\n",
- para_strerror(-ret));
- return ret;
- }
- if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) {
- close(sockfd);
- continue;
- }
- return sockfd;
- } else {
- if (connect(sockfd, ai->ai_addr, ai->ai_addrlen) == 0)
- return sockfd;
- close(sockfd);
+ fd = ret;
+ flowopt_setopts(fd, fo);
+ if (!passive) {
+ if (connect(fd, ai->ai_addr, ai->ai_addrlen) == 0)
+ return fd;
+ close(fd);
+ continue;
+ }
+ /*
+ * Reuse the address on passive sockets to avoid failure on
+ * restart (protocols using listen()) and when creating
+ * multiple listener instances (UDP multicast).
+ */
+ if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on,
+ sizeof(on)) == -1) {
+ close(fd);
+ continue;
}
+ if (bind(fd, ai->ai_addr, ai->ai_addrlen) < 0) {
+ close(fd);
+ continue;
+ }
+ return fd;
}
return -E_MAKESOCK;
}
ret = makesock_addrinfo(l4type, passive, ai, fo);
if (ai)
freeaddrinfo(ai);
- flowopt_cleanup(fo);
if (ret < 0) {
PARA_ERROR_LOG("can not create %s socket %s#%d.\n",
layer4_name(l4type), host? host : (passive?
*ia = ((struct sockaddr_in *)sa)->sin_addr;
}
+/**
+ * Compare the address part of IPv4/6 addresses.
+ *
+ * \param sa1 First address.
+ * \param sa2 Second address.
+ *
+ * \return True iff the IP address of \a sa1 and \a sa2 match.
+ */
+bool sockaddr_equal(const struct sockaddr *sa1, const struct sockaddr *sa2)
+{
+ if (!sa1 || !sa2)
+ return false;
+ if (sa1->sa_family != sa2->sa_family)
+ return false;
+ if (sa1->sa_family == AF_INET) {
+ struct sockaddr_in *a1 = (typeof(a1))sa1,
+ *a2 = (typeof (a2))sa2;
+ return a1->sin_addr.s_addr == a2->sin_addr.s_addr;
+ } else if (sa1->sa_family == AF_INET6) {
+ struct sockaddr_in6 *a1 = (typeof(a1))sa1,
+ *a2 = (typeof (a2))sa2;
+ return !memcmp(a1, a2, sizeof(*a1));
+ } else
+ return false;
+}
+
/**
* Receive data from a file descriptor.
*
return recv_buffer(fd, buf, size) > 0? 1 : -E_RECVMSG;
}
#else /* HAVE_UCRED */
+
/**
- * Send \p NULL-terminated buffer and Unix credentials of the current process.
+ * Send a buffer and the credentials of the current process to a socket.
*
- * \param sock The socket file descriptor.
- * \param buf The buffer to be sent.
+ * \param sock The file descriptor of the sending socket.
+ * \param buf The zero-terminated buffer to send.
*
- * \return On success, this call returns the number of characters sent. On
- * error, \p -E_SENDMSG is returned.
+ * \return On success, this call returns the number of bytes sent. On errors,
+ * \p -E_SENDMSG is returned.
*
- * \sa sendmsg(2), okir's Black Hats Manual.
+ * \sa \ref recv_cred_buffer, sendmsg(2), socket(7), unix(7), okir's Black Hats
+ * Manual.
*/
ssize_t send_cred_buffer(int sock, char *buf)
{
/* Response data */
iov.iov_base = buf;
- iov.iov_len = strlen(buf);
+ iov.iov_len = strlen(buf);
c.pid = getpid();
c.uid = getuid();
c.gid = getgid();
*(struct ucred *)CMSG_DATA(cmsg) = c;
msg.msg_controllen = cmsg->cmsg_len;
ret = sendmsg(sock, &msg, 0);
- if (ret < 0)
+ if (ret < 0)
ret = -E_SENDMSG;
return ret;
}
/**
* Receive a buffer and the Unix credentials of the sending process.
*
- * \param fd the socket file descriptor.
- * \param buf the buffer to store the message.
- * \param size the size of \a buffer.
+ * \param fd The file descriptor of the receiving socket.
+ * \param buf The buffer to store the received message.
+ * \param size The length of \a buf in bytes.
*
- * \return negative on errors, the user id on success.
+ * \return Negative on errors, the user id of the sending process on success.
*
- * \sa recvmsg(2), okir's Black Hats Manual.
+ * \sa \ref send_cred_buffer and the references given there.
*/
int recv_cred_buffer(int fd, char *buf, size_t size)
{
} else
if (cmsg->cmsg_level == SOL_SOCKET
&& cmsg->cmsg_type == SCM_RIGHTS) {
- dispose_fds((int *) CMSG_DATA(cmsg),
+ dispose_fds((int *)CMSG_DATA(cmsg),
(cmsg->cmsg_len - CMSG_LEN(0))
/ sizeof(int));
}