Exemplo n.º 1
0
STATIC IElement DIR_ItrNext(Iterator * itr)
{
    Win32DirIterator * w = CAST(itr,Win32DirIterator,common.itr);
    DirIterator * di = &w->common;

    /* this must succeed because we have preallocated the memory */
    VERIFY(STRBUF_Copy(&di->fileName, w->data.cFileName));
    if (w->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        di->entry.type = DTypeDir;
    } else {
        di->entry.type = DTypeFile;
    }

    /* find the next entry */
    di->hasNext = False;
    while (FindNextFile(w->handle, &w->data)) {
        if (StrCmp(w->data.cFileName,TEXT(".")) && 
            StrCmp(w->data.cFileName,TEXT(".."))) {
            /* preallocate space for the file name */
            if (STRBUF_Alloc(&di->fileName, StrLen(w->data.cFileName))) {
                di->hasNext = True;
            }
            break;
        }
    }

    di->entry.dir = STRBUF_Text(&di->dirName);
    di->entry.name = STRBUF_Text(&di->fileName);
    return &di->entry;
}
Exemplo n.º 2
0
Bool DIR_ItrRemove(Iterator * itr)
{
    Bool ok = False;
    DirIterator * di = CAST(itr,DirIterator,itr);
    DirType type = di->entry.type;
    size_t dirlen = STRBUF_Length(&di->dirName);
    if (STRBUF_Alloc(&di->dirName, dirlen+STRBUF_Length(&di->fileName)+1)) {
        Str fullName;
        Bool isDir;
        STRBUF_AppendChar(&di->dirName, FILE_SEPARATOR_CHAR);
        STRBUF_AppendBuf(&di->dirName, &di->fileName);
        fullName = STRBUF_Text(&di->dirName);
        if (type == DTypeUnknown) {
            isDir = FILE_IsDir(fullName);
        } else {
            isDir = BoolValue(type == DTypeDir);
        }
        if (isDir) {
            ok = FILE_RmDir(fullName, True);
        } else {
            ok = FILE_Delete(fullName);
        }
        STRBUF_SetLength(&di->dirName, dirlen);
        di->entry.dir = STRBUF_Text(&di->dirName);
    }
    return ok;
}
Exemplo n.º 3
0
/**
 * Creates a directory hierarhy.
 */
Bool FILE_MkDir(Str dir) 
{
    Bool ok = False;
    StrBuf64 entry;
    StrBuf* sb = &entry.sb;
    STRBUF_InitBufXXX(&entry);

    if (STRBUF_Copy(sb, dir)) {
        while (sb->len > 0 && FILE_IsFileSeparator(STRBUF_LastChar(sb))) {
            STRBUF_SetLength(sb, sb->len-1);
        }

        /* check if the directory already exists */
        if (FILE_IsDir(STRBUF_Text(sb)) ||
            FILE_CreateDir(STRBUF_Text(sb))) {
            ok = True;

        } else {

            /* directory does not exists, walk the hierarhy */
            int pos = 0;
            int next = 0;
            while ((next = FILE_FindSeparator(dir+pos)) >= 0) {
                STRBUF_Clear(sb);
                if (next == 0) {
                    pos++;
                    continue;
                } else {
                    if (!STRBUF_CopyN(sb,dir,pos+next) || 
                        !FILE_CreateDir(STRBUF_Text(sb))) {
                        break;
                    }
                    pos += next + 1;
                }
            }
                
            /* final test */
            if (STRBUF_Copy(sb, dir)) {
                while (sb->len && FILE_IsFileSeparator(STRBUF_LastChar(sb))) {
                    STRBUF_SetLength(sb, sb->len-1);
                }
                if (FILE_IsDir(STRBUF_Text(sb)) ||
                    FILE_CreateDir(STRBUF_Text(sb))) {
                    ok = True;
                }
            }
        }
    }

    STRBUF_Destroy(sb);
    return ok;
}
Exemplo n.º 4
0
/**
 * Parses Java version string. Also returns the number of digits in the
 * version string that have been successfully parsed. All non-parsed digits
 * are filled with zeros. The ndigits pointer may be NULL.
 */
