pty 0.1.3

Fork with new pseudo-terminal (PTY)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

# PTY [![Build Status](https://travis-ci.org/hibariya/pty-rs.svg?branch=master)](https://travis-ci.org/hibariya/pty-rs)

The `pty` crate provides `pty::fork()`. That makes a parent process fork with new pseudo-terminal (PTY).

This crate depends on followings:

* `libc` library
* POSIX environment

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]

pty = "0.1"
```

and this to your crate root:

```rust
extern crate pty;
```

### pty::fork()

This function returns two values. `pty::Child` represents a child process. `pty::Master` represents master of a PTY.

```rust
let (child_process, pty_master) = pty::fork();
```

For example, the following code spawns `tty(1)` command by `pty::fork()` and outputs the result of the command.

```rust
extern crate libc;
extern crate pty;

use std::ffi::CString;
use std::io::Read;
use std::ptr;

fn main()
{
    match pty::fork() {
        Ok((child_process, mut pty_master)) => {
            if child_process.pid() == 0 {
                // Child process just exec `tty`
                let mut ptrs = [CString::new("tty").unwrap().as_ptr(), ptr::null()];

                unsafe { libc::execvp(*ptrs.as_ptr(), ptrs.as_mut_ptr()) };
            }
            else {
                // Read output via PTY master
                let mut output = String::new();

                match pty_master.read_to_string(&mut output) {
                    Ok(_nread)  => println!("child tty is: {}", output.trim()),
                    Err(e)      => panic!("read error: {}", e)
                }

                child_process.wait();
                pty_master.close();
            }
        },
        Err(e) => panic!("pty::fork error: {}", e)
    }
}
```

When run this, we get new PTY in the child process.

```
$ tty
/dev/pts/5
$ cargo run
    Running `target/debug/example`
child tty is: /dev/pts/8
```

## Contributing

1. Fork it ( https://github.com/hibariya/pty-rs/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request

## License

Copyright (c) 2015 Hika Hibariya

Distributed under the [MIT License](LICENSE.txt).