All perguntas(unix)

Considere os dois comandos abaixo que estão programados para serem executados ao mesmo tempo (via Autosys, exatamente às 8h).

O findcomando removeu arquivos com mais de 15 dias, mas saiu com status diferente de zero com:

???find missing /app/source/a.txt no such file or directory

No entanto, a.txttem um dia de idade. Por que o findcomando está validando um arquivo recente que estava presente durante sua execução, mas foi movido para outra pasta ao mesmo tempo?

find /app/source -type f -name -mtime +15 rm -f {} \;

mv /app/source/a.txt /app/backup/

Tenho um arquivo de texto bem básico em uma máquina Linux que contém coisas como capítulos, diálogos e referências.

É assim que parece

Chapter: 1 One: Birds and Trees

Birds are beautiful and trees are amazing and
they are dependent on each other. Birds most of the time
choose to make their nests on trees since trees provide more
stability. One day the bird sat on a tree and said;

Bird: Oh my I'm so tired from all the flying, I should take a rest
Tree: Mr Bird, you seem tired, perhaps you should take some rest, and
here are some fruits to quench your thirst.
Bird: Oh thank you very much!

Reference:               Chapter 1: birds and trees

Chapter: 2 Two: Trees and Fruits

Fruits are very delicious to eat and they are mostly found
in trees. Fruits contain essential vitamins, minerals and loads
of good fibers.

Reference:               Chapter 2: trees and fruits

Este é o conteúdo do arquivo txt. Agora, digamos que eu estava procurando por quench, eu estava pensando que começaria do número do Capítulo até a Referência. Então eu tentei com grep;

$ grep -A 5 -B 5 'quench' file.txt

No entanto, isso não produz a saída desejada. Eu esperava algo assim;

Chapter: 1 One: Birds and Trees

Birds are beautiful and trees are amazing and
they are dependent on each other. Birds most of the time
choose to make their nests on trees since trees provide more
stability. One day the bird sat on a tree and said;

Bird: Oh my I'm so tired from all the flying, I should take a rest
Tree: Mr Bird, you seem tired, perhaps you should take some rest, and
here are some fruits to quench your thirst.
Bird: Oh thank you very much!

Reference:               Chapter 1: birds and trees

E também, pesquisar pela palavra "vitamina" retornaria;

Chapter: 2 Two: Trees and Fruits

Fruits are very delicious to eat and they are mostly found
in trees. Fruits contain essential vitamins, minerals and loads
of good fibers.

Reference:               Chapter 2: trees and fruits

Eu queria saber se isso seria possível através do sed ou awk.

PS: Cada nova linha é uma nova linha de verdade

Eu estava olhando para CVE-2024-53259 , onde um invasor pode injetar mensagem ICMP Fragmentation Needed em um host com conexão QUIC usando a biblioteca quic-go. A causa é a configuração IP_PMTUDISC_DOda opção socket do quic-go ao sondar seu caminho mtu.

O que eu realmente não entendo é que, embora a página CVE diga basicamente que o kernel recebe o pacote ICMP do invasor e atualiza o caminho mtu, parece que o kernel do Linux manipula o pacote separadamente por dst ip e src ip para erro ICMP recebido, construindo 'chave de fluxo' (estou olhando para a função ipv4_sk_update_pmtu ):

void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
{
    const struct iphdr *iph = (const struct iphdr *)skb->data;
    struct flowi4 fl4;
    struct rtable *rt;
    struct dst_entry *odst = NULL;
    bool new = false;
    struct net *net = sock_net(sk);

    bh_lock_sock(sk);

    if (!ip_sk_accept_pmtu(sk))
        goto out;

    odst = sk_dst_get(sk);

    if (sock_owned_by_user(sk) || !odst) {
        __ipv4_sk_update_pmtu(skb, sk, mtu);
        goto out;
    }
    // this function calls flowi4_init_output inside, which takes src/dst addr as arguments
    __build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);

    rt = dst_rtable(odst);
    if (odst->obsolete && !odst->ops->check(odst, 0)) {
        rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
        if (IS_ERR(rt))
            goto out;

        new = true;
    }
    ...
}

