Пример #1
0
/**
 * Calls a callback on each entry in the directory.
 * Returns number of directory entries read, 0 if directory 
 * was empty, -1 if error occurs of callback function returns False. 
 * The current and parent directories ("." and "..") are not included 
 * in the count, and callback is not invoked on those directory entries 
 * because these are always valid file names in any directory.
 */
int FILE_List(Str dir, FileListCB cb, void * ctx) 
{
    int n = -1;
    StrBuf64 pattern;
    STRBUF_InitBufXXX(&pattern);
    if (!dir || !dir[0]) dir = TEXT(".");
    if (STRBUF_Copy(&pattern.sb, dir) && 
        STRBUF_Append(&pattern.sb, TEXT("\\*.*"))) {
        WIN32_FIND_DATA data;
        HANDLE hfind = FindFirstFile(pattern.sb.s, &data);
        if (hfind != INVALID_HANDLE_VALUE) {
            Str fname = data.cFileName;
            n = 0;
            do {
                if (StrCmp(fname, TEXT(".")) && 
                    StrCmp(fname, TEXT(".."))) {
                    if (cb && !(*cb)(dir, fname, ctx)) {
                        n = -1;
                        break;
                    }
                    n++;
                }
            } while (FindNextFile(hfind, &data));
            FindClose(hfind);
        }
    }
    STRBUF_Destroy(&pattern.sb);
    return n; 
}
Пример #2
0
/**
 * FILE_RmDir callback. Recursively destroys the directory contents
 */
STATIC Bool RmDirCB(Str dir, Str fname, void * ctx) 
{
    Bool ok = False;
    StrBuf64 path;
    UNREF(ctx);
    STRBUF_InitBufXXX(&path);
    if (STRBUF_Copy(&path.sb, dir) && 
        STRBUF_AppendChar(&path.sb, FILE_SEPARATOR_CHAR) &&
        STRBUF_Append(&path.sb, fname)) {
        ok = True;
        if (FILE_IsDir(path.sb.s)) {
            FILE_RmDir(path.sb.s, True);
        } else {
            FILE_Delete(path.sb.s);
        }
    }
    STRBUF_Destroy(&path.sb);
    return ok;
}
Пример #3
0
/**
 * Enumerates the contents of the directory.
 */
Iterator * FILE_ListDir(Str dir)
{
    Win32DirIterator * w = MEM_New(Win32DirIterator);
    if (w) {
        size_t len;
        DirIterator * di = &w->common;
        memset(w, 0, sizeof(*w));
        DIR_ItrInit(di, &dirIterator);
        if (!dir || !dir[0]) dir = TEXT(".");
        len = StrLen(dir);
        if (STRBUF_Alloc(&di->dirName, len + 4)) { 
            VERIFY(STRBUF_Copy(&di->dirName, dir));
            VERIFY(STRBUF_Append(&di->dirName, TEXT("\\*.*")));
            w->handle = FindFirstFile(di->dirName.s, &w->data);
            STRBUF_SetLength(&di->dirName, len);
            if (w->handle != INVALID_HANDLE_VALUE) {
                if (StrCmp(w->data.cFileName,TEXT(".")) && 
                    StrCmp(w->data.cFileName,TEXT(".."))) {
                    di->hasNext = True;
                } else {
                    while (FindNextFile(w->handle, &w->data)) {
                        if (StrCmp(w->data.cFileName,TEXT(".")) && 
                            StrCmp(w->data.cFileName,TEXT(".."))) {
                            di->hasNext = True;
                            break;
                        }
                    }
                }

                /* preallocate space for the file name */
                if (!di->hasNext ||
                    STRBUF_Alloc(&di->fileName, StrLen(w->data.cFileName))) {
                    return &di->itr;
                }
                FindClose(w->handle);
            }
        }
        DIR_ItrDestroy(&w->common);
        MEM_Free(w);
    }
    return NULL;
}
Пример #4
0
/**
 * Discovers all available JVMs. If no JVMs are discovered, returns NULL.
 * In addition to the standard directories, also looks in the additional
 * directories specified by the dirs array. Note that this directory list
 * replaces the default list ("jre","../jre") used by JVM_Find, it does not
 * adds new directories to the list.
 */
