z.h.'s questions

Ao gerar pares de chaves usando ssh-keygen, pode-se especificar o tipo de assinatura desejado por -t, como ssh-keygen -t ssh-rsa. Eu me pergunto, o tipo de assinatura de uma chave privada ssh é imutável , uma vez que os pares de chaves são criados?

Se for mutável, qual ferramenta posso utilizar para alterar o tipo de assinatura? e como?

Estou fazendo esta pergunta porque uma das minhas chaves antigas usa ssh-rsao tipo de assinatura e agora o ssh-rsaalgoritmo de assinatura ficou obsoleto.

Eu entendo que o espaço de endereço usado de PCs de 64 bits é [0,2^48), mas posso usar mmap para mapear um arquivo para um endereço acima de 2 ⁴⁸ ?

Eu escrevi o seguinte código, mas descobri que o endereço mapeado ainda estava dentro [0,2^48).

int
main(void) {
    const char* name = "/tmp/file";

    int fd = open(name, O_RDONLY);
    if (fd < 0) {
        perror("open");
        exit(-1);
    }

    int pageSize = sysconf(_SC_PAGE_SIZE);
    void* targetAddr = (void*)(0UL - pageSize);

    char* str = mmap(targetAddr, pageSize, PROT_READ, MAP_SHARED, fd, 0);
    if (str == MAP_FAILED) {
        perror("mmap");
        exit(-1);
    }

    printf("addr: %p\n", str);

    return 0;
}

Saída de amostra:addr: 0x7fc761f6f000

É possível mapear algum arquivo para o endereço acima de 2 ⁴⁸ com mmap?

Se não, como posso usar o bit48-bit63 "não usado"?

Estou curioso para saber como usar os bits mais altos do endereço.

SO: Ubuntu16.04

Tamanho da memória: 4 GB

Eu escrevi um Makefile e descobri que ao executar o makecomando, um inesperado rmfoi executado, depois que todos os comandos no Mmakefile foram feitos. Mas eu não escrevi o rmcomando no Makefile.

run-%: d/%.out
    $<

d/%.out: d/%.c
    gcc -o $(subst .c,.out,$<) $<

Saída de execução make run-a:

gcc -o d/a.out d/a.c
d/a.out
rm d/a.out

Observe o trailing rm d/a.out, que eu não escrevi.

Em que circunstância o rmcomando automático será adicionado?

Eu tenho um monte de .carquivo de origem de teste no diretório tests/. Agora eu quero compilar e vinculá-los respectivamente e produzir o executável *.outem tests/. Então eu escrevi um makefile, que não funcionou.

# ...
TestDir := tests
TestSourceFile := $(shell sh -c "ls tests/*.c")
TestTargetFile := $(subst .c,.out,$(TestSourceFile))

TestFrame := testframe.o

TestNeededObjectFile := $(TestFrame) \
    + util.o \
    + tokennames.o \
    + lex.yy.o \
    + hex.o \

.PHONY: test-%

test-%: $(TestDir)/%.out
    $^

.PHONY: test

test: $(TestTargetFile)
    @for t in $(TestTargetFile); do \
        $$t ; \
    done

$(TestDir)/%.out: $(TestDir)/%.o $(TestNeededObjectFile)
    gcc -o $@ $^

%.o : %.c
    gcc -c $(CFLAGS) $^