Se os pacotes forem manipulados com base em seus endereços src/dst, o pacote do invasor não deve interromper a conexão existente porque o pacote tem um endereço IP de origem diferente. Por que esse tipo de ataque está disponível?

desde já, obrigado

Ambiente

Este é um servidor vps Ubuntu 22.04.5. O Wireguard usa tuntap em vez do kernel mod.

Roteiro

/etc/wireguard/gw0.shpode iniciar o wireguard corretamente se executado a partir da linha de comando:

# cleanup
echo "$(date) - cleanup"
/usr/sbin/ip link del gw0 2>&1
/usr/sbin/iptables -t nat -D POSTROUTING -s 10.0.0.0/24 -o venet0 -j MASQUERADE 2>&1

# setup
echo "$(date) - setup"
#/usr/sbin/ip tuntap add dev gw0 mode tun
/usr/bin/wireguard gw0 2>&1
/usr/sbin/ip a add 10.0.0.1/24 dev gw0
/usr/bin/wg set gw0 listen-port 12345
/usr/bin/wg set gw0 private-key /etc/wireguard/gw0.key
# wg0
/usr/bin/wg set gw0 peer <wg0 key> allowed-ips 10.0.0.2/32
# wg1
/usr/bin/wg set gw0 peer <wg1 key> allowed-ips 10.0.0.3/32

# start
echo "$(date) - start"
/usr/sbin/ip link set gw0 up 2>&1
/usr/sbin/iptables -t nat -A POSTROUTING -s 10.0.0.0/24 -o venet0 -j MASQUERADE 2>&1

# end
echo "$(date) - end"

exit 0

Saída:

# /etc/wireguard/gw0.sh
Thu Dec  5 10:03:32 EST 2024 - cleanup
Cannot find device "gw0"
Thu Dec  5 10:03:32 EST 2024 - setup
┌──────────────────────────────────────────────────────┐
│                                                      │
│   Running wireguard-go is not required because this  │
│   kernel has first class support for WireGuard. For  │
│   information on installing the kernel module,       │
│   please visit:                                      │
│         https://www.wireguard.com/install/           │
│                                                      │
└──────────────────────────────────────────────────────┘
Thu Dec  5 10:03:32 EST 2024 - start
Thu Dec  5 10:03:33 EST 2024 - end

Serviço Systemd

/etc/systemd/system/gw0.service:

[Unit]
Description = Start Wireguard gw0
After = network-online.target
Wants = network-online.target
[Service]
Type = oneshot
ExecStart = /usr/bin/bash -c "/etc/wireguard/gw0.sh >> /tmp/gw0.log"

[Install]
WantedBy=multi-user.target

Iniciar o serviço sempre resultará em erro de tempo limite e nenhum processo wireguard:

# systemctl start gw0.service
Job for gw0.service failed because a timeout was exceeded.
See "systemctl status gw0.service" and "journalctl -xeu gw0.service" for details.

# systemctl status gw0.service
× gw0.service - Start Wireguard gw0
     Loaded: loaded (/etc/systemd/system/gw0.service; disabled; vendor preset: enabled)
     Active: failed (Result: timeout) since Thu 2024-12-05 10:12:07 EST; 34s ago
    Process: 95515 ExecStart=/usr/bin/bash -c /etc/wireguard/gw0.sh >> /tmp/gw0.log (code=exited, status=0/SUCCESS)
   Main PID: 95515 (code=exited, status=0/SUCCESS)

Dec 05 10:10:37 mybox systemd[1]: Starting Start Wireguard gw0...
Dec 05 10:12:07 mybox systemd[1]: gw0.service: State 'stop-sigterm' timed out. Killing.
Dec 05 10:12:07 mybox systemd[1]: gw0.service: Failed with result 'timeout'.
Dec 05 10:12:07 mybox systemd[1]: Failed to start Start Wireguard gw0.

