What is the best way to generate a path in C?

Question

I need to generate three different types of paths on runtime:

/sys/class/gpio/gpio%d
/sys/class/gpio/gpio%d/value
/sys/class/gpio/gpio%d/direction

Currently I generate these by doing the following:

#define GPIO_PATH_BASE "/sys/class/gpio/gpio"
#define GPIO_PATH_DIRECTION "/direction"
#define GPIO_PATH_VALUE "/value"

int open_gpio(const char * port) {
    char * base_path = (char *) malloc(sizeof(GPIO_PATH_BASE) + sizeof(port));
    strcpy(base_path, GPIO_PATH_BASE);
    strcat(base_path, port);

    char * value_path = (char *) malloc(sizeof(base_path) + sizeof(GPIO_PATH_VALUE));
    strcpy(value_path, (const char *) base_path);
    strcat(value_path, GPIO_PATH_VALUE);

    char * dir_path = (char *) malloc(sizeof(base_path) + sizeof(GPIO_PATH_DIRECTION));
    strcpy(dir_path, (const char *) base_path);
    strcat(dir_path, GPIO_PATH_DIRECTION);
}

I am actually quite unhappy with this approach. Is there a possibility to let a macro this stuff for me or should I create a helper function?

Bodo

If you know the value of `port` at compile time it is possible that an appropriate macro could be constructed. Do you know `port` at compile time? — Magnus Hoff, Jun 17 '13 at 16:13
Do you have `asprintf()` available to you? If so, use it. You need to understand the difference between `sizeof(base_path)` and `strlen(base_path)` -- and you need to use the latter. — Jonathan Leffler, Jun 17 '13 at 16:15
Might want to take a look at: [C Macro Token Concatenation involving a variable - is it possible?](http://stackoverflow.com/questions/3633026/c-macro-token-concatenation-involving-a-variable-is-it-possible) — Mike, Jun 17 '13 at 16:21

Aif · Answer 1 · 2013-06-17T16:22:02.530

I find sprintf (or snprintf as mentionned by @larsmans) more suitable for string manipulations, especially if you want to add decimal values in your string.

I would use PATH_MAX (defined in limits.h) to have a statically allocated buffer like:

#include <limits.h>
#include <stdio.h>

unsigned char path[PATH_MAX];

#define GPIO_PATH_BASE "/sys/class/gpio/gpio"
#define GPIO_PATH_VALUE "/value"

int main(void)
{
        snprintf(path, PATH_MAX, "%s/%d%s", GPIO_PATH_BASE, 42, GPIO_PATH_VALUE);
        puts(path);
        return 0;
}

$ make main
cc     main.c   -o main
$ ./main 
/sys/class/gpio/gpio/42/value
$

`sprintf` is terribly unsafe, though. Better use `snprintf` or `asprintf`. — Fred Foo, Jun 17 '13 at 16:15

score 4 · Answer 2 · answered Jun 17 '13 at 16:20

You can make a function that takes two parts, allocates the space, and concatenates them. This should reduce the code duplication, while keeping your code readable:

static char *concat(const char* prefix, const char* suffix) {
    size_t len = strlen(prefix) + strlen(suffix) + 1;
    char *res = malloc(len);
    strcpy(res, prefix);
    strcat(res, suffix);
    return res;
}

Now you can use this function as follows:

char * base_path = concat(GPIO_PATH_BASE, port);
char * value_path = concat(base_path, GPIO_PATH_VALUE);
char * dir_path = concat(base_path, GPIO_PATH_DIRECTION);

score 2 · Answer 3 · answered Jun 17 '13 at 16:16

I quite like to use sprintf to generate strings like this. But that assumes that you have a reasonable maximum size that you know won't be exceeded.

Of course, that's at least a little better than sizeof(base_path), which is completely wrong.

Using malloc also seems like a bad idea for variables that aren't being visible outside the module.

If we assume that port is the correct string, something like this:

 char base_path[100]; 

 sprintf(base_path, "%s/%s", GPIO_PATH_BASE, port);

Jonathan Leffler · Accepted Answer · 2013-06-17T20:25:03.987

If your system supports it, then asprintf() is the easiest mechanism:

#define GPIO_PATH_BASE      "/sys/class/gpio/gpio"
#define GPIO_PATH_DIRECTION "/direction"
#define GPIO_PATH_VALUE     "/value"

int open_gpio(const char * port)
{
    char *base_path  = asprintf("%s%s", GPIO_PATH_BASE, port);
    char *value_path = asprintf("%s%s", base_path, GPIO_PATH_VALUE);
    char *dir_path   = asprintf("%s%s", base_path, GPIO_PATH_DIRECTION);
    //...do some work with these...or return them...
    //...should check for failed allocations, too...
}

If your system doesn't support asprintf(), you can 'fake' it with:

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>

/* Should be in a header */
#ifndef HAVE_ASPRINTF
extern int asprintf(char **ret, const char *format, ...);
extern int vasprintf(char **ret, const char *format, va_list args);
#endif

#ifndef HAVE_ASPRINTF

int vasprintf(char **ret, const char *format, va_list args)
{
    va_list copy;
    va_copy(copy, args);

    /* Make sure return pointer is determinate */
    *ret = 0;

    int count = vsnprintf(NULL, 0, format, args);
    if (count >= 0)
    {
        char* buffer = malloc(count + 1);
        if (buffer != NULL)
        {
            count = vsnprintf(buffer, count + 1, format, copy);
            if (count < 0)
            {
                free(buffer);
                buffer = 0;
            }
            *ret = buffer;
        }
    }

    va_end(copy);

    return count;
}

int asprintf(char **ret, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    int count = vasprintf(ret, format, args);
    va_end(args);
    return(count);
}

#endif /* HAVE_ASPRINTF */

What is the best way to generate a path in C?

4 Answers4