testing.test=test${test1}test${test2}test
Announcer.announceAlertIntro=Freenet si sta connettendo alla rete - l'operazione può richiedere alcuni minuti di attesa. Le performance del processo miglioreranno col passare delle ore. Tutto ciò accade ogni volta che ci si disconnette da Freenet per più di qualche minuto, perciò provate a lasciarlo attivo per 24 ore al giorno se possibile.
Announcer.announceAlertTitle=Annuncio Nodo in corso
Announcer.announceDetails=Il nodo ha recentemente inoltrato ${recentSentAnnouncements} annunci, ${runningAnnouncements} dei quali ancora in corso, ed aggiunto ${addedNodes} nodi (${refusedNodes} nodi hanno rifiutato la connessione). In questo momento il nodo è connesso a ${connectedSeednodes} seednode e sta cercando di connettersi ad altri ${disconnectedSeednodes}.
Announcer.announceAlertNoSeednodes=Non e' stato trovato il file seednodes.fref e quindi il nodo non può connettersi automaticamente ad Opennet. Aggiungere alcuni nodi manualmente o scaricare il file seednodes da http://downloads.freenetproject.org/alpha/opennet/ .
Announcer.announceLoading=Il nodo sta caricando il file seednodes per annunciarsi al resto della rete. Il completamento dell' operazione potrebbe richiedere diversi minuti.
Announcer.announceDisabledTooOldTitle=Annuncio disabilitato (obsoleto)
Announcer.announceDisabledTooOld=Questo nodo sembra essere troppo vecchio per connettersi alla rete Freenet. Il tuo nodo cercherà di scaricare una versione più recente di Freenet e si riavvierà per installare gli aggiornamenti. Per favore attendi qualche istante. Questo messaggio sparirà quando l'aggiornamento sarà completato. Abbiamo disabilitato gli avvisi, visto che ora non servono.
Announcer.announceDisabledTooOldUpdateDisabled=Per autorizzare freenet a aggiornarsi da solo, perfavore abilitare l'auto-aggiornamento su ${config}Configuration page${/config}.
Announcer.announceDisabledTooOldShort=Il nodo non riesce a connettersi alla rete perché la versione di Freenet utilizzata è obsoleta. Si prega di eseguire l'aggiornamento.
Announcer.announceAlertShort=Tentativo di connessione in corso: le prestazioni del nodo risulteranno ridotte fino a connessione avvenuta.
Announcer.coolingOff=Per i prossimi ${time} secondi, il vostro nodo Freenet aspetterà che i nodi che ha annunciato si connettano; se non ci saranno abbastanza nodi proverà con un altro nodo.
Announcer.dontKnowAddress=Non è stato possibile determinare l'indirizzo IP del computer in cui Freenet viene eseguito. Non è possibile procedere all'annuncio finché non si conosce l'IP.
BMPFilter.InvalidBitDepthD=La profondità di campo in bit non è impostata su 1, 2, 4, 8, 16, o 32.
BMPFilter.InvalidBitDepthT=Profondità in bit non valida
BMPFilter.InvalidBitMapInfoHeaderSizeD=Dimensione info header bitmap diversa da 40
BMPFilter.InvalidBitMapInfoHeaderSizeT=Dimensioni header Bitmap info non valide
BMPFilter.InvalidDimensionD=Immagine con valore negativo per altezza o ampiezza
BMPFilter.InvalidDimensionT=Dimensione Non Valida
BMPFilter.InvalidFileSizeD=Dimensioni file immagine non corrispondenti a dimensioni-header+dimensioni-dati-immagine
BMPFilter.InvalidFileSizeT=Dimensioni file immagine non valide
BMPFilter.InvalidImageDataSizeD=Dimensione calcolata dati immagine non corrispondente all'effettiva dimensione
BMPFilter.InvalidImageDataSizeT=Dimensioni dati immagine non valide
BMPFilter.InvalidNoOfPlanesD=Il numero di piani è diverso da uno.
BMPFilter.InvalidNoOfPlanesT=Numero di piani non valido
BMPFilter.InvalidOffsetD=Valore negativo per data offset
BMPFilter.InvalidOffsetT=Offset Non Valido
BMPFilter.InvalidResolutionD=La risoluzione dell'immagine ha valore negativo
BMPFilter.InvalidResolutionT= Risoluzione non valida
BMPFilter.InvalidStartWordD=La parola di avvio non è una delle BM,BA,CI,CP,IC e PT
BMPFilter.InvalidStartWordT=Parola di avvio non valida
BMPFilter.notBMP=Non è stato possible filtrare BMP:
Bookmark.noName=nessun nome
BookmarkEditorToadlet.addBookmark=Aggiungi Segnalibro
BookmarkEditorToadlet.addCategory=Aggiungi Categoria
BookmarkEditorToadlet.addNewBookmark=Aggiungi nuovo segnalibro
BookmarkEditorToadlet.addNewCategory=Aggiungi una nuova categoria
BookmarkEditorToadlet.addedNewBookmark=Nuovo segnalibro aggiunto correttamente.
BookmarkEditorToadlet.addedNewBookmarkTitle=Aggiunto nuovo segnalibro
BookmarkEditorToadlet.bookmarkDoesNotExist=Il segnalibro "${bookmark}" non esiste.
BookmarkEditorToadlet.cancelCut=Cancella taglia
BookmarkEditorToadlet.changesSaved=Le modifiche sono state salvate correttamente.
BookmarkEditorToadlet.changesSavedTitle=Modifiche Salvate
BookmarkEditorToadlet.confirmDelete=Elimina
BookmarkEditorToadlet.addDefaultBookmarks=Ri-aggiungi segnalibri originali
BookmarkEditorToadlet.cut=Taglia
BookmarkEditorToadlet.delete=Elimina
BookmarkEditorToadlet.deleteBookmark=Rimuovi segnalibro
BookmarkEditorToadlet.deleteBookmarkConfirm=Confermi l'eliminazione di ${bookmark}?
BookmarkEditorToadlet.deleteCategory=Elimina categoria
BookmarkEditorToadlet.deleteCategoryConfirm=Conferma: eliminare ${bookmark} con tutte le sottocategorie?
BookmarkEditorToadlet.deleteSucceeded=Rimozione effettuata con successo.
BookmarkEditorToadlet.deleteSucceededTitle=Eliminato con successo
BookmarkEditorToadlet.descLabel=Descrizione del segnalibro
BookmarkEditorToadlet.edit=Modifica
BookmarkEditorToadlet.editBookmarkTitle=Modifica segnalibro
BookmarkEditorToadlet.editCategoryTitle=Modifica Categoria
BookmarkEditorToadlet.error=Errore
BookmarkEditorToadlet.explainLabel=Breve descrizione
BookmarkEditorToadlet.hasAnActivelinkLabel=Il freesite ha un activelink?
BookmarkEditorToadlet.invalidKeyTitle=Chiave non valida
BookmarkEditorToadlet.invalidKeyWithReason=Chiave Freenet non valida.
BookmarkEditorToadlet.invalidKey=La chiave Freenet non è valida.
BookmarkEditorToadlet.invalidNameTitle=Nome non valido
BookmarkEditorToadlet.invalidName=Il nome del segnalibro non é valido.
BookmarkEditorToadlet.keyLabel=Chiave:
BookmarkEditorToadlet.moveDown=Giù
BookmarkEditorToadlet.moveUp=Su
BookmarkEditorToadlet.myBookmarksTitle=Segnalibri
BookmarkEditorToadlet.myBookmarksExplanation=Link ai website pubblicati su Freenet, riceverai una notifica ogni volta che vengono aggiornati
BookmarkEditorToadlet.nameLabel=Nome:
BookmarkEditorToadlet.paste=Incolla
BookmarkEditorToadlet.pasteOrCancel=Clicca su un'icona 'incolla' o 'cancella'.
BookmarkEditorToadlet.pasteTitle=Taglia/Incolla
BookmarkEditorToadlet.publicDescLabel=Descrizione visibile agli amici:
BookmarkEditorToadlet.recommendToFriends=Raccomanda ad amici
BookmarkEditorToadlet.save=Salva
BookmarkEditorToadlet.share=Condividi
BookmarkEditorToadlet.title=Modifica segnalibro
BookmarkEditorToadlet.urlDecodeError=Errore nella decodificazione dell'URL
BookmarkFeedUserAlert.addAsABookmark=Aggiungi ai segnalibri
BookmarkFeedUserAlert.bookmarkDescription=Descrizione:
BookmarkFeedUserAlert.delete=Elimina
BookmarkFeedUserAlert.peerName=Nome:
BookmarkFeedUserAlert.title=${from} ti raccomanda un freesite
BookmarkItem.bookmarkUpdated=Il sito ${name} è stato aggiornato all'edizione ${edition}.
BookmarkItem.bookmarkUpdatedTitle=${name}: segnalibro aggiornato
BookmarkItem.bookmarkUpdatedWithLink=Il Sito ${link}${name}${/link} è stato aggiornato all'edizione ${edition}.
BookmarkItem.bookmarkUpdatedShort=Freesite aggiornato: ${name}
BookmarkItem.deleteBookmarkUpdateNotification=Elimina notifica
BookmarkItem.unnamedBookmark=Segnalibro Senza Nome
BookmarkManager.defaultBookmarks=Segnalibri Predefiniti
BookmarkManager.list=Segnalibri
BookmarkManager.listLong=Lista dei freesite preferiti
BookmarkManager.malformedBookmark=Segnalibro malformato
Bookmarks.Defaults.Name.categoryIndexes=Cartelle dei siti su Freenet
Bookmarks.Defaults.Name.categoryDocumentation=Documentazione relativa a Freenet
Bookmarks.Defaults.Name.categorySoftware=Software correlato a Freenet
Bookmarks.Defaults.Name.categoryBlogs=Lista dei blog del team Freenet
Bookmarks.Defaults.Description.TUFI=Un indice di una pagina con un menù che include le categorie
Bookmarks.Defaults.Description.AFK=Un indice dei siti di Freenet con le categorie (per le più vecchie, utilizza Enzo)
Bookmarks.Defaults.Description.Enzo=Un indice dei siti di Freenet con le categorie
Bookmarks.Defaults.Description.Gantros=Un indice dei siti di Freenet con le categorie
Bookmarks.Defaults.Description.Linkageddon=Un grande indice, regolarmente aggiornato, che ti collega a tutto. Alcuni siti potrebbero non avere una descrizione accurata. Fai attenzione!
Bookmarks.Defaults.Description.ISF=Un piccolo indice Francese con le descrizioni
Bookmarks.Defaults.Description.FMS=Il freesite ufficiale di FMS, un sistema di forum resistente alle spam per Freenet
Bookmarks.Defaults.Description.Fniki=I siti di Freenet più vecchi
Bookmarks.Defaults.Description.Freemail=Il sito ufficiale di Freemail - email attraverso Freenet
Bookmarks.Defaults.Description.unofficialfmsguide=Tutorial e spiegazioni per il Freenet Message System
Bookmarks.Defaults.Description.PrivacyAndSoftware=Tecniche per proteggere la tua privacy quando si usa Freenet
Bookmarks.Defaults.Description.freenetprojectorg=Un mirror del sito ufficiale Freenet con novità e documentazione
Bookmarks.Defaults.Description.Publish=Guida semplice per pubblicare siti web su Freenet
Bookmarks.Defaults.Description.FreesiteHOWTO=Una spiegazione più dettagliata per pubblicare freesites
Bookmarks.Defaults.Description.Sone=Chat sociale veloce e anonima attraverso Freenet
Bookmarks.Defaults.Description.freenetdocwiki=Wiki riguardo Freenet (necessita di strumenti per l'editing)
Bookmarks.Defaults.Description.FSNG=Una guida illustrata su come impostare gli strumenti per il social networking
Bookmarks.Defaults.Description.jSite=Strumento per caricare i freesites (siti web di Freenet)
Bookmarks.Defaults.Description.Flog.Toad=Il flog di Toad
Bookmarks.Defaults.Description.Flog.Bombe=Il flog di Bombe
Bookmarks.Defaults.Description.Flog.Xor=Il flog del principale sviluppatore Freetalk & Web Of Trust
Bookmarks.Defaults.ShortDescription.Linkageddon=Link a tutti i siti Freenet, ordinati secondo l'aggiornamento più recente, alcuni sono molto offensivi, fate attenzione!
Bookmarks.Defaults.ShortDescription.AFK=I siti di Freenet ordinati per categoria per ricercare ciò di cui hai bisogno. (Per i più vecchi, utilizza Enzo)
Bookmarks.Defaults.ShortDescription.Enzo=I siti di Freenet ordinati per categoria per ricercare ciò di cui hai bisogno
Bookmarks.Defaults.ShortDescription.Gantros=I siti di Freenet ordinati per categoria per ricercare ciò di cui hai bisogno
Bookmarks.Defaults.ShortDescription.TUFI=I siti di Freenet più vecchi
Bookmarks.Defaults.ShortDescription.ISF=Indice dei siti Francesi
Bookmarks.Defaults.ShortDescription.FMS=I forum su Freenet
Bookmarks.Defaults.ShortDescription.Fniki=Una wiki vecchia a proposito di Freenet
Bookmarks.Defaults.ShortDescription.Freemail=Email attraverso Freenet
Bookmarks.Defaults.ShortDescription.unofficialfmsguide=La guida non ufficiale a FMS (Forums over Freenet)
Bookmarks.Defaults.ShortDescription.PrivacyAndSoftware=Le migliori pratiche per gli utenti Freenet
Bookmarks.Defaults.ShortDescription.freenetprojectorg=Il sito ufficiale del Progetto Freenet
Bookmarks.Defaults.ShortDescription.Publish=Come pubblicare siti web su Freenet
Bookmarks.Defaults.ShortDescription.FreesiteHOWTO=Un'altra guida per pubblicare un sito web su Freenet
Bookmarks.Defaults.ShortDescription.Sone=Chat sociale attraverso Freenet
Bookmarks.Defaults.ShortDescription.freenetdocwiki=Documentazione wiki su Freenet
Bookmarks.Defaults.ShortDescription.FSNG=Guida passo-passo su come impostare email, forum, chat, strumenti social ecc. su Freenet in modo anonimo. Fortemente raccomandata!
Bookmarks.Defaults.ShortDescription.jSite=Strumento essenziale per caricare siti web su Freenet
Bookmarks.Defaults.ShortDescription.Flog.Toad=Blog personale dello sviluppatore di Freenet in carica
Bookmarks.Defaults.ShortDescription.Flog.Bombe=Blog personale dello sviluppatore di Sone
Bookmarks.Defaults.ShortDescription.Flog.Xor=Blog dello sviluppatore di Freetalk
BooleanOption.parseError=Booleano non riconosciuto: ${val} - prova "vero o falso"
ChatForumsToadlet.title=Comunica con altri utenti su Freenet
ChatForumsToadlet.frost=${frost-freenet}Frost${/frost-freenet} (${frost-web}collegamento web${/frost-web}) - Il client originale per forum di discussione su Freenet. Sfortunatamente, Frost è vulnerabile agli attacchi "denial of service" o spam, ti raccomandiamo fortemente di usare un altro client. Come FMS, Frost non fa parte di Freenet, perciò dovrà essere installato e caricato dall'utente.
ChatForumsToadlet.fms=${fms}FMS${/fms} - Il Sistema Messaggi Freenet (FMS = Freenet Message System) è un altro client per forum, che è mantenuto attivamente e ha una comunità in crescita. Non fa parte di Freenet, perciò dovrà essere installato e caricato dell'utente.
ChatForumsToadlet.fsng=${fsng}Guida al Social Networking di Freenet${/fsng} - Questa guida non ufficiale può essere un ottimo mezzo per impostare questi e altri strumenti di comunicazione di Freenet.
ChatForumsToadlet.sone=${sone}Sone${/sone} - Un sistema di discussione centrato tra una persona e un seguace. Questo è un plugin per Freenet. Richiede il plugin WebOfTrust.
ChatForumsToadlet.content2=Il team di Freenet non scrive or recensisce Frost, FMS, o Sone, perciò non è possibile garantire la loro qualità. Ci sono molti altri plugin per Freenet e app (come le wiki) che chiunque può trovare navigando su Freenet.
CSSTokenizerFilter.deletedDisallowedString=Stringa non permessa eliminata
CSSTokenizerFilter.deletedUnmatchedChar=Ignorato char non corrispondente:
CSSTokenizerFilter.deletedUnofficialIdent=Eliminata ident ufficiosa
CSSTokenizerFilter.deletedUnofficialIdentWithURL=Eliminata ident ufficiosa con url
CSSTokenizerFilter.invalidURLContents=Contenuto dell'url() non valido
CSSTokenizerFilter.supplementalCharsNotSupported=CARATTERI UCS-4 OLTRE 0xFFFF NON SUPPORTATI!
CSSTokenizerFilter.unknownAtIdentifierLabel=@identifier sconosciuto:
ConfigToadlet.appliedFailureExceptions=Le modifiche alla configurazione sono state applicate con le seguenti eccezioni:
ConfigToadlet.appliedFailureTitle=Configurazione Non Applicata!
ConfigToadlet.appliedSuccess=Le modifiche alla configurazione sono state applicate.
ConfigToadlet.appliedTitle=Configurazione Applicata
ConfigToadlet.apply=Conferma
ConfigToadlet.confirmReset=Sei sicuro di voler resettare le impostazioni di questa pagina ai valori di default?
ConfigToadlet.confirmResetTitle=Resettare ai valori di default?
ConfigToadlet.console=Consolle
ConfigToadlet.false=falso
ConfigToadlet.fproxy=Interfaccia Web
ConfigToadlet.fullTitle=Configurazione del nodo Freenet
ConfigToadlet.logger=Log
ConfigToadlet.needRestartTitle=É necessario riavviare il nodo
ConfigToadlet.needRestart=Alcune configurazioni necessitano di un riavvio per attivarsi. Si prega di riavviare Freenet immediatamente.
ConfigToadlet.needRestartShort=Uno o più cambiamenti di configurazione richiedono il riavvio per poter essere attivati. Si prega di riavviare Freenet immediatamente.
ConfigToadlet.restartNode=Riavvia Adesso
ConfigToadlet.selectDirectory=Seleziona cartella
PageMaker.modeSimple=Interfaccia semplice
PageMaker.modeSimpleTooltip=Un'interfaccia semplice che può essere usata da ogni utente
PageMaker.modeAdvanced=Interfaccia avanzata
PageMaker.modeAdvancedTooltip=Un'interfaccia più complessa, utile soltanto agli utenti esperti
ConfigToadlet.node=Impostazioni principali
ConfigToadlet.node.install=Impostazioni di installazione
ConfigToadlet.node.load=Gestione del caricamento
ConfigToadlet.node.opennet=Nodo Opennet
ConfigToadlet.node.scheduler=Pianificatore della richiesta
ConfigToadlet.node.testnet=Nodo Testnet
ConfigToadlet.node.updater=Autoaggiornamento
ConfigToadlet.possibilitiesTitle=Continua
ConfigToadlet.resetToDefaults=Resettare ai valori di default
ConfigToadlet.returnToNodeConfig=Torna alla pagina della configurazione
ConfigToadlet.shortTitle=Configurazione
ConfigToadlet.ssl=SSL (necessario riavvio)
ConfigToadlet.title=Configurazione del Nodo Freenet
ConfigToadlet.title.node=Configurazione opzioni principali (es. uso di banda)
ConfigToadlet.title.node.install=Impostazioni di installazione (es. locazione del programma di sola lettura)
ConfigToadlet.title.node.load=Configurazione quantità di traffico attraverso il nodo
ConfigToadlet.title.node.opennet=Configurazione connessioni a nodi diversi da quelli Amici
ConfigToadlet.title.node.scheduler=Configurazione priorità richieste locali
ConfigToadlet.title.node.updater=Configurazione aggiornamenti automatici
ConfigToadlet.title.ssl=Configurazione SSL
ConfigToadlet.title.fcp=Configurazione Freenet Client Protocol (usato da applicazioni client per comunicare con Freenet)
ConfigToadlet.title.fproxy=Configurazione interfaccia web
ConfigToadlet.title.logger=Configurazione quantità di informazioni trattenute da Freenet allo scopo di identificare eventuali problemi
ConfigToadlet.title.console=Configurazione interfaccia consolle
ConfigToadlet.title.toadletsymlinker=Configurazione alias interfaccia web
ConfigToadlet.toadletsymlinker=Alias interfaccia web
ConfigToadlet.true=vero
ConfigToadlet.undo=Annullamento dei cambiamenti non salvati
ConfigToadlet.wrapper=Impostazioni di Java
ConfigurablePersister.doesNotExistCannotCreate=Il file non esiste e non può essere creato
ConfigurablePersister.existsCannotReadWrite=Il file esiste ma non può essere letto/scritto
ConnectivityToadlet.byIPTitle=Pacchetti per ${ip} per indirizzo IP - ${status} (lunghezza minima tunnel ${tunnelLength})
ConnectivityToadlet.title=Stato della connessione Internet
ConnectivityToadlet.connectivity=Stato della Connessione Internet (forward delle porte, ecc)
ConnectivityToadlet.connectivityTitle=Connessione Internet
ConnectivityToadlet.firstSendLeadTime=Da start a prima trasmissione
ConnectivityToadlet.firstReceiveLeadTime=Da online a prima ricezione
ConnectivityToadlet.localRemoteTitle=Locale/remoto
ConnectivityToadlet.addressTitle=Indirizzo
ConnectivityToadlet.sentReceivedTitle=Pacchetti ricevuti/trasmessi
ConnectivityToadlet.byPortTitle=Pacchetti per ${port} per porta - ${status} (lunghezza minima tunnel ${tunnelLength})
ConnectivityToadlet.local=LOCALE
ConnectivityToadlet.remote=REMOTO
ConnectivityToadlet.noreply=NON RISPONDE
ConnectivityToadlet.summaryTitle=Connettività
ConnectivityToadlet.status.DEFINITELY_PORT_FORWARDED=Porta inoltrata
ConnectivityToadlet.status.MAYBE_PORT_FORWARDED=Può darsi che la porta sia inoltrata
ConnectivityToadlet.status.MAYBE_NATED=Può darsi che si sia dietro un NAT
ConnectivityToadlet.status.DEFINITELY_NATED=Dietro un NAT
ConnectivityToadlet.status.DONT_KNOW=Stato sconosciuto
ConnectionsToadlet.nodeStatus.CONNECTED=CONNESSO
ConnectionsToadlet.nodeStatus.BACKED_OFF=RESPINTO
ConnectionsToadlet.nodeStatus.NO_LOAD_STATS=NESSUNO STATO DI CARICAMENTO
ConnectionsToadlet.nodeStatus.TOO_NEW=TROPPO RECENTE
ConnectionsToadlet.nodeStatus.TOO_OLD=TROPPO VECCHIO
ConnectionsToadlet.nodeStatus.DISCONNECTED=DISCONNESSO
ConnectionsToadlet.nodeStatus.NEVER_CONNECTED=MAI CONNESSO
ConnectionsToadlet.nodeStatus.DISABLED=DISABILITATO
ConnectionsToadlet.nodeStatus.LISTEN_ONLY=SOLO ASCOLTO
ConnectionsToadlet.nodeStatus.LISTENING=IN ASCOLTO
ConnectionsToadlet.nodeStatus.BURSTING=SCOPPIO
ConnectionsToadlet.nodeStatus.CLOCK_PROBLEM=CATTIVA SINCRONIZZAZIONE
ConnectionsToadlet.nodeStatus.CONNECTION_ERROR=ERRORE DI CONNESSIONE
ConnectionsToadlet.nodeStatus.DISCONNECTING=DISCONNESSIONE IN CORSO
ConnectionsToadlet.nodeStatus.UNKNOWN_STATUS=STATUS NON DETERMINATO
ConnectionsToadlet.nodeStatus.BUSY=OCCUPATO
ConnectionsToadlet.nodeStatus.ROUTING_DISABLED=NON INSTRADA TRAFFICO
ContentDataFilter.unknownCharset=La pagina che sta per essere visualizzata utilizza un formato di caratteri (charset) di tipo sconosciuto. Ciò rende impossibile filtrare la pagina, il che potrebbe a sua volta compromettere l'anonimato dell'utente.
ContentDataFilter.unknownCharsetTitle=Character set sconosciuto!
ContentDataFilter.warningUnknownCharsetTitle=Attenzione: charset sconosciuto (${charset})
ContentFilter.applicationPdfReadAdvice=Documento Adobe(R) PDF - MOLTO PERICOLOSO!
ContentFilter.applicationPdfWriteAdvice=Documento Adobe(R) PDF - MOLTO PERICOLOSO!
ContentFilter.audioMP3ReadAdvice=File MP3 musicale/audio - probabilmente non pericoloso ma può contenere metadati che potrebbero includere URL di contenuto non criptato; il filtro li rimuoverà
ContentFilter.audioMP3WriteAdvice=File MP3 musicale/audio - probabilmente non pericoloso ma può contenere metadati che potrebbero includere URL di contenuto non criptato; il filtro li rimuoverà
ContentFilter.EOFMessage=Fine del file inaspettata
ContentFilter.EOFDescription=Il filtro richiedeva più dati di quanti ne fossero disponibili dal file a cui stavate accedento. Il file potrebbe essere malformato o corrotto.
ContentFilter.imageBMPReadAdvice=Immagine BMP - file probabilmente non pericoloso
ContentFilter.imageBMPWriteAdvice=Immagine BMP - file probabilmente non pericoloso
ContentFilter.imageGifReadAdvice=Immagine GIF - probabilmente non pericoloso
ContentFilter.imageGifWriteAdvice=Immagine GIF - probabilmente non pericoloso ma sarebbe opportuno eliminare tutti i commenti
ContentFilter.imageIcoReadAdvice=File icona - probabilmente non pericoloso
ContentFilter.imageIcoWriteAdvice=File icona - probabilmente non pericoloso (ma potrebbe contenere altri dati)
ContentFilter.imageJpegReadAdvice=Immagine JPEG - probabilmente non pericoloso
ContentFilter.imageJpegWriteAdvice=Immagine JPEG - probabilmente non pericoloso ma può contenere dati EXIF
ContentFilter.imagePngReadAdvice=Immagine PNG - probabilmente non pericoloso
ContentFilter.imagePngWriteAdvice=Immagine PNG -  probabilmente non pericoloso ma sarebbe opportuno eliminare eventuali commenti e porzioni di testo
ContentFilter.textCssReadAdvice=CSS (cascading style sheet, di solito è usato in combinazione con HTML) - probabilmente non pericoloso se filtrato, ma il filtro non è del tipo "whitelist" quindi fare attenzione
ContentFilter.textCssWriteAdvice=CSS (cascading style sheet, solitamente usato con HTML) - può contenere metadati, controllare manualmente
ContentFilter.textHtmlReadAdvice=HTML - Non pericoloso se filtrato
ContentFilter.textHtmlWriteAdvice=HTML - può contenere metadati di tipo pericoloso, ecc; si consiglia di controllare manualmente
ContentFilter.textPlainReadAdvice=Formato testo semplice (plain text)- non è pericoloso a meno che il browser utilizzato non sia particolarmente "stupido" (per esempio Internet Explorer)
ContentFilter.textPlainWriteAdvice=Testo semplice (plain text) - non pericoloso a meno che l'utente vi includa informazioni compromettenti
ContentFilterToadlet.displayResultLabel=Mostra il risultato nel browser
ContentFilterToadlet.errorBadRequest=La richiesta non è valida.
ContentFilterToadlet.errorBadRequestTitle=Richiesta non valida
ContentFilterToadlet.errorMustSpecifyFilterOperation=Usa LEGGI per applicare il filtro di lettura. Usa SCRIVI per applicare il filtro di scrittura. Usa ENTRAMBI per applicarli entrambi.
ContentFilterToadlet.errorMustSpecifyFilterOperationTitle=Devi specificare che tipo di filtro vuoi applicare quando devi filtrare un file!
ContentFilterToadlet.errorMustSpecifyResultHandling=Usa MOSTRA per vedere il risultato nel browser. Usa SALVA per scaricare il risultato come file.
ContentFilterToadlet.errorMustSpecifyResultHandlingTitle=Devi specificare che tipo di filtro usare quando filtri un file!
ContentFilterToadlet.errorNoFileOrCannotRead=Freenet non è in grado di leggere il file "${file}".
ContentFilterToadlet.errorNoFileOrCannotReadTitle=Il file non esiste o non può essere letto
ContentFilterToadlet.errorNoFileSelected=Non hai selezionato un file da filtrare.
ContentFilterToadlet.errorNoFileSelectedTitle=Nessun file selezionato
ContentFilterToadlet.errorUnsafeContent=Il contenuto del filtro ha determinato che il file non è sicuro da mostrare.
ContentFilterToadlet.errorUnsafeContentTitle=Contenuto pericoloso
ContentFilterToadlet.filterFile=Testa il contenuto del filtro attraverso un file
ContentFilterToadlet.filterFileBrowseButton=Sfoglia i file
ContentFilterToadlet.filterFileBrowseLabel=Filtra un file dal disco
ContentFilterToadlet.filterFileFilterLabel=Filtra file
ContentFilterToadlet.filterFileUploadLabel=O filtra un file attraverso il browser
ContentFilterToadlet.mimeTypeLabel=Tratta il file come questo tipo MIME
ContentFilterToadlet.mimeTypeText=Lascia questo vuoto per permettere a Freenet di auto-determinare il tipo MIME.
ContentFilterToadlet.pageTitle=Testa il Filtro dei Contenuti
ContentFilterToadlet.saveResultLabel=Salva il risultato su disco
ContentFilterToadlet.selectFile=Filtro
ContentFilterToadlet.tryAgainFilterFilePage=${link}Prova ancora${/link} a filtrare un file.
DarknetAddRefToadlet.title=Connetti ad Amici
DarknetAddRefToadlet.explainBoxTitle=Perché connettersi ad amici che usano Freenet
DarknetAddRefToadlet.explainBox1=E' possibile migliorare la sicurezza di Freenet connettendosi ad amici. Per amici si intende persone che si conoscono e delle quali é possibile fidarsi, e che sono utenti Freenet. Gli amici possono essere persone conosciute su internet, ma si raccomanda di NON connettersi a dei perfetti sconosciuti poiché ciò non migliora la sicurezza e creerebbe problemi per la rete Freenet se molti lo facessero. Una volta aggiunti abbastanza amici in modo da garatire che almeno 5 di essi siano connessi in qualsiasi momento, è possibile impostare il livello di sicurezza in rete su ALTO, detto anche "modalità darknet". Ciò renderà molto più difficile anche il fatto stesso di determinare che un nodo Freenet giri all'indirizzo IP dell'utente, rendendo gli attacchi all'anonimato molto più difficili da eseguire. Freenet renderà criptate le connessioni con amici direttamente attraverso Internet, perciò aggiungete solo persone con cui potete già comunicare facilmente (famigliari, colleghi, amici reali, amici online).
DarknetAddRefToadlet.explainInstallerWindows=La versione aggiornata del programma di installazione per Windows disponibile in ${filename} oppure con un click ${get-windows}qui${/get-windows}.
DarknetAddRefToadlet.explainInstallerWindowsNotYet=Il download del programma di installazione per Windows non è riuscito. Click ${link}qui${/link} per provare a scaricarlo da Freenet.
DarknetAddRefToadlet.explainInstallerNonWindows=La versione aggiornata del programma di installazione non-Windows è disponibile in ${filename} oppure click ${get-nonwindows}qui${/get-nonwindows}. Si tratta di un file .jar che va aperto con Java. In alcuni casi è possibile lanciarlo con il doppio click, altrimenti usare il terminale con la riga di comando "java -jar ${shortfilename}".
DarknetAddRefToadlet.explainInstallerNonWindowsNotYet=Il download dell programma di installazione per non-Windows non è ancora riuscito ma è disponibile il download da Freenet, click ${link}qui${/link}. Il programma di installazione consiste in un file .jar che va aperto con Java. In alcuni casi è possibile lanciarlo on il doppio click, altrimenti aprire il terminale e usare la riga di comando "java - jar ${shortfilename}".
DarknetAddRefToadlet.explainBox2=Per poter connettersi ad un Amico bisogna scambiarsi le 'noderef' (referenza del nodo). Le noderef sono piccoli file che contengono le informazioni necessarie a connettere la copia di Freenet ("nodo Freenet") dal quale sono estratte, con il nodo a cui vengono aggiunte. Ognuno dei due utenti che vogliono connettere i loro nodi deve aggiungere al proprio nodo la noderef dell'altro, in modo che i due nodi possano connettersi. La noderef da mandare agli Amici è qui in basso.
DarknetConnectionsToadlet.addAnotherFriend=Aggiungi Amici
DarknetConnectionsToadlet.goFriendConnectionStatus=Si prega di aprire la pagina degli Amici e controllare che questa connessione sia attiva
DarknetConnectionsToadlet.activityTitle=Attività corrente
DarknetConnectionsToadlet.add=Aggiungi
DarknetConnectionsToadlet.addPeerTitle=Connettiti ad un Amico
DarknetConnectionsToadlet.addOpennetPeerTitle=Connettiti manualmente ad uno Sconosciuto (sconsigliato!)
DarknetConnectionsToadlet.alreadyInReferences=La referenza data è già presente in lista.
DarknetConnectionsToadlet.backedOff=Connesso ma respinto: Il nodo è connesso a questi peer ma ne viene respinto. Pertanto, il nodo non instrada traffico verso di essi.
DarknetConnectionsToadlet.backedOffShort=Respinti
DarknetConnectionsToadlet.bracketedMoreDetailed=(più dettagliato)
DarknetConnectionsToadlet.bursting=Non connesso e bursting: per un breve periodo, il nodo sta tentando di connettersi a questi peer perché l'utente li ha impostati su BurstOnly.
DarknetConnectionsToadlet.busy=Occupato: Questi peer sono connessi ma troppo occupati per poter accettare ulteriori richieste. Pertanto, il nodo non instrada richieste verso di essi.
DarknetConnectionsToadlet.busyShort=Occupato
DarknetConnectionsToadlet.cantFetchNoderefURL=Non è stato possibile richiamare la referenza di un nodo da ${url}. Riprovare.
DarknetConnectionsToadlet.cantParseTryAgain=Non è stato possibile interpretare it testo dato come referenza di un nodo: (${error}). Riprovare.
DarknetConnectionsToadlet.cantParseWrongEnding=Non è stato possibile interpretare le referenza: L'ultima riga dovrebbe contenere solo la parola End, esso contiene invece: ${end}
DarknetConnectionsToadlet.changeMyName=Cambiamo
DarknetConnectionsToadlet.changeTrustButton=Cambia la fiducia a
DarknetConnectionsToadlet.changeVisibilityButton=Cambia la visibilità in
DarknetConnectionsToadlet.clockProblem=L'orologio di sitema e l'orologio del nodo differiscono di oltre 24 ore.  Ciò potrebbe causare problemi con l'aggiornamento e con i client. La connessione è stata pertanto disabilitata.
DarknetConnectionsToadlet.clockProblemShort=Problema di sincronizzazione orologio
DarknetConnectionsToadlet.confirmRemoveNode=Conferma rimozione di "${name}" ? Rimuovere un nodo che è stato disconnesso per meno di una settimana non è consigliabile. L'azione più appropriata sarebbe di attendere ancora un po', considerando che potrebbe trattarsi di un problema temporaneo, e che ci sono utenti che non hanno la possibilità lasciar girare il proprio nodo giorno e notte.
DarknetConnectionsToadlet.confirmRemoveNodeTitle=Conferma
DarknetConnectionsToadlet.confirmRemoveNodeWarningTitle=Rimozione Nodo
DarknetConnectionsToadlet.connected=Connesso: Il nodo è connesso a questi peer:
DarknetConnectionsToadlet.connectedShort=Connessi
DarknetConnectionsToadlet.countTitle=Conteggio
DarknetConnectionsToadlet.darknetFnpPort=Darknet FNP: ${port}/UDP (usata per connessioni a peer affidabili. Forwardare se possibile)
DarknetConnectionsToadlet.disabled=Non connesso e disabilitato: L'utente ha configurato il nodo in maniera da non connettersi a questo peer.
DarknetConnectionsToadlet.disabledShort=Disabilitato
DarknetConnectionsToadlet.enterDescription=Inserisci descrizione:
DarknetConnectionsToadlet.foafReachableThroughTitle=Rintracciabile Attraverso
DarknetConnectionsToadlet.connError=Connessione fallita (il nodo ha un 'bug'?)
DarknetConnectionsToadlet.routingDisabled=Non sta instradando traffico: (la connessione tra nodo locale e remoto è attiva ma uno dei due rifiuta di instradare traffico)
DarknetConnectionsToadlet.routingDisabledShort=Non instrada traffico
DarknetConnectionsToadlet.noLoadStats=Non è possibile sapere quante richieste possono essere inviate, perciò non ne viene inviata nessuna
DarknetConnectionsToadlet.noLoadStatsShort=Nessuno stato di caricamento
DarknetConnectionsToadlet.myName=Nickname per questo nodo: ${name}
DarknetConnectionsToadlet.disconnectingShort=Disconnessione in corso
DarknetConnectionsToadlet.disconnecting=Disconnessione in corso (si sta procedendo alla rimozione del nodo; è necessario informare il nodo in questione e ciò potrebbe richiedere un po' di tempo)
DarknetConnectionsToadlet.connErrorShort=Errore di Connessione
DarknetConnectionsToadlet.failedToAddNodeInternalError=Impossibile interpretare il testo dato come referenza di un nodo Freenet. Si prega di riportare agli sviluppatori quanto segue:
DarknetConnectionsToadlet.failedToAddNodeInternalErrorTitle=Aggiunta nuovo nodo fallita: Errore interno.
DarknetConnectionsToadlet.failedToAddNodeTitle=Aggiunta Nodo Fallita
DarknetConnectionsToadlet.fcpDisabled=FCP non è abilitato (per applicazioni client di Freenet come Frost e Thaw)
DarknetConnectionsToadlet.fcpPort=FCP: ${port}/TCP (per le applicazioni client di Freenet, per esempio Frost e Thaw)
DarknetConnectionsToadlet.fileReference=Seleziona il file contenente la referenza:
DarknetConnectionsToadlet.forceRemove=Rimozione Forzata
DarknetConnectionsToadlet.fproxyDisabled=FProxy non è abilitato (questa interfaccia web)
DarknetConnectionsToadlet.fproxyPort=FProxy: ${port}/TCO (questa interfaccia web)
DarknetConnectionsToadlet.fullTitle=${counts} Amici (peer affidabili)
DarknetConnectionsToadlet.go=Vai
DarknetConnectionsToadlet.idleTime=Tempo trascorso da quando il nodo è connesso o da quando lo è stato per l'ultima volta
DarknetConnectionsToadlet.idleTimeTitle=Connesso / Inattivo
DarknetConnectionsToadlet.invalidSignature=Non è stato possibile verificare le firma elettronica della referenza (${error}).
DarknetConnectionsToadlet.ipAddress=Indirizzo del nodo in formato IP:Porta
DarknetConnectionsToadlet.ipAddressTitle=Indirizzo
DarknetConnectionsToadlet.listeningShort=Ascolto
DarknetConnectionsToadlet.locationTitle=Luogo
DarknetConnectionsToadlet.myFriends=I Miei Amici (peer affidabili aggiunti da me)
DarknetConnectionsToadlet.myReferenceHeader=${linkref}Referenza del Nodo${/linkref} (${linktext}testo${/linktext})
DarknetConnectionsToadlet.nameClickToMessage=Nome del nodo. Clicca sul nome per mandare un messaggio N2NTM (Node To Node Text Message) a questo peer
DarknetConnectionsToadlet.nameTitle=Nome
DarknetConnectionsToadlet.neverConnected=Mai Connesso. Questo peer non è mai stato connesso al nostro nodo.
DarknetConnectionsToadlet.neverConnectedShort=Mai connessi
DarknetConnectionsToadlet.noPeersWithHomepageLink=Freenet non può funzionare perché non sono ancora stati aggiunti dei peer ai quali collegarsi. Alla pagina ${link}node homepage${/link}, in alto, si può leggere come fare.
DarknetConnectionsToadlet.noRefOrURL=Non è stato possibile rilevare una referenza nodo o una URL. Si prega di riprovare.
DarknetConnectionsToadlet.nodePortsTitle=Porte utilizzate dal Nodo
DarknetConnectionsToadlet.notConnected=Non connesso: Finora non ci sono state connessioni ma il nodo cerca continuamente di connettersi
DarknetConnectionsToadlet.notConnectedShort=Disconnessi
DarknetConnectionsToadlet.noTrustLevelAddingFriendTitle=Devi impostare un livello di fiducia per il nodo del tuo amico
DarknetConnectionsToadlet.noTrustLevelAddingFriend=Devi impostare un livello di fiducia - BASSO, NORMALE o ALTO. Questo è semplicemente quanto ti fidi di questo amico. Livelli di fiducia superiori danno migliori prestazioni ma anche meno sicurezza se l'amico decide di attaccarti, per esempio tentare di scoprire cosa stai facendo su Freenet. Se il tuo amico è solo una conoscenza casuale, potresti volere impostare BASSO; se ti fidi di loro completamente dovresti impostare ALTO. Se sai che non si prendono cura del loro computer in modo appropriato e prendono virus costantemente, ecc. dovresti ridurlo un po' dato che potrebbero non essere loro quelli a cui ti stai connettendo ma qualcuno che è entrato nel loro computer!
DarknetConnectionsToadlet.noVisibilityLevelAddingFriendTitle=Devi impostare un livello di visibilità per il nodo del tuo amico
DarknetConnectionsToadlet.noVisibilityLevelAddingFriend=Devi impostare un livello di visibilità per il tuo amico - SÌ (gli altri tuoi amici possono vedersi, avendo ricevuto anche loro il SÌ), SOLO NOME (loro possono vedere il nome del peer e offrirgli di connettersi in caso si conoscano), NO (gli altri amici non possono vedere questo nodo). Rendendo i tuoi amici visibili gli uni agli altri migliorerai le performance e renderai più facile la connessione a Freenet e alle persone che conosci quando sei su Freenet.
DarknetConnectionsToadlet.opennetFnpPort=Opennet FNP: ${port}/UDP (usata per connessioni a peer non affidabili, cioè Sconosciuti. Forwardare se possibile)
DarknetConnectionsToadlet.pasteReference=Digita la referenza qui:
DarknetConnectionsToadlet.peersEnable=Abilita i peer selezionati
DarknetConnectionsToadlet.peersDisable=Disabilita i peer selezionati
DarknetConnectionsToadlet.peersSetBurstOnly=Sui peer selezionati, imposta BurstOnly (usare SOLO se si ha IP statico, se non ci si trova dietro NAT, né lo è il peer)
DarknetConnectionsToadlet.peersClearBurstOnly=Sui peer selezionati, disabilita  BurstOnly
DarknetConnectionsToadlet.peersSetListenOnly=Sui peer selezionati, posto ListenOnly (solo ascolto). Scelta sconsigliata.
DarknetConnectionsToadlet.peersClearListenOnly=Sui peer selezionati, disabilita ListenOnly
DarknetConnectionsToadlet.peersSetAllowLocal=Sui peer selezionati, imposta allowLocalAddresses (abilita indirizzi locali). Utile per connettersi ad altri nodi sulla stessa rete locale (LAN)
DarknetConnectionsToadlet.peersClearAllowLocal=Sui peer selezionati, rimuovi i'opzione 'abilita indirizzi locali' (allowLocalAddresses)
DarknetConnectionsToadlet.peersSetIgnoreSourcePort=Sui peer selezionati, imposta ignoreSourcePort (ignora porta sorgente). L'uso di questa opzione può essere utile se ci si trova dietro firewall aziendali molto limitanti, altrimenti sconsigliato.
DarknetConnectionsToadlet.peersClearIgnoreSourcePort=Sui peer selezionati, disabilita ignoreSourcePort
DarknetConnectionsToadlet.peersSetDontRoute=Sui peer selezionati, imposta dontRoute (queta opzione non dovrebbe essere usata se non da persone veramente esperte)
DarknetConnectionsToadlet.peersClearDontRoute=Sui peer selezionati, disabilita dontRoute
DarknetConnectionsToadlet.peerTrustTitle=Quanto ti fidi di questo amico?
DarknetConnectionsToadlet.peerTrustIntroduction=Maggiore è il livello di fiducia, più informazioni Freenet condividerà, ma questo ti rende anche più vulnerabile se il computer di questo amico viene confiscato o hackerato, o se è malintenzionato.
DarknetConnectionsToadlet.peerTrustExplain.LOW=Non mi fido del mio amico. Condividi il meno possibile. Prestazioni inferiori. Tieni presente che questo è sempre più sicuro che connettersi a degli sconosciuti in quasi tutti i casi.
DarknetConnectionsToadlet.peerTrustExplain.NORMAL=Mi fido un po' del mio amico. Condividi qualche informazione, ma prendi qualche precauzione. Di nuovo prestazioni moderate.
DarknetConnectionsToadlet.peerTrustExplain.HIGH=Mi fido del mio amico, e confido nella sua capacità di tenere sicuro il suo computer. Condividi quante più informazioni possibili per massimizzare le prestazioni.
DarknetConnectionsToadlet.peerTrust.LOW=BASSO
DarknetConnectionsToadlet.peerTrust.NORMAL=NORMALE
DarknetConnectionsToadlet.peerTrust.HIGH=ALTO
DarknetConnectionsToadlet.peerVisibilityTitle=Vuoi che gli altri amici possano vedere e si possano connettere a questo amico?
DarknetConnectionsToadlet.peerVisibilityIntroduction=Se permetti ai tuoi amici di vedere questo amico, e viceversa, questo migliorerà significativamente le performance. Comunque potresti non volere che gli altri amici sappiano di questo amico (ma ricorda che chiunque riesca a vedere la tua connessione internet potrebbe essere in grado di collegarsi a te). Lui/Lei può disabilitare l'opzione di essere visto/a dai tuoi amici.
DarknetConnectionsToadlet.peerVisibility.YES=SI
DarknetConnectionsToadlet.peerVisibility.NAME_ONLY=SOLO NOME
DarknetConnectionsToadlet.peerVisibilityExplain.NO=Non dire ai miei amici di questo amico, e non permettere loro di dire ai loro amici di me: loro sono un contatto segreto.
DarknetConnectionsToadlet.peerVisibilityExplain.YES=Dì agli altri amici di questo amico, e viceversa. Loro saranno in grado di connettersi anche se io sono offline, migliorando significativamente le performance.
DarknetConnectionsToadlet.privateNote=Un commento privato relativo a questo nodo
DarknetConnectionsToadlet.privateNoteTitle=Nota Privata
DarknetConnectionsToadlet.referenceCopyWarning=La referenza del nodo va copiata ${bold}SENZA VARIAZIONI${/bold}. Qualsiasi modifica lo renderà ${bold}inutilizzabile${/bold}.
DarknetConnectionsToadlet.remove=Elimina!
DarknetConnectionsToadlet.removePeers=Elimina peer selezionati
DarknetConnectionsToadlet.returnToAddAFriendPage=Riprova (ritorna alla pagina aggiungi un amico)
DarknetConnectionsToadlet.secondDegreeAlsoOurs=${count} i luoghi probabilmente anche i nostri stessi peer (in bold)
DarknetConnectionsToadlet.secondDegreeConnectionsCountTitle=${count} Connessioni di Secondo Livello
DarknetConnectionsToadlet.secondDegreeTrivialHiddenCount=${count} connessioni non sovrapposte potenzialmente nascoste
DarknetConnectionsToadlet.secondDegreeNonTrivialCount=${count} raggiungibile attraverso più di un peer
DarknetConnectionsToadlet.seedServers=Nodi attualmente usati come seednode.
DarknetConnectionsToadlet.seedServersShort=Seednode
DarknetConnectionsToadlet.seedClients=Nodi per i quali il nodo locale sta facendo da seednode.
DarknetConnectionsToadlet.seedClientsShort=Seeding per
DarknetConnectionsToadlet.selectAction=-- Seleziona azione --
DarknetConnectionsToadlet.sendMessageTitle=Invia Messaggio di Testo da Nodo a Nodo (N2NTM)
DarknetConnectionsToadlet.sendMessageToPeers=Manda messaggio ai peer selezionati
DarknetConnectionsToadlet.tmciDisabled=TMCI non è abilitato (semplice interfaccia a comandi testuali simile a telnet)
DarknetConnectionsToadlet.tmciPort=TMCI: ${port}/TCP (semplice interfaccia a comandi testuali simile a telnet)
DarknetConnectionsToadlet.tooNew=Connesso ma troppo recente: La versione obbligatoria minima di questo peer è maggiore della versione che stiamo utilizzando.
DarknetConnectionsToadlet.tooNewShort=Troppo recente
DarknetConnectionsToadlet.tooOldShort=Obsoleti
DarknetConnectionsToadlet.triedToAddSelf=Non è possibile aggiungere il proprio nodo ad una lista di peer remoti.
DarknetConnectionsToadlet.trustTitle=Livello di fiducia
DarknetConnectionsToadlet.unknownAddress=(indirizzo sconosciuto)
DarknetConnectionsToadlet.updateChangedPrivnotes=Aggiorna commenti
DarknetConnectionsToadlet.urlReference=Inserire qui la URL della referenza:
DarknetConnectionsToadlet.versionTitle=Versione
DarknetConnectionsToadlet.reportOfNodeAddition=Aggiunti alcuni Amici
DarknetConnectionsToadlet.returnToPrevPage=Torna alla pagina precedente
DarknetConnectionsToadlet.peerAdditionCode.OK=Aggiunto con successo
DarknetConnectionsToadlet.peerAdditionCode.TRY_TO_ADD_SELF=Tentativo di aggiungere sé stesso
DarknetConnectionsToadlet.peerAdditionCode.WRONG_ENCODING=Encoding sbagliato
DarknetConnectionsToadlet.peerAdditionCode.CANT_PARSE=Analisi non possibile
DarknetConnectionsToadlet.peerAdditionCode.INTERNAL_ERROR=Errore interno
DarknetConnectionsToadlet.peerAdditionCode.INVALID_SIGNATURE=Firma non valida
DarknetConnectionsToadlet.peerAdditionCode.ALREADY_IN_REFERENCE=Giá presente in referenza
DarknetConnectionsToadlet.resultName=Nome risultato
DarknetConnectionsToadlet.numOfResults=Numero risultati
DarknetConnectionsToadlet.visibilityTitle=Visibile agli amici?
DarknetConnectionsToadlet.visibilityMessageSimple=Questo amico è visibile agli altri amici? (Usiamo le impostazioni più stringenti per entrambi, vedi di più in impostazioni avanzate)
DarknetConnectionsToadlet.visibilityMessageAdvanced=Questo amico è visibile ad altri amici? (Usiamo le impostazioni più stringenti per entrambi, le loro tra parentesi)
DiskSpaceUserAlert.title=Libera dello spazio sul disco per piacere!
DiskSpaceUserAlert.notEnoughSpaceIn=Non c'è abbastanza spazio libero in ${where}
DownloadFeedUserAlert.delete=Cancellare
DownloadFeedUserAlert.fileDescription=Descrizione:
DownloadFeedUserAlert.title=${from} vi raccomanda un file
FileInsertWizardToadlet.filterFileLabel=Puoi usare il filtro in modalità avanzata per vedere come apparirà una volta caricato:
FileInsertWizardToadlet.insertCanonicalTitle=Inserite una chiave canonica
FileInsertWizardToadlet.insertCanonical=Questa produrrà sempre la stessa chiave per lo stesso file, quindi è conveniente per la condivisione dei file. Comunque, se i tipi cattivi possono predire quali file state per inserire, potrebbero essere capaci di usare ciò per tracciarvi molto più facilmente.
FileInsertWizardToadlet.insertCanonicalAdvanced=(Inserisce a CHK@, con le chiavi di criptazione derivate dal contenuto)
FileInsertWizardToadlet.insertIntro=Ci sono molti modi diversi di caricare (inserire) un file su Freenet dipendentemente dal fatto che voi abbiate o meno caricato il file precedentemente e da quali siano i vostri requisiti di sicurezza:
FileInsertWizardToadlet.insertRandomTitle=Inserite una chiave casuale, sicura
FileInsertWizardToadlet.insertRandom=Questa è molto più sicura della prima opzione, ma la chiave sarà differente ogni volta che voi o qualcun altro inserirà la chiave. Usate questa se siete la fonte originale di qualche dato sensibile.
FileInsertWizardToadlet.insertRandomAdvanced=(Inserisce un SSK casuale, con le chiavi di criptazione create casualmente)
FileInsertWizardToadlet.insertSpecificKeyTitle=Specificate una chiave
FileInsertWizardToadlet.insertSpecificKey=Se conoscete la chiave esatta che volete inserire, prego specificatela qui. Se è una SSK, USK o KSK, tutti i dati sotto di essa verranno criptati casualmente come con l'opzione "Inserire una chiave sicura, casuale".
FileInsertWizardToadlet.previewFilterFile=Filtra un file
FileInsertWizardToadlet.splitfileCryptoKeyLabel=(facoltativa) Chiave di criptazione dello splitfile (esadecimale)
FileInsertWizardToadlet.pageTitle=Carica un file su Freenet
FirstTimeWizardToadlet.homepageTitle=Configurazione di Freenet
FirstTimeWizardToadlet.autodetectedSuggestedLimit=(Scelta consigliata)
FirstTimeWizardToadlet.autoUpdate=Aggiornamenti Automatici
FirstTimeWizardToadlet.autoUpdateAutodeploy=Aggiorna Freenet automaticamente
FirstTimeWizardToadlet.autoUpdateNoAutodeploy=Notifica quando è disponibile una nuova versione
FirstTimeWizardToadlet.autoUpdateLong=E' possibile configurare Freenet per auto-aggiornarsi automaticamente. Scelte disponibili:
FirstTimeWizardToadlet.bandwidthCapPrompt=La tua connessione internet ha un limite di traffico dati mensile?
FirstTimeWizardToadlet.bandwidthLimitMonthlyTitle=Limite di traffico dati
FirstTimeWizardToadlet.bandwidthLimitMonthly=Freenet può essere configurato affinché non superi il limite di traffico dati. Quanto traffico dati vuoi che Freenet usi ogni mese? Sfortunatamente, Freenet potrebbe diventare molto lento affinché rientri nel limite stabilito. I limiti saranno settati assumendo che Freenet sia sempre online, perciò l'uso di banda potrebbe essere inferiore. Questi limiti possono essere modificati in qualsiasi momento attraverso la pagina ${bold}${coreSettings}${/bold}.
FirstTimeWizardToadlet.bandwidthLimitRateTitle=Andamento del limite di trasmissione
FirstTimeWizardToadlet.bandwidthConnectionHeader=Tipo di connessione
FirstTimeWizardToadlet.bandwidthDetected=Velocità rilevata (usane la metà)
FirstTimeWizardToadlet.bandwidthConnectionDialUp=Modem dial up (SCONSIGLIATO!)
FirstTimeWizardToadlet.bandwidthConnectionISDN=ISDN (raro)
FirstTimeWizardToadlet.bandwidthConnectionSlow256=256kbps semi-bandalarga
FirstTimeWizardToadlet.bandwidthConnectionSlow512=512kbps bandalarga lenta
FirstTimeWizardToadlet.bandwidthConnection2M=2 megabit
FirstTimeWizardToadlet.bandwidthConnection4M=4 megabit
FirstTimeWizardToadlet.bandwidthConnection6M=6 megabit (media ADSL 1)
FirstTimeWizardToadlet.bandwidthConnection8M=8 megabit (ADSL1 veloce)
FirstTimeWizardToadlet.bandwidthConnection12M=12 megabit (ADSL2 lenta)
FirstTimeWizardToadlet.bandwidthConnection20M=20 megabit (ADSL2 veloce, cavo veloce)
FirstTimeWizardToadlet.bandwidthConnection100M=100 megabit (fibra)
FirstTimeWizardToadlet.bandwidthCurrent=Limite di banda corrente
FirstTimeWizardToadlet.bandwidthCustom=Digita il limite di banda che desideri
FirstTimeWizardToadlet.bandwidthDownloadHeader=Limite di download
FirstTimeWizardToadlet.bandwidthMonthlyLow=Il limite mensile richiesto di ${requested} GB/mese è troppo basso. Con i limiti di banda impostati al minimo, Freenet può usare circa ${minimum} GB/mese, se rimane sempre online. Se Freenet non è sempre online allora possono essere impostati dei limiti più alti. Per usare i limiti più bassi, clicca su ${useMinimum}.
FirstTimeWizardToadlet.bandwidthMonthlyUseMinimum=Usa il Minimo
FirstTimeWizardToadlet.bandwidthUploadHeader=Limite di upload
FirstTimeWizardToadlet.bandwidthSelect=Seleziona
FirstTimeWizardToadlet.bandwidthMonthlyNetTransfer=Trasferimento mensile
FirstTimeWizardToadlet.bandwidthCouldNotParse=Impossibile analizzare il limite "${limit}", prova di nuovo.
FirstTimeWizardToadlet.bandwidthErrorSettingTitle=Errore nell'impostazione del Limite di Banda
FirstTimeWizardToadlet.browserWarningPageTitle=Consultivo per la sicurezza del Browser
FirstTimeWizardToadlet.browserWarningShort=É necessario l'utilizzo di un browser per uso esclusivo di Freenet (o un browser con la modalità privacy/incognito)!
FirstTimeWizardToadlet.browserWarningShortRelativelySafe=É possibile usare la modalità privacy o un browser differente per migliorare la sicure
FirstTimeWizardToadlet.browserWarningIncognitoShort=É in uso un browser provvisto di modalità 'incognito': bene!
FirstTimeWizardToadlet.browserWarning=Si consiglia ${bold}vivamente${/bold} di non usare lo stesso browser per internet e Freenet, a meno che non si usi la modalità incognito/privacy. Siti internet malevoli potrebbero usare un browser history attack per determinare quali siti ospitati su Freenet ("freesite") sono stati recentemente visitati, compromettendo l'anonimato dell'utente. Si prega pertanto di accedere all' interfaccia web di Freenet tramite un browser o almeno un profilo separato da quello usato per i normali siti web. Per esempio in Windows, l'opzione di navigazione con Freenet attraverso l'icona del coniglio bianco (nel system tray) aprirà automaticamente Google Chrome in modalità incognito se installata.
FirstTimeWizardToadlet.browserWarningMaybeSafe=Stai usando una versione recente del browser che dovrebbe essere relativamente sicura. Comunque verrà salvato ciò che guardi su Freenet nella sua cronologia. Potresti usare la modalità privacy/incognito per prevenire questo. La cronologia può anche essere cancellata manualmente, ma questo di solito lascia delle tracce.
FirstTimeWizardToadlet.browserWarningIncognito=É in uso un browser provvisto di supporto per la modalità privacy/incognito (controlla la barra del titolo). Ciò influisce positivamente sulla sicurezza. In generale, sarebbe opportuno usare sempre browser con modalità 'incognito' per Freenet. In caso contrario, almeno assicurarsi di usare due browser separati per Freenet e non-Freenet, o dei siti web (non-freenet) potrebbero rilevare dati sui siti Freenet visitati in precedenza.
FirstTimeWizardToadlet.browserWarningIncognitoMaybeSafe=Sembra che tu stia usando un browser recente in modalità privacy/incognito (controlla nella barra del titolo). Questo dovrebbe essere abbastanza sicuro. Con un browser più vecchio (precedente a Firefox 4), non usare lo stesso browser sia per la navigazione web normale che per Freenet, a meno che non sia in modalità privacy.
FirstTimeWizardToadlet.browserWarningFirefoxMightHaveClobberedTabs=Freenet ha tentato di avviare Firefox in modalità privacy. Questo dovrebbe impedire al browser di salvare la cronologia di ciò che stai guardando su Freenet. In alcune versioni, potrebbe essere necessario chiudere tutte le finestre già aperte. È possibile riaprirle andando nella voce del menù Strumenti e cliccando su Ferma Navigazione in Privato. É possibile verificare che Firefox sia in modalità privacy controllando la barra del titolo o della finestra. Se così non fosse è possibile aprirlo manualmente in modalità privacy e successivamente andando su ${url}, o usando un altro browser (o un altro profilo browser) solo per Freenet.
FirstTimeWizardToadlet.browserWarningOldFirefox=Stai usando una versione datata di Firefox (3 o inferiore). Firefox 4 o superiore ha un importante potenziamento per la privacy, l'aggiustamento del CSS history leak. Dovresti aggiornare il browser se possibile.
FirstTimeWizardToadlet.browserWarningOldFirefoxNewerHasPrivacyMode=Anche le più recenti versioni di Firefox supportano la modalità privacy, che può sempre essere utile.
FirstTimeWizardToadlet.browserWarningSuggestion=Microsoft Internet Explorer ha dei problemi nel rilevare il tipo di contenuto, ma la maggioranza degli altri browser funziona adeguatamente con Freenet. Tra i browser che sono stati collaudati con esito positivo vi sono Opera, Firefox, Safari e Lynx. Si consiglia di installare un browser dedicato per Freenet o creare un profilo nel browser esistente, copiare la URL dalla barra degli indirizzi ed aprirla nel nuovo browser.
FirstTimeWizardToadlet.browserWarningIncognitoSuggestion=Quasi tutti i browser tranne Microsoft Internet Explorer funzionano adeguatamente con Freenet. Per esempio Firefox, Opera, Safari, Chrome, Lynx hanno dimostrato di funzionare.
FirstTimeWizardToadlet.chooseNodeName=Il nome del nodo è obbligatorio!
FirstTimeWizardToadlet.chooseNodeNameLong=Digitare il nome del nodo nel campo sottostante (si raccomanda un nickname possibilmente con un indirizzo email). Questo affinché i tuoi amici (peer approvati, che hai aggiunto manualmente) possano raggiungere il tuo nodo con i loro. Questo non sarà visibile agli sconosciuti (peer non approvati aggiunti in automatico). Ricorda che qualsiasi amico o sconosciuto potrebbe identificarti attraverso il tuo IP, finché sei connesso con loro, ma non possono sapere altrettanto facilmente quello che stai guardando.
FirstTimeWizardToadlet.connectToStrangers=Connetti a sconosciuti?
FirstTimeWizardToadlet.connectToStrangersLong=In un mondo ideale, ogni utente Freenet si connetterebbe esclusivamente con nodi gestiti da persone fidàte. Questo è di gran lunga il sistema più sicuro, che rende molto difficile per un osservatore esterno determinare se un nodo stia o meno girando sul computer osservato. D'altra parte, non avendo a disposizione almeno cinque amici, parenti o conoscenti fidàti che già usano Freenet, ai quali connettersi, come soluzione alternativa è possibile lasciare che il nodo si connetta automaticamente a nodi gestiti da sconosciuti. Questa opzione può essere disattivata in qualsiasi momento.
FirstTimeWizardToadlet.enableOpennet=É possibile disattivare le connessioni con gli sconosciuti, appena avrai aggiunto abbastanza amici, anche se nel frattempo avrai condiviso informazioni con gli sconosciuti. Freenet è ancora in fase di sperimentazione, e non offriamo garanzie sulla sicurezza.
FirstTimeWizardToadlet.enableUPnP=Abilita Plug and Play Universale (UPnP). Da utilizzare se la home LAN comprende un router. Non utilizzare in caso di connessione diretta a ISP via block-ethernet, o in presenza di persone non affiabili sulla rete locale.
FirstTimeWizardToadlet.opennetYes=Desidero che il nodo trovi automaticamente degli sconosciuti ai quali connettersi.
FirstTimeWizardToadlet.opennetNo=Si, ho almeno 5 amici che usano Freenet e aggiungerò i loro dati alla pagina degli Amici.
FirstTimeWizardToadlet.bandwidthLimit=Limitazione banda
FirstTimeWizardToadlet.continue=Continua
FirstTimeWizardToadlet.currentPrefix=Dimensione attuale:
FirstTimeWizardToadlet.currentSpeed=Limite attuale:
FirstTimeWizardToadlet.datastoreSize=Dimensioni magazzino dati (datastore)
FirstTimeWizardToadlet.highNetworkThreatLevelWarning=${bold}ATTENZIONE${/bold}: Il livello di sicurezza in rete sta per essere impostato su ALTO. Ciò significa che il nodo resterà incapace di connettersi se non ${bold}vengono aggiunte connessioni ad Amici${/bold}. Gli Amici ai quali connettersi dovrebbero essere persone consciute e delle quali sia possibile fidarsi almeno parzialmente. Se non si conoscono  utenti Freenet, utilizzare il livello di sicurezza NORMALE che permette a Freenet di connettersi automaticamente. Aggiungere degli sconosciuti agli Amici influirebbe negativamente sulle prestazioni e non migliorerebbe la sicurezza. Inoltre, usando il livello di sicurezza ALTO Freenet risulterà più lento soprattutto se si hanno pochi Amici (ne occorrono almeno 5-10 per ottenere buone prestazioni).
FirstTimeWizardToadlet.highNetworkThreatLevelCheckbox=Conosco almeno una persona che già usa Freenet, e la aggiungerò nella pagina ${bold}${addAFriend}${/bold}.
FirstTimeWizardToadlet.isNetworkTrusted=La rete locale è affidabile?
FirstTimeWizardToadlet.isNetworkTrustedLong=La rete locale è affidabile? Rispondendo di si a questa domanda, tutti i servizi forniti dal nodo Freenet saranno pienamente accessibili da chiunque sul network suddetto. É possibile configurare un accesso più selettivo attraverso la pagina "configurazione" dopo aver completato questo wizard.
FirstTimeWizardToadlet.noNetworkIF=Non è stata trovata nessuna interfaccia di rete addizionale
FirstTimeWizardToadlet.noNetworkIFLong=Freenet non ha trovato altre interfacce di rete, quindi darà per scontato che l'utente si connetterà dal computer locale e solo da quello.
FirstTimeWizardToadlet.iDoTrust=Possiamo fidarci degli utenti connessi a ${interface} (${ip}) ?
FirstTimeWizardToadlet.memory.64M=64MB - Usare solo in caso di estrema necessità
FirstTimeWizardToadlet.memory.128M=128MB - Il minimo indispensabile
FirstTimeWizardToadlet.memory.192M=192MB - Default ragionevole
FirstTimeWizardToadlet.memory.256M=256MiB - per computer con almeno 1GiB di RAM
FirstTimeWizardToadlet.memory.512M=512MB - per computer con molta memoria RAM
FirstTimeWizardToadlet.memoryLimit=Utilizzo memoria
FirstTimeWizardToadlet.networkThreatLevelConfirmTitle.HIGH=ATTENZIONE: Dovete aggiungere degli amici manualmente o Freenet non si connetterà!
FirstTimeWizardToadlet.networkThreatLevelConfirmTitle.MAXIMUM=ATTENZIONE: Dovete aggiungere manualmente degli amici o Freenet non si connetterà!
FirstTimeWizardToadlet.networkThreatLevelIntroOpennet=Freenet si connetterà a sconosciuti, quindi la sicurezza sarà relativamente bassa. Potete aggiungere amici più tardi se volete. Quanto siete preoccupati riguardo ad attacchi da parte di persone che non conoscete?
FirstTimeWizardToadlet.networkThreatLevelIntroDarknet=Freenet si connetterà solo ai vostri amici, rendendo davvero difficile per chiunque tracciare il vostro utilizzo di Freenet. Quanto siete preoccupati al riguardo di seri, costosi attacchi da parte di persone che non conoscete?
FirstTimeWizardToadlet.networkThreatLevelHeaderOpennet=Protezione contro uno sconosciuto che vi attacchi su Internet (connessione a sconosciuti)
FirstTimeWizardToadlet.networkThreatLevelHeaderDarknet=Protezione contro uno sconosciuto che vi attacchi su Internet (connessione solo ad amici)
FirstTimeWizardToadlet.networkSecurityPageTitle=Configurazione della rete
FirstTimeWizardToadlet.opennetChoicePageTitle=A chi dovrebbe connettersi Freenet?
FirstTimeWizardToadlet.opennetChoiceTitle=A chi dovrebbe connettersi Freenet?
FirstTimeWizardToadlet.opennetChoiceIntroduction=Freenet è progettata per impedire che i vostri messaggi di chat, download, navigazione, ecc. siano riconducibili a voi. Freenet può fornirvi una forte protezione solo quando conoscete le persone a cui siete direttamente connessi.
FirstTimeWizardToadlet.opennetChoiceConnectFriends=Connettetevi solo ai vostri amici
FirstTimeWizardToadlet.opennetChoiceConnectStrangers=Connessione a sconosciuti
FirstTimeWizardToadlet.opennetChoiceConnectFriendsPRO=É molto difficile ricondurre a voi qualsiasi cosa su Freenet.
FirstTimeWizardToadlet.opennetChoiceConnectFriendsCON=Vi servono almeno ${minfriends} amici che usano Freenet.
FirstTimeWizardToadlet.opennetChoiceConnectStrangersPRO=Non c'è bisogno di conoscere nessuno che usi Freenet.
FirstTimeWizardToadlet.opennetChoiceConnectStrangersCON=É molto più semplice ricondurre i vostri messaggi, file, ecc. a voi.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetToggle=Freenet fornisce un anonimato ragionevole ed è veramente difficile da bloccare, SE: (toccate per vedere)
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetStupid=Non fate niente di stupido (ad es. usare il vostro vero nome, scrivere l'indirizzo di casa vostra in un'area di chat o parlare di persone che conoscete personalmente). Altre informazioni personali includono la scuola che hai frequentato, ma anche il tuo indirizzo IP, i numeri della tua porta Freenet, in alcuni casi i tuoi log e le statistiche con Freenet. Se riscontri problemi con Freenet, prova prima ad attivare una nuova identità, invece di chiedere subito aiuto.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetFriends=Vi connettete solo ai vostri amici.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetTrustworthy=I vostri amici sono degni di fiducia (ma gli sconosciuti sono sempre peggio degli amici).
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetNoSuspect=I possibili attaccanti non sanno o sospettano chi o dove siate: sanno solo che siete una particolare identità su Freenet.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetChangeID=Cambiate la vostra identità occasionalmente (esempio: sui forum).
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetSSK=Caricate sempre i file in modo sicuro. Freenet vi ricorderà come farlo.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetOS=I vostri amici tengono sicuri i loro computer.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetBigPriv=Siete parte di una grossa rete (per es. la Freenet principale che ottenete se abilitate la connessione a sconosciuti) o parte di una rete privata che gli attaccanti non conoscono.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetDistant=Non siete troppo vicini a sconosciuti. Se però i vostri amici si connettono a sconosciuti, potreste non essere al sicuro contro un attaccante potente. La maggior parte delle persone non si preoccupa troppo di questo, ma tutto ciò migliorerà fintantoché i tuoi amici si connettono con i loro amici e non con degli sconosciuti.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetBugs=Non c'è nessun bug orribile in Freenet. Ogni programma di dimensione ragionevole contiene bug. Speriamo che nessun bug serio che possa colpire il vostro anonimato sia rimasto in Freenet, ma non può essercene una prova definitiva. Siete stati avvertiti!
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetFoot2=Per adesso probabilmente vorreste connettervi a degli sconosciuti giusto per essere connessi. Comunque un attaccante determinato potrebbe essere in grado di ricondurre a voi i vostri upload/download/chat/ecc., perciò non fate questo se progettate di caricare contenuti pericolosi. Nel lungo termine speriamo che tutti si connettano solo ai loro amici dato che questo è molto più sicuro.
FirstTimeWizardToadlet.opennetChoicePro=Vantaggio
FirstTimeWizardToadlet.opennetChoiceCon=Svantaggio
FirstTimeWizardToadlet.friendsSecurityPageTitle=Impostazioni Sicurezza Amici
FirstTimeWizardToadlet.physicalSecurityPageTitle=Impostazioni Sicurezza Fisica
FirstTimeWizardToadlet.plugins=Plug-in
FirstTimeWizardToadlet.pluginsLong=I plug-in sono estensioni opzionali che aggiungono diverse funzionalità a Freenet, ma alcuni di essi possono presentare problemi di sicurezza per alcuni utenti (vedi sotto).
FirstTimeWizardToadlet.presetTitleLow=Connettiti a qualsiasi utente Freenet: (basso livello di sicurezza)
FirstTimeWizardToadlet.presetChooseLow=Scegli un basso livello di sicurezza
FirstTimeWizardToadlet.presetLow=Se vivi in un Paese abbastanza libero dove usare Freenet é legale, puoi scegliere questa opzione. É più sicuro dei tradizionali software P2P come BitTorrent o Gnutella, ma un malintenzionato con moderate risorse potrebbe tracciare le tue attività su Freenet e ricondurle a te. Se hai amici che usano Freenet, puoi aumentare la sicurezza aggiungendoli come Amici, e connettendoti solo con loro.
FirstTimeWizardToadlet.presetTitleHigh=Connettiti solo agli amici: (livello di sicurezza alto)
FirstTimeWizardToadlet.presetChooseHigh=Scegli un elevato livello di sicurezza
FirstTimeWizardToadlet.presetHigh=Se conosci molte persone a cui vuoi connetterti, questa impostazione ti permette di creare la tua darknet di Freenet per una sicurezza molto più avanzata. Se conosci solo poche persone questa opzione potrebbe non esserti così utile, ma se qualcuno di loro conosce altri, o ha un settaggio di sicurezza basso, puoi avere una rete molto ampia.
FirstTimeWizardToadlet.presetTitleNone=Settaggi dettagliati: (personalizzato)
FirstTimeWizardToadlet.presetNone=Se desideri un controllo più particolare, questa opzione ti permette di settare Freenet secondo le tue esigenze di privacy. Ci vorrà un po' più di tempo rispetto alle altre due opzioni.
FirstTimeWizardToadlet.presetChooseNone=Scegli un livello personalizzato di sicurezza
FirstTimeWizardToadlet.step1Title=Configurazione Automatica Freenet - Amici e Sconosciuti
FirstTimeWizardToadlet.step2Title=Inserire un nome per il nodo
FirstTimeWizardToadlet.step3Title=Limiti ampiezza di banda
FirstTimeWizardToadlet.step4Title=Dimensioni magazzino dati (datastore)
FirstTimeWizardToadlet.stepMiscTitle=Aggiornamenti e Plug-in
FirstTimeWizardToadlet.tenPercentDisk=(= 10% di spazio libero su disco)
FirstTimeWizardToadlet.fivePercentDisk=(= 5% di spazio libero su disco)
FirstTimeWizardToadlet.backToSecurityLevels=Torna al wizard senza configurare una password
FProxyToadlet.abortToHomepage=Interrompi e ritorna alla homepage di Freenet
FProxyToadlet.addFriendTitle=Aggiungi Amici
FProxyToadlet.addFriend=Connetti ad amici che usano Freenet per migliorare la sicurezza
FProxyToadlet.alertsTitle=Messaggi
FProxyToadlet.alerts=Messaggi dettagliati sullo stato del nodo e messaggi da parte di Amici
FProxyToadlet.backToFProxy=${link}Clicca qui${/link} per andare alla homepage di Freenet
FProxyToadlet.backToReferrer=${link}Clicca qui${/link} per tornare alla pagina referente.
FProxyToadlet.blocksDetail=Blocchi: ${fetched} / ${required} (totale ${total} falliti ${failed} falliti in modo permanente ${fatallyfailed})
FProxyToadlet.cantBindPort=Non è possibile abbinare FProxy a quella porta!
FProxyToadlet.categoryBrowsing=Navigazione
FProxyToadlet.categoryTitleBrowsing=Esplora Freenet
FProxyToadlet.categoryChat=Comunicazione
FProxyToadlet.categoryTitleChat=Comunicazione su Freenet attraverso i forum
FProxyToadlet.categoryStatus=Stato
FProxyToadlet.categoryTitleStatus=Informazioni sullo stato del nodo
FProxyToadlet.categoryQueue=Upload/Download File
FProxyToadlet.categoryTitleQueue=Upload e download
FProxyToadlet.categoryConfig=Configurazione
FProxyToadlet.categoryTitleConfig=Configurazione Freenet
FProxyToadlet.categoryFriends=Amici
FProxyToadlet.categoryTitleFriends=Aggiungi connessioni ad Amici per migliorare la sicurezza e le prestazioni di Freenet
FProxyToadlet.chatForumsTitle=Forum
FProxyToadlet.chatForums=Come usare forum di discussione per comunicare in modo anonimo con altri utenti Freenet
FProxyToadlet.config=configurazione nodo
FProxyToadlet.configTitle=Configurazione
FProxyToadlet.contentTypeLabel=Tipo di contenuto:
FProxyToadlet.dangerousContentTitle=Contenuto Potenzialmente Pericoloso
FProxyToadlet.dangerousRSS=Il file richiesto potrebbe essere RSS. Questo tipo di file non può essere filtrato da Freenet nel modo giusto, ed inoltre potrebbe contenere dei difetti (web-bugs) come immagini in-line ecc, che potrebbero esporre l'indirizzo IP del computer in uso ad eventuali siti-trappola e pertanto mettere a serio rischio l'anonimato dell'utente. Firefox 2.0 e Internet Explorer 7.0 aprono il file come RSS anche se la tipologia del contentuto (content type) è "${type}".
FProxyToadlet.dangerousRSSSubtitle=I feed RSS possono costituire un pericolo
FProxyToadlet.dangerousRSSTitle=Contentuto Potenzialmente Pericoloso (RSS)
FProxyToadlet.diagnostic=File di diagnosi da mandare agli sviluppatori
FProxyToadlet.diagnosticTitle=Diagnosi
FProxyToadlet.downloadInBackgroundToDiskButton=Scarica
FProxyToadlet.downloadInBackgroundToDisk=Scarica in background e conserva in ${dir}. Riceverai una notifica quando il download sarà completato, inoltre potrai seguire i progressi nella ${page}pagina dei download${/page}.
FProxyToadlet.downloadInBackgroundToTempSpaceButton=Richiama
FProxyToadlet.downloadInBackgroundToTempSpace=Scarica il file in background. Esso sarà accessibile alla ${page}pagina dei download${/page}, e andrà perso se si disinstalla Freenet, se si perde la password, o se si usa il bottone emergenza. Un messaggio di notifica apparirà al completamento del download.
FProxyToadlet.downloadToDiskSecurityWarning=${bold}Attenzione${/bold}: questo immagazzinerà il file non criptato sul vostro disco fisso, e potrebbe costituire un rischio di sicurezza se non state usando il criptaggio completo del disco.
FProxyToadlet.downloadsTitle=Download
FProxyToadlet.downloads=File in corso di download da Freenet
FProxyToadlet.errorIsFatal= Questo è un errore grave (fatal error). Riprovare probabilmente non risolverà il problema.
FProxyToadlet.errorWithReason=Errore: ${error}
FProxyToadlet.expectedKeyButGot=Invece di una chiave Freenet, è stato ricevuto:
FProxyToadlet.expectedMimeType=Tipo che ci si aspettava: ${mime}
FProxyToadlet.explanationTitle=Spiegazione
FProxyToadlet.fetchingPageTitle=È in corso il download di una pagina
FProxyToadlet.fetchingPageBox=Download della pagina richiesta in corso
FProxyToadlet.fetchingPageOptions=Opzioni disponibili
FProxyToadlet.fetchLargeFileAnywayAndDisplay=Apri comunque e mostra il file nel browser. Potrebbe richiedere del tempo e il file potrebbe essere pesante.
FProxyToadlet.fetchLargeFileAnywayAndDisplayButton=Visualizza
FProxyToadlet.fileInformationTitle=Informazioni file
FProxyToadlet.filenameLabel=File:
FProxyToadlet.filterFile=Avvia il file attraverso il filtro del contenuto
FProxyToadlet.filterFileTitle=Filtra un file
FProxyToadlet.filterData=Filtra i dati:
FProxyToadlet.filterDataMessage=Scegliete questo per eseguire le vostre richieste tramite il filtro dei contenuti. Il filtro tenterà di impedire che il vostro computer esegua qualunque cosa che potrebbe danneggiarlo, o infrangere il vostro anonimato. È fortemente consigliato mantenere questa opzione.
FProxyToadlet.friends=Connessioni a nodi gestiti da amici
FProxyToadlet.friendsTitle=Connessioni ad Amici
FProxyToadlet.goBack=Indietro
FProxyToadlet.goBackToPrev=Torna alla pagina precedente
FProxyToadlet.help=Aiuto
FProxyToadlet.insertFreesiteTitle=Aggiungi Freesite
FProxyToadlet.insertFreesite=Carica un sito web su Freenet in modo anonimo
FProxyToadlet.invalidKeyTitle=Chiave non valida
FProxyToadlet.invalidKeyWithReason=Chiave non valida: ${reason}
FProxyToadlet.largeFile=File di grosse dimensioni
FProxyToadlet.largeFileExplanationAndOptions=La chiave Freenet richiesta fa riferimento a un file di grosse dimensioni. I file così grandi di solito non possono essere mandati direttamente al browser perché il nodo avrebbe bisogno di troppo tempo per richiamarli. Le seguenti opzioni sono disponibili:
FProxyToadlet.mayChange= (può cambiare)
FProxyToadlet.mimeType=Tipo di contenuto: ${mime}
FProxyToadlet.notFoundTitle=Non Trovato
FProxyToadlet.openAsText=${link}Clicca qui${/link} per aprire il file come testo 'liscio' (plain text) . Questo non dovrebbe essere pericoloso ma la visualizzazione può risultare disturbata.
FProxyToadlet.openAsThawIndex=${link}Clicca qui${/link} per aprire un file con il browser di indici Thaw. (leggere l'avvertenza!)
FProxyToadlet.openForce=${link}Clicca qui${/link} per aprire il file come ${mime} senza filtrarlo (NON RACCOMANDATO: leggi l'avvertenza sopra!).
FProxyToadlet.openForceDisk=${link}Clicca qui${/link} per scaricare il file su disco.
FProxyToadlet.openRSSAsRSS=${link}Clicca qui${/link} per aprire il file come RSS (ciò ${bold}rappresenta un pericolo${/bold} se l'autore del sito è mal intenzionato, perché il filtraggio di RSS in Freenet non è ancora stato implementato).
FProxyToadlet.openRSSForce=${link}Clicca qui${/link} per aprire il file come ${mime} (ciò ${bold}può costituire un pericolo${/bold} se si usa IE7 o FF2).
FProxyToadlet.opennet=Gestisci connessioni non affidabili
FProxyToadlet.opennetTitle=Connessioni a Sconosciuti
FProxyToadlet.openWithKeyExplorer=${link}Cliccare qui${/link} per aprire la Freenet uri con key explorer
FProxyToadlet.openWithSiteExplorer=${link}Cliccare qui${/link} per aprire la Freenet uri con site explorer
FProxyToadlet.options=Opzioni disponibili:
FProxyToadlet.pathNotFound=Il percorso specificato non esiste.
FProxyToadlet.pathNotFoundTitle=Percorso non trovato
FProxyToadlet.plugins=Configurazione e gestione plugin
FProxyToadlet.pluginsTitle=Plugin
FProxyToadlet.progressCheckingStore=Ricerca del file o pagina nella cache locale in corso. Se la ricerca nella cache locale non produrrà risultati, si procederà al download da Freenet.
FProxyToadlet.lastRefresh=L'ultimo aggiornamento è stato {0} fà
FProxyToadlet.progressDownloading=Download da Freenet in corso. L'operazione potrebbe avere una durata compresa tra i pochi secondi ed alcuni minuti a seconda del numero di richieste per quella pagina o file: un file che viene molto richiesto diviene più facile e veloce da scaricare.
FProxyToadlet.progressNotFinalized=E' possibile che l'indicatore di progresso (progress bar) salti avanti e indietro a causa del numero insufficiente di blocchi scaricati finora che rende poco attendibili le informazioni relative alle dimensioni del file.
FProxyToadlet.progressOptionZero=E' possibile attendere che il download della pagina richiesta giunga a completamento. Questa pagina temporanea verrà aggiornata automaticamente ogni 2 secondi fino al completamento o fallimento del download. In alternativa:
FProxyToadlet.uploadsTitle=Upload
FProxyToadlet.uploads=File in corso di upload su Freenet
FProxyToadlet.uploadFileWizardTitle=Carica un file
FProxyToadlet.uploadFileWizard=Carica un file su Freenet
FProxyToadlet.retryNow=Riprova
FProxyToadlet.seclevelsTitle=Livelli di Sicurezza
FProxyToadlet.seclevels=Configurazione livelli di sicurezza Freenet
FProxyToadlet.sizeLabel=Dimensioni:
FProxyToadlet.sizeUnknown=Dimensioni: sconosciute
FProxyToadlet.stats=Mostra statistiche
FProxyToadlet.statsTitle=Statistiche
FProxyToadlet.timeElapsedLabel=Tempo trascorso:
FProxyToadlet.unableToRetrieve=Non è stato possibile richiamare questo file.
FProxyToadlet.unableToSafelyDisplay=Freenet non può garantire che questo file sia sicuro: potrebbe portare il tuo browser a dare via il tuo indirizzo IP e compromettere il tuo anonimato!
FProxyToadlet.unknownMIMEType=Tipo di contenuto: sconosciuto
FProxyToadlet.welcome=Esplora e cerca Freesite, siti web ospitati anonimamente su Freenet
FProxyToadlet.welcomeTitle=Esplora Freenet
FProxyToadlet.imageinitializing=Inizializzando
FcpServer.allowedHosts=Host abilitati (Leggere l'avvertenza)
FcpServer.allowedHostsFullAccess=Host ai quali è consentito accesso pieno
FcpServer.allowedHostsFullAccessLong=Indirizzi IP ai quali è consentito pieno accesso al nodo. I client su questi IP possono riavviare il nodo, riconfigurarlo ecc. Attenzione: a TUTTI i client è consentito di fare I/O diretto sul disco!
FcpServer.allowedHostsLong=Indirizzi IP ai quali è consentito connettersi al server FCP. Può essere una lista di IP singoli separati da virgole e indirizzi IP in formato CIDR come 192.168.0.0/24. AVVERTENZA! Chiunque abbia accesso a FCP potrà caricare su Freenet  qualsiasi file al quale il nodo abbia accesso e scaricare su disco qualsiasi file da Freenet (i file esistenti non verranno sovrascritti).
FcpServer.assumeDownloadDDAIsAllowed=Presumi che DDA in download sia permesso?
FcpServer.assumeDownloadDDAIsAllowedLong=Presumere che DDA in download sia permesso? Se impostato su 'falso' sarà necessaria una TestDDARequest prima di ogni accesso DDA.
FcpServer.assumeUploadDDAIsAllowed=Presumi che DDA in upload sia permesso?
FcpServer.assumeUploadDDAIsAllowedLong=Presumere che DDA in upload sia permesso? Se impostato su 'falso', sarà necessaria una TestDDARequest prima di ogni accesso DDA.
FcpServer.bindTo=Indirizzo IP del servizio
FcpServer.bindToLong=Indirizzo IP del server FCP.
FcpServer.cannotStartOrStopOnTheFly=Non è possibile arrestare il server FCP "al volo"
FcpServer.enablePersistentDownload=Abilita download persistenti?
FcpServer.enablePersistentDownloadLong=Abilita Persistence=forever (persistenza illimitata) per le richieste FCP. Abilitando questa opzione si permette alle richieste di persistere attraverso il riavvio del nodo: tali richieste devono essere scritte sul disco rigido e questo in alcuni casi particolari può costituire un problema di sicurezza.
FcpServer.isEnabled=Abilita FCP?
FcpServer.isEnabledLong=Abilita il Protocollo Freenet Client (FCP)
FcpServer.portNumber=Numero della porta FCP
FcpServer.portNumberLong=Numero della porta FCP.
FcpServer.ssl=Abilita SSL?
FcpServer.sslLong=Abilita SSL sul server FCP. Sarà necessario disporre di 'Java Cryptography Extension (JCE) Unlimited Strenght Jurisdiction Policy Files' per funzionare.
FcpServer.maxMessageQueueLength=Numero massimo di messaggi FCP accodati per connessione
FcpServer.neverDropAMessage=Non scartare mai un messaggio FCP?
FcpServer.neverDropAMessageLong=Abilita questa per mettere in cache tutti i messaggi per qualsiasi connessione FCP per sempre anche se provoca l'esaurimento della memoria per il nodo. Non una buona idea ma utile per il debug in certi casi.
FetchException.longError.10=File non in archivio
FetchException.longError.11=Troppe componenti di percorso. Prova a eliminarne uno
FetchException.longError.12=Errore interno relativo ai file temporanei: potrebbe trattarsi di esaurimento dello spazio libero su disco rigido o di un problema relativo a permessi ed autorizzazioni?
FetchException.longError.13=Dati non trovati
FetchException.longError.14=Percorso non trovato: non è stato possibile trovare un numero di nodi sufficiente ad essere certi che i dati non esistono
FetchException.longError.15=Un nodo è stato sovraccaricato o è uscito fuori tempo massimo
FetchException.longError.16=Troppi redirects - loop?
FetchException.longError.17=Errore interno, probabilmente un bug
FetchException.longError.18=Il file è stato trovato ma è andato perso durante la ricezione
FetchException.longError.19=Errore splitfile
FetchException.longError.1=Troppi livelli di recursione negli archivi
FetchException.longError.20=URI non valida
FetchException.longError.21=Troppo grande
FetchException.longError.22=Volume dei metadati troppo grande
FetchException.longError.23=Troppi blocchi per segmento
FetchException.longError.25=Annullato
FetchException.longError.26=Archivio riavviato
FetchException.longError.27=Redirezione permanente: usare la nuova URI
FetchException.longError.28=Non è stato possibile raccogliere dati in quantità sufficiente; dati parziali sono stati richiamati ma il redirect potrebbe puntare su località non valide.
FetchException.longError.29=Tipo di contenuto non valido: chiave non presente in lista di contenuti permessi fornita dal client.
FetchException.longError.2=Il nodo non sa cosa fare dello splitfile
FetchException.longError.30=La richiesta è stata terminata da un nodo perchè esso aveva da poco ricevuto un'altra richiesta per la stessa chiave e quella richiesta non era andata a buon fine
FetchException.longError.31=La pagina (o il file) sembra essere corrotta, e potrebbe essere pericolosa; non dovresti aprire questa pagina a meno che tu non sappia cosa stai facendo. Normalmente Freenet può filtrare le pagine di questo tipo, ma questa pagina è così corrotta che non siamo in grado di renderla sicura. Se la apri comunque, non sarà filtrata, e potrà dare via il tuo indirizzo IP.
FetchException.longError.32=I dati sono di un tipo sconosciuto, il che potrebbe essere pericoloso
FetchException.longError.33=I dati sono di un tipo conosciuto per essere pericoloso, quindi il filtro ha fermato la richiesta
FetchException.longError.34=Gli hash nei metadati non corrispondono ai dati correnti. I dati potrebbero essere stati corrotti durante il download, o potrebbero essere stati rovinati mentre venivano inseriti per esempio se il nodo inserente era rovinato o i dati sono cambiati sul disco a metà inserimento.
FetchException.longError.35=La decodifica splitfile ha prodotto un blocco di dati che non era nella lista originaria delle chiavi. È probabile che l'inserimento sia stato corrotto, ma è possibile che questo sia un bug o un fallimento hardware sul vostro computer.
FetchException.longError.36=Il file ritiene di avere un tipo sicuro MIME, ma viene scaricato nell'Hard Disk con un file avente estensione non compatibile con quel tipo. Per esempio, "virus.exe", ritenendo di essere un semplice file di testo, porterebbe a questo tipo di errore. Questo è semplicemente un nome sbagliato dato a un file, ma potrebbe essere un file malevolo che tenta di ingannare il filtro.
FetchException.longError.3=Metadati non utilizzabili
FetchException.longError.4=Non è stato possibile interpretare i metadati.
FetchException.longError.5=Fallimento durante l'estrazione di file da un archivio
FetchException.longError.6=Non è stato possibile decodificare un blocco
FetchException.longError.7=Metadati divisi in troppi livelli
FetchException.longError.8=La richiesta è stata riavviata troppe volte a causa di cambiamenti negli archivi
FetchException.longError.9=Troppe redirezioni (troppa ricorsività)
FetchException.shortError.10=Non in archivio
FetchException.shortError.11=Troppe componenti nel percorso
FetchException.shortError.12=Errore nei file temporanei
FetchException.shortError.13=Dati non trovati
FetchException.shortError.14=Percorso non trovato
FetchException.shortError.15=Timeout o sovraccarico
FetchException.shortError.16=Troppi redirects
FetchException.shortError.17=Errore interno
FetchException.shortError.18=Trasferimento fallito
FetchException.shortError.19=Errore splitfile
FetchException.shortError.1=Ricorsione archivio troppo profonda
FetchException.shortError.20=URI non valida
FetchException.shortError.21=Troppo grande
FetchException.shortError.22=Volume metadati eccessivo
FetchException.shortError.23=Troppi blocchi per segmento
FetchException.shortError.25=Annullato da caller
FetchException.shortError.26=Archivio riavviato
FetchException.shortError.27=Nuova URI
FetchException.shortError.28=Non tutti i dati sono stati trovati
FetchException.shortError.29=Errore: MIME type sbagliato
FetchException.shortError.2=Splitfile metadati sconosciuto
FetchException.shortError.30=Non è stato possibile trovare i dati richiesti (fallimento recente)
FetchException.shortError.31=Igienizzazione del contenuto non riuscita
FetchException.shortError.32=Il filtro dei contenuti ha incontrato un tipo sconosciuto
FetchException.shortError.33=Il filtro dei contenuti ha trovato un tipo pericoloso
FetchException.shortError.34=Il contenuto non corrisponde agli hash nei metadati
FetchException.shortError.35=Errore di decodifica dello splitfile
FetchException.shortError.36=Il nome del file non è del tipo MIME per filtrare i download nell'Hard Disk
FetchException.shortError.37=Non c'è abbastanza spazio su disco
FetchException.shortError.3=Metadati sconosciuti
FetchException.shortError.4=Metadati non validi
FetchException.shortError.5=Fallimento archivio
FetchException.shortError.6=Errore di decodificazione blocco
FetchException.shortError.7=Troppi livelli di metadati
FetchException.shortError.8=Troppi riavvii di archivio
FetchException.shortError.9=Troppa ricorsione
FileOffer.askUserTitle=Trasferimento file diretto.
FileOffer.offeredFileHeader=Il nodo ${name} offre il file:
FileOffer.offeredFileShort=Il peer ${node} ha inviato il file ${filename}.
FileOffer.fileSavedToLabel=Salva in:
FileOffer.senderLabel=Mittente:
FileOffer.commentLabel=Commenti:
FileOffer.mimeLabel=Tipo di contenuto:
FileOffer.sizeLabel=Dimensioni:
FileOffer.acceptTransferButton=Accetta Trasferimento
FileOffer.rejectTransferButton=Rifiuta trasferimento
FileOffer.failedReceiveHeader=Non è stato possibile completare il trasferimento del file ${filename} da ${node}.
FileOffer.failedReceiveTitle=Trasferimento fallito
FileOffer.failedReceiveShort=Trasferimento di ${filename} da ${node} fallito.
FileOffer.succeededReceiveTitle=Trasferimento file completato
FileOffer.succeededReceiveHeader=Il trasferimento del file ${filename} da ${node} è stato completato.
FileOffer.succeededReceiveShort=${filename} è stato ricevuto da ${node}.
GIFFilter.invalidHeader=Il file non contiene un header GIF valido.
GIFFilter.invalidHeaderTitle=Header non valido
GIFFilter.notGif=Il file che si sta cercando di richiamare non è una GIF. Potrebbe trattarsi di un file in un altro formato, ed il browser potrebbe fare qualcosa di pericoloso a cause della confusione generata dalla mancata corrispondenza; il file è stato pertanto bloccato.
GenericReadFilterCallback.bogusBaseHref=Base href non accettabike
GenericReadFilterCallback.couldNotParseAbsoluteFreenetURI=Impossibile analizzare come una URI Freenet assoluta
GenericReadFilterCallback.couldNotParseFormURIWithError=Il filtro non è riuscito ad analizzare il form della URI: ${error}
GenericReadFilterCallback.couldNotParseRelativeFreenetURI=Impossibile analizzare come una URI Freenet relativa.
GenericReadFilterCallback.couldNotParseURIWithError=Il filtro non ha potuto analizzare la URI: ${error}
GenericReadFilterCallback.deletedURI=URI non valido o pericoloso cancella
GenericReadFilterCallback.invalidFormURI=URI in formato non valido: punta a una risorsa esterna
GenericReadFilterCallback.invalidFormURIAttemptToEscape=Tentativo di evadere la struttura della directory
GenericReadFilterCallback.malformedAbsoluteURL=URL (assoluto) malformato: ${error}
GenericReadFilterCallback.malformedRelativeURL=URL (relativa) malformata: ${error}
GenericReadFilterCallback.protocolNotEscaped=Non è un protocollo fuoriuscito: ${protocol}
HTMLFilter.couldNotParseStyle=Non è stato possibile abbinare lo stile dell'input
HTMLFilter.deletedUnknownStyle=stile sconosciuto eliminato
HTMLFilter.failedToParseLabel=Pagina web corrotta o malevola (impossibile filtrare la pagina)!
HTMLFilter.invalidMetaType=Tipo di contenuto non valido nella tag meta, formato HTML non conosciuto.
HTMLFilter.metaOutsideHead=Tag <meta> esterna a <head>. Questo non è permesso perché non è valido e presumendo che non accada si velocizza la il rilevamento del set dei caratteri.
HTMLFilter.multipleCharsetsInMeta=Dichiarazioni <meta> del set dei caratteri multiple. Questo fà confusione, non è valido, non è sicuro e non è permesso.
HTMLFilter.textBeforeHTML=Documento HTML non valido: Testo prima della tag <html>. Permettiamo solo documenti HTML validi e non frammenti perché ciò funziona per un filtraggio più affidabile (particolarmente evitando le ambiguità del set di caratteri).
HTMLFilter.tooManyNestedStyleOrScriptTags=Troppi tag 'style' annidati e/o troppi tag di scripting: analisi ambigua o non valida
HTMLFilter.tooManyNestedStyleOrScriptTagsLong=Troppi tag </style> annidati - analisi ambigua o non valida. Non è possibile filtrare in modo affidabile quindi i tag interni sono stai rimossi: questo può causare al browser qualche inconveniente nella visuallizzazione
HTMLFilter.unknownTag=tag sconosciuto ${tag}
HTMLFilter.wrongCharsetInMeta=Un tag meta indica il set di caratteri sbagliato
InsertContext.CompatibilityMode.COMPAT_CURRENT=Corrente (ultima, più efficiente)
InsertContext.CompatibilityMode.COMPAT_UNKNOWN=Sconosciuto
InsertContext.CompatibilityMode.COMPAT_1250_EXACT=Pre-1250 (esatto)
InsertContext.CompatibilityMode.COMPAT_1250=Pre-1250 (con divisione di parità)
InsertFreesiteToadlet.title=Upload freesite
InsertFreesiteToadlet.content1=Siti web possono essere caricati ("inseriti") su Freenet in modo anonimo. Una volta caricato, il sito resta su Freenet finché ci sono utenti che vi accedono almeno occasionalmente, è distribuito sulla rete, non è dipendente dal computer che lo ha generato, e non dovrebbe essere possibile rintracciarne l'autore.
InsertFreesiteToadlet.contentFlogHelper=Se vuoi creare un semplice blog, ti raccomandiamo di usare FlogHelper. Puoi caricarlo nella ${plugins}pagina dei plug-in${/plugins}, e usarlo dal menù.
InsertFreesiteToadlet.content3=Una volta scaricato jSite e costruito un sito web in HTML, usando un editor come KompoZer (gratuito), seguire le seguenti istruzioni pubblicate su Freenet:
InsertFreesiteToadlet.contentThingamablog=In alternativa, Thingamablog è un generatore di blog dall'interfaccia semplice ed intuitiva; la versione compatibile con Freenet è disponibile sia ${thingamablog} sul web${/thingamablog} che ${thingamablog-freenet} su Freenet ${/thingamablog-freenet}.
InsertFreesiteToadlet.publishExplanation=Istruzioni rapide su come inserire freesite
InsertFreesiteToadlet.freesiteHowtoExplanation=Istruzioni su come inserire un freesite in una versione più dettagliata
IPDetectorPluginManager.direct=Il computer appare connesso ad internet direttamente. Freenet dovrebbe riuscire a connettersi con qualsiasi nodo.
IPDetectorPluginManager.directTitle=Rilevata connessione diretta a Internet
IPDetectorPluginManager.fullCone=La connessione a Internet sembra avvenire attraverso una "full cone" NAT. Il nodo dovrebbe riuscire connettersi con qualunque altro nodo Freenet.
IPDetectorPluginManager.fullConeTitle=Full cone NAT rilevata
IPDetectorPluginManager.noConnectivity=La connessione Internet non appare provvista di supporto UDP. A meno che non si tratti di un rilevamento erroneo, non è probabile che Freenet possa funzionare al momento.
IPDetectorPluginManager.noConnectivityTitle=Mancanza di connettività UDP
IPDetectorPluginManager.noConnectivityshort=Gravi problemi di connessione: Nessuna connettività UDP, Freenet non può funzionare!
IPDetectorPluginManager.portRestricted=La connessione a Internet sembra avvenire attraverso una NAT a porte ristrette (router). Il nodo potrà connettersi a quasi tutti gli altri nodi ma non a quelli dietro NAT simmetrica.
IPDetectorPluginManager.portRestrictedTitle=Port restricted cone NAT rilevata
IPDetectorPluginManager.restricted=La connessione a Internet sembra avvenire attraverso una "restricted cone" NAT (router). Dovrebbe essere comunque possibile connettersi alla maggior parte dei nodi Freenet.
IPDetectorPluginManager.restrictedTitle=È stata rilevata una restricted cone NAT
IPDetectorPluginManager.suggestForwardPort= Potrebbe essere necessario configurare  manualmente il 'port forwarding'  per la porta UDP numero ${port}. Vedi: http://wiki.freenetproject.org/FirewallAndRouterIssues .
IPDetectorPluginManager.suggestForwardTwoPorts= Sarebbe opportuno configurare manualmente il port forward sul router per le porte ${port1} e ${port2} (UDP). vedi http://wiki.freenetproject.org/FirewallAndRouterIssues .
IPDetectorPluginManager.suggestForwardPortWithLink= Potrebbe essere necessario ${link}configurare il port forwarding${/link} (porta UDP numero ${port}) manualmente (oppure ciò è già stato fatto: Freenet può avere delle difficoltà in questo tipo di rilevazione).
IPDetectorPluginManager.suggestForwardTwoPortsWithLink= Potrebbe essere necessario configurare manualmente ${link}il forward delle porte${/link} ${port1} e ${port2} UDP. (questo messaggio può in alcuni casi continuare ad apparire per qualche tempo anche dopo aver configurato il forward).
IPDetectorPluginManager.symmetric=Dai rilevamenti appare che il nodo potrebbe trovarsi dietro una NAT simmetrica o un firewall. Freenet potrà connettersi soltanto ad utenti connessi ad internet direttamente o dietro restricted cone NAT.
IPDetectorPluginManager.symmetricTitle=Rilevato firewall simmetrico
IPDetectorPluginManager.seriousConnectionProblems=Gravi problemi di connessione:
IPDetectorPluginManager.connectionProblems=Problemi di connessione:
IPDetectorPluginManager.forwardPortShortMaybeForwarded=Si prega di configurare il forward della porta ${port} UDP (questo potrebbe essere già stato fatto, ma non ancora rilevato)
IPDetectorPluginManager.forwardPortShortNotForwarded=Si prega di configurare il forward per la porta ${port} UDP .
IPDetectorPluginManager.forwardTwoPortsShortMaybeForwarded=Si prega di configurare il forward  delle porte ${port1} e ${port2} UDP (potrebbe essere già stato fatto).
IPDetectorPluginManager.forwardTwoPortsShortNotForwarded=Si prega di configurare il forward per le porte ${port1} e ${port2} UDP.
IPDetectorPluginManager.forwardPortMaybeForwarded=Il nodo sembra trovarsi dietro una NAT (per i dettagli vedi menu Stato, pagina Connessione Internet). Se possibile, configurare il forward per la porta ${port} UDP (non TCP) allo scopo di migliorare la connettività. È possibile comunque che ciò sia già stato fatto: occorre un po' di tempo perché Freenet rilevi il port forward. Fare clic ${link}qui${/link} per ulteriori informazioni.
IPDetectorPluginManager.forwardPortNotForwarded=Il nodo sembra trovarsi dietro una NAT (per i dettagli vedi menu Stato, pagina Connessione Internet). Se possibile, configurare il forward per le porte ${port1} e ${port2} UDP (non TCP) allo scopo di migliorare la connettività. Al momento pare che il port forward non sia stato configurato, ma Freenet non è in grado di determinarlo con certezza. Fare clic ${link}qui${/link} per ulteriori informazioni. Il tempo necessario perché Freenet rilevi il forward delle porte può arrivare fino a 24 ore.
IPDetectorPluginManager.maybeAlreadyForwarded=Potrebbe essere già stato fatto (è difficile per Freenet determinarlo).
IPDetectorPluginManager.forwardTwoPortsMaybeForwarded=Il nodo sembra trovarsi dietro una  NAT (per i dettagli vedi menu Stato, pagina Connessione Internet). Se possibile, configurare il forward per le porte ${port1} e ${port2} UDP (non TCP) allo scopo di migliorare la connettività. Ciò potrebbe essere stato fatto ma non ancora rilevato. Fare clic ${link}qui${/link} per ulteriori informazioni.
IPDetectorPluginManager.forwardTwoPortsNotForwarded=Il nodo sembra trovarsi dietro una  NAT (per i dettagli vedi menu Stato, pagina Connessione Internet). Se possibile, configurare il forward per le porte ${port1} e ${port2} UDP (non TCP) allo scopo di migliorare la connettività. Al momento pare che forward delle porte non sia attivo, ma Freenet non può determinarlo con certezza. Fare clic ${link}qui${/link} per ulteriori informazioni.
IPDetectorPluginManager.symmetricPS=Il nodo sembra trovarsi dietro una NAT simmetrica, configurazione particolarmente òstica: è necessario configurare il forward della/e porta/e o potrebbe risultare impossibile connettersi alla maggiorparte dei nodi.
IPUndetectedUserAlert.detecting=Freenet sta cercando in questo momento di rilevare l'indirizzo IP esterno. Il protrarsi della durata di questa operazione oltre il limite di pochi minuti è indicativo di problemi.
IPUndetectedUserAlert.detectingShort=Indirizzo IP esterno in corso di rilevamento.
IPUndetectedUserAlert.detectingWithConfigLink=Freenet sta rilevando l'indirizzo IP esterno. Se l'operazione dura più di qualche minuto si può presumere che qualcosa non stia andando come dovrebbe e si può provare ad usare il Suggerimento Temporaneo per l'Indirizzo IP ${link}parametro di configurazione${/link}.
IPUndetectedUserAlert.loadDetectPlugins=Nessun IP-detect plugin è attivo al momento. Si prega di caricare i plugin UPnP e JSTUN alla ${plugins}Pagina dei Plugin${/plugins} e caricare il plugin UPnP.
IPUndetectedUserAlert.loadJSTUN=Puoi caricare il plugin JSTUN nella ${plugins}Pagina dei plugin${/plugins}, ma prima leggi con attenzione le avvertenze a riguardo dato che potrebbe non essere sicuro.
IPUndetectedUserAlert.noIPMaybeFromPeers=Freenet dovrebbe riuscire a rilevarlo dai tuoi ${number} amici, ma loro potrebbero essere offline o potrebbero non avere forwardato la porta.
IPUndetectedUserAlert.noDetectorPlugins=Freenet non riesce a determinare l'indirizzo IP. Si prega di caricare il plugin UPnP!
IPUndetectedUserAlert.unknownAddress=Non è stato possibile rilevare l'indirizzo IP esterno (o l'indirizzo IP del NAT box o del firewall). Si può comunque scambiare refs con altri utenti, ma sarà possibile connettersi solamente a nodi che non si trovano a loro volta dietro NAT o firewall. Non appena ci si sarà connessi in questo modo ad almeno un altro utente, sarà possibile determinare l'indirizzo IP esterno. Si può suggerire al nodo l'indirizzo IP esterno usando 'Suggerimento Temporaneo per l'Indirizzo IP' ${link}parametro di configurazione${/link}
IPUndetectedUserAlert.unknownAddressTitle=Indirizzo esterno sconosciuto
IPUndetectedUserAlert.unknownAddressShort=Non è stato possibile rilevare l'indirizzo IP. Potrebbero verificarsi problemi di connessione.
IPUndetectedUserAlert.suggestForwardPort=Sarebbe opportuno configurare il port forward sul router per le porte ${port1} e ${port2} (UDP) in modo da facilitare le connessioni.
IPUndetectedUserAlert.suggestForwardTwoPorts=Sarebbe opportuno configurare il port forward sul router per le porte ${port1} e ${port2} (UDP) in modo da facilitare le connessioni.
InsertException.longError.10=Annullato dall'utente
InsertException.longError.12=Errore di formattazione nel blob binario
InsertException.longError.13=Troppi file in una cartella sola nell'inserimento in freesite
InsertException.longError.1=Caller ha fornito una URI che non è possibile utilizzare
InsertException.longError.2=Errore bucket interno: potrebbe trattarsi di mancanza di spazio sufficiente su disco rigido o di mancanza di autorizzazione?
InsertException.longError.3=Errore interno
InsertException.longError.4=Un nodo 'a valle' (downstream) è andato in time out o è stato gravemente sovraccaricato
InsertException.longError.5=Non è stato possibile propagare questa inserzione su un numero sufficiente di nodi (questo è normale su network di piccole dimensioni: si può provare a richiamare il file comunque)
InsertException.longError.6=Errori fatali in un'inserzione di splitfiles
InsertException.longError.7=Non è stato possibile inserire splitfile: numero di tentativi esaurito (errori nonfatali)
InsertException.longError.8=Non è stato possibile far partire l'inserzione dal nodo locale.
InsertException.longError.9=L' inserzione è in conflitto con dati pre-esistenti e differenti alla stessa chiave
InsertException.shortError.10=Annullato
InsertException.shortError.11=Meta string usata nella chiave
InsertException.shortError.12=Errore nel formato del binary blob
InsertException.shortError.13=Troppi file in una sola cartella
InsertException.shortError.14=Il file è troppo grande
InsertException.shortError.1=URI non valida
InsertException.shortError.2=Errore nei temp files
InsertException.shortError.3=Errore Interno
InsertException.shortError.4=Timeout o sovraccarico
InsertException.shortError.5=Percorso non trovato
InsertException.shortError.6=Alcuni block sono falliti in modo fatale
InsertException.shortError.7=Alcuni block hanno esaurito il numero di tentativi a disposizione
InsertException.shortError.8=Non è stato possibile inoltrare la richiesta
InsertException.shortError.9=Conflitto con dati esistenti
InvalidAddressOverrideUserAlert.unknownAddress=Freenet ha rilevato che il valore attualmente in uso per ipAddessOverride non è valido in quanto non conforme alla sintassi appropriata per un hostname né per un indirizzo IPv4 o IPv6 (in accordo con l'attuale implementazione della funzione che controlla la sintassi per indirizzi IPv6)
InvalidAddressOverrideUserAlert.unknownAddressTitle=Valore Override Indirizzo non Valido
InvalidAddressOverrideUserAlert.unknownAddressWithConfigLink=Freenet ha rilevato che il valore attualmente in uso per ipAddessOverride non è valido in quanto non conforme alla sintassi appropriata per un hostname né per un indirizzo IPv4 o IPv6 (in accordo con l'attuale implementazione della funzione che controlla la sintassi per indirizzi IPv6) E' possibile correggere il ${link}parametro di configurazione${/link} dell' IP address override.
InvalidAddressOverrideUserAlert.unknownAddressShort=L' indirizzo IP impostato manualmente (ipAddressOverride) non funziona. Si prega di correggerlo.
IntOption.parseError=Il valore specificato non può essere interpretato come 32-bit integer : ${val}
JavaEOLAlert.title=Freenet smetterà di funzionare con la tua versione obsoleta di Java
JPEGFilter.notJpeg=Le dimensioni del file che si sta cercando di richiamare sono troppo ridotte perché possa trattarsi di un'immagine JPEG. Potrebbe essere un file in un altro formato e il browser potrebbe fare qualcosa di sbagliato a causa della mancata corrispondenza; il file è stato pertanto bloccato.
KnownUnsafeContentTypeException.dangerousInlines=Contenuto di questo tipo può includere immagini o video che vengono caricati direttamente da internet, esponendo l'indirizzo IP dell'utente e quindi compromettendone gravemente l'anonimato.
KnownUnsafeContentTypeException.dangerousInlinesLabel=Collegamenti esterni pericolosi:
KnownUnsafeContentTypeException.dangerousLinks=Contenuto di questo tipo può includere dei link a pagine pubblicate al di fuori di Freenet. Cliccando su tali link (e possono essere camuffati) si espone il proprio indirizzo IP, compromettendo l'anonimato.
KnownUnsafeContentTypeException.dangerousLinksLabel=Link pericolosi:
KnownUnsafeContentTypeException.dangerousMetadata=Contenuto di questo tipo può includere metadati, i quali possono essere visualizzati da alcuni browser o con l'aiuto di altri programmi: i metadati possono contenere link o immagini caricate direttamente da internet, che possono compromettere l'anonimato.
KnownUnsafeContentTypeException.dangerousMetadataLabel=Metadati pericolosi:
KnownUnsafeContentTypeException.dangerousScripts=Contenuto di questo tipo può includere script pericolosi che quando eseguiti possono compromettere l'anonimato dell'utente connettendosi direttamente al web o compromettere la sicurezza in altro modo.
KnownUnsafeContentTypeException.dangerousScriptsLabel=Scripting pericoloso:
KnownUnsafeContentTypeException.knownUnsafe=Questo e' un MIME type potenzialmente pericoloso. Se il nodo lo lascia passare, il browser potrebbe fare qualcosa capace di compromettere l'anonimato dell'utente, esponendone l'indirizzo IP in relazione a questa pagina. In particolare:
KnownUnsafeContentTypeException.noFilter=Non è disponibile alcun filtro per questo tipo di dati; è necessario quindi prendere tutte le possibili precauzioni.
KnownUnsafeContentTypeException.title=Conosciuto come pericoloso: Tipo ${type}
LocalFileInsertToadlet.checkPathExist=Accerta l'esistenza del percorso specificato.
LocalFileInsertToadlet.checkPathIsDir=Controlla che il percorso specificato sia una directory
LocalFileInsertToadlet.checkPathReadable=Controlla che il percorso specificato sia leggibile dall'utente che sta utilizzando il nodo.
LocalFileInsertToadlet.dirAccessDenied=L'accesso a questa directory è interdetto
LocalFileInsertToadlet.dirCannotBeRead=Non è stato possibile leggere dalla directory "${path}".
LocalFileInsertToadlet.insert=Inserisci
LocalFileInsertToadlet.listing=Elenco directory ${path}
LocalFileInsertToadlet.listingTitle=Listing di ${path}
LocalFileInsertToadlet.sizeHeader=Dimensioni
LogConfigHandler.detaildPriorityThreshold=Soglie di priorità dettagliate
LogConfigHandler.detaildPriorityThresholdLong=Soglie di priorità dettagliate. Esempio: freenet:normal,freenet.node:minor
LogConfigHandler.dirName=Directory dei log
LogConfigHandler.dirNameLong=Directory contenente i log files
LogConfigHandler.enabled=Abilita Log
LogConfigHandler.enabledLong=Impostare su 'falso' per disabilitare completamente il log
LogConfigHandler.maxBacklogNotBusy=Tempo massimo tra la scrittura dei registri (millisecondi)
LogConfigHandler.maxCachedBytes=Max bytes di log nella RAM cache
LogConfigHandler.maxCachedBytesLong=Numero massimo di bytes nella RAM cache
LogConfigHandler.maxCachedLines=Numero massimo di righe nella RAM cache
LogConfigHandler.maxCachedLinesLong=Numero massimo di righe nella RAM cache
LogConfigHandler.maxZippedLogsSize=Spazio massimo per vecchi log
LogConfigHandler.maxZippedLogsSizeLong=Spazio massimo su disco utilizzabile da vecchi log.
LogConfigHandler.minLoggingPriority=Priorità minima dei messaggi da iscrivere nei log.
LogConfigHandler.rotationInterval=Intervallo di rotazione dei log
LogConfigHandler.rotationIntervalLong=Intervallo di rotazione dei log - periodo di tempo allo scadere del quale i log vengono ruotati. Gli ultimi due log files vengono conservati (current.log e prev.log) insieme a diversi log file compressi fino al massimo impostato in maxZippedLogsSize
LoggerHook.unrecognizedPriority=Nome di priorità non riconosciuto: ${name}.
LongOption.parseError=Il valore specificato non può essere analizzato come un intero a 64 bit: ${val}
MainJarUpdater.ConfirmMultiFileUpdater.title.wrapper-update-unix=Per favore aggiornare la fascia dei file
MeaningfulNodeNameUserAlert.noNodeNick=Per favore imposta un nome per il tuo nodo in modo che i tuoi amici possano identificarlo, per esempio se mandi loro un messaggio o un file. Questo sarà reso visibile agli Amici a cui ti sei connesso manualmente attraverso la pagina Aggiungi un Amico, e probabilmente ai loro Amici. Il nickname del nodo non sarà visibile a sconosciuti, come connessioni Freenet aggiunte automaticamente con bassi livelli di sicurezza.
MeaningfulNodeNameUserAlert.noNodeNickTitle=Per favore imposta un nome per il tuo nodo Freenet.
MeaningfulNodeNameUserAlert.noNodeNickShort=Per favore imposta un nome per il tuo nodo Freenet.
MP3Filter.bogusMP3NoFrames=Non sembra essere un MP3.
MP3Filter.bogusMP3NoFramesExplanation=Questo non sembra un file MP3. Potrebbe essere corrotto o qualcuno potrebbe stare tentando di mascherare qualche altro tipo di file come se fosse un MP3 per infrangere il vostro anonimato.
N2NTMToadlet.composingMessageLabel=Composizione messaggio N2NTM da inviare ai seguenti peer:
N2NTMToadlet.delayed=Il nodo interressato sta temporaneamente respingendo richieste; il messaggio potrebbe giungere in lieve ritardo.
N2NTMToadlet.delayedTitle=Differito
N2NTMToadlet.failed=Peer non connesso: messaggio non inviato
N2NTMToadlet.failedTitle=Fallito
N2NTMToadlet.friends=Amici
N2NTMToadlet.mayAttachFile=Puoi allegare un file, ma non sei obbligato a farlo.
N2NTMToadlet.noSuchFileOrCannotRead=Trasferimento fallito: File inesistente o illegibile.
N2NTMToadlet.peerName=Nome del Peer
N2NTMToadlet.peerNotFoundTitle=Peer non trovato
N2NTMToadlet.peerNotFoundWithHash=Non è stato possibile trovare il peer con hash code “${hash}”.
N2NTMToadlet.processingSend=Invio messaggio in corso
N2NTMToadlet.queued=In attesa: Il peer interessato non è connesso in questo momento. Il messaggio è stato posto in attesa e verrà spedito al più presto possibile
N2NTMToadlet.queuedTitle=Aggiunto alla Coda
N2NTMToadlet.returnToFriends=Torna alla lista degli Amici
N2NTMToadlet.sendMessage=Invia Messaggio di Testo da Nodo a Nodo (N2NTM)
N2NTMToadlet.sendMessageShort=Invia Messaggio
N2NTMToadlet.sendStatus=Stato N2NTM in uscita
N2NTMToadlet.sent=Messaggio inviato al peer
N2NTMToadlet.sentTitle=Inviato
N2NTMToadlet.tooLong=I messaggi N2NTM possono contenere fino a un massimo di 1024 caratteri
N2NTMToadlet.tooLongTitle=Lunghezza eccessiva
N2NTMToadlet.tooLarge=Il file che hai caricato tramite il tuo browser è ${attempt}, ma il limite è ${limit}. Per favore carica dal disco.
N2NTMToadlet.sizeWarning=Per favore tieni presente che l'upload basato sul browser ha un limite di ${limit}.
N2NTMToadlet.uploadFailed=Upload del file fallito.
N2NTMUserAlert.delete=Elimina
N2NTMUserAlert.header=Da: ${from} (${composed})
N2NTMUserAlert.headerShort=Messaggio da ${from}
N2NTMUserAlert.reply=Rispondi
N2NTMUserAlert.title=Messaggio di testo da nodo a nodo (N2NTM) ${number} da: ${peername} (${peer})
Node.acceptSeedConnectionsShort=Abilita seednode?
Node.acceptSeedConnections=Selezionando "vero" il nodo accetterà connessioni da nodi che intendono usare la modalità insicura (opennet) e li aiuterà a connettersi alla rete Freenet. Ciò rende possibile la connessione a qualsiasi nodo in possesso della referenza ma limitata dall'annuncio: le richieste di connessione sono indirizzate solo ai nodi aggiunti tramite annuncio. Il nodo locale potrebbe essere incluso a meno che non abbia già molti peer opennet (visibili alla pagina "Sconosciuti").
Node.alwaysAllowLocalAddresses=Permetti sempre la connessione a nodi via indirizzi locali?
Node.alwaysAllowLocalAddressesLong=Se impostato su "vero" il nodo cercherà di connettersi ad altri nodi usando il loro indirizzo locale (localhost, LAN) oltre al loro indirizzo IP pubblico. Se questa opzione non e' impostata, si può comunque abilitarla separatamente per singoli peer darknet (ma non per i peer opennet). Impostare questa opzione se ci si vuole connettere ad altri nodi sulla stessa rete locale (LAN) o che girano sullo stesso computer, e non far caso alle referenze "bogus" ("scràuse") che possono far mandare al nodo pacchetti UDP alle macchine sulla rete locale.
Node.assumeNATed=Presumi che la porta non sia forwardata.
Node.assumeNATedLong=Dare per scontato che la porta sia dietro NAT e non forwardata? In questo caso il nodo manderà handshake ogni 10-30 secondi.
Node.bandwidthLimitMustBePositiveOrMinusOne=Il limite di banda in download deve essere positivo o -1.
Node.bindTo=Indirizzo IP del servizio
Node.bindToLong=Indirizzo IP del servizio
Node.bwlimitMustBePositive=Il limite di banda in upload deve essere positivo.
Node.cachingFreenetStoreMaxSize=Grandezza massima della cache di scrittura in memoria per ogni store (ci sono 9 di questi store).
Node.clientCacheType=Tipo di cache del client?
Node.clientCacheTypeLong=Impostando questa opzione su 'nessuno', ci saranno meno tracce visibili in caso di furto o confisca del computer, ma il nodo dovrà scaricare ogni pagina visitata ogni volta che la si visita, riducendo le prestazioni e aumentando la visibilità delle richieste sulla rete; se impostata su 'ram', le pagine in cache verranno ricordate fino al riavvio del nodo e faranno uso di memoria RAM; la configurazione automatica la imposta su 'salt-hash', che conserva le pagine visitate su disco ma in forma cifrata e con la possibilità di impostare una password configurando il livello di sicurezza fisica (quindi eliminando in modo sicuro il file master.keys si potrà di fatto eliminare la client cache).
Node.clientCacheSize=Dimensioni cache del client (byte, MB, GB, TB, etc.)
Node.connectToSeednodesCannotBeChangedMustDisableOpennetOrReboot=Impostazione delle connessioni a nodi seed. Non disabilitare mentre Opennet è in funzione. Disabilitare Opennet prima di disabilitare questa opzione, quindi abilitare nuovamente Opennet o riavviare il nodo.
Node.databaseMemory=Memoria massima utilizzabile dal datastore (OBSOLETO: solo bdbje-index!)
Node.databaseMemoryLong=Uso massimo della memoria del database contenente indici del magazzino dati (datastore). 0 significa nessun limite (non supera comunque il 30% circa della memoria massima)
Node.deadlockTitle=Deadlocking probabilmente dovuto ad una combinazione di JVM e kernel che da luogo a "bug".
Node.defragDatabaseOnStartup=Deframmenta il database della coda dei download durante il prossimo avvio?
Node.defragDatabaseOnStartupLong=Se impostato su 'vero' il datastore verrà deframmentato al prossimo riavvio, o quando si inserisce la password.
Node.defragOnce=Deframmenta una sola volta (configurare anche l'opzione sopra!)
Node.defragOnceLong=Se questa opzione e quella precedente sono impostate su 'vero', si provvederà alla deframmentazione al prossimo riavvio, dopodiché l' opzione 'deframmenta' verrà disabilitata.
Node.disablePHTLS=Disabilita HTL probabilistico
Node.disablePHTLSLong=Disabilita HTL probabilistico (in caso di dubbio, non modificare)
Node.dropPacketEvery=Frequenza di rilascio dei pacchetti per motivi di collaudo
Node.dropPacketEveryLong=Frequenza di rilascio dei pacchetti. Opzione di collaudo usata dagli sviluppatori per simulare la perdita di pacchetti. 0 significa non rilasciare pacchetti artificialmente. Non modificare!
Node.enableARKs=Abilita ARK? (NON MODIFICARE!)
Node.enableARKsLong=Abilitare ARK? (NON MODIFICARE!)
Node.enableOpennetFailedTitle=Abilitazione opennet fallita
Node.enableOpennetFailed=Non è stato possibile abilitare Opennet e pertanto il nodo non potrà connettersi a Sconosciuti. Bisognerebbe risolvere il problema, riportare un bug, o continuare a connettersi esclusivamente ad Amici. Dettagli: ${message}
Node.enableNewLoadManagementRT=Abilitare una nuova gestione di caricamento (per le richieste in realtime)? (SPERIMENTALE!)
Node.enableNewLoadManagementRTLong=Impostalo su test per un nuovo codice di gestione di caricamento per le richieste in realtime. Questo è ancora in via sperimentale e potrebbe danneggiare seriamente il tuo nodo o ridurre o migliorare le performance! Buona fortuna, e dicci cosa succede!
Node.enableNewLoadManagementBulk=Abilita nuova gestione di caricamento (per richieste di massa)? (SPERIMENTALE!)
Node.enableNewLoadManagementBulkLong=Impostalo su test per un nuovo codice di gestione del caricamento per le richieste di massa. Questo è ancora in via sperimentale e potrebbe danneggiare il tuo nodo o ridurre o migliorare le performance! Buona fortuna, e dicci cosa succede!
Node.enablePacketCoalescing=Abilita coalescenza pacchetti?
Node.enablePacketCoalescingLong=Ablilitare la coalescenza dei pacchetti? La coalescenza dei pacchetti aumenta l'efficienza della banda, riduce l'uso di CPU e aumenta leggermente la resistenza all'analisi di traffico, al costo di una leggera latenza dei messaggi. Si consiglia di non disabilitare questa opzione.
Node.enablePerNodeFailureTables=Abilita tabelle operazioni fallite per-nodo?
Node.enablePerNodeFailureTablesLong=Abilita il reinstradamento automatico intorno a nodi che hanno fallito richieste negli ultimi 10 minuti?
Node.enableRoutedPing=Abilitare FNPRoutedPing?
Node.enableRoutedPingLong=Abilitare FNPRoutedPing? Utile solo nelle simulazioni, non nella rete reale. Spegnilo.
Node.enableULPRDataPropagation=Abilita propagazione dati ULPR?
Node.errorApplyingConfig=Si è verificato un errore durante l'applicazione della nuova configurazione : ${error}
Node.forceBigShrink=Esegui immediatamente grosse riduzioni di dimensione del datastore (solo per store di tipo bdbje-index)
Node.forceBigShrinkLong=Determina se eseguire immediatamente le riduzioni di dimensione in misura superiore al 10% del magazzino (store), piuttosto che aspettare il prossimo riavvio del nodo. Le riduzioni on-line non preservano i dati utilizzati per ultimi quindi l'uso di questa opzione non è raccomandato; da usarsi solo nel caso in cui sia desiderabile un risultato immediato.
Node.inBWLimit=Limite della banda di download
Node.invalidStoreSize=Dimensioni minime del datastore: 32MB
Node.l10nLanguage=Lingua in cui visualizzare messaggi e informazioni
Node.l10nLanguageLong=Questa impostazione cambia la lingua dei messaggi visualizzati. Alcune frasi e messaggi saranno visibili in versione tradotta solo dopo il prossimo riavvio del nodo.
Node.masterKeyFile=Posizione del file delle chiavi principali
Node.maxHTL=HTL massimo
Node.maxHTLLong=HTL massimo
Node.maxOpennetPeers=Numero massimo di peer Opennet
Node.maxOpennetPeersLong=Numero massimo di peer su Opennet (deve essere compreso tra 0 e ${default} incluso, il limite reale dipenderà dal numero di Amici e il tuo limite di banda, e verrà mostrato nella pagina delle statistiche).
Node.maxOpennetPeersMustBeTwentyOrLess=Devono essere al massimo ${maxpeers}
Node.mustBePositive=Il valore deve essere positivo!
Node.nodeDir=Directory del nodo
Node.nodeDirLong=Directory dove conservare file relativi al nodo, per esempio la lista dei peer.
Node.cfgDir=Cartella di configurazione
Node.cfgDirLong=Percorso della cartella per i file di configurazione modificabili dall'utente (es. override della lingua)
Node.userDir=Cartella dei dati utente
Node.userDirLong=Percorso della cartella per i dati utente (es.: segnalibri, elenchi dei download).
Node.runDir=Cartella dello stato di runtime
Node.runDirLong=Percorso della directory per lo stato di run-time. Questa verrà ripulita quando Freenet non è in funzione.
Node.pluginDir=Cartella dei Plugin
Node.pluginDirLong=Percorso della cartella per i plugin.
Node.probeBandwidthShort=Rispondere alla richiesta di sondare il limite di banda
Node.probeBandwidthLong=Se impostato su 'vero' Freenet risponderà alla richiesta di aumentare il limite di banda. Questo serve a migliorare la conoscenza delle condizioni della rete e a permettere simulazioni per riflettere al meglio la rete reale. Ciò produrrà un piccolo numero di suoni alla rinfusa per rendere le informazioni meno identificabili ma comunque utili per gli esperimenti. Se impostato su 'falso' risponderà con un refuso.
Node.probeBuildShort=Rispondere alla richiesta di sondare la costruziin
Node.probeBuildLong=Se impostato su 'vero' Freenet risponderà alla richiesta di sondare la costruzione. Questo serve a misurare la propagazione dell'aggiornamento. Se impostato su 'falso' risponderà con un refuso.
Node.probeIdentifierShort=Assegnato identificatore casuale alla richiesta di sondaggio
Node.probeIdentifierLong=L'identificatore è usato solo in una richiesta di sondaggio per un identificatore. Se impostato su -1 allora selezionerà un nuovo valore casuale.
Node.probeRespondIdentifierShort=Rispondere alla richiesta di sondaggio per identificatore
Node.probeLinkLengthsShort=Rispondere alla richiesta di sondaggio per le lunghezze dei link
Node.probeLinkLengthsLong=Se impostato su 'vero' Freenet risponderà alla richiesta di sondaggio per le lunghezze dei link. Questo serve a migliorare la conoscenza delle condizioni della rete, e permette delle simulazioni per riflettere la rete reale. Ciò produrrà un piccolo numero di suoni casuali per rendere le informazioni meno identificabili ma comunque utili per gli esperimenti. Se impostato su 'falso' risponderà con un refuso.
Node.probeLocationShort=Rispondere alla richiesta di sondare la posizione
Node.probeLocationLong=Se impostato su 'vero' Freenet risponderà alla richiesta di sondare una posizione poco precisa. Questo permetterà di misurare la distribuzione della posizione della rete, e non conterrà altre informazioni a parte la posizione stessa. Se impostato su 'falso' risponderà con un refuso.
Node.probeStoreSizeShort=Rispondere alla richiesta di sondare la grandezza di immagazzinagg
Node.probeStoreSizeLong=Se impostato su 'vero' Freenet risponderà alla richiesta di sondare la grandezza di immagazzinaggio. Questo servirà a migliorare la conoscenza delle condizioni della rete, e permetterà simulazioni per riflettere al meglio la rete reale. Ciò produrrà un piccolo numero di suoni casuali per rendere le informazioni meno identificabili ma comunque utili per gli esperimenti. Se impostato su 'falso' risponderà con un refuso.
Node.probeUptimeShort=Rispondere alla richiesta di sondare il tempo di attivita
Node.probeUptimeLong=Se impostato su 'vero' Freenet risponderà alla richiesta di sondaggio della percentuale per 48 ore o 7 giorni del tempo di attività. Questo migliorerà la conoscenza delle condizioni della rete, e permetterà simulazioni per riflettere al meglio la rete reale. Ciò produrrà un piccolo numero di suoni casuali per rendere le informazioni meno indetificabili ma comunque utili per gli esperimenti. Se impostato su 'falso' risponderà con un refuso.
Node.nodeName=Nome del nodo
Node.nodeNameLong=Il nome del nodo è visibile solo agli Amici
Node.maxPacketSize=Dimensione massima del paccketto (leggasi MTU)
Node.maxPacketSizeLong=Massima dimensione dei pacchetti UDP che Freenet invia, presumendo che gli header UDP/IP siano di 28 byte. Useremo lo MTU dell'interfaccia se possiamo rilevarlo, ma la maggior parte delle ostruzioni accadono altrove, e sfortunatamente non possiamo rilevare facilmente il percorso MTU.
Node.notUsingWrapperTitle=Il nodo non sta usando il wrapper!
Node.notUsingWrapper=Il nodo sta girando senza il wrapper. Ciò è generalmente sconsigliabile. Il nodo non potrà riavviare sé stesso e quindi l'aggiornamento automatico non potrà funzionare. Inoltre, se la JVM se ne dovesse andare nel "limbo" non sarà possibile riavviare automaticamente nemmeno quella. Non verranno generati stack dump in alcuni posti e quindi debugging sarà più difficile.
Node.notUsingWrapperShort=Freenet sta girando senza wrapper. Questo non è raccomandato.
Node.oneConnectionPerIP=Limita ad una connessione per indirizzo? (amici) (SCONSIGLIATO)
Node.opennetEnabled=Abilita modalità insicura (connessioni automatiche a nodi non fidàti)?
Node.opennetEnabledLong=Abilita Modalità Insicura? (Opennet) Abilitando questa opzione il nodo scambierà automaticamente referenze con altri nodi. Ciò rende la presenza di un nodo Freenet facilmente osservabile dall'esterno, facilitando attacchi di diversi tipi. Avendone la possibilità, l'opzione migiore è quella di connettersi soltanto ad utenti conosciuti ed affidabili (Amici) e disabilitare questa opzione.
Node.outBWLimit=Limite della banda di upload
Node.paddDataPackets=Aggiungi contenuto di dimensioni variabili e casuali ai pacchetti trasmessi dal nodo (LEGGERE L'AVVERTENZA)
Node.paddDataPacketsLong=Aggiunge contenuto ai pacchetti trasmessi dal nodo in quantità variabile e determinata a caso. In termini di sicurezza per il singolo nodo, disabilitare questa opzione non è consigliabile. Inoltre, se una grossa porzione della rete Freenet cominciasse a fare lo stesso, gli attacchi di tipo 'passivo' diverrebbero molto più facili. Uomo avvisato...
Node.passOpennetPeersThroughDarknet=Trasmetti referenze opennet attraverso i peer darknet?
Node.passOpennetPeersThroughDarknetLong=Se impostata su "vero" referenze opennet verranno trasmesse attraverso peer darknet (ma MAI la referenza del nodo locale). In questo modo un nodo (nodo locale, o i suoi peer) può ottenere peer opennet dai suoi peer darknet. Questo è utile perché permette di riconnettersi in caso di perdita dei peer, per esempio dopo una lunga disconnessione, ma rende l'analisi del traffico leggermente più facile, quindi chi è paranoico dovrebbe disabilitare questa opzione.
Node.port=Numero della porta FNP (UDP)
Node.portLong=Porta UDP per le comunicazioni da nodo a nodo. Questa porta dovrebbe essere forwardata al tuo router se possibile. Usiamo una porta differente per le connessioni a Sconosciuti.
Node.opennetPort=Numero della porta opennet (UDP)
Node.opennetPortLong=Porta UDP usata da Freenet per comunicare con gli sconosciuti, ad es. i nodi Freenet funzionanti in modalità opennet. Questa porta dovrebbe essere inoltrata nel tuo router se possibile. Usiamo una porta separata per le connessioni ai nodi dei tuoi Amici.
Node.publishOurPeersLocation=Trasmetti ad ogni peer la locazione dei nostri peer?
Node.publishOurPeersLocationLong=Trasmettere ai peer la locazione dei nostri peer? Ciò facilita il routing ma fornisce informazioni ad un potenziale avversario.
Node.pleaseSetPeersVisibilityAlertTitle=Per favore imposta la visibilità per i tuoi amici
Node.pleaseSetPeersVisibilityAlert=Freenet ora può connettersi agli amici dei tuoi amici per migliorare le performance e rendere la tua connessione più efficiente, ma ha bisogno di sapere con quali peer è sicuro farlo. Per favore vai nella pagina Connessioni con gli Amici e imposta la visibilità per i tuoi amici. Generalmente devi settarli su SI cosicché Freenet possa connettersi ai loro amici e loro possano connettersi ai tuoi amici, ma se non vuoi che i tuoi amici vedano un amico specifico, settalo su NO.
Node.skipWrapperWarning=Saltare l'avviso "non si sta usando il wrapper"?
Node.skipWrapperWarningLong=Se vero, non verrà mostrato l'avviso "non si sta usando il wrapper". Si noti che questo nasconderà l'avviso solo a partire dal prossimo riavvio.
Node.slashdotCacheLifetime=Per quanto tempo di giacenza devono restare i dati nella cache delle richieste recenti?
Node.slashdotCacheLifetimeLong=Configura quanto tempo (in millisecondi) i dati vengono trattenuti nella cache delle richieste recenti. Nota: i dati vengono comunque eliminati al riavvio.
Node.slashdotCacheSize=Dimensioni massime della cache richieste recenti
Node.slashdotCacheSizeLong=Dimensione massima della cache dele richieste frequenti (nota: esiste anche un limite di tempo).
Node.storeDirectory=Directory magazzino dati (store)
Node.storeDirectoryLong=Directory contenente gli store file, che contengono i dati (chiavi, blocchi, ecc.) necessari ad altri utenti.
Node.storeMaxMemTooHigh=Impostare un valore superiore ad 80% della memoria RAM da destinare a BDB è generalmente una pessima idea.
Node.storePreallocate=Pre-allocare spazio per datastore su disco
Node.storePreallocateLong=Allocazione dello spazio datastore
Node.storeSaltHashResizeOnStart=Modifica dimensione del datastore al prossimo avvio del nodo (solo per salt-hash)
Node.storeSaltHashResizeOnStartLong=Cambiamento dimensioni datastore all' avvio (solo per salt-hash). Se impostato su 'vero', il nodo completerà le modifiche delle dimensioni del datastore durante il processo di avvio. In questo modo il processo risulterà più rapido di quanto sarebbe se fosse eseguito 'al volo', ma durante il processo stesso il nodo non sara accessibile.
Node.storeSize=Freenet dimensioni datastore (byte, MB, GB, TB, ecc)
Node.storeSizeLong=Dimensioni del magazzino (store) in bytes
Node.storeTypeLong=Al momento sono disponibili i seguenti tipi di datastore: salt-hash (SPERIMENTALE, usa salted hash table su disco con bloom filter); bdb-index (STABILE, usa BerkeleyDBFreenetStore per immagazzinare l'indice e tiene i dati su disco) o ram (SOLO PER TESTING, tiene sia indice che dati su RAM). Usare ram solo se competenti e se è disponibile memoria sufficiente per immagazzinare tutti i dati (NOTA: i dati NON verranno salvati quando il nodo viene spento). I cambiamenti verranno attivati al riavvio di Freenet.
Node.storeBloomFilterSize=Dimensione del filtro bloom (totale) in bytes
Node.storeBloomFilterSizeLong=Dimensioni del filtro bloom in bytes. Di solito 1/2048mo della dimensione del  datastore è più che abbastanza. Impostare su zero per disabilitare il bloom filter. Impostare su -1 per tornare al default.
Node.storeBloomFilterCounting=Usa filtro counting bloom
Node.storeBloomFilterCountingLong=Usare filtro bloom con contatore a 2 bit? (in caso di dubbio, non modificare)
Node.storeUseSlotFilters=Utilizza i filtri sugli slot? (Fortemente raccomandato)
Node.storeUseSlotFiltersLong=Questo riduce di molto gli I/O del disco per il salvataggio degli hash, ad un costo di memoria e di disco di circa 4 bytes per ogni chiave, ad esempio 1/3000-esimo dello spazio su disco. Tutto ciò è fortemente raccomandato, a meno che la tua RAM sia piccola e tu abbia un veloce disco SSD.
Node.storeSaltHashSlotFilterPersistenceTime=Usa intervalli fissi per i filtri degli slot
Node.storeSaltHashSlotFilterPersistenceTimeLong=Quanto spesso i filtri degli slot devono essere riscritti per il salvataggio? -1 = scrivi immediatamente. 0 = scrivi allo spegnimento. >0 = scrivi ad ogni n millesecondi. Perciò, ad esempio 60000 = ogni minuto. Nota che se Freenet viene chiuso senza essere ripulito, e non è stata impostata la scrittura immediata, il filtro dello slot sarà ricostruito al successivo avvio, che causerà un significativo numero di accessi al disco.
Node.slotFilterPersistenceTimeError=Il valore fisso del tempo per i filtri degli slot deve essere -1, 0, o positivo.
Node.swapRInterval=Intervallo tra le richieste di scambio (swap) in millisecondi
Node.throttleLocalTraffic=Limitazione di banda su traffico locale
Node.throttleLocalTrafficLong=Abilita limitazione di banda su traffico locale? Abilitando questa opzione,  la limitazione di banda avrà effetto anche sulla rete locale (LAN) e su localhost.
Node.useSlashdotCache=Aggiungi tutte le richieste alla cache per 30 minuti
Node.usingGCJTitle=Eseguire Freenet con GCJ non è raccomandato
Node.usingGCJ=Stai usando Freenet con GCJ (un compilatore Java free). Questo non è raccomandato e potrebbe creare problemi. Ti raccomandiamo di utilizzare OpenJDK (che è sempre free, e con meno probabilità di avere problemi)
Node.usingOracleTitle=Stai eseguendo Freenet con la versione ufficiale di Oracle della Java Virtual Machine. Ti consigliamo di passare a OpenJDK se possibile.
Node.usingOracle=Stai usando Freenet attraverso la Macchina Virtuale di Java ufficiale di Oracle. La JVM ufficiale ha deliberatamente reso inutilizzabile il codice di criptazione a causa delle restrizioni nelle esportazioni, perciò useremo il codice interno a Freenet, che potrebbe risultare più lento. Ti consigliamo di passare a OpenJDK se possibile (lo trovi nel gestore di pacchetti).
Node.withAnnouncementLong=Permettere che il nodo si auto-inserisca nella rete Freenet usando seednodes? Per potersi connettere ad Opennet (rete di Sconosciuti alla quale Freenet si connette automaticamente se il livello di sicurezza è impostato su Basso o Medio) il nodo si mette in contatto con dei nodi pubblicamente accessibili che sceglie da una breve lista distribuita con Freenet. Ovviamente la sicurezza di una connessione di questo tipo sarà meno che ottimale, ma chi usa Opennet di solito lo fa perché non ha scelta: se un nodo resta disconnesso per un po' di tempo, specialmente se è dietro NAT e/o se cambia spesso IP, probabilmente avrà bisogno del reseed. Per ottenere un livello di sicurezza più alto è necessario connettersi a nodi gestiti da amici ed abilitare il livello di sicurezza in rete Alto.
Node.writeLocalToDatastore=Iscrivi richieste locali e vicine nel datastore
NodeClientCore.alwaysCommit=Scrivi su disco dopo ogni attività su database?
NodeClientCore.alwaysCommitLong=Se impostato su 'falso', i dati vengono scritti su disco ogni 30 secondi. Impostando su 'vero', saranno scritti dopo ogni cambiamento nel database. Se da un lato ciò causerà una riduzione nelle prestazioni, il vantaggio è che si eliminerà il rischio di perdere dei dati in caso di arresto improvviso. L'uso di memoria risulterà inoltre leggermente inferiore. In casi normali questa opzione dovrebbe essere impostata su 'falso' per ridurre l'accesso al disco.
NodeClientCore.maxArchiveSize=Dimensioni massime di ogni archivio
NodeClientCore.maxArchiveSizeLong=Dimensione massima di ogni archivio
NodeClientCore.couldNotFindOrCreateDir=Non è stato possibile trovare o creare la directory
NodeClientCore.downloadAllowedDirs=Directory dove il download è consentito
NodeClientCore.downloadsDir=Directory predefinita per i download
NodeClientCore.downloadsDirLong=Directory predefinita dove salvare i file scaricati
NodeClientCore.encryptTempBuckets=Crittografare i bucket di dati temporanei?
NodeClientCore.fileForClientStats=File contenente statistiche del client
NodeClientCore.fileForClientStatsLong=File dove conservare le statistiche relative al client throttling (utilizzato per stabilire l'intervallo tra le richieste)
NodeClientCore.maxUSKFetchers=Numero massimo di USK fetchers ammessi
NodeClientCore.maxUSKFetchersLong=Numero massimo di fecthes temporanei in background per USKs visti di recente (ad esempio freesites). Nota che i client e i plugin (come WebOfTrust) possono sottoscrivere gli USKs, che non contano nel limite.
NodeClientCore.maxUSKFetchersMustBeGreaterThanZero=Deve essere maggiore di zero
NodeClientCore.minDiskFreeLongTerm=Minimo spazio libero su disco
NodeClientCore.minDiskFreeShortTerm=Minimum free disk space during decode
NodeClientCore.movingTempDirOnTheFlyNotSupported=Non è possible cambiare la directory dei file temporanei mentre il nodo è in funzione
NodeClientCore.persistentTempDir=Directory dei file temporanei persistenti
NodeClientCore.persistentTempDirLong=Nome della directory dei file temporanei persistenti
NodeClientCore.pluginStoresDir=Cartella dei plugin
NodeClientCore.maxRAMBucketSize=Dimensioni massime di un RAMBucket
NodeClientCore.maxRAMBucketSizeLong=Dimensioni massime di un RAMBucket (i bucket di dimensioni maggiori saranno immagazzinati sul disco rigido)
NodeClientCore.ramBucketPoolSize=Quantità di RAM da dedicare ai bucket di dati temporanei
NodeClientCore.ramBucketPoolSizeLong=Quantità di RAM da dedicare ai bucket di dati temporanei che verrebbero altrimenti immagazzinati sul disco rigido. L'equilibrio sta nel maggiore uso di memoria contro più I/O.
NodeClientCore.startingUpTitle=Avviamento di Freenet in corso
NodeClientCore.startingUp=Si prega di concedere a Freenet alcuni minuti per completare il processo di avviamento. Nel frattempo alcune funzioni non saranno disponibili e il nodo potrà risultare più lento del normale.
NodeClientCore.startingUpShort=L'avviamento di Freenet è ancora in corso: alcune funzioni potrebbero non essere ancora disponibili e il nodo potrebbe operare ad una velocità inferiore al normale.
NodeClientCore.tempDir=Directory file temporanei
NodeClientCore.tempDirLong=Nome della directory dei file temporanei
NodeClientCore.uploadAllowedDirs=Directory dalle quali l'upload e' consentito
NodeClientCore.useAIMDsRT=Utilizzare AIMD per le richieste in tempo reale? (SOLO PER UTENTI ESPERTI)
NodeClientCore.useAIMDsRTLong=Abilita l'acceleratore a livello originatore di richieste basato sul tasso di stima in stile TCP di Additive Increase Multiplicative Decrease (per richieste istantanee). Ciò abilta o disabilita una parte fondamentale del sistema di gestione del caricamento. SOLO PER ESPERTI!!!
NodeClientCore.useAIMDsBulk=Utilizzare AIMD per la maggior parte delle richieste? (SOLO PER UTENTI ESPERTI)
NodeClientCore.useAIMDsBulkLong=Abilita l'acceleratore a livello originatore di richieste basato sul tasso di stima in stile TCP di Additive Increase Multiplicative Decrease (per richieste numerose). Ciò abilta o disabilita una parte fondamentale del sistema di gestione del caricamento. SOLO PER ESPERTI!!!
NodeIPDectector.inclLocalAddress=Includere gli indirizzi locali nelle referenze del nodo
NodeIPDectector.inclLocalAddressLong=Se includere o meno indirizzi locali (LAN e localhost) nelle referenze del nodo. Ciò non sarà utile a meno che entrambi i lati impostino llowLocalAddresses=true per le rispettive referenze (usate la pagina Amici nella modalità avanzata per impostare questa opzione).
NodeIPDectector.ipOverride=Impostazione manuale dell'indirizzo IP
NodeIPDectector.ipOverrideLong=Impostazione manuale dell'indirizzo IP (solitamente non necessaria) - impostatelo se avete un indirizzo IP *statico* o un nome di dominio (per es. tramite dyndns) e siete dietro ad un firewall.
NodeIPDectector.tempAddressHint=Suggerimento dell'indirizzo IP temporaneo
NodeIPDectector.tempAddressHintLong=Suggerimento temporaneo di quale potrebbe essere il nostro IP; cancellato dopo l'uso
NodeIPDetector.maybeSymmetric=Sembra che il nodo sia dietro una NAT simmetrica. Potrebbe trattarsi di problemi di connessione: se ci si trova dietro una NAT simmetrica ci si potrà probabilmente connettere soltanto con i nodi che sono raggiungibili da interenet.
NodeIPDetector.maybeSymmetricTitle=Problemi di connessione
NodeIPDetector.maybeSymmetricShort=Problema di connessione: il nodo potrebbe trovarsi dietro una NAT simmetrica.
NodeIPDetector.unknownHostErrorInIPOverride=Host sconosciuto: ${error}
NodeStat.aggressiveGC=Modificatore  dell' AggressiveGC
NodeStat.ignoreLocalVsRemoteBandwidthLiability=Tratta richieste locali come fossero remote riducendo la passività sulla banda
NodeStat.ignoreLocalVsRemoteBandwidthLiabilityLong=Abilitando questa opzione si riduce notevolmente la banda utilizzata e si aumenta leggermente la sicurezza nei confronti di attacchi di timing. Generalmente non c'è di che preoccuparsi per questo tipo di attacchi in quanto gli attacchi di correlazione sono più facili da eseguire.
NodeStat.freeHeapBytesThreshold=Soglia free heap bytes
NodeStat.freeHeapPercentThreshold=Soglia percentuale free heap
NodeStat.maxPingTime=Tempo massimo di ping
NodeStat.maxPingTimeLong=Freenet rifiuterà tutte le richieste quando il tempo medio di ping dei peers dovesse superare la soglia configurata in questa opzione. Il tempo di ping ha dimostrato di essere un buon indicatore del carico su sistema e network, ma quando la connessione internet fosse lenta in modo anormale, sarebbe bene aumentare il limite impostato in questa sede (in millisecondi).
NodeStat.subMaxPingTime=Tempo di ping oltre il quale rifiutare richieste
NodeStat.subMaxPingTimeLong=Freenet comincerà a rifiutare richieste quando il tempo medio (in millisecondi) di ping dei peer superasse il limite impostato in questa opzione. Si consiglia di alzare il limite quando la connessione internet fosse lenta in modo anormale.
NodeStat.memCheck=Abilita Verifica di Memoria
NodeStat.memCheckLong=Abilita verifica della memoria (scrive un messaggio nel log file. La verifica della memoria deve essere abilitata perche' aggressiveGCModificator abbia effetto)
NodeStat.statsPersister=File contenente le statistiche del nodo
NodeStat.statsPersisterLong=File contenente statistiche: NON si tratta delle statistiche del client. Queste statistiche servono al nodo per decidere se accettare o rifiutare nuove richieste. Non eliminare!
NodeStat.threadLimit=Massimo numero di thread
NodeStat.threadLimitLong=Il nodo respinge richieste per limitare l'uso di thread al valore specificato.
NodeStats.allRequests=Tutte le richieste
NodeStats.averageHeader=Media
NodeStats.bulkSends=Invii di massa
NodeStats.blockTransfersRT=Trasferimenti di massa (RT)
NodeStats.blockTransfersBulk=Trasferimenti in blocco (di massa)
NodeStats.blockTransfersLocal=Trasferimenti in blocco (locali)
NodeStats.bulkHeader=Massa
NodeStats.count=Conto
NodeStats.delayTimes=Ritardo
NodeStats.group=Gruppo
NodeStats.localHeader=Locale
NodeStats.localCHKs=CHK locali
NodeStats.localSSKs=SSK locali
NodeStats.mustBePercentValueNotFull=Questo valore deve essere espresso in precentuale, compresa tra 0 e 99.
NodeStats.pSuccess=P(Successo)
NodeStats.realTimeHeader=Tempo Reale
NodeStats.remoteHeader=Remoto
NodeStats.remoteCHKs=CHK remote
NodeStats.remoteSSKs=SSK remote
NodeStats.slotsWaiting=Richieste in attesa di slot: ${local} local, ${remote} remote.
NodeStats.successfulHeader=Riuscito
NodeStats.timeoutFractions=Tempo scaduto per l'accodamento
NodeStats.transfersTimedOut=Trasferimenti fuori tempo max.
NodeStats.unsuccessfulHeader=Fallito
NodeStats.valueTooLow=Valore troppo basso per questa impostazione: è necessario aumentarlo.
MainJarUpdater.fetchingDependencies=Fetching di jars richiesti nella nuova versione
MainJarUpdater.fetchingFromUOM=Fetching direttamente da un nodo più aggiornato ("Aggiornamento Obbligatorio)
NodeUpdateManager.enabled=Verifica disponibilità e scarica nuove versioni
NodeUpdateManager.enabledLong=Verifica e scarica automaticamente nuove versioni di Freenet. Se impostatos su 'vero', le nuove versioni verranno scaricate ma non necessariamente installate. L'impostazione torna sempre su 'falso' se il nodo non gira all'interno del wrapper.
NodeUpdateManager.installNewVersions=Installa nuove versioni automaticamente
NodeUpdateManager.installNewVersionsLong=Scarica e installa aggiornamenti automaticamente senza chiedere conferma
NodeUpdateManager.invalidRevocationURI=URI di revoca non valida: ${error}
NodeUpdateManager.invalidUpdateURI=URI di aggiornamento non valida: ${error}
NodeUpdateManager.noUpdateWithoutWrapper=Non è stato possibile completare l'aggiornamento perché il nodo non sta girando nel Java Service Wrapper
NodeUpdateManager.revocationURI=Dove cercare la chiave di revoca?
NodeUpdateManager.updateCatastropheTitle=Fallimento Catastrofico dell' Aggiornamento!
NodeUpdateManager.updateFailed=Aggiornamento fallito: ${reason}
NodeUpdateManager.updateFailedTitle=Aggiornamento Fallito!
NodeUpdateManager.updateFailedShort=Aggiornamento fallito: ${reason}
NodeUpdateManager.updateSeednodes=Aggiorna seednodes automaticamente
NodeUpdateManager.updateSeednodesLong=Aggiorna il file seednodes.fref automaticamente scaricando da Freenet
NodeUpdateManager.updateInstallers=Scarica i più recenti programmi di installazione da Freenet
NodeUpdateManager.updateInstallersLong=Configura se scaricare da Freenet gli ultimi parogrammi di installazione disponibili. Dei link verranno creati alla pagina 'Aggiungi Amici'
NodeUpdateManager.updateURI=Dove cercare aggiornamenti?
NodeUpdateManager.updateURILong=Dove cercare aggiornamenti?
NodeUpdateManager.updateURIMustBeAUSK=L'URI di aggiornamento deve essere una USK!
NodeUpdateManager.updateFailedInternalError=IMPOSSIBILE AGGIORNAREFREENET. Errore interno: ${reason}
NotEnoughNiceLevelsUserAlert.title=Numero di Nice level insufficiente!
NotEnoughNiceLevelsUserAlert.short=Non ci sono abbastanza Nice level disponibili. si prega di assegnare a Freenet un Nice level inferiore.
NotEnoughNiceLevelsUserAlert.content=Il nodo ha rilevato di stare operando ad un Nice level alto. In mancanza di un numero sufficiente di livelli di nice, il nodo non potrà operare a pieno regime. Si prega di ridurre il livello di nice. (cercare PRIORITY nel file run.sh e ridurne il valore). Attualmente il nodo ha ${available} livelli a disposizione mentre avrebbe bisogno di ${required} livelli.
OpennetManager.oneConnectionPerIP=Limitare ad una connessione per indirizzo? (sconosciuti)
OpennetManager.oneConnectionPerIPLong=Non permettere più di una connessione sconosciuta per indirizzo? Questo renderà un po' più difficile per un attaccante connettersi più di una volta al vostro nodo come identità diverse, per dominare i vostri instradamenti o rendere l'harvesting più facile. Impedisce anche di avere lo stesso nodo connesso come amico e sconosciuto simultaneamente.
OpennetConnectionsToadlet.successTimeTitle=Ultimo successo
OpennetConnectionsToadlet.successTime=L'ultima volta che si è riusciti a richiamare una CHK dal nodo.
OpennetConnectionsToadlet.fullTitle=${counts} Sconosciuti (Peer non fidàti)
OpennetConnectionsToadlet.peersListTitle=Peer Opennet (peer non fidàti aggiunti automaticamente dal nodo)
PNGFilter.invalidHeader=Il file che si sta cercando di richiamare non e' un PNG: esso non include un header PNG valido. Potrebbe trattarsi di un file in altro formato e il browser potrebbe fare qualcosa di pericoloso a causa della confusione creata dalla mancata corrispondenza; il file è stato pertanto bloccato.
PNGFilter.invalidHeaderTitle=Header PNG non valido
PeerManagerUserAlert.connErrorTitle=Alcuni peer non riescono a connettersi
PeerManagerUserAlert.connError=${count} peer non riescono a connettersi per motivi sconosciuti, forse per causa di 'bug' nel nodo o di una referenza di un nodo che e' corrotta.
PeerManagerUserAlert.clockProblemTitle=Problema di sincronizzazione.
PeerManagerUserAlert.clockProblem=${count} peer non riescono a connettersi perché il loro orologio di sistema differisce di oltre 24 ore da quello locale. Si prega di verificare che l'orologio di sistema del computer sia regolato sull'ora esatta. Regolazioni inaccurate dell'orologio causano molti problemi nel funzionamento dei meccanismi tra nodo e client.
PeerManagerUserAlert.noConns=Non è stato finora possibile connettersi ad alcun nodo. Forse qualcuno dei peer si connettera entro breve. in caso contrario sarà necessario aggiungere altri peer; c'e' bisogno di almeno tre peer connessi in ogni momento, meglio 5-10.
PeerManagerUserAlert.noConnsTitle=Nessuna connessione aperta
PeerManagerUserAlert.noPeersDarknet=Il nodo non ha peers ai quali connettersi e quindi non sarà in grado di funzionare normalmente. In teoria bisognerebbe connettersi a nodi operati da persone conosciute (persone fidàte se si è paranoici; se non lo si è, basta averci parlato). E' necessario avere almeno 3 peer connessi in qualsiasi momento, meglio 5-10 peer. E' possibile ottenere velocemente delle connessioni a sconosciuti impostando il livello di sicurezza in rete su NORMALE o BASSO
PeerManagerUserAlert.noPeersTitle=Nessun peer trovato
PeerManagerUserAlert.oneConn=Questo nodo ha una sola connessione. Il rendimento ne risentirà in modo notevole, e l'utente non disporrà di anonimato e "negabilità plausibile" se quell' unico nodo al quale si è conessi dovesse essere operato da un avversario. Il nodo risulterà attaccato al network come una "foglia all' albero" e non contribuirà alla salute generale del network stesso. Per un corretto funzionamento del nodo è necessario che almeno tre peer e (idealmente 5-10) siano connessi in qualsiasi momento.
PeerManagerUserAlert.onlyFewConnsTitle=Soltanto ${count} connessione/i aperta/e
PeerManagerUserAlert.outdatedUpdateTitle=Freenet richiede un aggiornamento! Per favore attiva il sistema di aggiornamento nella sezione "aggiornamento automatico" della pagina di configurazione.
PeerManagerUserAlert.tooHighBwlimitDelayTime=Questo nodo deve aspettare troppo a lungo la banda disponibile (${delay}ms > ${max}ms). Aumentare l'ampiezza di banda in uscita e/o rimuovere alcuni peer migliorerebbe la situazione.
PeerManagerUserAlert.tooHighBwlimitDelayTimeTitle=bwlimitDelayTime troppo alto
PeerManagerUserAlert.tooHighPingTime=Il nodo non riesce a comunicare abbastanza velocemente con i peer (${ping}ms > ${max}ms). Aumentare l'ampiezza di banda in uscita per migliorare la situazione
PeerManagerUserAlert.tooHighPingTimeTitle=nodeAveragePingTime troppo alto
PeerManagerUserAlert.tooManyConns=Questo nodo ha troppe connessioni (${count} > ${max}). Aggiungere troppi peer non produce un topologia mondo-piccolo, danneggia l'instradamento, e rischia di produrre punti di fallimento singoli.
PeerManagerUserAlert.tooManyConnsTitle=Troppe connessioni aperte
PeerManagerUserAlert.tooManyDisconnected=Questo nodo ha troppi peer disconnessi (${count} > ${max}). Questo può avere un leggero impatto sul rendimento perché anche i peer disconnessi usano una piccola quantità di banda e CPU. Potrebbe essere necessario "ripulire" la lista dei peer. Nota che almeno in teoria, bisognerebbe connettersi esclusivamente ad utenti che si conosce. Anche in caso contrario, aggiungere troppi nodi automaticamente produce un risultato negativo in quanto la topologia risultante non è ottimale.
PeerManagerUserAlert.tooManyDisconnectedTitle=Troppi peer disconnessi
PeerManagerUserAlert.tooManyNeverConnected=Ben ${count} tra i peer di questo nodo non sono mai stati connessi, nemmeno una volta sola: . Non bisognerebbe aggiungere peer a meno che la propria referenza venga aggiunta a sua volta. In caso contrario sarà impossibile connettersi.
PeerManagerUserAlert.tooManyNeverConnectedTitle=Molti peers non sono ancora stati connessi nemmeno una volta
PeerManagerUserAlert.tooManyNeverConnectedWithLink=${count} peer di questo nodo non sono mai stati connessi, nemmeno una volta sola. Non bisognerebbe aggiungere nuovi peers a meno che essi non aggiungano a loro volta ${link}your reference${/link}. Se ciò non avviene non sarà possibile stabilire una connessione.
PeerManagerUserAlert.tooOldNeverConnectedPeers=Uno o più peer non si sono mai connessi nelle due settimane trascorse da quando sono stati aggiunti.  E' da prendere in considerazione l'idea di rimuoverli in quanto essi stanno marginalmente compromettendo il rendimento (pacchetti sprecati cencando di comunicare con nodi che non ci sono).
PeerManagerUserAlert.tooOldNeverConnectedPeersTitle=Peer mai connesso/i obsoleto/i
PeerManagerUserAlert.twoConns=Il nodo ha solo due connessioni. Rendimento e sicurezza risulteranno di qualità inferiore, e non sara possibile provvedere instradamento (routing) per altri nodi. Il nodo è collegato al network come un "anello di catena" e non contribuisce (molto) alla salute generale del network stesso. Per un corretto funzionamento del nodo, è necessario che almeno tre peers (e idealmente 5-10) siano connessi in ogni momento.
PeersSayKeyBlownAlert.fetching=Il nodo sta scaricando il certificato di revoca contentnte spiegazioni più dettagliate.
PeersSayKeyBlownAlert.short=Stando ad alcuni peer non è sicuro effettuare un aggiornamento. L'auto-aggiornamento è stato disablitato fino a quando non capiremo se i peer stanno mentendo.
PluginConfig.configFile=File di configurazione dei plugin
PluginConfig.configFileLong=Percorso/Nome del file che contiene la configurazione del plugin
PluginConfig.installDir=Directory di installazione dei plugin
PluginConfig.installDirLong=Directory dove installare i plugin
PluginJarUpdater.pluginUpdatedShortText=E` disponibile una nuova versione del plugin ${name}!
PluginJarUpdater.pluginUpdatedText=Cliccate qui sotto per aggiornare all'ultima versione (${newVersion}) di ${name}.
PluginJarUpdater.pluginUpdatedTitle=E` disponibile una nuova versione del plugin ${name}!
PluginJarUpdater.updatePlugin=Aggiornare il plugin dopo i controlli di sicurezza finali
PluginManager.alwaysLoadPluginsFromCentralServer=Carica sempre i plugin via web? (SCONSIGLIATO!)
PluginManager.alwaysLoadPluginsFromCentralServerLong=If true, always download plugins over the web from our web server rather than over Freenet. This is more reliable but dangerous: While we use SSL, wiretappers may still be able to identify which plugin you download, and correlate it with when a new identity is created e.g. on Freemail;  certainly they could tell you use Freenet.
PluginManager.cannotSetOnceLoaded=Una volta caricata, non è più possibile impostare la lista dei plugin
PluginManager.deleteFailedPluginButton=Non riprovare al prossimo riavvio
PluginManager.loadedOnStartup=Plugin da caricare all'avvio
PluginManager.loadedOnStartupLong=Classpath, nome e locazione dei plugin da caricare all'avvio
PluginManager.loadedPlugins=Plugin da caricare all'avvio
PluginManager.loadedPluginsLong=Un elenco dei plugin che sono avviati quando parte Freenet
PluginManager.pluginReqNewerJVMTitle=Il plugin ${name} richiede una versione Java successiva.
PluginManager.pluginLoadingFailedTitle=Impossibile caricare il plugin!
PluginManager.pluginLoadingFailedShort=Impossibile caricare il plugin ${name}!
PluginManager.pluginLoadingFailed=Non è stato possibile caricare il plugin specificato ${name}.
PluginManager.pluginLoadingFailedStillTryingOverFreenet=Il caricamento del plugin da Freenet è ancora in corso.
PluginManager.pluginLoadingFailedWithMessage=Non è stato possibile caricare il plugin specificato ${name}: ${message}
PluginManager.officialPluginLoadFailedSuggestTryAgainFreenet=E' posibile riprovare a scaricare da Freenet, o scaricare dal web
PluginManager.officialPluginLoadFailedSuggestTryAgainHTTPS=E' possibile scaricare il plugin da Freenet o riprovare a scaricarlo dal web.
PluginManager.officialPluginLoadFailedTryAgainFreenet=Carica il plugin da Freenet
PluginManager.officialPluginLoadFailedTryAgain=Carica il plugin sul web dal nostro server (NON ANONIMO!)
PluginToadlet.addPluginTitle=Carica plugin
PluginToadlet.failedToLoadPlugin=Caricamento plugin fallito.
PluginToadlet.failedToLoadPluginCheckClass=Non è stato possibile caricare il plugin richiesto. Verificare il nome del plugin, class, e URL se se ne è usata una.
PluginToadlet.failedToLoadPluginTitle=Caricamento plugin fallito
PluginToadlet.internalNameTitle=Nome Interno
PluginToadlet.loadPluginCommand=Carica Plugin
PluginToadlet.noWebInterface=Questo plugin non ha interfaccia web e pertanto non c'è nulla da mostrare
PluginToadlet.noWebInterfaceTitle=Plugin non provvisto di interfaccia web
PluginToadlet.pluginList=Lista plugin
PluginToadlet.pluginListTitle=Lista Plugin
PluginToadlet.pluginNameTitle=Nome Plugin
PluginToadlet.pluginNotFound=Non è stato possibile trovare il plugin richiesto
PluginToadlet.pluginNotFoundTitle=Plugin non trovato
PluginToadlet.returnToPluginsWithLinks=${link}return${/link} alla lista di plugins.
PluginToadlet.unsupportedMethod=Metodo non supportato
PluginToadlet.unsupportedMethodTitle=Metodo non supportato
PluginToadlet.visit=Visita
PproxyToadlet.changeReloadOnStartup=Cambia
PproxyToadlet.downloadNotAllowedFromRemoteServer=Donload dei plugins è ammesso solo dal server di Freenet.
PproxyToadlet.Error=Errore
PproxyToadlet.fileonly=accetta solo file locali
PproxyToadlet.internalIDTitle=ID interna
PproxyToadlet.Load=Carica
PproxyToadlet.loadFreenetPlugin=Carica Plugin Non Ufficiale da Freenet
PproxyToadlet.loadFreenetPluginText=Inserire la URI del plugin che si vuole caricare. I plugin disponibili si Freenet non godono di alcun supporto ufficiale e non vengono controllati dagli sviluppatori di Freenet. Non è quindi possibile quindi garantire la privacy e la sicurezza di chi decidesse di utilizzarli.
PproxyToadlet.loadFreenetURLLabel=Chiave del plugin
PproxyToadlet.loadLabelDeprecated=deprecato
PproxyToadlet.loadLabelExperimental=sperimentale
PproxyToadlet.loadOfficialPlugin=Carica Plugin Ufficiale
PproxyToadlet.loadOfficialPluginText=QuestiPlugin Ufficiali non dovrebbero mettere in pericolo la privacy dell' Utente ma non è possibile offrire una garanzia al 100%. E' inoltre possibile caricare plugin non non ufficiali (vedi sotto)
PproxyToadlet.loadOfficialPluginLabel=Carica Plugin Ufficiale
PproxyToadlet.loadOtherPlugin=Carica Plugin Non Ufficiale
PproxyToadlet.loadOtherPluginText=Inserire qui la URL del plugin che si vuole caricare. ATTENZIONE! I Plugin non ufficiali non ricevono alcuna assistenza e non vengono controllati dai programmatory di Freenet, pertanto chi volesse utilizzarli lo farà A PROPRIO RISCHIO.
PproxyToadlet.loadOtherURLLabel=URL del plugin
PproxyToadlet.noPlugins=Nessun plugin caricato
PluginManager.pluginDesc.HelloWorld=Plugin di test. Non serve a nulla, solo per gli sviluppatori di nuovi plugin.
PluginManager.pluginDesc.HelloFCP=Plugin di test di FCP. Non serve a nulla, solo per gli sviluppatori di nuovi plugin.
PluginManager.pluginDesc.KeyUtils=Un utile strumento per esaminare chiavi Freenet, per esempio per fare una lista delle pagine in un freesite.
PluginManager.pluginDesc.MDNSDiscovery=Annuncia Freenet sulla rete locale (LAN) così i client possono collegarsi automaticamente al nodo. Non molto usato al momento.
PluginManager.pluginDesc.SNMP=Abilita la possibilità di controllare da remoto lo stato del tuo nodo Freenet con strumenti come MRTG.
PluginManager.pluginDesc.Freereader=Strumento per inserire feed RSS e ATOM come se fossero freesite.
PluginManager.pluginDesc.Library=Strumento per cercare dentro Freenet usando il vecchio o il nuovo formato degli indici di ricerca.
PluginManager.pluginName.Freemail=Freemail v0.1 (vecchio!)
PluginManager.pluginName.KeyUtils=Chiave di Utility
PproxyToadlet.pluginFilename=Nome
PproxyToadlet.pluginGroup.communication=Comunicazione
PproxyToadlet.pluginGroup.connectivity=Connettività
PproxyToadlet.pluginGroup.example=Esempio
PproxyToadlet.pluginGroup.file-transfer=Trasferimento file
PproxyToadlet.pluginGroup.index=Indicizzazione in corso
PproxyToadlet.pluginGroup.technical=Technica
PproxyToadlet.pluginVersion=versione
PproxyToadlet.pluginNotFoundReload=Non è stato possibile localizzare il plugin specificato per poterlo ricaricare.
PproxyToadlet.pluginNotFoundReloadTitle=Plugin non trovato (ricaricamento in corso)
PproxyToadlet.pluginNotFoundUpdatingTitle=Plugin non trovato (aggiornamento)
PproxyToadlet.pluginNotFoundUpdating=Il plugin che state tentando di aggiornare non è caricato!
PproxyToadlet.pluginSourceChoice=E' possibile scegliere se scaricare il plugin da Freenet o dai server del Progetto:
PproxyToadlet.pluginSourceFreenet=Scarica da Freenet. Questa è la scelta sicura e non rintracciabile, ma dal completamento più lento.
PproxyToadlet.pluginSourceHTTPS=Scarica dai server sul web non anonimo.
PproxyToadlet.pluginUnloaded=Plugin terminato
PproxyToadlet.pluginUnloadedWithName=Il plugin ${name} è stato terminato.
PproxyToadlet.plugins=Plugin
PproxyToadlet.reloadOnStartupShort=Ricarica all'avvio
PproxyToadlet.reload=Ricarica
PproxyToadlet.reloadPluginTitle=Ricarica Plugin
PproxyToadlet.reloadExplanation=Ricaricare un plugin è come scaricarlo e ricaricarlo.
PproxyToadlet.reloadWarning=Attenzione: alcuni plugin reagiscono in modo non ottimale a un reload.
PproxyToadlet.reloadPurgeWarning=Rimuovi il plugin dalla cache prima di ricaricarlo. Se il plugin era stato scaricato da internet, sarà scaricato nuovamente.
PproxyToadlet.refreshOnStartup=Ricarica da server all'avvio
PproxyToadlet.returnToPluginPage=Torna alla pagina dei plugin
PproxyToadlet.startedAtTitle=Avviato:
PproxyToadlet.startingPluginsTitle=Avvio plugins in corso
PproxyToadlet.startingPluginName=Nome del plugin
PproxyToadlet.startingPluginStatus=Stato attuale
PproxyToadlet.startingPluginStatus.downloading=creazione copia locale in corso
PproxyToadlet.startingPluginStatus.starting=Avvio in corso
PproxyToadlet.startingPluginTime=tempo trascorso
PproxyToadlet.pluginDirectoryNotCreated=Non è stato possibile creare una directory per i plugin.
PproxyToadlet.pluginNotDownloaded=Non è stato possibile scaricare il plugin
PproxyToadlet.pluginStopping=Disconnessione plugin in corso
PproxyToadlet.unload=Termina
PproxyToadlet.unloadPluginTitle=Termina plugin?
PproxyToadlet.unloadPluginWithName=Conferma terminazione ${name}?
PproxyToadlet.unloadPurge=Rimuovi plugin da cache
PproxyToadlet.versionTitle=Versione
SaltedHashFreenetStore.shortResizeProgress=Ridimensionamento del datastore(${name}) in corso: ${processed}/${total}
SaltedHashFreenetStore.shortRebuildProgressNew=Archivio Dati(${name}) Manutenzione in Corso$ {processed}/${total} (Sto Convertendo al nuovo formato)
SaltedHashFreenetStore.shortRebuildProgress=Manutenzione del datastore(${name}) in corso: ${processed}/${total}
SaltedHashFreenetStore.longResizeProgress=Ridimensionamento del datastore(${name}) in corso: ${processed}/${total}. Il nodo potrebbe risultare più lento durante questa operazione. Evitare di riavviare il nodo durante il processo.
SaltedHashFreenetStore.longRebuildProgress=Manutenzione del datastore(${name}) in corso: ${processed}/${total}. Il nodo potrebbe risultare più lento durante questa operazione. Evitare di riavviare il nodo durante il processo.
SaltedHashFreenetStore.cleanerAlertTitle=Manutenzione del datastore (magazzino dati) in corso
QueueToadlet.awaitingCompression=In Attesa
QueueToadlet.awaitingPasswordTitleDownloads=Password di accesso alla coda dei download
QueueToadlet.awaitingPasswordTitleUploads=Password di accesso alla coda degli upload
QueueToadlet.badMIMETypeIntro=I download seguenti sono di tipo ${type}. Freenet non possiede nessun tipo di supporto incorporato per rendere sicuro questo tipo, e sappiamo che potrebbe contenere molte cose pericolose che possono compromettere il tuo anonimato. Se sei sicuro di volere scaricare comunque questi file, marca la casella vicina a ciascun download e premi Riavvia.
QueueToadlet.backToUploadsPage=Torna alla pagina degli upload
QueueToadlet.backToDownloadsPage=Torna alla pagina dei download
QueueToadlet.bulkDownloadSelectOptionDisk=su disco
QueueToadlet.bulkDownloadSelectOptionDirect=in spazio temporaneo
QueueToadlet.DUinProgress=Directory upload in corso
QueueToadlet.DinProgress=Download in corso
QueueToadlet.UinProgress=Upload in corso
QueueToadlet.cancelSelected=Cancella
QueueToadlet.compatModeLabel=Modalità di compatibilità
QueueToadlet.compatibilityMode=Modalità di compatibilità
QueueToadlet.change=Modifica
QueueToadlet.changeDownloadPriorities=Cambia la priorità dei download
QueueToadlet.changeUploadPriorities=Cambia la priorità degli upload
QueueToadlet.completedDU=Upload di directory completati
QueueToadlet.completedDinDownloadDirectory=Download completati (directory dei download) (${size})
QueueToadlet.completedDinTempDirectory=Download Completati (directory temporanea) (${size})
QueueToadlet.completedDtoDisk=Download completati
QueueToadlet.completedU=Upload completati: (${size})
QueueToadlet.completedUDirectory=Directory Upload Completati:(${size})
QueueToadlet.compressing=Compressione in corso
QueueToadlet.confirmDeleteTitle=Il file sta per essere eliminato. Conferma?
QueueToadlet.deleteFileFromTemp=ELIMINA FILE
QueueToadlet.disableFilter=Disabilita il filtro dei contenuti
QueueToadlet.dontCompressInCompatCell=non usare compressione
QueueToadlet.download=Scarica
QueueToadlet.downloadDisallowed=Il download nella cartella "${directory}" non è permesso dalla configurazione attuale.
QueueToadlet.downloadFiles=Download multipli
QueueToadlet.downloadFilesInstructions=Per download multipli, incollare una lista chiavi nello spazio sottostante, una per rigo.
QueueToadlet.downloadSucceededTitle=Download completato: ${filename}
QueueToadlet.downloadsSucceededTitle=${nr} download completati
QueueToadlet.downloadSucceeded=Il file ${origlink}${filename}${/origlink} è stato scaricato. ${link}Click qui${/link} per aprile il file (${size}).
QueueToadlet.enqueuedSuccessfully=Aggiunte alla coda dei download ${number} chiavi elencate di seguito:
QueueToadlet.enqueuedFailure=Le seguenti ${number} chiavi non possono essere accodate:
QueueToadlet.errorAccessDenied=Errore: Accesso Negato
QueueToadlet.errorAccessDeniedFile=L'attuale configurazione del nodo non consente l'upload del file "${file}".
QueueToadlet.errorDToDisk=Non è stato possibile scaricare su disco
QueueToadlet.errorDToDiskConfig=L'attuale configurazione del nodo non consente di scaricare file nella directory dei download
QueueToadlet.errorDownloadNotCompleted=Download Non Completato
QueueToadlet.errorDownloadNotFound=Non è stato possibile localizzare il download richiesto
QueueToadlet.errorDownloadNotFoundExplanation=Non è stato possibile trovare il download specificato. Potrebbe essere stato eliminato in precedenza.
QueueToadlet.errorInvalidURI=URI non valida
QueueToadlet.errorInvalidURIToD=La URI non è valida e pertanto non può essere scaricata.
QueueToadlet.errorInvalidURIToU=Non è stata specificata alcuna URI valida dove inserire il file
QueueToadlet.tooManyFilesInOneFolder=Non posso iniziare l'inserimento: Troppi file nella stessa cartella (directory).
QueueToadlet.errorMustSpecifyKeyTypeTitle=Devi specificare che tipo di chiave usare quando carichi un file!
QueueToadlet.errorMustSpecifyKeyType=Devi specificare che tipo di chiave usare quando carichi un file! Usa SSK se non sei certo, dato che è più sicuro. Usa CHK se vuoi che sia la stessa chiave ogni volta (buono per la condivisione di file) ma solo se non ti importa della sicurezza.
QueueToadlet.errorNoFileOrCannotRead=File inesistente o illegibile
QueueToadlet.errorNoFileSelected=Nessun file selezionato
QueueToadlet.errorNoFileSelectedU=Non e' stato selezionato alcun file per l'upload
QueueToadlet.errorNoKey=Non è stata specificata alcuna chiave per il download
QueueToadlet.errorNoKeyToD=Non è stata specificata una chiave per il download
QueueToadlet.failedD=Download falliti
QueueToadlet.failedDUnknownMIME=Download non riusciti: tipo sconosciuto ${type} (${size})
QueueToadlet.failedDBadMIME=Download non riusciti: tipi pericolosi noti ${type} (${size})
QueueToadlet.failedDU=Upload di directory falliti
QueueToadlet.failedToRemove=Non è stato possibile rimuovere ${id}: ${message}
QueueToadlet.failedToRemoveId=Non è stato possibile eliminare: ${id}
QueueToadlet.failedToRemoveAll=Rimozione di tutte le richieste fallita. Eliminarle una per una o in alternativa arrestare il nodo ed eliminare manualmente il file del client database (client.dat)
QueueToadlet.failedToRemoveRequest=Non è stato possibile eliminare la richiesta
QueueToadlet.failedToRestart=Non è stato possibile riavviare: ${id}
QueueToadlet.failedToRestartRequest=Non e' stato possibile riavviare la richiesta
QueueToadlet.failedU=Upload falliti
QueueToadlet.fcpIsMissing=Server FCP non trovato
QueueToadlet.fileName=Percorso locale
QueueToadlet.files=File
QueueToadlet.filterData=Filtro:
QueueToadlet.filterDataMessage=Scegli questo per avviare la tua richiesta tramite il filtro dei contenuti. Il filtro tenterà di impedire al tuo computer di eseguire qualsiasi cosa che potrebbe danneggiarlo, o infrangere il tuo anonimato. E` fortemente raccomandado di mantenere questo selezionato.
QueueToadlet.follow=Segui Redirect
QueueToadlet.globalQueueIsEmpty=Nessuna operazione in corso
QueueToadlet.identifier=Identificazione
QueueToadlet.insertAs=Inserisci come:
QueueToadlet.insertFile=Inserisci File
QueueToadlet.insertFileLabel=File
QueueToadlet.insertFileCompressLabel=Usa compressione
QueueToadlet.insertFileInsertFileLabel=Inserisci File
QueueToadlet.insertFileBrowseLabel=Scegli un file dal disco del nodo
QueueToadlet.insertFileBrowseButton=Sfoglia
QueueToadlet.insertFileResetForm=Annulla
QueueToadlet.key=Chiave
QueueToadlet.lastActivity=Ultimo progresso
QueueToadlet.lastActivity.unknown=sconosciuta
QueueToadlet.lastActivity.ago=${time} fà
QueueToadlet.lastFailure=Ultimo fallimento
QueueToadlet.lastFailure.never=mai
QueueToadlet.lastFailure.ago=${time} fa
QueueToadlet.legend=Significato dei colori: Priorità...
QueueToadlet.mimeProblemFetchAnyway=Ad ogni modo puoi chiedere a Freenet di richiamare i file premendo Riavvia (PRIMA LEGGI L'AVVERTIMENTO SOPRASTANTE!)
QueueToadlet.mimeType=MIME type
QueueToadlet.noTaskOnGlobalQueue=Nessuna operazione in coda globale al momento.
QueueToadlet.none=nessuno
QueueToadlet.overriddenCryptoKeyInCompatCell=chiave di criptaggio casuale
QueueToadlet.panicButtonTitle=Bottone emergenza
QueueToadlet.panicButtonNoConfirmation=Fare clic per eliminare tutti i download/upload in coda e tutte le tracce di siti visitati e file scaricati attraverso Freenet. NON verranno rimossi i file scaricati su disco, i siti visitati conservati nel browser, ecc. Freenet non verrò disinstallato. Senza conferma!
QueueToadlet.panicButtonWithConfirmation=Fare clic per eliminare tutti i download/upload in coda e tutte le tracce di siti visitati e file scaricati attraverso Freenet. NON verranno rimossi i file scaricati su disco, i siti visitati conservati nel browser, ecc. Freenet non verrò disinstallato.
QueueToadlet.confirmPanicButtonPageTitle=Conferma bottone emergenza
QueueToadlet.confirmPanicButton=Cliccando 'si' verranno eliminati tutti i file dalla cache dei siti visitati di recente, il file delle chiavi principali verrà eliminato e con esso tutti i download e upload, ogni traccia di precedenti download e upload verrà eliminata, e Freenet verrà riavviato. Conferma?
QueueToadlet.confirmPanicButtonYes=Si, elimina tutto
QueueToadlet.confirmPanicButtonNo=No, non eliminare nulla
QueueToadlet.persistence=Persistenza
QueueToadlet.persistenceForever=illimitata
QueueToadlet.persistenceNone=nessuna
QueueToadlet.persistenceBrokenTitle=Il database della coda download/upload risulta corrotto.
QueueToadlet.persistenceBrokenShortAlert=La coda download/upload risulta compromessa a causa di una corruzione nel database. Cliccare per dettagli e istruzioni.
QueueToadlet.pleaseEnableFCP=Per accedere a questa pagina è necessario abilitare il server FCP
QueueToadlet.panicButton=PANICO!
QueueToadlet.priority0=emergenza
QueueToadlet.priority1=molto alta
QueueToadlet.priority2=alta
QueueToadlet.priority3=media
QueueToadlet.priority4=bassa
QueueToadlet.priority5=bassissima
QueueToadlet.priority6=campa cavallo
QueueToadlet.priority=Priorità
QueueToadlet.progress=Completato
QueueToadlet.progressbarAccurate=Questo valore e' accurato
QueueToadlet.progressbarNotAccurate=I valori possono essere imprecisi perché il processo di download del file non e' stato finalizzato
QueueToadlet.uploadProgressbarNotAccurate=Il valore di questo indicatore di progresso può essere falsato quando l'upload codifica ulteriori blocchi.
QueueToadlet.reason=Motivo
QueueToadlet.remove=Elimina
QueueToadlet.removeFinishedUploads=Rimuovi i caricamenti completati
QueueToadlet.requestNavigation=Esplora Richieste
QueueToadlet.restart=Riavvia
QueueToadlet.restartSelected=Riavvia
QueueToadlet.returnToQueuePage=Torna alla ${link}pagina della coda${/link}.
QueueToadlet.tryAgainUploadFilePage=${link}Riprova${/link} a caricare un file.
QueueToadlet.recommend=Raccomanda
QueueToadlet.recommendAFileToFriends=Raccomanda un file ad amici
QueueToadlet.recommendDescription=Descrizione del file:
QueueToadlet.recommendToFriends=Raccomanda ad amici
QueueToadlet.recommendFilesToFriends=Raccomanda dei file agli amici
QueueToadlet.browseToChange=Sfoglia per cambiare
QueueToadlet.siteUploadSucceededTitle=Inserzione freesite completata: ${filename}
QueueToadlet.sitesUploadSucceededTitle=${nr} inserzioni di freesite completate
QueueToadlet.siteUploadSucceeded=E' stato completato l'upload del freesite ${filename} (${files} files, dimensioni totali ${size}). ${link}Clicca qui${/link} per aprire la homepage del sito.
QueueToadlet.size=Dimensioni
QueueToadlet.shuttingDownTitle=Arresto del nodo in corso.
QueueToadlet.shuttingDown=La coda download/upload non è disponibile perché l'arresto del nodo è in corso.
QueueToadlet.starting=AVVIAMENTO IN CORSO
QueueToadlet.title=Coda globale
QueueToadlet.titleUploads=Upload
QueueToadlet.titleDownloads=Download
QueueToadlet.totalQueuedDownloads=Totale download in coda: ${size}
QueueToadlet.totalQueuedUploads=Totale upload in coda: ${size}
QueueToadlet.totalSize=Dimensioni Totali
QueueToadlet.unknown=Non Disp.
QueueToadlet.uploadSucceededTitle=Inserzione completata: ${filename}
QueueToadlet.uploadsSucceededTitle=${nr} inserimenti completati
QueueToadlet.uploadSucceeded=Il file ${filename} (size ${size}) è stato correttamente caricato su Freenet. ${link}Click qui${/link} per aprire il file.
QueueToadlet.warningUnsafeContent=Contenuto Potenzialmente Pericoloso
RequestStatus.unknownFilename=nome file sconosciuto
RequestStarterGroup.schedulerSSKInserts=Policy di priorità dello scheduler (inserzioni SSK)
RequestStarterGroup.schedulerSSKRequests=Policy di priorità dello scheduler (richieste SSK)
RequestStarterGroup.schedulerCHKInserts=Policy di priorità dello scheduler (inserzioni CHK)
RequestStarterGroup.schedulerCHKRequests=Policy di priorità dello scheduler (richieste CHK)
RequestStarterGroup.scheduler=Policy di priorità dello schedulatore
RequestStarterGroup.schedulerLong=Imposta lo schema delle policy di priorità usate dallo schedulatore.
RevocationKeyFoundUserAlert.textDetail=Il messaggio è: ${message}
RevocationKeyFoundUserAlert.textDisabledDetail=Il motivo è: ${message}.
RevocationKeyFoundUserAlert.title=URGENTE: Il sistema di aggiornamento automatico di Freenet è stato compromesso!
SecurityLevels.title=Livelli di sicurezza
SecurityLevels.tooltip=Configura il grado di sicurezza del tuo nodo Freenet
SecurityLevels.networkThreatLevelShort=Protezione contro uno sconosciuto che ti attacchi su Internet
SecurityLevels.networkThreatLevel=Quanta sicurezza necessiti contro persone e organizzazioni che tentino di tracciare cosa stai facendo su Freenet?
SecurityLevels.networkThreatLevel.name.MAXIMUM=MASSIMO
SecurityLevels.networkThreatLevel.name.HIGH=ALTO
SecurityLevels.networkThreatLevel.name.NORMAL=NORMALE
SecurityLevels.networkThreatLevel.name.LOW=BASSO
SecurityLevels.networkThreatLevel.choice.MAXIMUM=Intendo accedere a informazioni che potrebbero portare al mio arresto, imprigionamento, o peggio. Capisco che Freenet è sperimentale e che non può assicurare la sicurezza contro certi attacchi noti, ma accetto i rischi comparati alle alternative.
SecurityLevels.networkThreatLevel.desc.MAXIMUM=Freenet sarà ${bold}significativamente${/bold} più lenta che in ALTO, e si connetterà solo agli Amici. Se si può presumere con sicurezza che un attaccante sia inizialmente distante, che non sappia chi stia bersagliando come persona reale e che conosca solo ciò che sta tracciando, e che sia costoso per lui hackerare e aprirsi la strada attraverso la rete tramite l'ingegneria sociale (e se non c'è un bug vistoso), la tua identità reale dovrebbe essere al sicuro.
SecurityLevels.networkThreatLevel.choice.HIGH=Vorrei rendere molto più difficile per gli altri monitorare le mie comunicazioni, o sono preoccupato riguardo agli ISP e/o governi che tentino di bloccare Freenet.
SecurityLevels.networkThreatLevel.desc.HIGH=Connettersi solo ad Amici migliora massicciamente la sicurezza, ma Freenet sarà lenta a meno che tu aggiunga almeno 5-10 amici.
SecurityLevels.networkThreatLevel.choice.NORMAL=Vivo in un paese relativamente sicuro, ma vorrei rendere più difficile per gli altri monitorare le mie comunicazioni.
SecurityLevels.networkThreatLevel.desc.NORMAL=Freenet sarà ragionevolmente attenta a proteggere il tuo anonimato, al costo di un po' delle prestazioni. Quando possibile dovresti aggiungere amici che usano Freenet e passare ad ALTO.
SecurityLevels.networkThreatLevel.choice.LOW=Non mi importa del monitoraggio e voglio prestazioni massime.
SecurityLevels.networkThreatLevel.desc.LOW=Potrebbe essere abbastanza facile per gli altri scoprire la tua identità!
SecurityLevels.networkThreatLevel.opennetIntro=Conosci personalmente qualcuno che usa già Freenet? Se conosci almeno 3 persone che usano già Freenet, puoi abilitare la modalità darknet, così che Freenet si connetta solamente ai tuoi Amici, migliorando grandemente la sicurezza.Comunque, se non conosci nessuno che sia già su Freenet, o se vuoi prestazioni massime, dovresti abilitare la modalità opennet, e Freenet si connetterà automaticamente ad altri nodi Freenet fatti girare da sconosciuti (e dai tuoi Amici).
SecurityLevels.networkThreatLevel.opennetFriendsWarning=Aggiungere come Amici persone che non conosci al di fuori di Freenet non aumenterà la sicurezza e ridurrà le prestazioni!
SecurityLevels.networkThreatLevel.opennetLabel=Modalità opennet (connessione a sconosciuti e amici)
SecurityLevels.networkThreatLevel.opennetExplain=Non conosco nessuno che usi già Freenet: Connettiti ad altri nodi Freenet automaticamente.
SecurityLevels.networkThreatLevel.darknetLabel=Modalità darknet (connessione solo ad amici)
SecurityLevels.networkThreatLevel.darknetExplain=Conosco almeno 3 persone (10 e più per una buona prestazione) che usano già Freenet: Connettiti solo agli Amici.
SecurityLevels.noFriendsWarning=Non hai aggiunto nessun Amico. Se vuoi impostare il livello di sicurezza di rete su alto o massimo, non ti sarà possibile connetterti a Freenet finché non avrai almeno un Amico connesso! Tieni presente che per esserci un qualsiasi beneficio di sicurezza significativo, questi devono essere persone che conosci davvero e di cui ti fidi almeno marginalmente, e per avere delle buone prestazioni ti serviranno almeno 5-10 di loro sempre connessi. Sei sicuro?
SecurityLevels.noFriendsCheckbox=Sono sicuro, abilita il livello di sicurezza alto, aggiungerò alcuni Amici il prima possibile.
SecurityLevels.noConnectedFriendsWarning=Non hai nessun Amico connesso, sebbene tu abbia aggiunto ${added} amico/ci. Se imposti il livello di sicurezza della rete su alto o massimo, ti sarà possibile connetterti a Freenet solo quando i tuoi amici sono online, cosa che non sono al momento. Dovresti aggiungere Amici aggiuntivi, usare Freenet quando i tuoi amici sono connessi o non aumentare ad una sicurezza alta. Tieni presente che per esserci un qualsiasi beneficio di sicurezza significativo, i tuoi Amici devono essere persone che conosci davvero e di cui ti fidi almeno marginalmente, e per avere delle buone prestazioni ti serviranno almeno 5-10 di loro sempre connessi. Sei sicuro?
SecurityLevels.noConnectedFriendsCheckbox=Sono sicuro, aggiungerò più Amici e/o accetterò che Freenet sia online solo quando i miei Amici esistenti sono online.
SecurityLevels.fewConnectedFriendsWarning=In questo momento avete solo ${connected} Amici connessi, ed avete aggiunto ${added} amici in totale. Se impostate il livello di sicurezza della rete su alto o massimo, Freenet si connetterà solo ai vostri amici, quindi le vostre prestazioni potrebbero venire ridotte significativamente, e se tutti i vostri  Amici fossero offline allora non sarà in grado di connettersi del tutto. Tenete presente che gli Amici devono essere persone che conosci e di cui vi fidate almeno marginalmente perché ci sia un qualunque beneficio reale di sicurezza, e vi serviranno almeno 5-10 Amici connessi per una buona prestazione. Siete sicuri?
SecurityLevels.fewConnectedFriendsCheckbox=Sono sicuro, aggiungerò più Amici e/o accetterò il costo di prestazioni e il fatto che Freenet potrebbe non connettersi quando i miei amici sono offline.
SecurityLevels.networkThreatLevelLowWarning=Stai per abbassare il livello del grado di sicurezza della rete del tuo nodo a basso. Questo significa che sarà semplice per degli sconosciuti attaccare il tuo anonimato su Internet. Sei sicuro?
SecurityLevels.networkThreatLevelLowCheckbox=Sono sicuro, voglio più velocità e non mi importa chi possa dire cosa sto facendo con Freenet!
SecurityLevels.networkThreatLevelConfirmTitle=ATTENZIONE: Impostazione del livello di sicurezza su ${mode}
SecurityLevels.maximumNetworkThreatLevelWarning=${bold}ATTENZIONE:${/bold} Stai per impostare il livello massimo di sicurezza di rete! Questo ti rallenterà ${bold}significativamente${/bold} Freenet! Per favore non farlo a meno che ti serva davvero quella sicurezza!
SecurityLevels.maxSecurityYouNeedFriends=${bold}Devi conoscere almeno una persona che stia già usando Freenet${/bold}, preferibilmente 3, 5-10 per buone prestazioni. Devi aggiungerle alla pagina degli Amici. Queste devono essere persone che conosci già e di cui ti fidi almeno marginalmente.
SecurityLevels.maximumNetworkThreatLevelCheckbox=Sì voglio davvero abilitare la massima sicurezza, capisco che Freenet è ancora sperimentale e che potrebbe essere ancora possibile tracciarmi, e che questa impostazione potrebbe ridurre drammaticamente le prestazioni di Freenet!
SecurityLevels.physicalThreatLevelShort=Protezione se il tuo computer viene confiscato o rubato
SecurityLevels.physicalThreatLevel=Quanto sei preoccupato riguardo a persone che rubino o confischino il tuo computer e siano in grado di vedere cosa hai fatto su Freenet?
SecurityLevels.physicalThreatLevelSwapfileWindows=Su certe versioni di Windows puoi fare questo con il comando "fsutil behavior set encryptpagingfile 1".
SecurityLevels.physicalThreatLevel.name.LOW=BASSO
SecurityLevels.physicalThreatLevel.name.NORMAL=NORMALE
SecurityLevels.physicalThreatLevel.choice.NORMAL=Sono preoccupato. Cripta tutti i dati importanti. (La maggior parte degli utenti dovrebbe scegliere questa opzione)
SecurityLevels.physicalThreatLevel.desc.NORMAL=Puoi cancellare dati sensibili usando il pulsante di panico o cancellando in modo sicuro il file master.keys.Ti raccomandiamo di Richiamare file grossi piuttosto di farne il Download, così che siano criptati e possano essere visti attraverso la pagina dei download.
SecurityLevels.physicalThreatLevel.name.HIGH=ALTO
SecurityLevels.physicalThreatLevel.choice.HIGH=Sono molto preoccupato. Cripta tutti i dati importanti con una password. (Scegli questo se sei contento di fare affidamento su di una password)
SecurityLevels.physicalThreatLevel.desc.HIGH=Dovrai inserire la password per accedere alla tua coda di download (ed alla cache dei siti visitati di recente). Puoi anche usare il pulsante di panico.
SecurityLevels.physicalThreatLevel.name.MAXIMUM=MASSIMO
SecurityLevels.physicalThreatLevel.choice.MAXIMUM=Sono estremamente preoccupato. Cripta tutto e non immagazzinare la chiave. Cancella tutto, inclusi i download, ogni qual volta Freenet è riavviato. (Freenet non ricorderà cosa hai visitato tra i riavvii, perciò scaricherà nuovamente la roba; questo potrebbe renderti leggermente più vulnerabile sul livello rete ma se sei molto preoccupato riguardo alla confisca scegli questa opzione).
SecurityLevels.physicalThreatLevelEnd=Dovresti seguire precauzioni di sicurezza comuni (mantenere aggiornato, usare un antivirus, non aprire file di cui non ti fidi, ecc.), e tenere presente che se catturano il tuo computer mentre è acceso e e sta facendo girare Freenet, nessuna quantità di criptaggio potrà aiutarti!
OperatingSystemName.Unknown=il tuo sistema operativo
SecurityLevels.userAlertShortText=Livelli di sicurezza: Rete: ${network}, Amici: ${friends}, Fisica: ${physical}
SecurityLevels.userAlertNetworkThreatLevel=Protezione contro uno sconosciuto che ti attacchi su Internet: ${level}
SecurityLevels.userAlertPhysicalThreatLevel=Protezione se il tuo computer viene confiscato o rubato: ${level}
SecurityLevels.userAlertExtro=Puoi cambiare queste impostazioni nella ${link}pagina di configurazione${/link}.
SecurityLevels.passwordPageTitle=Prego inserisci la password principale
SecurityLevels.passwordWrongTitle=Password inserita sbagliata
SecurityLevels.enterPasswordTitle=Inserire la password principale per accedere ai contenuti della cache ed ai download/upload accodati
SecurityLevels.passwordWrong=Hai inserito la password sbagliata. Per favore inserisci la password corretta per abilitare l'accesso alla cache del client e migliorare le prestazioni di navigazione.
SecurityLevels.enterPassword=Prego inserisci la password principale per abilitare l'accesso ai download ed agli upload e per migliorare le prestazioni abilitando la cache dei freesite visitati di recente.
SecurityLevels.setPasswordLabel=Imposta la password
SecurityLevels.setPassword=Prego imposta la password principale, che sarà usata per proteggere il contenuto della cache. Più forte è la password, più forte è la protezione: molte lettere e numeri e segni di punteggiatura sono meglio.
SecurityLevels.passwordNotZeroLength=La password deve essere lunga almeno un carattere, per esempio non deve essere "".
SecurityLevels.passwordForDecryptTitle=Prego inserisci la vecchia password
SecurityLevels.passwordForDecrypt=Per sproteggere la cache del client ecc., ci serve la vecchia password.
SecurityLevels.cantWriteNewMasterKeysFileTitle=Impossibile scrivere il nuovo file master.keys!
SecurityLevels.cantWriteNewMasterKeysFile=Qualcosa è andato storto - potrebbe essere finito lo spazio su disco o potrebbe essere un problema del disco fisso. Vedi il messaggio d'errore seguente per i dettagli:
SecurityLevels.oldPasswordLabel=Vecchia password:
SecurityLevels.newPasswordLabel=Nuova password:
SecurityLevels.setPasswordTitle=Imposta una nuova password principale
SecurityLevels.changePasswordButton=Cambia password
SecurityLevels.changePasswordTitle=Cambia la password principale
SecurityLevels.backToSecurityLevels=Non impostare o cambiare la password e torna alla pagina dei livelli di sicurezza.
SecurityLevels.passwordFileCorruptedTitle=Il file della password principale è corrotto
SecurityLevels.passwordFileCorrupted=Il file della password principale ${file} è stato corrotto. Puoi cancellarlo e perdere la cache del client e le code di download e upload, o ripristinarlo da un backup.
SecurityLevels.wrongOldPassword=Hai inserito una vecchia password sbagliata. Se hai perso la password puoi rimuovere il file master.keys per impostare una nuova password, ma perderai tutti i dati protetti dalla vecchia password - in particolare la cache dei siti visitati di recente e la coda dei download.
SecurityLevels.cantDeletePasswordFileButton=Riprova
SecurityLevels.warningMaximumWillDeleteQueue=Attenzione: Freenet cancellerà le tua coda di download e upload al prossimo riavvio se scegli questo livello di sicurezza!
SecurityLevelsToadlet.fullTitle=Livelli di sicurezza
SecurityLevels.statusBarPrefix=Livelli di sicurezza:
StringArrOption.parseError=Impossibile interpretare il valore come array di stringhe: ${error}
ShortOption.unrecognisedShort=Il valore specificato non può essere analizzato come un intero a 16 bit: ${val}
SimpleHelpToadlet.CHK=CHK = Content Hash Key - Chiave statica derivata dall' hash matematico di un file.
SimpleHelpToadlet.SSK=SSK = Signed Subspace Key - Chiave di subspazio, firmata
SimpleHelpToadlet.USK=USK = Updateable Subspace Key - Chiave di subspazio, aggiornabile
SimpleHelpToadlet.connectivityText=Prova. Test. uno, due tre, prova.   Bla bla bla, eccetera eccetera eccetera
SimpleHelpToadlet.connectivityTitle=Connettività
SimpleHelpToadlet.definitionsTitle=Definizioni
SimpleHelpToadlet.descriptionText=Questa pagina contiene alcume informazioni basilari per cominciare ad usare Freenet. Informazioni più dettagliate (in inglese) sono disponibili presso il sito ufficiale del progetto http://freenetproject.org, il wiki http://wiki.freenetproject.org e su Freenet stesso, presso diversi freesties.
SimpleHelpToadlet.descriptionTitle=Descrizione
SimpleToadletServer.advancedMode=Abilita modalità avanzata
SimpleToadletServer.advancedModeLong=Mostra informazioni che possono interessare solo utenti avanzati o sviluppatori. Nella maggioranza dei casi dovrebbe essere impostata su 'falso'.
SimpleToadletServer.allowedFullAccess=Host ai quali è consentito pieno accesso a FProxy (leggere l'avvertenza)
SimpleToadletServer.allowedFullAccessLong=Host ai quali è consentito accesso pieno al nodo (cambiare impostazioni di configurazione, riavviare, ecc). AVVERTENZA: Usare cautela nel decidere a chi consentire accesso pieno!
SimpleToadletServer.allowedHosts=Nomi host o indirizzi IP ai quali e' consentito connettersi a FProxy
SimpleToadletServer.allowedHostsLong=Può essere una lista di IP separati da virgole e IP in formato CIDR come 192.168.0.0/24. Tutti possono accedere al disco rigido nei limiti definiti dalle altre opzioni di configurazione.
SimpleToadletServer.bindTo=Indirizzo IP del servizio
SimpleToadletServer.bindToLong=Indirizzo IP del servizio
SimpleToadletServer.cannotChangePortOnTheFly=Non è possibile cambiare il numero della porta FProxy "al volo"
SimpleToadletServer.cssName=Nome del CSS
SimpleToadletServer.cssNameLong=Nome del CSS utilizzato da FProxy
SimpleToadletServer.cssOverride=Usa un CSS personalizzato (ATTENZIONE!)
SimpleToadletServer.cssOverrideCantRead=Non è stato possibile leggere il file di sovrascrittura CSS fornito: ${filename}
SimpleToadletServer.disableProgressPage=Disabilita pagina del progresso durante il caricamento di pagine
SimpleToadletServer.doRobots=Usa robots.txt per escludere i robot
SimpleToadletServer.doRobotsLong=Pubblica un file /robots.txt allo scopo di tenere lontano Google, spiders, Wget, etc.
SimpleToadletServer.enableActivelinks=Abilita activelinks
SimpleToadletServer.enableActivelinksLong=Determina se visualizzare le icone per I siti aggiunti ai segnalibri alla pagina 'Esplora Freenet'. Una pagina senza icone carica più velocemente... ma ovviamente non ha le icone!
SimpleToadletServer.enableWP=Abilitare l'utilizzo del web pushing da parte dell'interfaccia web? (sperimentale)
SimpleToadletServer.enabled=Abilita FProxy
SimpleToadletServer.enabledLong=Abilitare FProxy e relativi servizi HTTP?
SimpleToadletServer.enableExtendedMethodHandling=Abilita metodo esteso di trattamento HTTP
SimpleToadletServer.enableInlinePrefetch=Abilita pre-ricezione (prefetching) di immagini inlinea (inline)
SimpleToadletServer.enableInlinePrefetchLong=Questo potrebbe essere utile se il browser utilizza un numero ridotto di connessioni per comunicare con il nodo. D'altra parte potrebbe non esserlo.
SimpleToadletServer.enablePersistentConnections=Abilita connessioni HTTP persistenti(Leggere la descrizione)
SimpleToadletServer.enablePersistentConnectionsLong=Non abilitare questa opzione tranne nel caso in cui il browser sia configurato per usare molte connessioni anche se sono persistenti.
SimpleToadletServer.hasCompletedWizard=E' già stata completata la configurazione automatica?
SimpleToadletServer.hasCompletedWizardLong=Se la configurazione automatica di Freenet non è ancora stata completata, FProxy redirigerà tutte le richieste alla pagina apposita.
SimpleToadletServer.illegalCSSName=Il nome CSS non può contenere i catarreri "barra" (/ slash) e "due punti" ( : colon)
SimpleToadletServer.maxFproxyConnections=Numero massimo di connessioni fproxy
SimpleToadletServer.maxFproxyConnectionsLong=Numero massimo di connessioni fproxy che verranno gestite in una sola volta. Ognuna usa un thread.
SimpleToadletServer.panicButton=Mostra bottone Emergenza
SimpleToadletServer.panicButtonLong=Mostra il bottone Emergenza nella pagina della Coda. Se usato, Il bottone Emergenza rimuove tutte le richieste che non hanno ricevuto conferma.
SimpleToadletServer.noConfirmPanic=Nessuna conferma sul bottone emergenza
SimpleToadletServer.noConfirmPanicLong=Se impostato su 'vero' il bottone emergenza eseguirà il comando immediatamente, senza chidere conferma.
SimpleToadletServer.passthroughMaxSize=Dimensione massima per pass-though trasparente in FProxy
SimpleToadletServer.passthroughMaxSizeLong=Dimensione massima di un file per pass-through trasparente in FProxy.
SimpleToadletServer.port=Numero della porta FProxy
SimpleToadletServer.portLong=Numero della porta FProxy
SimpleToadletServer.publicGatewayMode=Modalità gateway pubblico (Ha effetto solo sulle connessioni autorizzate ma senza accesso pieno)
SimpleToadletServer.publicGatewayModeLong=Abilita modalità gteway pubblico? Per gli indirizzi IP con accesso al nodo autorizzato ma non pieno, questa opzione disabilita l'accesso alla coda dei download ed a tutte le operazioni di cui ci si potrebbe servire per attaccare il nodo, ma continuando a permettere la navigazione su freesite. Agli indirizzi IP che godono di accesso pieno viene permesso di modificare la configurazione del nodo
SimpleToadletServer.refilterPolicy=Cosa dovrebbe fare fproxy quando un file scaricato corrisponde alla chiave che sta venendo richiamata, ma è già stata filtrata?
SimpleToadletServer.refilterPolicyLong=Cosa dovrebbe fare fproxy quando un file scaricabile corrisponde alla chiave che sta venendo richiamata, ma è già stata filtrata? RE_FILTER = filtrare in ogni caso, dato che il filtro potrebbe essere stato migliorato dal download originario, ACCEPT_OLD = accettare i vecchi dati (prestazioni massime), RE_FETCH = ignorare i vecchi dati.
SimpleToadletServer.sendAllThemes=Inviare tutti i temi al browser?
SimpleToadletServer.ssl=Abilita SSL
SimpleToadletServer.sslLong=Abilitare SSL su FProxy?
SSL.enable=Attiva supporto SSL
SSL.keyPass=Password della chiave privata
SSL.version=Versione di SSL
SSL.versionLong=Versione di SSL, SSLv3 o TLSv1 (default SSLv3)
StartupToadlet.entropyErrorTitle=Freenet sta aspettando un livello maggiore di entropia prima di poter partire.
StartupToadlet.isStartingUp=Avviamento del nodo Freenet in corso, si prega di attendere.
StartupToadlet.title=Avvio di Freenet in corso
StaticToadlet.pathInvalidChars=La URI specificata contiene caratteri non permessi.
StaticToadlet.pathNotFound=Il percorso specificato non esiste.
StaticToadlet.pathNotFoundTitle=Percorso non trovato
StatisticsToadlet.accessRate=Tasso di accesso
StatisticsToadlet.ackOnlyBytes=Pacchetti ack-only: ${total}
StatisticsToadlet.activityInserts=Inserimenti: handler CHK ${CHKhandlers}, handler SSK ${SSKhandlers} (${local} locali)
StatisticsToadlet.activityRequests=Richieste: handler CHK ${CHKhandlers}, handler SSK (${local} locali)
StatisticsToadlet.adminBytes=Byte di amministrazione: messaggi iniziali ${initial}, messaggi di cambio IP ${changedIP}, notifiche di disconnessione ${disconn}, stato dell'instradamento ${routingStatus}
StatisticsToadlet.allocMemory=Memoria Java allocata: ${memory}
StatisticsToadlet.announceBytes=Output di annunciamento: ${total} (carico utile del trasferimento delle referenze del nodo ${payload})
StatisticsToadlet.authBytes=Configurazione della connessione: output ${total}
StatisticsToadlet.avgDist=Distanza media
StatisticsToadlet.avgLocation=Ubicazione media
StatisticsToadlet.avgSuccessLoc=Successo di locazione medio
StatisticsToadlet.avgTime=Tempo medio
StatisticsToadlet.bandwidthTitle=Larghezza di banda
StatisticsToadlet.capacity=Capacità
StatisticsToadlet.chkDetailTiming=Tempi dettagliati (richiami locali CHK)
StatisticsToadlet.CLIENT=Cache del client
StatisticsToadlet.clientRequesters.age=Età
StatisticsToadlet.clientRequesters.priorityClass=Classe di priorità
StatisticsToadlet.clientRequesters.realtimeFlag=Opzione tempo-reale?
StatisticsToadlet.count=Conteggio
StatisticsToadlet.cpus=CPU Disponibili: ${count}
StatisticsToadlet.cryptoUsingBuiltin=Criptazione: Utilizza il codice interno.
StatisticsToadlet.cryptoUsingJCA=Criptazione: Utilizza JCA (${provider}).
StatisticsToadlet.datasize=Dimensioni dei dati
StatisticsToadlet.datastore=Banca dati
StatisticsToadlet.databaseJobsByPriority=Processi del database
StatisticsToadlet.debuggingBytes=Byte di debug: colorazione rete ${netColoring}, ping ${ping}, richieste sonda ${probe}, messaggi di prova instradati ${routed}
StatisticsToadlet.distanceStats=Statistiche di distanza
StatisticsToadlet.falsePos=Falsi positivi
StatisticsToadlet.fullTitle=Statistiche
StatisticsToadlet.furthestSuccess=Successo più lontano
StatisticsToadlet.getLogs=Prendi l'ultimo file di registro del nodo
StatisticsToadlet.globalWindow=Finestra globale
StatisticsToadlet.inputRate=Tasso di input: ${rate}/s (di ${max}/s)
StatisticsToadlet.insertOutput=Output degli inserimenti (escludendo il carico utile): CHK ${chk} SSK ${ssk}
StatisticsToadlet.jobType=Tipo di lavoro
StatisticsToadlet.jvmInfoTitle=Informazioni della macchina virtuale Java
StatisticsToadlet.jvmName=Nome della macchina virtuale Java: ${name}
StatisticsToadlet.jvmVendor=Fornitore della macchina virtuale Java: ${vendor}
StatisticsToadlet.javaVersion=Versione Java: ${version}
StatisticsToadlet.jvmVersion=Versione della macchina virtuale Java: ${version}
StatisticsToadlet.keys=Chiavi
StatisticsToadlet.maxMemory=Memoria Java massima: ${memory}
StatisticsToadlet.maxTotalPeers=Peer massimi
StatisticsToadlet.maxOpennetPeers=Max sconosciuti
StatisticsToadlet.nodeToNodeBytes=Messaggi da nodo a nodo: ${total}
StatisticsToadlet.loadAllocationNoticesBytes=Notifiche di allocazione di carico: ${total}
StatisticsToadlet.noRequests=In questo momento il tuo nodo non sta elaborando nessuna richiesta.
StatisticsToadlet.offerReplys=Risposte alle offerte attive: CHK ${chk}, SSK ${ssk}
StatisticsToadlet.offeredKeyOutput=Chiavi offerte: invio di chiavi ${total}, offerte di invio ${offered}
StatisticsToadlet.opennetStats=Statistiche opennet
StatisticsToadlet.osArch=Architettura del S.O.: ${arch}
StatisticsToadlet.osName=Nome del S.O.: ${name}
StatisticsToadlet.osVersion=Versione del S.O.: ${version}
StatisticsToadlet.outputRate=Tasso di output: ${rate}/s (di ${max}/s)
StatisticsToadlet.payloadOutput=Output del carico utile: ${total} (${rate}/sec)(${percent}%)
StatisticsToadlet.peerStatsTitle=Statistiche dei peer
StatisticsToadlet.priority=Priorità
StatisticsToadlet.PUB_KEY=Pubkey (chiave pubblica)
StatisticsToadlet.queuedCount=Conteggio accodato
StatisticsToadlet.readRequests=Richieste di lettura
StatisticsToadlet.realGlobalWindow=Finestra reale globale
StatisticsToadlet.requestOutput=Output delle richieste (carico utile escluso): CHK ${chk} SSK ${ssk}.
StatisticsToadlet.resendBytes=Bytes rispediti: ${total} (${percent}%)
StatisticsToadlet.routingBackoffReason=Motivo del recesso dell'instradamento
StatisticsToadlet.routingDisabled=Traffico non instradato (siamo attualmente connessi al nodo ma noi o esso rifiutiamo di instradare il traffico)
StatisticsToadlet.routingDisabledShort=Traffico non instradato
StatisticsToadlet.running=In funzione
StatisticsToadlet.runningBlockTransfers=Trasferimenti di blocco: invii ${sends}, ricezioni ${receives}
StatisticsToadlet.seedStats=Statistiche del seme
StatisticsToadlet.seedTableConnections=Connesso
StatisticsToadlet.seedTableAnnouncements=Annunciato
StatisticsToadlet.seedTableAccepted=Accettato
StatisticsToadlet.seedTableCompleted=Completato
StatisticsToadlet.seedTableForwarded=Ref. inviate
StatisticsToadlet.seedTableVersion=Versione
StatisticsToadlet.SLASHDOT=Cache slashdot
StatisticsToadlet.statisticGatheringTitle=Raccolta delle statistiche
StatisticsToadlet.STORE=Memoria
StatisticsToadlet.storeJobsByPriority=Processi di controllo d'immagazzinamento per priorità
StatisticsToadlet.successByHTLRT=Tassi di successo per HTL (richiami remoti in tempo reale)
StatisticsToadlet.successByHTLBulk=Tassi di successo per HTL (richiami remoti di massa)
StatisticsToadlet.successfulReads=Letture riuscite
StatisticsToadlet.successRate=Tasso di successo
StatisticsToadlet.swapOutput=Output di scambio: ${total}.
StatisticsToadlet.threadDumpButton=Genera un dump dei thread
StatisticsToadlet.threads=Thread in uso: ${running}/${max}
StatisticsToadlet.threadsByPriority=Thread riuniti per priorità
StatisticsToadlet.totalInput=Input totale globale: ${total}
StatisticsToadlet.totalInputSession=Input totale della sessione: ${total} (${rate}/sec. in media)
StatisticsToadlet.totalOutput=Output totale globale: ${total}
StatisticsToadlet.totalOutputSession=Output totale della sessione: ${total} (${rate}/s in media)
StatisticsToadlet.totalOverhead=Overhead totale non richiesto: ${rate}/sec (${percent}%).
StatisticsToadlet.totalTime=Tempo totale
StatisticsToadlet.transferBackoffReason=Motivo del recesso di trasferimento
StatisticsToadlet.transferringRequests=Richieste di trasferimento: invianti ${senders}, riceventi ${receivers}
StatisticsToadlet.uomBytes=Output di aggiornamento: ${total}
StatisticsToadlet.unaccountedBytes=Altro output: ${total} (${percent}%)
StatisticsToadlet.usedMemory=Memoria Java utilizzata: ${memory}
StatisticsToadlet.utilization=Utilizzo
StatisticsToadlet.versionTitle=Informazioni della versione del nodo
StatisticsToadlet.waiting=In attesa
StatisticsToadlet.writeRate=Tasso di scrittura
StatisticsToadlet.writes=Compilare
StatusBar.alerts=Messaggi:
StatusBar.connectedPeers=Siamo attualmente connessi a ${X} amico/i e ${Y} sconosciuti.
StatusBar.switchToAdvancedMode=Usa modalità avanzata
StatusBar.switchToSimpleMode=Usa modalità semplice
SymlinkerToadlet.symlinks=Link simbolici in ToadletServer
SymlinkerToadlet.symlinksLong=Lista di "alias#target" che va a formare un gruppo di link simbolici
TestnetHandler.cannotEnableDisableOnTheFly=Non è possibile abilitare o disabilitare la modalità testnet "al volo";  è necessario riavviare il nodo ed ottenere nuove connessioni.
TestnetHandler.enable=Abilita modalità testnet (PERICOLO)
TestnetHandler.enableLong=Abilita la modalità testnet (PERICOLO). La modalità testnet elimina l'anonimato per poter permettere agli sviluppatori di fare il debugging del nodo
TestnetHandler.port=Porta testnet
TestnetHandler.portLong=Numero della porta testnet (-1 = listenPort+1000)
TextModeClientInterfaceServer.allowedHosts=Host autorizzati
TextModeClientInterfaceServer.allowedHostsLong=Nomi host o indirizzi IP ai quali è consentito connettersi a TMCI. Può essere una lista di nomi host e indirizzi IP separati da virgole, o anche IP in formato CIDR come 192.168.0.0/24
TextModeClientInterfaceServer.bindTo=Indirizzo IP del servizio
TextModeClientInterfaceServer.bindToLong=Indirizzo IP del servizio
TextModeClientInterfaceServer.enableInputOutput=Abilita stdout/stdin
TextModeClientInterfaceServer.enabled=Abilita TMCI
TextModeClientInterfaceServer.enabledLong=Abilita TMCI
TextModeClientInterfaceServer.ssl=Abilita SSL
TextModeClientInterfaceServer.sslLong=Abilitare SSL sul server TMCI?
TextModeClientInterfaceServer.telnetPortNumber=Porta telnet
TextModeClientInterfaceServer.telnetPortNumberLong=Porta TCP utlizzata dal server TMCI
TimeSkewDetectedUserAlert.title=Data e ora non corrette
TimeSkewDetectedUserAlert.text=L'orologio del computer sembra essere sbagliato. Freenet non può connettersi correttamente alla rete. Impostare l'orologio del computer con la data e l'ora corretta, quindi riavviare Freenet.
TimeSkewDetectedUserAlert.shortText=Freenet non si può connettere perchè l'orologio del tuo computer è sbagliato.
Toadlet.yes=Sì
Toadlet.back=Precedente
Toadlet.next=Successivo
Toadlet.cancel=Cancella
Toadlet.clickHere=Clicca qui
Toadlet.internalErrorPleaseReport=Errore interno:  riportarlo se possibile
Toadlet.internalErrorTitle=Errore Interno
Toadlet.nodeHomepage=Homepage del Nodo
Toadlet.notSupportedTitle=Non Supportato
Toadlet.notSupportedWithClass=Il browser ha mandato una richiesta che Freenet (${class}) non capisce.
Toadlet.permRedirectWithReason=Redirect permanente: ${reason}
Toadlet.returnToNodeHomepage=Torna alla pagina principale
Toadlet.returnToQueuepage=Torna a Download e Upload
Toadlet.returnToPrevPage=Torna alla pagina precedente
Toadlet.tempRedirectWithReason=Redirect temporaneo: ${reason}
Toadlet.unauthorizedTitle=Non Autorizzato
Toadlet.unauthorized=L'accesso a questa pagina è interdetto.
ToadletContextImpl.cannotParseContentLength=errore nell' analisi contenuto-lunghezza: ${error}
ToadletContextImpl.cannotParseContentLengthWithError=Impossibile interpretare contenuto-lunghezza: ${error}
ToadletContextImpl.headersLineTooLong=Rigo troppo lungo dalla ricostruzione di headers
ToadletContextImpl.methodNotAllowed=Metodo HTTP Non Permesso
ToadletContextImpl.noContentLengthInPOST=Nessun content-length in POST
ToadletContextImpl.noSuchToadlet=Nessuna Toadlet con quel nome
ToadletContextImpl.parseErrorWithError=Errore nell' interpretazione ${error}
ToadletContextImpl.uriParseErrorTitle=Errore Nell' Interpretazione della URI
TranslationToadlet.title=Traduzione
TranslationToadlet.titleLong=contribuisci alla traduzione
TranslationToadlet.bracketRemoveOverride= (Elimina chiave di traduzione)
TranslationToadlet.bracketTranslateIt= (aggiungi alla traduzione)
TranslationToadlet.bracketUpdateTranslation= (aggiorna traduzione)
TranslationToadlet.confirmRemoveOverride=Conferma: elimina chiave di traduzione : (${key} - ${value}) ?
TranslationToadlet.contributingToLabelWithLang=Stai contribuendo alla traduzione: ${lang}:
TranslationToadlet.currentTranslationLabel=Traduzione attuale
TranslationToadlet.downloadTranslationsFile=Scarica le tue traduzioni
TranslationToadlet.gotoNext=Vai alla prossima stringa non tradotta?
TranslationToadlet.hideAlreadyTranslated=Nascondi le stringhe già tradotte
TranslationToadlet.noCustomTranslations=Nessuna traduzione personalizzata disponibile.
TranslationToadlet.originalVersionLabel=Originale (versione inglese)
TranslationToadlet.reEdit=Ri-modifica la traduzione
TranslationToadlet.remove=Elimina
TranslationToadlet.removeOverrideTitle=Elimina una chiave di traduzione
TranslationToadlet.removeOverrideWarningTitle=Attenzione: la chiave di traduzione verrà eliminata!
TranslationToadlet.returnToTranslations=Torna alla pagina della traduzione
TranslationToadlet.selectTranslation=Scegliete la traduzione
TranslationToadlet.showEverything=Mostra tutto, incluse stringhe già tradotte
TranslationToadlet.showTranslationOf=Mostrare la traduzione di:
TranslationToadlet.translationKeyLabel=Chiave di traduzione
TranslationToadlet.translationUpdateTitle=Aggiornamento traduzione
TranslationToadlet.translationUpdatedTitle=Traduzione aggiornata!
TranslationToadlet.updateTranslationCommand=Aggiorna traduzione
UndetectableCharsetException.title=Impossibile identificare il set di caratteri locale, sembra ${charset} ma non lo è
UndetectableCharsetException.explanation=Individuati i primi byte della dichiarazione del set dei caratteri ma non è valida, ignoro il foglio di stile come da CSS 2.1 sezione 4.4
UnknownContentTypeException.explanation=Il nodo non ha informazioni su questo MIME type. Ciò potrebbe comportare una reazione pericolosa da parte del browser in risposta al download di questo file. Per esempio, molti formati possono contenere immagini o video inclusi (embedded) che vengono scaricati dal web: ciò espone l'utente al rischio di rivelare il proprio indirizzo IP ad un eventuale avversario (per esempio un avversario che gestisca il il sito web dal quale le immagini o video ecc. vengono scaricati, o uno che abbia in qualche modo ottenuto accesso ai log del sito stesso). Hyperlinks e scripting sono entrambi ugualmente pericolosi per lo stesso motivo, oltre che per alcuni altri.
UnknownContentTypeException.title=Contenuto di tipo sconosciuto e potenzialmente pericoloso: ${type}
UnsupportedCharsetInFilterException.title=Set di caratteri di testo non supportato: ${charset}.
UnsupportedCharsetInFilterException.explanation=Questo è un set di caratteri molto raro, non supportato da Java, e è abbastanza probabile che questo sia un tentativo di evitare il filtro dei contenuti, o semplicemente dati corrotti.
UpdateDeployContext.cannotUpdateNoMainJar=Non è stato possibile trovare freenet.jar in wrapper.conf (freenet-ext.jar non trovata: ${extFilename})
UpdateDeployContext.updateCatastrophe=ERRORE CATASTROFICO: Eliminato ${old} ma impossibile rinominare ${new} in ${old} quindi IL NODO NON SI AVVIERA'! La soluzione consiste nel rinominare ${new}  in ${old} manualmente
UpdateDeployContext.updateFailedCannotDeleteOldConfig=Non è stato possibile eliminare ${old} quindi non è possibile sovrascrivere. Aggiornamento fallito.
UpdateDeployContext.updateFailedNonStandardConfig=Non è stato possibile completare l'aggiornamento a causa della configurazione non-standard: written main=${main} ext=${ext} - Questo non dovrebbe accadere! Si prega di riportare l'accaduto agli sviluppatori includendo il file wrapper.conf
UpdatedVersionAvailableUserAlert.armed=Il nodo verrà riavviato automaticamente dopo aver completato il download e verificato la nuova versione di Freenet.
UpdatedVersionAvailableUserAlert.changelog=Avviso di rilascio
UpdatedVersionAvailableUserAlert.devchangelog=Dettagli per sviluppatori
UpdatedVersionAvailableUserAlert.clickToUpdateASAP=Clicca qui sotto per aggiornare il nodo dopo la verifica dell'aggiornamento.
UpdatedVersionAvailableUserAlert.clickToUpdateNow=Clicca qui sotto per aggiornare il nodo immediatamente.
UpdatedVersionAvailableUserAlert.downloadedNewJar=Il nodo ha scaricato una versione aggiornata di Freenet: versione ${version}.
UpdatedVersionAvailableUserAlert.fetchingNewNode=Il nodo sta scaricando una versione aggiornata di Freenet (versione nodo ${nodeVersion}).
UpdatedVersionAvailableUserAlert.finalCheck=Il nodo sta eseguendo un controllo finale per verificare la sicurezza dell'aggiornamento (${count} of ${max}).
UpdatedVersionAvailableUserAlert.notLatest=Sembra che il nodo non stia usando la versione più aggiornata del software.
UpdatedVersionAvailableUserAlert.shortArmed=In nodo sta scaricando una nuova versione di Freenet e si riavvierà una volta terminato il download.
UpdatedVersionAvailableUserAlert.shortReadyNotArmed=Il nodo ha scaricato una nuova versione di Freenet ma potrà usarla solo dopo la conferma da parte dell' utente.
UpdatedVersionAvailableUserAlert.shortNotReadyNotArmed=Il nodo sta scaricando una nuova versione di Freenet, ma per poterla utilizzare è necessaria la conferma da parte dell'utente.
UpdatedVersionAvailableUserAlert.title=E' disponibile una nuova versione stabile di Freenet
UpdatedVersionAvailableUserAlert.updateASAPButton=Si prega di aggiornare al più presto possibile
UpdatedVersionAvailableUserAlert.updateASAPQuestion=Riavviare il nodo dopo che l'aggiornamento è stato completato?
UpdatedVersionAvailableUserAlert.updateNowButton=Aggiorna Adesso!
UpdatedVersionAvailableUserAlert.updateIsUrgent=Per favore aggiorna al più presto altrimenti il tuo nodo Freenet potrebbe non essere più in grado di comunicare con il resto della rete!
UserAlert.apply=Conferma
UserAlert.hide=Nascondi
UserAlert.reset=Cancella
UserAlertManager.alertsOnAlertsPage=Vedi dettagli alla ${link}pagina delle avvertenze${/link}.
UserAlertManager.alertsTitle=Notificazioni particolari
UserAlertManager.clickForMore=Click su un oggetto per maggiori informazioni o per sbarazzarsene.
UserAlertManager.criticalErrorCountLabel=Errori Critici:
UserAlertManager.dumpEventsButton=Elimina notifiche di routine
UserAlertManager.errorCountLabel=Errori:
UserAlertManager.feedTitle=Freenet feeds
UserAlertManager.minorCountLabel=Minori:
UserAlertManager.totalLabel=Totale:
UserAlertManager.warningCountLabel=Avvertenze:
UserAlertsToadlet.title=Messaggi di stato
UserAlertsToadlet.noMessages=Nessun messaggio
WelcomeToadlet.activityTitle=Attività in corso
WelcomeToadlet.alertsSummary=Sommario avvertenze
WelcomeToadlet.confirmAddBookmarkSubTitle=Conferma Aggiunta Sgnalibro
WelcomeToadlet.confirmAddBookmarkTitle=Aggiungi ai Segnalibri
WelcomeToadlet.confirmAddBookmarkWithKey=Si prega di confermare l' intenzione di aggiungere la chiave ${key} ai preferiti ed aggiugnere una descrizione.
WelcomeToadlet.confirmExternalLinkSubTitle=Conferma link esterno
WelcomeToadlet.confirmExternalLinkTitle=ATTENZIONE: Link esterno
WelcomeToadlet.confirmFIN=Conferma inserzione del seguente messaggio Frost:
WelcomeToadlet.disabledAlert=Allarme disabilitato
WelcomeToadlet.fetch=Richiama
WelcomeToadlet.finInsertSuccessWithKey=Il messaggio è stato inserito in ${key}.
WelcomeToadlet.finInsertedTitle=Inserzione
WelcomeToadlet.finTitle=Inserzione Nota  Istantanea di Frost
WelcomeToadlet.fromHeader=Da
WelcomeToadlet.goToExternalLink=Vai al link specificato
WelcomeToadlet.ieWarning=E' stato rilevato l'uso di Microsoft Internet Explorer. Ciò potrebbe costituire un pericolo per l'anonimato dell'utente.
WelcomeToadlet.ieWarningTitle=Rischio Sicurezza!
WelcomeToadlet.insertCount=Inserzioni: ${total}
WelcomeToadlet.insertFailedTitle=Inserzione fallita
WelcomeToadlet.insertFailedWithMessage=L'inserzione è fallita con il messaggio: ${message}
WelcomeToadlet.insertSucceededTitle=Inserzione Completata
WelcomeToadlet.insertedTitle=Inserzione
WelcomeToadlet.keyInsertedSuccessfullyWithKeyAndName=La chiave ${link}${name}${/link} è stata inserita.
WelcomeToadlet.keyRequestLabel=Chiave:
WelcomeToadlet.messageHeader=Messaggio
WelcomeToadlet.nodeUpdateConfirm=Conferma: aggiornare il nodo Freenet?
WelcomeToadlet.nodeUpdateConfirmTitle=Conferma Aggiorna Nodo
WelcomeToadlet.privateKeyHeader=Chiave Privata
WelcomeToadlet.publicKeyHeader=Chiave Pubblica
WelcomeToadlet.requestCount=Richieste: ${total}
WelcomeToadlet.restart=Riavvia
WelcomeToadlet.restartConfirm=Conferma: Riavvia nodo Freenet?
WelcomeToadlet.restartConfirmTitle=Riavvia Nodo
WelcomeToadlet.restartNode=Riavvia nodo
WelcomeToadlet.restarting=Si prega di attendere durante il riavvio del nodo. Questa schermata  si aggiornerà automaticamente, fino a mostrare la pagina iniziale di Freenet. Grazie di aver scelto Freenet.
WelcomeToadlet.restartingTitle=Riavvio del nodo Freenet in corso.
WelcomeToadlet.searchBoxLabel=Cerca su Freenet
WelcomeToadlet.searchBoxWarningSlow=Questa opzione aprirà una nuova finestra perché al momento la ricerca può risultare un po' lenta. Durante l'attesa si consiglia di dare un'occhiata agli indici linkati qui sotto.
WelcomeToadlet.searchPluginNotLoaded=Il plugin di ricerca non è stato caricato
WelcomeToadlet.searchPluginLoading=Il plugin richiesto per cercare su Freenet non è ancora caricato, probabilmente perché sta venendo aggiornato. Per favore ricarica la pagina un po' di volte, o vai alla ${link}pagina dei Plugin${/link} per vedere il progresso corrente.
WelcomeToadlet.searchFreenet=Cerca su Freenet
WelcomeToadlet.shutdown=Arresta
WelcomeToadlet.shutdownConfirm=Conferma: Arresta nodo Freenet?
WelcomeToadlet.shutdownConfirmTitle=Arresta Nodo
WelcomeToadlet.shutdownDone=Arresto del nodo Freenet in corso
WelcomeToadlet.shutdownNode=Arresta il nodo
WelcomeToadlet.splitfileErrorLabel=Errore specifico splitfile:
WelcomeToadlet.startIndexHeader=Indice dal quale iniziare
WelcomeToadlet.subjectHeader=Oggetto
WelcomeToadlet.testnetWarning=gira in modalità testnet. DISTRUGGE l'anonimato!
WelcomeToadlet.testnetWarningTitle=Modalità Testnet
WelcomeToadlet.thanks=Grazie di aver scelto Freenet.
WelcomeToadlet.threadDumpNotUsingWrapper=Non è possibile generare un thread dump se il nodo non sta girando nel wrapper
WelcomeToadlet.threadDumpSubTitle=Generazione di Thread Dump
WelcomeToadlet.threadDumpTitle=Genera Thread Dump
WelcomeToadlet.threadDumpWithFilename=E' stato generato un thread dump, esso è disponibile in ${filename}.
WelcomeToadlet.transferringRequestCount=Richieste in corso di trasferimento: ${total}
WelcomeToadlet.update=Aggiorna
WelcomeToadlet.updating=Il nodo Freenet è stato aggiornato e sarà ora riavviato automaticamente. Il processo di riavvio può durare fino a dieci minuti perchè il nodo prima di aggiornare deve controllare se sia presente una chiave di revoca.
WelcomeToadlet.updatingTitle=Aggiornamento del nodo in corso
WelcomeToadlet.uriWouldHaveBeen=La URI sarebbe stata: ${uri}
WelcomeToadlet.version=Freenet ${fullVersion} Build ${build} r${rev}
WelcomeToadlet.versionHeader=Informazioni sulla Versione e Controllo del Nodo
WrapperConfig.wrapper.java.maxmemory.short=Memoria massima (in megabytes)
WrapperConfig.wrapper.java.maxmemory.long=Limita la quantità massima di memoria utilizzabile da Freenet. Freenet ha bisogno di molta più memoria se si hanno molti e/o grossi file in coda di dowload/upload,  ed in misura minore se il nodo è dotato di un datastore di dimensioni abbondanti.  I cambiamenti saranno effettivi dopo il riavvio del nodo.
fproxy.push.hide=Nascondi
fproxy.push.show=Mostra
fproxy.push.imageprogress=Progresso di caricamento dell'immagine:
fproxy.push.pushingCancelled=Push annullato
End
