> This change makes the code use the POSIX basename() function. It has the
> advantage that (if implemented correctly), it also imposes no restrict
> on the pathname length.

I'm not sure what the parenthetic remark "if implemented correctly"
means, but libc basename() has this in it:

        char *
        basename(const char *path)
        {
                static char *bname = NULL;

                if (bname == NULL) {
                        bname = (char *)malloc(MAXPATHLEN);
                        if (bname == NULL)
                                return (NULL);
                }
                return (basename_r(path, bname));
        }

which means that it is not only not thread-safe, it also
imposes restrictions on pathname length.

I recently wrote a pair of can-be-thread-safe yet can-be-
unlimited-path-length yet can-be-backwards-compatible basename
and dirname functions (I tested to see if they produced the same
errno's and oddball outputs like for dirname("///")).  I'll toss
them in here in case anyone has some enthusiasm for fixing the
mess.  Of course they are equally non-standard, unless we can
convince a future POSIX committee or something.

(I also wrote some halfway useable reentrant getpw* and getgr*
functions but they need more thought and do not play well with
nsswitch so I am not including them here.  NB: rfuncs.h just
contains declarations for these reentrant r_* functions.)

Chris

-------

/*
 * Copyright 2016 Chris Torek <chris.to...@gmail.com>
 * All rights reserved
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted providing that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "rfuncs.h"

/*
 * This is essentially a clone of the BSD basename_r function,
 * which is like POSIX basename() but puts the result in a user
 * supplied buffer.
 *
 * In BSD basename_r, the buffer must be least MAXPATHLEN bytes
 * long.  In our case we take the size of the buffer as an argument.
 *
 * Note that it's impossible in general to do this without
 * a temporary buffer since basename("foo/bar") is "bar",
 * but basename("foo/bar/") is still "bar" -- no trailing
 * slash is allowed.
 *
 * The return value is your supplied buffer <buf>, or NULL if
 * the length of the basename of the supplied <path> equals or
 * exceeds your indicated <bufsize>.
 *
 * As a special but useful case, if you supply NULL for the <buf>
 * argument, we allocate the buffer dynamically to match the
 * basename, i.e., the result is basically strdup()ed for you.
 * In this case <bufsize> is ignored (recommended: pass 0 here).
 */
char *
r_basename(const char *path, char *buf, size_t bufsize)
{
        const char *endp, *comp;
        size_t len;

        /*
         * NULL or empty path means ".".  This is perhaps overly
         * forgiving but matches libc basename_r(), and avoids
         * breaking the code below.
         */
        if (path == NULL || *path == '\0') {
                comp = ".";
                len = 1;
        } else {
                /*
                 * Back up over any trailing slashes.  If we reach
                 * the top of the path and it's still a trailing
                 * slash, it's also a leading slash and the entire
                 * path is just "/" (or "//", or "///", etc).
                 */
                endp = path + strlen(path) - 1;
                while (*endp == '/' && endp > path)
                        endp--;
                /* Invariant: *endp != '/' || endp == path */
                if (*endp == '/') {
                        /* then endp==path and hence entire path is "/" */
                        comp = "/";
                        len = 1;
                } else {
                        /*
                         * We handled empty strings earlier, and
                         * we just proved *endp != '/'.  Hence
                         * we have a non-empty basename, ending
                         * at endp.
                         *
                         * Back up one path name component.  The
                         * part between these two is the basename.
                         *
                         * Note that we only stop backing up when
                         * either comp==path, or comp[-1] is '/'.
                         *
                         * Suppose path[0] is '/'.  Then, since *endp
                         * is *not* '/', we had comp>path initially, and
                         * stopped backing up because we found a '/'
                         * (perhaps path[0], perhaps a later '/').
                         *
                         * Or, suppose path[0] is NOT '/'.  Then,
                         * either there are no '/'s at all and
                         * comp==path, or comp[-1] is '/'.
                         *
                         * In all cases, we want all bytes from *comp
                         * to *endp, inclusive.
                         */
                        comp = endp;
                        while (comp > path && comp[-1] != '/')
                                comp--;
                        len = (size_t)(endp - comp + 1);
                }
        }
        if (buf == NULL) {
                buf = malloc(len + 1);
                if (buf == NULL)
                        return (NULL);
        } else {
                if (len >= bufsize) {
                        errno = ENAMETOOLONG;
                        return (NULL);
                }
        }
        memcpy(buf, comp, len);
        buf[len] = '\0';
        return (buf);
}

/*
 * This is much like POSIX dirname(), but is reentrant.
 *
 * We examine a path, find the directory portion, and copy that
 * to a user supplied buffer <buf> of the given size <bufsize>.
 *
 * Note that dirname("/foo/bar/") is "/foo", dirname("/foo") is "/",
 * and dirname("////") is "/". However, dirname("////foo/bar") is
 * "////foo" (we do not resolve these leading slashes away -- this
 * matches the BSD libc behavior).
 *
 * The return value is your supplied buffer <buf>, or NULL if
 * the length of the dirname of the supplied <path> equals or
 * exceeds your indicated <bufsize>.
 *
 * As a special but useful case, if you supply NULL for the <buf>
 * argument, we allocate the buffer dynamically to match the
 * dirname, i.e., the result is basically strdup()ed for you.
 * In this case <bufsize> is ignored (recommended: pass 0 here).
 */
char *
r_dirname(const char *path, char *buf, size_t bufsize)
{
        const char *endp, *dirpart;
        size_t len;

        /*
         * NULL or empty path means ".".  This is perhaps overly
         * forgiving but matches libc dirname(), and avoids breaking
         * the code below.
         */
        if (path == NULL || *path == '\0') {
                dirpart = ".";
                len = 1;
        } else {
                /*
                 * Back up over any trailing slashes, then back up
                 * one path name, then back up over more slashes.
                 * In all cases, stop as soon as endp==path so
                 * that we do not back out of the buffer entirely.
                 *
                 * The first loop takes care of trailing slashes
                 * in names like "/foo/bar//" (where the dirname
                 * part is to be "/foo"), the second strips out
                 * the non-dir-name part, and the third leaves us
                 * pointing to the end of the directory component.
                 *
                 * If the entire name is of the form "/foo" or
                 * "//foo" (or "/foo/", etc, but we already
                 * handled trailing slashes), we end up pointing
                 * to the leading "/", which is what we want; but
                 * if it is of the form "foo" (or "foo/", etc) we
                 * point to a non-slash.  So, if (and only if)
                 * endp==path AND *endp is not '/', the dirname is
                 * ".", but in all cases, the LENGTH of the
                 * dirname is (endp-path+1).
                 */
                endp = path + strlen(path) - 1;
                while (endp > path && *endp == '/')
                        endp--;
                while (endp > path && *endp != '/')
                        endp--;
                while (endp > path && *endp == '/')
                        endp--;

                len = (size_t)(endp - path + 1);
                if (endp == path && *endp != '/')
                        dirpart = ".";
                else
                        dirpart = path;
        }
        if (buf == NULL) {
                buf = malloc(len + 1);
                if (buf == NULL)
                        return (NULL);
        } else {
                if (len >= bufsize) {
                        errno = ENAMETOOLONG;
                        return (NULL);
                }
        }
        memcpy(buf, dirpart, len);
        buf[len] = '\0';
        return (buf);
}
_______________________________________________
svn-src-all@freebsd.org mailing list
https://lists.freebsd.org/mailman/listinfo/svn-src-all
To unsubscribe, send any mail to "svn-src-all-unsubscr...@freebsd.org"

Reply via email to