if (ret == 0) { // function GetTempFileName fails
        LOG.error("mkTempFileName: error in GetTempFileName");
        return 0;
    }
    return toMultibyte(tmpFileName);
}


size_t fgetsize(FILE *f)
{
    size_t size;

    fseek(f, 0, SEEK_END);
    size=ftell(f);
    fseek(f, 0, SEEK_SET);
    return size;
}

bool readFile(const char* path, char **message, size_t *len, bool binary)
{
    FILE *f;
    size_t msglen=0;
    char *msg=0;
    const char *mode = binary ? "rb" : "r" ;

    f = fopen(path, mode);
    if ( !f ) {
        return false;
    }
    msglen = fgetsize(f);
    msg = new char[msglen+1];
    memset(msg, 0, msglen);

    *len=fread(msg, sizeof(char), msglen, f);
    if(ferror(f)){
        delete [] msg;
        return false;
    }
    fclose(f);

    // Set return parameters
    *message= msg ;
    *len=msglen;

    return true;
}


bool saveFile(const char *filename,
              const char *buffer,
              size_t len, bool binary)
{
    const char *mode = binary ? "wb" : "w" ;
    FILE *f = fopen(filename, mode);

    if(!f) {
        return false;
    }

    if (fwrite(buffer, sizeof(char), len, f) != len) {
        fclose(f);
        return false;
    }
    fclose(f);

    return true;
}


#if defined(WIN32) && !defined(_WIN32_WCE)
/// Returns a file list from a directory, as char**.
char** readDir(char* name, int *count, bool onlyCount) {

    *count = 0;
    char** fileNames = NULL;
    WIN32_FIND_DATA FileData;
    HANDLE hFind;
    DWORD dwAttrs;
    WCHAR toFind    [512];
    WCHAR szNewPath [512];
    szNewPath[0] = 0;
    bool fFinished = false;

    //
    // Get number of files
    //
    if (!onlyCount) {
        int i=0;
        readDir(name, &i, true);
        if (i>0)
            fileNames = new char*[i];
        else
            return NULL;
    }

    WCHAR* wname = toWideChar(name);
    wsprintf(toFind, TEXT("%s\\*.*"), wname);


    //
    // Get file names from dir
    //
    hFind = FindFirstFile(toFind, &FileData);
    if (hFind == INVALID_HANDLE_VALUE) {
        LOG.error("Invalid handle for retrieve files from %s", name);
        *count = 0;
        fileNames = NULL;
        goto finally;
    }
    else {
        while (!fFinished) {
            wsprintf(szNewPath, TEXT("%s/%s"), wname, FileData.cFileName);
            dwAttrs = GetFileAttributes(szNewPath);

             if (   (dwAttrs & FILE_ATTRIBUTE_DIRECTORY)
                 || (dwAttrs & FILE_ATTRIBUTE_HIDDEN)
                 || (dwAttrs & FILE_ATTRIBUTE_SYSTEM) ) {
             }// nothing
             else {
                 if (!onlyCount) {
                    fileNames[*count] = toMultibyte(FileData.cFileName);
                 }
                (*count) ++;
            }

            if (!FindNextFile(hFind, &FileData)) {
			    if (GetLastError() == ERROR_NO_MORE_FILES){
				    fFinished = true;
			    }
		    }
	    }
        // Close the search handle.
	    FindClose(hFind);
    }

finally:
    if (wname) {
        delete [] wname;
        wname = NULL;
    }
    return fileNames;
}

unsigned long getFileModTime(const char* name) {
	struct _stat buffer;
	return _stat(name, &buffer) ? 0 : (unsigned long)buffer.st_mtime;
}


#else
// TBD: dummy implementation!
char** readDir(char* name, int *count, bool onlyCount) {
    return NULL;
}
#endif   // #if defined(WIN32) && !defined(_WIN32_WCE)




static int findCodePage(const char *encoding)
{
    if (encoding){
        for(int i=0; encodings[i].name; i++) {
            if(_stricmp(encodings[i].name, encoding) == 0) {
                // Found
                return encodings[i].codepage_id;
            }
        }
        // Not found
        sprintf(logmsg, "Invalid encoding: %s", encoding);
        LOG.error(logmsg);
    }
    // Default encoding
    return CP_UTF8;
}