# journalctl -xeu gw0.service
Dec 05 10:10:37 mybox systemd[1]: Starting Start Wireguard gw0...
░░ Subject: A start job for unit gw0.service has begun execution
░░ Defined-By: systemd
░░ Support: http://www.ubuntu.com/support
░░
░░ A start job for unit gw0.service has begun execution.
░░
░░ The job identifier is 2611.
Dec 05 10:12:07 mybox systemd[1]: gw0.service: State 'stop-sigterm' timed out. Killing.
Dec 05 10:12:07 mybox systemd[1]: gw0.service: Failed with result 'timeout'.
░░ Subject: Unit failed
░░ Defined-By: systemd
░░ Support: http://www.ubuntu.com/support
░░
░░ The unit gw0.service has entered the 'failed' state with result 'timeout'.
Dec 05 10:12:07 mybox systemd[1]: Failed to start Start Wireguard gw0.
░░ Subject: A start job for unit gw0.service has failed
░░ Defined-By: systemd
░░ Support: http://www.ubuntu.com/support
░░
░░ A start job for unit gw0.service has finished with a failure.
░░
░░ The job identifier is 2611 and the job result is failed.

No entanto, /tmp/gw0.logmostra o script concluído:

Thu Dec  5 10:10:37 EST 2024 - cleanup
Thu Dec  5 10:10:37 EST 2024 - setup
┌──────────────────────────────────────────────────────┐
│                                                      │
│   Running wireguard-go is not required because this  │
│   kernel has first class support for WireGuard. For  │
│   information on installing the kernel module,       │
│   please visit:                                      │
│         https://www.wireguard.com/install/           │
│                                                      │
└──────────────────────────────────────────────────────┘
Thu Dec  5 10:10:37 EST 2024 - start
Thu Dec  5 10:10:37 EST 2024 - end

Pergunta

Alguém tem ideia de como fazer gw0.servicefuncionar?

No meu servidor Ubuntu, acho muito útil que netstat -tulpntambém mostre o nome de usuário conectado sshd(aparentemente, essa impressão de nome de usuário é específica para sshd) - infelizmente, essa impressão também é truncada:

$ sudo netstat -tulpn | grep 'PID\|user1'
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:12345           0.0.0.0:*               LISTEN      1620557/sshd: user1
tcp6       0      0 :::12345                :::*                    LISTEN      1620557/sshd: user1

No exemplo acima, o nome de usuário completo é user1234, mas devido ao truncamento, só consigo ler user1.

Ainda mais infelizmente, descobri que esse truncamento está codificado no netcatlimite de largura da linha de saída do Netstat :

Infelizmente, a largura da coluna PID/Nome do programa no netstat é codificada com hardcode, #define PROGNAME_WIDTH 20então não há como obter a saída completa do netstat diretamente. Além disso, você acaba com 19 caracteres e um espaço no final.

A mesma resposta também recomenda:

No Linux de hoje, pode-se usar sudo ss -natppara obter as informações completas formatadas de forma um pouco diferente, mas com o nome completo:

... infelizmente, ssnão imprime o nome de usuário do usuário conectado sshdcomo netstatfaz:

$ sudo ss -tulpn | grep user1
$

$ sudo ss -tulpn | grep 12345
tcp     LISTEN   0        128              0.0.0.0:12345          0.0.0.0:*      users:(("sshd",pid=1620557,fd=10))

tcp     LISTEN   0        128                 [::]:12345             [::]:*      users:(("sshd",pid=1620557,fd=11))

Então, como posso obter uma saída idêntica ou semelhante à saída de netstat -tulpn, mas que imprima os nomes de usuário completos conectados a sshd?

Minha versão do netstat é:

$ netstat --version
net-tools 2.10-alpha
Fred Baumgarten, Alan Cox, Bernd Eckenfels, Phil Blundell, Tuan Hoang, Brian Micek and others
+NEW_ADDRT +RTF_IRTT +RTF_REJECT +FW_MASQUERADE +I18N +SELINUX
AF: (inet) +UNIX +INET +INET6 +IPX +AX25 +NETROM +X25 +ATALK +ECONET +ROSE -BLUETOOTH
HW:  +ETHER +ARC +SLIP +PPP +TUNNEL -TR +AX25 +NETROM +X25 +FR +ROSE +ASH +SIT +FDDI +HIPPI +HDLC/LAPB +EUI64

Frequentemente, uso grep para procurar algum texto em várias pastas, por exemplo

grep --include='*.csv' -nRHI --color=always 'pattern' Folder1 Folder2  

