io.c

Open DMT Client C Source code

#endif
    } else {
        return utFalse;
    }
}

// ----------------------------------------------------------------------------

/* open stream */
FILE *ioOpenStream(const char *fileName, const char *mode)
{
    // 'mode' should be one of the following:
    //  IO_OPEN_READ   ["rb"]
    //  IO_OPEN_WRITE  ["wb"]
    //  IO_OPEN_APPEND ["ab"]

    /* fileName & mode specified? */
    if (!fileName || !*fileName || !mode || !*mode) {
        return (FILE*)0;
    }
    
    /* mode length */
    //int modeLen = strlen(mode);
    //if (modeLen > 3) {
    //    return (FILE*)0;
    //}
    
    /* binary mode? */
    //if (mode[modeLen - 1] != 'b') {
    //    logWARNING(LOGSRC,"Opening file in ASCII text mode: %s", fileName);
    //}

    /* open file */
    FILE *file = (FILE*)0;
    IO_LOCK {
        file = fopen(fileName, mode);
    } IO_UNLOCK
    return file;
    
}

/* close stream */
void ioCloseStream(FILE *file)
{
    if (file && (file != stderr) && (file != stdout)) {
        ioFlushStream(file);
        if (fclose(file)) {
            logERROR(LOGSRC,"I/O fclose");
        }
    }
}

// ----------------------------------------------------------------------------

/* read file contents */
long ioReadStream(FILE *file, void *vData, long maxLen)
{
    
    /* invalid file handle? */
    if (!file || !vData || (maxLen < 0L)) {
        return -1L;
    }
    
    /* read data */
    UInt8 *uData = (UInt8*)vData;
    long readLen = 0L;
    IO_LOCK {
        while (readLen < maxLen) {
            long len = fread(&uData[readLen], 1, maxLen - readLen, file);
            if (len <= 0L) {
                break; // Error/EOF
            }
            readLen += len;
        }
    } IO_UNLOCK
    return readLen;

}

/* read file contents */
long ioReadFile(const char *fileName, void *data, long maxLen)
{
    
    /* invalid config file name? */
    if (!fileName || !*fileName) {
        return -1L;
    }
    
    /* open file */
    FILE *file = ioOpenStream(fileName, IO_OPEN_READ);
    if (!file) {
        // error openning
        return -1L;
    }

    /* read data */
    long len = ioReadStream(file, data, maxLen);
    ioCloseStream(file);
    if (len < 0L) {
        // error reading
        return -1L;
    }

    return len;
}

/* read line */
// Warning: this function currently does not look ahead to see if a '\n' follows a '\r'
long ioReadLine(FILE *file, char *data, long dataLen)
{
    
    /* no data buffer? */
    if (!data || (dataLen <= 0L)) {
        return -1L;
    }
    data[0] = 0; // pre-terminate
    
    /* invalid file? */
    if (!file) {
        return -1L;
    }
    
    /* read until '\r' or '\n' */
    long d = 0;
    for (;;) {
        
        /* read character */
        char ch;
        long len = ioReadStream(file, &ch, 1);
        if (len < 0L) {
            // error reading
            data[d] = 0; // terminate what we've already read
            return -1L;
        } else 
        if (len == 0L) {
            // EOF
            break;
        }
        
        /* check EOL */
        if (ch == '\n') {
            // checking for existing characters in the buffer avoids sending blank lines 
            // should the records be terminated with CR pairs
            if (d > 0) {
                break; // data is present, return
            }
        } else
        if (ch == '\r') {
            break;
        } else {
            if (d < dataLen - 1L) {
                // at most 'dataLen' characters are saved in the buffer
                data[d++] = ch;
            }
        }
        
    }
    
    /* terminate data and return length */
    data[d] = 0;
    return d;

}

// ----------------------------------------------------------------------------

/* write file contents */
long ioWriteStream(FILE *file, const void *data, long dataLen)
{
    
    /* invalid file handle? */
    if (!file || (dataLen < 0L)) {
        return -1L;
    }
    
    /* write to stream */
    long len = 0L;
    IO_LOCK {
        len = fwrite(data, 1, dataLen, file);
    } IO_UNLOCK
    if (len < 0) {
        // error writing
        return -1L;
    }
    return len;

}

