Commit | Line | Data |
---|---|---|
85e6fe83 LW |
1 | Article 20992 of comp.lang.perl: |
2 | Path: netlabs!news.cerf.net!mvb.saic.com!MathWorks.Com!europa.eng.gtefsd.com!howland.reston.ans.net!cs.utexas.edu!swrinde!ihnp4.ucsd.edu!ames!koriel!male.EBay.Sun.COM!jethro.Corp.Sun.COM!eric | |
3 | From: eric.arnold@sun.com (Eric Arnold) | |
4 | Newsgroups: comp.lang.perl | |
5 | Subject: Re: Need a bidirectional filter for interactive Unix applications | |
6 | Date: 15 Apr 94 21:24:03 GMT | |
7 | Organization: Sun Microsystems | |
8 | Lines: 478 | |
9 | Sender: news@sun.com | |
10 | Message-ID: <ERIC.94Apr15212403@sun.com> | |
11 | References: <dgfCo9F2J.Jzw@netcom.com> <1994Apr15.110134.4581@chemabs.uucp> | |
12 | NNTP-Posting-Host: animus.corp.sun.com | |
13 | X-Newsreader: prn Ver 1.09 | |
14 | In-reply-to: btf64@cas.org's message of Fri, 15 Apr 1994 11:01:34 GMT | |
15 | ||
16 | In article <1994Apr15.110134.4581@chemabs.uucp> | |
17 | btf64@cas.org (Bernard T. French) writes: | |
18 | ||
19 | >In article <dgfCo9F2J.Jzw@netcom.com> dgf@netcom.com (David Feldman) writes: | |
20 | >>I need to write a bidirectional filter that would (ideally) sit between a | |
21 | .. | |
22 | >>program's stdin & stdout to point to a pty pair known to perl. The perl app- | |
23 | >>lication would talk to the user's crt/keyboard, translate (application-specific) | |
24 | >>the input & output streams, and pass these as appropriate to/from the pty pair, | |
25 | .. | |
26 | > | |
27 | > I'm afraid I can't offer you a perl solution, but err..... there is a | |
28 | >Tcl solution. There is a Tcl extension called "expect" that is designed to | |
29 | ||
30 | There *is* an old, established Perl solution: "chat2.pl" which does | |
31 | everything (well, basically) "expect" does but you get it in the | |
32 | expressive Perl environment. "chat2.pl" is delivered with the Perl | |
33 | source. | |
34 | ||
35 | Randal: "interact()" still hasn't made it into Perl5alpha8 | |
36 | "chat2.pl", so I've included a version which does. | |
37 | ||
38 | -Eric | |
39 | ||
40 | ||
41 | ## chat.pl: chat with a server | |
42 | ## V2.01.alpha.7 91/06/16 | |
43 | ## Randal L. Schwartz | |
44 | ||
45 | package chat; | |
46 | ||
47 | $sockaddr = 'S n a4 x8'; | |
48 | chop($thishost = `hostname`); $thisaddr = (gethostbyname($thishost))[4]; | |
49 | $thisproc = pack($sockaddr, 2, 0, $thisaddr); | |
50 | ||
51 | # *S = symbol for current I/O, gets assigned *chatsymbol.... | |
52 | $next = "chatsymbol000000"; # next one | |
53 | $nextpat = "^chatsymbol"; # patterns that match next++, ++, ++, ++ | |
54 | ||
55 | ||
56 | ## $handle = &chat'open_port("server.address",$port_number); | |
57 | ## opens a named or numbered TCP server | |
58 | ||
59 | sub open_port { ## public | |
60 | local($server, $port) = @_; | |
61 | ||
62 | local($serveraddr,$serverproc); | |
63 | ||
64 | *S = ++$next; | |
65 | if ($server =~ /^(\d+)+\.(\d+)\.(\d+)\.(\d+)$/) { | |
66 | $serveraddr = pack('C4', $1, $2, $3, $4); | |
67 | } else { | |
68 | local(@x) = gethostbyname($server); | |
69 | return undef unless @x; | |
70 | $serveraddr = $x[4]; | |
71 | } | |
72 | $serverproc = pack($sockaddr, 2, $port, $serveraddr); | |
73 | unless (socket(S, 2, 1, 6)) { | |
74 | # XXX hardwired $AF_SOCKET, $SOCK_STREAM, 'tcp' | |
75 | # but who the heck would change these anyway? (:-) | |
76 | ($!) = ($!, close(S)); # close S while saving $! | |
77 | return undef; | |
78 | } | |
79 | unless (bind(S, $thisproc)) { | |
80 | ($!) = ($!, close(S)); # close S while saving $! | |
81 | return undef; | |
82 | } | |
83 | unless (connect(S, $serverproc)) { | |
84 | ($!) = ($!, close(S)); # close S while saving $! | |
85 | return undef; | |
86 | } | |
87 | select((select(S), $| = 1)[0]); | |
88 | $next; # return symbol for switcharound | |
89 | } | |
90 | ||
91 | ## ($host, $port, $handle) = &chat'open_listen([$port_number]); | |
92 | ## opens a TCP port on the current machine, ready to be listened to | |
93 | ## if $port_number is absent or zero, pick a default port number | |
94 | ## process must be uid 0 to listen to a low port number | |
95 | ||
96 | sub open_listen { ## public | |
97 | ||
98 | *S = ++$next; | |
99 | local($thisport) = shift || 0; | |
100 | local($thisproc_local) = pack($sockaddr, 2, $thisport, $thisaddr); | |
101 | local(*NS) = "__" . time; | |
102 | unless (socket(NS, 2, 1, 6)) { | |
103 | # XXX hardwired $AF_SOCKET, $SOCK_STREAM, 'tcp' | |
104 | # but who the heck would change these anyway? (:-) | |
105 | ($!) = ($!, close(NS)); | |
106 | return undef; | |
107 | } | |
108 | unless (bind(NS, $thisproc_local)) { | |
109 | ($!) = ($!, close(NS)); | |
110 | return undef; | |
111 | } | |
112 | unless (listen(NS, 1)) { | |
113 | ($!) = ($!, close(NS)); | |
114 | return undef; | |
115 | } | |
116 | select((select(NS), $| = 1)[0]); | |
117 | local($family, $port, @myaddr) = | |
118 | unpack("S n C C C C x8", getsockname(NS)); | |
119 | $S{"needs_accept"} = *NS; # so expect will open it | |
120 | (@myaddr, $port, $next); # returning this | |
121 | } | |
122 | ||
123 | ## $handle = &chat'open_proc("command","arg1","arg2",...); | |
124 | ## opens a /bin/sh on a pseudo-tty | |
125 | ||
126 | sub open_proc { ## public | |
127 | local(@cmd) = @_; | |
128 | ||
129 | *S = ++$next; | |
130 | local(*TTY) = "__TTY" . time; | |
131 | local($pty,$tty,$pty_handle) = &_getpty(S,TTY); | |
132 | ||
133 | #local($pty,$tty,$pty_handle) = &getpty(S,TTY); | |
134 | #$Tty = $tty; | |
135 | ||
136 | die "Cannot find a new pty" unless defined $pty; | |
137 | local($pid) = fork; | |
138 | die "Cannot fork: $!" unless defined $pid; | |
139 | unless ($pid) { | |
140 | close STDIN; close STDOUT; close STDERR; | |
141 | #close($pty_handle); | |
142 | setpgrp(0,$$); | |
143 | if (open(DEVTTY, "/dev/tty")) { | |
144 | ioctl(DEVTTY,0x20007471,0); # XXX s/b &TIOCNOTTY | |
145 | close DEVTTY; | |
146 | } | |
147 | open(STDIN,"<&TTY"); | |
148 | open(STDOUT,">&TTY"); | |
149 | open(STDERR,">&STDOUT"); | |
150 | die "Oops" unless fileno(STDERR) == 2; # sanity | |
151 | close(S); | |
152 | ||
153 | exec @cmd; | |
154 | die "Cannot exec @cmd: $!"; | |
155 | } | |
156 | close(TTY); | |
157 | $PID{$next} = $pid; | |
158 | $next; # return symbol for switcharound | |
159 | ||
160 | } | |
161 | ||
162 | # $S is the read-ahead buffer | |
163 | ||
164 | ## $return = &chat'expect([$handle,] $timeout_time, | |
165 | ## $pat1, $body1, $pat2, $body2, ... ) | |
166 | ## $handle is from previous &chat'open_*(). | |
167 | ## $timeout_time is the time (either relative to the current time, or | |
168 | ## absolute, ala time(2)) at which a timeout event occurs. | |
169 | ## $pat1, $pat2, and so on are regexs which are matched against the input | |
170 | ## stream. If a match is found, the entire matched string is consumed, | |
171 | ## and the corresponding body eval string is evaled. | |
172 | ## | |
173 | ## Each pat is a regular-expression (probably enclosed in single-quotes | |
174 | ## in the invocation). ^ and $ will work, respecting the current value of $*. | |
175 | ## If pat is 'TIMEOUT', the body is executed if the timeout is exceeded. | |
176 | ## If pat is 'EOF', the body is executed if the process exits before | |
177 | ## the other patterns are seen. | |
178 | ## | |
179 | ## Pats are scanned in the order given, so later pats can contain | |
180 | ## general defaults that won't be examined unless the earlier pats | |
181 | ## have failed. | |
182 | ## | |
183 | ## The result of eval'ing body is returned as the result of | |
184 | ## the invocation. Recursive invocations are not thought | |
185 | ## through, and may work only accidentally. :-) | |
186 | ## | |
187 | ## undef is returned if either a timeout or an eof occurs and no | |
188 | ## corresponding body has been defined. | |
189 | ## I/O errors of any sort are treated as eof. | |
190 | ||
191 | $nextsubname = "expectloop000000"; # used for subroutines | |
192 | ||
193 | sub expect { ## public | |
194 | if ($_[0] =~ /$nextpat/) { | |
195 | *S = shift; | |
196 | } | |
197 | local($endtime) = shift; | |
198 | ||
199 | local($timeout,$eof) = (1,1); | |
200 | local($caller) = caller; | |
201 | local($rmask, $nfound, $timeleft, $thisbuf); | |
202 | local($cases, $pattern, $action, $subname); | |
203 | $endtime += time if $endtime < 600_000_000; | |
204 | ||
205 | if (defined $S{"needs_accept"}) { # is it a listen socket? | |
206 | local(*NS) = $S{"needs_accept"}; | |
207 | delete $S{"needs_accept"}; | |
208 | $S{"needs_close"} = *NS; | |
209 | unless(accept(S,NS)) { | |
210 | ($!) = ($!, close(S), close(NS)); | |
211 | return undef; | |
212 | } | |
213 | select((select(S), $| = 1)[0]); | |
214 | } | |
215 | ||
216 | # now see whether we need to create a new sub: | |
217 | ||
218 | unless ($subname = $expect_subname{$caller,@_}) { | |
219 | # nope. make a new one: | |
220 | $expect_subname{$caller,@_} = $subname = $nextsubname++; | |
221 | ||
222 | $cases .= <<"EDQ"; # header is funny to make everything elsif's | |
223 | sub $subname { | |
224 | LOOP: { | |
225 | if (0) { ; } | |
226 | EDQ | |
227 | while (@_) { | |
228 | ($pattern,$action) = splice(@_,0,2); | |
229 | if ($pattern =~ /^eof$/i) { | |
230 | $cases .= <<"EDQ"; | |
231 | elsif (\$eof) { | |
232 | package $caller; | |
233 | $action; | |
234 | } | |
235 | EDQ | |
236 | $eof = 0; | |
237 | } elsif ($pattern =~ /^timeout$/i) { | |
238 | $cases .= <<"EDQ"; | |
239 | elsif (\$timeout) { | |
240 | package $caller; | |
241 | $action; | |
242 | } | |
243 | EDQ | |
244 | $timeout = 0; | |
245 | } else { | |
246 | $pattern =~ s#/#\\/#g; | |
247 | $cases .= <<"EDQ"; | |
248 | elsif (\$S =~ /$pattern/) { | |
249 | \$S = \$'; | |
250 | package $caller; | |
251 | $action; | |
252 | } | |
253 | EDQ | |
254 | } | |
255 | } | |
256 | $cases .= <<"EDQ" if $eof; | |
257 | elsif (\$eof) { | |
258 | undef; | |
259 | } | |
260 | EDQ | |
261 | $cases .= <<"EDQ" if $timeout; | |
262 | elsif (\$timeout) { | |
263 | undef; | |
264 | } | |
265 | EDQ | |
266 | $cases .= <<'ESQ'; | |
267 | else { | |
268 | $rmask = ""; | |
269 | vec($rmask,fileno(S),1) = 1; | |
270 | ($nfound, $rmask) = | |
271 | select($rmask, undef, undef, $endtime - time); | |
272 | if ($nfound) { | |
273 | $nread = sysread(S, $thisbuf, 1024); | |
274 | if ($nread > 0) { | |
275 | $S .= $thisbuf; | |
276 | } else { | |
277 | $eof++, redo LOOP; # any error is also eof | |
278 | } | |
279 | } else { | |
280 | $timeout++, redo LOOP; # timeout | |
281 | } | |
282 | redo LOOP; | |
283 | } | |
284 | } | |
285 | } | |
286 | ESQ | |
287 | eval $cases; die "$cases:\n$@" if $@; | |
288 | } | |
289 | $eof = $timeout = 0; | |
290 | do $subname(); | |
291 | } | |
292 | ||
293 | ## &chat'print([$handle,] @data) | |
294 | ## $handle is from previous &chat'open(). | |
295 | ## like print $handle @data | |
296 | ||
297 | sub print { ## public | |
298 | if ($_[0] =~ /$nextpat/) { | |
299 | *S = shift; | |
300 | } | |
301 | print S @_; | |
302 | } | |
303 | ||
304 | ## &chat'close([$handle,]) | |
305 | ## $handle is from previous &chat'open(). | |
306 | ## like close $handle | |
307 | ||
308 | sub close { ## public | |
309 | local($pid); | |
310 | if ($_[0] =~ /$nextpat/) { | |
311 | $pid = $PID{$_[0]}; | |
312 | *S = shift; | |
313 | } else { | |
314 | $pid = $PID{$next}; | |
315 | } | |
316 | close(S); | |
317 | waitpid($pid,0); | |
318 | if (defined $S{"needs_close"}) { # is it a listen socket? | |
319 | local(*NS) = $S{"needs_close"}; | |
320 | delete $S{"needs_close"}; | |
321 | close(NS); | |
322 | } | |
323 | } | |
324 | ||
325 | ## @ready_handles = &chat'select($timeout, @handles) | |
326 | ## select()'s the handles with a timeout value of $timeout seconds. | |
327 | ## Returns an array of handles that are ready for I/O. | |
328 | ## Both user handles and chat handles are supported (but beware of | |
329 | ## stdio's buffering for user handles). | |
330 | ||
331 | sub select { ## public | |
332 | local($timeout) = shift; | |
333 | local(@handles) = @_; | |
334 | local(%handlename) = (); | |
335 | local(%ready) = (); | |
336 | local($caller) = caller; | |
337 | local($rmask) = ""; | |
338 | for (@handles) { | |
339 | if (/$nextpat/o) { # one of ours... see if ready | |
340 | local(*SYM) = $_; | |
341 | if (length($SYM)) { | |
342 | $timeout = 0; # we have a winner | |
343 | $ready{$_}++; | |
344 | } | |
345 | $handlename{fileno($_)} = $_; | |
346 | } else { | |
347 | $handlename{fileno(/'/ ? $_ : "$caller\'$_")} = $_; | |
348 | } | |
349 | } | |
350 | for (sort keys %handlename) { | |
351 | vec($rmask, $_, 1) = 1; | |
352 | } | |
353 | select($rmask, undef, undef, $timeout); | |
354 | for (sort keys %handlename) { | |
355 | $ready{$handlename{$_}}++ if vec($rmask,$_,1); | |
356 | } | |
357 | sort keys %ready; | |
358 | } | |
359 | ||
360 | # ($pty,$tty) = $chat'_getpty(PTY,TTY): | |
361 | # internal procedure to get the next available pty. | |
362 | # opens pty on handle PTY, and matching tty on handle TTY. | |
363 | # returns undef if can't find a pty. | |
364 | ||
365 | sub _getpty { ## private | |
366 | local($_PTY,$_TTY) = @_; | |
367 | $_PTY =~ s/^([^']+)$/(caller)[$[]."'".$1/e; | |
368 | $_TTY =~ s/^([^']+)$/(caller)[$[]."'".$1/e; | |
369 | local($pty,$tty); | |
370 | for $bank (112..127) { | |
371 | next unless -e sprintf("/dev/pty%c0", $bank); | |
372 | for $unit (48..57) { | |
373 | $pty = sprintf("/dev/pty%c%c", $bank, $unit); | |
374 | open($_PTY,"+>$pty") || next; | |
375 | select((select($_PTY), $| = 1)[0]); | |
376 | ($tty = $pty) =~ s/pty/tty/; | |
377 | open($_TTY,"+>$tty") || next; | |
378 | select((select($_TTY), $| = 1)[0]); | |
379 | system "stty nl>$tty"; | |
380 | return ($pty,$tty,$_PTY); | |
381 | } | |
382 | } | |
383 | undef; | |
384 | } | |
385 | ||
386 | ||
387 | sub getpty { | |
388 | local( $pty_handle, $tty_handle ) = @_; | |
389 | ||
390 | print "--------in getpty----------\n"; | |
391 | $pty_handle =~ s/^([^']+)$/(caller)[$[]."'".$1/e; | |
392 | $pty_handle =~ s/^([^']+)$/(caller)[$[]."'".$1/e; | |
393 | ||
394 | #$pty_handle = ++$next_handle; | |
395 | chop( @ptys = `ls /dev/pty*` ); | |
396 | ||
397 | for $pty ( @ptys ) | |
398 | { | |
399 | open($pty_handle,"+>$pty") || next; | |
400 | select((select($pty_handle), $| = 1)[0]); | |
401 | ($tty = $pty) =~ s/pty/tty/; | |
402 | ||
403 | open($tty_handle,"+>$tty") || next; | |
404 | select((select($tty_handle), $| = 1)[0]); | |
405 | ($tty = $pty) =~ s/pty/tty/; | |
406 | ||
407 | return ($pty, $tty, $pty_handle ); | |
408 | } | |
409 | return undef; | |
410 | } | |
411 | ||
412 | ||
413 | ||
414 | # from: Randal L. Schwartz | |
415 | ||
416 | # Usage: | |
417 | # | |
418 | # ($chathandle = &chat'open_proc("/bin/sh")) || die "cannot open shell"; | |
419 | # system("stty cbreak raw -echo >/dev/tty\n"); | |
420 | # &chat'interact($chathandle); | |
421 | # &chat'close($chathandle); | |
422 | # system("stty -cbreak -raw echo >/dev/tty\n"); | |
423 | ||
424 | sub interact | |
425 | { | |
426 | local( $chathandle ) = @_; | |
427 | ||
428 | &chat'print($chathandle, "stty sane\n"); | |
429 | select(STDOUT) ; $| = 1; # unbuffer STDOUT | |
430 | ||
431 | #print "tty=$Tty,whoami=",`whoami`,"\n"; | |
432 | #&change_utmp( "", $Tty, "eric", "", time() ); | |
433 | ||
434 | { | |
435 | @ready = &chat'select(30, STDIN,$chathandle); | |
436 | print "after select, ready=",join(",",@ready),"\n"; | |
437 | #(warn "[waiting]"), redo unless @ready; | |
438 | if (grep($_ eq $chathandle, @ready)) { | |
439 | print "checking $chathandle\n"; | |
440 | last unless $text = &chat'expect($chathandle,0,'[\s\S]+','$&'); | |
441 | print "$chathandle OK\n"; | |
442 | print "got=($text)"; | |
443 | #print $text; | |
444 | } | |
445 | if (grep($_ eq STDIN, @ready)) { | |
446 | print "checking STDIN\n"; | |
447 | last unless sysread(STDIN,$buf,1024) > 0; | |
448 | print "STDIN OK\n"; | |
449 | &chat'print($chathandle,$buf); | |
450 | } | |
451 | redo; | |
452 | } | |
453 | #&change_utmp( $Tty, "$Tty", "", "", 0 ); | |
454 | print "leaving interact, \$!=$!\n"; | |
455 | } | |
456 | ||
457 | ## $handle = &chat'open_duphandle(handle); | |
458 | ## duplicates an input file handle to conform to chat format | |
459 | ||
460 | sub open_duphandle { ## public | |
461 | *S = ++$next; | |
462 | open(S,"<&$_[0]"); | |
463 | $next; # return symbol for switcharound | |
464 | } | |
465 | ||
466 | #Here is an example which uses this routine. | |
467 | # | |
468 | # # The following lines makes stdin unbuffered | |
469 | # | |
470 | # $BSD = -f '/vmunix'; | |
471 | # | |
472 | # if ($BSD) { | |
473 | # system "stty cbreak </dev/tty >/dev/tty 2>&1"; | |
474 | # } | |
475 | # else { | |
476 | # system "stty", '-icanon'; | |
477 | # system "stty", 'eol', '^A'; | |
478 | # } | |
479 | # | |
480 | # require 'mychat2.pl'; | |
481 | # | |
482 | # &chat'open_duphandle(STDIN); | |
483 | # | |
484 | ||
485 | # &chat'expect(3, | |
486 | # '[A-Z]', '" :-)"', | |
487 | # '.', '" :-("', | |
488 | # TIMEOUT, '"-o-"', | |
489 | # EOF, '"\$\$"'), | |
490 | # "\n"; | |
491 | ||
492 | ||
493 | 1; | |
494 | ||
495 |