E – Kermit — Kermit per l’incorporamento

 

L’originale è disponibile su kermitproject.org

Protocollo di trasferimento file Kermit compatto, veloce, affidabile e portatile per l’incorporamento

Versione : 1.7

Data : 6 giugno 2011

Questa pagina è stata aggiornata : 9 aprile 2019

Annuncio Open Source : Il 30 marzo 2011, la versione 1.6 di E-Kermit sarà rilasciata “così com’è” sotto la Revised 3-Clause BSD License.

Contenuti

  1. PROGRAMMA DI GESTIONE
  2. TRASFERIMENTO DI FILE
  3. CODICE SORGENTE
  4. VERSIONE UNIX
  5. TRASFERIMENTO SU UNA NUOVA PIATTAFORMA
  6. DEBUTTO
  7. STORIA DELLE USCITE
  8. SCARICA

EK (Embedded Kermit, E-Kermit) è un’implementazione del protocollo di trasferimento file Kermit scritto in ANSI C e progettato per essere integrato in dispositivi e firmware, utilizzato in un’applicazione in tempo reale o per creare DLL e librerie. EKSW è una nuova versione di E-Kermit che include una vera trasmissione di pacchetti a scorrimento. EK ed EKSW avrebbero dovuto essere concordate in un’unica base di codice, ma finora ciò non è avvenuto.

Cosa fa E-Kermit

EK svolge solo due funzioni: inviare file e ricevere file. È compatto, portatile e riutilizzabile. A SPARC (RISC), kermit.o è di circa 25K. In Intel (CISC) sono circa 15K. Riducendo la dimensione del buffer ed eliminando funzioni aggiuntive o indesiderate, è possibile ottenere dimensioni inferiori.

Cosa NON FA E-Kermit

EK non include le funzioni client/server; linguaggio di programmazione a comandi o script; conversione dei caratteri; crittografia dei trasporti; o qualsiasi forma di comunicazione o input/output di file. Non compone modem, non stabilisce connessioni, non ha uno stack TCP/IP integrato. Se hai bisogno di queste funzionalità, dovresti usare un programma Kermit completo come C-Kermit   o  Kermit 95 .

EK non è l’applicazione stessa, è una subroutine che viene chiamata dall’applicazione principale. È utile solo per gli sviluppatori che devono fornire un’applicazione o un ambiente di chiamata, nonché file di I/O e routine di messaggi. A sua volta, l’ambiente di chiamata deve effettuare e stabilire la comunicazione se necessario e non ancora aperta. Unix fornisce chiamate all’ambiente applicativo e supporto I/O.

I clienti hanno adattato EK a diversi ambienti e piattaforme, tra cui Palm Pilot, diversi tipi di apparecchiature per i tecnici (ad esempio, per diagnosticare e mantenere le torri dei telefoni cellulari) e talvolta apportano i propri adattamenti o procedure di I/O e noi possiamo realizzarli disponibile su base rigorosa. Non possiamo supportare il codice fornito ai clienti; quindi (ad esempio) quando viene rilasciata una nuova versione di EK, i moduli aggiunti dall’utente non vengono necessariamente aggiornati. Il codice inserito dal cliente include:

  • Microsoft Windows 9x/ME/NT/2000/XP/Vista/7 porta seriale e file I/O per EK 1.3 e versioni successive.
  • Wind River VxWorks per EK 1.1
  • EK 1.2 è tradotto in Java .

EK include le seguenti funzionalità del protocollo Kermit:

  • Pacchetti lunghi
  • Finestre scorrevoli con recupero errori Go-Back-to-N (vera ripetizione selettiva in EKSW).
  • Compressione con ripetizione
  • Il prefisso del carattere di controllo e viceversa
  • Prefisso a 8 bit (per il trasferimento di dati a 8 bit su collegamenti a 7 bit) (= parità)
  • Pacchetti di attributi (tipo, dimensione e data)
  • Invia e ricevi uno o più file.
  • Passaggio automatico tra modalità testo e binaria.
  • Tutti e tre i tipi di blocchi di controllo (checksum a 6 e 12 bit, CRC a 16 bit).
  • Rapporti di stato (stato del protocollo, nome file, dimensione, timestamp, byte e così via).
  • Annulla il trasferimento di una delle parti.

Le seguenti funzionalità del protocollo Kermit non sono implementate:

  • Finestre scorrevoli con ritrasmissione selettiva (escluso EKSW)
  • Set di caratteri
  • Blocco modifiche
  • Cliente / server

