OLD | NEW |
1 | 1 |
2 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 2 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
3 // Use of this source code is governed by a BSD-style license that can be | 3 // Use of this source code is governed by a BSD-style license that can be |
4 // found in the LICENSE file. | 4 // found in the LICENSE file. |
5 // | 5 // |
6 // This file implements the Windows service controlling Me2Me host processes | 6 // This file implements the Windows service controlling Me2Me host processes |
7 // running within user sessions. | 7 // running within user sessions. |
8 | 8 |
9 #include "remoting/host/win/unprivileged_process_delegate.h" | 9 #include "remoting/host/win/unprivileged_process_delegate.h" |
10 | 10 |
(...skipping 210 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
221 } // namespace | 221 } // namespace |
222 | 222 |
223 UnprivilegedProcessDelegate::UnprivilegedProcessDelegate( | 223 UnprivilegedProcessDelegate::UnprivilegedProcessDelegate( |
224 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner, | 224 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner, |
225 std::unique_ptr<base::CommandLine> target_command) | 225 std::unique_ptr<base::CommandLine> target_command) |
226 : io_task_runner_(io_task_runner), | 226 : io_task_runner_(io_task_runner), |
227 target_command_(std::move(target_command)), | 227 target_command_(std::move(target_command)), |
228 event_handler_(nullptr) {} | 228 event_handler_(nullptr) {} |
229 | 229 |
230 UnprivilegedProcessDelegate::~UnprivilegedProcessDelegate() { | 230 UnprivilegedProcessDelegate::~UnprivilegedProcessDelegate() { |
231 DCHECK(CalledOnValidThread()); | 231 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
232 DCHECK(!channel_); | 232 DCHECK(!channel_); |
233 DCHECK(!worker_process_.IsValid()); | 233 DCHECK(!worker_process_.IsValid()); |
234 } | 234 } |
235 | 235 |
236 void UnprivilegedProcessDelegate::LaunchProcess( | 236 void UnprivilegedProcessDelegate::LaunchProcess( |
237 WorkerProcessLauncher* event_handler) { | 237 WorkerProcessLauncher* event_handler) { |
238 DCHECK(CalledOnValidThread()); | 238 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
239 DCHECK(!event_handler_); | 239 DCHECK(!event_handler_); |
240 | 240 |
241 event_handler_ = event_handler; | 241 event_handler_ = event_handler; |
242 | 242 |
243 // Create a restricted token that will be used to run the worker process. | 243 // Create a restricted token that will be used to run the worker process. |
244 ScopedHandle token; | 244 ScopedHandle token; |
245 if (!CreateRestrictedToken(&token)) { | 245 if (!CreateRestrictedToken(&token)) { |
246 PLOG(ERROR) << "Failed to create a restricted LocalService token"; | 246 PLOG(ERROR) << "Failed to create a restricted LocalService token"; |
247 ReportFatalError(); | 247 ReportFatalError(); |
248 return; | 248 return; |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
315 worker_process.Get(), | 315 worker_process.Get(), |
316 mojo::edk::ConnectionParams(mojo::edk::TransportProtocol::kLegacy, | 316 mojo::edk::ConnectionParams(mojo::edk::TransportProtocol::kLegacy, |
317 mojo_channel.PassServerHandle())); | 317 mojo_channel.PassServerHandle())); |
318 | 318 |
319 channel_ = std::move(server); | 319 channel_ = std::move(server); |
320 | 320 |
321 ReportProcessLaunched(std::move(worker_process)); | 321 ReportProcessLaunched(std::move(worker_process)); |
322 } | 322 } |
323 | 323 |
324 void UnprivilegedProcessDelegate::Send(IPC::Message* message) { | 324 void UnprivilegedProcessDelegate::Send(IPC::Message* message) { |
325 DCHECK(CalledOnValidThread()); | 325 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
326 | 326 |
327 if (channel_) { | 327 if (channel_) { |
328 channel_->Send(message); | 328 channel_->Send(message); |
329 } else { | 329 } else { |
330 delete message; | 330 delete message; |
331 } | 331 } |
332 } | 332 } |
333 | 333 |
334 void UnprivilegedProcessDelegate::CloseChannel() { | 334 void UnprivilegedProcessDelegate::CloseChannel() { |
335 DCHECK(CalledOnValidThread()); | 335 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
336 channel_.reset(); | 336 channel_.reset(); |
337 } | 337 } |
338 | 338 |
339 void UnprivilegedProcessDelegate::KillProcess() { | 339 void UnprivilegedProcessDelegate::KillProcess() { |
340 DCHECK(CalledOnValidThread()); | 340 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
341 | 341 |
342 CloseChannel(); | 342 CloseChannel(); |
343 event_handler_ = nullptr; | 343 event_handler_ = nullptr; |
344 | 344 |
345 if (worker_process_.IsValid()) { | 345 if (worker_process_.IsValid()) { |
346 TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT); | 346 TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT); |
347 worker_process_.Close(); | 347 worker_process_.Close(); |
348 } | 348 } |
349 } | 349 } |
350 | 350 |
351 bool UnprivilegedProcessDelegate::OnMessageReceived( | 351 bool UnprivilegedProcessDelegate::OnMessageReceived( |
352 const IPC::Message& message) { | 352 const IPC::Message& message) { |
353 DCHECK(CalledOnValidThread()); | 353 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
354 | 354 |
355 return event_handler_->OnMessageReceived(message); | 355 return event_handler_->OnMessageReceived(message); |
356 } | 356 } |
357 | 357 |
358 void UnprivilegedProcessDelegate::OnChannelConnected(int32_t peer_pid) { | 358 void UnprivilegedProcessDelegate::OnChannelConnected(int32_t peer_pid) { |
359 DCHECK(CalledOnValidThread()); | 359 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
360 | 360 |
361 DWORD pid = GetProcessId(worker_process_.Get()); | 361 DWORD pid = GetProcessId(worker_process_.Get()); |
362 if (pid != static_cast<DWORD>(peer_pid)) { | 362 if (pid != static_cast<DWORD>(peer_pid)) { |
363 LOG(ERROR) << "The actual client PID " << pid | 363 LOG(ERROR) << "The actual client PID " << pid |
364 << " does not match the one reported by the client: " | 364 << " does not match the one reported by the client: " |
365 << peer_pid; | 365 << peer_pid; |
366 ReportFatalError(); | 366 ReportFatalError(); |
367 return; | 367 return; |
368 } | 368 } |
369 | 369 |
370 event_handler_->OnChannelConnected(peer_pid); | 370 event_handler_->OnChannelConnected(peer_pid); |
371 } | 371 } |
372 | 372 |
373 void UnprivilegedProcessDelegate::OnChannelError() { | 373 void UnprivilegedProcessDelegate::OnChannelError() { |
374 DCHECK(CalledOnValidThread()); | 374 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
375 | 375 |
376 event_handler_->OnChannelError(); | 376 event_handler_->OnChannelError(); |
377 } | 377 } |
378 | 378 |
379 void UnprivilegedProcessDelegate::ReportFatalError() { | 379 void UnprivilegedProcessDelegate::ReportFatalError() { |
380 DCHECK(CalledOnValidThread()); | 380 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
381 | 381 |
382 CloseChannel(); | 382 CloseChannel(); |
383 | 383 |
384 WorkerProcessLauncher* event_handler = event_handler_; | 384 WorkerProcessLauncher* event_handler = event_handler_; |
385 event_handler_ = nullptr; | 385 event_handler_ = nullptr; |
386 event_handler->OnFatalError(); | 386 event_handler->OnFatalError(); |
387 } | 387 } |
388 | 388 |
389 void UnprivilegedProcessDelegate::ReportProcessLaunched( | 389 void UnprivilegedProcessDelegate::ReportProcessLaunched( |
390 base::win::ScopedHandle worker_process) { | 390 base::win::ScopedHandle worker_process) { |
391 DCHECK(CalledOnValidThread()); | 391 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
392 DCHECK(!worker_process_.IsValid()); | 392 DCHECK(!worker_process_.IsValid()); |
393 | 393 |
394 worker_process_ = std::move(worker_process); | 394 worker_process_ = std::move(worker_process); |
395 | 395 |
396 // Report a handle that can be used to wait for the worker process completion, | 396 // Report a handle that can be used to wait for the worker process completion, |
397 // query information about the process and duplicate handles. | 397 // query information about the process and duplicate handles. |
398 DWORD desired_access = | 398 DWORD desired_access = |
399 SYNCHRONIZE | PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION; | 399 SYNCHRONIZE | PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION; |
400 HANDLE temp_handle; | 400 HANDLE temp_handle; |
401 if (!DuplicateHandle(GetCurrentProcess(), worker_process_.Get(), | 401 if (!DuplicateHandle(GetCurrentProcess(), worker_process_.Get(), |
402 GetCurrentProcess(), &temp_handle, desired_access, FALSE, | 402 GetCurrentProcess(), &temp_handle, desired_access, FALSE, |
403 0)) { | 403 0)) { |
404 PLOG(ERROR) << "Failed to duplicate a handle"; | 404 PLOG(ERROR) << "Failed to duplicate a handle"; |
405 ReportFatalError(); | 405 ReportFatalError(); |
406 return; | 406 return; |
407 } | 407 } |
408 ScopedHandle limited_handle(temp_handle); | 408 ScopedHandle limited_handle(temp_handle); |
409 | 409 |
410 event_handler_->OnProcessLaunched(std::move(limited_handle)); | 410 event_handler_->OnProcessLaunched(std::move(limited_handle)); |
411 } | 411 } |
412 | 412 |
413 } // namespace remoting | 413 } // namespace remoting |
OLD | NEW |