libc/bionic/scandir.cpp

   1 /*
   2  * Copyright (C) 2013 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <dirent.h>
  18
  19 #include <fcntl.h>
  20 #include <errno.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24
  25 #include "private/bionic_macros.h"
  26 #include "private/ScopedReaddir.h"
  27
  28 // A smart pointer to the scandir dirent**.
  29 class ScandirResult {
  30  public:
  31   ScandirResult() : names_(nullptr), size_(0), capacity_(0) {
  32   }
  33
  34   ~ScandirResult() {
  35     while (size_ > 0) {
  36       free(names_[--size_]);
  37     }
  38     free(names_);
  39   }
  40
  41   size_t size() {
  42     return size_;
  43   }
  44
  45   dirent** release() {
  46     dirent** result = names_;
  47     names_ = nullptr;
  48     size_ = capacity_ = 0;
  49     return result;
  50   }
  51
  52   bool Add(dirent* entry) {
  53     if (size_ >= capacity_) {
  54       size_t new_capacity = capacity_ + 32;
  55       dirent** new_names =
  56           reinterpret_cast<dirent**>(realloc(names_, new_capacity * sizeof(dirent*)));
  57       if (new_names == nullptr) {
  58         return false;
  59       }
  60       names_ = new_names;
  61       capacity_ = new_capacity;
  62     }
  63
  64     dirent* copy = CopyDirent(entry);
  65     if (copy == nullptr) {
  66       return false;
  67     }
  68     names_[size_++] = copy;
  69     return true;
  70   }
  71
  72   void Sort(int (*comparator)(const dirent**, const dirent**)) {
  73     // If we have entries and a comparator, sort them.
  74     if (size_ > 0 && comparator != nullptr) {
  75       qsort(names_, size_, sizeof(dirent*),
  76             reinterpret_cast<int (*)(const void*, const void*)>(comparator));
  77     }
  78   }
  79
  80  private:
  81   dirent** names_;
  82   size_t size_;
  83   size_t capacity_;
  84
  85   static dirent* CopyDirent(dirent* original) {
  86     // Allocate the minimum number of bytes necessary, rounded up to a 4-byte boundary.
  87     size_t size = ((original->d_reclen + 3) & ~3);
  88     dirent* copy = reinterpret_cast<dirent*>(malloc(size));
  89     memcpy(copy, original, original->d_reclen);
  90     return copy;
  91   }
  92
  93   DISALLOW_COPY_AND_ASSIGN(ScandirResult);
  94 };
  95
  96 int scandirat(int parent_fd, const char* dir_name, dirent*** name_list,
  97               int (*filter)(const dirent*),
  98               int (*comparator)(const dirent**, const dirent**)) {
  99   DIR* dir = nullptr;
 100   if (parent_fd == AT_FDCWD) {
 101     dir = opendir(dir_name);
 102   } else {
 103     int dir_fd = openat(parent_fd, dir_name, O_CLOEXEC | O_DIRECTORY | O_RDONLY);
 104     if (dir_fd != -1) {
 105       dir = fdopendir(dir_fd);
 106     }
 107   }
 108
 109   ScopedReaddir reader(dir);
 110   if (reader.IsBad()) {
 111     return -1;
 112   }
 113
 114   ScandirResult names;
 115   dirent* entry;
 116   while ((entry = reader.ReadEntry()) != nullptr) {
 117     // If we have a filter, skip names that don't match.
 118     if (filter != nullptr && !(*filter)(entry)) {
 119       continue;
 120     }
 121     names.Add(entry);
 122   }
 123
 124   names.Sort(comparator);
 125
 126   size_t size = names.size();
 127   *name_list = names.release();
 128   return size;
 129 }
 130 __strong_alias(scandirat64, scandirat);
 131
 132 int scandir(const char* dir_path, dirent*** name_list,
 133             int (*filter)(const dirent*),
 134             int (*comparator)(const dirent**, const dirent**)) {
 135   return scandirat(AT_FDCWD, dir_path, name_list, filter, comparator);
 136 }
 137 __strong_alias(scandir64, scandir);