JVMSet * JVM_Find2(const Str dirs[], int n)
{
    JVMSet * jvms = MEM_New(JVMSet);
    if (jvms) {
        memset(jvms, 0, sizeof(*jvms));
        if (VECTOR_Init(&jvms->found, 0, JVM_VectorEquals, JVM_VectorFree)) {

            /* Look for JVMs in the Windows registry */
            JVM_Discover(jvms);

            /* Look for JVMs in the additional directories */
            if (n > 0) {
                int i;
                StrBuf sb,sb2;
                Char* baseDir = NULL;
                STRBUF_Init(&sb);
                STRBUF_Init(&sb2);
                TRACE("JNILIB: checking special directories\n");
                for (i=0; i<n; i++) {
                    Str javaHome = NULL;
                    JvmPathType pathType = JVM_GetPathType(dirs[i]);
                    if (pathType == JvmPathRelative) {
                        LPTSTR filePath;
                        TRACE1("JNILIB: relative path: %s\n",dirs[i]);
                        if (baseDir) {
                            STRBUF_Copy(&sb, baseDir);
                        } else {
                            int separator;
                            JVM_GetModuleFileName(NULL,&sb);
                            STRBUF_Replace(&sb, '/', '\\');
                            separator = STRBUF_LastIndexOf(&sb,'\\');
                            STRBUF_SetLength(&sb,separator+1);
                            baseDir = STRBUF_Dup(&sb);
                            if (!baseDir) continue;
                            TRACE1("JNILIB: base dir: %s\n",baseDir);
                        }
                        STRBUF_Append(&sb, dirs[i]);
                        STRBUF_Replace(&sb, '/', '\\');
                        STRBUF_Alloc(&sb2, STRBUF_Length(&sb));
                        sb2.len = GetFullPathName(STRBUF_Text(&sb), 
                            sb2.alloc, sb2.s, &filePath);
                        ASSERT(sb2.len && sb2.s[0]);
                        javaHome = STRBUF_Text(&sb2);
                    } else if (pathType == JvmPathAbsolute) {
                        TRACE1("JNILIB: absolute path: %s\n",dirs[i]);
                        javaHome = dirs[i];
                    } else if (pathType == JvmPathSystem) {
                        /* directory on the system drive */
                        TRACE1("JNILIB: system path: %s\n",dirs[i]);
                        STRBUF_Alloc(&sb,GetSystemDirectory(NULL,0)+1);
                        STRBUF_SetLength(&sb,GetSystemDirectory(sb.s,sb.alloc));
                        STRBUF_Clear(&sb2);
                        STRBUF_AppendChar(&sb2,STRBUF_CharAt(&sb,0));
                        STRBUF_AppendChar(&sb2,':');
                        STRBUF_Append(&sb2, dirs[i]);
                        javaHome = STRBUF_Text(&sb2);
                    } else {
                        TRACE1("JNILIB: invalid path: %s\n",dirs[i]);
                        continue;
                    }
                    if (javaHome) {
                        TRACE1("JNILIB: Java home: %s\n",javaHome);
                        if (FILE_IsDir(javaHome)) {
                            JVM* jvm = JVM_CreateDirContext(javaHome);
                            if (jvm) {
                                jvm->flags |= JVM_FLAG_SPECIAL;
                                if (JVM_Add(jvms, jvm) && !jvms->specialVM) {
                                    jvms->specialVM = jvm;
                                }
                            }
                        } else {
                            TRACE1("JNILIB: no such directory: %s\n",javaHome);
                        }
                    }
                }
                MEM_Free(baseDir);
                STRBUF_Destroy(&sb);
                STRBUF_Destroy(&sb2);
            }

            /* Did we find anything? */
            if (!VECTOR_IsEmpty(&jvms->found)) {
                JVM_Sort(jvms, JVM_DefaultSort);
                TRACE1("JNILIB: found %d JVM(s)\n",VECTOR_Size(&jvms->found));
                return jvms;
            }
            TRACE("JNILIB: found no JVMs\n, sorry");
            VECTOR_Destroy(&jvms->found);
        }
        MEM_Free(jvms);
    }
    return NULL;
}
Пример #5
0
/**
 * The same as BASE32_Encode but stores encoded data into a string buffer.
 * Does not destroy the original contents of the string buffer. The
 * Base32 string is appended to it. Returns pointer to string buffer
 * data, NULL on memory allocation failure
 */
Str BASE32_EncodeStr(const void * data, int n, StrBuf * sb, int flags)
{
    const char* encodeMap = ((flags & BASE32_LOWERCASE) ? 
        base32_lowerCaseEncodeMap : 
        base32_upperCaseEncodeMap);

    int alloc = (n/ENCODE_CHUNK_SIZE+((n%ENCODE_CHUNK_SIZE)?1:0))*
        DECODE_CHUNK_SIZE+1;

    /*
     *   +--- octet 0 ---+--- octet 1 ---+--- octet 2 ---+
     *   |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|
     *   +---------+-----+---+---------+-+-------+-------+
     *   |4 3 2 1 0|4 3 2 1 0|4 3 2 1 0|4 3 2 1 0|4 3 2 1
     *   +-0.index-+-1.index-+-2.index-+-3.index-+-4.index
     *   
     *   +--- octet 3 ---+--- octet 4 ---+
     *   |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|
     *   +-+---------+---+-----+---------+
     *    0|4 3 2 1 0|4 3 2 1 0|4 3 2 1 0|
     *   --+-5.index-+-6.index-+-7.index-+
     */

    if (STRBUF_Alloc(sb, STRBUF_Length(sb)+alloc)) {
        const char * buf = (const char *)data;
        int off;

        /* encode the bulk of the data */
        for (off=0; (off+ENCODE_CHUNK_SIZE)<=n; off+=ENCODE_CHUNK_SIZE) {
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_3(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_4(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_5(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_6(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_7(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_8(buf,off)]);
        }

        /* manage the last few bytes */
        switch (n % ENCODE_CHUNK_SIZE) {
        case 0:
            break;
        case 1:
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2_1(buf,off)]);
            break;
        case 2:
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_3(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_4_1(buf,off)]);
            break;
        case 3:
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_3(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_4(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_5_1(buf,off)]);
            break;
        case 4:
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_1(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_2(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_3(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_4(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_5(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_6(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE32_ENCODE_7_1(buf,off)]);
            break;
        }

        /* append padding characters */
        if (flags & BASE32_PAD) {
            STRBUF_Append(sb, base32_pad[n % ENCODE_CHUNK_SIZE]);
        }

        return STRBUF_Text(sb);
    }
    
    /* could not allocate memory */
    return NULL;    
}