I timeout saranno responsabili del programma Kermit all’altro capo della connessione o, se necessario, nell’E-Kermit stesso, che dipende dalla piattaforma della procedura di lettura del pacchetto che si scrive.

A partire dalla versione 1.5, E-Kermit include progetti di preprocessore che consentono di disattivare varie funzionalità come pacchetti lunghi, finestre scorrevoli e controllare blocchi di ordine superiore per ottenere la minima quantità di memoria e può anche essere creato in una configurazione solo per ammissione.

PROGRAMMA DI GESTIONE

EK è progettato per funzionare in un ambiente multitasking collaborativo, ma non richiede tale ambiente. Il programma di gestione si occupa della pianificazione. Ecco cosa dovrebbe (e/o può) fare un programma di gestione:

  • Se lo si desidera, aprire i dispositivi di comunicazione, se presenti.
  • Se si desidera installare eventuali dispositivi di comunicazione in “modalità batch”.
  • Inizializzare la struttura kermit con i parametri operativi richiesti.
  • Chiama kermit (K_INIT,…) per fare in modo che Kermit si inizializzi.
  • Quando si inviano file, chiamare kermit (K_SEND) per avviare il trasferimento.

(Quando E-Kermit riceve file, attende passivamente il primo pacchetto dal mittente del file, quindi entra semplicemente nel ciclo del pacchetto.) Nel ciclo del pacchetto E-Kermit:

  • Ottiene il buffer e legge il pacchetto in arrivo.
  • Controlla l’interruzione dell’utente.
  • Invoca kermit (K_RUN,…) per eseguire il passaggio successivo nel protocollo.
  • Fa quello che vuole (ad esempio, svolge altri compiti).
  • Esce o continua un ciclo in base al codice di ritorno kermit().

Ogni volta che il programma di controllo chiama la funzione kermit(), dà il permesso di elaborare un pacchetto; quindi, un pacchetto = una fetta. Quando un programma di gestione non ha più nulla da fare, elabora semplicemente i pacchetti in modo continuo, come un normale programma Kermit. Durante il ciclo di dati, ogni chiamata kermit() restituisce una struttura contenente:

  • Lo stato attuale del protocollo;
  • Nome del file corrente;
  • Dimensione del file, se nota, o -1;
  • Stimare il tempo del file se è noto;
  • Il numero di byte trasmessi.

Fatto ciò, il programma di gestione:

  • Ripristina e (se necessario) chiude il dispositivo di comunicazione.

Codici funzione con cui il programma di controllo può chiamare kermit():

K_INIT – Inizializza le strutture dati.

K_SEND – (Solo invio) – avvia l’invio.

K_RUN – Esegue il protocollo.

K_STATUS – Restituisce un rapporto di stato nella struttura k_response.

K_QUIT – Esci subito e in silenzio.

K_ERROR – Invia un pacchetto di errore e poi esci.

Codici di ritorno Kermit():

X_OK – OK, protocollo attivo.

X_DONE – OK, protocollo completato.

X_ERROR – Errore irreversibile.

X_STATUS – Stato restituito in risposta a K_STATUS.

(In realtà, lo stato viene riconfigurato ad ogni chiamata.) Codici di stato del protocollo:

-1 – Errore fatale

 0 – ricevitore (il protocollo non funziona)

 1 – Il ricevitore è in attesa del pacchetto S

 2 – Il ricevitore è in attesa del pacchetto F o B

 3 – Il ricevitore è in attesa del pacchetto A o D

 4 – Il ricevitore è in attesa del pacchetto D o Z

10 – Mittente (protocollo non funzionante)

11 – Il mittente ha inviato il pacchetto S (inizio)

12 – Pacchetto F inviato dal mittente (nome file)

13 – Pacchetto inviato dal mittente (attributi)

14 – Il mittente ha inviato il pacchetto D (dati)

15 – Il mittente ha inviato il pacchetto Z (EOF)

16 – Il mittente ha inviato il pacchetto B (EOT)

TRASFERIMENTO DI FILE

