// ----------------------------------------------------------------------------// Copyright 2006-2007, Martin D. Flynn// All rights reserved// ----------------------------------------------------------------------------//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at// // http://www.apache.org/licenses/LICENSE-2.0// // Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.//// ----------------------------------------------------------------------------// Description://  File I/O utilities //  Utilities for reading/writing files.// ---// Change History://  2006/01/04  Martin D. Flynn//     -Initial release//  2006/01/18  Martin D. Flynn//     -Added 'ioAppendFile'//  2007/01/28  Martin D. Flynn//     -WindowsCE port//     -Added 'ioCreateFile'//     -Added 'ioOpenStream', 'ioCloseStream', 'ioReadStream', 'ioWriteStream'//     -Added option for locking file i/o// ----------------------------------------------------------------------------#include "stdafx.h" // TARGET_WINCE#define SKIP_TRANSPORT_MEDIA_CHECK // only if TRANSPORT_MEDIA not used in this file #include "custom/defaults.h"#include <stdio.h>#include <string.h>#include <stdarg.h>#include <stdlib.h>#if defined(TARGET_WINCE)// already included#else#  include <unistd.h>#  include <fcntl.h>#  include <dirent.h>#  include <errno.h>#  include <termios.h>#  include <sys/stat.h>#  include <sys/types.h>#  include <sys/select.h>#  include <sys/errno.h>#endif#include "custom/log.h"#include "tools/stdtypes.h"#include "tools/strtools.h"#include "tools/io.h"// ----------------------------------------------------------------------------#if defined(TARGET_WINCE)// 'mkdir' not yet implemented on WinCE#else#  ifndef IO_mkdir//   define 'mkdir' if not defined elsewhere#    define IO_mkdir(DIR, PERM)     mkdir((DIR),(PERM))#  endif#endif// ----------------------------------------------------------------------------// uncomment to enable file access thread locking // this is only needed if the platform 'fread'/'fwrite' functions// are not thread-safe. (not fully implemented)//#define IO_THREAD_LOCK#ifdef IO_THREAD_LOCK#  include "tools/threads.h"static threadMutex_t                ioMutex;#  define IO_LOCK                   MUTEX_LOCK(&ioMutex);#  define IO_UNLOCK                 MUTEX_UNLOCK(&ioMutex);#else#  define IO_LOCK#  define IO_UNLOCK#endif// ----------------------------------------------------------------------------/* initialization */void ioInitialize(){#if defined(IO_THREAD_LOCK)    /* create mutex */    threadMutexInit(&ioMutex);#endif}// ----------------------------------------------------------------------------#if defined(TARGET_WINCE)// not supported#else/* turn off buffering on stdin */void ioResetSTDIN(){    // turn off buffering    struct termios options;    //setvbuf(stdin, 0/*(char*)malloc(200)*/, _IONBF, 0); // [MALLOC]    fcntl(STDIN_FILENO, F_SETFL, 0);    tcgetattr(STDIN_FILENO, &options);    options.c_lflag &= ~ECHO;    options.c_lflag &= ~ICANON;    tcsetattr(STDIN_FILENO, TCSANOW, &options);}#endif// ----------------------------------------------------------------------------#if defined(TARGET_WINCE)// not supported#else/* turn off buffering on stdout */void ioResetSTDOUT(){    // turn off buffering    struct termios options;    //setvbuf(stdout, (char*)malloc(1), _IOFBF, 1); // [MALLOC]    setvbuf(stdout, 0, _IONBF, 0);    fcntl(STDOUT_FILENO, F_SETFL, 0);    tcgetattr(STDOUT_FILENO, &options);    options.c_lflag &= ~ICANON;    tcsetattr(STDOUT_FILENO, TCSANOW, &options);}#endif// ----------------------------------------------------------------------------/* return true if specified name exists */utBool ioExists(const char *fn){    if (fn && *fn) {#if defined(TARGET_WINCE)        wchar_t wfn[512];        strWideCopy(wfn, sizeof(wfn)/sizeof(wfn[0]), fn, -1);        //MultiByteToWideChar(CP_UTF8, 0, fn, -1, wfn, sizeof(wfn)/sizeof(wchar_t));        DWORD attr = GetFileAttributes(wfn);        return (attr != 0xFFFFFFFFL)? utTrue : utFalse;#else        struct stat buf;        int rtn = stat(fn, &buf);        return (rtn == 0)? utTrue : utFalse;#endif    } else {        return utFalse;    }}/* return true if specified name is a file */utBool ioIsFile(const char *fn){    if (fn && *fn) {#if defined(TARGET_WINCE)        wchar_t wfn[512];        strWideCopy(wfn, sizeof(wfn)/sizeof(wfn[0]), fn, -1);        //MultiByteToWideChar(CP_UTF8, 0, fn, -1, wfn, sizeof(wfn)/sizeof(wchar_t));        DWORD attr = GetFileAttributes(wfn);        return ((attr != 0xFFFFFFFFL) && ((attr & FILE_ATTRIBUTE_DIRECTORY) == 0x0))? utTrue : utFalse;#else        struct stat buf;        int rtn = stat(fn, &buf);        return (rtn == 0)? S_ISREG(buf.st_mode) : utFalse;#endif    } else {        return utFalse;    }}/* return true if specified name is a file */utBool ioIsDirectory(const char *fn){    if (fn && *fn) {#if defined(TARGET_WINCE)        wchar_t wfn[512];        strWideCopy(wfn, sizeof(wfn)/sizeof(wfn[0]), fn, -1);        DWORD attr = GetFileAttributes(wfn);        return ((attr != 0xFFFFFFFFL) && ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0x0))? utTrue : utFalse;#else        struct stat buf;        int rtn = stat(fn, &buf);        return (rtn == 0)? S_ISDIR(buf.st_mode) : utFalse;#endif    } else {        return utFalse;    }}// ----------------------------------------------------------------------------/* read file list from directory */int ioReadDir(const char *dirName, char *buf, int bufLen, char *file[], int fileLen){        /* no place to store the list of files? */    if (!buf || (bufLen < 5) || !file || (fileLen < 1)) {        logERROR(LOGSRC,"Invalid parameters ...");        return 0;    }        /* file count */    int fileNdx = 0, bufNdx = 0;#if defined(TARGET_LINUX) || defined(TARGET_CYGWIN)    // open directory     DIR *dir = opendir(dirName);    if (!dir) {        logERROR(LOGSRC,"Unable to open dir %s", dirName);        return -1;    }        // read directory contents    while (utTrue) {        struct dirent *de = readdir(dir);        if (!de) {            // no more directory entries?            break;         }        char *name = de->d_name;        if (!strEquals(name,".") && !strEquals(name,"..")) {            //logINFO(LOGSRC,"Found: %s", de->d_name);            int nameLen = strlen(name);            if ((bufNdx + nameLen + 1) >= bufLen) {                break; // buffer overflow            }            strcpy(&buf[bufNdx], name);            file[fileNdx++] = &buf[bufNdx];            bufNdx += (nameLen + 1);            if (fileNdx >= fileLen) {                break; // file list overflow            }        }    }        // close directory    if (closedir(dir)) {        logERROR(LOGSRC,"I/O closedir");    }    #elif defined(TARGET_WINCE)    // open directory     WIN32_FIND_DATA FileData;    TCHAR wszDir[MAX_PATH + 1];    strWideCopy(wszDir, sizeof(wszDir)-3, dirName, -1);    wcscat(wszDir, L"\\*");    HANDLE hList = FindFirstFile(wszDir, &FileData);    if (hList == INVALID_HANDLE_VALUE) {        logERROR(LOGSRC,"Unable to open dir %s", dirName);        return -1;    }        // read directory contents    while (utTrue) {        TCHAR *name = FileData.cFileName;        if ((wcscmp(name,L".")==0) && (wcscmp(name,L"..")==0)) {            logINFO(LOGSRC,"Found: %ls", name);            int nameLen = wcslen(name);            if ((bufNdx + nameLen + 1) >= bufLen) {                break; // buffer overflow            }            sprintf(&buf[bufNdx], "%ls", name); // wide to narrow copy            file[fileNdx++] = &buf[bufNdx];            bufNdx += (nameLen + 1);            if (fileNdx >= fileLen) {                break; // file list overflow            }        }        if (!FindNextFile(hList, &FileData)) {            break;        }    }        // close directory    FindClose(hList); // ignore any returned errors#else#   warning 'ioReadDir' not supported on this platform#endif    /* return count */    return fileNdx;}// ----------------------------------------------------------------------------/* return size of file name */long ioGetFileSize(const char *fn, int fd){#if defined(TARGET_WINCE)    if (fn && *fn) {        wchar_t wfn[512];        strWideCopy(wfn, sizeof(wfn)/sizeof(wfn[0]), fn, -1);        HANDLE fh = CreateFile(wfn, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);        if (fh != INVALID_HANDLE_VALUE) {            DWORD fileSize = GetFileSize(fh, NULL);            CloseHandle(fh);            if (fileSize != INVALID_FILE_SIZE) {                return (long)fileSize;            } else {                DWORD err = GetLastError();                logWARNING(LOGSRC,"Unable to get file size: %ls [%lu]", wfn, err);                return -1L;            }        } else {            return -1L;        }    } else    if (fd >= 0) {        // not yet supported        logERROR(LOGSRC,"'ioGetFileSize' (with fd) not yet implemented");        return -1L;    } else {        return -1L;    }#else    struct stat buf;    int rtn = -1; // ERROR    if (fn && *fn) {        rtn = stat(fn, &buf);    } else    if (fd >= 0) {        rtn = fstat(fd, &buf);    }    return (rtn == 0)? buf.st_size : -1L;#endif}// ----------------------------------------------------------------------------utBool ioDeleteFile(const char *fn){    if (fn && *fn) {#if defined(TARGET_WINCE)        wchar_t wfn[512];        strWideCopy(wfn, sizeof(wfn)/sizeof(wfn[0]), fn, -1);        BOOL ok = DeleteFile(wfn);        return ok? utTrue : utFalse;#else        return (unlink(fn) == 0)? utTrue : utFalse;