jpnevulator - Online nel cloud

PROGRAMMA:

NOME

jpnevulator - Solo un altro sniffer seriale

SINOSSI

jpnevulator [OPZIONE]...RISORSE>

DESCRIZIONE

jpnevulator è un pratico sniffer seriale. Puoi usarlo anche per inviare dati su un dispositivo seriale.
Puoi leggere o scrivere da/verso uno o più dispositivi seriali contemporaneamente.

In modalità di scrittura (--write) i dati da inviare sui dispositivi seriali vengono letti da un file o
stdin nella notazione definita in base (--base). I dati vengono inviati sulla linea dei dispositivi seriali da
linea.

In modalità lettura (--read) i dati da leggere dai dispositivi seriali vengono scritti su un file o
stdout nella notazione definita in base (--base). Scorri le opzioni per diversi
miglioramenti nell'output. È anche possibile passare (--passare) sui dati tra i
diversi dispositivi seriali.

Gli argomenti obbligatori per le opzioni lunghe è obbligatoria per brevi opzioni troppo.

Opzioni generiche:

-B, --base=BASE
Specificare l'unità di base dei byte di lettura/scrittura. Attualmente solo 2=binario e
16=esadecimale sono supportati. L'unità di base predefinita è esadecimale.

Selezionando esadecimale come unità di base, il formato di input è FD o 0xFD. Certo
tutto l'input viene trattato senza distinzione tra maiuscole e minuscole. Gli spazi possono o non possono essere inclusi nel
ingresso. Quindi DEADBEEF è esattamente lo stesso di DE AD BE EF.

Selezionando binario come unità di base, il formato di input è 01000010. Gli spazi possono o possono
non essere incluso nell'input. Quindi 01000010111 è esattamente uguale a 01000010 111.
Sì, è giusto! Va benissimo scrivere meno di 8 bit, esclusi i
zeri iniziali. Si prega di capire se così facendo, sono necessari spazi per separare i
singoli byte in questo caso, ma è ovvio. Se non vengono utilizzati spazi, il
parses legge i primi 8 bit prima di continuare con il successivo, come mostrato nel
esempio sopra.

-l, --alias-separatore
Usa la stringa data come separatore di alias. Vedere --tty per ulteriori informazioni.

-f, --file=NOME
In modalità scrittura leggere il contenuto del file fornito e inviarlo sul seriale
dispositivo(i) e in modalità lettura scrivi il contenuto del(i) dispositivo(i) seriale(i) nel file
dato.

-h, --Aiuto
Mostra un breve elenco di opzioni.

-o, --contare=BYTE
Esci dopo aver letto/scritto la quantità di byte indicata.

-r, --leggere
Metti il ​​programma in modalità lettura. In questo modo si leggono i dati dal seriale dato
device(s) e scriverlo nel file fornito o stdout se non ne viene fornito nessuno. Vedi la lettura
sezione opzioni per ulteriori opzioni di lettura specifiche.

-t, --tty=NOME: ALIAS
Il dispositivo seriale da cui leggere o su cui scrivere. Utilizzare più volte per leggere/scrivere
da/verso più dispositivi seriali. Per un riferimento pratico puoi anche separare
un alias dal nome tty con un collon ':'. Se un collon è per qualcuno strano
motivo parte del nome del dispositivo, è possibile utilizzare l'opzione --alias-separator per
specificare un'altra stringa di separazione. Se viene fornito un alias, verrà utilizzato come nome
del dispositivo seriale.

-v, --versione
Emetti le informazioni sulla versione, un piccolo avviso GPL ed esci.

-w, --Scrivi
Metti il ​​programma in modalità di scrittura. In questo modo leggi i dati da un dato file o stdin se
none fornito e scrivilo sui dispositivi seriali forniti. Vedi le opzioni di scrittura
sezione per ulteriori opzioni di scrittura specifiche.

Opzioni di lettura:

-a, --ascii
Oltre al normale output dei dati, visualizza anche una colonna aggiuntiva con i dati
nella rappresentazione ASCII. I caratteri non stampabili vengono visualizzati come un punto '.'.
I dati ASCII vengono visualizzati dopo i dati normali.

-b, --conteggio-byte
Oltre all'output normale viene visualizzata anche una colonna aggiuntiva con l'indice corrente
numero del byte in uscita. Questi numeri vengono visualizzati davanti a
uscita normale. Quando si legge da più dispositivi seriali contemporaneamente l'indice
il numero aumenterà per dispositivo seriale.