Gostaria de criar um alias algo como

alias MyGrep="grep --include='*.csv' -nRHI --color=always Folder1 Folder2"

para que da próxima vez que eu tiver algo para pesquisar, eu só precise

MyGrep 'pattern'

Entretanto, isso não funciona, pois o padrão de pesquisa precisa vir antes da lista de pastas.

Existe alguma solução alternativa para o alias?

ps. Posso usar uma função em vez disso, por exemplo

function MyGrep() { grep --include='*.csv' -nRHI --color=always "$@" Folder1 Folder2;}

então eu posso correr

MyGrep pattern

Mas estou curioso para saber se há uma solução alternativa via alias.

Estou usando um script para transcodificar um monte de filmes usando a versão de linha de comando do HandBrake. Estou usando uma versão modificada do script aqui:

https://gist.github.com/ralphcrisostomo/56fc395b1646bd55aeeb2eb442043887

O problema que tenho é que a transcodificação trava de forma não reproduzível em um pequeno subconjunto de filmes. Isso é acompanhado por um erro muito específico no stderr.

O que eu gostaria de fazer é 1) seguir o stdout (mas não o stderr) na tela, 2) monitorar o stderr para a condição de erro e 3) se a condição de erro for satisfeita, encerrar o processo do HandBrake, registrar o arquivo problemático e passar para o próximo.

Atualmente, o comando de transcodificação se parece com isto:

echo "" | HandBrakeCLI -i "$ITEM" -o "$OUTPUT" --preset="$PRESET" $OPTS 2> /dev/null

que satisfaz 1).

Seguindo os conselhos aqui:

Como executar grep no fluxo de erro padrão (stderr)?

Posso executar grep com sucesso no fluxo de erros para a palavra relevante, por exemplo

echo "" | HandBrakeCLI -i "$ITEM" -o "$OUTPUT" --preset="$PRESET" 2> >(grep -i error)

ou

echo "" | HandBrakeCLI -i "$ITEM" -o "$OUTPUT" --preset="$PRESET" 3>&2 2>&1 1>&3- | grep -i "error"

No entanto, tudo isso fará com que ele imprima a linha relevante do stderr na tela. Não está claro para mim como posso usar isso para executar comandos específicos, por exemplo, kill HandBrakeCLI ; echo $ITEM >> err.log

Tentei usar grep -q para testar se a correspondência foi bem-sucedida assim:

echo "" | HandBrakeCLI -i "$ITEM" -o "$OUTPUT" --preset="$PRESET" $OPTS 3>&2 2>&1 1>&3- | grep -q "error" && echo "error found" ; echo $ITEM >> failed.txt

Mas o script simplesmente sai ao encontrar o erro, sem passar para o próximo item do loop.

Qualquer ajuda será bem-vinda!

atualizado para responder à pergunta de Terdon:

Também fiquei curioso sobre o echo inicial "" | na invocação do HandBrake. Estava no script original referenciado no topo da consulta, mas também não está claro para mim por que é necessário. Estou executando isso no MacOS. O script completo é

#!/bin/bash

SOURCE=$1
ENCODER=$2
OPTS=$3

TOTAL=$(find "$SOURCE" \! -name ".*" -type f | wc -l)
CURR=0
DESTINATION="PROCESSED"

ENCODER=${ENCODER:="hw"}

# Create directorys
[[ -d $DESTINATION ]] || mkdir -p $DESTINATION