Poiché EK è principalmente per l’incorporamento, non utilizza lo streaming o (tranne EKSW) le vere finestre scorrevoli (sebbene gran parte del codice per le finestre scorrevoli sia presente). Ciò accade per i seguenti motivi:

  • L’utilizzo del consueto protocollo ACK/NAK consente al programma di controllo di riprendere il controllo dopo ogni pacchetto. Ciò gli consente di eseguire il multitasking, visualizzare una visualizzazione grafica dei trasferimenti di file, qualunque cosa. Le finestre a getto d’inchiostro o scorrevoli possono far fallire un programma di gestione per lunghi periodi di tempo.
  • Lo streaming o le finestre scorrevoli reali renderanno l’interfaccia tra il programma di controllo e il modulo kermit() più complessa e in realtà spingeranno molti dettagli del protocollo nello spazio del programma di controllo a cui non appartengono.
  • La trasmissione può essere utilizzata solo per connessioni sicure (come TCP/IP), ma i dispositivi con comunicazione integrata in genere utilizzano porte seriali.

La mancanza di vere finestre scorrevoli in EK è compensata dal fatto che EK finge di sostenerle senza farlo. Ciò consente al partner mittente di “trasmettere” i pacchetti invece di attendere un ACK dopo ciascuno di essi se non ci sono errori. In caso di errore, la strategia di ripristino “ritornerà su n” (o forse in alcuni casi “errore”) anziché “ripetizione selettiva”. EKSW, un programma separato che non è stato integrato con EK (ma dovrebbe esserlo), supporta finestre scorrevoli valide con ripetizione selettiva; cioè, vengono trasmessi solo quei pacchetti che in realtà dovrebbero essere.

In ogni caso, poiché EK è progettato principalmente per l’incorporamento, ci si aspetta che i ritardi ad entrambe le estremità non rappresentino un fattore importante; le connessioni sono generalmente locali, brevi, relativamente veloci e, se la connessione è effettivamente controllata dal flusso, esente da errori. Se manca un controllo efficiente del flusso, la velocità e/o la lunghezza del pacchetto e/o la dimensione della finestra possono essere impostate su una combinazione di valori che massimizzano la larghezza di banda e riducono al minimo la perdita di dati.

CODICE SORGENTE

 File sorgenti:

piattaforma.h

Il file di intestazione per qualsiasi #include la piattaforma o le definizioni richieste. 

Necessario anche se è vuoto perché kermit.c lo include.

kermit.h

File di intestazione per tutti i moduli. Definire le strutture k_data e k_response.

kermit.c

Questo è il meccanismo del protocollo Kermit. Dipende completamente dai dati della chiamata. Tutte le informazioni sullo stato sono memorizzate nella struttura dati kermit, che viene passata per riferimento dal modulo principale e tra tutte le funzioni del modulo kermit e di nuovo al modulo principale; quindi, lo stesso modulo deve trasferire contemporaneamente più file su connessioni diverse. Inoltre, il modulo kermit non ha riferimenti di libreria, nessuno, nemmeno stdio (a meno che il debug non sia abilitato) e nessun file di intestazione / usr / include / *. Regole per kermit.c:

  • Nessuna variabile globale (a parte il debug) o buffer.
  • Nessuna inizializzazione del compilatore degli array.
  • Solo per sicurezza, non inizializza gli scalari automatici.
  • Nessuna libreria o chiamate di sistema, nessun #include <…>.
  • Tutte le operazioni di I/O vengono eseguite da funzioni definite nei singoli moduli.

L’unico punto di ingresso per il modulo kermit.c è la funzione kermit():

int kermit(struct k_data * k, struct 

k_risposta * r)

La struttura k contiene tutti i parametri operativi, variabili, informazioni di stato e buffer; La struttura r informa l’abbonato sullo stato corrente del protocollo, sul nome del file e sulle informazioni sul file, nonché sull’avanzamento del trasferimento (byte).

main.c

Programma di gestione del campionamento. In un banco di prova Unix, è solo una funzione main() tradizionale che legge gli argomenti della riga di comando, inizializza il protocollo e quindi chiama il modulo del protocollo in un ciclo controllato dalla posizione finché non viene eseguito e quindi cancellato. Nell’ambiente embedded, queste funzioni saranno integrate nel programma di controllo.

unixio.c

Funzioni di I/O Unix. Sostituisci il tuo modulo che implementa queste funzioni nell’ambiente di destinazione e modifica la procedura di compilazione per associarlo. I punti di ingresso e gli accordi di chiamata sono descritti di seguito.

VERSIONE UNIX

