API tools faq
paste
Advertisement
Guest User

Command line for HTA

a guest
Mar 31st, 2014
232
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
HTML 5 9.97 KB | None | 0 0
raw download clone embed print report
  1. <html>
  2.     <head>
  3.         <!-- Copyright (c) 2013 Alf P. Steinbach -->
  4.         <!-- How to retrieve a command line for an IE10-based Windows HTML-Application (HTA). -->
  5.  
  6.         <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
  7.         <!-- A windows web control defaults to quirky IE7 semantics. Request for better: -->
  8.         <meta http-equiv="X-UA-Compatible" content="IE=edge">
  9.         <meta http-equiv="MSThemeCompatible" content="yes">
  10.  
  11.         <title>Command line</title>
  12.  
  13.         <style>
  14.             * { font: 10pt 'MS Shell Dlg 2'; }
  15.  
  16.             #command-line {
  17.                 background-color: lightBlue;
  18.             }
  19.         </style>
  20.  
  21.         <script type="text/javascript">
  22.             function is_whitespace( s )
  23.             {
  24.                 var n = s.length;
  25.                 if( n == 1 )
  26.                 {
  27.                     return (s == ' ' || s == '\n' || s == '\r' || s == '\t');
  28.                 }
  29.                 else
  30.                 {
  31.                     for( var i = 0; i < n; ++i )
  32.                    {
  33.                        if( !is_whitespace( s.substr( i, 1 ) ) )
  34.                        {
  35.                            return false;
  36.                        }
  37.                    }
  38.                    return true;
  39.                }
  40.            }
  41.  
  42.            // This function doesn't work when using IE10 engine or better, because
  43.            // (1) no GetObject in new JScript, and (2) no cross-language scripting.
  44.            function raw_commandline_from_wmi_automation()
  45.            {
  46.                var computer_id = '.' ;
  47.                var wmi = some_get_object_function( 'winmgmts:\\\\' + computer_id + '\\root\\CIMV2' );
  48.                var wbemFlagForwardOnly = 32;
  49.                var wbemFlagReturnImmediately = 16;
  50.                var items = wmi.ExecQuery(
  51.                    'SELECT * FROM Win32_Process WHERE Name = \'mshta.exe\'',
  52.                    'WQL',
  53.                    wbemFlagForwardOnly + wbemFlagReturnImmediately
  54.                    );
  55.                var s = '';
  56.                var this_process;
  57.                var this_usertime;
  58.                for( var it = new Enumerator( items ); !it.atEnd(); it.moveNext() )
  59.                {
  60.                    var process = it.item();
  61.                    var usertime = parseInt( process.UserModeTime );
  62.                    if( this_usertime == undefined || usertime < this_usertime )
  63.                    {
  64.                        this_process = process;
  65.                        this_usertime = usertime;
  66.                    }
  67.                }
  68.                return (this_process == undefined? '' : this_process.CommandLine);
  69.            }
  71.            function is_running( wsh_execution )
  72.            {
  73.                return (wsh_execution.Status == 0);
  74.            }
  76.            function wsh_sleep( wsh_shell, millisecs )
  77.            {
  78.                var nowindow = 0;
  79.                var wait = true;
  80.                wsh_shell.Run( 'ping 1.1.1.1 -n 1 -w ' + millisecs, nowindow, wait );
  81.            }
  83.            function Process_record()
  84.            {
  85.                this.add_item = function( spec )
  86.                {
  87.                    i_delimiter = spec.indexOf( '=' );
  88.                    if( i_delimiter != -1 )
  89.                    {
  90.                        var property_name = spec.substring( 0, i_delimiter );
  91.                        var value = spec.substr( i_delimiter + 1 );
  92.                        this[property_name] = value;
  93.                    }
  94.                }
  95.            }
  97.            function mshta_process_records()
  98.            {
  99.                var wsh_shell = new ActiveXObject( 'WScript.Shell' );
  100.                var execution = wsh_shell.Exec( 'wmic process list full' );
  102.                var records = new Array();
  103.                var current_record = null;
  104.                var n_blank = 0;
  105.                var n_added = 0;
  106.                
  107.                function update_from( line )
  108.                {
  109.                    var i_end = line.length - 1;
  110.                    while( i_end >= 0 && line.substr( i_end, 1 ) < ' ' )
  111.                    {
  112.                        --i_end;
  113.                     }
  114.                     if( 0 <= i_end && i_end < line.length - 1 )
  115.                    {
  116.                        line = line.substr( 0, i_end + 1 );
  117.                    }
  118.  
  119.                    if( is_whitespace( line ) )
  120.                    {
  121.                        ++n_blank;
  122.                        if( current_record != null )
  123.                        {
  124.                            records.push( current_record );
  125.                            current_record = null;
  126.                            ++n_added;
  127.                        }
  128.                    }
  129.                    else //  line.length > 0
  130.                     {
  131.                         if( current_record == null )
  132.                         {
  133.                             current_record = new Process_record();
  134.                         }
  135.                         current_record.add_item( line );
  136.                     }
  137.                 }
  138.                
  139.                 var count1 = 0;
  140.                 while( is_running( execution ) )
  141.                 {
  142.                     //wsh_sleep( wsh_shell, 100 );
  143.                     var line = execution.StdOut.ReadLine();
  144.                     ++count1;
  145.                     update_from( line );
  146.                 }
  147.                 var count2 = 0;
  148.                 while( !execution.StdOut.AtEndOfStream )
  149.                 {
  150.                     var line = execution.StdOut.ReadLine() + '\n';
  151.                     ++count2;
  152.                     update_from( line );
  153.                 }
  154.                 update_from( '' );      // Complete a possible last record.
  155.  
  156.                 return records;
  157.  
  158.                 return ''
  159.                     + count1 + ' + ' + count2 + ' lines processed, '
  160.                     + n_blank + ' blanks, '
  161.                     + n_added + ' records added, '
  162.                     + records.length + ' records.';
  163.             }
  164.  
  165.             // Assumption: a call near the start of this process.
  166.             function record_for_this_process( records )
  167.             {
  168.                 var this_process    = null;
  169.                 var this_usertime   = null;
  170.                 var n               = records.length;
  171.                 for( var i = 0; i != n; ++i )
  172.                 {
  173.                     var process = records[i];
  174.                     if( process.Name == 'mshta.exe' )
  175.                     {
  176.                         var usertime = parseInt( process.UserModeTime );
  177.                         if( this_usertime == null || usertime < this_usertime )
  178.                        {
  179.                            this_process = process;
  180.                            this_usertime = usertime;
  181.                        }
  182.                    }
  183.                }
  184.                return this_process;
  185.            }
  186.  
  187.            function raw_commandline_from_wmic()
  188.            {
  189.                var records         = mshta_process_records();
  190.                var this_process    = record_for_this_process( records );
  191.  
  192.                return (this_process == null? '*' : this_process.CommandLine);
  193.            }
  194.  
  195.            var raw_commandline = raw_commandline_from_wmic;
  196.  
  197.            function Span( _start, _end )
  198.            {
  199.                this.start = _start;
  200.                this.end = _end;
  201.            };
  202.  
  203.            function commandline_argument_spans( s )
  204.            {
  205.                var spans = new Array();
  206.  
  207.                var n = s.length;
  208.                var unquoted = true;
  209.                var in_argument = false;
  210.                var i_span_start;
  211.                for( var i = 0; i <= n; ++i )
  212.                {
  213.                    if( i == n )
  214.                    {
  215.                        if( in_argument )
  216.                        {
  217.                            spans.push( new Span( i_span_start, i ) );
  218.                        }
  219.                        break;
  220.                    }
  221.  
  222.                    var ch = s.substr( i, 1 );
  223.                    if( ch == '"' )
  224.                    {
  225.                        unquoted = !unquoted;
  226.                    }
  227.  
  228.                    if( in_argument )
  229.                    {
  230.                        if( unquoted && is_whitespace( ch ) )
  231.                        {
  232.                            spans.push( new Span( i_span_start, i ) );
  233.                            in_argument = false;
  234.                        }
  235.                    }
  236.                    else
  237.                    {
  238.                        if( !is_whitespace( ch ) )
  239.                        {
  240.                            in_argument = true;
  241.                            i_span_start = i;
  242.                        }
  243.                    }
  244.                }
  245.                return spans;
  246.            }
  247.  
  248.            function commandline()
  249.            {
  250.                var line = raw_commandline();
  251.                var spans = commandline_argument_spans( line );
  252.                var n = spans.length;
  253.                if( n <= 1 )
  254.                {
  255.                    return '';
  256.                }
  257.                else
  258.                {
  259.                    var s = line.substring( spans[1].start, spans[1].end );
  260.                    if( n > 3 )
  261.                     {
  262.                         s += line.substring( spans[2].end );
  263.                     }
  264.                     return s;
  265.                 }
  266.             }
  267.  
  268.             function on_document_loaded()
  269.             {
  270.                 document.getElementById( 'command-line' ).innerText = commandline();
  271.             }
  272.         </script>
  273.     </head>
  274.    
  275.     <body onload="on_document_loaded();" style="background-color: lightGray;" >
  276.         <div style="position: absolute; left: 0; top: 0; right: 0; bottom: 0; margin: 1em; border: 1px solid blue; border-radius: 8px; background-color: white; padding: 2em;"/>
  277.         <p>
  278.             <span id="command-line"></span></p>
  279.         </div>
  280.     </body>
  281. </html>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!