static size_t getLenEncoding(const WCHAR* s, int codepage)
{
    if (!s)
        return 0;

    int len = wcslen(s);

    if (!len)
        return 0;

    long k = WideCharToMultiByte (codepage, 0, s, len, 0, 0, 0, 0);

    return (k != 0) ? (long)k : -1;
}

size_t getLenEncoding(const WCHAR* s, const char* encoding)
{
    return getLenEncoding( s, findCodePage(encoding) );
}

char* toMultibyte(const WCHAR *wc, const char *encoding)
{
    if (!wc) {
        return NULL;
    }

    char *ret;
    size_t wlen = wcslen(wc);

    if (!wlen) {
        ret = new char[1];
        ret[0] = 0;
        return ret;
    }

    int codepage = findCodePage(encoding);
    size_t blen = getLenEncoding(wc, codepage);

    if(blen <= 0) {
        LOG.error("toMultibyte: invalid encoding");
        return NULL;
    }

    ret = new char[blen+1];

    blen = WideCharToMultiByte(codepage, 0, wc, wlen, ret, blen, 0, 0);
    ret[blen] = 0;

    return ret;
}

WCHAR* toWideChar(const char *mb, const char *encoding) {

    if (mb == NULL) {
        return NULL;
    }

    unsigned long dsize = strlen(mb);
    WCHAR *ret = new WCHAR[dsize+2];
    memset(ret, 0, (dsize + 1)*sizeof(WCHAR));

    if (!dsize)
        return ret;

    int codepage = findCodePage(encoding);
    unsigned long k = 0;

    k = MultiByteToWideChar(codepage, 0, mb, -1, ret, dsize + 1);
    if( !k ) {
        LOG.error("toWideChar: error %d \n\tConverting: %s\n\tWith encoding %s",
            GetLastError(), mb, encoding);
        LOG.error("toWideChar: try to use default codepage.");
        k = MultiByteToWideChar(CP_UTF8, 0, mb, -1, ret, dsize + 1);
        if( !k ){
            LOG.error("toWideChar: error %d converting the string using default codepage.");
            delete [] ret; ret = 0;
        }
    }

    return ret;
}



#if defined(WIN32) && !defined(_WIN32_WCE)
// ----------------------------------------------------
// REDEFINITION OF NEW / DELETE -> debug for memory leaks
//
// WARNING: this sloooooowwwwssss doooowwwwnnnn things!
// ----------------------------------------------------
#ifdef MALLOC_DEBUG

    //
    // This is required since in debug mode, new is rewritten
    // as new(__FILE__, __LINE__). See utils.h for details
    //
    #undef new
    #include "base/memTracker.h"

    MemTracker m = MemTracker(TRUE);


    void *operator new(size_t s, char* file, int line) {
        void* p = malloc(s);

        //fprintf(stderr, "new - p:%lx s:%ld, %s:%d\n", p, s, file, line);
        if (m.isMemTracking()) {
            m.disableMemTracker();
		    m.addTrack((DWORD)p, s, file, line);
            m.enableMemTracker();
        }

        return p;
    }

    void *operator new(size_t s) {
        return ::operator new(s, "", 0);
    }

    void *operator new[](size_t s) {
        return ::operator new(s, "", 0);
    }

    void *operator new[](size_t s, char* file, int line) {
        return ::operator new(s, file, line);
    }

    void operator delete(void* p) {

        //fprintf(stderr, "delete - p:%lx\n", (long)p);
        if (m.isMemTracking()) {
            m.disableMemTracker();
		    m.removeTrack((DWORD)p);
            m.enableMemTracker();
        }

        if (p) {
            free(p);
        }
    }

    void operator delete[] (void* p) {
        ::operator delete(p);
    }


    void printMemLeaks() {
        if (m.isMemTracking())
            m.dumpUnfreed();
    }

#endif  // #ifdef MALLOC_DEBUG
#endif  // #if defined(WIN32) && !defined(_WIN32_WCE)