Skip to content

Commit

Permalink
socket-util: Add symlink based workaround for long pathnames.
Browse files Browse the repository at this point in the history 
The existing /proc workaround only works on Linux.  Symlinks are more
widely available.

Signed-off-by: YAMAMOTO Takashi <[email protected]>
Co-authored-by: Ben Pfaff <[email protected]>
Signed-off-by: Ben Pfaff <[email protected]>
  • Loading branch information
@yamt @blp
yamt and blp committed Oct 18, 2013
1 parent 260aeca commit 5b5d183
Show file tree
Hide file tree
Showing 3 changed files with 196 additions and 67 deletions.
215 changes: 151 additions & 64 deletions lib/socket-util.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -60,6 +60,10 @@ VLOG_DEFINE_THIS_MODULE(socket_util);
#define O_DIRECTORY 0
#endif

/* Maximum length of the sun_path member in a struct sockaddr_un, excluding
* space for a null terminator. */
#define MAX_UN_LEN (sizeof(((struct sockaddr_un *) 0)->sun_path) - 1)

static int getsockopt_int(int fd, int level, int option, const char *optname,
int *valuep);

Expand Down Expand Up @@ -337,78 +341,161 @@ drain_fd(int fd, size_t n_packets)
}
}

/* Stores in '*un' a sockaddr_un that refers to file 'name'. Stores in
* '*un_len' the size of the sockaddr_un. */
static void
make_sockaddr_un__(const char *name, struct sockaddr_un *un, socklen_t *un_len)
/* Attempts to shorten 'name' by opening a file descriptor for the directory
* part of the name and indirecting through /proc/self/fd/<dirfd>/<basename>.
* On systems with Linux-like /proc, this works as long as <basename> isn't too
* long.
*
* On success, returns 0 and stores the short name in 'short_name' and a
* directory file descriptor to eventually be closed in '*dirfpd'. */
static int
shorten_name_via_proc(const char *name, char short_name[MAX_UN_LEN + 1],
int *dirfdp)
{
un->sun_family = AF_UNIX;
ovs_strzcpy(un->sun_path, name, sizeof un->sun_path);
*un_len = (offsetof(struct sockaddr_un, sun_path)
+ strlen (un->sun_path) + 1);
char *dir, *base;
int dirfd;
int len;

if (!LINUX_DATAPATH) {
return ENAMETOOLONG;
}

dir = dir_name(name);
dirfd = open(dir, O_DIRECTORY | O_RDONLY);
if (dirfd < 0) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
int error = errno;

VLOG_WARN_RL(&rl, "%s: open failed (%s)", dir, ovs_strerror(error));
free(dir);

return error;
}
free(dir);

base = base_name(name);
len = snprintf(short_name, MAX_UN_LEN + 1,
"/proc/self/fd/%d/%s", dirfd, base);
free(base);

if (len >= 0 && len <= MAX_UN_LEN) {
*dirfdp = dirfd;
return 0;
} else {
close(dirfd);
return ENAMETOOLONG;
}
}

/* Attempts to shorten 'name' by creating a symlink for the directory part of
* the name and indirecting through <symlink>/<basename>. This works on
* systems that support symlinks, as long as <basename> isn't too long.
*
* On success, returns 0 and stores the short name in 'short_name' and the
* symbolic link to eventually delete in 'linkname'. */
static int
shorten_name_via_symlink(const char *name, char short_name[MAX_UN_LEN + 1],
char linkname[MAX_UN_LEN + 1])
{
char *abs, *dir, *base;
const char *tmpdir;
int error;
int i;

abs = abs_file_name(NULL, name);
dir = dir_name(abs);
base = base_name(abs);
free(abs);

tmpdir = getenv("TMPDIR");
if (tmpdir == NULL) {
tmpdir = "/tmp";
}

for (i = 0; i < 1000; i++) {
int len;

len = snprintf(linkname, MAX_UN_LEN + 1,
"%s/ovs-un-c-%"PRIu32, tmpdir, random_uint32());
error = (len < 0 || len > MAX_UN_LEN ? ENAMETOOLONG
: symlink(dir, linkname) ? errno
: 0);
if (error != EEXIST) {
break;
}
}

if (!error) {
int len;

fatal_signal_add_file_to_unlink(linkname);

len = snprintf(short_name, MAX_UN_LEN + 1, "%s/%s", linkname, base);
if (len < 0 || len > MAX_UN_LEN) {
fatal_signal_unlink_file_now(linkname);
error = ENAMETOOLONG;
}
}

if (error) {
linkname[0] = '\0';
}
free(dir);
free(base);

return error;
}

