1 //===-- CommandObjectPlatform.cpp -------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/lldb-python.h"
11 
12 #include "CommandObjectPlatform.h"
13 
14 // C Includes
15 // C++ Includes
16 // Other libraries and framework includes
17 // Project includes
18 #include "lldb/Core/DataExtractor.h"
19 #include "lldb/Core/Debugger.h"
20 #include "lldb/Core/Module.h"
21 #include "lldb/Core/PluginManager.h"
22 #include "lldb/Host/StringConvert.h"
23 #include "lldb/Interpreter/Args.h"
24 #include "lldb/Interpreter/CommandInterpreter.h"
25 #include "lldb/Interpreter/CommandOptionValidators.h"
26 #include "lldb/Interpreter/CommandReturnObject.h"
27 #include "lldb/Interpreter/OptionGroupFile.h"
28 #include "lldb/Interpreter/OptionGroupPlatform.h"
29 #include "lldb/Target/ExecutionContext.h"
30 #include "lldb/Target/Platform.h"
31 #include "lldb/Target/Process.h"
32 #include "lldb/Utility/Utils.h"
33 
34 using namespace lldb;
35 using namespace lldb_private;
36 
37 static mode_t
38 ParsePermissionString(const char* permissions)
39 {
40     if (strlen(permissions) != 9)
41         return (mode_t)(-1);
42     bool user_r,user_w,user_x,
43     group_r,group_w,group_x,
44     world_r,world_w,world_x;
45 
46     user_r = (permissions[0] == 'r');
47     user_w = (permissions[1] == 'w');
48     user_x = (permissions[2] == 'x');
49 
50     group_r = (permissions[3] == 'r');
51     group_w = (permissions[4] == 'w');
52     group_x = (permissions[5] == 'x');
53 
54     world_r = (permissions[6] == 'r');
55     world_w = (permissions[7] == 'w');
56     world_x = (permissions[8] == 'x');
57 
58     mode_t user,group,world;
59     user = (user_r ? 4 : 0) | (user_w ? 2 : 0) | (user_x ? 1 : 0);
60     group = (group_r ? 4 : 0) | (group_w ? 2 : 0) | (group_x ? 1 : 0);
61     world = (world_r ? 4 : 0) | (world_w ? 2 : 0) | (world_x ? 1 : 0);
62 
63     return user | group | world;
64 }
65 
66 static OptionDefinition
67 g_permissions_options[] =
68 {
69     {   LLDB_OPT_SET_ALL, false, "permissions-value",   'v', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePermissionsNumber         , "Give out the numeric value for permissions (e.g. 757)" },
70     {   LLDB_OPT_SET_ALL, false, "permissions-string",  's', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePermissionsString  , "Give out the string value for permissions (e.g. rwxr-xr--)." },
71     {   LLDB_OPT_SET_ALL, false, "user-read",           'r', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow user to read." },
72     {   LLDB_OPT_SET_ALL, false, "user-write",          'w', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow user to write." },
73     {   LLDB_OPT_SET_ALL, false, "user-exec",           'x', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow user to execute." },
74 
75     {   LLDB_OPT_SET_ALL, false, "group-read",          'R', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow group to read." },
76     {   LLDB_OPT_SET_ALL, false, "group-write",         'W', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow group to write." },
77     {   LLDB_OPT_SET_ALL, false, "group-exec",          'X', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow group to execute." },
78 
79     {   LLDB_OPT_SET_ALL, false, "world-read",          'd', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow world to read." },
80     {   LLDB_OPT_SET_ALL, false, "world-write",         't', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow world to write." },
81     {   LLDB_OPT_SET_ALL, false, "world-exec",          'e', OptionParser::eNoArgument,       NULL, NULL, 0, eArgTypeNone         , "Allow world to execute." },
82 };
83 
84 class OptionPermissions : public lldb_private::OptionGroup
85 {
86 public:
87     OptionPermissions ()
88     {
89     }
90 
91     virtual
92     ~OptionPermissions ()
93     {
94     }
95 
96     virtual lldb_private::Error
97     SetOptionValue (CommandInterpreter &interpreter,
98                     uint32_t option_idx,
99                     const char *option_arg)
100     {
101         Error error;
102         char short_option = (char) GetDefinitions()[option_idx].short_option;
103         switch (short_option)
104         {
105             case 'v':
106             {
107                 bool ok;
108                 uint32_t perms = StringConvert::ToUInt32(option_arg, 777, 8, &ok);
109                 if (!ok)
110                     error.SetErrorStringWithFormat("invalid value for permissions: %s", option_arg);
111                 else
112                     m_permissions = perms;
113             }
114                 break;
115             case 's':
116             {
117                 mode_t perms = ParsePermissionString(option_arg);
118                 if (perms == (mode_t)-1)
119                     error.SetErrorStringWithFormat("invalid value for permissions: %s", option_arg);
120                 else
121                     m_permissions = perms;
122             }
123             case 'r':
124                 m_permissions |= lldb::eFilePermissionsUserRead;
125                 break;
126             case 'w':
127                 m_permissions |= lldb::eFilePermissionsUserWrite;
128                 break;
129             case 'x':
130                 m_permissions |= lldb::eFilePermissionsUserExecute;
131                 break;
132             case 'R':
133                 m_permissions |= lldb::eFilePermissionsGroupRead;
134                 break;
135             case 'W':
136                 m_permissions |= lldb::eFilePermissionsGroupWrite;
137                 break;
138             case 'X':
139                 m_permissions |= lldb::eFilePermissionsGroupExecute;
140                 break;
141             case 'd':
142                 m_permissions |= lldb::eFilePermissionsWorldRead;
143                 break;
144             case 't':
145                 m_permissions |= lldb::eFilePermissionsWorldWrite;
146                 break;
147             case 'e':
148                 m_permissions |= lldb::eFilePermissionsWorldExecute;
149                 break;
150 
151             default:
152                 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
153                 break;
154         }
155 
156         return error;
157     }
158 
159     void
160     OptionParsingStarting (CommandInterpreter &interpreter)
161     {
162         m_permissions = 0;
163     }
164 
165     virtual uint32_t
166     GetNumDefinitions ()
167     {
168         return llvm::array_lengthof(g_permissions_options);
169     }
170 
171     const lldb_private::OptionDefinition*
172     GetDefinitions ()
173     {
174         return g_permissions_options;
175     }
176 
177     // Instance variables to hold the values for command options.
178 
179     uint32_t m_permissions;
180 private:
181     DISALLOW_COPY_AND_ASSIGN(OptionPermissions);
182 };
183 
184 //----------------------------------------------------------------------
185 // "platform select <platform-name>"
186 //----------------------------------------------------------------------
187 class CommandObjectPlatformSelect : public CommandObjectParsed
188 {
189 public:
190     CommandObjectPlatformSelect (CommandInterpreter &interpreter) :
191         CommandObjectParsed (interpreter,
192                              "platform select",
193                              "Create a platform if needed and select it as the current platform.",
194                              "platform select <platform-name>",
195                              0),
196         m_option_group (interpreter),
197         m_platform_options (false) // Don't include the "--platform" option by passing false
198     {
199         m_option_group.Append (&m_platform_options, LLDB_OPT_SET_ALL, 1);
200         m_option_group.Finalize();
201     }
202 
203     virtual
204     ~CommandObjectPlatformSelect ()
205     {
206     }
207 
208     virtual int
209     HandleCompletion (Args &input,
210                       int &cursor_index,
211                       int &cursor_char_position,
212                       int match_start_point,
213                       int max_return_elements,
214                       bool &word_complete,
215                       StringList &matches)
216     {
217         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
218         completion_str.erase (cursor_char_position);
219 
220         CommandCompletions::PlatformPluginNames (m_interpreter,
221                                                  completion_str.c_str(),
222                                                  match_start_point,
223                                                  max_return_elements,
224                                                  NULL,
225                                                  word_complete,
226                                                  matches);
227         return matches.GetSize();
228     }
229 
230     virtual Options *
231     GetOptions ()
232     {
233         return &m_option_group;
234     }
235 
236 protected:
237     virtual bool
238     DoExecute (Args& args, CommandReturnObject &result)
239     {
240         if (args.GetArgumentCount() == 1)
241         {
242             const char *platform_name = args.GetArgumentAtIndex (0);
243             if (platform_name && platform_name[0])
244             {
245                 const bool select = true;
246                 m_platform_options.SetPlatformName (platform_name);
247                 Error error;
248                 ArchSpec platform_arch;
249                 PlatformSP platform_sp (m_platform_options.CreatePlatformWithOptions (m_interpreter, ArchSpec(), select, error, platform_arch));
250                 if (platform_sp)
251                 {
252                     m_interpreter.GetDebugger().GetPlatformList().SetSelectedPlatform(platform_sp);
253 
254                     platform_sp->GetStatus (result.GetOutputStream());
255                     result.SetStatus (eReturnStatusSuccessFinishResult);
256                 }
257                 else
258                 {
259                     result.AppendError(error.AsCString());
260                     result.SetStatus (eReturnStatusFailed);
261                 }
262             }
263             else
264             {
265                 result.AppendError ("invalid platform name");
266                 result.SetStatus (eReturnStatusFailed);
267             }
268         }
269         else
270         {
271             result.AppendError ("platform create takes a platform name as an argument\n");
272             result.SetStatus (eReturnStatusFailed);
273         }
274         return result.Succeeded();
275     }
276 
277     OptionGroupOptions m_option_group;
278     OptionGroupPlatform m_platform_options;
279 };
280 
281 //----------------------------------------------------------------------
282 // "platform list"
283 //----------------------------------------------------------------------
284 class CommandObjectPlatformList : public CommandObjectParsed
285 {
286 public:
287     CommandObjectPlatformList (CommandInterpreter &interpreter) :
288         CommandObjectParsed (interpreter,
289                              "platform list",
290                              "List all platforms that are available.",
291                              NULL,
292                              0)
293     {
294     }
295 
296     virtual
297     ~CommandObjectPlatformList ()
298     {
299     }
300 
301 protected:
302     virtual bool
303     DoExecute (Args& args, CommandReturnObject &result)
304     {
305         Stream &ostrm = result.GetOutputStream();
306         ostrm.Printf("Available platforms:\n");
307 
308         PlatformSP host_platform_sp (Platform::GetHostPlatform());
309         ostrm.Printf ("%s: %s\n",
310                       host_platform_sp->GetPluginName().GetCString(),
311                       host_platform_sp->GetDescription());
312 
313         uint32_t idx;
314         for (idx = 0; 1; ++idx)
315         {
316             const char *plugin_name = PluginManager::GetPlatformPluginNameAtIndex (idx);
317             if (plugin_name == NULL)
318                 break;
319             const char *plugin_desc = PluginManager::GetPlatformPluginDescriptionAtIndex (idx);
320             if (plugin_desc == NULL)
321                 break;
322             ostrm.Printf("%s: %s\n", plugin_name, plugin_desc);
323         }
324 
325         if (idx == 0)
326         {
327             result.AppendError ("no platforms are available\n");
328             result.SetStatus (eReturnStatusFailed);
329         }
330         else
331             result.SetStatus (eReturnStatusSuccessFinishResult);
332         return result.Succeeded();
333     }
334 };
335 
336 //----------------------------------------------------------------------
337 // "platform status"
338 //----------------------------------------------------------------------
339 class CommandObjectPlatformStatus : public CommandObjectParsed
340 {
341 public:
342     CommandObjectPlatformStatus (CommandInterpreter &interpreter) :
343         CommandObjectParsed (interpreter,
344                              "platform status",
345                              "Display status for the currently selected platform.",
346                              NULL,
347                              0)
348     {
349     }
350 
351     virtual
352     ~CommandObjectPlatformStatus ()
353     {
354     }
355 
356 protected:
357     virtual bool
358     DoExecute (Args& args, CommandReturnObject &result)
359     {
360         Stream &ostrm = result.GetOutputStream();
361 
362         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
363         PlatformSP platform_sp;
364         if (target)
365         {
366             platform_sp = target->GetPlatform();
367         }
368         if (!platform_sp)
369         {
370             platform_sp = m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform();
371         }
372         if (platform_sp)
373         {
374             platform_sp->GetStatus (ostrm);
375             result.SetStatus (eReturnStatusSuccessFinishResult);
376         }
377         else
378         {
379             result.AppendError ("no platform us currently selected\n");
380             result.SetStatus (eReturnStatusFailed);
381         }
382         return result.Succeeded();
383     }
384 };
385 
386 //----------------------------------------------------------------------
387 // "platform connect <connect-url>"
388 //----------------------------------------------------------------------
389 class CommandObjectPlatformConnect : public CommandObjectParsed
390 {
391 public:
392     CommandObjectPlatformConnect (CommandInterpreter &interpreter) :
393         CommandObjectParsed (interpreter,
394                              "platform connect",
395                              "Connect a platform by name to be the currently selected platform.",
396                              "platform connect <connect-url>",
397                              0)
398     {
399     }
400 
401     virtual
402     ~CommandObjectPlatformConnect ()
403     {
404     }
405 
406 protected:
407     virtual bool
408     DoExecute (Args& args, CommandReturnObject &result)
409     {
410         Stream &ostrm = result.GetOutputStream();
411 
412         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
413         if (platform_sp)
414         {
415             Error error (platform_sp->ConnectRemote (args));
416             if (error.Success())
417             {
418                 platform_sp->GetStatus (ostrm);
419                 result.SetStatus (eReturnStatusSuccessFinishResult);
420             }
421             else
422             {
423                 result.AppendErrorWithFormat ("%s\n", error.AsCString());
424                 result.SetStatus (eReturnStatusFailed);
425             }
426         }
427         else
428         {
429             result.AppendError ("no platform is currently selected\n");
430             result.SetStatus (eReturnStatusFailed);
431         }
432         return result.Succeeded();
433     }
434 
435     virtual Options *
436     GetOptions ()
437     {
438         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
439         OptionGroupOptions* m_platform_options = NULL;
440         if (platform_sp)
441         {
442             m_platform_options = platform_sp->GetConnectionOptions(m_interpreter);
443             if (m_platform_options != NULL && !m_platform_options->m_did_finalize)
444                 m_platform_options->Finalize();
445         }
446         return m_platform_options;
447     }
448 
449 };
450 
451 //----------------------------------------------------------------------
452 // "platform disconnect"
453 //----------------------------------------------------------------------
454 class CommandObjectPlatformDisconnect : public CommandObjectParsed
455 {
456 public:
457     CommandObjectPlatformDisconnect (CommandInterpreter &interpreter) :
458         CommandObjectParsed (interpreter,
459                              "platform disconnect",
460                              "Disconnect a platform by name to be the currently selected platform.",
461                              "platform disconnect",
462                              0)
463     {
464     }
465 
466     virtual
467     ~CommandObjectPlatformDisconnect ()
468     {
469     }
470 
471 protected:
472     virtual bool
473     DoExecute (Args& args, CommandReturnObject &result)
474     {
475         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
476         if (platform_sp)
477         {
478             if (args.GetArgumentCount() == 0)
479             {
480                 Error error;
481 
482                 if (platform_sp->IsConnected())
483                 {
484                     // Cache the instance name if there is one since we are
485                     // about to disconnect and the name might go with it.
486                     const char *hostname_cstr = platform_sp->GetHostname();
487                     std::string hostname;
488                     if (hostname_cstr)
489                         hostname.assign (hostname_cstr);
490 
491                     error = platform_sp->DisconnectRemote ();
492                     if (error.Success())
493                     {
494                         Stream &ostrm = result.GetOutputStream();
495                         if (hostname.empty())
496                             ostrm.Printf ("Disconnected from \"%s\"\n", platform_sp->GetPluginName().GetCString());
497                         else
498                             ostrm.Printf ("Disconnected from \"%s\"\n", hostname.c_str());
499                         result.SetStatus (eReturnStatusSuccessFinishResult);
500                     }
501                     else
502                     {
503                         result.AppendErrorWithFormat ("%s", error.AsCString());
504                         result.SetStatus (eReturnStatusFailed);
505                     }
506                 }
507                 else
508                 {
509                     // Not connected...
510                     result.AppendErrorWithFormat ("not connected to '%s'", platform_sp->GetPluginName().GetCString());
511                     result.SetStatus (eReturnStatusFailed);
512                 }
513             }
514             else
515             {
516                 // Bad args
517                 result.AppendError ("\"platform disconnect\" doesn't take any arguments");
518                 result.SetStatus (eReturnStatusFailed);
519             }
520         }
521         else
522         {
523             result.AppendError ("no platform is currently selected");
524             result.SetStatus (eReturnStatusFailed);
525         }
526         return result.Succeeded();
527     }
528 };
529 
530 //----------------------------------------------------------------------
531 // "platform settings"
532 //----------------------------------------------------------------------
533 class CommandObjectPlatformSettings : public CommandObjectParsed
534 {
535 public:
536     CommandObjectPlatformSettings (CommandInterpreter &interpreter) :
537         CommandObjectParsed (interpreter,
538                              "platform settings",
539                              "Set settings for the current target's platform, or for a platform by name.",
540                              "platform settings",
541                              0),
542         m_options (interpreter),
543         m_option_working_dir (LLDB_OPT_SET_1, false, "working-dir", 'w', 0, eArgTypePath, "The working directory for the platform.")
544     {
545         m_options.Append (&m_option_working_dir, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
546     }
547 
548     virtual
549     ~CommandObjectPlatformSettings ()
550     {
551     }
552 
553 protected:
554     virtual bool
555     DoExecute (Args& args, CommandReturnObject &result)
556     {
557         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
558         if (platform_sp)
559         {
560             if (m_option_working_dir.GetOptionValue().OptionWasSet())
561                 platform_sp->SetWorkingDirectory (ConstString(m_option_working_dir.GetOptionValue().GetCurrentValue().GetPath().c_str()));
562         }
563         else
564         {
565             result.AppendError ("no platform is currently selected");
566             result.SetStatus (eReturnStatusFailed);
567         }
568         return result.Succeeded();
569     }
570 
571     virtual Options *
572     GetOptions ()
573     {
574         if (m_options.DidFinalize() == false)
575         {
576             m_options.Append(new OptionPermissions());
577             m_options.Finalize();
578         }
579         return &m_options;
580     }
581 protected:
582 
583     OptionGroupOptions m_options;
584     OptionGroupFile m_option_working_dir;
585 
586 };
587 
588 
589 //----------------------------------------------------------------------
590 // "platform mkdir"
591 //----------------------------------------------------------------------
592 class CommandObjectPlatformMkDir : public CommandObjectParsed
593 {
594 public:
595     CommandObjectPlatformMkDir (CommandInterpreter &interpreter) :
596     CommandObjectParsed (interpreter,
597                          "platform mkdir",
598                          "Make a new directory on the remote end.",
599                          NULL,
600                          0),
601     m_options(interpreter)
602     {
603     }
604 
605     virtual
606     ~CommandObjectPlatformMkDir ()
607     {
608     }
609 
610     virtual bool
611     DoExecute (Args& args, CommandReturnObject &result)
612     {
613         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
614         if (platform_sp)
615         {
616             std::string cmd_line;
617             args.GetCommandString(cmd_line);
618             uint32_t mode;
619             const OptionPermissions* options_permissions = (const OptionPermissions*)m_options.GetGroupWithOption('r');
620             if (options_permissions)
621                 mode = options_permissions->m_permissions;
622             else
623                 mode = lldb::eFilePermissionsUserRWX | lldb::eFilePermissionsGroupRWX | lldb::eFilePermissionsWorldRX;
624             Error error = platform_sp->MakeDirectory(cmd_line.c_str(), mode);
625             if (error.Success())
626             {
627                 result.SetStatus (eReturnStatusSuccessFinishResult);
628             }
629             else
630             {
631                 result.AppendError(error.AsCString());
632                 result.SetStatus (eReturnStatusFailed);
633             }
634         }
635         else
636         {
637             result.AppendError ("no platform currently selected\n");
638             result.SetStatus (eReturnStatusFailed);
639         }
640         return result.Succeeded();
641     }
642 
643     virtual Options *
644     GetOptions ()
645     {
646         if (m_options.DidFinalize() == false)
647         {
648             m_options.Append(new OptionPermissions());
649             m_options.Finalize();
650         }
651         return &m_options;
652     }
653     OptionGroupOptions m_options;
654 
655 };
656 
657 //----------------------------------------------------------------------
658 // "platform fopen"
659 //----------------------------------------------------------------------
660 class CommandObjectPlatformFOpen : public CommandObjectParsed
661 {
662 public:
663     CommandObjectPlatformFOpen (CommandInterpreter &interpreter) :
664     CommandObjectParsed (interpreter,
665                          "platform file open",
666                          "Open a file on the remote end.",
667                          NULL,
668                          0),
669     m_options(interpreter)
670     {
671     }
672 
673     virtual
674     ~CommandObjectPlatformFOpen ()
675     {
676     }
677 
678     virtual bool
679     DoExecute (Args& args, CommandReturnObject &result)
680     {
681         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
682         if (platform_sp)
683         {
684             Error error;
685             std::string cmd_line;
686             args.GetCommandString(cmd_line);
687             mode_t perms;
688             const OptionPermissions* options_permissions = (const OptionPermissions*)m_options.GetGroupWithOption('r');
689             if (options_permissions)
690                 perms = options_permissions->m_permissions;
691             else
692                 perms = lldb::eFilePermissionsUserRW | lldb::eFilePermissionsGroupRW | lldb::eFilePermissionsWorldRead;
693             lldb::user_id_t fd = platform_sp->OpenFile(FileSpec(cmd_line.c_str(),false),
694                                                        File::eOpenOptionRead | File::eOpenOptionWrite |
695                                                        File::eOpenOptionAppend | File::eOpenOptionCanCreate,
696                                                        perms,
697                                                        error);
698             if (error.Success())
699             {
700                 result.AppendMessageWithFormat("File Descriptor = %" PRIu64 "\n",fd);
701                 result.SetStatus (eReturnStatusSuccessFinishResult);
702             }
703             else
704             {
705                 result.AppendError(error.AsCString());
706                 result.SetStatus (eReturnStatusFailed);
707             }
708         }
709         else
710         {
711             result.AppendError ("no platform currently selected\n");
712             result.SetStatus (eReturnStatusFailed);
713         }
714         return result.Succeeded();
715     }
716     virtual Options *
717     GetOptions ()
718     {
719         if (m_options.DidFinalize() == false)
720         {
721             m_options.Append(new OptionPermissions());
722             m_options.Finalize();
723         }
724         return &m_options;
725     }
726     OptionGroupOptions m_options;
727 };
728 
729 //----------------------------------------------------------------------
730 // "platform fclose"
731 //----------------------------------------------------------------------
732 class CommandObjectPlatformFClose : public CommandObjectParsed
733 {
734 public:
735     CommandObjectPlatformFClose (CommandInterpreter &interpreter) :
736     CommandObjectParsed (interpreter,
737                          "platform file close",
738                          "Close a file on the remote end.",
739                          NULL,
740                          0)
741     {
742     }
743 
744     virtual
745     ~CommandObjectPlatformFClose ()
746     {
747     }
748 
749     virtual bool
750     DoExecute (Args& args, CommandReturnObject &result)
751     {
752         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
753         if (platform_sp)
754         {
755             std::string cmd_line;
756             args.GetCommandString(cmd_line);
757             const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
758             Error error;
759             bool success = platform_sp->CloseFile(fd, error);
760             if (success)
761             {
762                 result.AppendMessageWithFormat("file %" PRIu64 " closed.\n", fd);
763                 result.SetStatus (eReturnStatusSuccessFinishResult);
764             }
765             else
766             {
767                 result.AppendError(error.AsCString());
768                 result.SetStatus (eReturnStatusFailed);
769             }
770         }
771         else
772         {
773             result.AppendError ("no platform currently selected\n");
774             result.SetStatus (eReturnStatusFailed);
775         }
776         return result.Succeeded();
777     }
778 };
779 
780 //----------------------------------------------------------------------
781 // "platform fread"
782 //----------------------------------------------------------------------
783 class CommandObjectPlatformFRead : public CommandObjectParsed
784 {
785 public:
786     CommandObjectPlatformFRead (CommandInterpreter &interpreter) :
787     CommandObjectParsed (interpreter,
788                          "platform file read",
789                          "Read data from a file on the remote end.",
790                          NULL,
791                          0),
792     m_options (interpreter)
793     {
794     }
795 
796     virtual
797     ~CommandObjectPlatformFRead ()
798     {
799     }
800 
801     virtual bool
802     DoExecute (Args& args, CommandReturnObject &result)
803     {
804         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
805         if (platform_sp)
806         {
807             std::string cmd_line;
808             args.GetCommandString(cmd_line);
809             const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
810             std::string buffer(m_options.m_count,0);
811             Error error;
812             uint32_t retcode = platform_sp->ReadFile(fd, m_options.m_offset, &buffer[0], m_options.m_count, error);
813             result.AppendMessageWithFormat("Return = %d\n",retcode);
814             result.AppendMessageWithFormat("Data = \"%s\"\n",buffer.c_str());
815             result.SetStatus (eReturnStatusSuccessFinishResult);
816         }
817         else
818         {
819             result.AppendError ("no platform currently selected\n");
820             result.SetStatus (eReturnStatusFailed);
821         }
822         return result.Succeeded();
823     }
824     virtual Options *
825     GetOptions ()
826     {
827         return &m_options;
828     }
829 
830 protected:
831     class CommandOptions : public Options
832     {
833     public:
834 
835         CommandOptions (CommandInterpreter &interpreter) :
836         Options (interpreter)
837         {
838         }
839 
840         virtual
841         ~CommandOptions ()
842         {
843         }
844 
845         virtual Error
846         SetOptionValue (uint32_t option_idx, const char *option_arg)
847         {
848             Error error;
849             char short_option = (char) m_getopt_table[option_idx].val;
850             bool success = false;
851 
852             switch (short_option)
853             {
854                 case 'o':
855                     m_offset = StringConvert::ToUInt32(option_arg, 0, 0, &success);
856                     if (!success)
857                         error.SetErrorStringWithFormat("invalid offset: '%s'", option_arg);
858                     break;
859                 case 'c':
860                     m_count = StringConvert::ToUInt32(option_arg, 0, 0, &success);
861                     if (!success)
862                         error.SetErrorStringWithFormat("invalid offset: '%s'", option_arg);
863                     break;
864 
865                 default:
866                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
867                     break;
868             }
869 
870             return error;
871         }
872 
873         void
874         OptionParsingStarting ()
875         {
876             m_offset = 0;
877             m_count = 1;
878         }
879 
880         const OptionDefinition*
881         GetDefinitions ()
882         {
883             return g_option_table;
884         }
885 
886         // Options table: Required for subclasses of Options.
887 
888         static OptionDefinition g_option_table[];
889 
890         // Instance variables to hold the values for command options.
891 
892         uint32_t m_offset;
893         uint32_t m_count;
894     };
895     CommandOptions m_options;
896 };
897 OptionDefinition
898 CommandObjectPlatformFRead::CommandOptions::g_option_table[] =
899 {
900     {   LLDB_OPT_SET_1, false, "offset"           , 'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeIndex        , "Offset into the file at which to start reading." },
901     {   LLDB_OPT_SET_1, false, "count"            , 'c', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeCount        , "Number of bytes to read from the file." },
902     {  0              , false, NULL               ,  0 , 0                              , NULL, NULL, 0, eArgTypeNone         , NULL }
903 };
904 
905 
906 //----------------------------------------------------------------------
907 // "platform fwrite"
908 //----------------------------------------------------------------------
909 class CommandObjectPlatformFWrite : public CommandObjectParsed
910 {
911 public:
912     CommandObjectPlatformFWrite (CommandInterpreter &interpreter) :
913     CommandObjectParsed (interpreter,
914                          "platform file write",
915                          "Write data to a file on the remote end.",
916                          NULL,
917                          0),
918     m_options (interpreter)
919     {
920     }
921 
922     virtual
923     ~CommandObjectPlatformFWrite ()
924     {
925     }
926 
927     virtual bool
928     DoExecute (Args& args, CommandReturnObject &result)
929     {
930         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
931         if (platform_sp)
932         {
933             std::string cmd_line;
934             args.GetCommandString(cmd_line);
935             Error error;
936             const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
937             uint32_t retcode = platform_sp->WriteFile (fd,
938                                                        m_options.m_offset,
939                                                        &m_options.m_data[0],
940                                                        m_options.m_data.size(),
941                                                        error);
942             result.AppendMessageWithFormat("Return = %d\n",retcode);
943             result.SetStatus (eReturnStatusSuccessFinishResult);
944         }
945         else
946         {
947             result.AppendError ("no platform currently selected\n");
948             result.SetStatus (eReturnStatusFailed);
949         }
950         return result.Succeeded();
951     }
952     virtual Options *
953     GetOptions ()
954     {
955         return &m_options;
956     }
957 
958 protected:
959     class CommandOptions : public Options
960     {
961     public:
962 
963         CommandOptions (CommandInterpreter &interpreter) :
964         Options (interpreter)
965         {
966         }
967 
968         virtual
969         ~CommandOptions ()
970         {
971         }
972 
973         virtual Error
974         SetOptionValue (uint32_t option_idx, const char *option_arg)
975         {
976             Error error;
977             char short_option = (char) m_getopt_table[option_idx].val;
978             bool success = false;
979 
980             switch (short_option)
981             {
982                 case 'o':
983                     m_offset = StringConvert::ToUInt32(option_arg, 0, 0, &success);
984                     if (!success)
985                         error.SetErrorStringWithFormat("invalid offset: '%s'", option_arg);
986                     break;
987                 case 'd':
988                     m_data.assign(option_arg);
989                     break;
990 
991                 default:
992                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
993                     break;
994             }
995 
996             return error;
997         }
998 
999         void
1000         OptionParsingStarting ()
1001         {
1002             m_offset = 0;
1003             m_data.clear();
1004         }
1005 
1006         const OptionDefinition*
1007         GetDefinitions ()
1008         {
1009             return g_option_table;
1010         }
1011 
1012         // Options table: Required for subclasses of Options.
1013 
1014         static OptionDefinition g_option_table[];
1015 
1016         // Instance variables to hold the values for command options.
1017 
1018         uint32_t m_offset;
1019         std::string m_data;
1020     };
1021     CommandOptions m_options;
1022 };
1023 OptionDefinition
1024 CommandObjectPlatformFWrite::CommandOptions::g_option_table[] =
1025 {
1026     {   LLDB_OPT_SET_1, false, "offset"           , 'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeIndex        , "Offset into the file at which to start reading." },
1027     {   LLDB_OPT_SET_1, false, "data"            , 'd', OptionParser::eRequiredArgument , NULL, NULL, 0, eArgTypeValue        , "Text to write to the file." },
1028     {  0              , false, NULL               ,  0 , 0                              , NULL, NULL, 0, eArgTypeNone         , NULL }
1029 };
1030 
1031 class CommandObjectPlatformFile : public CommandObjectMultiword
1032 {
1033 public:
1034     //------------------------------------------------------------------
1035     // Constructors and Destructors
1036     //------------------------------------------------------------------
1037     CommandObjectPlatformFile (CommandInterpreter &interpreter) :
1038     CommandObjectMultiword (interpreter,
1039                             "platform file",
1040                             "A set of commands to manage file access through a platform",
1041                             "platform file [open|close|read|write] ...")
1042     {
1043         LoadSubCommand ("open", CommandObjectSP (new CommandObjectPlatformFOpen  (interpreter)));
1044         LoadSubCommand ("close", CommandObjectSP (new CommandObjectPlatformFClose  (interpreter)));
1045         LoadSubCommand ("read", CommandObjectSP (new CommandObjectPlatformFRead  (interpreter)));
1046         LoadSubCommand ("write", CommandObjectSP (new CommandObjectPlatformFWrite  (interpreter)));
1047     }
1048 
1049     virtual
1050     ~CommandObjectPlatformFile ()
1051     {
1052     }
1053 
1054 private:
1055     //------------------------------------------------------------------
1056     // For CommandObjectPlatform only
1057     //------------------------------------------------------------------
1058     DISALLOW_COPY_AND_ASSIGN (CommandObjectPlatformFile);
1059 };
1060 
1061 //----------------------------------------------------------------------
1062 // "platform get-file remote-file-path host-file-path"
1063 //----------------------------------------------------------------------
1064 class CommandObjectPlatformGetFile : public CommandObjectParsed
1065 {
1066 public:
1067     CommandObjectPlatformGetFile (CommandInterpreter &interpreter) :
1068     CommandObjectParsed (interpreter,
1069                          "platform get-file",
1070                          "Transfer a file from the remote end to the local host.",
1071                          "platform get-file <remote-file-spec> <local-file-spec>",
1072                          0)
1073     {
1074         SetHelpLong(
1075 "Examples: \n\
1076 \n\
1077     platform get-file /the/remote/file/path /the/local/file/path\n\
1078     # Transfer a file from the remote end with file path /the/remote/file/path to the local host.\n");
1079 
1080         CommandArgumentEntry arg1, arg2;
1081         CommandArgumentData file_arg_remote, file_arg_host;
1082 
1083         // Define the first (and only) variant of this arg.
1084         file_arg_remote.arg_type = eArgTypeFilename;
1085         file_arg_remote.arg_repetition = eArgRepeatPlain;
1086         // There is only one variant this argument could be; put it into the argument entry.
1087         arg1.push_back (file_arg_remote);
1088 
1089         // Define the second (and only) variant of this arg.
1090         file_arg_host.arg_type = eArgTypeFilename;
1091         file_arg_host.arg_repetition = eArgRepeatPlain;
1092         // There is only one variant this argument could be; put it into the argument entry.
1093         arg2.push_back (file_arg_host);
1094 
1095         // Push the data for the first and the second arguments into the m_arguments vector.
1096         m_arguments.push_back (arg1);
1097         m_arguments.push_back (arg2);
1098     }
1099 
1100     virtual
1101     ~CommandObjectPlatformGetFile ()
1102     {
1103     }
1104 
1105     virtual bool
1106     DoExecute (Args& args, CommandReturnObject &result)
1107     {
1108         // If the number of arguments is incorrect, issue an error message.
1109         if (args.GetArgumentCount() != 2)
1110         {
1111             result.GetErrorStream().Printf("error: required arguments missing; specify both the source and destination file paths\n");
1112             result.SetStatus(eReturnStatusFailed);
1113             return false;
1114         }
1115 
1116         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
1117         if (platform_sp)
1118         {
1119             const char *remote_file_path = args.GetArgumentAtIndex(0);
1120             const char *local_file_path = args.GetArgumentAtIndex(1);
1121             Error error = platform_sp->GetFile(FileSpec(remote_file_path, false),
1122                                                FileSpec(local_file_path, false));
1123             if (error.Success())
1124             {
1125                 result.AppendMessageWithFormat("successfully get-file from %s (remote) to %s (host)\n",
1126                                                remote_file_path, local_file_path);
1127                 result.SetStatus (eReturnStatusSuccessFinishResult);
1128             }
1129             else
1130             {
1131                 result.AppendMessageWithFormat("get-file failed: %s\n", error.AsCString());
1132                 result.SetStatus (eReturnStatusFailed);
1133             }
1134         }
1135         else
1136         {
1137             result.AppendError ("no platform currently selected\n");
1138             result.SetStatus (eReturnStatusFailed);
1139         }
1140         return result.Succeeded();
1141     }
1142 };
1143 
1144 //----------------------------------------------------------------------
1145 // "platform get-size remote-file-path"
1146 //----------------------------------------------------------------------
1147 class CommandObjectPlatformGetSize : public CommandObjectParsed
1148 {
1149 public:
1150     CommandObjectPlatformGetSize (CommandInterpreter &interpreter) :
1151     CommandObjectParsed (interpreter,
1152                          "platform get-size",
1153                          "Get the file size from the remote end.",
1154                          "platform get-size <remote-file-spec>",
1155                          0)
1156     {
1157         SetHelpLong(
1158 "Examples: \n\
1159 \n\
1160     platform get-size /the/remote/file/path\n\
1161     # Get the file size from the remote end with path /the/remote/file/path.\n");
1162 
1163         CommandArgumentEntry arg1;
1164         CommandArgumentData file_arg_remote;
1165 
1166         // Define the first (and only) variant of this arg.
1167         file_arg_remote.arg_type = eArgTypeFilename;
1168         file_arg_remote.arg_repetition = eArgRepeatPlain;
1169         // There is only one variant this argument could be; put it into the argument entry.
1170         arg1.push_back (file_arg_remote);
1171 
1172         // Push the data for the first argument into the m_arguments vector.
1173         m_arguments.push_back (arg1);
1174     }
1175 
1176     virtual
1177     ~CommandObjectPlatformGetSize ()
1178     {
1179     }
1180 
1181     virtual bool
1182     DoExecute (Args& args, CommandReturnObject &result)
1183     {
1184         // If the number of arguments is incorrect, issue an error message.
1185         if (args.GetArgumentCount() != 1)
1186         {
1187             result.GetErrorStream().Printf("error: required argument missing; specify the source file path as the only argument\n");
1188             result.SetStatus(eReturnStatusFailed);
1189             return false;
1190         }
1191 
1192         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
1193         if (platform_sp)
1194         {
1195             std::string remote_file_path(args.GetArgumentAtIndex(0));
1196             user_id_t size = platform_sp->GetFileSize(FileSpec(remote_file_path.c_str(), false));
1197             if (size != UINT64_MAX)
1198             {
1199                 result.AppendMessageWithFormat("File size of %s (remote): %" PRIu64 "\n", remote_file_path.c_str(), size);
1200                 result.SetStatus (eReturnStatusSuccessFinishResult);
1201             }
1202             else
1203             {
1204                 result.AppendMessageWithFormat("Eroor getting file size of %s (remote)\n", remote_file_path.c_str());
1205                 result.SetStatus (eReturnStatusFailed);
1206             }
1207         }
1208         else
1209         {
1210             result.AppendError ("no platform currently selected\n");
1211             result.SetStatus (eReturnStatusFailed);
1212         }
1213         return result.Succeeded();
1214     }
1215 };
1216 
1217 //----------------------------------------------------------------------
1218 // "platform put-file"
1219 //----------------------------------------------------------------------
1220 class CommandObjectPlatformPutFile : public CommandObjectParsed
1221 {
1222 public:
1223     CommandObjectPlatformPutFile (CommandInterpreter &interpreter) :
1224     CommandObjectParsed (interpreter,
1225                          "platform put-file",
1226                          "Transfer a file from this system to the remote end.",
1227                          NULL,
1228                          0)
1229     {
1230     }
1231 
1232     virtual
1233     ~CommandObjectPlatformPutFile ()
1234     {
1235     }
1236 
1237     virtual bool
1238     DoExecute (Args& args, CommandReturnObject &result)
1239     {
1240         const char* src = args.GetArgumentAtIndex(0);
1241         const char* dst = args.GetArgumentAtIndex(1);
1242 
1243         FileSpec src_fs(src, true);
1244         FileSpec dst_fs(dst, false);
1245 
1246         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
1247         if (platform_sp)
1248         {
1249             Error error (platform_sp->PutFile(src_fs, dst_fs));
1250             if (error.Success())
1251             {
1252                 result.SetStatus (eReturnStatusSuccessFinishNoResult);
1253             }
1254             else
1255             {
1256                 result.AppendError (error.AsCString());
1257                 result.SetStatus (eReturnStatusFailed);
1258             }
1259         }
1260         else
1261         {
1262             result.AppendError ("no platform currently selected\n");
1263             result.SetStatus (eReturnStatusFailed);
1264         }
1265         return result.Succeeded();
1266     }
1267 };
1268 
1269 //----------------------------------------------------------------------
1270 // "platform process launch"
1271 //----------------------------------------------------------------------
1272 class CommandObjectPlatformProcessLaunch : public CommandObjectParsed
1273 {
1274 public:
1275     CommandObjectPlatformProcessLaunch (CommandInterpreter &interpreter) :
1276         CommandObjectParsed (interpreter,
1277                              "platform process launch",
1278                              "Launch a new process on a remote platform.",
1279                              "platform process launch program",
1280                              eFlagRequiresTarget | eFlagTryTargetAPILock),
1281         m_options (interpreter)
1282     {
1283     }
1284 
1285     virtual
1286     ~CommandObjectPlatformProcessLaunch ()
1287     {
1288     }
1289 
1290     virtual Options *
1291     GetOptions ()
1292     {
1293         return &m_options;
1294     }
1295 
1296 protected:
1297     virtual bool
1298     DoExecute (Args& args, CommandReturnObject &result)
1299     {
1300         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1301         PlatformSP platform_sp;
1302         if (target)
1303         {
1304             platform_sp = target->GetPlatform();
1305         }
1306         if (!platform_sp)
1307         {
1308             platform_sp = m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform();
1309         }
1310 
1311         if (platform_sp)
1312         {
1313             Error error;
1314             const size_t argc = args.GetArgumentCount();
1315             Target *target = m_exe_ctx.GetTargetPtr();
1316             Module *exe_module = target->GetExecutableModulePointer();
1317             if (exe_module)
1318             {
1319                 m_options.launch_info.GetExecutableFile () = exe_module->GetFileSpec();
1320                 char exe_path[PATH_MAX];
1321                 if (m_options.launch_info.GetExecutableFile ().GetPath (exe_path, sizeof(exe_path)))
1322                     m_options.launch_info.GetArguments().AppendArgument (exe_path);
1323                 m_options.launch_info.GetArchitecture() = exe_module->GetArchitecture();
1324             }
1325 
1326             if (argc > 0)
1327             {
1328                 if (m_options.launch_info.GetExecutableFile ())
1329                 {
1330                     // We already have an executable file, so we will use this
1331                     // and all arguments to this function are extra arguments
1332                     m_options.launch_info.GetArguments().AppendArguments (args);
1333                 }
1334                 else
1335                 {
1336                     // We don't have any file yet, so the first argument is our
1337                     // executable, and the rest are program arguments
1338                     const bool first_arg_is_executable = true;
1339                     m_options.launch_info.SetArguments (args, first_arg_is_executable);
1340                 }
1341             }
1342 
1343             if (m_options.launch_info.GetExecutableFile ())
1344             {
1345                 Debugger &debugger = m_interpreter.GetDebugger();
1346 
1347                 if (argc == 0)
1348                     target->GetRunArguments(m_options.launch_info.GetArguments());
1349 
1350                 ProcessSP process_sp (platform_sp->DebugProcess (m_options.launch_info,
1351                                                                  debugger,
1352                                                                  target,
1353                                                                  error));
1354                 if (process_sp && process_sp->IsAlive())
1355                 {
1356                     result.SetStatus (eReturnStatusSuccessFinishNoResult);
1357                     return true;
1358                 }
1359 
1360                 if (error.Success())
1361                     result.AppendError ("process launch failed");
1362                 else
1363                     result.AppendError (error.AsCString());
1364                 result.SetStatus (eReturnStatusFailed);
1365             }
1366             else
1367             {
1368                 result.AppendError ("'platform process launch' uses the current target file and arguments, or the executable and its arguments can be specified in this command");
1369                 result.SetStatus (eReturnStatusFailed);
1370                 return false;
1371             }
1372         }
1373         else
1374         {
1375             result.AppendError ("no platform is selected\n");
1376         }
1377         return result.Succeeded();
1378     }
1379 
1380 protected:
1381     ProcessLaunchCommandOptions m_options;
1382 };
1383 
1384 
1385 
1386 //----------------------------------------------------------------------
1387 // "platform process list"
1388 //----------------------------------------------------------------------
1389 class CommandObjectPlatformProcessList : public CommandObjectParsed
1390 {
1391 public:
1392     CommandObjectPlatformProcessList (CommandInterpreter &interpreter) :
1393         CommandObjectParsed (interpreter,
1394                              "platform process list",
1395                              "List processes on a remote platform by name, pid, or many other matching attributes.",
1396                              "platform process list",
1397                              0),
1398         m_options (interpreter)
1399     {
1400     }
1401 
1402     virtual
1403     ~CommandObjectPlatformProcessList ()
1404     {
1405     }
1406 
1407     virtual Options *
1408     GetOptions ()
1409     {
1410         return &m_options;
1411     }
1412 
1413 protected:
1414     virtual bool
1415     DoExecute (Args& args, CommandReturnObject &result)
1416     {
1417         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1418         PlatformSP platform_sp;
1419         if (target)
1420         {
1421             platform_sp = target->GetPlatform();
1422         }
1423         if (!platform_sp)
1424         {
1425             platform_sp = m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform();
1426         }
1427 
1428         if (platform_sp)
1429         {
1430             Error error;
1431             if (args.GetArgumentCount() == 0)
1432             {
1433 
1434                 if (platform_sp)
1435                 {
1436                     Stream &ostrm = result.GetOutputStream();
1437 
1438                     lldb::pid_t pid = m_options.match_info.GetProcessInfo().GetProcessID();
1439                     if (pid != LLDB_INVALID_PROCESS_ID)
1440                     {
1441                         ProcessInstanceInfo proc_info;
1442                         if (platform_sp->GetProcessInfo (pid, proc_info))
1443                         {
1444                             ProcessInstanceInfo::DumpTableHeader (ostrm, platform_sp.get(), m_options.show_args, m_options.verbose);
1445                             proc_info.DumpAsTableRow(ostrm, platform_sp.get(), m_options.show_args, m_options.verbose);
1446                             result.SetStatus (eReturnStatusSuccessFinishResult);
1447                         }
1448                         else
1449                         {
1450                             result.AppendErrorWithFormat ("no process found with pid = %" PRIu64 "\n", pid);
1451                             result.SetStatus (eReturnStatusFailed);
1452                         }
1453                     }
1454                     else
1455                     {
1456                         ProcessInstanceInfoList proc_infos;
1457                         const uint32_t matches = platform_sp->FindProcesses (m_options.match_info, proc_infos);
1458                         const char *match_desc = NULL;
1459                         const char *match_name = m_options.match_info.GetProcessInfo().GetName();
1460                         if (match_name && match_name[0])
1461                         {
1462                             switch (m_options.match_info.GetNameMatchType())
1463                             {
1464                                 case eNameMatchIgnore: break;
1465                                 case eNameMatchEquals: match_desc = "matched"; break;
1466                                 case eNameMatchContains: match_desc = "contained"; break;
1467                                 case eNameMatchStartsWith: match_desc = "started with"; break;
1468                                 case eNameMatchEndsWith: match_desc = "ended with"; break;
1469                                 case eNameMatchRegularExpression: match_desc = "matched the regular expression"; break;
1470                             }
1471                         }
1472 
1473                         if (matches == 0)
1474                         {
1475                             if (match_desc)
1476                                 result.AppendErrorWithFormat ("no processes were found that %s \"%s\" on the \"%s\" platform\n",
1477                                                               match_desc,
1478                                                               match_name,
1479                                                               platform_sp->GetPluginName().GetCString());
1480                             else
1481                                 result.AppendErrorWithFormat ("no processes were found on the \"%s\" platform\n", platform_sp->GetPluginName().GetCString());
1482                             result.SetStatus (eReturnStatusFailed);
1483                         }
1484                         else
1485                         {
1486                             result.AppendMessageWithFormat ("%u matching process%s found on \"%s\"",
1487                                                             matches,
1488                                                             matches > 1 ? "es were" : " was",
1489                                                             platform_sp->GetName().GetCString());
1490                             if (match_desc)
1491                                 result.AppendMessageWithFormat (" whose name %s \"%s\"",
1492                                                                 match_desc,
1493                                                                 match_name);
1494                             result.AppendMessageWithFormat ("\n");
1495                             ProcessInstanceInfo::DumpTableHeader (ostrm, platform_sp.get(), m_options.show_args, m_options.verbose);
1496                             for (uint32_t i=0; i<matches; ++i)
1497                             {
1498                                 proc_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(ostrm, platform_sp.get(), m_options.show_args, m_options.verbose);
1499                             }
1500                         }
1501                     }
1502                 }
1503             }
1504             else
1505             {
1506                 result.AppendError ("invalid args: process list takes only options\n");
1507                 result.SetStatus (eReturnStatusFailed);
1508             }
1509         }
1510         else
1511         {
1512             result.AppendError ("no platform is selected\n");
1513             result.SetStatus (eReturnStatusFailed);
1514         }
1515         return result.Succeeded();
1516     }
1517 
1518     class CommandOptions : public Options
1519     {
1520     public:
1521 
1522         CommandOptions (CommandInterpreter &interpreter) :
1523             Options (interpreter),
1524             match_info ()
1525         {
1526         }
1527 
1528         virtual
1529         ~CommandOptions ()
1530         {
1531         }
1532 
1533         virtual Error
1534         SetOptionValue (uint32_t option_idx, const char *option_arg)
1535         {
1536             Error error;
1537             const int short_option = m_getopt_table[option_idx].val;
1538             bool success = false;
1539 
1540             switch (short_option)
1541             {
1542                 case 'p':
1543                     match_info.GetProcessInfo().SetProcessID (StringConvert::ToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success));
1544                     if (!success)
1545                         error.SetErrorStringWithFormat("invalid process ID string: '%s'", option_arg);
1546                     break;
1547 
1548                 case 'P':
1549                     match_info.GetProcessInfo().SetParentProcessID (StringConvert::ToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success));
1550                     if (!success)
1551                         error.SetErrorStringWithFormat("invalid parent process ID string: '%s'", option_arg);
1552                     break;
1553 
1554                 case 'u':
1555                     match_info.GetProcessInfo().SetUserID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
1556                     if (!success)
1557                         error.SetErrorStringWithFormat("invalid user ID string: '%s'", option_arg);
1558                     break;
1559 
1560                 case 'U':
1561                     match_info.GetProcessInfo().SetEffectiveUserID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
1562                     if (!success)
1563                         error.SetErrorStringWithFormat("invalid effective user ID string: '%s'", option_arg);
1564                     break;
1565 
1566                 case 'g':
1567                     match_info.GetProcessInfo().SetGroupID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
1568                     if (!success)
1569                         error.SetErrorStringWithFormat("invalid group ID string: '%s'", option_arg);
1570                     break;
1571 
1572                 case 'G':
1573                     match_info.GetProcessInfo().SetEffectiveGroupID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
1574                     if (!success)
1575                         error.SetErrorStringWithFormat("invalid effective group ID string: '%s'", option_arg);
1576                     break;
1577 
1578                 case 'a':
1579                     match_info.GetProcessInfo().GetArchitecture().SetTriple (option_arg, m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform().get());
1580                     break;
1581 
1582                 case 'n':
1583                     match_info.GetProcessInfo().GetExecutableFile().SetFile (option_arg, false);
1584                     match_info.SetNameMatchType (eNameMatchEquals);
1585                     break;
1586 
1587                 case 'e':
1588                     match_info.GetProcessInfo().GetExecutableFile().SetFile (option_arg, false);
1589                     match_info.SetNameMatchType (eNameMatchEndsWith);
1590                     break;
1591 
1592                 case 's':
1593                     match_info.GetProcessInfo().GetExecutableFile().SetFile (option_arg, false);
1594                     match_info.SetNameMatchType (eNameMatchStartsWith);
1595                     break;
1596 
1597                 case 'c':
1598                     match_info.GetProcessInfo().GetExecutableFile().SetFile (option_arg, false);
1599                     match_info.SetNameMatchType (eNameMatchContains);
1600                     break;
1601 
1602                 case 'r':
1603                     match_info.GetProcessInfo().GetExecutableFile().SetFile (option_arg, false);
1604                     match_info.SetNameMatchType (eNameMatchRegularExpression);
1605                     break;
1606 
1607                 case 'A':
1608                     show_args = true;
1609                     break;
1610 
1611                 case 'v':
1612                     verbose = true;
1613                     break;
1614 
1615                 default:
1616                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1617                     break;
1618             }
1619 
1620             return error;
1621         }
1622 
1623         void
1624         OptionParsingStarting ()
1625         {
1626             match_info.Clear();
1627             show_args = false;
1628             verbose = false;
1629         }
1630 
1631         const OptionDefinition*
1632         GetDefinitions ()
1633         {
1634             return g_option_table;
1635         }
1636 
1637         // Options table: Required for subclasses of Options.
1638 
1639         static OptionDefinition g_option_table[];
1640 
1641         // Instance variables to hold the values for command options.
1642 
1643         ProcessInstanceInfoMatch match_info;
1644         bool show_args;
1645         bool verbose;
1646     };
1647     CommandOptions m_options;
1648 };
1649 
1650 namespace
1651 {
1652     PosixPlatformCommandOptionValidator g_posix_validator;
1653 }
1654 
1655 OptionDefinition
1656 CommandObjectPlatformProcessList::CommandOptions::g_option_table[] =
1657 {
1658 { LLDB_OPT_SET_1            , false, "pid"        , 'p', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePid              , "List the process info for a specific process ID." },
1659 { LLDB_OPT_SET_2            , true , "name"       , 'n', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeProcessName      , "Find processes with executable basenames that match a string." },
1660 { LLDB_OPT_SET_3            , true , "ends-with"  , 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeProcessName      , "Find processes with executable basenames that end with a string." },
1661 { LLDB_OPT_SET_4            , true , "starts-with", 's', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeProcessName      , "Find processes with executable basenames that start with a string." },
1662 { LLDB_OPT_SET_5            , true , "contains"   , 'c', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeProcessName      , "Find processes with executable basenames that contain a string." },
1663 { LLDB_OPT_SET_6            , true , "regex"      , 'r', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeRegularExpression, "Find processes with executable basenames that match a regular expression." },
1664 { LLDB_OPT_SET_FROM_TO(2, 6), false, "parent"     , 'P', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePid              , "Find processes that have a matching parent process ID." },
1665 { LLDB_OPT_SET_FROM_TO(2, 6), false, "uid"        , 'u', OptionParser::eRequiredArgument, &g_posix_validator, NULL, 0, eArgTypeUnsignedInteger  , "Find processes that have a matching user ID." },
1666 { LLDB_OPT_SET_FROM_TO(2, 6), false, "euid"       , 'U', OptionParser::eRequiredArgument, &g_posix_validator, NULL, 0, eArgTypeUnsignedInteger  , "Find processes that have a matching effective user ID." },
1667 { LLDB_OPT_SET_FROM_TO(2, 6), false, "gid"        , 'g', OptionParser::eRequiredArgument, &g_posix_validator, NULL, 0, eArgTypeUnsignedInteger  , "Find processes that have a matching group ID." },
1668 { LLDB_OPT_SET_FROM_TO(2, 6), false, "egid"       , 'G', OptionParser::eRequiredArgument, &g_posix_validator, NULL, 0, eArgTypeUnsignedInteger  , "Find processes that have a matching effective group ID." },
1669 { LLDB_OPT_SET_FROM_TO(2, 6), false, "arch"       , 'a', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeArchitecture     , "Find processes that have a matching architecture." },
1670 { LLDB_OPT_SET_FROM_TO(1, 6), false, "show-args"  , 'A', OptionParser::eNoArgument      , NULL, NULL, 0, eArgTypeNone             , "Show process arguments instead of the process executable basename." },
1671 { LLDB_OPT_SET_FROM_TO(1, 6), false, "verbose"    , 'v', OptionParser::eNoArgument      , NULL, NULL, 0, eArgTypeNone             , "Enable verbose output." },
1672 { 0                         , false, NULL         ,  0 , 0                              , NULL, NULL, 0, eArgTypeNone             , NULL }
1673 };
1674 
1675 //----------------------------------------------------------------------
1676 // "platform process info"
1677 //----------------------------------------------------------------------
1678 class CommandObjectPlatformProcessInfo : public CommandObjectParsed
1679 {
1680 public:
1681     CommandObjectPlatformProcessInfo (CommandInterpreter &interpreter) :
1682     CommandObjectParsed (interpreter,
1683                          "platform process info",
1684                          "Get detailed information for one or more process by process ID.",
1685                          "platform process info <pid> [<pid> <pid> ...]",
1686                          0)
1687     {
1688         CommandArgumentEntry arg;
1689         CommandArgumentData pid_args;
1690 
1691         // Define the first (and only) variant of this arg.
1692         pid_args.arg_type = eArgTypePid;
1693         pid_args.arg_repetition = eArgRepeatStar;
1694 
1695         // There is only one variant this argument could be; put it into the argument entry.
1696         arg.push_back (pid_args);
1697 
1698         // Push the data for the first argument into the m_arguments vector.
1699         m_arguments.push_back (arg);
1700     }
1701 
1702     virtual
1703     ~CommandObjectPlatformProcessInfo ()
1704     {
1705     }
1706 
1707 protected:
1708     virtual bool
1709     DoExecute (Args& args, CommandReturnObject &result)
1710     {
1711         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1712         PlatformSP platform_sp;
1713         if (target)
1714         {
1715             platform_sp = target->GetPlatform();
1716         }
1717         if (!platform_sp)
1718         {
1719             platform_sp = m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform();
1720         }
1721 
1722         if (platform_sp)
1723         {
1724             const size_t argc = args.GetArgumentCount();
1725             if (argc > 0)
1726             {
1727                 Error error;
1728 
1729                 if (platform_sp->IsConnected())
1730                 {
1731                     Stream &ostrm = result.GetOutputStream();
1732                     bool success;
1733                     for (size_t i=0; i<argc; ++ i)
1734                     {
1735                         const char *arg = args.GetArgumentAtIndex(i);
1736                         lldb::pid_t pid = StringConvert::ToUInt32 (arg, LLDB_INVALID_PROCESS_ID, 0, &success);
1737                         if (success)
1738                         {
1739                             ProcessInstanceInfo proc_info;
1740                             if (platform_sp->GetProcessInfo (pid, proc_info))
1741                             {
1742                                 ostrm.Printf ("Process information for process %" PRIu64 ":\n", pid);
1743                                 proc_info.Dump (ostrm, platform_sp.get());
1744                             }
1745                             else
1746                             {
1747                                 ostrm.Printf ("error: no process information is available for process %" PRIu64 "\n", pid);
1748                             }
1749                             ostrm.EOL();
1750                         }
1751                         else
1752                         {
1753                             result.AppendErrorWithFormat ("invalid process ID argument '%s'", arg);
1754                             result.SetStatus (eReturnStatusFailed);
1755                             break;
1756                         }
1757                     }
1758                 }
1759                 else
1760                 {
1761                     // Not connected...
1762                     result.AppendErrorWithFormat ("not connected to '%s'", platform_sp->GetPluginName().GetCString());
1763                     result.SetStatus (eReturnStatusFailed);
1764                 }
1765             }
1766             else
1767             {
1768                 // No args
1769                 result.AppendError ("one or more process id(s) must be specified");
1770                 result.SetStatus (eReturnStatusFailed);
1771             }
1772         }
1773         else
1774         {
1775             result.AppendError ("no platform is currently selected");
1776             result.SetStatus (eReturnStatusFailed);
1777         }
1778         return result.Succeeded();
1779     }
1780 };
1781 
1782 class CommandObjectPlatformProcessAttach : public CommandObjectParsed
1783 {
1784 public:
1785 
1786     class CommandOptions : public Options
1787     {
1788     public:
1789 
1790         CommandOptions (CommandInterpreter &interpreter) :
1791         Options(interpreter)
1792         {
1793             // Keep default values of all options in one place: OptionParsingStarting ()
1794             OptionParsingStarting ();
1795         }
1796 
1797         ~CommandOptions ()
1798         {
1799         }
1800 
1801         Error
1802         SetOptionValue (uint32_t option_idx, const char *option_arg)
1803         {
1804             Error error;
1805             char short_option = (char) m_getopt_table[option_idx].val;
1806             bool success = false;
1807             switch (short_option)
1808             {
1809                 case 'p':
1810                 {
1811                     lldb::pid_t pid = StringConvert::ToUInt32 (option_arg, LLDB_INVALID_PROCESS_ID, 0, &success);
1812                     if (!success || pid == LLDB_INVALID_PROCESS_ID)
1813                     {
1814                         error.SetErrorStringWithFormat("invalid process ID '%s'", option_arg);
1815                     }
1816                     else
1817                     {
1818                         attach_info.SetProcessID (pid);
1819                     }
1820                 }
1821                     break;
1822 
1823                 case 'P':
1824                     attach_info.SetProcessPluginName (option_arg);
1825                     break;
1826 
1827                 case 'n':
1828                     attach_info.GetExecutableFile().SetFile(option_arg, false);
1829                     break;
1830 
1831                 case 'w':
1832                     attach_info.SetWaitForLaunch(true);
1833                     break;
1834 
1835                 default:
1836                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
1837                     break;
1838             }
1839             return error;
1840         }
1841 
1842         void
1843         OptionParsingStarting ()
1844         {
1845             attach_info.Clear();
1846         }
1847 
1848         const OptionDefinition*
1849         GetDefinitions ()
1850         {
1851             return g_option_table;
1852         }
1853 
1854         virtual bool
1855         HandleOptionArgumentCompletion (Args &input,
1856                                         int cursor_index,
1857                                         int char_pos,
1858                                         OptionElementVector &opt_element_vector,
1859                                         int opt_element_index,
1860                                         int match_start_point,
1861                                         int max_return_elements,
1862                                         bool &word_complete,
1863                                         StringList &matches)
1864         {
1865             int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
1866             int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
1867 
1868             // We are only completing the name option for now...
1869 
1870             const OptionDefinition *opt_defs = GetDefinitions();
1871             if (opt_defs[opt_defs_index].short_option == 'n')
1872             {
1873                 // Are we in the name?
1874 
1875                 // Look to see if there is a -P argument provided, and if so use that plugin, otherwise
1876                 // use the default plugin.
1877 
1878                 const char *partial_name = NULL;
1879                 partial_name = input.GetArgumentAtIndex(opt_arg_pos);
1880 
1881                 PlatformSP platform_sp (m_interpreter.GetPlatform (true));
1882                 if (platform_sp)
1883                 {
1884                     ProcessInstanceInfoList process_infos;
1885                     ProcessInstanceInfoMatch match_info;
1886                     if (partial_name)
1887                     {
1888                         match_info.GetProcessInfo().GetExecutableFile().SetFile(partial_name, false);
1889                         match_info.SetNameMatchType(eNameMatchStartsWith);
1890                     }
1891                     platform_sp->FindProcesses (match_info, process_infos);
1892                     const uint32_t num_matches = process_infos.GetSize();
1893                     if (num_matches > 0)
1894                     {
1895                         for (uint32_t i=0; i<num_matches; ++i)
1896                         {
1897                             matches.AppendString (process_infos.GetProcessNameAtIndex(i),
1898                                                   process_infos.GetProcessNameLengthAtIndex(i));
1899                         }
1900                     }
1901                 }
1902             }
1903 
1904             return false;
1905         }
1906 
1907         // Options table: Required for subclasses of Options.
1908 
1909         static OptionDefinition g_option_table[];
1910 
1911         // Instance variables to hold the values for command options.
1912 
1913         ProcessAttachInfo attach_info;
1914     };
1915 
1916     CommandObjectPlatformProcessAttach (CommandInterpreter &interpreter) :
1917     CommandObjectParsed (interpreter,
1918                          "platform process attach",
1919                          "Attach to a process.",
1920                          "platform process attach <cmd-options>"),
1921     m_options (interpreter)
1922     {
1923     }
1924 
1925     ~CommandObjectPlatformProcessAttach ()
1926     {
1927     }
1928 
1929     bool
1930     DoExecute (Args& command,
1931              CommandReturnObject &result)
1932     {
1933         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
1934         if (platform_sp)
1935         {
1936             Error err;
1937             ProcessSP remote_process_sp =
1938             platform_sp->Attach(m_options.attach_info, m_interpreter.GetDebugger(), NULL, err);
1939             if (err.Fail())
1940             {
1941                 result.AppendError(err.AsCString());
1942                 result.SetStatus (eReturnStatusFailed);
1943             }
1944             else if (remote_process_sp.get() == NULL)
1945             {
1946                 result.AppendError("could not attach: unknown reason");
1947                 result.SetStatus (eReturnStatusFailed);
1948             }
1949             else
1950                 result.SetStatus (eReturnStatusSuccessFinishResult);
1951         }
1952         else
1953         {
1954             result.AppendError ("no platform is currently selected");
1955             result.SetStatus (eReturnStatusFailed);
1956         }
1957         return result.Succeeded();
1958     }
1959 
1960     Options *
1961     GetOptions ()
1962     {
1963         return &m_options;
1964     }
1965 
1966 protected:
1967 
1968     CommandOptions m_options;
1969 };
1970 
1971 
1972 OptionDefinition
1973 CommandObjectPlatformProcessAttach::CommandOptions::g_option_table[] =
1974 {
1975     { LLDB_OPT_SET_ALL, false, "plugin",  'P'  , OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePlugin,        "Name of the process plugin you want to use."},
1976     { LLDB_OPT_SET_1,   false, "pid",     'p'  , OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePid,           "The process ID of an existing process to attach to."},
1977     { LLDB_OPT_SET_2,   false, "name",    'n'  , OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeProcessName,  "The name of the process to attach to."},
1978     { LLDB_OPT_SET_2,   false, "waitfor", 'w'  , OptionParser::eNoArgument      , NULL, NULL, 0, eArgTypeNone,              "Wait for the the process with <process-name> to launch."},
1979     { 0,                false, NULL     , 0    , 0                              , NULL, NULL, 0, eArgTypeNone, NULL }
1980 };
1981 
1982 
1983 class CommandObjectPlatformProcess : public CommandObjectMultiword
1984 {
1985 public:
1986     //------------------------------------------------------------------
1987     // Constructors and Destructors
1988     //------------------------------------------------------------------
1989      CommandObjectPlatformProcess (CommandInterpreter &interpreter) :
1990         CommandObjectMultiword (interpreter,
1991                                 "platform process",
1992                                 "A set of commands to query, launch and attach to platform processes",
1993                                 "platform process [attach|launch|list] ...")
1994     {
1995         LoadSubCommand ("attach", CommandObjectSP (new CommandObjectPlatformProcessAttach (interpreter)));
1996         LoadSubCommand ("launch", CommandObjectSP (new CommandObjectPlatformProcessLaunch (interpreter)));
1997         LoadSubCommand ("info"  , CommandObjectSP (new CommandObjectPlatformProcessInfo (interpreter)));
1998         LoadSubCommand ("list"  , CommandObjectSP (new CommandObjectPlatformProcessList (interpreter)));
1999 
2000     }
2001 
2002     virtual
2003     ~CommandObjectPlatformProcess ()
2004     {
2005     }
2006 
2007 private:
2008     //------------------------------------------------------------------
2009     // For CommandObjectPlatform only
2010     //------------------------------------------------------------------
2011     DISALLOW_COPY_AND_ASSIGN (CommandObjectPlatformProcess);
2012 };
2013 
2014 //----------------------------------------------------------------------
2015 // "platform shell"
2016 //----------------------------------------------------------------------
2017 class CommandObjectPlatformShell : public CommandObjectRaw
2018 {
2019 public:
2020 
2021     class CommandOptions : public Options
2022     {
2023     public:
2024 
2025         CommandOptions (CommandInterpreter &interpreter) :
2026         Options(interpreter),
2027         timeout(10)
2028         {
2029         }
2030 
2031         virtual
2032         ~CommandOptions ()
2033         {
2034         }
2035 
2036         virtual uint32_t
2037         GetNumDefinitions ()
2038         {
2039             return 1;
2040         }
2041 
2042         virtual const OptionDefinition*
2043         GetDefinitions ()
2044         {
2045             return g_option_table;
2046         }
2047 
2048         virtual Error
2049         SetOptionValue (uint32_t option_idx,
2050                         const char *option_value)
2051         {
2052             Error error;
2053 
2054             const char short_option = (char) g_option_table[option_idx].short_option;
2055 
2056             switch (short_option)
2057             {
2058                 case 't':
2059                 {
2060                     bool success;
2061                     timeout = StringConvert::ToUInt32(option_value, 10, 10, &success);
2062                     if (!success)
2063                         error.SetErrorStringWithFormat("could not convert \"%s\" to a numeric value.", option_value);
2064                     break;
2065                 }
2066                 default:
2067                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
2068                     break;
2069             }
2070 
2071             return error;
2072         }
2073 
2074         virtual void
2075         OptionParsingStarting ()
2076         {
2077         }
2078 
2079         // Options table: Required for subclasses of Options.
2080 
2081         static OptionDefinition g_option_table[];
2082         uint32_t timeout;
2083     };
2084 
2085     CommandObjectPlatformShell (CommandInterpreter &interpreter) :
2086     CommandObjectRaw (interpreter,
2087                       "platform shell",
2088                       "Run a shell command on a the selected platform.",
2089                       "platform shell <shell-command>",
2090                       0),
2091     m_options(interpreter)
2092     {
2093     }
2094 
2095     virtual
2096     ~CommandObjectPlatformShell ()
2097     {
2098     }
2099 
2100     virtual
2101     Options *
2102     GetOptions ()
2103     {
2104         return &m_options;
2105     }
2106 
2107     virtual bool
2108     DoExecute (const char *raw_command_line, CommandReturnObject &result)
2109     {
2110         m_options.NotifyOptionParsingStarting();
2111 
2112         const char* expr = NULL;
2113 
2114         // Print out an usage syntax on an empty command line.
2115         if (raw_command_line[0] == '\0')
2116         {
2117             result.GetOutputStream().Printf("%s\n", this->GetSyntax());
2118             return true;
2119         }
2120 
2121         if (raw_command_line[0] == '-')
2122         {
2123             // We have some options and these options MUST end with --.
2124             const char *end_options = NULL;
2125             const char *s = raw_command_line;
2126             while (s && s[0])
2127             {
2128                 end_options = ::strstr (s, "--");
2129                 if (end_options)
2130                 {
2131                     end_options += 2; // Get past the "--"
2132                     if (::isspace (end_options[0]))
2133                     {
2134                         expr = end_options;
2135                         while (::isspace (*expr))
2136                             ++expr;
2137                         break;
2138                     }
2139                 }
2140                 s = end_options;
2141             }
2142 
2143             if (end_options)
2144             {
2145                 Args args (raw_command_line, end_options - raw_command_line);
2146                 if (!ParseOptions (args, result))
2147                     return false;
2148             }
2149         }
2150 
2151         if (expr == NULL)
2152             expr = raw_command_line;
2153 
2154         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
2155         Error error;
2156         if (platform_sp)
2157         {
2158             const char *working_dir = NULL;
2159             std::string output;
2160             int status = -1;
2161             int signo = -1;
2162             error = (platform_sp->RunShellCommand (expr, working_dir, &status, &signo, &output, m_options.timeout));
2163             if (!output.empty())
2164                 result.GetOutputStream().PutCString(output.c_str());
2165             if (status > 0)
2166             {
2167                 if (signo > 0)
2168                 {
2169                     const char *signo_cstr = Host::GetSignalAsCString(signo);
2170                     if (signo_cstr)
2171                         result.GetOutputStream().Printf("error: command returned with status %i and signal %s\n", status, signo_cstr);
2172                     else
2173                         result.GetOutputStream().Printf("error: command returned with status %i and signal %i\n", status, signo);
2174                 }
2175                 else
2176                     result.GetOutputStream().Printf("error: command returned with status %i\n", status);
2177             }
2178         }
2179         else
2180         {
2181             result.GetOutputStream().Printf("error: cannot run remote shell commands without a platform\n");
2182             error.SetErrorString("error: cannot run remote shell commands without a platform");
2183         }
2184 
2185         if (error.Fail())
2186         {
2187             result.AppendError(error.AsCString());
2188             result.SetStatus (eReturnStatusFailed);
2189         }
2190         else
2191         {
2192             result.SetStatus (eReturnStatusSuccessFinishResult);
2193         }
2194         return true;
2195     }
2196     CommandOptions m_options;
2197 };
2198 
2199 OptionDefinition
2200 CommandObjectPlatformShell::CommandOptions::g_option_table[] =
2201 {
2202     { LLDB_OPT_SET_ALL, false, "timeout",      't', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeValue,    "Seconds to wait for the remote host to finish running the command."},
2203     { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
2204 };
2205 
2206 
2207 //----------------------------------------------------------------------
2208 // "platform install" - install a target to a remote end
2209 //----------------------------------------------------------------------
2210 class CommandObjectPlatformInstall : public CommandObjectParsed
2211 {
2212 public:
2213     CommandObjectPlatformInstall (CommandInterpreter &interpreter) :
2214     CommandObjectParsed (interpreter,
2215                          "platform target-install",
2216                          "Install a target (bundle or executable file) to the remote end.",
2217                          "platform target-install <local-thing> <remote-sandbox>",
2218                          0)
2219     {
2220     }
2221 
2222     virtual
2223     ~CommandObjectPlatformInstall ()
2224     {
2225     }
2226 
2227     virtual bool
2228     DoExecute (Args& args, CommandReturnObject &result)
2229     {
2230         if (args.GetArgumentCount() != 2)
2231         {
2232             result.AppendError("platform target-install takes two arguments");
2233             result.SetStatus(eReturnStatusFailed);
2234             return false;
2235         }
2236         // TODO: move the bulk of this code over to the platform itself
2237         FileSpec src(args.GetArgumentAtIndex(0), true);
2238         FileSpec dst(args.GetArgumentAtIndex(1), false);
2239         if (src.Exists() == false)
2240         {
2241             result.AppendError("source location does not exist or is not accessible");
2242             result.SetStatus(eReturnStatusFailed);
2243             return false;
2244         }
2245         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
2246         if (!platform_sp)
2247         {
2248             result.AppendError ("no platform currently selected");
2249             result.SetStatus (eReturnStatusFailed);
2250             return false;
2251         }
2252 
2253         Error error = platform_sp->Install(src, dst);
2254         if (error.Success())
2255         {
2256             result.SetStatus(eReturnStatusSuccessFinishNoResult);
2257         }
2258         else
2259         {
2260             result.AppendErrorWithFormat("install failed: %s", error.AsCString());
2261             result.SetStatus(eReturnStatusFailed);
2262         }
2263         return result.Succeeded();
2264     }
2265 private:
2266 
2267 };
2268 
2269 //----------------------------------------------------------------------
2270 // CommandObjectPlatform constructor
2271 //----------------------------------------------------------------------
2272 CommandObjectPlatform::CommandObjectPlatform(CommandInterpreter &interpreter) :
2273     CommandObjectMultiword (interpreter,
2274                             "platform",
2275                             "A set of commands to manage and create platforms.",
2276                             "platform [connect|disconnect|info|list|status|select] ...")
2277 {
2278     LoadSubCommand ("select", CommandObjectSP (new CommandObjectPlatformSelect (interpreter)));
2279     LoadSubCommand ("list"  , CommandObjectSP (new CommandObjectPlatformList (interpreter)));
2280     LoadSubCommand ("status", CommandObjectSP (new CommandObjectPlatformStatus (interpreter)));
2281     LoadSubCommand ("connect", CommandObjectSP (new CommandObjectPlatformConnect (interpreter)));
2282     LoadSubCommand ("disconnect", CommandObjectSP (new CommandObjectPlatformDisconnect (interpreter)));
2283     LoadSubCommand ("settings", CommandObjectSP (new CommandObjectPlatformSettings (interpreter)));
2284     LoadSubCommand ("mkdir", CommandObjectSP (new CommandObjectPlatformMkDir (interpreter)));
2285     LoadSubCommand ("file", CommandObjectSP (new CommandObjectPlatformFile (interpreter)));
2286     LoadSubCommand ("get-file", CommandObjectSP (new CommandObjectPlatformGetFile (interpreter)));
2287     LoadSubCommand ("get-size", CommandObjectSP (new CommandObjectPlatformGetSize (interpreter)));
2288     LoadSubCommand ("put-file", CommandObjectSP (new CommandObjectPlatformPutFile (interpreter)));
2289     LoadSubCommand ("process", CommandObjectSP (new CommandObjectPlatformProcess (interpreter)));
2290     LoadSubCommand ("shell", CommandObjectSP (new CommandObjectPlatformShell (interpreter)));
2291     LoadSubCommand ("target-install", CommandObjectSP (new CommandObjectPlatformInstall (interpreter)));
2292 }
2293 
2294 //----------------------------------------------------------------------
2295 // Destructor
2296 //----------------------------------------------------------------------
2297 CommandObjectPlatform::~CommandObjectPlatform()
2298 {
2299 }
2300