netcat não funciona como esperado quando desanexado do console com nohup (Ubuntu / Debian 64bit)

Question

Estou tentando deixar o netcat em execução e fechar a sessão ssh (pare o daemon ssh). Mas, em seguida, sai antes de todos os dados serem gravados. Estou testando em um console não-ssh (local):

nohup nc -l -p 4000  | dd of=/home/myname/test.txt 2>/run/user/myname/stderr  1>/run/user/myname/stdout &

Para testar, fecho o console e em outro console eu despejo um arquivo:

dd if=/var/log/Xorg.0.log  |  nc localhost 4000

Nada é escrito em /home/myname/test.txt. Mas se eu remover o comando nohup, o test.txt contém todos os dados descartados. Como obter o funcionamento do netcat e desanexado do console?

    

Answer 1

OK, eu analisei: nohup executa o programa com a entrada padrão redirecionada de / dev / null. Portanto, o comando dd não obterá nada de nc e nc provavelmente falhará ao escrever & fechar-se na primeira tentativa de escrever. Então, primeiro precisamos criar um pipe nomeado para rotear o I / O via:

mkfifo my.pipe

execute dd com o arquivo de entrada do canal:

nohup dd if=./my.pipe of=./test.txt 2>/run/user/myname/stderr  1>/run/user/myname/stdout &

Agora podemos alimentar o pipe com dados da rede. Infelizmente, o netcat não faz isso, porque grava no stdout e isso não está disponível no nohup. Eu tenho que modificar a fonte do netcat. Para ser mais fácil (sem o compilador C), eu tomarei uma porta perl loose para o netcat, chamada também de "Poor's Netcat" ... Ok .. Eu reescrevi, adicionando um recurso de E / S de arquivo com o parâmetro -f . Então aqui está a fonte:

#! /usr/bin/perl
# Poor man's Netcat, the famous "TCP/IP swiss army knife"
# Only the basic functions are replicated : 
# - TCP only
# - only : "hostname port" or "-l" with "-p port" 
# but with *extended* functionality for direct file I/O by "-f file"

use strict;
use warnings;

use IO::Socket;
use Getopt::Long;

my $help='';
my $verbose;

my $local_port;
my $listen='';
$main::file_io='';

$SIG{CHLD} = 'IGNORE';

my $result = GetOptions(
        "help|h" => \$help,
        "verbose|v" => \$verbose,
    "local-port|p=i" => \$local_port,
    "listen|l" => \$listen,
        "file-io|f=s" => \$main::file_io,
       );
if ($help eq '' && $listen eq '' && (scalar @ARGV < 2) ) {$help = 1;}
if ($help) {
        print STDERR "Perl loose port of netcat(1)\n";
        print STDERR "usage : $0 [-p local_port] hostname port [-f file-for-input] (client)\n";
        print STDERR "   or : $0 -l -p local_port [-f file-for-output] (server)\n";
        exit(1);
}

# No need to close the socks as they are closed 
# when going out-of-scope
if ($listen) 
  { if (! $local_port) { die "You must specify the port to listen to in server mode\n";}
    # server mode
    my $l_sock = IO::Socket::INET->new(
        Proto => "tcp",
        LocalPort => $local_port,
        Listen => 1,
        Reuse => 1,
    ) or die "Could not create socket: $!";

    my $a_sock = $l_sock->accept(); 
    $l_sock->shutdown(SHUT_RDWR);
    read_from_network($a_sock); #server mode - calling read_data 
  } else 
     { #client mode
    if (scalar @ARGV < 2) { die "You must specify where to connect in client mode\n";}
    my ($remote_host, $remote_port) = @ARGV;
    my $c_sock = IO::Socket::INET->new(
        Proto => "tcp",
        LocalPort => $local_port,
        PeerAddr => $remote_host,
        PeerPort => $remote_port,
    ) or die "Could not create socket, reason: $!";
    write_to_network($c_sock);
    }

sub read_from_network 
 {
    my ($socket) = @_;  my $output_fh;
        if($main::file_io ne '') 
       {
             open($output_fh, ">", $main::file_io) or die "Can't open $main::file_io : $!";
           } else { $output_fh = *STDOUT;}
    close(STDIN);
    copy_data_mono($socket, $output_fh);# *STDOUT
        $socket->shutdown(SHUT_RD); 
        close($output_fh); close(STDOUT);
 }


sub write_to_network 
 {
    my ($socket) = @_;
        my $input_fh;
        if($main::file_io ne '') 
       {
             open($input_fh, "<", $main::file_io) or die "Can't open $main::file_io : $!";
           } else { $input_fh = *STDIN;}
    close(STDOUT);
    copy_data_mono($input_fh,$socket);
        $socket->shutdown(SHUT_WR); 
        close($input_fh);close(STDIN);
 }

sub copy_data_mono {
    my ($src, $dst) = @_;
    my $buf;
        print STDERR "copy_data_mono: output: $dst \n";
    while (my $read_len = sysread($src, $buf, 4096)) 
        {
        my $write_len = $read_len;
        while ($write_len) 
                {
         my $written_len = syswrite($dst, $buf);
         return unless $written_len; # $dst is closed
         $write_len -= $written_len;
        }
    }
}

É claro que o dd e o named pipe agora podem ser pulados, mas eu não verifiquei se este código funciona bem quando escrevo para partições físicas ... Agora todos os comandos são (assumindo que o código é salvo em netcat_g.pl):

mkfifo my.pipe #create a fifo, @ writable FS
nohup dd if=./my.pipe of=./test.txt & 
nohup ./netcat_g.pl -l -p 4000 -f ./my.pipe  &

e um pode fechar o console. A principal desvantagem é que outros comandos não podem ser encadeados a menos que suportem E / S de arquivo e novos pipes nomeados sejam criados.

    

Answer 2

Você precisa executar o comando em sua própria instância de shell.

nohup sh -c 'nc -l -p 4000  | dd of=/home/myname/test.txt 2>/run/user/myname/stderr  1>/run/user/myname/stdout' &

    

Answer 3

Tente adicionar uma opção extra '-d' ao netcat (para que não tente ler de stdin). Usando isso e estendendo a solução shell separada funcionou para mim mesmo depois de fechar o console e copiar mais de um MB de dados:

nohup sh -c 'nc -d -l 4000 | dd of=/home/user/dir/test.txt 
    2>/home/user/dir/stderr  
    1>/home/user/dir/stdout' &