/* Stores in '*un' a sockaddr_un that refers to file 'name'. Stores in
* '*un_len' the size of the sockaddr_un.
*
* Returns 0 on success, otherwise a positive errno value. On success,
* '*dirfdp' is either -1 or a nonnegative file descriptor that the caller
* should close after using '*un' to bind or connect. On failure, '*dirfdp' is
* -1. */
* Returns 0 on success, otherwise a positive errno value.
*
* Uses '*dirfdp' and 'linkname' to store references to data when the caller no
* longer needs to use 'un'. On success, freeing these references with
* free_sockaddr_un() is mandatory to avoid a leak; on failure, freeing them is
* unnecessary but harmless. */
static int
make_sockaddr_un(const char *name, struct sockaddr_un *un, socklen_t *un_len,
int *dirfdp)
int *dirfdp, char linkname[MAX_UN_LEN + 1])
{
enum { MAX_UN_LEN = sizeof un->sun_path - 1 };
char short_name[MAX_UN_LEN + 1];

*dirfdp = -1;
linkname[0] = '\0';
if (strlen(name) > MAX_UN_LEN) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);

if (LINUX_DATAPATH) {
/* 'name' is too long to fit in a sockaddr_un, but we have a
* workaround for that on Linux: shorten it by opening a file
* descriptor for the directory part of the name and indirecting
* through /proc/self/fd/<dirfd>/<basename>. */
char *dir, *base;
char *short_name;
int dirfd;

dir = dir_name(name);
base = base_name(name);

dirfd = open(dir, O_DIRECTORY | O_RDONLY);
if (dirfd < 0) {
free(base);
free(dir);
return errno;
}

short_name = xasprintf("/proc/self/fd/%d/%s", dirfd, base);
free(dir);
free(base);

if (strlen(short_name) <= MAX_UN_LEN) {
make_sockaddr_un__(short_name, un, un_len);
free(short_name);
*dirfdp = dirfd;
return 0;
}
free(short_name);
close(dirfd);
/* 'name' is too long to fit in a sockaddr_un. Try a workaround. */
int error = shorten_name_via_proc(name, short_name, dirfdp);
if (error == ENAMETOOLONG) {
error = shorten_name_via_symlink(name, short_name, linkname);
}
if (error) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);

VLOG_WARN_RL(&rl, "Unix socket name %s is longer than maximum "
"%d bytes (even shortened)", name, MAX_UN_LEN);
} else {
/* 'name' is too long and we have no workaround. */
VLOG_WARN_RL(&rl, "Unix socket name %s is longer than maximum "
"%d bytes", name, MAX_UN_LEN);
"%zu bytes", name, MAX_UN_LEN);
return error;
}

return ENAMETOOLONG;
} else {
make_sockaddr_un__(name, un, un_len);
return 0;
name = short_name;
}

un->sun_family = AF_UNIX;
ovs_strzcpy(un->sun_path, name, sizeof un->sun_path);
*un_len = (offsetof(struct sockaddr_un, sun_path)
+ strlen (un->sun_path) + 1);
return 0;
}

/* Clean up after make_sockaddr_un(). */
static void
free_sockaddr_un(int dirfd, const char *linkname)
{
if (dirfd >= 0) {
close(dirfd);
}
if (linkname[0]) {
fatal_signal_unlink_file_now(linkname);
}
}

Expand Down Expand Up @@ -453,6 +540,7 @@ make_unix_socket(int style, bool nonblock,
}

if (bind_path) {
char linkname[MAX_UN_LEN + 1];
struct sockaddr_un un;
socklen_t un_len;
int dirfd;
Expand All @@ -463,32 +551,31 @@ make_unix_socket(int style, bool nonblock,
}
fatal_signal_add_file_to_unlink(bind_path);

error = make_sockaddr_un(bind_path, &un, &un_len, &dirfd);
error = make_sockaddr_un(bind_path, &un, &un_len, &dirfd, linkname);
if (!error) {
error = bind_unix_socket(fd, (struct sockaddr *) &un, un_len);
}
if (dirfd >= 0) {
close(dirfd);
}
free_sockaddr_un(dirfd, linkname);

if (error) {
goto error;
}
}