EK è sviluppato su una piattaforma Unix convenzionale, come Solaris, HP-UX o Linux, in cui EK è costruito come un programma di trasferimento file Kermit controllato a distanza, simile a G-Kermit, e testato contro Kermit desktop in un modo simile K95 o C-Kermit. NOTA. La versione Unix gira su stdin / stdout; La “linea” è dovuta al modo più severo (sistema (“stty…”)).1700Kcps.Non preoccuparti perché EK non è progettato per l’uso in Unix, che ha già G-Kermit e C -Kermit per la produzione.

Unix makefile ha i seguenti obiettivi (facilmente aggiungerne altri):

gcc: compila con gcc (predefinito).

cc: Costruisci con cc.

hp: Crea per HP-UX.

gccnd: compila con gcc, senza debug.

gprof: Crea con gcc, abilita la profilazione.

clean: elimina i file oggetto e kernel.

Makefile crea un file Unix eseguibile chiamato “ek” (kermit integrato). La procedura di esempio main() fornisce una semplice interfaccia a riga di comando:

$ ./ek -h

Utilizzo: ./ek opzioni

Opzioni:

 -r Ricevi file

 -s file           Invia file

 -p [neoms] Parità: nessuna, pari, dispari, mark, space

 -b [123] Tipo controllo blocco: 1, 2 o 3 (predefinito = 3)

 -k Conserva i file ricevuti in modo incompleto

 -B Forza la modalità binaria

 -T Forza modalità testo

 -R Modalità remota (vs locale)

 -L Modalità locale (vs remoto)

 -E numero       Tasso di errore simulato (0-100)

 -d Crea debug.log

 -h Aiuto (questo messaggio)

$

Quando si inviano file, se non si specifica un file di testo o binario, EK esegue la scansione di ogni file e seleziona una modalità testo o binaria in base al suo contenuto.

La modalità remota/locale viene utilizzata solo per abilitare il test di interruzione del trasferimento di file.

PARTY SI NUOVE PIATTAFORME

La versione 1.0 EK è stata portata su VxWorks da Airvana, Inc., Chelmsford MA. Il pacchetto completo VxWorks EK 1.1 è incluso come esempio di un sistema di produzione con il permesso di Airvana (notare che l’API EK è cambiata un po’ da allora, quindi prima di usare il codice VxWorks, deve essere aggiornato). Per connettersi alla nuova piattaforma:

  • Aggiungi una nuova voce Makefile per il tuo scopo o scrivi la tua procedura di compilazione.
  • Crea un file platform.h per la tua piattaforma. Questo può includere qualsiasi #include o definizioni richieste e può anche essere usato per sovrascrivere determinate definizioni in kermit.h:

#define NODEBUG per creare senza codice di debug.

#define HAVE_UCHAR se UCHAR è già definito o typedef’d unsigned character

#define HAVE_ULONG se ULONG è già definito o un carattere senza segno typedef’d

#define IBUFLEN è la dimensione desiderata per il buffer del file di input.

#define OBUFLEN – la dimensione desiderata per il buffer di output.

#define FN_MAX come lunghezza massima per il nome del file.

#define P_PKTLEN per sovrascrivere la lunghezza massima del pacchetto predefinita.

#define P_WSLOTS per sovrascrivere gli intervalli massimi della finestra per impostazione predefinita.

  • Sostituisci l’esempio main.c con il tuo programma di controllo. Utilizzare gli stessi accordi di inclusione e attivazione dell’esempio.
  • Copia il file unixio.c in xxxio.c (il nome che preferisci), modificalo in modo che funzioni sulla tua piattaforma utilizzando esattamente le stesse convenzioni di chiamata e regola la procedura di compilazione per associare il tuo nuovo modulo xxxio invece di unixio. Nota che l’input e l’output del buffer (i_buf [] e o_buf []) devono essere definiti nella procedura xxxio.

Ecco alcuni suggerimenti per la creazione di un modulo I/O:

Si prevede che le procedure di I/O del dispositivo gestiscano da sé i parametri di comunicazione, inclusi velocità di linea, controllo di parità e controllo di flusso. In particolare, Kermit non affronta la parità, ma ha ancora bisogno di dirlo. Questo viene fatto nell’impostazione main (). Se necessario, i tuoi programmi readpkt() e ttx_data() dovrebbero dividersi e aggiungere parità se necessario. Con le connessioni seriali, forse è possibile programmare un UART per questo.