/* flush stream */
void ioFlushStream(FILE *file)
{
    if (file) {
        if (fflush(file)) { 
            logERROR(LOGSRC,"I/O fflush");
        }
    }
}

/* write file contents */
long ioWriteFile(const char *fileName, const void *data, long dataLen)
{
    
    /* invalid config file name? */
    if (!fileName || !*fileName) {
        return -1L;
    }

    /* open file */
    FILE *file = ioOpenStream(fileName, IO_OPEN_WRITE);
    if (!file) {
        // error openning
        return -1L;
    }
    
    /* write to file */
    long len = ioWriteStream(file, data, dataLen);
    ioCloseStream(file);
    if (len < 0) {
        // error writing
        return -1L;
    }
    
    /* return number of bytes written */
    return len;

}

/* append to file contents */
long ioAppendFile(const char *fileName, const void *data, long dataLen)
{
    
    /* invalid config file name? */
    if (!fileName || !*fileName) {
        return -1L;
    }
    
    /* open file */
    FILE *file = ioOpenStream(fileName, IO_OPEN_APPEND);
    if (!file) {
        // error openning
        return -1L;
    }
    
    /* write to file */
    long len = ioWriteStream(file, data, dataLen);
    ioCloseStream(file);
    if (len < 0) {
        // error writing
        return -1L;
    }
    
    /* return number of bytes written */
    return len;

}

// ----------------------------------------------------------------------------

/* create file with specified pre-allocated size */
long ioCreateFile(const char *fileName, long fileSize)
{
    
    /* invalid config file name? */
    if (!fileName || !*fileName || (fileSize < 0L)) {
        return -1L;
    }

    /* open file */
    FILE *file = ioOpenStream(fileName, IO_OPEN_WRITE);
    if (!file) {
        // error openning
        return -1L;
    }
    
    /* write to file */
    UInt8 buf[1024];
    long size = 0L;
    while (size < fileSize) {
        long wrtLen = ((fileSize - size) > sizeof(buf))? sizeof(buf) : (fileSize - size);
        long len = ioWriteStream(file, buf, wrtLen);
        if (len < 0) {
            break;
        }
        size += len;
    }
    ioCloseStream(file);

    /* return size */
    if (size < fileSize) {
        // error writing
        ioDeleteFile(fileName);
        return -1L;
    } else {
        // return number of bytes written
        return size;
    }

}

// ----------------------------------------------------------------------------

#if defined(TARGET_WINCE)
utBool ioMakeDirs(const char *dirs, utBool omitLast)
{
    // not yet supported
    logERROR(LOGSRC,"'ioMakeDirs' not yet supported on WindowsCE platform");
    return utFalse;
}
#else
#define IS_DIR_SEP(C)   (((C) == '/') || ((C) == '\\'))
utBool ioMakeDirs(const char *dirs, utBool omitLast)
{
    char path[256], *p = path;
    const char *d = dirs;
    
    /* first character must be a '/' */
    if (!IS_DIR_SEP(*d)) {
        return utFalse;
    }
    
    /* scan through directories to attempt creating each one */
    *p++ = *d++; // copy first '/'
    for (;;d++) {
        utBool mkd = (IS_DIR_SEP(*d) || ((*d == 0) && !omitLast))? utTrue : utFalse;
        if (mkd) {
            // end of directory name reached in 'dirs'
            if (IS_DIR_SEP(*(p - 1))) {
                // found an empty directory [ie. "//"]
            } else {
                *p = 0; // terminate
                //logDEBUG(LOGSRC,"Making dir: %s\n", path);
                int status = IO_mkdir(path, 0777);
                if ((status != 0) && (errno != EEXIST)) {
                    return utFalse;
                }
                if (*d != 0) {
                    *p++ = *d; // copy '/'
                }
            }
        } else {
            if (*d != 0) {
                *p++ = *d; // copy dir character
            }
        }
        if (*d == 0) { 
            break;
        }
    }
    
    return utTrue;
}
#endif

// ----------------------------------------------------------------------------