ArraKISS
μ | 📰 | | 📧 |

    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