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