Modifica API tra EK 1.1 e 1.2 : gli accordi di chiamata (liste di argomenti di funzione e valori restituiti) sono stati modificati tra le versioni 1.1 e 1.2, principalmente per fornire l’accesso a ciascuna struttura k in sequenza e anche per fornire un feedback migliore alla parte chiamante. In ogni caso in cui è stata effettuata una modifica, vengono indicati sia il vecchio che il nuovo formato.

Funzioni I/O del dispositivo:

int

devopen (char * dispositivo)

Apre questo dispositivo di comunicazione. Può anche essere un host di rete. Restituisce 0 in caso di errore, 1 in caso di esecuzione riuscita.

int

devsettings (char * settings)

Esegue tutte le impostazioni necessarie per il dispositivo come la velocità e il controllo del flusso per il dispositivo seriale. Non avendo modo di conoscere quali siano i relativi parametri, questa procedura accetta semplicemente una stringa che può essere in qualsiasi formato, come ad esempio “9600;8N1” o “velocità = 57600; flusso = rts/cts”; la procedura devsettings dovrà analizzare la stringa. Restituisce 0 in caso di errore, 1 in caso di esecuzione riuscita.

int

devrestore (vuoto)

Se necessario, restituisci il dispositivo quando noti le sue impostazioni di sviluppo (). poco prima della chiusura.

int

devclose (vuoto)

Chiude il dispositivo di comunicazione.

int

readpkt (UCHAR * buffer, struttura k_data * k) (1.1)

readpkt (struct k_data * k, UCHAR * buffer, int length) (1.2)

Questa procedura dovrebbe eseguire esattamente ciò che fa l’esempio: trovare l’inizio del pacchetto, quindi copiare tutti i caratteri (esclusi) alla fine del pacchetto nel buffer del pacchetto il cui indirizzo è specificato. Dovrai compilarlo nel modo più efficiente possibile utilizzando tutti i trucchi a tua disposizione. Se vuoi che il tuo programma Kermit subisca un timeout, qui devi inserire il codice. NOTA. I timeout non sono richiesti, poiché la probabilità che il partner ek Kermit non possa uscire è circa 0. Il formato EK 1.2 contiene k come primo argomento per coerenza con altre subroutine e aggiunge un argomento di lunghezza del buffer.

Nota la funzione F_CTRLC. Questo è abilitato per impostazione predefinita. Ciò consente a EK di uscire dalla modalità batch inviando tre flussi di dati Ctrl-C consecutivi. Di solito non è necessario disabilitarlo, perché anche se il mittente “senza prefisso” Ctrl-C, tre di loro in una riga verranno solitamente compressi in una sequenza ripetuta.

int

tx_data (UCHAR * dati, lunghezza int, parità breve) (1.1)

tx_data (struct k_data * k, UCHAR * data, int length) (1.2)

Anche in questo caso è necessario aderire all’uguaglianza (se non viene eseguita automaticamente dal dispositivo di comunicazione o dal conducente). Questa procedura dovrebbe essere efficace e affidabile. Deve passare l’intera riga di dati, altrimenti si blocca. Vedere unixio.c, che intendo per “robusto”. In EK 1.2 e versioni successive, l’insediamento di parità viene elevato dalla struttura k.

Le funzioni di I/O del file sono le seguenti: possono essere utilizzate per leggere o scrivere qualsiasi cosa – non solo file: memoria, nastro, schede, raggi laser, controller di strumenti, qualsiasi cosa. Non importa come chiamate queste procedure, ma l’elenco degli argomenti e il tipo di valore restituito dovrebbero essere come specificato; inoltre, se dai loro nomi diversi, dovrai cambiare i prototipi in kermit.h:

int

openfile (UCHAR * nomefile, modalità int, struct k_date * k) (1.1)

openfile (struct k_date * k, UCHAR * nome file, modalità int) (1.2)

Apre il file del nome nella modalità specificata (1 = leggi, 2 = scrivi, 3 = aggiungi). Restituisce X_OK in caso di successo, X_ERROR in caso di fallimento.

ULONG

fileinfo (UCHAR * nome file, UCHAR * buf, int buflen, short * tipo, modalità breve) (1.1)

fileinfo (struct k_data * k, UCHAR * nomefile, UCHAR * buf, int buflen, short * tipo, modalità breve) (1.2)

Ottiene informazioni sul file locale esistente specificato: dimensione, data e, se modalità == 0, tipo di file (testo o binario). buf e buflen vengono applicati alla riga data/ora del file. Restituisce X_OK o X_ERROR.

