Unigram/Telegram.Native/FileStreamFromApp.cpp at develop · Koki1610/Unigram · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include "pch.h"
#include "FileStreamFromApp.h"
#if __has_include("FileStreamFromApp.g.cpp")
#include "FileStreamFromApp.g.cpp"
#endif

namespace winrt::Telegram::Native::implementation
{
    FileStreamFromApp::FileStreamFromApp(hstring path)
    {
        DWORD desired_access = GENERIC_READ;

        // TODO: share mode
        DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_DELETE | FILE_SHARE_WRITE;

        DWORD creation_disposition = OPEN_ALWAYS;

        DWORD native_flags = FILE_FLAG_BACKUP_SEMANTICS;
        //if (flags & Direct) {
        //	native_flags |= FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING;
        //}
        //if (flags & WinStat) {
        //	native_flags |= FILE_FLAG_BACKUP_SEMANTICS;
        //}
        CREATEFILE2_EXTENDED_PARAMETERS extended_parameters;
        std::memset(&extended_parameters, 0, sizeof(extended_parameters));
        extended_parameters.dwSize = sizeof(extended_parameters);
        extended_parameters.dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
        extended_parameters.dwFileFlags = native_flags;
        auto handle = CreateFile2FromAppW(path.c_str(), desired_access, share_mode, creation_disposition, &extended_parameters);

        m_handle = handle;
    }

    bool FileStreamFromApp::IsValid()
    {
        std::lock_guard const guard(m_lock);
        return m_handle != INVALID_HANDLE_VALUE;
    }

    bool FileStreamFromApp::Seek(int64_t offset)
    {
        std::lock_guard const guard(m_lock);

        if (m_handle != INVALID_HANDLE_VALUE)
        {
            LARGE_INTEGER distancetoMove{};
            distancetoMove.QuadPart = offset;

            return SetFilePointerEx(m_handle, distancetoMove, NULL, FILE_BEGIN);
        }

        return false;
    }

    int32_t FileStreamFromApp::Read(int64_t pointer, uint32_t length)
    {
        std::lock_guard const guard(m_lock);

        if (m_handle != INVALID_HANDLE_VALUE)
        {
            DWORD numberOfBytesRead;
            if (ReadFile(m_handle, (LPVOID)pointer, length, &numberOfBytesRead, NULL))
            {
                return numberOfBytesRead;
            }
        }

        return -1;
    }

    void FileStreamFromApp::Close()
    {
        std::lock_guard const guard(m_lock);

        if (m_handle != INVALID_HANDLE_VALUE)
        {
            CloseHandle(m_handle);
        }

        m_handle = INVALID_HANDLE_VALUE;
    }
}