LCOV - code coverage report
Current view: directory - toolkit/crashreporter/google-breakpad/src/client/linux/minidump_writer - directory_reader.h (source / functions) Found Hit Coverage
Test: app.info Lines: 23 0 0.0 %
Date: 2012-06-02 Functions: 3 0 0.0 %

       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_syscall_support.h"
      41                 : 
      42                 : namespace google_breakpad {
      43                 : 
      44                 : // A class for enumerating a directory without using diropen/readdir or other
      45                 : // functions which may allocate memory.
      46                 : class DirectoryReader {
      47                 :  public:
      48               0 :   DirectoryReader(int fd)
      49                 :       : fd_(fd),
      50               0 :         buf_used_(0) {
      51               0 :   }
      52                 : 
      53                 :   // Return the next entry from the directory
      54                 :   //   name: (output) the NUL terminated entry name
      55                 :   //
      56                 :   // Returns true iff successful (false on EOF).
      57                 :   //
      58                 :   // After calling this, one must call |PopEntry| otherwise you'll get the same
      59                 :   // entry over and over.
      60               0 :   bool GetNextEntry(const char** name) {
      61                 :     struct kernel_dirent* const dent =
      62               0 :       reinterpret_cast<kernel_dirent*>(buf_);
      63                 : 
      64               0 :     if (buf_used_ == 0) {
      65                 :       // need to read more entries.
      66               0 :       const int n = sys_getdents(fd_, dent, sizeof(buf_));
      67               0 :       if (n < 0) {
      68               0 :         return false;
      69               0 :       } else if (n == 0) {
      70               0 :         hit_eof_ = true;
      71                 :       } else {
      72               0 :         buf_used_ += n;
      73                 :       }
      74                 :     }
      75                 : 
      76               0 :     if (buf_used_ == 0 && hit_eof_)
      77               0 :       return false;
      78                 : 
      79               0 :     assert(buf_used_ > 0);
      80                 : 
      81               0 :     *name = dent->d_name;
      82               0 :     return true;
      83                 :   }
      84                 : 
      85               0 :   void PopEntry() {
      86               0 :     if (!buf_used_)
      87               0 :       return;
      88                 : 
      89                 :     const struct kernel_dirent* const dent =
      90               0 :       reinterpret_cast<kernel_dirent*>(buf_);
      91                 : 
      92               0 :     buf_used_ -= dent->d_reclen;
      93               0 :     memmove(buf_, buf_ + dent->d_reclen, buf_used_);
      94                 :   }
      95                 : 
      96                 :  private:
      97                 :   const int fd_;
      98                 :   bool hit_eof_;
      99                 :   unsigned buf_used_;
     100                 :   uint8_t buf_[sizeof(struct kernel_dirent) + NAME_MAX + 1];
     101                 : };
     102                 : 
     103                 : }  // namespace google_breakpad
     104                 : 
     105                 : #endif  // CLIENT_LINUX_MINIDUMP_WRITER_DIRECTORY_READER_H_

Generated by: LCOV version 1.7