int

readfile (struct k_data *)

Legge il buffer dal file di input e, quando viene trasmesso in modalità testo, converte il formato di scrittura in CRLF Cermit Stream standard. Restituisce X_OK o X_ERROR.

int

writefile (struct k_data *, CHAR * buffer, int length)

Scrive un buffer nel file di output e, quando viene trasmesso in modalità testo, converte anche il formato di scrittura CRLF standard del flusso Kermit in quanto richiesto localmente. Restituisce X_OK o X_ERROR.

int

closefile (struct k_data *, codice UCHAR, modalità int)

Chiude il file. Per i file di output, ovviamente, questo ripristina i buffer in sospeso sul file prima di chiuderlo; quindi controlla se il trasferimento Kermit annulla il trasferimento del file prima del suo completamento (codice == ‘D’), e in questo caso scarta il file parziale invece di salvarlo. La modalità indica se si tratta di un file di input o di output, quindi i file incompleti possono essere eliminati se necessario. Restituisce X_OK o X_ERROR.

Gli accordi di chiamata esatti sono mostrati nel file unixio.c.

DEBUTTO

Se l’EK è stato creato senza una definizione NODEBUG, se si abilita l’opzione -d sulla riga di comando, la versione dell’applicazione basata su Unix dell’EK crea un file debug.log nella directory corrente. Nella versione di produzione devi aggiungere -DNODEBUG al compilatore C CFLAGS per escludere il codice di debug. Le dimensioni mostrate sopra includono il debug. Puoi implementare la funzione di debug nel modo che preferisci nel tuo modulo I/O per la piattaforma.

STORIA DEL RILASCIO

Versione DataDescrizione
1.12002/10/07   Emissione iniziale. La versione VxWorks è ancora a questo livello.
1.228/01/2003API migliorata, porta Java (che è ancora a questo livello).
1.32004/03/04Correggere il trasferimento dei file utilizzando HyperTerminal.
1.420/03/2004Correggi la ricezione di file vuoti
1.52004/04/10Risolvi il problema con i pacchetti A, consenti impostazioni ultra-piccole e/o solo per la ricezione.
1,5123/09/2004Adattamento a Philips XAG30 ( John Dunlap )
EKSW 0.942010/06/24Presenti vetri scorrevoli con ritrasmissione selettiva (John Dunlap)
1.630/03/2011Rilasciato e rilasciato con una licenza BSD modificata a 3 clausole .
1.706/06/2011Il protocollo FORCE-3 06/06/2011 funziona in combinazione con C-Kermit 9.0 (spiegato qui )

SCARICA

Diverse implementazioni di E-Kermit sono disponibili per il download. E-Kermit stesso, versione 1.7, è di base. Altri – adattamento a diverse piattaforme o linguaggi che sono stati effettuati durante le versioni precedenti di E-Kermit, come mostrato nella sezione precedente; in altre parole, le correzioni trovate in E-Kermit 1.3, 1.4 e 1.5 non sono nelle versioni VxWorks o Java e la versione VxWorks utilizza l’API E-Kermit 1.1 invece della versione migliorata 1.2. EKSW ha alcune modifiche API e altre incongruenze che dovrebbero essere eliminate prima di poter essere integrato con EK 1.6, ma è abbastanza utile di per sé. In effetti, è una versione che funziona nella nuova generazione di galleggianti oceanici Apex-EM, ed è stato testato in modo più approfondito in condizioni più avverse rispetto a qualsiasi altra implementazione del protocollo Kermit. Tornando alla versione 1.7, che implementa il nuovo protocollo di validazione dei pacchetti Force-3 . (EKSW otterrà anche questo ad un certo punto.)

HTTPFTP
NomeDescrizionecatrame *Cerniera lampoFile sorgenti
E-Kermit 1.7Portabile su tutte le piattaforme, con demo Unix.ScaricaScaricaScarica
EKSW 0.94E-Kermit con vere finestre scorrevoli adattate a Linux.ScaricaScaricaScarica
EKVX 1.1 E-Kermit 1.1 è adattato a VxWorks.ScaricaScaricaScarica
GiavaE-Kermit 1.2 viene convertito in JavaScaricaScaricaScarica
SimiridProtocollo Stress Tester [ Descrizione ]ScaricaScaricaScarica

* Non compressi, non servono, sono molto piccoli.

Clicca qui per accedere all’FTP di tutti i file E-Kermit