Ending Process Infinite Loop Input Redirection

I think I've got a much easier solution but I'm not sure how portable it is. Consider:

$ cat trunc.c
#include <stdio.h>

int main() {
    int c;
    while(((c = getchar()) != EOF) && ((c & 0xff) != 0xff))
        putchar(c);
    return 0; 
}

This exploits the fact that on a two's-complement machine (-1 & 0xff) == 0xff. This catches your program that prints EOF as a character. I did test it:

your_buggy_source_gen < any_ascii_file | trunc

which is equivalent to cat any_ascii_file provided there are no octets of value 0xff in it.

Not exactly a shell programming tip, but the reality is you need to modify the behaviour of the broken program even if you cannot modify its source code.

One way to do that would be a LD_PRELOAD module which intercepts the "read()" system call, in a way that invokes the actual "read()" system call and then exits when it encounters an end-of-file condition. (Ideally I'd intercept "getchar()" but that's usually a macro rather than a function call, so cannot be intercepted.)

Another way would be to run the code under a debugger, find where it goes into the infinite loop, and then patch the binary, either by modifying the executable file, or again, by applying a LD_PRELOAD module which replaces the errant function.

Or you could do as the previous answer suggests, and pipe the output into something which closes its input when the errant program outputs something that indicates it has reached the end of its input. (Note that this relies on it not trapping SIGPIPE, which is a fair assumption in this case.)

A more sophisticated version of this would be to share the input filedescriptor with another program which doesn't read from it but monitors to see whether it has reached its end. However that is a particularly tricky thing to do, especially if you might be dealing with pipes or sockets or devices.

Assuming your errant program is reading from stdin, wrap it with something like this:

  #!/bin/sh
  run-bad-program "$@" &
  pid=$!
  perl -MFcntl=:mode -e '
    @S = stat STDIN or die "Invalid input; $!\n";
    S_IFREG($S[2]) or die "Input is not a plain file\n";
    while (sysseek(STDIN,0,1) != $S[7]) { sleep 1 }
  '
  kill $pid
  wait

You really should fix the broken program, but if you can't, you can work around it by having the shell cat the file and pipe it to the program, then sleep for a second or two before exiting, thus closing the pipe and killing the program with SIGPIPE.

(cat file ; sleep 2) | stupid_program

"Now I'm wondering is there a way to check if the program goes into an infinite loop before all the input is read. For example if a program goes into an infinite loop, is the only way to stop the program."

We've known the answer to that question for nearly eighty years. The answer is no, there is not a way.

Thanks for giving a question that wasn't even close to your actual question:

"I'm trying to grade student's output. I just want to create a script so I can use for the future. Right now I have it working pretty well using a sleep timer but I want to make the script more robust without a timer"

Simple solution:

# how many seconds of CPU (not wall clock)
# should the student's program get?
# 10 seconds is generous for an intro class
# 60 seconds of CPU would be obscene
$ ulimit -t 10
$ run_student_program

# but since I don't have a student program

$ time dd if=/dev/zero of=/dev/null
Killed

real    0m9.998s
user    0m3.080s
sys     0m6.912s