├── perl-cgi-wrapper.pl
├── README.md
└── fastcgi-wrapper.pl


/perl-cgi-wrapper.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | 
 3 | # Original author: Denis S. Filimonov
 4 | # Patched by Lewin Bormann <lbo@spheniscida.de>
 5 | # Changes (quite much):
 6 | #   - Using STDIN as socket, for cooperation with Apache's mod_fcgid.
 7 | #   - No daemonization.
 8 | #   - No fork()s anymore, instead "inline" execution by first reading the
 9 | #     script and then executing it using eval().
10 | #     This should result in far superior performance with perl scripts.
11 | 
12 | use FCGI;
13 | use Socket;
14 | use POSIX qw(setsid);
15 | 
16 | require 'syscall.ph';
17 | 
18 | #&daemonize;
19 | 
20 | #this keeps the program alive or something after exec'ing perl scripts
21 | END() { } BEGIN() { }
22 | *CORE::GLOBAL::exit = sub { die "fakeexit\nrc=".shift()."\n"; };
23 | eval q{exit};
24 | if ($@) {
25 |     exit unless $@ =~ /^fakeexit/;
26 | };
27 | 
28 | &main;
29 | 
30 | sub daemonize() {
31 |     chdir '/'                 or die "Can't chdir to /: $!";
32 |     defined(my $pid = fork)   or die "Can't fork: $!";
33 |     exit if $pid;
34 |     setsid                    or die "Can't start a new session: $!";
35 |     umask 0;
36 | }
37 | 
38 | sub main {
39 |     $socket = STDIN; #FCGI::OpenSocket( "127.0.0.1:8999", 10 ); #use IP sockets
40 |     $request = FCGI::Request( \*STDIN, \*STDOUT, \*STDERR, \%req_params, $socket );
41 |     if ($request) { request_loop()};
42 |     FCGI::CloseSocket( $socket );
43 | }
44 | 
45 | sub request_loop {
46 |     while( $request->Accept() >= 0 ) {
47 | 
48 |         #running the cgi app
49 |         if ( (-x $req_params{SCRIPT_FILENAME}) &&  #can I execute this?
50 |             (-s $req_params{SCRIPT_FILENAME}) &&  #Is this file empty?
51 |             (-r $req_params{SCRIPT_FILENAME})     #can I read this file?
52 |         ){
53 |             foreach $key ( keys %req_params){
54 |                 $ENV{$key} = $req_params{$key};
55 |             }
56 |             my $script_content;
57 |             open(SCRIPT,"<",$req_params{SCRIPT_FILENAME});
58 |             {
59 |                 local $/;
60 |                 $script_content = <SCRIPT>;
61 |             }
62 |             close(SCRIPT);
63 |             my $result = eval($script_content);
64 | 
65 |             unless(defined($result)) {
66 |                 print("Content-type: text/plain\n\n");
67 |                 print "Error: CGI app returned no output - ";
68 |                 print "Executing $req_params{SCRIPT_FILENAME} failed !\n";
69 |                 next;
70 |             }
71 |         }
72 |         else {
73 |             print("Content-type: text/plain\n\n");
74 |             print "Error: No such CGI app - $req_params{SCRIPT_FILENAME} may not ";
75 |             print "exist or is not executable by this process.\n";
76 |         }
77 | 
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # FastCGI wrappers
  2 | 
  3 | (The original file was taken from the links described in http://nginxlibrary.com/perl-fastcgi/, that is
  4 | http://nginxlibrary.com/downloads/perl-fcgi/fastcgi-wrapper. It is attributed to Denis S. Filimonov).
  5 | 
  6 | These scripts are intended for use with Apache's mod\_fcgid. If the daemonizing code is uncommented
  7 | and the socket changed to a TCP/IP one, they may be used with nginx as well.
  8 | 
  9 | Feel free to use these scripts. Please consider giving changes back to the community.
 10 | 
 11 | ## `fastcgi-wrapper.pl`
 12 | 
 13 | This wrapper may execute virtually anything that uses STDIN and STDOUT. Originally written for
 14 | Perl scripts, it should only be used for anything *but* Perl scripts, e.g. ELF binaries, Python CGI
 15 | scripts etc.
 16 | 
 17 | This script works a bit like mod\_cgid in that it still forks the application process.
 18 | 
 19 | ## `perl-cgi-wrapper.pl`
 20 | 
 21 | This script is based on the same fastcgi-wrapper script as the one above, but it's adapted
 22 | for best Perl performance. It doesn't use the usual fork-exec-interpret mechanism (like CGI does).
 23 | It rather works like the PHP binaries compiled for FastCGI use (php-cgi, for example): It accepts
 24 | FastCGI requests, reads the file described in the `$ENV{SCRIPT_FILENAME}` variable and `eval()`uates
 25 | it. This mechanism does not involve any forking (as already mentioned), making it quite cheap.
 26 | 
 27 | ## systemd configuration
 28 | 
 29 | For `perl-cgi-wrapper`:
 30 | 
 31 | ```ini
 32 | # fcgi-pl.service
 33 | 
 34 | [Unit]
 35 | Description=Perl CGI scripts for <user>
 36 | 
 37 | [Service]
 38 | Type=exec
 39 | User=<user>
 40 | StandardInput=socket
 41 | ExecStart=/usr/bin/perl /path/to/fastcgi-wrappers/perl-cgi-wrapper.pl
 42 | ExecStop=/bin/kill -TERM $MAINPID
 43 | 
 44 | [Install]
 45 | WantedBy=network.target
 46 | ```
 47 | 
 48 | and a socket unit,
 49 | 
 50 | ```ini
 51 | Description = "FCGI socket for fcgi-pl (%i)"
 52 | 
 53 | [Socket]
 54 | ListenStream = 127.0.0.1:8999
 55 | Accept = false
 56 | 
 57 | [Install]
 58 | WantedBy = sockets.target fcgi-pl.service
 59 | ```
 60 | 
 61 | Note that for this to work, use the standard way of `STDIN` in the `main()`
 62 | function. Start the script using:
 63 | 
 64 | ```bash
 65 | sudo systemctl start fcgi-pl.service
 66 | ```
 67 | 
 68 | ## `nginx` configuration
 69 | 
 70 | If you use IP sockets with the above configuration:
 71 | 
 72 | ```nginx
 73 | location /util/ {
 74 |         fastcgi_pass   127.0.0.1:8999;
 75 |         fastcgi_index  index.pl;
 76 |         fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
 77 |         include        fastcgi_params;
 78 | }
 79 | ```
 80 | 
 81 | You can alternatively use UNIX domain sockets.
 82 | 
 83 | ## `mod_fcgid` configuration
 84 | 
 85 | A working configuration could look like the following example:
 86 | 
 87 | ```
 88 | <IfModule mod_fcgid.c>
 89 |     FcgidConnectTimeout 20
 90 |     FcgidMaxProcesses 30
 91 |     FcgidMaxRequestsPerProcess 10000
 92 |     FcgidMaxProcessesPerClass 3
 93 |     FcgidMaxRequestLen 20000000
 94 | 
 95 |     <FilesMatch "\.fcgi">
 96 |     AddHandler fcgid-script .fcgi
 97 |     Options +ExecCGI
 98 |     </FilesMatch>
 99 | 
100 |     <FilesMatch "\.pl">
101 |     AddHandler fcgid-script .pl
102 |     Options +ExecCGI
103 |     FcgidWrapper /usr/local/bin/perl-cgi-wrapper.pl .pl
104 |     </FilesMatch>
105 | 
106 |     # C/C++/Haskell binaries
107 |     <FilesMatch "\.elf">
108 |     AddHandler fcgid-script .elf
109 |     Options +ExecCGI
110 |     FcgidWrapper /usr/local/bin/fastcgi-wrapper.pl .elf
111 |     </FilesMatch>
112 | 
113 | </IfModule>
114 | ```
115 | 
116 | If you don't use suexec or any other modules interfering with mod\_fcgid, this is all
117 | the configuration you need.
118 | 
119 | 


--------------------------------------------------------------------------------
/fastcgi-wrapper.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | 
  3 | # Original author: Denis S. Filimonov
  4 | # Patched by Lewin Bormann <lbo@spheniscida.de>
  5 | # Changes:
  6 | #   - Using explicit pipes, none of Perl's open() black magic
  7 | #   - Using STDIN as socket. This is necessary for cooperation with Apache's mod_fcgid.
  8 | #   -> Also no daemonization.
  9 | 
 10 | use FCGI;
 11 | use Socket;
 12 | use POSIX qw(setsid);
 13 | 
 14 | require 'syscall.ph';
 15 | 
 16 | #&daemonize;
 17 | 
 18 | #this keeps the program alive or something after exec'ing perl scripts
 19 | END() { } BEGIN() { }
 20 | *CORE::GLOBAL::exit = sub { die "fakeexit\nrc=".shift()."\n"; };
 21 | eval q{exit};
 22 | if ($@) {
 23 |     exit unless $@ =~ /^fakeexit/;
 24 | };
 25 | 
 26 | &main;
 27 | 
 28 | sub daemonize() {
 29 |     chdir '/'                 or die "Can't chdir to /: $!";
 30 |     defined(my $pid = fork)   or die "Can't fork: $!";
 31 |     exit if $pid;
 32 |     setsid                    or die "Can't start a new session: $!";
 33 |     umask 0;
 34 | }
 35 | 
 36 | sub main {
 37 |     $socket = STDIN; #FCGI::OpenSocket( "127.0.0.1:8999", 10 ); #use IP sockets
 38 |     $request = FCGI::Request( \*STDIN, \*STDOUT, \*STDERR, \%req_params, $socket );
 39 |     if ($request) { request_loop()};
 40 |     FCGI::CloseSocket( $socket );
 41 | }
 42 | 
 43 | sub request_loop {
 44 |     while( $request->Accept() >= 0 ) {
 45 | 
 46 |         #processing any STDIN input from WebServer (for CGI-POST actions)
 47 |         $stdin_passthrough ='';
 48 |         $req_len = 0 + $req_params{'CONTENT_LENGTH'};
 49 |         if (($req_params{'REQUEST_METHOD'} eq 'POST') && ($req_len != 0) ){
 50 |             my $bytes_read = 0;
 51 |             while ($bytes_read < $req_len) {
 52 |                 my $data = '';
 53 |                 my $bytes = read(STDIN, $data, ($req_len - $bytes_read));
 54 |                 last if ($bytes == 0 || !defined($bytes));
 55 |                 $stdin_passthrough .= $data;
 56 |                 $bytes_read += $bytes;
 57 |             }
 58 |         }
 59 | 
 60 | 
 61 |         #running the cgi app
 62 |         if ( (-x $req_params{SCRIPT_FILENAME}) &&  #can I execute this?
 63 |             (-s $req_params{SCRIPT_FILENAME}) &&  #Is this file empty?
 64 |             (-r $req_params{SCRIPT_FILENAME})     #can I read this file?
 65 |         ){
 66 |             pipe(CHILD_RD, PARENT_WR);
 67 |             pipe(PARENT_RD, CHILD_WR);
 68 |             pipe(PARENT_ERR_RD, CHILD_ERR_WR);
 69 | 
 70 |             my $pid = fork();
 71 |             unless(defined($pid)) {
 72 |                 print("Content-type: text/plain\r\n\r\n");
 73 |                 print "Error: CGI app returned no output - ";
 74 |                 print "Executing $req_params{SCRIPT_FILENAME} failed !\n";
 75 |                 next;
 76 |             }
 77 |             if ($pid > 0) {
 78 |                 # Avoid waiting for eof on pipe!!!
 79 |                 close(CHILD_RD);
 80 |                 close(CHILD_WR);
 81 |                 close(CHILD_ERR_WR);
 82 | 
 83 |                 print PARENT_WR $stdin_passthrough;
 84 |                 close(PARENT_WR);
 85 | 
 86 |                 while(my $s = <PARENT_RD>) { print $s; }
 87 |                 close(PARENT_RD);
 88 |                 while(my $s = <PARENT_ERR_RD>) { print STDERR $s; }
 89 |                 close(PARENT_ERR_RD);
 90 | 
 91 |                 waitpid($pid, 0);
 92 |             } else {
 93 |                 foreach $key ( keys %req_params){
 94 |                     $ENV{$key} = $req_params{$key};
 95 |                 }
 96 |                 # cd to the script's local directory
 97 |                 if ($req_params{SCRIPT_FILENAME} =~ /^(.*)\/[^\/]+$/) {
 98 |                     chdir $1;
 99 |                 }
100 | 
101 |                 # Avoid waiting for eof on pipe!!!
102 |                 close(PARENT_RD);
103 |                 close(PARENT_WR);
104 |                 close(PARENT_ERR_RD);
105 | 
106 |                 syscall(&SYS_dup2, fileno(CHILD_RD), 0);
107 |                 syscall(&SYS_dup2, fileno(CHILD_WR), 1);
108 |                 syscall(&SYS_dup2, fileno(CHILD_ERR_WR), 2);
109 |                 exec($req_params{SCRIPT_FILENAME});
110 |                 die("exec failed");
111 |             }
112 |         }
113 |         else {
114 |             print("Content-type: text/plain\r\n\r\n");
115 |             print "Error: No such CGI app - $req_params{SCRIPT_FILENAME} may not ";
116 |             print "exist or is not executable by this process.\n";
117 |         }
118 | 
119 |     }
120 | }
121 | 


--------------------------------------------------------------------------------