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
18namespace base {
19class ThreadChecker;
20}
21
22namespace IPC {
23
24class 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);
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 HandleHelloMessage(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