Line data    Source code

       1             : // Copyright (c) 2009, Google Inc.
       2             : // All rights reserved.
       3             : //
       4             : // Redistribution and use in source and binary forms, with or without
       5             : // modification, are permitted provided that the following conditions are
       6             : // met:
       7             : //
       8             : //     * Redistributions of source code must retain the above copyright
       9             : // notice, this list of conditions and the following disclaimer.
      10             : //     * Redistributions in binary form must reproduce the above
      11             : // copyright notice, this list of conditions and the following disclaimer
      12             : // in the documentation and/or other materials provided with the
      13             : // distribution.
      14             : //     * Neither the name of Google Inc. nor the names of its
      15             : // contributors may be used to endorse or promote products derived from
      16             : // this software without specific prior written permission.
      17             : //
      18             : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      19             : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      20             : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      21             : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      22             : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      23             : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      24             : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      25             : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      26             : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      27             : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      28             : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      29             : 
      30             : #ifndef CLIENT_LINUX_MINIDUMP_WRITER_DIRECTORY_READER_H_
      31             : #define CLIENT_LINUX_MINIDUMP_WRITER_DIRECTORY_READER_H_
      32             : 
      33             : #include <stdint.h>
      34             : #include <unistd.h>
      35             : #include <limits.h>
      36             : #include <assert.h>
      37             : #include <errno.h>
      38             : #include <string.h>
      39             : 
      40             : #include "common/linux/linux_libc_support.h"
      41             : #include "third_party/lss/linux_syscall_support.h"
      42             : 
      43             : namespace google_breakpad {
      44             : 
      45             : // A class for enumerating a directory without using diropen/readdir or other
      46             : // functions which may allocate memory.
      47             : class DirectoryReader {
      48             :  public:
      49           0 :   DirectoryReader(int fd)
      50           0 :       : fd_(fd),
      51           0 :         buf_used_(0) {
      52           0 :   }
      53             : 
      54             :   // Return the next entry from the directory
      55             :   //   name: (output) the NUL terminated entry name
      56             :   //
      57             :   // Returns true iff successful (false on EOF).
      58             :   //
      59             :   // After calling this, one must call |PopEntry| otherwise you'll get the same
      60             :   // entry over and over.
      61           0 :   bool GetNextEntry(const char** name) {
      62             :     struct kernel_dirent* const dent =
      63           0 :       reinterpret_cast<kernel_dirent*>(buf_);
      64             : 
      65           0 :     if (buf_used_ == 0) {
      66             :       // need to read more entries.
      67           0 :       const int n = sys_getdents(fd_, dent, sizeof(buf_));
      68           0 :       if (n < 0) {
      69           0 :         return false;
      70           0 :       } else if (n == 0) {
      71           0 :         hit_eof_ = true;
      72             :       } else {
      73           0 :         buf_used_ += n;
      74             :       }
      75             :     }
      76             : 
      77           0 :     if (buf_used_ == 0 && hit_eof_)
      78           0 :       return false;
      79             : 
      80           0 :     assert(buf_used_ > 0);
      81             : 
      82           0 :     *name = dent->d_name;
      83           0 :     return true;
      84             :   }
      85             : 
      86           0 :   void PopEntry() {
      87           0 :     if (!buf_used_)
      88           0 :       return;
      89             : 
      90             :     const struct kernel_dirent* const dent =
      91           0 :       reinterpret_cast<kernel_dirent*>(buf_);
      92             : 
      93           0 :     buf_used_ -= dent->d_reclen;
      94           0 :     my_memmove(buf_, buf_ + dent->d_reclen, buf_used_);
      95             :   }
      96             : 
      97             :  private:
      98             :   const int fd_;
      99             :   bool hit_eof_;
     100             :   unsigned buf_used_;
     101             :   uint8_t buf_[sizeof(struct kernel_dirent) + NAME_MAX + 1];
     102             : };
     103             : 
     104             : }  // namespace google_breakpad
     105             : 
     106             : #endif  // CLIENT_LINUX_MINIDUMP_WRITER_DIRECTORY_READER_H_