mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-09-22 06:11:32 +02:00
Code Issues Projects Releases Wiki Activity

[CLEANUP] unix sockets : move create_uxst_socket() in uxst_bind_listener()

Browse Source 
The code of create_uxst_socket() is moved in uxst_bind_listener() so that we
don't need to pass a lot of parameters, as it was only called there.
This commit is contained in:
Cyril Bont 2010-11-14 17:03:19 +01:00 committed by Willy Tarreau
parent e4cbbe2a0e
commit 1f5848a460
1 changed files with 84 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
src/proto_uxst.c
View File

@ -72,21 +72,68 @@ static struct protocol proto_unix = {
********************************/ ********************************/
/* This function creates a named PF_UNIX stream socket at address <path>. Note /* Tries to destroy the UNIX stream socket <path>. The socket must not be used
* that the path cannot be NULL nor empty. <uid> and <gid> different of -1 will * anymore. It practises best effort, and no error is returned.
* be used to change the socket owner. If <mode> is not 0, it will be used to
* restrict access to the socket. While it is known not to be portable on every
* OS, it's still useful where it works.
* It returns the assigned file descriptor, or -1 in the event of an error.
*/ */
static int create_uxst_socket(const char *path, uid_t uid, gid_t gid, mode_t mode, int backlog, char *errmsg, int errlen) static void destroy_uxst_socket(const char *path)
{ {
struct sockaddr_un addr;
int sock, ret;
/* We might have been chrooted, so we may not be able to access the
* socket. In order to avoid bothering the other end, we connect with a
* wrong protocol, namely SOCK_DGRAM. The return code from connect()
* is enough to know if the socket is still live or not. If it's live
* in mode SOCK_STREAM, we get EPROTOTYPE or anything else but not
* ECONNREFUSED. In this case, we do not touch it because it's used
* by some other process.
*/
sock = socket(PF_UNIX, SOCK_DGRAM, 0);
if (sock < 0)
return;
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, path, sizeof(addr.sun_path));
addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
if (ret < 0 && errno == ECONNREFUSED) {
/* Connect failed: the socket still exists but is not used
* anymore. Let's remove this socket now.
*/
unlink(path);
}
close(sock);
}
/********************************
* 2) listener-oriented functions
********************************/
/* This function creates a UNIX socket associated to the listener. It changes
* the state from ASSIGNED to LISTEN. The socket is NOT enabled for polling.
* The return value is composed from ERR_NONE, ERR_RETRYABLE and ERR_FATAL.
*/
static int uxst_bind_listener(struct listener *listener, char *errmsg, int errlen)
{
int fd;
char tempname[MAXPATHLEN]; char tempname[MAXPATHLEN];
char backname[MAXPATHLEN]; char backname[MAXPATHLEN];
struct sockaddr_un addr; struct sockaddr_un addr;
const char *msg = NULL; const char *msg = NULL;
const char *path;
int ret, sock; int ret;
/* ensure we never return garbage */
if (errmsg && errlen)
*errmsg = 0;
if (listener->state != LI_ASSIGNED)
return ERR_NONE; /* already bound */
path = ((struct sockaddr_un *)&listener->addr)->sun_path;
/* 1. create socket names */ /* 1. create socket names */
if (!path[0]) { if (!path[0]) {
@ -128,35 +175,41 @@ static int create_uxst_socket(const char *path, uid_t uid, gid_t gid, mode_t mod
strncpy(addr.sun_path, tempname, sizeof(addr.sun_path)); strncpy(addr.sun_path, tempname, sizeof(addr.sun_path));
addr.sun_path[sizeof(addr.sun_path) - 1] = 0; addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
sock = socket(PF_UNIX, SOCK_STREAM, 0); fd = socket(PF_UNIX, SOCK_STREAM, 0);
if (sock < 0) { if (fd < 0) {
msg = "cannot create UNIX socket"; msg = "cannot create UNIX socket";
goto err_unlink_back; goto err_unlink_back;
} }
if (sock >= global.maxsock) { if (fd >= global.maxsock) {
msg = "socket(): not enough free sockets, raise -n argument"; msg = "socket(): not enough free sockets, raise -n argument";
goto err_unlink_temp; goto err_unlink_temp;
} }
if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) { if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
msg = "cannot make UNIX socket non-blocking"; msg = "cannot make UNIX socket non-blocking";
goto err_unlink_temp; goto err_unlink_temp;
} }
if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
/* note that bind() creates the socket <tempname> on the file system */ /* note that bind() creates the socket <tempname> on the file system */
msg = "cannot bind UNIX socket"; msg = "cannot bind UNIX socket";
goto err_unlink_temp; goto err_unlink_temp;
} }
if (((uid != -1 || gid != -1) && (chown(tempname, uid, gid) == -1)) || /* <uid> and <gid> different of -1 will be used to change the socket owner.
(mode != 0 && chmod(tempname, mode) == -1)) { * If <mode> is not 0, it will be used to restrict access to the socket.
* While it is known not to be portable on every OS, it's still useful
* where it works.
*/
if (((listener->perm.ux.uid != -1 || listener->perm.ux.gid != -1) &&
(chown(tempname, listener->perm.ux.uid, listener->perm.ux.gid) == -1)) ||
(listener->perm.ux.mode != 0 && chmod(tempname, listener->perm.ux.mode) == -1)) {
msg = "cannot change UNIX socket ownership"; msg = "cannot change UNIX socket ownership";
goto err_unlink_temp; goto err_unlink_temp;
} }
if (listen(sock, backlog) < 0) { if (listen(fd, listener->backlog ? listener->backlog : listener->maxconn) < 0) {
msg = "cannot listen to UNIX socket"; msg = "cannot listen to UNIX socket";
goto err_unlink_temp; goto err_unlink_temp;
} }
@ -174,87 +227,6 @@ static int create_uxst_socket(const char *path, uid_t uid, gid_t gid, mode_t mod
/* 6. cleanup */ /* 6. cleanup */
unlink(backname); /* no need to keep this one either */ unlink(backname); /* no need to keep this one either */
return sock;
err_rename:
ret = rename(backname, path);
if (ret < 0 && errno == ENOENT)
unlink(path);
err_unlink_temp:
unlink(tempname);
close(sock);
err_unlink_back:
unlink(backname);
err_return:
if (msg && errlen)
snprintf(errmsg, errlen, "%s [%s]", msg, path);
return -1;
}
/* Tries to destroy the UNIX stream socket <path>. The socket must not be used
* anymore. It practises best effort, and no error is returned.
*/
static void destroy_uxst_socket(const char *path)
{
struct sockaddr_un addr;
int sock, ret;
/* We might have been chrooted, so we may not be able to access the
* socket. In order to avoid bothering the other end, we connect with a
* wrong protocol, namely SOCK_DGRAM. The return code from connect()
* is enough to know if the socket is still live or not. If it's live
* in mode SOCK_STREAM, we get EPROTOTYPE or anything else but not
* ECONNREFUSED. In this case, we do not touch it because it's used
* by some other process.
*/
sock = socket(PF_UNIX, SOCK_DGRAM, 0);
if (sock < 0)
return;
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, path, sizeof(addr.sun_path));
addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
if (ret < 0 && errno == ECONNREFUSED) {
/* Connect failed: the socket still exists but is not used
* anymore. Let's remove this socket now.
*/
unlink(path);
}
close(sock);
}
/********************************
* 2) listener-oriented functions
********************************/
/* This function creates the UNIX socket associated to the listener. It changes
* the state from ASSIGNED to LISTEN. The socket is NOT enabled for polling.
* The return value is composed from ERR_NONE, ERR_RETRYABLE and ERR_FATAL.
*/
static int uxst_bind_listener(struct listener *listener, char *errmsg, int errlen)
{
int fd;
/* ensure we never return garbage */
if (errmsg && errlen)
*errmsg = 0;
if (listener->state != LI_ASSIGNED)
return ERR_NONE; /* already bound */
fd = create_uxst_socket(((struct sockaddr_un *)&listener->addr)->sun_path,
listener->perm.ux.uid,
listener->perm.ux.gid,
listener->perm.ux.mode,
listener->backlog ? listener->backlog : listener->maxconn,
errmsg, errlen);
if (fd == -1) {
return ERR_FATAL | ERR_ALERT;
}
/* the socket is now listening */ /* the socket is now listening */
listener->fd = fd; listener->fd = fd;
listener->state = LI_LISTEN; listener->state = LI_LISTEN;
@ -269,6 +241,19 @@ static int uxst_bind_listener(struct listener *listener, char *errmsg, int errle
fdinfo[fd].peeraddr = NULL; fdinfo[fd].peeraddr = NULL;
fdinfo[fd].peerlen = 0; fdinfo[fd].peerlen = 0;
return ERR_NONE; return ERR_NONE;
err_rename:
ret = rename(backname, path);
if (ret < 0 && errno == ENOENT)
unlink(path);
err_unlink_temp:
unlink(tempname);
close(fd);
err_unlink_back:
unlink(backname);
err_return:
if (msg && errlen)
snprintf(errmsg, errlen, "%s [%s]", msg, path);
return ERR_FATAL | ERR_ALERT;
} }
/* This function closes the UNIX sockets for the specified listener. /* This function closes the UNIX sockets for the specified listener.