    gdb ./vuln_prog
    run &lt; filename_with_input

I am an iOS newbie. I have a selector method as follows - 

    - (void) fooFirstInput:(NSString*) first secondInput:(NSString*) second
    {
    
    }

I am trying to implement something like this - 

    [self performSelector:@selector(fooFirstInput:secondInput:) withObject:@&quot;first&quot; withObject:@&quot;second&quot; afterDelay:15.0];

But that gives me an error saying -

    Instance method -performSelector:withObject:withObject:afterDelay: not found

Any ideas as to what I am missing?

iOS - How to implement a performSelector with multiple arguments and with afterDelay?

I have a &#39;page&#39; that has a number of components on it, and who&#39;s content is longer than the height of the device.  Fine, just put all of the layout (the entire page) inside a `ScrollView`, no problem.

One of the components is a `ViewPager`.  This renders correctly, but the response to a swipe/fling is not performing correctly, it is jittery and doesn&#39;t always work.  It seems to be getting &#39;confused&#39; with the `ScrollView`, so only works 100% when you fling in an exact horizontal line.

If I remove the `ScrollView`, the ViewPager responds perfectly.

I&#39;ve had a search around and have not found this as a known defect.
Has anyone else experienced this?

* Platform Version: 1.6
* Compatibility Library v4.  
* Device: HTC Incredible S

Below is some example code for you to test with, comment out `ScrollView` to see it working correctly.

Activity:

    package com.ss.activities;
    
    import com.ss.R;
    
    import android.app.Activity;
    import android.content.Context;
    import android.graphics.Color;
    import android.os.Bundle;
    import android.os.Parcelable;
    import android.support.v4.view.PagerAdapter;
    import android.support.v4.view.ViewPager;
    import android.view.View;
    import android.widget.TextView;
    
    public class PagerInsideScollViewActivity extends Activity {
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
    
            ViewPager vp = (ViewPager) findViewById(R.id.viewpager);
            vp.setAdapter(new MyPagerAdapter(this));
        }
    }
    
    class MyPagerAdapter extends PagerAdapter {
    
        private Context ctx;
    
        public MyPagerAdapter(Context context) {
            ctx = context;
        }
    
        @Override
        public int getCount() {
            return 2;
        }
    
        @Override
        public Object instantiateItem(View collection, int position) {
    
            TextView tv =  new TextView(ctx);
            tv.setTextSize(50);
            tv.setTextColor(Color.WHITE);
            tv.setText(&quot;SMILE DUDE, SMILE DUDE, SMILE DUDE, SMILE DUDE, SMILE DUDE, &quot; +
                    &quot;SMILE DUDE, SMILE DUDE, SMILE DUDE, SMILE DUDE, SMILE DUDE, &quot; +
                    &quot;SMILE DUDE, SMILE DUDE, SMILE DUDE, SMILE DUDE, SMILE DUDE, &quot; +
                    &quot;SMILE DUDE, SMILE DUDE, SMILE DUDE&quot;);
    
            ((ViewPager) collection).addView(tv);
    
            return tv;
    
        }
    
        @Override
        public void destroyItem(View collection, int position, Object view) {
             ((ViewPager) collection).removeView((View) view);
        }
    
        @Override
        public boolean isViewFromObject(View view, Object object) {
            return view == object;
        }
    
        @Override
        public Parcelable saveState() {
            return null;
        }
    
        @Override
        public void restoreState(Parcelable arg0, ClassLoader arg1) {
        }
    
        @Override
        public void startUpdate(View arg0) {
        }
    
        @Override
        public void finishUpdate(View arg0) {
        }
    }

Layout:

    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
        &lt;ScrollView
             xmlns:android=&quot;http://schemas.android.com/apk/res/android&quot;
            android:layout_width=&quot;fill_parent&quot;
            android:layout_height=&quot;fill_parent&quot; &gt;
    
            &lt;LinearLayout
                android:layout_width=&quot;fill_parent&quot;
                android:layout_height=&quot;fill_parent&quot;
                android:orientation=&quot;vertical&quot; &gt;
    
                &lt;android.support.v4.view.ViewPager
                    android:id=&quot;@+id/viewpager&quot;
                    android:layout_width=&quot;fill_parent&quot;
                    android:layout_height=&quot;300dp&quot; /&gt;
                
            &lt;/LinearLayout&gt;
    
        &lt;/ScrollView&gt;

ViewPager inside a ScrollView does not scroll correclty

I typically run my program with:

    perl -e &#39;print &quot;A&quot;x200&#39; | ./vuln_prog

The stdin is consumed by a `gets()` function in C++.