-C, --controllo
Monitora i bit di controllo del modem (abilitazione linea, terminale dati pronto, richiesta di invio,
TXD secondario, RXD secondario, chiaro per inviare, rilevamento portante, squillo e set di dati
ready) e notificare le modifiche. Usa l'opzione --control-poll per specificare la frequenza
per sondare i bit.

-D, --control-sondaggio=MICROSECONDI
Il poll di controllo è la quantità di microsecondi da attendere tra due controlli del
bit di controllo del modem se non sta accadendo nient'altro.

-P, --passaggio
Questo passa tutti i dati tra i dispositivi seriali. Comodo se vuoi mettere
il tuo sniffer seriale tra i dispositivi seriali che vuoi annusare.

-q, --pty=:ALIAS
Il dispositivo pseudo-terminale da cui leggere. Utilizzare più volte per leggere da più di
uno o più dispositivi pseudo-terminali. Per riferimento pratico puoi anche usare un alias per
nominare il pty. Assicurati che inizi con un collon ':'. Usa il separatore --alias
opzione se per qualche motivo non ti piace usare un collon. Se viene dato un alias
verrà utilizzato come nome del dispositivo pseudo-terminale.

-e, --delta temporale=MICROSECONDI
Il delta di temporizzazione è la quantità di microsecondi tra due byte che quest'ultimo è
considerato parte di un nuovo pacchetto. Il valore predefinito è 100 millisecondi. Usa questo
opzione in combinazione con l'opzione --timing-print.

-g, --stampa del tempo
Stampa una riga di informazioni sui tempi prima di ogni flusso continuo di byte. quando
vengono forniti più dispositivi seriali stampare anche il nome o l'alias del dispositivo dove
i dati provengono da.

-i, --larghezza=LARGHEZZA
Il numero di byte da visualizzare su una riga. Il valore predefinito è 16.

-A, --aggiungere
Aggiungi al file di output invece di sovrascrivere. L'impostazione predefinita è sovrascrivere.

-S, --append-separatore
Usa la stringa data come separatore di aggiunta. La stringa viene elaborata e '\n'
sequenza si trasforma in una vera e propria nuova riga. Finora nessun'altra sequenza fa nulla
speciale. L'impostazione predefinita è un singolo carattere di nuova riga.

Opzioni di scrittura:

-c, --somma di controllo
Aggiungi un singolo byte di checksum alla riga di dati scritti sui dispositivi seriali
scelto. Questo checksum è una semplice aggiunta modulo 256 di tutti i byte di input su una riga.

-z, --crc8=POLY
Aggiungi un checksum crc8 alla riga di dati scritti sui dispositivi seriali scelti.
Usa il poly dato facoltativamente come polinomio. Specificare il polinomio come
valore esadecimale, come in 0x07 (il valore predefinito).

-y, --crc16=POLY
Aggiungi un checksum crc16 alla riga di dati scritti sui dispositivi seriali scelti.
Usa il poly dato facoltativamente come polinomio. Specificare il polinomio come
valore esadecimale, come in 0xA001 (predefinito).

-k, --byte di ritardo=MICROSECONDI
Questo ritardo è una quantità facoltativa di microsecondi da attendere tra ogni input
byte viene inviato sui dispositivi seriali.

-d, --linea di ritardo=MICROSECONDI
Questo ritardo è una quantità facoltativa di microsecondi da attendere tra ogni input
la linea viene inviata sui dispositivi seriali.

-j, --cazzo
Questa è l'opzione speciale del cazzo. Quando si sceglie il calcolo di un checksum
(vedi opzioni checksum e crc*) il checkum verrà storpiato di proposito. Con attenzione
prende il nome dal pulsante speciale "Fuck up crc" di Jan Arie de Bruin.

-n, --no-invio
Non inviare effettivamente i byte sui dispositivi seriali. Piuttosto inutile, ma
sembrava un giorno molto tempo fa una caratteristica piuttosto utile.

-p, --Stampa
Oltre a inviare i dati sui dispositivi seriali, scrivi anche i dati su stdout.

-s, --dimensione=TAGLIA
Il numero massimo di byte per riga da inviare sui dispositivi seriali. Il predefinito
è 22, rientrando nei giorni di Cham2 del programma.

DIAGNOSTICA

Normalmente, lo stato di uscita è 0 se il programma è stato eseguito senza alcun problema. Se l'uscita
lo stato non è uguale a 0 un messaggio di errore viene stampato su stderr che dovrebbe aiutarti a risolvere
il problema.

Usa jpnevulator online usando i servizi onworks.net