1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef IPC_IPC_CHANNEL_WIN_H_ 6 #define IPC_IPC_CHANNEL_WIN_H_ 7 8 #include "ipc/ipc_channel.h" 9 10 #include <queue> 11 #include <string> 12 13 #include "base/memory/scoped_ptr.h" 14 #include "base/memory/weak_ptr.h" 15 #include "base/message_loop/message_loop.h" 16 #include "ipc/ipc_channel_reader.h" 17 18 namespace base { 19 class ThreadChecker; 20 } 21 22 namespace IPC { 23 24 class Channel::ChannelImpl : public internal::ChannelReader, 25 public base::MessageLoopForIO::IOHandler { 26 public: 27 // Mirror methods of Channel, see ipc_channel.h for description. 28 ChannelImpl(const IPC::ChannelHandle &channel_handle, Mode mode, 29 Listener* listener); 30 ~ChannelImpl(); 31 bool Connect(); 32 void Close(); 33 bool Send(Message* message); 34 static bool IsNamedServerInitialized(const std::string& channel_id); peer_pid()35 base::ProcessId peer_pid() const { return peer_pid_; } 36 37 private: 38 // ChannelReader implementation. 39 virtual ReadState ReadData(char* buffer, 40 int buffer_len, 41 int* bytes_read) OVERRIDE; 42 virtual bool WillDispatchInputMessage(Message* msg) OVERRIDE; 43 bool DidEmptyInputBuffers() OVERRIDE; 44 virtual void HandleInternalMessage(const Message& msg) OVERRIDE; 45 46 static const string16 PipeName(const std::string& channel_id, 47 int32* secret); 48 bool CreatePipe(const IPC::ChannelHandle &channel_handle, Mode mode); 49 50 bool ProcessConnection(); 51 bool ProcessOutgoingMessages(base::MessageLoopForIO::IOContext* context, 52 DWORD bytes_written); 53 54 // MessageLoop::IOHandler implementation. 55 virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context, 56 DWORD bytes_transfered, 57 DWORD error); 58 59 private: 60 struct State { 61 explicit State(ChannelImpl* channel); 62 ~State(); 63 base::MessageLoopForIO::IOContext context; 64 bool is_pending; 65 }; 66 67 State input_state_; 68 State output_state_; 69 70 HANDLE pipe_; 71 72 base::ProcessId peer_pid_; 73 74 // Messages to be sent are queued here. 75 std::queue<Message*> output_queue_; 76 77 // In server-mode, we have to wait for the client to connect before we 78 // can begin reading. We make use of the input_state_ when performing 79 // the connect operation in overlapped mode. 80 bool waiting_connect_; 81 82 // This flag is set when processing incoming messages. It is used to 83 // avoid recursing through ProcessIncomingMessages, which could cause 84 // problems. TODO(darin): make this unnecessary 85 bool processing_incoming_; 86 87 // Determines if we should validate a client's secret on connection. 88 bool validate_client_; 89 90 // This is a unique per-channel value used to authenticate the client end of 91 // a connection. If the value is non-zero, the client passes it in the hello 92 // and the host validates. (We don't send the zero value fto preserve IPC 93 // compatability with existing clients that don't validate the channel.) 94 int32 client_secret_; 95 96 97 base::WeakPtrFactory<ChannelImpl> weak_factory_; 98 99 scoped_ptr<base::ThreadChecker> thread_check_; 100 101 DISALLOW_COPY_AND_ASSIGN(ChannelImpl); 102 }; 103 104 } // namespace IPC 105 106 #endif // IPC_IPC_CHANNEL_WIN_H_ 107