Unreviewed, rolling out r243008.
[WebKit-https.git] / Source / WebKit / Shared / SandboxExtension.h
1 /*
2  * Copyright (C) 2010 Apple Inc. 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
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include <wtf/Forward.h>
29 #include <wtf/Noncopyable.h>
30 #include <wtf/RefCounted.h>
31 #include <wtf/RefPtr.h>
32 #include <wtf/Vector.h>
33 #include <wtf/text/WTFString.h>
34
35 namespace IPC {
36 class Encoder;
37 class Decoder;
38 }
39
40 namespace WebKit {
41     
42 class SandboxExtensionImpl;
43
44 class SandboxExtension : public RefCounted<SandboxExtension> {
45 public:
46     enum class Type {
47         ReadOnly,
48         ReadWrite,
49         Generic,
50     };
51
52     class Handle {
53         WTF_MAKE_NONCOPYABLE(Handle);
54     public:
55         Handle();
56 #if ENABLE(SANDBOX_EXTENSIONS)
57         Handle(Handle&&);
58         Handle& operator=(Handle&&);
59 #else
60         Handle(Handle&&) = default;
61         Handle& operator=(Handle&&) = default;
62 #endif
63         ~Handle();
64
65         void encode(IPC::Encoder&) const;
66         static Optional<Handle> decode(IPC::Decoder&);
67
68     private:
69         friend class SandboxExtension;
70 #if ENABLE(SANDBOX_EXTENSIONS)
71         mutable std::unique_ptr<SandboxExtensionImpl> m_sandboxExtension;
72 #endif
73     };
74
75     class HandleArray {
76         WTF_MAKE_NONCOPYABLE(HandleArray);
77     public:
78         HandleArray();
79         HandleArray(HandleArray&&) = default;
80         HandleArray& operator=(HandleArray&&) = default;
81         ~HandleArray();
82         void allocate(size_t);
83         Handle& operator[](size_t i);
84         Handle& at(size_t i) { return operator[](i); }
85         const Handle& operator[](size_t i) const;
86         size_t size() const;
87         void encode(IPC::Encoder&) const;
88         static Optional<HandleArray> decode(IPC::Decoder&);
89
90     private:
91 #if ENABLE(SANDBOX_EXTENSIONS)
92         Vector<Handle> m_data;
93 #else
94         Handle m_emptyHandle;
95 #endif
96     };
97     
98     static RefPtr<SandboxExtension> create(Handle&&);
99     static bool createHandle(const String& path, Type, Handle&);
100     static bool createHandleWithoutResolvingPath(const String& path, Type, Handle&);
101     static bool createHandleForReadWriteDirectory(const String& path, Handle&); // Will attempt to create the directory.
102     static String createHandleForTemporaryFile(const String& prefix, Type, Handle&);
103     static bool createHandleForGenericExtension(const String& extensionClass, Handle&);
104     ~SandboxExtension();
105
106     bool consume();
107     bool revoke();
108
109     bool consumePermanently();
110     static bool consumePermanently(const Handle&);
111
112 private:
113     explicit SandboxExtension(const Handle&);
114                      
115 #if ENABLE(SANDBOX_EXTENSIONS)
116     mutable std::unique_ptr<SandboxExtensionImpl> m_sandboxExtension;
117     size_t m_useCount { 0 };
118 #endif
119 };
120
121 #if !ENABLE(SANDBOX_EXTENSIONS)
122 inline SandboxExtension::Handle::Handle() { }
123 inline SandboxExtension::Handle::~Handle() { }
124 inline void SandboxExtension::Handle::encode(IPC::Encoder&) const { }
125 inline Optional<SandboxExtension::Handle> SandboxExtension::Handle::decode(IPC::Decoder&) { return SandboxExtension::Handle { }; }
126 inline SandboxExtension::HandleArray::HandleArray() { }
127 inline SandboxExtension::HandleArray::~HandleArray() { }
128 inline void SandboxExtension::HandleArray::allocate(size_t) { }
129 inline size_t SandboxExtension::HandleArray::size() const { return 0; }    
130 inline const SandboxExtension::Handle& SandboxExtension::HandleArray::operator[](size_t) const { return m_emptyHandle; }
131 inline SandboxExtension::Handle& SandboxExtension::HandleArray::operator[](size_t) { return m_emptyHandle; }
132 inline void SandboxExtension::HandleArray::encode(IPC::Encoder&) const { }
133 inline auto SandboxExtension::HandleArray::decode(IPC::Decoder&) -> Optional<HandleArray> { return {{ }}; }
134 inline RefPtr<SandboxExtension> SandboxExtension::create(Handle&&) { return nullptr; }
135 inline bool SandboxExtension::createHandle(const String&, Type, Handle&) { return true; }
136 inline bool SandboxExtension::createHandleWithoutResolvingPath(const String&, Type, Handle&) { return true; }
137 inline bool SandboxExtension::createHandleForReadWriteDirectory(const String&, Handle&) { return true; }
138 inline String SandboxExtension::createHandleForTemporaryFile(const String& /*prefix*/, Type, Handle&) {return String();}
139 inline bool SandboxExtension::createHandleForGenericExtension(const String& /*extensionClass*/, Handle&) { return true; }
140 inline SandboxExtension::~SandboxExtension() { }
141 inline bool SandboxExtension::revoke() { return true; }
142 inline bool SandboxExtension::consume() { return true; }
143 inline bool SandboxExtension::consumePermanently() { return true; }
144 inline bool SandboxExtension::consumePermanently(const Handle&) { return true; }
145 inline String stringByResolvingSymlinksInPath(const String& path) { return path; }
146 inline String resolvePathForSandboxExtension(const String& path) { return path; }
147 inline String resolveAndCreateReadWriteDirectoryForSandboxExtension(const String& path) { return path; }
148 #else
149 String stringByResolvingSymlinksInPath(const String& path);
150 String resolvePathForSandboxExtension(const String& path);
151 String resolveAndCreateReadWriteDirectoryForSandboxExtension(const String& path);
152 #endif
153
154 } // namespace WebKit