Tcl Expect script - Spawned process from forked child process never returns EOF - tcl

Question

I've run into another strange behavior I can't seem to find an answer for. These are really confusing as I am seeing this problem with the simplest code, which is nearly straight out of the Exploring Expect book. I'm not sure why I'm seeing these issue, and no one else seems to have any problems.
Again, I've boiled this down to a super simple script. If I run it with no arguments, it doesn't fork off the process to a child and kill the parent. If I pass it any argument at all, it will use fork to create a child. When this runs as a parent process, it works normally as expected. But when this runs in the child process, the "expect" command doesn't seem to be connected to anything as it isn't receiving any output from the spawned process. I just don't know enough about what is going on here to be able to debug the problem.
The simple (updated) script:
package require Expect
puts "Tcl version : [info tclversion]"
puts "Expect version: [exp_version]"
# Any passed in argument will enable forking to child process
# fork_cat : Forks and then spawns a process to simply cat a text to stdout
# fork_wish: Forks and then spawns a process to start up wish which opens the
# Tk window as well out the interactive prompt % from the interpreter.
if {$argc > 0} {
while {1} {
# If forking fails, retry every 10 seconds until it succeeds.
if {[catch fork child_pid] == 0} {
break
}
sleep 10
}
if {[lindex $argv 0] == "fork_wish"} {
# Delay so process tree snapshot can be captured with both parent and child processes
sleep 20
}
# Kills the parent process to return terminal control to shell
if {$child_pid != 0} {
puts "[pid] Parent process exiting..."
exit
}
if {[lindex $argv 0] == "fork_wish"} {
# Delay so process tree snapshot can be captured of only child process after parent exits
sleep 20
}
# Redefine exit procedure for child so it kills the process for sure on exit
# I have no idea why exit doesn't work for a child process, but this seems to ensure it goes away on exit.
exit -onexit {
puts "[pid] Killing PID..."
exec kill [pid]
}
}
sleep 1
# Show stty output in case it is relevant to debugging
puts ""
stty -a
puts ""
# Spawn process to cat a text file
switch -exact [lindex $argv 0] {
"fork_cat" {
set spawned_pid [spawn -noecho cat 123.txt]
}
"fork_wish" {
set spawned_pid [spawn -noecho wish]
}
default {
set spawned_pid [spawn -noecho cat 123.txt]
}
}
while {1} {
expect {
eof {
puts ""
puts "[pid] Process received EOF from spawned process"
break
}
timeout {
puts ""
puts "[pid] Process expect timed out for spawned process"
}
}
}
puts ""
puts "[pid] Process exiting..."
exit
Running "cat" without any forking (normal foreground process):
:> temp_eof
Tcl version : 8.4
Expect version: 5.43.0
speed 38400 baud; line = 0;
-brkint ixoff -imaxbel
123
123
123
123
123
15060 Process recieved EOF from spawned process
15060 Process exiting...
Running "cat" without any forking (background process):
:> temp_eof &
[1] 15081
:> Tcl version : 8.4
Expect version: 5.43.0
speed 38400 baud; line = 0;
eof = <undef>; susp = <undef>; rprnt = <undef>; werase = <undef>; lnext = <undef>; min = 1; time = 0;
-brkint inlcr ixoff -imaxbel
-icanon -iexten -echo -echok
123
123
123
123
123
15081 Process received EOF from spawned process
15081 Process exiting...
[1] + Suspended (tty output) temp_eof
[lc-bun-019: AB: ~/bin]
:> fg
temp_eof
Running "cat" with forking:
:> temp_eof fork_cat
Tcl version : 8.4
Expect version: 5.43.0
15121 Parent process exiting...
:>
speed 38400 baud; line = 0;
eof = <undef>; susp = <undef>; rprnt = <undef>; werase = <undef>; lnext = <undef>; min = 1; time = 0;
-brkint inlcr ixoff -imaxbel
-icanon -iexten -echo -echok
15123 Process expect timed out for spawned process
15123 Process expect timed out for spawned process
15123 Process expect timed out for spawned process
15123 Process expect timed out for spawned process
15123 Process expect timed out for spawned process
15123 Process expect timed out for spawned process
15123 Process expect timed out for spawned process
:> pkill temp_eof
So the question is, why does expect work fine from a normal foregrounded process, but doesn't seem to receive any output from the spawned process when executed from a forked child process? Also not sure why the non-forked backgrounded version is suspending the tty when it exits. But you can now see the similarity of the output from stty in a normally started background process compared to the spawned process started from the forked child process.
I have verified that the spawn command is actually running from the forked child process. I changed the command from cat to something like "touch" that creates a file as evidence it actually was spawned. But either the spawned process has it's output directed somewhere else, or the expect isn't correctly seeing it. My feeling is that it's the former, and that while spawn is succesfully creating a process, it's stdin/stdout maybe be pointing to /dev/null. I am just not experienced enough to debug further. I know enough to get myself into trouble, but apparently not enough to get myself out of it.
I also wanted to capture snapshots of the process tree at 3 points in time. One when the parent and child are both alive. Another when the parent has died, and only the child remains alive. And finally when the child process and it's spawned process are alive. For this I change to spawning something GUI-like that stays open until you X it dead. I thought "wish" was perfect for this. In a separate shell during the 20 second delays, I ran "ps axjf" and redirected into a file. The important parts of that output are shown below the stdout captured below.
First the shell output from this run of "fork_wish":
:> temp_eof fork_wish
Tcl version : 8.4
Expect version: 5.43.0
29172 Parent process exiting...
:>
speed 38400 baud; line = 0;
eof = <undef>; susp = <undef>; rprnt = <undef>; werase = <undef>; lnext = <undef>; min = 1; time = 0;
-brkint inlcr ixoff -imaxbel
-icanon -iexten -echo -echok
29174 Process expect timed out for spawned process
29174 Process expect timed out for spawned process
29174 Process expect timed out for spawned process
29174 Process expect timed out for spawned process
29174 Process expect timed out for spawned process
29174 Process expect timed out for spawned process
29174 Process expect timed out for spawned process
:> pkill temp_eof
First snapshot (both parent and child alive):
PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
1 24566 24564 20131 pts/30 20131 S 9276 0:00 konsole -T Main /dev/null
24566 24569 24569 24569 pts/35 29172 Ss 9276 0:00 \_ -bin/tcsh
24569 29172 29172 24569 pts/35 29172 Sl+ 9276 0:00 | \_ /usr/local/bin/tclsh temp_eof fork_wish
29172 29174 29172 24569 pts/35 29172 S+ 9276 0:00 | \_ /usr/local/bin/tclsh temp_eof fork_wish
24566 26530 26530 26530 pts/36 29175 Ss 9276 0:00 \_ -bin/tcsh
26530 29175 29175 26530 pts/36 29175 R+ 9276 0:00 \_ ps axjf
Second snapshot (child alive, parent dead):
PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
1 24566 24564 20131 pts/30 20131 S 9276 0:00 konsole -T Main /dev/null
24566 24569 24569 24569 pts/35 24569 Ss+ 9276 0:00 \_ -bin/tcsh
24566 26530 26530 26530 pts/36 29176 Ss 9276 0:00 \_ -bin/tcsh
26530 29176 29176 26530 pts/36 29176 R+ 9276 0:00 \_ ps axjf
1 29174 29172 24569 pts/35 24569 S 9276 0:00 /usr/local/bin/tclsh temp_eof fork_wish
Third snapshot (child and spawn alive):
PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
1 24566 24564 20131 pts/30 20131 S 9276 0:00 konsole -T Main /dev/null
24566 24569 24569 24569 pts/35 24569 Ss+ 9276 0:00 \_ -bin/tcsh
24566 26530 26530 26530 pts/36 29192 Ss 9276 0:00 \_ -bin/tcsh
26530 29192 29192 26530 pts/36 29192 R+ 9276 0:00 \_ ps axjf
1 29174 29172 24569 pts/35 24569 S 9276 0:00 /usr/local/bin/tclsh temp_eof fork_wish
29174 29178 29178 29178 pts/37 29178 Ssl+ 9276 0:00 \_ /usr/bin/wish
The thing that looks strange to me here, is that the spawned process has a new, unique, TTY of pty/37, while the child process has a TTY of pty/35 (which matches the tcsh TTY that started it). This is in line with the child still being able to send text to stdout, while the spawened process can't seem to send anything anywhere. Is the unique pts/37 TTY expected for a process spawned from Expect? I thought I remember reading that Expect created a new pseudo-terminal for communication with it's spawned processes. But if that's the case, why is Expect losing communication with it's spawned process connected to pty/37?
I've tried to gather some more clues and information, but something still seems very fishy here. This is pretty much what Expect is designed to do, and the behavior just doesn't seem to be in line with what I understand. Do others see this same behavior if you run my simple example script on your setup?
Thanks in advance for any help or suggestions.

Answer 1

use :
expect_user [expect_args]
is like expect but it reads characters from stdin (i.e.
keystrokes from the user). By default, reading is performed in
cooked mode. Thus, lines must end with a return in order for
expect to see them. This may be changed via stty (see the stty
command below).
instead of expect worked for me.