1	//===-- debugserver.cpp -----------------------------------------*- C++ -*-===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#include <arpa/inet.h>
10	#include <asl.h>
11	#include <cerrno>
12	#include <crt_externs.h>
13	#include <getopt.h>
14	#include <netdb.h>
15	#include <netinet/in.h>
16	#include <netinet/tcp.h>
17	#include <string>
18	#include <sys/select.h>
19	#include <sys/socket.h>
20	#include <sys/sysctl.h>
21	#include <sys/types.h>
22	#include <sys/un.h>
23
24	#include <memory>
25	#include <vector>
26
27	#if defined(__APPLE__)
28	#include <sched.h>
29	extern "C" int proc_set_wakemon_params(pid_t, int,
30	int); // <libproc_internal.h> SPI
31	#endif
32
33	#include "CFString.h"
34	#include "DNB.h"
35	#include "DNBLog.h"
36	#include "DNBTimer.h"
37	#include "OsLogger.h"
38	#include "PseudoTerminal.h"
39	#include "RNBContext.h"
40	#include "RNBRemote.h"
41	#include "RNBServices.h"
42	#include "RNBSocket.h"
43	#include "SysSignal.h"
44
45	// Global PID in case we get a signal and need to stop the process...
46	nub_process_t g_pid = INVALID_NUB_PROCESS;
47
48	// Run loop modes which determine which run loop function will be called
49	enum RNBRunLoopMode {
50	eRNBRunLoopModeInvalid = 0,
51	eRNBRunLoopModeGetStartModeFromRemoteProtocol,
52	eRNBRunLoopModeInferiorAttaching,
53	eRNBRunLoopModeInferiorLaunching,
54	eRNBRunLoopModeInferiorExecuting,
55	eRNBRunLoopModePlatformMode,
56	eRNBRunLoopModeExit
57	};
58
59	// Global Variables
60	RNBRemoteSP g_remoteSP;
61	static int g_lockdown_opt = 0;
62	static int g_applist_opt = 0;
63	static nub_launch_flavor_t g_launch_flavor = eLaunchFlavorDefault;
64	int g_disable_aslr = 0;
65
66	int g_isatty = 0;
67	bool g_detach_on_error = true;
68
69	#define RNBLogSTDOUT(fmt, ...) \
70	do { \
71	if (g_isatty) { \
72	fprintf(stdout, fmt, ##__VA_ARGS__); \
73	} else { \
74	_DNBLog(0, fmt, ##__VA_ARGS__); \
75	} \
76	} while (0)
77	#define RNBLogSTDERR(fmt, ...) \
78	do { \
79	if (g_isatty) { \
80	fprintf(stderr, fmt, ##__VA_ARGS__); \
81	} else { \
82	_DNBLog(0, fmt, ##__VA_ARGS__); \
83	} \
84	} while (0)
85
86	// Get our program path and arguments from the remote connection.
87	// We will need to start up the remote connection without a PID, get the
88	// arguments, wait for the new process to finish launching and hit its
89	// entry point, and then return the run loop mode that should come next.
90	RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemote *remote) {
91	std::string packet;
92
93	if (remote) {
94	RNBContext &ctx = remote->Context();
95	uint32_t event_mask = RNBContext::event_read_packet_available |
96	RNBContext::event_read_thread_exiting;
97
98	// Spin waiting to get the A packet.
99	while (true) {
100	DNBLogThreadedIf(LOG_RNB_MAX,
101	"%s ctx.Events().WaitForSetEvents( 0x%08x ) ...",
102	__FUNCTION__, event_mask);
103	nub_event_t set_events = ctx.Events().WaitForSetEvents(mask: event_mask);
104	DNBLogThreadedIf(LOG_RNB_MAX,
105	"%s ctx.Events().WaitForSetEvents( 0x%08x ) => 0x%08x",
106	__FUNCTION__, event_mask, set_events);
107
108	if (set_events & RNBContext::event_read_thread_exiting) {
109	RNBLogSTDERR("error: packet read thread exited.\n");
110	return eRNBRunLoopModeExit;
111	}
112
113	if (set_events & RNBContext::event_read_packet_available) {
114	rnb_err_t err = rnb_err;
115	RNBRemote::PacketEnum type;
116
117	err = remote->HandleReceivedPacket(type: &type);
118
119	// check if we tried to attach to a process
120	if (type == RNBRemote::vattach || type == RNBRemote::vattachwait ||
121	type == RNBRemote::vattachorwait) {
122	if (err == rnb_success) {
123	RNBLogSTDOUT("Attach succeeded, ready to debug.\n");
124	return eRNBRunLoopModeInferiorExecuting;
125	} else {
126	RNBLogSTDERR("error: attach failed.\n");
127	return eRNBRunLoopModeExit;
128	}
129	}
130
131	if (err == rnb_success) {
132	// If we got our arguments we are ready to launch using the arguments
133	// and any environment variables we received.
134	if (type == RNBRemote::set_argv) {
135	return eRNBRunLoopModeInferiorLaunching;
136	}
137	} else if (err == rnb_not_connected) {
138	RNBLogSTDERR("error: connection lost.\n");
139	return eRNBRunLoopModeExit;
140	} else {
141	// a catch all for any other gdb remote packets that failed
142	DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Error getting packet.",
143	__FUNCTION__);
144	continue;
145	}
146
147	DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s", __FUNCTION__);
148	} else {
149	DNBLogThreadedIf(LOG_RNB_MINIMAL,
150	"%s Connection closed before getting \"A\" packet.",
151	__FUNCTION__);
152	return eRNBRunLoopModeExit;
153	}
154	}
155	}
156	return eRNBRunLoopModeExit;
157	}
158
159	static nub_launch_flavor_t default_launch_flavor(const char *app_name) {
160	#if defined(WITH_FBS) || defined(WITH_BKS) || defined(WITH_SPRINGBOARD)
161	// Check the name to see if it ends with .app
162	auto is_dot_app = [](const char *app_name) {
163	size_t len = strlen(app_name);
164	if (len < 4)
165	return false;
166
167	if (app_name[len - 4] == '.' && app_name[len - 3] == 'a' &&
168	app_name[len - 2] == 'p' && app_name[len - 1] == 'p')
169	return true;
170	return false;
171	};
172
173	if (is_dot_app(app_name)) {
174	#if defined WITH_FBS
175	// Check if we have an app bundle, if so launch using FrontBoard Services.
176	return eLaunchFlavorFBS;
177	#elif defined WITH_BKS
178	// Check if we have an app bundle, if so launch using BackBoard Services.
179	return eLaunchFlavorBKS;
180	#elif defined WITH_SPRINGBOARD
181	// Check if we have an app bundle, if so launch using SpringBoard.
182	return eLaunchFlavorSpringBoard;
183	#endif
184	}
185	#endif
186
187	// Our default launch method is posix spawn
188	return eLaunchFlavorPosixSpawn;
189	}
190
191	// This run loop mode will wait for the process to launch and hit its
192	// entry point. It will currently ignore all events except for the
193	// process state changed event, where it watches for the process stopped
194	// or crash process state.
195	RNBRunLoopMode RNBRunLoopLaunchInferior(RNBRemote *remote,
196	const char *stdin_path,
197	const char *stdout_path,
198	const char *stderr_path,
199	bool no_stdio) {
200	RNBContext &ctx = remote->Context();
201
202	// The Process stuff takes a c array, the RNBContext has a vector...
203	// So make up a c array.
204
205	DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Launching '%s'...", __FUNCTION__,
206	ctx.ArgumentAtIndex(0));
207
208	size_t inferior_argc = ctx.ArgumentCount();
209	// Initialize inferior_argv with inferior_argc + 1 NULLs
210	std::vector<const char *> inferior_argv(inferior_argc + 1, NULL);
211
212	size_t i;
213	for (i = 0; i < inferior_argc; i++)
214	inferior_argv[i] = ctx.ArgumentAtIndex(index: i);
215
216	// Pass the environment array the same way:
217
218	size_t inferior_envc = ctx.EnvironmentCount();
219	// Initialize inferior_argv with inferior_argc + 1 NULLs
220	std::vector<const char *> inferior_envp(inferior_envc + 1, NULL);
221
222	for (i = 0; i < inferior_envc; i++)
223	inferior_envp[i] = ctx.EnvironmentAtIndex(index: i);
224
225	// Our launch type hasn't been set to anything concrete, so we need to
226	// figure our how we are going to launch automatically.
227
228	nub_launch_flavor_t launch_flavor = g_launch_flavor;
229	if (launch_flavor == eLaunchFlavorDefault)
230	launch_flavor = default_launch_flavor(app_name: inferior_argv[0]);
231
232	ctx.SetLaunchFlavor(launch_flavor);
233	char resolved_path[PATH_MAX];
234
235	// If we fail to resolve the path to our executable, then just use what we
236	// were given and hope for the best
237	if (!DNBResolveExecutablePath(inferior_argv[0], resolved_path,
238	sizeof(resolved_path)))
239	::strlcpy(resolved_path, inferior_argv[0], sizeof(resolved_path));
240
241	char launch_err_str[PATH_MAX];
242	launch_err_str[0] = '\0';
243	const char *cwd =
244	(ctx.GetWorkingDirPath() != NULL ? ctx.GetWorkingDirPath()
245	: ctx.GetWorkingDirectory());
246	const char *process_event = ctx.GetProcessEvent();
247	nub_process_t pid = DNBProcessLaunch(
248	&ctx, resolved_path, &inferior_argv[0], &inferior_envp[0], cwd,
249	stdin_path, stdout_path, stderr_path, no_stdio, g_disable_aslr,
250	process_event, launch_err_str, sizeof(launch_err_str));
251
252	g_pid = pid;
253
254	if (pid == INVALID_NUB_PROCESS && strlen(launch_err_str) > 0) {
255	DNBLogThreaded("%s DNBProcessLaunch() returned error: '%s'", __FUNCTION__,
256	launch_err_str);
257	ctx.LaunchStatus().SetError(err: -1, flavor: DNBError::Generic);
258	ctx.LaunchStatus().SetErrorString(launch_err_str);
259	} else if (pid == INVALID_NUB_PROCESS) {
260	DNBLogThreaded(
261	"%s DNBProcessLaunch() failed to launch process, unknown failure",
262	__FUNCTION__);
263	ctx.LaunchStatus().SetError(err: -1, flavor: DNBError::Generic);
264	ctx.LaunchStatus().SetErrorString("<unknown failure>");
265	} else {
266	ctx.LaunchStatus().Clear();
267	}
268
269	if (remote->Comm().IsConnected()) {
270	// It we are connected already, the next thing gdb will do is ask
271	// whether the launch succeeded, and if not, whether there is an
272	// error code. So we need to fetch one packet from gdb before we wait
273	// on the stop from the target.
274
275	uint32_t event_mask = RNBContext::event_read_packet_available;
276	nub_event_t set_events = ctx.Events().WaitForSetEvents(mask: event_mask);
277
278	if (set_events & RNBContext::event_read_packet_available) {
279	rnb_err_t err = rnb_err;
280	RNBRemote::PacketEnum type;
281
282	err = remote->HandleReceivedPacket(type: &type);
283
284	if (err != rnb_success) {
285	DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Error getting packet.",
286	__FUNCTION__);
287	return eRNBRunLoopModeExit;
288	}
289	if (type != RNBRemote::query_launch_success) {
290	DNBLogThreadedIf(LOG_RNB_MINIMAL,
291	"%s Didn't get the expected qLaunchSuccess packet.",
292	__FUNCTION__);
293	}
294	}
295	}
296
297	while (pid != INVALID_NUB_PROCESS) {
298	// Wait for process to start up and hit entry point
299	DNBLogThreadedIf(LOG_RNB_EVENTS, "%s DNBProcessWaitForEvent (%4.4x, "
300	"eEventProcessRunningStateChanged | "
301	"eEventProcessStoppedStateChanged, true, "
302	"INFINITE)...",
303	__FUNCTION__, pid);
304	nub_event_t set_events =
305	DNBProcessWaitForEvents(pid, event_mask: eEventProcessRunningStateChanged |
306	eEventProcessStoppedStateChanged,
307	wait_for_set: true, NULL);
308	DNBLogThreadedIf(LOG_RNB_EVENTS, "%s DNBProcessWaitForEvent (%4.4x, "
309	"eEventProcessRunningStateChanged | "
310	"eEventProcessStoppedStateChanged, true, "
311	"INFINITE) => 0x%8.8x",
312	__FUNCTION__, pid, set_events);
313
314	if (set_events == 0) {
315	pid = INVALID_NUB_PROCESS;
316	g_pid = pid;
317	} else {
318	if (set_events & (eEventProcessRunningStateChanged |
319	eEventProcessStoppedStateChanged)) {
320	nub_state_t pid_state = DNBProcessGetState(pid);
321	DNBLogThreadedIf(
322	LOG_RNB_EVENTS,
323	"%s process %4.4x state changed (eEventProcessStateChanged): %s",
324	__FUNCTION__, pid, DNBStateAsString(pid_state));
325
326	switch (pid_state) {
327	case eStateInvalid:
328	case eStateUnloaded:
329	case eStateAttaching:
330	case eStateLaunching:
331	case eStateSuspended:
332	break; // Ignore
333
334	case eStateRunning:
335	case eStateStepping:
336	// Still waiting to stop at entry point...
337	break;
338
339	case eStateStopped:
340	case eStateCrashed:
341	ctx.SetProcessID(pid);
342	return eRNBRunLoopModeInferiorExecuting;
343
344	case eStateDetached:
345	case eStateExited:
346	pid = INVALID_NUB_PROCESS;
347	g_pid = pid;
348	return eRNBRunLoopModeExit;
349	}
350	}
351
352	DNBProcessResetEvents(pid, event_mask: set_events);
353	}
354	}
355
356	return eRNBRunLoopModeExit;
357	}
358
359	// This run loop mode will wait for the process to launch and hit its
360	// entry point. It will currently ignore all events except for the
361	// process state changed event, where it watches for the process stopped
362	// or crash process state.
363	RNBRunLoopMode RNBRunLoopLaunchAttaching(RNBRemote *remote,
364	nub_process_t attach_pid,
365	nub_process_t &pid) {
366	RNBContext &ctx = remote->Context();
367
368	DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Attaching to pid %i...", __FUNCTION__,
369	attach_pid);
370	char err_str[1024];
371	pid = DNBProcessAttach(attach_pid, NULL, ctx.GetIgnoredExceptions(), err_str,
372	sizeof(err_str));
373	g_pid = pid;
374
375	if (pid == INVALID_NUB_PROCESS) {
376	ctx.LaunchStatus().SetError(err: -1, flavor: DNBError::Generic);
377	if (err_str[0])
378	ctx.LaunchStatus().SetErrorString(err_str);
379	return eRNBRunLoopModeExit;
380	} else {
381	ctx.SetProcessID(pid);
382	return eRNBRunLoopModeInferiorExecuting;
383	}
384	}
385
386	// Watch for signals:
387	// SIGINT: so we can halt our inferior. (disabled for now)
388	// SIGPIPE: in case our child process dies
389	int g_sigint_received = 0;
390	int g_sigpipe_received = 0;
391	void signal_handler(int signo) {
392	DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s (%s)", __FUNCTION__,
393	SysSignal::Name(signo));
394
395	switch (signo) {
396	case SIGINT:
397	g_sigint_received++;
398	if (g_pid != INVALID_NUB_PROCESS) {
399	// Only send a SIGINT once...
400	if (g_sigint_received == 1) {
401	switch (DNBProcessGetState(pid: g_pid)) {
402	case eStateRunning:
403	case eStateStepping:
404	DNBProcessSignal(pid: g_pid, SIGSTOP);
405	return;
406	default:
407	break;
408	}
409	}
410	}
411	exit(SIGINT);
412	break;
413
414	case SIGPIPE:
415	g_sigpipe_received = 1;
416	break;
417	}
418	}
419
420	// Return the new run loop mode based off of the current process state
421	RNBRunLoopMode HandleProcessStateChange(RNBRemote *remote, bool initialize) {
422	RNBContext &ctx = remote->Context();
423	nub_process_t pid = ctx.ProcessID();
424
425	if (pid == INVALID_NUB_PROCESS) {
426	DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s error: pid invalid, exiting...",
427	__FUNCTION__);
428	return eRNBRunLoopModeExit;
429	}
430	nub_state_t pid_state = DNBProcessGetState(pid);
431
432	DNBLogThreadedIf(LOG_RNB_MINIMAL,
433	"%s (&remote, initialize=%i) pid_state = %s", __FUNCTION__,
434	(int)initialize, DNBStateAsString(pid_state));
435
436	switch (pid_state) {
437	case eStateInvalid:
438	case eStateUnloaded:
439	// Something bad happened
440	return eRNBRunLoopModeExit;
441	break;
442
443	case eStateAttaching:
444	case eStateLaunching:
445	return eRNBRunLoopModeInferiorExecuting;
446
447	case eStateSuspended:
448	case eStateCrashed:
449	case eStateStopped:
450	// If we stop due to a signal, so clear the fact that we got a SIGINT
451	// so we can stop ourselves again (but only while our inferior
452	// process is running..)
453	g_sigint_received = 0;
454	if (initialize == false) {
455	// Compare the last stop count to our current notion of a stop count
456	// to make sure we don't notify more than once for a given stop.
457	nub_size_t prev_pid_stop_count = ctx.GetProcessStopCount();
458	bool pid_stop_count_changed =
459	ctx.SetProcessStopCount(DNBProcessGetStopCount(pid));
460	if (pid_stop_count_changed) {
461	remote->FlushSTDIO();
462
463	if (ctx.GetProcessStopCount() == 1) {
464	DNBLogThreadedIf(
465	LOG_RNB_MINIMAL, "%s (&remote, initialize=%i) pid_state = %s "
466	"pid_stop_count %llu (old %llu)) Notify??? no, "
467	"first stop...",
468	__FUNCTION__, (int)initialize, DNBStateAsString(pid_state),
469	(uint64_t)ctx.GetProcessStopCount(),
470	(uint64_t)prev_pid_stop_count);
471	} else {
472
473	DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s (&remote, initialize=%i) "
474	"pid_state = %s pid_stop_count "
475	"%llu (old %llu)) Notify??? YES!!!",
476	__FUNCTION__, (int)initialize,
477	DNBStateAsString(pid_state),
478	(uint64_t)ctx.GetProcessStopCount(),
479	(uint64_t)prev_pid_stop_count);
480	remote->NotifyThatProcessStopped();
481	}
482	} else {
483	DNBLogThreadedIf(
484	LOG_RNB_MINIMAL, "%s (&remote, initialize=%i) pid_state = %s "
485	"pid_stop_count %llu (old %llu)) Notify??? "
486	"skipping...",
487	__FUNCTION__, (int)initialize, DNBStateAsString(pid_state),
488	(uint64_t)ctx.GetProcessStopCount(), (uint64_t)prev_pid_stop_count);
489	}
490	}
491	return eRNBRunLoopModeInferiorExecuting;
492
493	case eStateStepping:
494	case eStateRunning:
495	return eRNBRunLoopModeInferiorExecuting;
496
497	case eStateExited:
498	remote->HandlePacket_last_signal(NULL);
499	return eRNBRunLoopModeExit;
500	case eStateDetached:
501	return eRNBRunLoopModeExit;
502	}
503
504	// Catch all...
505	return eRNBRunLoopModeExit;
506	}
507
508	// This function handles the case where our inferior program is stopped and
509	// we are waiting for gdb remote protocol packets. When a packet occurs that
510	// makes the inferior run, we need to leave this function with a new state
511	// as the return code.
512	RNBRunLoopMode RNBRunLoopInferiorExecuting(RNBRemote *remote) {
513	DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s", __FUNCTION__);
514	RNBContext &ctx = remote->Context();
515
516	// Init our mode and set 'is_running' based on the current process state
517	RNBRunLoopMode mode = HandleProcessStateChange(remote, initialize: true);
518
519	while (ctx.ProcessID() != INVALID_NUB_PROCESS) {
520
521	std::string set_events_str;
522	uint32_t event_mask = ctx.NormalEventBits();
523
524	if (!ctx.ProcessStateRunning()) {
525	// Clear some bits if we are not running so we don't send any async
526	// packets
527	event_mask &= ~RNBContext::event_proc_stdio_available;
528	event_mask &= ~RNBContext::event_proc_profile_data;
529	}
530
531	// We want to make sure we consume all process state changes and have
532	// whomever is notifying us to wait for us to reset the event bit before
533	// continuing.
534	// ctx.Events().SetResetAckMask (RNBContext::event_proc_state_changed);
535
536	DNBLogThreadedIf(LOG_RNB_EVENTS,
537	"%s ctx.Events().WaitForSetEvents(0x%08x) ...",
538	__FUNCTION__, event_mask);
539	nub_event_t set_events = ctx.Events().WaitForSetEvents(mask: event_mask);
540	DNBLogThreadedIf(LOG_RNB_EVENTS,
541	"%s ctx.Events().WaitForSetEvents(0x%08x) => 0x%08x (%s)",
542	__FUNCTION__, event_mask, set_events,
543	ctx.EventsAsString(set_events, set_events_str));
544
545	if (set_events) {
546	if ((set_events & RNBContext::event_proc_thread_exiting) ||
547	(set_events & RNBContext::event_proc_stdio_available)) {
548	remote->FlushSTDIO();
549	}
550
551	if (set_events & RNBContext::event_proc_profile_data) {
552	remote->SendAsyncProfileData();
553	}
554
555	if (set_events & RNBContext::event_read_packet_available) {
556	// handleReceivedPacket will take care of resetting the
557	// event_read_packet_available events when there are no more...
558	set_events ^= RNBContext::event_read_packet_available;
559
560	if (ctx.ProcessStateRunning()) {
561	if (remote->HandleAsyncPacket() == rnb_not_connected) {
562	// TODO: connect again? Exit?
563	}
564	} else {
565	if (remote->HandleReceivedPacket() == rnb_not_connected) {
566	// TODO: connect again? Exit?
567	}
568	}
569	}
570
571	if (set_events & RNBContext::event_proc_state_changed) {
572	mode = HandleProcessStateChange(remote, initialize: false);
573	ctx.Events().ResetEvents(mask: RNBContext::event_proc_state_changed);
574	set_events ^= RNBContext::event_proc_state_changed;
575	}
576
577	if (set_events & RNBContext::event_proc_thread_exiting) {
578	DNBLog("debugserver's process monitoring thread has exited.");
579	mode = eRNBRunLoopModeExit;
580	}
581
582	if (set_events & RNBContext::event_read_thread_exiting) {
583	// Out remote packet receiving thread exited, exit for now.
584	DNBLog(
585	"debugserver's packet communication to lldb has been shut down.");
586	if (ctx.HasValidProcessID()) {
587	nub_process_t pid = ctx.ProcessID();
588	// TODO: We should add code that will leave the current process
589	// in its current state and listen for another connection...
590	if (ctx.ProcessStateRunning()) {
591	if (ctx.GetDetachOnError()) {
592	DNBLog("debugserver has a valid PID %d, it is still running. "
593	"detaching from the inferior process.",
594	pid);
595	DNBProcessDetach(pid);
596	} else {
597	DNBLog("debugserver killing the inferior process, pid %d.", pid);
598	DNBProcessKill(pid);
599	}
600	} else {
601	if (ctx.GetDetachOnError()) {
602	DNBLog("debugserver has a valid PID %d but it may no longer "
603	"be running, detaching from the inferior process.",
604	pid);
605	DNBProcessDetach(pid);
606	}
607	}
608	}
609	mode = eRNBRunLoopModeExit;
610	}
611	}
612
613	// Reset all event bits that weren't reset for now...
614	if (set_events != 0)
615	ctx.Events().ResetEvents(mask: set_events);
616
617	if (mode != eRNBRunLoopModeInferiorExecuting)
618	break;
619	}
620
621	return mode;
622	}
623
624	RNBRunLoopMode RNBRunLoopPlatform(RNBRemote *remote) {
625	RNBRunLoopMode mode = eRNBRunLoopModePlatformMode;
626	RNBContext &ctx = remote->Context();
627
628	while (mode == eRNBRunLoopModePlatformMode) {
629	std::string set_events_str;
630	const uint32_t event_mask = RNBContext::event_read_packet_available |
631	RNBContext::event_read_thread_exiting;
632
633	DNBLogThreadedIf(LOG_RNB_EVENTS,
634	"%s ctx.Events().WaitForSetEvents(0x%08x) ...",
635	__FUNCTION__, event_mask);
636	nub_event_t set_events = ctx.Events().WaitForSetEvents(mask: event_mask);
637	DNBLogThreadedIf(LOG_RNB_EVENTS,
638	"%s ctx.Events().WaitForSetEvents(0x%08x) => 0x%08x (%s)",
639	__FUNCTION__, event_mask, set_events,
640	ctx.EventsAsString(set_events, set_events_str));
641
642	if (set_events) {
643	if (set_events & RNBContext::event_read_packet_available) {
644	if (remote->HandleReceivedPacket() == rnb_not_connected)
645	mode = eRNBRunLoopModeExit;
646	}
647
648	if (set_events & RNBContext::event_read_thread_exiting) {
649	mode = eRNBRunLoopModeExit;
650	}
651	ctx.Events().ResetEvents(mask: set_events);
652	}
653	}
654	return eRNBRunLoopModeExit;
655	}
656
657	// Convenience function to set up the remote listening port
658	// Returns 1 for success 0 for failure.
659
660	static void PortWasBoundCallbackUnixSocket(const void *baton, in_port_t port) {
661	//::printf ("PortWasBoundCallbackUnixSocket (baton = %p, port = %u)\n", baton,
662	//port);
663
664	const char *unix_socket_name = (const char *)baton;
665
666	if (unix_socket_name && unix_socket_name[0]) {
667	// We were given a unix socket name to use to communicate the port
668	// that we ended up binding to back to our parent process
669	struct sockaddr_un saddr_un;
670	int s = ::socket(AF_UNIX, SOCK_STREAM, protocol: 0);
671	if (s < 0) {
672	perror(s: "error: socket (AF_UNIX, SOCK_STREAM, 0)");
673	exit(status: 1);
674	}
675
676	saddr_un.sun_family = AF_UNIX;
677	::strlcpy(saddr_un.sun_path, unix_socket_name,
678	sizeof(saddr_un.sun_path) - 1);
679	saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
680	saddr_un.sun_len = SUN_LEN(&saddr_un);
681
682	if (::connect(fd: s, addr: (struct sockaddr *)&saddr_un,
683	len: static_cast<socklen_t>(SUN_LEN(&saddr_un))) < 0) {
684	perror(s: "error: connect (socket, &saddr_un, saddr_un_len)");
685	exit(status: 1);
686	}
687
688	//::printf ("connect () sucess!!\n");
689
690	// We were able to connect to the socket, now write our PID so whomever
691	// launched us will know this process's ID
692	RNBLogSTDOUT("Listening to port %i...\n", port);
693
694	char pid_str[64];
695	const int pid_str_len = ::snprintf(s: pid_str, maxlen: sizeof(pid_str), format: "%u", port);
696	const ssize_t bytes_sent = ::send(fd: s, buf: pid_str, n: pid_str_len, flags: 0);
697
698	if (pid_str_len != bytes_sent) {
699	perror(s: "error: send (s, pid_str, pid_str_len, 0)");
700	exit(status: 1);
701	}
702
703	//::printf ("send () sucess!!\n");
704
705	// We are done with the socket
706	close(fd: s);
707	}
708	}
709
710	static void PortWasBoundCallbackNamedPipe(const void *baton, uint16_t port) {
711	const char *named_pipe = (const char *)baton;
712	if (named_pipe && named_pipe[0]) {
713	int fd = ::open(file: named_pipe, O_WRONLY);
714	if (fd > -1) {
715	char port_str[64];
716	const ssize_t port_str_len =
717	::snprintf(s: port_str, maxlen: sizeof(port_str), format: "%u", port);
718	// Write the port number as a C string with the NULL terminator
719	::write(fd: fd, buf: port_str, n: port_str_len + 1);
720	close(fd: fd);
721	}
722	}
723	}
724
725	static int ConnectRemote(RNBRemote *remote, const char *host, int port,
726	bool reverse_connect, const char *named_pipe_path,
727	const char *unix_socket_name) {
728	if (!remote->Comm().IsConnected()) {
729	if (reverse_connect) {
730	if (port == 0) {
731	DNBLogThreaded(
732	"error: invalid port supplied for reverse connection: %i.\n", port);
733	return 0;
734	}
735	if (remote->Comm().Connect(host, port) != rnb_success) {
736	DNBLogThreaded("Failed to reverse connect to %s:%i.\n", host, port);
737	return 0;
738	}
739	} else {
740	if (port != 0)
741	RNBLogSTDOUT("Listening to port %i for a connection from %s...\n", port,
742	host ? host : "127.0.0.1");
743	if (unix_socket_name && unix_socket_name[0]) {
744	if (remote->Comm().Listen(listen_host: host, port, callback: PortWasBoundCallbackUnixSocket,
745	callback_baton: unix_socket_name) != rnb_success) {
746	RNBLogSTDERR("Failed to get connection from a remote gdb process.\n");
747	return 0;
748	}
749	} else {
750	if (remote->Comm().Listen(listen_host: host, port, callback: PortWasBoundCallbackNamedPipe,
751	callback_baton: named_pipe_path) != rnb_success) {
752	RNBLogSTDERR("Failed to get connection from a remote gdb process.\n");
753	return 0;
754	}
755	}
756	}
757	remote->StartReadRemoteDataThread();
758	}
759	return 1;
760	}
761
762	// FILE based Logging callback that can be registered with
763	// DNBLogSetLogCallback
764	void FileLogCallback(void *baton, uint32_t flags, const char *format,
765	va_list args) {
766	if (baton == NULL || format == NULL)
767	return;
768
769	::vfprintf(s: (FILE *)baton, format: format, arg: args);
770	::fprintf(stream: (FILE *)baton, format: "\n");
771	::fflush(stream: (FILE *)baton);
772	}
773
774	void show_version_and_exit(int exit_code) {
775	const char *in_translation = "";
776	if (DNBDebugserverIsTranslated())
777	in_translation = " (running under translation)";
778	printf(format: "%s-%s for %s%s.\n", DEBUGSERVER_PROGRAM_NAME, DEBUGSERVER_VERSION_STR,
779	RNB_ARCH, in_translation);
780	exit(status: exit_code);
781	}
782
783	void show_usage_and_exit(int exit_code) {
784	RNBLogSTDERR(
785	"Usage:\n %s host:port [program-name program-arg1 program-arg2 ...]\n",
786	DEBUGSERVER_PROGRAM_NAME);
787	RNBLogSTDERR(" %s /path/file [program-name program-arg1 program-arg2 ...]\n",
788	DEBUGSERVER_PROGRAM_NAME);
789	RNBLogSTDERR(" %s host:port --attach=<pid>\n", DEBUGSERVER_PROGRAM_NAME);
790	RNBLogSTDERR(" %s /path/file --attach=<pid>\n", DEBUGSERVER_PROGRAM_NAME);
791	RNBLogSTDERR(" %s host:port --attach=<process_name>\n",
792	DEBUGSERVER_PROGRAM_NAME);
793	RNBLogSTDERR(" %s /path/file --attach=<process_name>\n",
794	DEBUGSERVER_PROGRAM_NAME);
795	exit(status: exit_code);
796	}
797
798	// option descriptors for getopt_long_only()
799	static struct option g_long_options[] = {
800	{.name: "attach", required_argument, NULL, .val: 'a'},
801	{.name: "arch", required_argument, NULL, .val: 'A'},
802	{.name: "debug", no_argument, NULL, .val: 'g'},
803	{.name: "kill-on-error", no_argument, NULL, .val: 'K'},
804	{.name: "verbose", no_argument, NULL, .val: 'v'},
805	{.name: "version", no_argument, NULL, .val: 'V'},
806	{.name: "lockdown", no_argument, .flag: &g_lockdown_opt, .val: 1}, // short option "-k"
807	{.name: "applist", no_argument, .flag: &g_applist_opt, .val: 1}, // short option "-t"
808	{.name: "log-file", required_argument, NULL, .val: 'l'},
809	{.name: "log-flags", required_argument, NULL, .val: 'f'},
810	{.name: "launch", required_argument, NULL, .val: 'x'}, // Valid values are "auto",
811	// "posix-spawn", "fork-exec",
812	// "springboard" (arm only)
813	{.name: "waitfor", required_argument, NULL,
814	.val: 'w'}, // Wait for a process whose name starts with ARG
815	{.name: "waitfor-interval", required_argument, NULL,
816	.val: 'i'}, // Time in usecs to wait between sampling the pid list when waiting
817	// for a process by name
818	{.name: "waitfor-duration", required_argument, NULL,
819	.val: 'd'}, // The time in seconds to wait for a process to show up by name
820	{.name: "native-regs", no_argument, NULL, .val: 'r'}, // Specify to use the native
821	// registers instead of the gdb
822	// defaults for the architecture.
823	{.name: "stdio-path", required_argument, NULL,
824	.val: 's'}, // Set the STDIO path to be used when launching applications (STDIN,
825	// STDOUT and STDERR) (only if debugserver launches the process)
826	{.name: "stdin-path", required_argument, NULL,
827	.val: 'I'}, // Set the STDIN path to be used when launching applications (only if
828	// debugserver launches the process)
829	{.name: "stdout-path", required_argument, NULL,
830	.val: 'O'}, // Set the STDOUT path to be used when launching applications (only
831	// if debugserver launches the process)
832	{.name: "stderr-path", required_argument, NULL,
833	.val: 'E'}, // Set the STDERR path to be used when launching applications (only
834	// if debugserver launches the process)
835	{.name: "no-stdio", no_argument, NULL,
836	.val: 'n'}, // Do not set up any stdio (perhaps the program is a GUI program)
837	// (only if debugserver launches the process)
838	{.name: "setsid", no_argument, NULL,
839	.val: 'S'}, // call setsid() to make debugserver run in its own session
840	{.name: "disable-aslr", no_argument, NULL, .val: 'D'}, // Use _POSIX_SPAWN_DISABLE_ASLR
841	// to avoid shared library
842	// randomization
843	{.name: "working-dir", required_argument, NULL,
844	.val: 'W'}, // The working directory that the inferior process should have (only
845	// if debugserver launches the process)
846	{.name: "platform", required_argument, NULL,
847	.val: 'p'}, // Put this executable into a remote platform mode
848	{.name: "unix-socket", required_argument, NULL,
849	.val: 'u'}, // If we need to handshake with our parent process, an option will be
850	// passed down that specifies a unix socket name to use
851	{.name: "fd", required_argument, NULL,
852	.val: '2'}, // A file descriptor was passed to this process when spawned that
853	// is already open and ready for communication
854	{.name: "named-pipe", required_argument, NULL, .val: 'P'},
855	{.name: "reverse-connect", no_argument, NULL, .val: 'R'},
856	{.name: "env", required_argument, NULL,
857	.val: 'e'}, // When debugserver launches the process, set a single environment
858	// entry as specified by the option value ("./debugserver -e FOO=1 -e
859	// BAR=2 localhost:1234 -- /bin/ls")
860	{.name: "forward-env", no_argument, NULL,
861	.val: 'F'}, // When debugserver launches the process, forward debugserver's
862	// current environment variables to the child process ("./debugserver
863	// -F localhost:1234 -- /bin/ls"
864	{.name: "unmask-signals", no_argument, NULL,
865	.val: 'U'}, // debugserver will ignore EXC_MASK_BAD_ACCESS,
866	// EXC_MASK_BAD_INSTRUCTION and EXC_MASK_ARITHMETIC, which results in
867	// SIGSEGV, SIGILL and SIGFPE being propagated to the target process.
868	{NULL, .has_arg: 0, NULL, .val: 0}};
869
870	int communication_fd = -1;
871
872	// main
873	int main(int argc, char *argv[]) {
874	// If debugserver is launched with DYLD_INSERT_LIBRARIES, unset it so we
875	// don't spawn child processes with this enabled.
876	unsetenv(name: "DYLD_INSERT_LIBRARIES");
877
878	const char *argv_sub_zero =
879	argv[0]; // save a copy of argv[0] for error reporting post-launch
880
881	#if defined(__APPLE__)
882	pthread_setname_np("main thread");
883	#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
884	struct sched_param thread_param;
885	int thread_sched_policy;
886	if (pthread_getschedparam(pthread_self(), &thread_sched_policy,
887	&thread_param) == 0) {
888	thread_param.sched_priority = 47;
889	pthread_setschedparam(pthread_self(), thread_sched_policy, &thread_param);
890	}
891
892	::proc_set_wakemon_params(
893	getpid(), 500,
894	0); // Allow up to 500 wakeups/sec to avoid EXC_RESOURCE for normal use.
895	#endif
896	#endif
897
898	g_isatty = ::isatty(STDIN_FILENO);
899
900	// ::printf ("uid=%u euid=%u gid=%u egid=%u\n",
901	// getuid(),
902	// geteuid(),
903	// getgid(),
904	// getegid());
905
906	// signal (SIGINT, signal_handler);
907	signal(SIGPIPE, handler: signal_handler);
908	signal(SIGHUP, handler: signal_handler);
909
910	// We're always sitting in waitpid or kevent waiting on our target process'
911	// death,
912	// we don't need no stinking SIGCHLD's...
913
914	sigset_t sigset;
915	sigemptyset(set: &sigset);
916	sigaddset(set: &sigset, SIGCHLD);
917	sigprocmask(SIG_BLOCK, set: &sigset, NULL);
918
919	// Set up DNB logging by default. If the user passes different log flags or a
920	// log file, these settings will be modified after processing the command line
921	// arguments.
922	if (auto log_callback = OsLogger::GetLogFunction())
923	DNBLogSetLogCallback(log_callback, nullptr);
924	DNBLogSetLogMask(/*log_flags*/ mask: 0);
925
926	g_remoteSP = std::make_shared<RNBRemote>();
927
928	RNBRemote *remote = g_remoteSP.get();
929	if (remote == NULL) {
930	RNBLogSTDERR("error: failed to create a remote connection class\n");
931	return -1;
932	}
933
934	RNBContext &ctx = remote->Context();
935
936	int i;
937	int attach_pid = INVALID_NUB_PROCESS;
938
939	FILE *log_file = NULL;
940	uint32_t log_flags = 0;
941	// Parse our options
942	int ch;
943	int long_option_index = 0;
944	int debug = 0;
945	std::string compile_options;
946	std::string waitfor_pid_name; // Wait for a process that starts with this name
947	std::string attach_pid_name;
948	std::string arch_name;
949	std::string working_dir; // The new working directory to use for the inferior
950	std::string unix_socket_name; // If we need to handshake with our parent
951	// process, an option will be passed down that
952	// specifies a unix socket name to use
953	std::string named_pipe_path; // If we need to handshake with our parent
954	// process, an option will be passed down that
955	// specifies a named pipe to use
956	useconds_t waitfor_interval = 1000; // Time in usecs between process lists
957	// polls when waiting for a process by
958	// name, default 1 msec.
959	useconds_t waitfor_duration =
960	0; // Time in seconds to wait for a process by name, 0 means wait forever.
961	bool no_stdio = false;
962	bool reverse_connect = false; // Set to true by an option to indicate we
963	// should reverse connect to the host:port
964	// supplied as the first debugserver argument
965
966	#if !defined(DNBLOG_ENABLED)
967	compile_options += "(no-logging) ";
968	#endif
969
970	RNBRunLoopMode start_mode = eRNBRunLoopModeExit;
971
972	char short_options[512];
973	uint32_t short_options_idx = 0;
974
975	// Handle the two case that don't have short options in g_long_options
976	short_options[short_options_idx++] = 'k';
977	short_options[short_options_idx++] = 't';
978
979	for (i = 0; g_long_options[i].name != NULL; ++i) {
980	if (isalpha(g_long_options[i].val)) {
981	short_options[short_options_idx++] = g_long_options[i].val;
982	switch (g_long_options[i].has_arg) {
983	default:
984	case no_argument:
985	break;
986
987	case optional_argument:
988	short_options[short_options_idx++] = ':';
989	short_options[short_options_idx++] = ':';
990	break;
991	case required_argument:
992	short_options[short_options_idx++] = ':';
993	break;
994	}
995	}
996	}
997	// NULL terminate the short option string.
998	short_options[short_options_idx++] = '\0';
999
1000	#if __GLIBC__
1001	optind = 0;
1002	#else
1003	optreset = 1;
1004	optind = 1;
1005	#endif
1006
1007	bool forward_env = false;
1008	while ((ch = getopt_long_only(argc: argc, argv: argv, shortopts: short_options, longopts: g_long_options,
1009	longind: &long_option_index)) != -1) {
1010	DNBLogDebug("option: ch == %c (0x%2.2x) --%s%c%s\n", ch, (uint8_t)ch,
1011	g_long_options[long_option_index].name,
1012	g_long_options[long_option_index].has_arg ? '=' : ' ',
1013	optarg ? optarg : "");
1014	switch (ch) {
1015	case 0: // Any optional that auto set themselves will return 0
1016	break;
1017
1018	case 'A':
1019	if (optarg && optarg[0])
1020	arch_name.assign(s: optarg);
1021	break;
1022
1023	case 'a':
1024	if (optarg && optarg[0]) {
1025	if (isdigit(optarg[0])) {
1026	char *end = NULL;
1027	attach_pid = static_cast<int>(strtoul(nptr: optarg, endptr: &end, base: 0));
1028	if (end == NULL || *end != '\0') {
1029	RNBLogSTDERR("error: invalid pid option '%s'\n", optarg);
1030	exit(status: 4);
1031	}
1032	} else {
1033	attach_pid_name = optarg;
1034	}
1035	start_mode = eRNBRunLoopModeInferiorAttaching;
1036	}
1037	break;
1038
1039	// --waitfor=NAME
1040	case 'w':
1041	if (optarg && optarg[0]) {
1042	waitfor_pid_name = optarg;
1043	start_mode = eRNBRunLoopModeInferiorAttaching;
1044	}
1045	break;
1046
1047	// --waitfor-interval=USEC
1048	case 'i':
1049	if (optarg && optarg[0]) {
1050	char *end = NULL;
1051	waitfor_interval = static_cast<useconds_t>(strtoul(nptr: optarg, endptr: &end, base: 0));
1052	if (end == NULL || *end != '\0') {
1053	RNBLogSTDERR("error: invalid waitfor-interval option value '%s'.\n",
1054	optarg);
1055	exit(status: 6);
1056	}
1057	}
1058	break;
1059
1060	// --waitfor-duration=SEC
1061	case 'd':
1062	if (optarg && optarg[0]) {
1063	char *end = NULL;
1064	waitfor_duration = static_cast<useconds_t>(strtoul(nptr: optarg, endptr: &end, base: 0));
1065	if (end == NULL || *end != '\0') {
1066	RNBLogSTDERR("error: invalid waitfor-duration option value '%s'.\n",
1067	optarg);
1068	exit(status: 7);
1069	}
1070	}
1071	break;
1072
1073	case 'K':
1074	g_detach_on_error = false;
1075	break;
1076	case 'W':
1077	if (optarg && optarg[0])
1078	working_dir.assign(s: optarg);
1079	break;
1080
1081	case 'x':
1082	if (optarg && optarg[0]) {
1083	if (strcasecmp(s1: optarg, s2: "auto") == 0)
1084	g_launch_flavor = eLaunchFlavorDefault;
1085	else if (strcasestr(haystack: optarg, needle: "posix") == optarg) {
1086	DNBLog(
1087	"[LaunchAttach] launch flavor is posix_spawn via cmdline option");
1088	g_launch_flavor = eLaunchFlavorPosixSpawn;
1089	} else if (strcasestr(haystack: optarg, needle: "fork") == optarg)
1090	g_launch_flavor = eLaunchFlavorForkExec;
1091	#ifdef WITH_SPRINGBOARD
1092	else if (strcasestr(optarg, "spring") == optarg) {
1093	DNBLog(
1094	"[LaunchAttach] launch flavor is SpringBoard via cmdline option");
1095	g_launch_flavor = eLaunchFlavorSpringBoard;
1096	}
1097	#endif
1098	#ifdef WITH_BKS
1099	else if (strcasestr(optarg, "backboard") == optarg) {
1100	DNBLog("[LaunchAttach] launch flavor is BKS via cmdline option");
1101	g_launch_flavor = eLaunchFlavorBKS;
1102	}
1103	#endif
1104	#ifdef WITH_FBS
1105	else if (strcasestr(optarg, "frontboard") == optarg) {
1106	DNBLog("[LaunchAttach] launch flavor is FBS via cmdline option");
1107	g_launch_flavor = eLaunchFlavorFBS;
1108	}
1109	#endif
1110
1111	else {
1112	RNBLogSTDERR("error: invalid TYPE for the --launch=TYPE (-x TYPE) "
1113	"option: '%s'\n",
1114	optarg);
1115	RNBLogSTDERR("Valid values TYPE are:\n");
1116	RNBLogSTDERR(
1117	" auto Auto-detect the best launch method to use.\n");
1118	RNBLogSTDERR(
1119	" posix Launch the executable using posix_spawn.\n");
1120	RNBLogSTDERR(
1121	" fork Launch the executable using fork and exec.\n");
1122	#ifdef WITH_SPRINGBOARD
1123	RNBLogSTDERR(
1124	" spring Launch the executable through Springboard.\n");
1125	#endif
1126	#ifdef WITH_BKS
1127	RNBLogSTDERR(" backboard Launch the executable through BackBoard "
1128	"Services.\n");
1129	#endif
1130	#ifdef WITH_FBS
1131	RNBLogSTDERR(" frontboard Launch the executable through FrontBoard "
1132	"Services.\n");
1133	#endif
1134	exit(status: 5);
1135	}
1136	}
1137	break;
1138
1139	case 'l': // Set Log File
1140	if (optarg && optarg[0]) {
1141	if (strcasecmp(s1: optarg, s2: "stdout") == 0)
1142	log_file = stdout;
1143	else if (strcasecmp(s1: optarg, s2: "stderr") == 0)
1144	log_file = stderr;
1145	else {
1146	log_file = fopen(filename: optarg, modes: "w");
1147	if (log_file != NULL)
1148	setlinebuf(log_file);
1149	}
1150
1151	if (log_file == NULL) {
1152	const char *errno_str = strerror(errno);
1153	RNBLogSTDERR(
1154	"Failed to open log file '%s' for writing: errno = %i (%s)",
1155	optarg, errno, errno_str ? errno_str : "unknown error");
1156	}
1157	}
1158	break;
1159
1160	case 'f': // Log Flags
1161	if (optarg && optarg[0])
1162	log_flags = static_cast<uint32_t>(strtoul(nptr: optarg, NULL, base: 0));
1163	break;
1164
1165	case 'g':
1166	debug = 1;
1167	DNBLogSetDebug(g: debug);
1168	break;
1169
1170	case 't':
1171	g_applist_opt = 1;
1172	break;
1173
1174	case 'k':
1175	g_lockdown_opt = 1;
1176	break;
1177
1178	case 'r':
1179	// Do nothing, native regs is the default these days
1180	break;
1181
1182	case 'R':
1183	reverse_connect = true;
1184	break;
1185	case 'v':
1186	DNBLogSetVerbose(g: 1);
1187	break;
1188
1189	case 'V':
1190	show_version_and_exit(exit_code: 0);
1191	break;
1192
1193	case 's':
1194	ctx.GetSTDIN().assign(s: optarg);
1195	ctx.GetSTDOUT().assign(s: optarg);
1196	ctx.GetSTDERR().assign(s: optarg);
1197	break;
1198
1199	case 'I':
1200	ctx.GetSTDIN().assign(s: optarg);
1201	break;
1202
1203	case 'O':
1204	ctx.GetSTDOUT().assign(s: optarg);
1205	break;
1206
1207	case 'E':
1208	ctx.GetSTDERR().assign(s: optarg);
1209	break;
1210
1211	case 'n':
1212	no_stdio = true;
1213	break;
1214
1215	case 'S':
1216	// Put debugserver into a new session. Terminals group processes
1217	// into sessions and when a special terminal key sequences
1218	// (like control+c) are typed they can cause signals to go out to
1219	// all processes in a session. Using this --setsid (-S) option
1220	// will cause debugserver to run in its own sessions and be free
1221	// from such issues.
1222	//
1223	// This is useful when debugserver is spawned from a command
1224	// line application that uses debugserver to do the debugging,
1225	// yet that application doesn't want debugserver receiving the
1226	// signals sent to the session (i.e. dying when anyone hits ^C).
1227	setsid();
1228	break;
1229	case 'D':
1230	g_disable_aslr = 1;
1231	break;
1232
1233	case 'p':
1234	start_mode = eRNBRunLoopModePlatformMode;
1235	break;
1236
1237	case 'u':
1238	unix_socket_name.assign(s: optarg);
1239	break;
1240
1241	case 'P':
1242	named_pipe_path.assign(s: optarg);
1243	break;
1244
1245	case 'e':
1246	// Pass a single specified environment variable down to the process that
1247	// gets launched
1248	remote->Context().PushEnvironment(arg: optarg);
1249	break;
1250
1251	case 'F':
1252	forward_env = true;
1253	break;
1254
1255	case 'U':
1256	ctx.AddDefaultIgnoredExceptions();
1257	break;
1258
1259	case '2':
1260	// File descriptor passed to this process during fork/exec and is already
1261	// open and ready for communication.
1262	communication_fd = atoi(nptr: optarg);
1263	break;
1264	}
1265	}
1266
1267	if (arch_name.empty()) {
1268	#if defined(__arm__)
1269	arch_name.assign("arm");
1270	#endif
1271	} else {
1272	DNBSetArchitecture(arch: arch_name.c_str());
1273	}
1274
1275	// if (arch_name.empty())
1276	// {
1277	// fprintf(stderr, "error: no architecture was specified\n");
1278	// exit (8);
1279	// }
1280	// Skip any options we consumed with getopt_long_only
1281	argc -= optind;
1282	argv += optind;
1283
1284	if (!working_dir.empty()) {
1285	if (remote->Context().SetWorkingDirectory(working_dir.c_str()) == false) {
1286	RNBLogSTDERR("error: working directory doesn't exist '%s'.\n",
1287	working_dir.c_str());
1288	exit(status: 8);
1289	}
1290	}
1291
1292	remote->Context().SetDetachOnError(g_detach_on_error);
1293
1294	remote->Initialize();
1295
1296	// It is ok for us to set NULL as the logfile (this will disable any logging)
1297
1298	if (log_file != NULL) {
1299	DNBLog("debugserver is switching to logging to a file.");
1300	DNBLogSetLogCallback(callback: FileLogCallback, baton: log_file);
1301	// If our log file was set, yet we have no log flags, log everything!
1302	if (log_flags == 0)
1303	log_flags = LOG_ALL | LOG_RNB_ALL;
1304	}
1305	DNBLogSetLogMask(mask: log_flags);
1306
1307	if (DNBLogEnabled()) {
1308	for (i = 0; i < argc; i++)
1309	DNBLogDebug("argv[%i] = %s", i, argv[i]);
1310	}
1311
1312	// as long as we're dropping remotenub in as a replacement for gdbserver,
1313	// explicitly note that this is not gdbserver.
1314
1315	const char *in_translation = "";
1316	if (DNBDebugserverIsTranslated())
1317	in_translation = " (running under translation)";
1318	RNBLogSTDOUT("%s-%s %sfor %s%s.\n", DEBUGSERVER_PROGRAM_NAME,
1319	DEBUGSERVER_VERSION_STR, compile_options.c_str(), RNB_ARCH,
1320	in_translation);
1321
1322	std::string host;
1323	int port = INT32_MAX;
1324	char str[PATH_MAX];
1325	str[0] = '\0';
1326
1327	if (g_lockdown_opt == 0 && g_applist_opt == 0 && communication_fd == -1) {
1328	// Make sure we at least have port
1329	if (argc < 1) {
1330	show_usage_and_exit(exit_code: 1);
1331	}
1332	// accept 'localhost:' prefix on port number
1333	std::string host_specifier = argv[0];
1334	auto colon_location = host_specifier.rfind(c: ':');
1335	if (colon_location != std::string::npos) {
1336	host = host_specifier.substr(pos: 0, n: colon_location);
1337	std::string port_str =
1338	host_specifier.substr(pos: colon_location + 1, n: std::string::npos);
1339	char *end_ptr;
1340	port = strtoul(nptr: port_str.c_str(), endptr: &end_ptr, base: 0);
1341	if (end_ptr < port_str.c_str() + port_str.size())
1342	show_usage_and_exit(exit_code: 2);
1343	if (host.front() == '[' && host.back() == ']')
1344	host = host.substr(pos: 1, n: host.size() - 2);
1345	DNBLogDebug("host = '%s' port = %i", host.c_str(), port);
1346	} else {
1347	// No hostname means "localhost"
1348	int items_scanned = ::sscanf(s: argv[0], format: "%i", &port);
1349	if (items_scanned == 1) {
1350	host = "127.0.0.1";
1351	DNBLogDebug("host = '%s' port = %i", host.c_str(), port);
1352	} else if (argv[0][0] == '/') {
1353	port = INT32_MAX;
1354	strlcpy(str, argv[0], sizeof(str));
1355	} else {
1356	show_usage_and_exit(exit_code: 2);
1357	}
1358	}
1359
1360	// We just used the 'host:port' or the '/path/file' arg...
1361	argc--;
1362	argv++;
1363	}
1364
1365	// If we know we're waiting to attach, we don't need any of this other info.
1366	if (start_mode != eRNBRunLoopModeInferiorAttaching &&
1367	start_mode != eRNBRunLoopModePlatformMode) {
1368	if (argc == 0 || g_lockdown_opt) {
1369	if (g_lockdown_opt != 0) {
1370	// Work around for SIGPIPE crashes due to posix_spawn issue.
1371	// We have to close STDOUT and STDERR, else the first time we
1372	// try and do any, we get SIGPIPE and die as posix_spawn is
1373	// doing bad things with our file descriptors at the moment.
1374	int null = open(file: "/dev/null", O_RDWR);
1375	dup2(fd: null, STDOUT_FILENO);
1376	dup2(fd: null, STDERR_FILENO);
1377	} else if (g_applist_opt != 0) {
1378	DNBLog("debugserver running in --applist mode");
1379	// List all applications we are able to see
1380	std::string applist_plist;
1381	int err = ListApplications(plist&: applist_plist, opt_runningApps: false, opt_debuggable: false);
1382	if (err == 0) {
1383	fputs(s: applist_plist.c_str(), stdout);
1384	} else {
1385	RNBLogSTDERR("error: ListApplications returned error %i\n", err);
1386	}
1387	// Exit with appropriate error if we were asked to list the applications
1388	// with no other args were given (and we weren't trying to do this over
1389	// lockdown)
1390	return err;
1391	}
1392
1393	DNBLogDebug("Get args from remote protocol...");
1394	start_mode = eRNBRunLoopModeGetStartModeFromRemoteProtocol;
1395	} else {
1396	start_mode = eRNBRunLoopModeInferiorLaunching;
1397	// Fill in the argv array in the context from the rest of our args.
1398	// Skip the name of this executable and the port number
1399	for (int i = 0; i < argc; i++) {
1400	DNBLogDebug("inferior_argv[%i] = '%s'", i, argv[i]);
1401	ctx.PushArgument(arg: argv[i]);
1402	}
1403	}
1404	}
1405
1406	if (start_mode == eRNBRunLoopModeExit)
1407	return -1;
1408
1409	if (forward_env || start_mode == eRNBRunLoopModeInferiorLaunching) {
1410	// Pass the current environment down to the process that gets launched
1411	// This happens automatically in the "launching" mode. For the rest, we
1412	// only do that if the user explicitly requested this via --forward-env
1413	// argument.
1414	char **host_env = *_NSGetEnviron();
1415	char *env_entry;
1416	size_t i;
1417	for (i = 0; (env_entry = host_env[i]) != NULL; ++i)
1418	remote->Context().PushEnvironmentIfNeeded(arg: env_entry);
1419	}
1420
1421	RNBRunLoopMode mode = start_mode;
1422	char err_str[1024] = {'\0'};
1423
1424	while (mode != eRNBRunLoopModeExit) {
1425	switch (mode) {
1426	case eRNBRunLoopModeGetStartModeFromRemoteProtocol:
1427	#ifdef WITH_LOCKDOWN
1428	if (g_lockdown_opt) {
1429	if (!remote->Comm().IsConnected()) {
1430	if (remote->Comm().ConnectToService() != rnb_success) {
1431	RNBLogSTDERR(
1432	"Failed to get connection from a remote gdb process.\n");
1433	mode = eRNBRunLoopModeExit;
1434	} else if (g_applist_opt != 0) {
1435	// List all applications we are able to see
1436	DNBLog("debugserver running in applist mode under lockdown");
1437	std::string applist_plist;
1438	if (ListApplications(applist_plist, false, false) == 0) {
1439	DNBLogDebug("Task list: %s", applist_plist.c_str());
1440
1441	remote->Comm().Write(applist_plist.c_str(), applist_plist.size());
1442	// Issue a read that will never yield any data until the other
1443	// side
1444	// closes the socket so this process doesn't just exit and cause
1445	// the
1446	// socket to close prematurely on the other end and cause data
1447	// loss.
1448	std::string buf;
1449	remote->Comm().Read(buf);
1450	}
1451	remote->Comm().Disconnect(false);
1452	mode = eRNBRunLoopModeExit;
1453	break;
1454	} else {
1455	// Start watching for remote packets
1456	remote->StartReadRemoteDataThread();
1457	}
1458	}
1459	} else
1460	#endif
1461	if (port != INT32_MAX) {
1462	if (!ConnectRemote(remote, host: host.c_str(), port, reverse_connect,
1463	named_pipe_path: named_pipe_path.c_str(), unix_socket_name: unix_socket_name.c_str()))
1464	mode = eRNBRunLoopModeExit;
1465	} else if (str[0] == '/') {
1466	if (remote->Comm().OpenFile(path: str))
1467	mode = eRNBRunLoopModeExit;
1468	} else if (communication_fd >= 0) {
1469	// We were passed a file descriptor to use during fork/exec that is
1470	// already open
1471	// in our process, so lets just use it!
1472	if (remote->Comm().useFD(fd: communication_fd))
1473	mode = eRNBRunLoopModeExit;
1474	else
1475	remote->StartReadRemoteDataThread();
1476	}
1477
1478	if (mode != eRNBRunLoopModeExit) {
1479	RNBLogSTDOUT("Got a connection, waiting for process information for "
1480	"launching or attaching.\n");
1481
1482	mode = RNBRunLoopGetStartModeFromRemote(remote);
1483	}
1484	break;
1485
1486	case eRNBRunLoopModeInferiorAttaching:
1487	if (!waitfor_pid_name.empty()) {
1488	// Set our end wait time if we are using a waitfor-duration
1489	// option that may have been specified
1490	struct timespec attach_timeout_abstime, *timeout_ptr = NULL;
1491	if (waitfor_duration != 0) {
1492	DNBTimer::OffsetTimeOfDay(&attach_timeout_abstime, waitfor_duration,
1493	0);
1494	timeout_ptr = &attach_timeout_abstime;
1495	}
1496	nub_launch_flavor_t launch_flavor = g_launch_flavor;
1497	if (launch_flavor == eLaunchFlavorDefault)
1498	launch_flavor = default_launch_flavor(app_name: waitfor_pid_name.c_str());
1499
1500	ctx.SetLaunchFlavor(launch_flavor);
1501	bool ignore_existing = false;
1502	RNBLogSTDOUT("Waiting to attach to process %s...\n",
1503	waitfor_pid_name.c_str());
1504	nub_process_t pid = DNBProcessAttachWait(
1505	ctx: &ctx, wait_name: waitfor_pid_name.c_str(), ignore_existing, timeout: timeout_ptr,
1506	interval: waitfor_interval, err_str, err_len: sizeof(err_str));
1507	g_pid = pid;
1508
1509	if (pid == INVALID_NUB_PROCESS) {
1510	ctx.LaunchStatus().SetError(err: -1, flavor: DNBError::Generic);
1511	if (err_str[0])
1512	ctx.LaunchStatus().SetErrorString(err_str);
1513	RNBLogSTDERR("error: failed to attach to process named: \"%s\" %s\n",
1514	waitfor_pid_name.c_str(), err_str);
1515	mode = eRNBRunLoopModeExit;
1516	} else {
1517	ctx.SetProcessID(pid);
1518	mode = eRNBRunLoopModeInferiorExecuting;
1519	}
1520	} else if (attach_pid != INVALID_NUB_PROCESS) {
1521
1522	RNBLogSTDOUT("Attaching to process %i...\n", attach_pid);
1523	nub_process_t attached_pid;
1524	mode = RNBRunLoopLaunchAttaching(remote, attach_pid, pid&: attached_pid);
1525	if (mode != eRNBRunLoopModeInferiorExecuting) {
1526	const char *error_str = remote->Context().LaunchStatus().AsString();
1527	RNBLogSTDERR("error: failed to attach process %i: %s\n", attach_pid,
1528	error_str ? error_str : "unknown error.");
1529	mode = eRNBRunLoopModeExit;
1530	}
1531	} else if (!attach_pid_name.empty()) {
1532	struct timespec attach_timeout_abstime, *timeout_ptr = NULL;
1533	if (waitfor_duration != 0) {
1534	DNBTimer::OffsetTimeOfDay(&attach_timeout_abstime, waitfor_duration,
1535	0);
1536	timeout_ptr = &attach_timeout_abstime;
1537	}
1538
1539	RNBLogSTDOUT("Attaching to process %s...\n", attach_pid_name.c_str());
1540	nub_process_t pid = DNBProcessAttachByName(
1541	attach_pid_name.c_str(), timeout_ptr, ctx.GetIgnoredExceptions(),
1542	err_str, sizeof(err_str));
1543	g_pid = pid;
1544	if (pid == INVALID_NUB_PROCESS) {
1545	ctx.LaunchStatus().SetError(err: -1, flavor: DNBError::Generic);
1546	if (err_str[0])
1547	ctx.LaunchStatus().SetErrorString(err_str);
1548	RNBLogSTDERR("error: failed to attach to process named: \"%s\" %s\n",
1549	waitfor_pid_name.c_str(), err_str);
1550	mode = eRNBRunLoopModeExit;
1551	} else {
1552	ctx.SetProcessID(pid);
1553	mode = eRNBRunLoopModeInferiorExecuting;
1554	}
1555
1556	} else {
1557	RNBLogSTDERR(
1558	"error: asked to attach with empty name and invalid PID.\n");
1559	mode = eRNBRunLoopModeExit;
1560	}
1561
1562	if (mode != eRNBRunLoopModeExit) {
1563	if (port != INT32_MAX) {
1564	if (!ConnectRemote(remote, host: host.c_str(), port, reverse_connect,
1565	named_pipe_path: named_pipe_path.c_str(), unix_socket_name: unix_socket_name.c_str()))
1566	mode = eRNBRunLoopModeExit;
1567	} else if (str[0] == '/') {
1568	if (remote->Comm().OpenFile(path: str))
1569	mode = eRNBRunLoopModeExit;
1570	} else if (communication_fd >= 0) {
1571	// We were passed a file descriptor to use during fork/exec that is
1572	// already open
1573	// in our process, so lets just use it!
1574	if (remote->Comm().useFD(fd: communication_fd))
1575	mode = eRNBRunLoopModeExit;
1576	else
1577	remote->StartReadRemoteDataThread();
1578	}
1579
1580	if (mode != eRNBRunLoopModeExit)
1581	RNBLogSTDOUT("Waiting for debugger instructions for process %d.\n",
1582	attach_pid);
1583	}
1584	break;
1585
1586	case eRNBRunLoopModeInferiorLaunching: {
1587	mode = RNBRunLoopLaunchInferior(remote, stdin_path: ctx.GetSTDINPath(),
1588	stdout_path: ctx.GetSTDOUTPath(), stderr_path: ctx.GetSTDERRPath(),
1589	no_stdio);
1590
1591	if (mode == eRNBRunLoopModeInferiorExecuting) {
1592	if (port != INT32_MAX) {
1593	if (!ConnectRemote(remote, host: host.c_str(), port, reverse_connect,
1594	named_pipe_path: named_pipe_path.c_str(), unix_socket_name: unix_socket_name.c_str()))
1595	mode = eRNBRunLoopModeExit;
1596	} else if (str[0] == '/') {
1597	if (remote->Comm().OpenFile(path: str))
1598	mode = eRNBRunLoopModeExit;
1599	} else if (communication_fd >= 0) {
1600	// We were passed a file descriptor to use during fork/exec that is
1601	// already open
1602	// in our process, so lets just use it!
1603	if (remote->Comm().useFD(fd: communication_fd))
1604	mode = eRNBRunLoopModeExit;
1605	else
1606	remote->StartReadRemoteDataThread();
1607	}
1608
1609	if (mode != eRNBRunLoopModeExit) {
1610	const char *proc_name = "<unknown>";
1611	if (ctx.ArgumentCount() > 0)
1612	proc_name = ctx.ArgumentAtIndex(index: 0);
1613	DNBLog("[LaunchAttach] Successfully launched %s (pid = %d).\n",
1614	proc_name, ctx.ProcessID());
1615	RNBLogSTDOUT("Got a connection, launched process %s (pid = %d).\n",
1616	proc_name, ctx.ProcessID());
1617	}
1618	} else {
1619	const char *error_str = remote->Context().LaunchStatus().AsString();
1620	RNBLogSTDERR("error: failed to launch process %s: %s\n", argv_sub_zero,
1621	error_str ? error_str : "unknown error.");
1622	}
1623	} break;
1624
1625	case eRNBRunLoopModeInferiorExecuting:
1626	mode = RNBRunLoopInferiorExecuting(remote);
1627	break;
1628
1629	case eRNBRunLoopModePlatformMode:
1630	if (port != INT32_MAX) {
1631	if (!ConnectRemote(remote, host: host.c_str(), port, reverse_connect,
1632	named_pipe_path: named_pipe_path.c_str(), unix_socket_name: unix_socket_name.c_str()))
1633	mode = eRNBRunLoopModeExit;
1634	} else if (str[0] == '/') {
1635	if (remote->Comm().OpenFile(path: str))
1636	mode = eRNBRunLoopModeExit;
1637	} else if (communication_fd >= 0) {
1638	// We were passed a file descriptor to use during fork/exec that is
1639	// already open
1640	// in our process, so lets just use it!
1641	if (remote->Comm().useFD(fd: communication_fd))
1642	mode = eRNBRunLoopModeExit;
1643	else
1644	remote->StartReadRemoteDataThread();
1645	}
1646
1647	if (mode != eRNBRunLoopModeExit)
1648	mode = RNBRunLoopPlatform(remote);
1649	break;
1650
1651	default:
1652	mode = eRNBRunLoopModeExit;
1653	break;
1654	case eRNBRunLoopModeExit:
1655	break;
1656	}
1657	}
1658
1659	remote->StopReadRemoteDataThread();
1660	remote->Context().SetProcessID(INVALID_NUB_PROCESS);
1661	RNBLogSTDOUT("Exiting.\n");
1662
1663	return 0;
1664	}
1665