source: trunk/minix/commands/rlogind/rlogind.c@ 9

Last change on this file since 9 was 9, checked in by Mattia Monga, 13 years ago

Minix 3.1.2a
File size: 9.3 KB
RevLine 
[9]1/*
2rlogind.c
3
4Created: by Philip Homburg <philip@cs.vu.nl>
5Log: Utmp improvement by Kees Bot <kjb@cs.vu.nl>
6 Split to compile easier on i86 by kjb
7*/
8
9#include <sys/types.h>
10#include <sys/stat.h>
11#include <sys/ioctl.h>
12#include <errno.h>
13#include <fcntl.h>
14#include <signal.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18#include <termios.h>
19#include <time.h>
20#include <unistd.h>
21#include <utmp.h>
22#include <net/hton.h>
23#define EXTERN
24#include "rlogind.h"
25
26char pty_str[]= "/dev/ptyXX";
27char tty_str[]= "/dev/ttyXX";
28char hex_str[16]= "0123456789abcdef";
29
30char PATH_UTMP[] = "/etc/utmp"; /* current logins */
31char PATH_WTMP[] = "/usr/adm/wtmp"; /* login/logout history */
32
33char term[64]= "TERM=";
34#define ENVSIZE (sizeof("TERM=")-1) /* skip null for concatenation. */
35int confirmed= 0;
36char *env[2];
37char *args[10];
38
39static void do_child(int tty_fd, char *tty_str);
40static void dealloc_term(int slot, char *tty_str, int pid);
41static void wtmp(char *user, char *id, char *line, int pid, int type, int slot);
42static void setup_term(int fd);
43static speed_t num2speed(int num);
44static int do_control(char *buf, int cnt);
45static void readall(char *buf, int cnt);
46
47int main(int argc, char *argv[])
48{
49 int error;
50 int i, j= 0;
51 int tty_fd, pty_fd;
52 int login_pid, write_pid;
53 int count, bytes, tmp_count;
54 char *lp= 0, *cp;
55 struct stat struct_stat;
56 int slot;
57
58 prog_name= argv[0];
59
60 /* Check if the remote user is allowed in. */
61 authenticate();
62
63 write(1, "", 1); /* Send the '\0' */
64 confirmed= 1;
65
66 /* We try to convince the other side not the do ^S/^Q, the rlogin
67 * protocol indicates the we only send this when XOFF is turned off
68 * but we don't know when this happens so we tell the other side that
69 * it is turned off.
70 */
71 tcp_urg(1, 1);
72
73 write(1, "\220", 1);
74
75 tcp_urg(1, 0);
76
77 /* Let's look for a pty. */
78 pty_fd= -1;
79 for (i= 'p'; i <= 'z'; i++)
80 {
81 pty_str[sizeof(pty_str)-3]= i;
82 pty_str[sizeof(pty_str)-2]= '0';
83 error= stat(pty_str, &struct_stat);
84 if (error == -1)
85 continue;
86 for (j= 0; j < 16; j++)
87 {
88 pty_str[sizeof(pty_str)-2]= hex_str[j];
89 pty_fd= open(pty_str, O_RDWR);
90 if (pty_fd != -1)
91 break;
92 }
93 if (pty_fd != -1)
94 break;
95 }
96 if (pty_fd == -1)
97 {
98 printf("%s: out of ptys\r\n", prog_name);
99 exit(1);
100 }
101 tty_str[sizeof(pty_str)-3]= i;
102 tty_str[sizeof(pty_str)-2]= hex_str[j];
103
104 tty_fd= open(tty_str, O_RDWR);
105 if (tty_fd == -1)
106 {
107 printf("%s: unable to open '%s': %s\r\n", prog_name, tty_str,
108 strerror(errno));
109 exit(1);
110 }
111
112 slot= fttyslot(tty_fd);
113
114 login_pid= fork();
115 if (login_pid == -1)
116 {
117 printf("%s: unable to fork: %s\r\n", prog_name,
118 strerror(errno));
119 exit(1);
120 }
121 if (login_pid == 0)
122 {
123 close(pty_fd);
124 wtmp("", "", tty_str, login_pid, LOGIN_PROCESS, slot);
125 do_child(tty_fd, tty_str);
126 }
127 close(tty_fd);
128
129 write_pid= fork();
130 if (write_pid == -1)
131 {
132 printf("%s: unable to fork: %s\r\n", prog_name,
133 strerror(errno));
134 exit(1);
135 }
136 if (write_pid == 0)
137 {
138 dup2(pty_fd, 0);
139 count= 0;
140 for (;;)
141 {
142 if (!count)
143 {
144 count= read(0, line, sizeof(line));
145 if (count <= 0)
146 break;
147 lp= line;
148 }
149 bytes= write(1, lp, count);
150 if (bytes <= 0 || bytes > count)
151 break;
152 lp += bytes;
153 count -= bytes;
154 }
155 kill(getppid(), SIGKILL);
156 dealloc_term(slot, tty_str, login_pid);
157 _exit(1);
158 }
159
160 dup2(pty_fd, 1);
161 count= 0;
162 for (;;)
163 {
164 if (!count)
165 {
166 count= read(0, line, sizeof(line));
167 if (count <= 0)
168 break;
169 lp= line;
170 }
171 tmp_count= count;
172 cp= memchr(lp, 255, count);
173 if (cp)
174 {
175 tmp_count= cp-lp;
176 if (tmp_count == 0)
177 {
178 tmp_count= do_control(lp, count);
179 if (tmp_count)
180 {
181 lp += tmp_count;
182 count -= tmp_count;
183 continue;
184 }
185 }
186 }
187 bytes= write(1, lp, tmp_count);
188 if (bytes <= 0 || bytes > count)
189 break;
190 lp += bytes;
191 count -= bytes;
192 }
193 kill(write_pid, SIGKILL);
194 dealloc_term(slot, tty_str, login_pid);
195 return(0);
196}
197
198static void do_child(int tty_fd, char *tty_str)
199{
200 int ctty_fd, tst_fd;
201 FILE *tty_file;
202 int sav_errno;
203 char **argp;
204
205 /* Set up the terminal attributes. */
206 setup_term(tty_fd);
207
208 /* Let's start the new session. */
209 setsid();
210 ctty_fd= open(tty_str, O_RDWR);
211 if (ctty_fd == -1)
212 {
213 printf("%s(do_child): unable to open '%s': %s\r\n",
214 prog_name, tty_str, strerror(errno));
215 exit(1);
216 }
217 /* Test if we really got a controlling tty. */
218 tst_fd= open("/dev/tty", O_RDWR);
219 if (tst_fd == -1)
220 {
221 printf(
222 "%s(do_child): '%s' didn't result in a controlling tty (%s)\r\n",
223 prog_name, tty_str, strerror(errno));
224 exit(1);
225 }
226
227 argp= args;
228 *argp++= "login";
229 *argp++= "-p";
230 *argp++= "-h";
231 *argp++= hostname;
232 if (authenticated)
233 *argp++= "-f";
234 if (lusername[0] != '\0')
235 *argp++= lusername;
236
237 /* We reached the point of no return. */
238 close(tst_fd);
239 close(tty_fd);
240
241 if (ctty_fd != 0)
242 {
243 dup2(ctty_fd, 0);
244 close(ctty_fd);
245 ctty_fd= 0;
246 }
247 dup2(ctty_fd, 1);
248#if DEBUG
249 fprintf(stderr, "execing login\r\n");
250#endif
251 dup2(ctty_fd, 2);
252 execve("/bin/login", args, env);
253 if (errno == ENOENT) execve("/usr/bin/login", args, env);
254 sav_errno= errno;
255 tty_file= fdopen(2, "w");
256 if (tty_file)
257 {
258 fprintf(tty_file, "%s(do_child): unable to exec login: %s\r\n",
259 prog_name, strerror(sav_errno));
260 fflush(tty_file);
261 }
262 _exit(1);
263}
264
265static void dealloc_term(int slot, char *tty_str, int pid)
266{
267 wtmp("", "", tty_str, pid, DEAD_PROCESS, slot);
268
269 /* Finally we reset the owner and mode of the terminal. */
270 chown(tty_str, 0, 0);
271 chmod(tty_str, 0666);
272}
273
274static void wtmp(
275 char *user, /* name of user */
276 char *id, /* inittab ID */
277 char *line, /* TTY name */
278 int pid, /* PID of process */
279 int type, /* TYPE of entry */
280 int slot) /* slot number in UTMP */
281{
282/* Log an event into the UTMP and WTMP files. */
283
284 struct utmp utmp; /* UTMP/WTMP User Accounting */
285 int fd= -1;
286 int log = 1; /* log in wtmp */
287 char *p;
288
289 /* Strip the /dev part of the TTY name. */
290 p = strrchr(line, '/');
291 if (p != 0)
292 line= p+1;
293
294 if (type == DEAD_PROCESS) {
295 /* Don't add a logout entry for just a dying login. */
296 if ((fd = open(PATH_UTMP, O_RDONLY)) < 0) return;
297 if (lseek(fd, (off_t) slot * sizeof(utmp), SEEK_SET) != -1
298 && read(fd, (void *) &utmp, sizeof(utmp)) == sizeof(utmp))
299 {
300 if (utmp.ut_type != INIT_PROCESS
301 && utmp.ut_type != USER_PROCESS)
302 log= 0;
303 }
304 close(fd);
305 }
306 if (type == LOGIN_PROCESS) log= 0; /* and don't log this one */
307
308 /* Clear the utmp record. */
309 memset((void *) &utmp, 0, sizeof(utmp));
310
311 /* Enter new values. */
312 strncpy(utmp.ut_name, user, sizeof(utmp.ut_name));
313 strncpy(utmp.ut_id, id, sizeof(utmp.ut_id));
314 strncpy(utmp.ut_line, line, sizeof(utmp.ut_line));
315 strncpy(utmp.ut_host, hostname, sizeof(utmp.ut_host));
316 utmp.ut_pid = pid;
317 utmp.ut_type = type;
318 utmp.ut_time = time((time_t *)0);
319
320 if (log) {
321 if ((fd = open(PATH_WTMP, O_WRONLY | O_APPEND)) < 0) return;
322 write(fd, (char *) &utmp, sizeof(struct utmp));
323 close(fd);
324 }
325
326 /* write entry to utmp */
327 if ((fd = open(PATH_UTMP, O_WRONLY)) < 0) return;
328 if (lseek(fd, (off_t) slot * sizeof(utmp), SEEK_SET) != -1)
329 write(fd, (char *) &utmp, sizeof(struct utmp));
330 close(fd);
331}
332
333void fatal(int fd, char *msg, int err)
334{
335 int len;
336 char buf[80], *bp;
337
338 bp= buf;
339 if (!confirmed)
340 *bp++= '\1';
341 if (err)
342 len= sprintf(bp, "rlogind: %s: %s.\r\n", msg, strerror(err));
343 else
344 len= sprintf(bp, "rlogind: %s.\r\n", msg);
345 write(fd, buf, bp+len-buf);
346 exit(1);
347}
348
349static void setup_term(int fd)
350{
351 char *cp, *speed;
352 struct termios tt;
353 speed_t spd;
354 int num;
355 char *check;
356
357 cp= strchr(term, '/');
358 if (cp)
359 {
360 tcgetattr(fd, &tt);
361 *cp++= '\0';
362 speed= cp;
363 cp= strchr(speed, '/');
364 if (cp)
365 *cp++= '\0';
366 num= strtol(speed, &check, 0);
367 spd= num2speed(num);
368 if (spd != B0 && check[0] == '\0')
369 {
370 cfsetospeed(&tt, spd);
371 cfsetispeed(&tt, spd);
372 }
373 tcsetattr(fd, TCSANOW, &tt);
374 }
375 env[0]= term;
376 env[1]= 0;
377}
378
379static speed_t num2speed(int num)
380{
381 static struct
382 {
383 int num;
384 speed_t value;
385 } speed_table[]=
386 {
387 { 0, B0, }, { 50, B50, }, { 75, B75, }, { 110, B110, },
388 { 134, B134, }, { 150, B150, }, { 200, B200, }, { 300, B300, },
389 { 600, B600, }, { 1200, B1200, }, { 1800, B1800, },
390 { 2400, B2400, }, { 4800, B4800, }, { 9600, B9600, },
391 { 19200, B19200, }, { 38400, B38400, },
392 { -1, -1 },
393 };
394 int i;
395
396 for (i= 0; speed_table[i].num != -1; i++)
397 {
398 if (speed_table[i].num == num)
399 return (speed_table[i].value);
400 }
401 return B0;
402}
403
404static int do_control(char *cp, int cnt)
405{
406 char buf[20];
407 struct winsize winsize;
408
409 if (cnt > sizeof(buf))
410 cnt= sizeof(buf);
411
412 memcpy(buf, cp, cnt);
413
414 /* Let's fetch the first 2 bytes. */
415 if (cnt < 2)
416 readall(buf+cnt, 2-cnt);
417 if ((unsigned char)buf[1] != 255)
418 return 0;
419
420 /* Let's fetch the first 4 bytes. */
421 if (cnt < 4)
422 readall(buf+cnt, 4-cnt);
423 if (buf[2] != 's' || buf[3] != 's')
424 return 0;
425
426 /* Let's fetch a winsize structure. */
427 if (cnt < 4 + sizeof(winsize))
428 readall(buf+cnt, 4 + sizeof(winsize) - cnt);
429
430 memcpy(&winsize, buf+4, sizeof(winsize));
431 winsize.ws_row= ntohs(winsize.ws_row);
432 winsize.ws_col= ntohs(winsize.ws_col);
433 winsize.ws_xpixel= ntohs(winsize.ws_xpixel);
434 winsize.ws_ypixel= ntohs(winsize.ws_ypixel);
435#if DEBUG
436 fprintf(stderr, "setting window size to %d, %d\r\n", winsize.ws_row,
437 winsize.ws_col);
438#endif
439 ioctl(1, TIOCSWINSZ, &winsize);
440 return 4 + sizeof(winsize);
441}
442
443static void readall(char *buf, int cnt)
444{
445 int res;
446
447 while(cnt)
448 {
449 res= read(0, buf, cnt);
450 if (res <= 0)
451 return;
452 buf += cnt;
453 cnt -= res;
454 }
455}
Note: See TracBrowser for help on using the repository browser.