1.6.0/c/util/src/platforms/windows/dir_windows.c

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

#include <malloc.h>
#include <string.h>
#include <errno.h>

#include <platforms/windows/axutil_dir_windows.h>

/*dirent.h style mehtods for win32*/

AXIS2_DIR *AXIS2_CALL
axis2_opendir(
    const char *_dirname)
{
    AXIS2_DIR *dirp;
    char *filespec;
    long handle;
    int index;

    filespec = malloc(strlen(_dirname) + 2 + 1);
    strcpy(filespec, _dirname);
    index = (int) strlen(filespec) - 1;
    if (index >= 0 &&
        (filespec[index] == '/' ||
         (filespec[index] == '\\' && !IsDBCSLeadByte(filespec[index - 1]))))
        filespec[index] = '\0';
    strcat(filespec, "/*");

    dirp = (AXIS2_DIR *) malloc(sizeof(AXIS2_DIR));
    dirp->offset = 0;
    dirp->finished = 0;

    if ((handle = (long)_findfirst(filespec, &(dirp->fileinfo))) < 0)
        /* We are sure that the difference lies within the long range */
    {
        if (errno == ENOENT || errno == EINVAL)
            dirp->finished = 1;
        else
        {
            free(dirp);
            free(filespec);
            return NULL;
        }
    }
    /* We are using the ISO C++ conformant name: _strdup, as demanded by VS 2005 */
    dirp->dirname = _strdup(_dirname);
    dirp->handle = handle;
    free(filespec);

    return dirp;
}

int AXIS2_CALL
axis2_closedir(
    AXIS2_DIR * _dirp)
{
    int iret = -1;
    if (!_dirp)
        return iret;
    iret = _findclose(_dirp->handle);
    if (_dirp->dirname)
        free(_dirp->dirname);
    if (_dirp)
        free(_dirp);

    return iret;
}

struct dirent *AXIS2_CALL
axis2_readdir(
    AXIS2_DIR * _dirp)
{
    if (!_dirp || _dirp->finished)
        return NULL;

    if (_dirp->offset != 0)
    {
        if (_findnext(_dirp->handle, &(_dirp->fileinfo)) < 0)
        {
            _dirp->finished = 1;
            return NULL;
        }
    }
    _dirp->offset++;

    strcpy(_dirp->dent.d_name, _dirp->fileinfo.name);   /*, _MAX_FNAME+1); */
    _dirp->dent.d_ino = 1;
    _dirp->dent.d_reclen = (unsigned short) strlen(_dirp->dent.d_name);
    _dirp->dent.d_off = _dirp->offset;

    return &(_dirp->dent);
}

int AXIS2_CALL
axis2_readdir_r(
    AXIS2_DIR * _dirp,
    struct dirent *_entry,
    struct dirent **__result)
{
    if (!_dirp || _dirp->finished)
    {
        *__result = NULL;
        return -1;
    }

    if (_dirp->offset != 0)
    {
        if (_findnext(_dirp->handle, &(_dirp->fileinfo)) < 0)
        {
            _dirp->finished = 1;
            *__result = NULL;
            return -1;
        }
    }
    _dirp->offset++;

    strcpy(_dirp->dent.d_name, _dirp->fileinfo.name);   /*, _MAX_FNAME+1); */
    _dirp->dent.d_ino = 1;
    _dirp->dent.d_reclen = (unsigned short) strlen(_dirp->dent.d_name);
    _dirp->dent.d_off = _dirp->offset;

    memcpy(_entry, &_dirp->dent, sizeof(*_entry));

    *__result = &_dirp->dent;

    return 0;
}

int AXIS2_CALL
axis2_rewinddir(
    AXIS2_DIR * dirp)
{
    char *filespec;
    long handle;
    int index;

    _findclose(dirp->handle);

    dirp->offset = 0;
    dirp->finished = 0;

    filespec = malloc(strlen(dirp->dirname) + 2 + 1);
    strcpy(filespec, dirp->dirname);
    index = (int) (strlen(filespec) - 1);
    if (index >= 0 && (filespec[index] == '/' || filespec[index] == '\\'))
        filespec[index] = '\0';
    strcat(filespec, "/*");

    if ((handle = (long)_findfirst(filespec, &(dirp->fileinfo))) < 0)
        /* We are sure that the difference lies within the int range */
    {
        if (errno == ENOENT || errno == EINVAL)
            dirp->finished = 1;
    }
    dirp->handle = handle;
    free(filespec);

    return 0;
}

int
alphasort(
    const struct dirent **__d1,
    const struct dirent **__d2)
{
    return strcoll((*__d1)->d_name, (*__d2)->d_name);
}

int AXIS2_CALL
axis2_scandir(
    const char *_dirname,
    struct dirent **__namelist[],
    int (*selector) (const struct dirent * entry),
    int (*compare) (const struct dirent ** __d1,
                    const struct dirent ** __d2))
{
    AXIS2_DIR *dirp = NULL;
    struct dirent **vector = NULL;
    struct dirent *dp = NULL;
    int vector_size = 0;
    int nfiles = 0;

    if (__namelist == NULL)
    {
        return -1;
    }
    dirp = axis2_opendir(_dirname);
    if (!dirp)
    {
        return -1;
    }
    dp = axis2_readdir(dirp);
    while (dp)
    {
        int dsize = 0;
        struct dirent *newdp = NULL;

        if (selector && (*selector) (dp) == 0)
        {
            dp = axis2_readdir(dirp);
            continue;
        }

        if (nfiles == vector_size)
        {
            struct dirent **newv;
            if (vector_size == 0)
            {
                vector_size = 10;
            }
            else
            {
                vector_size *= 2;
            }

            newv =
                (struct dirent **) realloc(vector,
                                           vector_size *
                                           sizeof(struct dirent *));
            if (!newv)
            {
                return -1;
            }
            vector = newv;
        }

        /*dsize =
            (int) sizeof(struct dirent) +
            (int) ((strlen(dp->d_name) + 1) * sizeof(char));*/
        dsize = (int) sizeof(struct dirent);
        newdp = (struct dirent *) malloc(dsize);

        if (newdp == NULL)
        {
            while (nfiles-- > 0)
            {
                free(vector[nfiles]);
            }
            free(vector);
            return -1;
        }

        vector[nfiles++] = (struct dirent *) memcpy(newdp, dp, dsize);
        dp = axis2_readdir(dirp);
    }

    axis2_closedir(dirp);

    *__namelist = vector;

    if (compare)
    {
        qsort(*__namelist, nfiles, sizeof(struct dirent *), compare);
    }

    return nfiles;
}