| /* |
| * 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; |
| HANDLE handle; |
| int index; |
| |
| filespec = (char*)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; |
| |
| handle = FindFirstFile(filespec, &(dirp->fileinfo)); |
| if (handle == INVALID_HANDLE_VALUE) |
| { |
| DWORD dwErr = GetLastError(); |
| if (dwErr == ERROR_FILE_NOT_FOUND || dwErr == ERROR_PATH_NOT_FOUND |
| || dwErr == ERROR_NO_MORE_FILES || dwErr == ERROR_NOT_READY) |
| { |
| errno = dwErr; |
| dirp->finished = 1; |
| } |
| else |
| { |
| free(dirp); |
| free(filespec); |
| errno = dwErr; |
| 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(FindNextFile(_dirp->handle, &(_dirp->fileinfo)) == 0) |
| { |
| _dirp->finished = 1; |
| return NULL; |
| } |
| } |
| _dirp->offset++; |
| |
| strcpy(_dirp->dent.d_name, _dirp->fileinfo.cFileName); /*, _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(FindNextFile(_dirp->handle, &(_dirp->fileinfo)) < 0) |
| { |
| _dirp->finished = 1; |
| *__result = NULL; |
| return -1; |
| } |
| } |
| _dirp->offset++; |
| |
| strcpy(_dirp->dent.d_name, _dirp->fileinfo.cFileName); /*, _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; |
| HANDLE 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, "/*"); |
| |
| handle = FindFirstFile(filespec, &(dirp->fileinfo)); |
| if(handle == INVALID_HANDLE_VALUE) |
| { |
| DWORD dwErr = GetLastError(); |
| if (dwErr == ERROR_FILE_NOT_FOUND || dwErr == ERROR_PATH_NOT_FOUND |
| || dwErr == ERROR_NO_MORE_FILES || dwErr == ERROR_NOT_READY) |
| { |
| 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; |
| } |