while IFS= read -d '' -r ITEM
do
  RES=`ffprobe -v error -select_streams v:0 -show_entries stream=width,height -of default=nw=1 "$ITEM" | grep 'height*' | cut -c 8-`
  FILE=${ITEM##*/}
  EXT=${ITEM##*.}
  EXT=$(echo $EXT | tr "[:upper:]" "[:lower:]")
  OUTPUT="$DESTINATION/${FILE%.*}.$EXT"

  # Get the right preset
  if [[ "$RES" == "2160" ]] && [[ "$ENCODER" == "hw" ]]
  then
    PRESET="H.265 Apple VideoToolbox 2160p 4K"
  elif [[ "$RES" == "2160" ]] && [[ "$ENCODER" == "sw" ]]
    then
      PRESET="Fast 2160p60 4K HEVC"
  elif [[ "$RES" != "2160" ]] && [[ "$ENCODER" == "hw" ]]
    then
      PRESET="H.265 Apple VideoToolbox 1080p"
  elif [[ "$RES" != "2160" ]] && [[ "$ENCODER" == "sw" ]]
    then
      PRESET="Fast 1080p30"
    fi
  
  echo "Processing" $FILE "using preset" $PRESET
  echo "" | HandBrakeCLI -i "$ITEM" -o "$OUTPUT" --preset="$PRESET" $OPTS 2> /dev/null

  CURR=$((CURR + 1))
  echo "done" $CURR "of"$TOTAL
    
done< <(find "$SOURCE" \( -iname '*.mp4' -or -iname '*.mov'  -or -iname '*.MP4' -or -iname '*.MOV' \) -print0)

Atualização 061224

Seguindo a sugestão de markp-fuso, modifiquei a linha que chama o HandBrake da seguinte forma:

echo "" | HandBrakeCLI -i "$ITEM" -o "$OUTPUT" --preset="$PRESET" 2> >(grep -i error && { pkill HandBrakeCLI ; echo $ITEM >> err.log; })

Isso imprime o erro relevante no stdout quando encontrado, mas só executa a segunda parte (por exemplo, matando o processo e registrando o resultado) quando a codificação atual é concluída. Se a codificação simplesmente travar e continuar gerando o mesmo erro, a segunda parte do comando não será executada. Se eu alterar a linha para:

echo "" | HandBrakeCLI -i "$ITEM" -o "$OUTPUT" --preset="$PRESET" 2> >(grep -q error && { pkill HandBrakeCLI ; echo $ITEM >> err.log; })

Então o comando grep sai ao encontrar o erro, o script inteiro sai sem processar mais nenhum item no loop. Estranhamente, porém, se eu matar o processo HandBrake de outro shell quando o encode trava, ele então moverá corretamente para o próximo item.

Tenho um problema em volumes NFS que apareceu há dois dias. O problema parece estar relacionado a operações de gravação, com o seguinte levando mais tempo (10s de segundos) para ser concluído:

• sed -i
• rm
• Editar e salvar emvim

Com strace, eu pude ver que sed -ipode travar em rename("./sedXXXXX", ...), ou que close(4)dá -1 EIO(erro de entrada/saída). Além disso, para cada sed -ichamada (mesmo quando funciona), uma linha NFS: nfs4_reclaim_open_state: unhandled error -13é reportada em dmesg.

Por fim, o longo tempo de espera não ocorre sempre, e os comandos serão concluídos "aleatoriamente" sem problemas.

O sistema está no CentOS 7.4, com kernel:

$ uname -r
3.10.0-693.5.2.el7.x86_64

Você tem alguma ideia do que pode estar errado ou como posso rastrear o problema com mais precisão?

Desde já, obrigado !

EDITAR Seguindo o conselho do grawity , a configuração rpcdebug -m nfs -s allleva a muito mais impressão na dmesgsaída, em particular:

$ dmesg | grep -i error | grep -i nfs
nfs41_handle_sequence_flag_errors: "IP_OF_NFS_SERVER" (client ID 22b1f26668d8b0fc) flags=0x00000040
nfs41_sequence_process: Error 0 free the slot

Não sei se pode ser relevante...

Tentando montar um compartilhamento do Windows de um contêiner UBI9-minimal. Descobri que cifs não está contido na imagem. Tentar instalar 'cifs-utils' via microdnf parece indicar que ele não existe. Fazer uma repoquery microdnf cifs (ou *cifs*) não produz resultados.

Como instalar o cifs-utils no UBI9-minimal para montar um compartilhamento do Windows?

Tenho dois arquivos, eth0-statice eth0-dhcp, para meu NetworkManager definido e quero que o NetworkManager use um desses arquivos como padrão. A seleção de arquivo depende se o DHCP está habilitado ou não. Como posso dizer ao NetworkManager para usar um desses arquivos em vez de criar Wired connection 1? Ou faz mais sentido renomear os arquivos existentes?