If this were just a command argument, I could open gdb by doing:

    gdb ./vuln_prog
    run $(perl -e &#39;print &quot;A&quot;x200&#39;)

However, my scenario is not a command argument, but rather input (STDIN?).  How would I debug this in gdb?  I&#39;ve tried a bunch of options, but nothing seems to really work.

I would normally just run gdb on the process, and when it prompts for user input, type it in, however I&#39;m not wanting to type just &quot;A&quot;.  I want to type all chars from \x00-\xff, which I can&#39;t type.


gdb - debugging with piped input (not arguments)

I typically run my program with:
<pre><code class="hljs language-bash">perl -e 'print "A"x200' | ./vuln_prog
</code></pre>
The stdin is consumed by a <code>gets()</code> function in C++.
If this were just a command argument, I could open gdb by doing:
<pre><code class="hljs language-arduino">gdb ./vuln_prog
run $(perl -e 'print "A"x200')
</code></pre>
However, my scenario is not a command argument, but rather input (STDIN?). How would I debug this in gdb? I've tried a bunch of options, but nothing seems to really work.
I would normally just run gdb on the process, and when it prompts for user input, type it in, however I'm not wanting to type just "A". I want to type all chars from \x00-\xff, which I can't type.

I&#39;m debugging a C++ program with GDB.

I have a pointer to an object of certain class. The pointer is declared to be of some super class which is extended by several sub-classes.

There is no fields in the object to specify the precise class type of this object but some virtual functions (e.g. bool is_xxx()) are defined to tell the class type at runtime.

Is there some way to tell the precise class type of an object in GDB without calling these virtual functions. Calling such functions in GDB may generate confusing result when the program is multi-threaded.


How to determine if an object is an instance of certain derived C++ class from a pointer to a base class in GDB?

How can I permanently change the disassembly flavor in GDB.  I tried:`set disassembly-flavor intel` in GDB, but when I fire up GDB later it still has the att flavor.

Permanently Change Disassembly Flavor in GDB

I&#39;m trying to inspect a buffer which contains a binary formatted message, but also contains string data. As an example, I&#39;m using this C code:

    int main (void) {
        char buf[100] = &quot;\x01\x02\x03\x04String Data\xAA\xBB\xCC&quot;;
    
        return 0;
    }

I&#39;d like to get a hex dump of what&#39;s in `buf`, of a format similar to `xxd` (I don&#39;t care if it&#39;s an exact match, what I&#39;m really looking for is a hex dump side by side with printable chars).

Inside GDB I can use something like:

    (gdb) x /100bx buf
    0x7fffffffdf00: 0x01    0x02    0x03    0x04    0x53    0x74    0x72    0x69
    0x7fffffffdf08: 0x6e    0x67    0x20    0x44    0x61    0x74    0x61    0xaa
    0x7fffffffdf10: 0xbb    0xcc    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf18: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf20: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf28: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf30: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf38: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf40: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf48: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf50: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00
    0x7fffffffdf58: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00

which is fine, but it&#39;s hard to pick out strings that way... or I can use

    (gdb) x /100bs buf
    0x7fffffffdf00:  &quot;\001\002\003\004String Data\252\273\314&quot;
    0x7fffffffdf13:  &quot;&quot;
    0x7fffffffdf14:  &quot;&quot;
    0x7fffffffdf15:  &quot;&quot;
    0x7fffffffdf16:  &quot;&quot;
    0x7fffffffdf17:  &quot;&quot;
    ...

which makes it hard to read the binary part... the actual messages I&#39;m dealing with have plenty of ascii nul&#39;s in them, too, so really it just looks like a mess.

The best I can come up with is to do this:

    (gdb) dump binary memory dump.bin buf buf+100

and then

    $ xxd dump.bin
    0000000: 0102 0304 5374 7269 6e67 2044 6174 61aa  ....String Data.
    0000010: bbcc 0000 0000 0000 0000 0000 0000 0000  ................
    0000020: 0000 0000 0000 0000 0000 0000 0000 0000  ................
    0000030: 0000 0000 0000 0000 0000 0000 0000 0000  ................
    0000040: 0000 0000 0000 0000 0000 0000 0000 0000  ................
    0000050: 0000 0000 0000 0000 0000 0000 0000 0000  ................
    0000060: 0000 0000                                ....

but that&#39;s a pain to do that every time. I figured somebody out there has wanted this before, so wondering if anybody has found a way to do it inside gdb.  Plus you lose the addresses from the original memory this way.

I&#39;m using GDB 7.4 with python support built in, so I&#39;m open to the idea of using a pretty printer or similar, but I don&#39;t know how to set that up.


Memory dump formatted like xxd from gdb

I keep getting this error mesage when trying to add a breakpoint in gdb.

I&#39;ve used these commands to compile:

    gcc -g main.c utmpib2.c -o main.o
    and:
    cc -g main.c utmpib2.c -o main.o
    and also:
    g++ -g main.c utmpib2.c -o main.o

I also tried &quot;-ggdb&quot; instead of &quot;-g&quot; and I still get that error message.

I then execute gdb:

    $gdb

In gdb:

    (gdb)exec-file main.o
    (gdb)break 59
    No symbol table is loaded. Use the &quot;file&quot; command.



gdb: &quot;No symbol table is loaded&quot;

Suppose that

    (gdb) print *this

resulted in 20 lines of output. Yes, there would be `Type &lt;return&gt; to continue, or q &lt;return&gt; to quit`, but I&#39;d like to scroll back to the top after I got to the bottom of the output.

I don&#39;t think http://sourceware.org/gdb/onlinedocs/gdb/TUI-Keys.html answers my question. It states

&gt; &amp;lt;PgUp&amp;gt; &lt;br&gt;
&gt; Scroll the active window one page up.

but when the focus is on the command window, &lt;kbd&gt;PgUp&lt;/kbd&gt; rewinds the command history, instead of scrolling back in the command window. Is it only me who suffers from this behavior?

I&#39;m using [PuTTY][1] in order to SSH to Red Hat Linux (if this makes any difference).

  [1]: http://en.wikipedia.org/wiki/PuTTY


How can I scroll back in GDB&#39;s command window in the TUI mode?

What are the fundamental differences between queues and pipes in [Python&#39;s multiprocessing package][1]?

In what scenarios should one choose one over the other?  When is it advantageous to use `Pipe()`?  When is it advantageous to use `Queue()`?


  [1]: http://docs.python.org/library/multiprocessing.html

Multiprocessing - Pipe vs Queue

I&#39;ve a pipline doing just 

     command1 | command2

So, stdout of command1 goes to command2 , while stderr of command1 go to the terminal (or wherever stdout of the shell is). 

How can I pipe stderr of command1 to a third process (`command3`) while stdout is still going to command2 ?

pipe stdout and stderr to two different processes in shell script?

I often use pipes in Bash, e.g.:

    dmesg | less

Although I know what this outputs, it takes `dmesg` and lets me scroll through it with `less`, I do not understand what the `|` is doing. Is it simply the opposite of `&gt;`?

- Is there a simple, or metaphorical explanation for what `|` does?
- What goes on when several pipes are used in a single line?
- Is the behavior of pipes consistent everywhere it appears in a Bash script?

What is a simple explanation for how pipes work in Bash?

How can I pipe several external commands together in Go? I&#39;ve tried this code but I get an error that says `exit status 1`.

	package main

	import (
		&quot;io&quot;
		&quot;log&quot;
		&quot;os&quot;
		&quot;os/exec&quot;
	)

	func main() {
		c1 := exec.Command(&quot;ls&quot;)
		stdout1, err := c1.StdoutPipe()
		if err != nil {
			log.Fatal(err)
		}

		if err = c1.Start(); err != nil {
			log.Fatal(err)
		}
		if err = c1.Wait(); err != nil {
			log.Fatal(err)
		}

		c2 := exec.Command(&quot;wc&quot;, &quot;-l&quot;)
		c2.Stdin = stdout1

		stdout2, err := c2.StdoutPipe()
		if err != nil {
			log.Fatal(err)
		}

		if err = c2.Start(); err != nil {
			log.Fatal(err)
		}
		if err = c2.Wait(); err != nil {
			log.Fatal(err)
		}

		io.Copy(os.Stdout, stdout2)
	}

How to pipe several commands in Go?

Usually, `stdout` is line-buffered. In other words, as long as your `printf` argument ends with a newline, you can expect the line to be printed instantly. This does not appear to hold when using a pipe to redirect to `tee`.

I have a C++ program, `a`, that outputs strings, always `\n`-terminated, to `stdout`.

When it is run by itself (`./a`), everything prints correctly and at the right time, as expected. However, if I pipe it to `tee` (`./a | tee output.txt`), it doesn&#39;t print anything until it quits, which defeats the purpose of using `tee`.

I know that I could fix it by adding a `fflush(stdout)` after each printing operation in the C++ program. But is there a cleaner, easier way? Is there a command I can run, for example, that would force `stdout` to be line-buffered, even when using a pipe?

Content Type	Original Author	Original Content on Stackoverflow
Question	mandreko	View Question on Stackoverflow
Solution 1 - Gdb	zed_0xff	View Answer on Stackoverflow

gdb - debugging with piped input (not arguments)

Gdb Problem Overview

Gdb Solutions

Solution 1 - Gdb

ViewPager inside a ScrollView does not scroll correclty

iOS - How to implement a performSelector with multiple arguments and with afterDelay?

Attributions