basename alternative

[philonto]

Hi

I wrote this code to ensure I am using a safer basename:
- not modifying argument
- not using malloc to avoid free
- I do not need it thread safe

char *BaseName(const char* full_path) {
    static char ret[PATH_MAX];
    char path_copy[PATH_MAX];
    char *ptr;

    if (full_path == NULL || strcmp(full_path, "") == 0) {
        strcpy(ret, ".");
    } else {
        strcpy(path_copy, full_path);
        ptr = strtok(path_copy, "/");
        if (ptr == NULL)
            strcpy(ret, "/");

        while (ptr != NULL) {
            strcpy(ret, ptr);
            ptr = strtok(NULL, "/");
        }
    }

    ptr = ret;
    return ptr;
}

I tested all exceptions and it seems to return same values as basename
It also supports spaces, unlike original basename

Any issue with this code? I chose static instead of malloc a pointer on start to make it simpler since it is not thread safe anyway

[kbw]

Any issue with this code?

Yes, use of a static.

You're not using bounded copies; i.e. you should be using strncpy and strncat.

Also, you should be using strtok_r rather strtok to support reentrancy.

I chose static instead of malloc a pointer on start to make it simpler since it is not thread safe anyway

But you've also made it non-reentrant.

It's the use of the static buffer and strtok that's stopping it from being reentrant and thread safe.

[philonto]

thanks
I wrote it for my needs, and mentioned in OP that I do not need it reetrant
I will change to malloc a pointer on first call though

About strncpy, in my case, PATH_MAX is 4096. However, sure it is safer to use strncpy

Thank you for the feedback

By the way, I saw some basename/dirname implementations using xmalloc on every call, without even a free

I found no info on the implementation used by Android NDK. Any idea if they also have a broken basename/dirname modifying argument and maybe not freeing resources?

[philonto]

Just for the feedback
I found an older NDK implementation of basename_r and dirname_r

I fixed dirname_r to never alter argument by setting the *startp pointer
Here's the fixed code that seems safe.

I added a small main() that prints out result from system basename/dirname, in-code functions and original argument passed

int basename_r(const char* path, char*  buffer, size_t  bufflen)
{
    const char *endp, *startp;
    int         len, result;

    /* Empty or NULL string gets treated as "." */
    if (path == NULL || *path == '\0') {
        startp  = ".";
        len     = 1;
        goto Exit;
    }

    /* Strip trailing slashes */
    endp = path + strlen(path) - 1;
    while (endp > path && *endp == '/')
        endp--;

    /* All slashes becomes "/" */
    if (endp == path && *endp == '/') {
        startp = "/";
        len    = 1;
        goto Exit;
    }

    /* Find the start of the base */
    startp = endp;
    while (startp > path && *(startp - 1) != '/')
        startp--;

    len = endp - startp +1;

Exit:
    result = len;
    if (buffer == NULL) {
        return result;
    }
    if (len > (int)bufflen-1) {
        len    = (int)bufflen-1;
        result = -1;
        errno  = ERANGE;
    }

    if (len >= 0) {
        memcpy( buffer, startp, len );
        buffer[len] = 0;
    }
    return result;
}

char* BaseName(const char*  path) {
    static char* bname = NULL;
    int ret;

    if (bname == NULL) {
        bname = (char *)malloc(PATH_MAX);
        if (bname == NULL)
            return(NULL);
    }
    ret = basename_r(path, bname, PATH_MAX);
    return (ret < 0) ? NULL : bname;
}

int
dirname_r(const char*  path, char*  buffer, size_t  bufflen)
{
    const char *endp, *startp;
    int         result, len;

    /* Empty or NULL string gets treated as "." */
    if (path == NULL || *path == '\0') {
        startp = ".";
        len  = 1;
        goto Exit;
    }

    /* Strip trailing slashes */
    endp = path + strlen(path) - 1;
    while (endp > path && *endp == '/')
        endp--;

    /* Find the start of the dir */
    while (endp > path && *endp != '/')
        endp--;

    /* Either the dir is "/" or there are no slashes */
    if (endp == path) {
        startp = (*endp == '/') ? "/" : ".";
        len  = 1;
        goto Exit;
    }

    do {
        endp--;
    } while (endp > path && *endp == '/');

    startp = path;
    len = endp - startp +1;

Exit:
    result = len;
    if (len+1 > PATH_MAX) {
        errno = ENAMETOOLONG;
        return -1;
    }
    if (buffer == NULL)
        return result;

    if (len > (int)bufflen-1) {
        len    = (int)bufflen-1;
        result = -1;
        errno  = ERANGE;
    }

    if (len >= 0) {
        memcpy( buffer, startp, len );
        buffer[len] = 0;
    }
    return result;
}

char* DirName(const char*  path) {
    static char*  bname = NULL;
    int           ret;

    if (bname == NULL) {
        bname = (char *)malloc(PATH_MAX);
        if (bname == NULL)
            return(NULL);
    }

    ret = dirname_r(path, bname, PATH_MAX);
    return (ret < 0) ? NULL : bname;
}

int main(int argc, char **argv) {
    if (argc != 2)
        printf("usage: bin [path/to/name]\n");
    else {
        printf("basename=%s\n", BaseName(argv[1]));
        char cmd[PATH_MAX];
        sprintf(cmd, "basename %s", argv[1]);
        system(cmd);

        printf("dirname=%s\n", DirName(argv[1]));
        sprintf(cmd, "dirname %s", argv[1]);
        system(cmd);
        printf("original:%s\n", argv[1]);
    }
    return 0;
}