directorycollection.cpp

Go to the documentation of this file.

/*
  Zipios -- a small C++ library that provides easy access to .zip files.

  Copyright (C) 2000-2007  Thomas Sondergaard
  Copyright (c) 2015-2022  Made to Order Software Corp.  All Rights Reserved

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#if !defined(ZIPIOS_WINDOWS) && (defined(_WINDOWS) || defined(WIN32) || defined(_WIN32) || defined(__WIN32))
#define ZIPIOS_WINDOWS
#endif

#include "zipios/directorycollection.hpp"

#include "zipios/zipiosexceptions.hpp"

#include <fstream>

#ifdef ZIPIOS_WINDOWS
#include <io.h>
#else
#include <dirent.h>
#include <errno.h>
#endif


namespace zipios
{

DirectoryCollection::DirectoryCollection()
{
}


DirectoryCollection::DirectoryCollection(
          std::string const & path
        , bool recursive)
    : m_recursive(recursive)
    , m_filepath(path)
{
    m_filename = m_filepath;
    m_valid = m_filepath.isDirectory() || m_filepath.isRegular();
}


DirectoryCollection::~DirectoryCollection()
{
    close();
}


void DirectoryCollection::close()
{
    m_entries_loaded = false;
    m_filepath.clear();

    FileCollection::close();
}


FileEntry::vector_t DirectoryCollection::entries() const
{
    loadEntries();

    return FileCollection::entries();
}


FileEntry::pointer_t DirectoryCollection::getEntry(std::string const & name, MatchPath matchpath) const
{
    loadEntries();

    return FileCollection::getEntry(name, matchpath);
}


DirectoryCollection::stream_pointer_t DirectoryCollection::getInputStream(std::string const & entry_name, MatchPath matchpath)
{
    FileEntry::pointer_t ent(getEntry(entry_name, matchpath));
    if(ent == nullptr || ent->isDirectory())
    {
        return DirectoryCollection::stream_pointer_t();
    }

    DirectoryCollection::stream_pointer_t p(std::make_shared<std::ifstream>(ent->getName(), std::ios::in | std::ios::binary));
    return p;
}


FileCollection::pointer_t DirectoryCollection::clone() const
{
    return std::make_shared<DirectoryCollection>(*this);
}


void DirectoryCollection::loadEntries() const
{
    // WARNING: this has to stay here because the collection could get close()'d...
    mustBeValid();

    if(!m_entries_loaded)
    {
        m_entries_loaded = true;

        // if the read fails then the directory may have been deleted
        // in which case we want to invalidate this DirectoryCollection
        // object
        try
        {
            // include the root directory
            FileEntry::pointer_t entry(std::make_shared<DirectoryEntry>(m_filepath, ""));
            const_cast<DirectoryCollection *>(this)->m_entries.push_back(entry);

            // now read the data inside that directory
            if(m_filepath.isDirectory())
            {
                const_cast<DirectoryCollection *>(this)->load(FilePath());
            }
        }
        catch(...)
        {
            const_cast<DirectoryCollection *>(this)->close();
            throw;
        }
    }
}


void DirectoryCollection::load(FilePath const & subdir)
{
#ifdef ZIPIOS_WINDOWS
    struct read_dir_t
    {
        read_dir_t(FilePath const & path)
        {
            m_handle = _findfirsti64(static_cast<std::string>(path).c_str(), &m_fileinfo);
            if(m_handle == 0)
            {
                if(errno == ENOENT)
                {
                    // this can happen, the directory is empty and thus has
                    // absolutely no information
                    m_read_first = true;
                }
                else
                {
                    throw IOException("an I/O error occurred while reading a directory");
                }
            }
        }

        ~read_dir_t()
        {
            // a completely empty directory may give us a "null pointer"
            // when calling _[w]findfirst[i64]()
            if(m_handle != 0)
            {
                _findclose(m_handle);
            }
        }

        std::string next()
        {
            if(m_read_first)
            {
                __int64 const r(_findnexti64(m_handle, &m_fileinfo));
                if(r != 0)
                {
                    if(errno != ENOENT)
                    {
                        throw IOException("an I/O error occurred while reading a directory");
                    }
                    return std::string();
                }
            }
            else
            {
                // the _findfirst() includes a response, use it!
                m_read_first = true;
            }

            return m_fileinfo.name;
        }

    private:
        long                    m_handle = 0;
        struct _finddatai64_t   m_fileinfo = {};
        bool                    m_read_first = 0;
    };
#else
    struct read_dir_t
    {
        read_dir_t(FilePath const & path)
            : m_dir(opendir(static_cast<std::string>(path).c_str()))
        {
            if(m_dir == nullptr)
            {
                throw IOException("an I/O error occurred while trying to access directory");
            }
        }

        ~read_dir_t()
        {
            closedir(m_dir);
        }

        std::string next()
        {
            // we must reset errno because readdir() does not change it
            // when the end of the directory is reached
            //
            // Note: readdir() is expected to be thread safe as long as
            //       each thread use a different m_dir parameter
            //
            errno = 0;
            struct dirent * entry(readdir(m_dir));
            if(entry == nullptr)
            {
                if(errno != 0)
                {
                    throw IOException("an I/O error occurred while reading a directory"); // LCOV_EXCL_LINE
                }
                return std::string();
            }

            return entry->d_name;
        }

    private:
        DIR *   m_dir = nullptr;
    };
#endif

    read_dir_t dir(m_filepath + subdir);
    for(;;)
    {
        std::string const & name(dir.next());
        if(name.empty())
        {
            break;
        }

        // skip the "." and ".." directories, they are never added to
        // a Zip archive
        if(name != "." && name != "..")
        {
            FileEntry::pointer_t entry(std::make_shared<DirectoryEntry>(m_filepath + subdir + name, ""));
            m_entries.push_back(entry);

            if(m_recursive && entry->isDirectory())
            {
                load(subdir + name);
            }
        }
    }
}


} // zipios namespace

// Local Variables:
// mode: cpp
// indent-tabs-mode: nil
// c-basic-offset: 4
// tab-width: 4
// End:

// vim: ts=4 sw=4 et