1 //////////////////////////////////////////////////////////////////////////////
2 //
3 // (C) Copyright Ion Gaztanaga 2011-2012. Distributed under the Boost
4 // Software License, Version 1.0. (See accompanying file
5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // See http://www.boost.org/libs/interprocess for documentation.
8 //
9 //////////////////////////////////////////////////////////////////////////////
10
11 #ifndef BOOST_INTERPROCESS_WINDOWS_NAMED_SYNC_HPP
12 #define BOOST_INTERPROCESS_WINDOWS_NAMED_SYNC_HPP
13
14 #ifndef BOOST_CONFIG_HPP
15 # include <boost/config.hpp>
16 #endif
17 #
18 #if defined(BOOST_HAS_PRAGMA_ONCE)
19 # pragma once
20 #endif
21
22 #include <boost/interprocess/detail/config_begin.hpp>
23 #include <boost/interprocess/detail/workaround.hpp>
24 #include <boost/interprocess/creation_tags.hpp>
25 #include <boost/interprocess/permissions.hpp>
26 #include <boost/interprocess/detail/shared_dir_helpers.hpp>
27 #include <boost/interprocess/sync/windows/sync_utils.hpp>
28 #include <boost/interprocess/errors.hpp>
29 #include <boost/interprocess/exceptions.hpp>
30 #include <string>
31 #include <boost/assert.hpp>
32
33 namespace boost {
34 namespace interprocess {
35 namespace ipcdetail {
36
37 class windows_named_sync_interface
38 {
39 public:
40 virtual std::size_t get_data_size() const = 0;
41 virtual const void *buffer_with_final_data_to_file() = 0;
42 virtual const void *buffer_with_init_data_to_file() = 0;
43 virtual void *buffer_to_store_init_data_from_file() = 0;
44 virtual bool open(create_enum_t creation_type, const char *id_name) = 0;
45 virtual void close() = 0;
46 virtual ~windows_named_sync_interface() = 0;
47 };
48
~windows_named_sync_interface()49 inline windows_named_sync_interface::~windows_named_sync_interface()
50 {}
51
52 class windows_named_sync
53 {
54 #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
55
56 //Non-copyable
57 windows_named_sync(const windows_named_sync &);
58 windows_named_sync &operator=(const windows_named_sync &);
59 #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
60
61 public:
62 windows_named_sync();
63 void open_or_create(create_enum_t creation_type, const char *name, const permissions &perm, windows_named_sync_interface &sync_interface);
64 void close(windows_named_sync_interface &sync_interface);
65
66 static bool remove(const char *name);
67
68 #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
69 private:
70 void *m_file_hnd;
71
72 #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
73 };
74
windows_named_sync()75 inline windows_named_sync::windows_named_sync()
76 : m_file_hnd(winapi::invalid_handle_value)
77 {}
78
close(windows_named_sync_interface & sync_interface)79 inline void windows_named_sync::close(windows_named_sync_interface &sync_interface)
80 {
81 const std::size_t buflen = sync_interface.get_data_size();
82 const std::size_t sizeof_file_info = sizeof(sync_id::internal_type) + buflen;
83 winapi::interprocess_overlapped overlapped;
84 if(winapi::lock_file_ex
85 (m_file_hnd, winapi::lockfile_exclusive_lock, 0, sizeof_file_info, 0, &overlapped)){
86 if(winapi::set_file_pointer(m_file_hnd, sizeof(sync_id::internal_type), 0, winapi::file_begin)){
87 const void *buf = sync_interface.buffer_with_final_data_to_file();
88
89 unsigned long written_or_read = 0;
90 if(winapi::write_file(m_file_hnd, buf, buflen, &written_or_read, 0)){
91 //...
92 }
93 }
94 }
95 sync_interface.close();
96 if(m_file_hnd != winapi::invalid_handle_value){
97 winapi::close_handle(m_file_hnd);
98 m_file_hnd = winapi::invalid_handle_value;
99 }
100 }
101
open_or_create(create_enum_t creation_type,const char * name,const permissions & perm,windows_named_sync_interface & sync_interface)102 inline void windows_named_sync::open_or_create
103 ( create_enum_t creation_type
104 , const char *name
105 , const permissions &perm
106 , windows_named_sync_interface &sync_interface)
107 {
108 std::string aux_str(name);
109 m_file_hnd = winapi::invalid_handle_value;
110 //Use a file to emulate POSIX lifetime semantics. After this logic
111 //we'll obtain the ID of the native handle to open in aux_str
112 {
113 create_shared_dir_cleaning_old_and_get_filepath(name, aux_str);
114 //Create a file with required permissions.
115 m_file_hnd = winapi::create_file
116 ( aux_str.c_str()
117 , winapi::generic_read | winapi::generic_write
118 , creation_type == DoOpen ? winapi::open_existing :
119 (creation_type == DoCreate ? winapi::create_new : winapi::open_always)
120 , 0
121 , (winapi::interprocess_security_attributes*)perm.get_permissions());
122
123 //Obtain OS error in case something has failed
124 error_info err;
125 bool success = false;
126 if(m_file_hnd != winapi::invalid_handle_value){
127 //Now lock the file
128 const std::size_t buflen = sync_interface.get_data_size();
129 typedef __int64 unique_id_type;
130 const std::size_t sizeof_file_info = sizeof(unique_id_type) + buflen;
131 winapi::interprocess_overlapped overlapped;
132 if(winapi::lock_file_ex
133 (m_file_hnd, winapi::lockfile_exclusive_lock, 0, sizeof_file_info, 0, &overlapped)){
134 __int64 filesize = 0;
135 //Obtain the unique id to open the native semaphore.
136 //If file size was created
137 if(winapi::get_file_size(m_file_hnd, filesize)){
138 unsigned long written_or_read = 0;
139 unique_id_type unique_id_val;
140 if(static_cast<std::size_t>(filesize) != sizeof_file_info){
141 winapi::set_end_of_file(m_file_hnd);
142 winapi::query_performance_counter(&unique_id_val);
143 const void *buf = sync_interface.buffer_with_init_data_to_file();
144 //Write unique ID in file. This ID will be used to calculate the semaphore name
145 if(winapi::write_file(m_file_hnd, &unique_id_val, sizeof(unique_id_val), &written_or_read, 0) &&
146 written_or_read == sizeof(unique_id_val) &&
147 winapi::write_file(m_file_hnd, buf, buflen, &written_or_read, 0) &&
148 written_or_read == buflen ){
149 success = true;
150 }
151 winapi::get_file_size(m_file_hnd, filesize);
152 BOOST_ASSERT(std::size_t(filesize) == sizeof_file_info);
153 }
154 else{
155 void *buf = sync_interface.buffer_to_store_init_data_from_file();
156 if(winapi::read_file(m_file_hnd, &unique_id_val, sizeof(unique_id_val), &written_or_read, 0) &&
157 written_or_read == sizeof(unique_id_val) &&
158 winapi::read_file(m_file_hnd, buf, buflen, &written_or_read, 0) &&
159 written_or_read == buflen ){
160 success = true;
161 }
162 }
163 if(success){
164 //Now create a global semaphore name based on the unique id
165 char unique_id_name[sizeof(unique_id_val)*2+1];
166 std::size_t name_suffix_length = sizeof(unique_id_name);
167 bytes_to_str(&unique_id_val, sizeof(unique_id_val), &unique_id_name[0], name_suffix_length);
168 success = sync_interface.open(creation_type, unique_id_name);
169 }
170 }
171
172 //Obtain OS error in case something has failed
173 err = system_error_code();
174
175 //If this fails we have no possible rollback so don't check the return
176 if(!winapi::unlock_file_ex(m_file_hnd, 0, sizeof_file_info, 0, &overlapped)){
177 err = system_error_code();
178 }
179 }
180 else{
181 //Obtain OS error in case something has failed
182 err = system_error_code();
183 }
184 }
185 else{
186 err = system_error_code();
187 }
188
189 if(!success){
190 if(m_file_hnd != winapi::invalid_handle_value){
191 winapi::close_handle(m_file_hnd);
192 m_file_hnd = winapi::invalid_handle_value;
193 }
194 //Throw as something went wrong
195 throw interprocess_exception(err);
196 }
197 }
198 }
199
remove(const char * name)200 inline bool windows_named_sync::remove(const char *name)
201 {
202 try{
203 //Make sure a temporary path is created for shared memory
204 std::string semfile;
205 ipcdetail::shared_filepath(name, semfile);
206 return winapi::unlink_file(semfile.c_str());
207 }
208 catch(...){
209 return false;
210 }
211 }
212
213 } //namespace ipcdetail {
214 } //namespace interprocess {
215 } //namespace boost {
216
217 #include <boost/interprocess/detail/config_end.hpp>
218
219 #endif //BOOST_INTERPROCESS_WINDOWS_NAMED_SYNC_HPP
220