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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
//required for posix_openpt to work
#define _XOPEN_SOURCE 600
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <string.h>
#include <signal.h>
#include "im.h"
#define WRITE_BUFFER_LEN 128
//determines if the master process is running
int running = 1;
//hook for when the pty child process dies
void childhook(int a) {
running = 0;
}
//pty master and slave fd
int pty_slave = -1;
int pty_master = -1;
//freopen requires fn and not fd since its a unix function
char * pty_slave_fn;
//termios of stdin before we condition it, restored on process exit
struct termios stdin_termio_bk;
//terminal rows and cols
int trows = 0;
int tcols = 0;
//hook for SIGWINCH
void winchhook(int a) {
struct winsize sz;
ioctl(STDIN_FILENO, TIOCGWINSZ, &sz);
trows = sz.ws_row;
tcols = sz.ws_col;
//trick programs into thinking the terminal is smaller than it is
if (sz.ws_row >= 1) {
sz.ws_row--;
}
ioctl(pty_slave, TIOCSWINSZ, &sz);
}
//return 0 on success, -1 on error
//sets the global vars pty_master and pty_slave
int make_pty() {
//creates the pty master
pty_master = posix_openpt(O_RDWR);
if (pty_master < 0) {
fprintf(stderr, "errno: %d, failed to create pty master", errno);
return errno;
}
//make the master pty nonblocking
fcntl(pty_master, F_SETFL,O_NONBLOCK);
//unlock the slave pty
if ( unlockpt(pty_master) <0) {
fprintf(stderr, "errno: %d, failed to unlock pty slave", errno);
return errno;
}
//gets slave path
pty_slave_fn = ptsname(pty_master);
//tries to open pty slave
pty_slave = open(pty_slave_fn, O_RDWR);
if (pty_slave < 0) {
fprintf(stderr, "errno: %d, failed to open pty slave '%s'",\
errno, pty_slave_fn);
return errno;
}
//make the pty slave the same line discipline stdin was
tcsetattr(pty_slave,TCSANOW,&stdin_termio_bk);
return 0;
}
//makes stdin raw and unblocking, previous state stored in global var
//stdin_termio_bk
void condition_stdin() {
struct termios stdin_termio;
//save existing termios settings
tcgetattr(STDIN_FILENO,&stdin_termio);
tcgetattr(STDIN_FILENO,&stdin_termio_bk);
//make it raw
cfmakeraw(&stdin_termio);
tcsetattr(STDIN_FILENO,TCSANOW,&stdin_termio);
//make it nonblocking
fcntl(STDIN_FILENO, F_SETFL,O_NONBLOCK);
}
void restore_stdin() {
tcsetattr(STDIN_FILENO,TCSANOW,&stdin_termio_bk);
}
int main (int argc, char * argv[], char * envp[]) {
condition_stdin();
if (make_pty() != 0) {
restore_stdin();
return errno;
}
//syncs the window sizes for the first time by manually running the
//resize interrupt handler
winchhook(0);
//forks for running bash
pid_t mypid = fork();
if (mypid == 0) {
//child process
//set self to be session leader
if (setsid() <0) {
fprintf(stderr, "failed to make new session\n");
}
//all the stand streams
freopen(pty_slave_fn, "r", stdin);
freopen(pty_slave_fn, "w", stdout);
freopen(pty_slave_fn, "w", stderr);
//must be a session leader to set the controlling terminal
if (ioctl(pty_slave, TIOCSCTTY, 0)) {
fprintf(stderr, "errno: %d, failed to set controlling tty\n", errno);
}
/*
* Opens up the Shell now
*/
// First checks argument, then env, then default /bin/sh
char * shellpath = "/bin/sh";
if (argc >1) {
shellpath = argv[1];
} else if (getenv("SHELL") != NULL) {
shellpath = getenv("SHELL");
}
//by convention we should set the first arg to the path to the
//shell, also should be null terminated
char * shell_args[2] = {shellpath, NULL};
//the process is now replaced with bash
if (execve(shellpath,shell_args, envp) == -1) {
fprintf(stderr, "errno: %d, Failed to start shell '%s'\n", errno, shellpath);
return errno;
}
//code should never reach this point since we ran execve
//should automatically close any file descriptors
_exit(0);
} else {
//master process
//registers interrupts
signal(SIGCHLD, childhook);
signal(SIGWINCH, winchhook);
//display the im for the first time
disp_im(STDIN_FILENO, trows, tcols);
//1 char buffer for reading from stdin and writing to pty_master
char read_buffer[1] = {0};
//buffer for reading from pty_master and writing to stdout
char write_buffer[WRITE_BUFFER_LEN] = {0};
//open
while (running) {
//only read/write syscalls work well for this, printfs
//etcs do not work
// pty_master -> STDOUT
int wchars_read = read(pty_master,write_buffer, WRITE_BUFFER_LEN);
if (wchars_read >0) {
write(STDOUT_FILENO,write_buffer,wchars_read);
}
// stdin -> pty_master, im logic is also here
int rchars_read = read(STDIN_FILENO, read_buffer, 1);
if (rchars_read > 0) {
//feeds the input char into the im state machine
char input_buffer[IM_TABLE_ENTRY_LEN+1] = {0};
int im_chars = update_im_state(read_buffer[0],
input_buffer);
//just in case it wasn't null terminated right
input_buffer[im_chars] = 0;
if (im_chars >0) {
//writes the input into pty_master if
//there was an output from the state
//machine
write(pty_master,input_buffer,im_chars);
}
//any input update will lead to a disp_im update
disp_im(STDIN_FILENO, trows, tcols);
}
}
}
//exit, only the master process should reach this point
close(pty_master);
close(pty_slave);
restore_stdin();
return 0;
}
|
