base/libs/qdecoder/qFile.c

Go to the documentation of this file.

/*
 * Copyright 2008 The qDecoder Project. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided 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 QDECODER PROJECT ``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 QDECODER PROJECT 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 <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <libgen.h>
#include <sys/stat.h>
#include <sys/file.h>
#include "qDecoder.h"
#include "qInternal.h"

bool qFileLock(int fd) {
#ifdef _WIN32
    return false;
#else
    int ret = flock(fd, LOCK_EX);
    if(ret == 0) return true;
    return false;
#endif
}

bool qFileUnlock(int fd) {
#ifdef _WIN32
    return false;
#else
    int ret = flock(fd, LOCK_EX);
    if(ret == 0) return true;
    return false;
#endif
}

bool qFileExist(const char *filepath) {
    struct stat finfo;
    if (stat(filepath, &finfo) < 0) return false;
    return true;
}

char *qFileGetName(const char *filepath) {
    char *path = strdup(filepath);
    char *bname = basename(path);
    char *filename = strdup(bname);
    free(path);
    return filename;
}

char *qFileGetDir(const char *filepath) {
    char *path = strdup(filepath);
    char *dname = dirname(path);
    char *dir = strdup(dname);
    free(path);
    return dir;
}

char *qFileGetExt(const char *filepath) {
#define MAX_EXTENSION_LENGTH        (5)
    char *filename = qFileGetName(filepath);
    char *p = strrchr(filename, '.');
    char *ext = NULL;
    if(p != NULL && strlen(p+1) <= MAX_EXTENSION_LENGTH && qStrIsAlnum(p+1) == true) {
        ext = strdup(p+1);
        qStrLower(ext);
    } else {
        ext = strdup("");
    }

    free(filename);
    return ext;
}

off_t qFileGetSize(const char *filepath) {
    struct stat finfo;
    if (stat(filepath, &finfo) < 0) return -1;
    return finfo.st_size;
}

off_t qFileSend(int outfd, int infd, off_t nbytes) {
#define MAX_FILESEND_CHUNK_SIZE     (32 * 1024)
    if(nbytes == 0) return 0;

    char buf[MAX_FILESEND_CHUNK_SIZE];

    off_t sent = 0; // total size sent
    while(sent < nbytes) {
        size_t sendsize;    // this time sending size
        if(nbytes - sent <= sizeof(buf)) sendsize = nbytes - sent;
        else sendsize = sizeof(buf);

        // read
        ssize_t retr = read(infd, buf, sendsize);
        DEBUG("read %zd", retr);
        if (retr <= 0) {
            if(sent == 0) return -1;
            break;
        }

        // write
        ssize_t retw = _q_write(outfd, buf, retr);
        DEBUG("write %zd", retw);
        if(retw <= 0) {
            if(sent == 0) return -1;
            break;
        }

        sent += retw;
        if(retr != retw) {
            DEBUG("size mismatch %zd, %zd", retr, retw);
            break;
        }
    }

    return sent;
}

void *qFileLoad(const char *filepath, size_t *nbytes) {
    int fd;
    if((fd = open(filepath, O_RDONLY, 0)) < 0) return NULL;

    struct stat fs;
    if (fstat(fd, &fs) < 0) {
        close(fd);
        return NULL;
    }

    size_t size = fs.st_size;
    if(nbytes != NULL && *nbytes > 0 && *nbytes < fs.st_size) size = *nbytes;

    void *buf = malloc(size + 1);
    if(buf == NULL) {
        close(fd);
        return NULL;
    }

    ssize_t count = read(fd, buf, size);
    close(fd);

    if (count != size) {
        free(buf);
        return NULL;
    }

    ((char*)buf)[count] = '\0';

    if(nbytes != NULL) *nbytes = count;
    return buf;
}

void *qFileRead(FILE *fp, size_t *nbytes) {
    size_t memsize;
    size_t c_count;
    size_t size = 0;
    char *data = NULL;

    if(nbytes != NULL && *nbytes > 0) size = *nbytes;

    int c;
    for (memsize = 1024, c_count = 0; (c = fgetc(fp)) != EOF;) {
        if(size > 0 && c_count == size) break;

        if (c_count == 0) {
            data = (char*)malloc(sizeof(char) * memsize);
            if (data == NULL) {
                DEBUG("Memory allocation failed.");
                return NULL;
            }
        } else if (c_count == memsize - 1) {
            memsize *= 2;

            /* Here, we do not use realloc(). Because sometimes it is unstable. */
            char *datatmp = (char*)malloc(sizeof(char) * (memsize + 1));
            if (datatmp == NULL) {
                DEBUG("Memory allocation failed.");
                free(data);
                return NULL;
            }
            memcpy(datatmp, data, c_count);
            free(data);
            data = datatmp;
        }
        data[c_count++] = (char)c;
    }

    if (c_count == 0 && c == EOF) return NULL;
    data[c_count] = '\0';

    if(nbytes != NULL) *nbytes = c_count;

    return (void*)data;
}

char *qFileReadLine(FILE *fp) {
    int memsize;
    int c, c_count;
    char *string = NULL;

    for (memsize = 1024, c_count = 0; (c = fgetc(fp)) != EOF;) {
        if (c_count == 0) {
            string = (char *)malloc(sizeof(char) * memsize);
            if (string == NULL) {
                DEBUG("Memory allocation failed.");
                return NULL;
            }
        } else if (c_count == memsize - 1) {
            char *stringtmp;

            memsize *= 2;

            /* Here, we do not use realloc(). Because sometimes it is unstable. */
            stringtmp = (char *)malloc(sizeof(char) * (memsize + 1));
            if (stringtmp == NULL) {
                DEBUG("Memory allocation failed.");
                free(string);
                return NULL;
            }
            memcpy(stringtmp, string, c_count);
            free(string);
            string = stringtmp;
        }
        string[c_count++] = (char)c;
        if ((char)c == '\n') break;
    }

    if (c_count == 0 && c == EOF) return NULL;
    string[c_count] = '\0';

    return string;
}

ssize_t qFileSave(const char *filepath, const void *buf, size_t size, bool append) {
    int fd;

    if(append == false) fd = open(filepath, O_CREAT|O_WRONLY|O_TRUNC, DEF_FILE_MODE);
    else fd = open(filepath, O_CREAT|O_WRONLY|O_APPEND, DEF_FILE_MODE);
    if(fd < 0) return -1;

    ssize_t count = write(fd, buf, size);
    close(fd);

    return count;
}

---