if (connect_path) {
char linkname[MAX_UN_LEN + 1];
struct sockaddr_un un;
socklen_t un_len;
int dirfd;

error = make_sockaddr_un(connect_path, &un, &un_len, &dirfd);
error = make_sockaddr_un(connect_path, &un, &un_len, &dirfd, linkname);
if (!error
&& connect(fd, (struct sockaddr*) &un, un_len)
&& errno != EINPROGRESS) {
error = errno;
}
if (dirfd >= 0) {
close(dirfd);
}
free_sockaddr_un(dirfd, linkname);

if (error) {
goto error;
}
Expand Down
46 changes: 45 additions & 1 deletion python/ovs/socket_util.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,8 @@

import errno
import os
import os.path
import random
import select
import socket
import sys
Expand All @@ -25,7 +27,33 @@
vlog = ovs.vlog.Vlog("socket_util")


def make_unix_socket(style, nonblock, bind_path, connect_path):
def make_short_name(long_name):
if long_name is None:
return None
long_name = os.path.abspath(long_name)
long_dirname = os.path.dirname(long_name)
tmpdir = os.getenv('TMPDIR', '/tmp')
for x in xrange(0, 1000):
link_name = \
'%s/ovs-un-py-%d-%d' % (tmpdir, random.randint(0, 10000), x)
try:
os.symlink(long_dirname, link_name)
ovs.fatal_signal.add_file_to_unlink(link_name)
return os.path.join(link_name, os.path.basename(long_name))
except OSError, e:
if e.errno != errno.EEXIST:
break
raise Exception("Failed to create temporary symlink")


def free_short_name(short_name):
if short_name is None:
return
link_name = os.path.dirname(short_name)
ovs.fatal_signal.unlink_file_now(link_name)


def make_unix_socket(style, nonblock, bind_path, connect_path, short=False):
"""Creates a Unix domain socket in the given 'style' (either
socket.SOCK_DGRAM or socket.SOCK_STREAM) that is bound to 'bind_path' (if
'bind_path' is not None) and connected to 'connect_path' (if 'connect_path'
Expand Down Expand Up @@ -106,6 +134,22 @@ def make_unix_socket(style, nonblock, bind_path, connect_path):
os.close(connect_dirfd)
if bind_dirfd is not None:
os.close(bind_dirfd)
elif (eno == "AF_UNIX path too long"):
if short:
return get_exception_errno(e), None
short_bind_path = None
try:
short_bind_path = make_short_name(bind_path)
short_connect_path = make_short_name(connect_path)
except:
free_short_name(short_bind_path)
return errno.ENAMETOOLONG, None
try:
return make_unix_socket(style, nonblock, short_bind_path,
short_connect_path, short=True)
finally:
free_short_name(short_bind_path)
free_short_name(short_connect_path)
else:
return get_exception_errno(e), None

Expand Down
2 changes: 0 additions & 2 deletions tests/library.at
View file
Original file line number Diff line number Diff line change
Expand Up @@ -135,7 +135,6 @@ dnl is about 100 bytes. On Linux, we work around this by indirecting through
dnl a directory fd using /proc/self/fd/<dirfd>. We do not have a workaround
dnl for other platforms, so we skip the test there.
AT_SETUP([test unix socket, long pathname - C])
AT_SKIP_IF([test ! -d /proc/self/fd])
dnl Linux has a 108 byte limit; this is 150 bytes long.
longname=012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
mkdir $longname
Expand All @@ -155,7 +154,6 @@ dnl a directory fd using /proc/self/fd/<dirfd>. We do not have a workaround
dnl for other platforms, so we skip the test there.
AT_SETUP([test unix socket, long pathname - Python])
AT_SKIP_IF([test $HAVE_PYTHON = no])
AT_SKIP_IF([test ! -d /proc/self/fd])
dnl Linux has a 108 byte limit; this is 150 bytes long.
longname=012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
mkdir $longname
Expand Down

0 comments on commit 5b5d183

Please sign in to comment.