Bool JVM_ParseVersion2(Str strVersion, JavaVersion * version, int* ndigits)
{
    int i;
    Str p = strVersion;
    StrBuf16 buf;
    STRBUF_InitBufXXX(&buf);

    memset(version, 0, sizeof(*version));
    for (i=0; i<JAVA_VERSION_SIZE; i++) {
        STRBUF_Clear(&buf.sb);
        while (*p && !IsDigit(*p)) p++;
        if (*p) {
            while (IsDigit(*p)) STRBUF_AppendChar(&buf.sb, *p++);
            if (STRBUF_Length(&buf.sb) > 0) {
                if (PARSE_Int(STRBUF_Text(&buf.sb),&(version->v[i]),10)) {
                    continue;
                }
            }
        }
        break;
    }

    if (ndigits) *ndigits = i;
    STRBUF_Destroy(&buf.sb);
    return (i >= 2);
}
Exemplo n.º 5
0
STATIC void EXPAT_EndElement(void * ctx, XML_Str tag)
{
    ExpatContext * expat = (ExpatContext *)ctx;
    if (expat->cb.endElem) {
        EXPAT_ConvertTag(&expat->sb, tag);
        (*expat->cb.endElem)(expat->ctx, STRBUF_Text(&expat->sb));
    }
}
Exemplo n.º 6
0
STATIC void EXPAT_StartElement(void * ctx, XML_Str tag, XML_Str * atts)
{
    ExpatContext * expat = (ExpatContext *)ctx;
    if (expat->cb.startElem) {
        XMLAttr aset;
        XML_Str * s = atts;

        BUFFER_Clear(&expat->buf);
        BUFFER_Clear(&expat->atts);
        while (*s) {
            wchar_t* ws;
            XML_Str xs = *s++;

            /* 
             * store offset in the vector - later will be replaces with the 
             * pointer. Cannot store the pointers now because buffer may be
             * reallocated during conversion. 
             */
            const int off = BUFFER_Size(&expat->buf)/sizeof(Char);
            BUFFER_Put(&expat->atts, &off, sizeof(off), False);

            /* Convert from UTF-8 XML_Str to Str */
            ws = STRING_ToUnicode(xs);
            if (ws) {
#ifdef UNICODE
                BUFFER_Put(&expat->buf,ws,(wcslen(ws)+1)*sizeof(ws[0]),False);
#else
                char * mb = STRING_ToMultiByte(ws);
                if (mb) {
                    BUFFER_Put(&expat->buf, mb, strlen(mb)+1, False);
                    MEM_Free(mb);
                } else {
                    BUFFER_Put(&expat->buf, xs, strlen(xs)+1, False);
                }
#endif
                MEM_Free(ws);
            }
        }

        ASSERT(!((BUFFER_Size(&expat->atts)/sizeof(int))%2));
        aset.storage = BUFFER_Access(&expat->buf);
        aset.size = BUFFER_Size(&expat->buf);
        aset.off = BUFFER_Access(&expat->atts);
        aset.n = BUFFER_Size(&expat->atts)/sizeof(int)/2;

        EXPAT_ConvertTag(&expat->sb, tag);
        (*expat->cb.startElem)(expat->ctx, STRBUF_Text(&expat->sb), &aset);
    }
}
Exemplo n.º 7
0
/**
 * The same as BASE64_Encode but stores encoded data into a string buffer.
 * Does not destroy the original contents of the string buffer. The
 * Base64 string is appended to it. Returns pointer to string buffer
 * data, NULL on memory allocation failure
 */
Str BASE64_EncodeStr(const void * data, size_t size, StrBuf * sb, int flags)
{
    const char* encodeMap = ((flags & BASE64_URLSAFE) ? 
        base64_safeEncodeMap : 
        base64_encodeMap);

    size_t alloc = ((size+2)/3)*4;
    if (STRBUF_Alloc(sb, STRBUF_Length(sb)+alloc)) {
        const char * buf = (const char *)data;
        size_t off;

        /* encode the bulk of the data */
        for (off=0; (off+3)<=size; off+=3) {
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_1(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_2(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_3(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_4(buf,off)]);
        }

        /* manage last one or two bytes */
        switch (size%3) {
        case 0:
            break;
        case 1:
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_1(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_2_1(buf,off)]);
            if (flags & BASE64_PAD) {
                STRBUF_AppendChar(sb,'=');
                STRBUF_AppendChar(sb,'=');
            }
            break;
        case 2:
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_1(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_2(buf,off)]);
            STRBUF_AppendChar(sb,encodeMap[BASE64_ENCODE_3_1(buf,off)]);
            if (flags & BASE64_PAD) STRBUF_AppendChar(sb,'=');
            break;
        }
        
        return STRBUF_Text(sb);
    }
    
    /* could not allocate memory */
    return NULL;    
}
Exemplo n.º 8
0
STATIC void EXPAT_StartElement(void * ctx, XML_Str tag, XML_Str * atts)
{
    ExpatContext * expat = (ExpatContext *)ctx;
    if (expat->cb.startElem) {
        XMLAttr aset;
        XML_Str * s = atts;

        BUFFER_Clear(&expat->buf);
        VECTOR_Clear(&expat->atts);
        while (*s) {
            Char tmp;
            const XML_Char * c = (*s);

            /* 
             * store offset in the vector - later will be replaces with the 
             * pointer. Cannot store the pointers now because buffer may be
             * reallocated during conversion. 
             */
            int off = BUFFER_Size(&expat->buf)/sizeof(Char);
            VECTOR_Add(&expat->atts,(VElement)(PtrWord)off);
            
            /*
             * Pretty naive convertion of attribute names and values from
             * XML_Str to Str. This part may need some improvement...
             */
            while (*c) {
                tmp = (Char)*c;
                BUFFER_Put(&expat->buf, &tmp, sizeof(tmp), False);
                c++;
            }
            tmp = 0;
            BUFFER_Put(&expat->buf, &tmp, sizeof(tmp), False);
            s++;
        }

        ASSERT(!(VECTOR_Size(&expat->atts)%2));
        aset.storage = (Char*)BUFFER_Access(&expat->buf);
        aset.size = BUFFER_Size(&expat->buf);
        aset.off = (int*)VECTOR_GetElements(&expat->atts);
        aset.n = VECTOR_Size(&expat->atts)/2;

        EXPAT_ConvertTag(&expat->sb, tag);
        (*expat->cb.startElem)(expat->ctx, STRBUF_Text(&expat->sb), &aset);
    }
}
Exemplo n.º 9
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;
}
Exemplo n.º 10
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;    
}