Quelques fonctions pratiques en C

Cette page sera alimentée de fonctions et extraits de code en C en guise d'aide mémoire. Ne prenez rien pour parfait, ces extraits peuvent certainement être améliorés.

ecalloc, erealloc : allocation avec gestion d'erreur

/* same thing that calloc and reallocarray but check for
 * error and exit if necessary
 */

void *
ecalloc(size_t nmemb, size_t size)
{
    void *p;

    if ((p = calloc(nmemb, size)) == NULL)
        err(1, "calloc");
    return p;
}

void *
ereallocarray(void *ptr, size_t nmemb, size_t size)
{
    if ((ptr = reallocarray(ptr, nmemb, size)) == NULL)
        err(1, "reallocarray");

    return ptr;
}

getstreamtxt: Récupérer le contenu d'un fichier ouvert

/* return text in fp
 * the fp must be closed properly after
 * the returned string is mallocated and must be freed.
 */
char *
get_stream_txt(FILE *fp)
{
    char *buf = NULL;
    size_t s;
    size_t len = 0;
    size_t bsize = 2 * BUFSIZ;

    buf = ecalloc(bsize, sizeof(char));
    while((s = fread(buf + len, 1, BUFSIZ, fp))) {
        len += s;
        if(BUFSIZ + len + 1 > bsize) {
            bsize += BUFSIZ;
            buf = ereallocarray(buf, bsize, sizeof(char));
        }
    }
    buf[len] = '\0';
    
    return(buf);
}

getcmdoutput: Récupérer la sortie d'une commande

/* return the output of cmd in an allocated
 * string created by get_stream_txt().
 * It is the caller responsibility to free it later
 */
char *
get_cmd_output(const char *cmd)
{
    FILE *fp = NULL;
    char *res = NULL;

    if ((fp = popen(cmd, "r")) == NULL)
        err(1, "%s: %s", "Error opening pipe for cmd", cmd);

    res = get_stream_txt(fp);
    if (pclose(fp) != 0)
        err(1, "%s %s", cmd, "not found or exited with error status");
    
    return res;
}

Jouons avec les strings

Quelques fonctions pour gérer les chaînes de caractères. Ici on abuse de la fonction strlcat qui s'assure que l'on termine bien une chaîne avec le fameux '\0'. Cette dernière est présente chez OpenBSD et facilement recopiable depuis leurs sources.

(v)estrlcat

/* strlcat with error handling */
size_t
estrlcat(char *dst, const char *src, size_t dstsize)
{
    size_t size;
    if ((size = strlcat(dst, src, dstsize)) >= dstsize)
        err(1, "strlcat");

    return size;
}

/* variadic strlcat
 * a call must end with NULL
 * to append "bar", "zoo", yo" to foo, call:
 * vestrlcat(foo, sizeof(foo), "bar", "zoo", "yo", NULL);
 */
size_t
vestrlcat(char *dst, size_t dstsize, ...)
{
    size_t size = 0;
    char *s;
    va_list ap;

    va_start(ap, dstsize);

    while ((s = va_arg(ap, char *)) != NULL) {
        size += estrlcat(dst, s, dstsize);
    }
    va_end(ap);

    return size;
}

mkstr

Et ma favorite qui permet de fabriquer n'importe quelle chaîne de caractères. On y passe un pointeur (qui peut être NULL au départ. Tous les arguments sont assemblés pour former une longue chaîne, cette dernière étant allouée dynamiquement au besoin.

/* 
 * Make any string 
 * add in str every argument and realloc str if necessary
 * if str is NULL, it is allocated
 * argument list **must** end with NULL
 * return str
 * str should be dynamically allocated and freed later
 * example: mkstr(&foo, "hello", " there.", NULL);
 */
char *
mkstr(char **str, ...)
{
    char *s;
    size_t len;    /* length of str at last*/
    va_list ap;
    va_list apcopy;

    va_copy(apcopy, ap);

    if (*str == NULL) {
        *str = calloc(1, sizeof(char));
        len = 0;
    } else {
        len = strlen(*str);
    }

    /* count required length */
    va_start(ap, str);
    while ((s = va_arg(ap, char *)) != NULL) {
        len += strlen(s);
    }
    va_end(ap);
    len++; /* \0 */

    *str = ereallocarray(*str, len, sizeof(char));

    /* copy */
    va_start(apcopy, str);

    while ((s = va_arg(apcopy, char *)) != NULL) {
        estrlcat(*str, s, len);
    }
    va_end(apcopy);
    return(*str);
}

trim

Comme son nom l'indique, elle vire les espaces et sauts de ligne en début et fin de chaîne. Il faut passer un pointeur vers la chaîne à modifié (et donc allouée dynamiquement).

/* return a trimmed copy of str */
/* trim(&str); */
void
trim(char **str)
{
    size_t begin = 0;
    size_t end = strlen(*str);


    while (isspace((*str)[begin])) {
        begin++;
    }

    while (isspace((*str)[end-1])) {
        end--;
    }
    for (size_t i = begin, j=0; i < end; i++, j++) {
        (*str)[j] = (*str)[i];
    }
    (*str)[end - begin] = '\0';
}

(v)esnprintf

Cette fonction fait comme snprintf avec gestion d'erreur. Il faut avoir un tableau de char déjà prêt, par exemple char s[256]. Ce code est en partie tiré de celui utilisé souvent par . Elle est très pratique car permet de définir le format des variables qu'une chaîne doit contenir. Par exemple :

esnprintf(s, sizeof(s), "%s%d%c", "blabla", 42, 'a');

static int
evsnprintf(char *str, size_t size, const char *format, va_list ap)
{
    int ret = vsnprintf(str, size, format, ap);

    if (ret < 0 || (size_t)ret >= size) {
        warn("%s", "vsnprintf: Output truncated");
    }

    return ret;
}

int
esnprintf(char *str, size_t size, const char *format, ...)
{
    va_list ap;
    int ret = 0;

    va_start(ap, format);
    ret = evsnprintf(str, size, format, ap);
    va_end(ap);

    return ret;
}

efopen, efclose, evfprintf : gestion des fichiers

On ouvre et on ferme les fichiers en gérant les erreurs

FILE *
efopen(const char *path, const char *mode)
{
    FILE *f = NULL;
    if ((f = fopen(path, mode)) == NULL)
        err(1, "%s: %s", "Fail to open", path);

    return f;
}

int
efclose(FILE *stream)
{
    int ret = 0;
    ret = fclose(stream);
    if (ferror(stream)) {
        err(1,"closefile");
    }
    return ret;
}

On écrit dans un fichier autant de choses que l'on veut en une fois. C'est comme fprint mais avec une liste d'arguments variable.

int
evfprintf(FILE *stream, const char *format, va_list ap)
{
    int ret;

    ret = vfprintf(stream, format, ap);
    if (ret < 0)
        err(1,"evfprintf:");

    return ret;
}

int
efprintf(FILE *stream, const char *format, ...)
{
    va_list ap;
    int ret;

    va_start(ap, format);
    ret = evfprintf(stream, format, ap);
    va_end(ap);

    return ret;
}

OpenBSD unveil et pledge

Deux macros pratiques et un exemple pour éviter des erreurs de compilation sur un autre système:

#define PLEDGEORDIE(prom) if (pledge(prom, NULL) == -1) { err(1, "pledge"); }
#define UNVEILORDIE(path,perms) if (unveil(path, perms) == -1) { err(1, "unveil"); }

Exemple:

#ifdef __OpenBSD__
    UNVEILORDIE(argv[1], "rwc");
    PLEDGEORDIE("stdio rpath cpath wpath exec proc");
#endif