clean:
    rm -rf *.o lextest *.yy.? *.tab.? *.output $(TokenNameFile) \
        $(TestDir)/*.out

Quando executo make test-add( add.cis in tests/), espero ver add.outin, tests/mas ocorre um erro:

> make test-add
make: *** No rule to make target 'tests/add.out', needed by 'test-add'.  Stop.

Eu quero saber como escrever este makefile corretamente e porque este makefile está errado.

Estou depurando com gdb e preciso definir alguns comandos auxiliares. Basicamente, quero que meu comando personalizado funcione de maneira diferente, dependendo do número de argumentos fornecidos.

Então tenho que testar se $arg*é dado, veja o código abaixo:

define pgdir

    set $pgdir = $arg0

    if ($arg1) {
        // show the corresponding PDE
    } else {
        // show the whole page directory
    }

end

É possível testar se uma variável é nula?

Eu passo 1(stdout)/ 2(stderr) para a readchamada do sistema, mas ainda funciona bem. Então eu passo 0(stdin) para a writechamada do sistema e descubro que funciona também!

int main(int argc, char** argv){
    char buf[1024] = "abcdefghi\n";

    write(0, buf, 10);

    char readbuf[1024] = {0};
    // read(1, readbuf, 10); works too
    read(2, readbuf, 10);
    write(2, readbuf, 10);

    return 0;
}

resultado:

abcdefghi
hey stdin  <-- I input this
hey stdin

Confuso, pensei que deveria ser um erro.

Experiência:

Então eu tentei redirecionar fd 2.

$ ./a.out 2>/dev/null

desta vez, tanto a leitura quanto a segunda gravação não são 'visíveis'. A saída é

abcdefgi

Então o stderr pode ser usado para leitura?

Eu então fecho o stdout & stderr e faço duas cópias do stdin:

int main(int argc, char** argv){
    char buf[1024] = "abcdefghi\n";

    close(1);
    close(2);

    dup2(0, 1);
    dup2(0, 2);

    write(0, buf, 10);

    char redbuf[1024] = {0};
    read(2, redbuf, 10);
    write(2, redbuf, 10);

    return 0;
}

Novamente funciona.

resultado:

abcdefghi
hey stdin  <-- I input this
hey stdin

Então stdin pode ser usado para escrever?

Preciso de uma explicação aqui.

Pergunta

Eu quero saber:

Por que stdout/stderr pode ser usado para leitura?

Por que stdin pode ser usado para gravação?

Os três fluxos ( stdin,stdout,stderr ) são internamente um fluxo?

Se não, por que estou obtendo esse resultado?

Estou tentando encontrar o .desktoparquivo para qtcreator, então escrevo isso:

$ for p in ${XDG_DATA_DIRS//:/ }; do
    grep -rni 'qtcreator' $p;
done

E aqui estão as linhas mais relevantes:

/usr/share/app-install/desktop/qtcreator-plugin-ubuntu:ubuntusdk.desktop:2:X-AppInstall-Package=qtcreator-plugin-ubuntu
/usr/share/app-install/desktop/qtcreator-plugin-ubuntu:ubuntusdk.desktop:6:Exec=qtcreator %F
/usr/share/app-install/desktop/qtcreator-plugin-ubuntu:ubuntusdk.desktop:7:Icon=ubuntu-qtcreator
/usr/share/app-install/desktop/qtcreator:qtcreator.desktop:2:X-AppInstall-Package=qtcreator
/usr/share/app-install/desktop/qtcreator:qtcreator.desktop:6:Exec=qtcreator %F
/usr/share/app-install/desktop/qtcreator:qtcreator.desktop:7:Icon=QtProject-qtcreator
/usr/share/app-install/desktop/qhimdtransfer:qhimdtransfer.desktop:12:#Icon=qtcreator_logo_32

Eu acho que qtcreator:qtcreator.desktopé a entrada da área de trabalho para o QtCreator, então eu abro e descubro:

[Desktop Entry]
X-AppInstall-Package=qtcreator
X-AppInstall-Popcon=292
X-AppInstall-Section=universe

Exec=qtcreator %F
Icon=QtProject-qtcreator
Type=Application
Terminal=false
Name=Qt Creator
GenericName=Integrated Development Environment
MimeType=text/x-c++src;text/x-c++hdr;text/x-xsrc;application/x-designer;application/vnd.nokia.qt.qmakeprofile;application/vnd.nokia.xml.qt.resource;
Categories=Qt;Development;IDE;
InitialPreference=9

X-Ubuntu-Gettext-Domain=app-install-data

qtcreator não está na variável $PATH do shell . Mas ainda posso iniciar o QtCreator na unidade do gnome.

Nas variáveis ​​freedesktop-exec, notei

Se nenhum caminho completo for fornecido, o executável será pesquisado na variável de ambiente $PATH usada pelo ambiente de desktop.

Pergunta

A variável de ambiente $ PATH de um ambiente de desktop é diferente de um shell?

Em caso afirmativo, onde está o arquivo de configuração contendo a variável $PATH para ambiente de desktop?

Eu instalo uma versão mais recente do QtCreator, em seguida, inicio o QtCreator na área de trabalho e descubro que ele faz referência à versão mais recente sem alterar o qtcreator:qtcreator.desktoparquivo. Acho que tem algo a ver com o caminho do qt?

Ambiente de trabalho: gnome

SO: Ubuntu16.04

Editar

O problema real que encontrei não foi sobre $ PATH (veja minha resposta). A resposta de Gilles é na verdade a resposta para 'A variável de ambiente $PATH de um ambiente de desktop é diferente daquela em um shell?' então aceitei caso alguém tenha a mesma dúvida que eu.

Qual é a ordem dos comandos executados que possuem redirecionamento de pipeline e de saída?

Digamos que façamos o seguinte:

Charles@myzone:/tmp$ mkdir /tmp/testdir      
Charles@myzone:/tmp$ cd /tmp/testdir   
Charles@myzone:/tmp/testdir$ touch file1 file2  
Charles@myzone:/tmp/testdir$ ls | wc -l
2
Charles@myzone:/tmp/testdir$ ls | wc -l > ls_result
Charles@myzone:/tmp/testdir$ cat ls_result
3

Eu sei que se você fizer ls > resultisso result, conterá o nome de si mesmo, porque o shell fará algo como

1) criar/abrir arquivo chamado result 2) definir o fd resultpara ser stdout 3) execls

Eu esperava ls_resultter o valor 2, mas é 3.

Pergunta

Como o comando ls | wc -w > ls_resultacima é executado?

É equivalente a (ls | wc -w ) > ls_result?

Alguns links com informações relativas? (Pesquisei o manual do bash)

Eu coloquei um script python com um loop infinito, /etc/rc.localmas a máquina inicializou com sucesso, o que me confunde.

O /etc/rc.localconteúdo:

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
  printf "My IP address is %s\n" "$_IP"
fi

/home/pi/py/startsignal.py &
/home/pi/py/fan.py
touch /home/pi/thisisrun
exit 0

startsignal.py

#!/usr/bin/python
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)

GPIO.output(18, 1)

fan.py

#!/usr/bin/python
# coding: utf8
import RPi.GPIO as gpio

gpio.setmode(gpio.BCM)
upper_temp = 55
lower_temp = 45
# minutes
check_interval = 2

def get_temp():
    with open('/sys/class/thermal/thermal_zone0/temp', 'r') as f:
        temp = float(f.read()) / 1000
    return temp

def check_temp():
    if get_temp() > upper_temp:
        gpio.setup(23, gpio.OUT)
    elif get_temp() < lower_temp:
        gpio.setup(23, gpio.IN)

if __name__ == '__main__':
    # check every 2 minutes
    try:
        while True:
            check_temp()
            sleep(check_interval * 60)
    finally:
        gpio.cleanup()

Todo o código relevante está acima. Eu pensei sobre isso depois de pesquisar no Google.

1. o #!/bin/sh -eindica que o script será encerrado assim que ocorrer um erro.
2. o /home/pi/thisisrunarquivo não foi criado, então deve haver um erro acima desta linha
3. depois de inicializar no sistema, posso ver que fan.pyestá em execução. Então eu acho que o erro ocorre durante a execução do fan.py. Mas o fan.pytem um loop infinito nele!

Como um script python pode gerar um erro, mas ainda é executado normalmente?

Como pode /bin/shdetectar o erro quando o fan.pynunca retorna?

SO: raspbian stretch

Achei uma coisa estranha enquanto brincava com o pi3B. Eu quero criar um arquivo /sys/class/gpio( apenas bisbilhotando, sem motivo específico ), mas recebo uma permissão negada . Abaixo algumas informações.

pi@raspberrypi:/sys/class/gpio $ groups
pi adm dialout cdrom sudo audio video plugdev games users input netdev gpio i2c spi
pi@raspberrypi:/sys/class/gpio $ ls -ld .
drwxrwx--- 2 root gpio 0 May  6 00:28 .
pi@raspberrypi:/sys/class/gpio $ touch somefile
touch: cannot touch 'somefile': Permission denied

Como você pode ver, estou no grupo gpio e o grupo tem a permissão de gravação do diretório /sys/class/gpio.

Portanto, a questão é por que não consigo criar novos arquivos, /sys/class/gpiomesmo que o grupo do qual faço parte tenha permissão.

Eu tentei relogar e reiniciar depois de adicionar o usuário pi ao grupo gpio e isso foi há vários dias.

SO: raspbian stretch

tentounewgrp