win: Crash handler server

util/win/registration_protocol_win.cc

Index: util/win/registration_protocol_win.cc
diff --git a/util/win/registration_protocol_win.cc b/util/win/registration_protocol_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7752a815fc595aaf8e18b7e6fb9b521f136e0f7b
--- /dev/null
+++ b/util/win/registration_protocol_win.cc
@@ -0,0 +1,66 @@
+// Copyright 2015 The Crashpad Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "util/win/registration_protocol_win.h"
+
+#include <windows.h>
+
+#include "base/logging.h"
+
+namespace crashpad {
+namespace internal {
+
+bool RegisterWithCrashHandlerServer(
+    const base::string16& pipe_name,
+    const crashpad::RegistrationRequest& request,
+    crashpad::RegistrationResponse* response) {
+  HANDLE pipe = CreateFile(pipe_name.c_str(),

[scottmg, 2015/08/27 01:04:38]

I realized this does need to retry. We only have two pipe instances, and
registration requests on those pipes should be serviced very quickly. But
requests won't be queued, so a large number sequentially could otherwise fail.
So the retry with Sleep() is to allow one of the other two outstanding
registrations to complete.

+                           GENERIC_READ | GENERIC_WRITE,
+                           0,
+                           nullptr,
+                           OPEN_EXISTING,
+                           SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION,
+                           nullptr);
+  if (pipe == INVALID_HANDLE_VALUE) {
+    PLOG(ERROR) << "CreateFile";
+    return false;
+  }
+  DWORD mode = PIPE_READMODE_MESSAGE;
+  if (!SetNamedPipeHandleState(pipe, &mode, nullptr, nullptr)) {
+    PLOG(ERROR) << "SetNamedPipeHandleState";
+    return false;
+  }
+  DWORD bytes_read = 0;
+  BOOL result =
+      TransactNamedPipe(pipe,
+                        // This is [in], but is incorrectly declared non-const.
+                        const_cast<crashpad::RegistrationRequest*>(&request),
+                        sizeof(request),
+                        response,
+                        sizeof(*response),
+                        &bytes_read,
+                        nullptr);
+  if (!result) {
+    PLOG(ERROR) << "TransactNamedPipe";
+    return false;
+  }
+  if (bytes_read != sizeof(*response)) {
+    LOG(ERROR) << "TransactNamedPipe read incorrect number of bytes";
+    return false;
+  }
+  return true;
+}
+
+}  // namespace internal
+}  // namespace crashpad