testing.test=test$(test1)test$(test2)test
Announcer.announceAlertIntro=Freenet is connecting to the network - this may take a few minutes. Performance will continue to improve during the next few hours. This will happen each time you shut down Freenet for more than a few minutes, so try to leave it running 24 hours a day if possible.
Announcer.announceAlertTitle=Node Announcing
Announcer.announceDetails=We have recently sent ${recentSentAnnouncements} announcements, ${runningAnnouncements} of which are still running, and added ${addedNodes} nodes (${refusedNodes} nodes have rejected us). We are currently connected to ${connectedSeednodes} seednodes and trying to connect to another ${disconnectedSeednodes}.
Announcer.announceAlertNoSeednodes=There is no seednodes.fref file found, so your Freenet node will not be able to automatically bootstrap itself onto the opennet. Please add some nodes manually, or download the seednodes file from http://downloads.freenetproject.org/alpha/opennet/ .
Announcer.announceLoading=Freenet is currently loading the seednodes file so that it can attempt to announce to the rest of the network. Announcement may take a few minutes.
Announcer.announceDisabledTooOldTitle=Announcement disabled (too old)
Announcer.announceDisabledTooOld=This node appears to be too old to connect to the current Freenet network. Your node will try to download a more recent version of Freenet from its peers and restart to update after this download finished. Please give it some time. This message will disappear when the update is finished. We have disabled announcement, since it is not getting anywhere.
Announcer.announceDisabledTooOldUpdateDisabled=To allow freenet to update itself, please enable auto-update on the ${config}Configuration page${/config}.
Announcer.announceDisabledTooOldShort=Your Freenet node has tried to connect to the network but your copy of Freenet is too old to route data. Please update!
Announcer.announceAlertShort=Freenet is trying to connect to the network, it will be slow for a while.
Announcer.coolingOff=For the next ${time} seconds, your Freenet node is waiting for the nodes that it just announced to to connect, if there are not enough nodes it will try a different node.
Announcer.dontKnowAddress=Freenet has not yet been able to determine our IP address, we cannot announce until we know what it is.
BMPFilter.InvalidBitDepthD=The bit depth field is not set to 1,2,4,8,16 or 32.
BMPFilter.InvalidBitDepthT=Invalid bit depth
BMPFilter.InvalidBitMapInfoHeaderSizeD=Size of bitmap info header is not 40
BMPFilter.InvalidBitMapInfoHeaderSizeT=Invalid Bitmap info header size
BMPFilter.InvalidDimensionD=The image has negative width or height
BMPFilter.InvalidDimensionT=Invalid Dimension
BMPFilter.InvalidFileSizeD=Image file size is not matching to headersize+imagedatasize
BMPFilter.InvalidFileSizeT=Invalid image file size
BMPFilter.InvalidImageDataSizeD=The calculated image data size is not matching with the actual size
BMPFilter.InvalidImageDataSizeT=Invalid image data size
BMPFilter.InvalidNoOfPlanesD=The number of planes is not one.
BMPFilter.InvalidNoOfPlanesT=Invalid no of planes
BMPFilter.InvalidOffsetD=The data offset is negative
BMPFilter.InvalidOffsetT=Invalid Offset
BMPFilter.InvalidResolutionD=Image has negative resolution
BMPFilter.InvalidResolutionT= Invalid resolution
BMPFilter.InvalidStartWordD=Start word is not one of the BM,BA,CI,CP,IC and PT
BMPFilter.InvalidStartWordT=Invalid Start word
BMPFilter.notBMP=Could not filter BMP:
Bookmark.noName=no name
BookmarkEditorToadlet.addBookmark=Add Bookmark
BookmarkEditorToadlet.addCategory=Add Category
BookmarkEditorToadlet.addNewBookmark=Add a new bookmark
BookmarkEditorToadlet.addNewCategory=Add a new category
BookmarkEditorToadlet.addedNewBookmark=The new bookmark has been added successfully.
BookmarkEditorToadlet.addedNewBookmarkTitle=New Bookmark Added
BookmarkEditorToadlet.bookmarkDoesNotExist=Bookmark "${bookmark}" does not exist.
BookmarkEditorToadlet.cancelCut=Cancel cut
BookmarkEditorToadlet.changesSaved=The changes has been saved successfully.
BookmarkEditorToadlet.changesSavedTitle=Modifications Saved
BookmarkEditorToadlet.confirmDelete=Delete
BookmarkEditorToadlet.addDefaultBookmarks=Re-add the default bookmark set
BookmarkEditorToadlet.cut=Cut
BookmarkEditorToadlet.delete=Delete
BookmarkEditorToadlet.deleteBookmark=Delete bookmark
BookmarkEditorToadlet.deleteBookmarkConfirm=Are you sure you want to delete ${bookmark}?
BookmarkEditorToadlet.deleteCategory=Delete category
BookmarkEditorToadlet.deleteCategoryConfirm=Are you sure you want to delete ${bookmark} and all of its children?
BookmarkEditorToadlet.deleteSucceeded=The bookmark has been deleted successfully.
BookmarkEditorToadlet.deleteSucceededTitle=Delete Succeeded
BookmarkEditorToadlet.descLabel=Detailed description of the bookmark
BookmarkEditorToadlet.edit=Edit
BookmarkEditorToadlet.editBookmarkTitle=Edit Bookmark
BookmarkEditorToadlet.editCategoryTitle=Edit Category
BookmarkEditorToadlet.error=Error
BookmarkEditorToadlet.explainLabel=Short description
BookmarkEditorToadlet.hasAnActivelinkLabel=Does the freesite have an active link?
BookmarkEditorToadlet.invalidKeyTitle=Invalid Key
BookmarkEditorToadlet.invalidKeyWithReason=Invalid Freenet key.
BookmarkEditorToadlet.invalidKey=The Freenet key is invalid.
BookmarkEditorToadlet.invalidNameTitle=Invalid Name
BookmarkEditorToadlet.invalidName=The bookmark name is invalid.
BookmarkEditorToadlet.keyLabel=Key:
BookmarkEditorToadlet.moveDown=Down
BookmarkEditorToadlet.moveUp=Up
BookmarkEditorToadlet.myBookmarksTitle=My bookmarks
BookmarkEditorToadlet.myBookmarksExplanation=Links to Freenet-hosted web sites, you will be notified when they are updated
BookmarkEditorToadlet.nameLabel=Name:
BookmarkEditorToadlet.paste=Paste
BookmarkEditorToadlet.pasteOrCancel=Click on a paste icon or cancel.
BookmarkEditorToadlet.pasteTitle=Cut/Paste
BookmarkEditorToadlet.publicDescLabel=Description for friends:
BookmarkEditorToadlet.recommendToFriends=Recommend to friends
BookmarkEditorToadlet.save=Save
BookmarkEditorToadlet.share=Share
BookmarkEditorToadlet.title=Bookmark Editor
BookmarkEditorToadlet.urlDecodeError=URL Decode Error
BookmarkFeedUserAlert.addAsABookmark=Add as a bookmark
BookmarkFeedUserAlert.bookmarkURI=URI:
BookmarkFeedUserAlert.bookmarkDescription=Description:
BookmarkFeedUserAlert.delete=Delete
BookmarkFeedUserAlert.peerName=Name:
BookmarkFeedUserAlert.title=${from} recommends you a freesite
BookmarkItem.bookmarkUpdated=The bookmarked site ${name} has been updated to edition ${edition}.
BookmarkItem.bookmarkUpdatedTitle=Bookmark Updated: ${name}
BookmarkItem.bookmarkUpdatedWithLink=The bookmarked site ${link}${name}${/link} has been updated to edition ${edition}.
BookmarkItem.bookmarkUpdatedShort=Bookmarked freesite updated: ${name}
BookmarkItem.deleteBookmarkUpdateNotification=Delete notification
BookmarkItem.unnamedBookmark=Unnamed Bookmark
BookmarkManager.defaultBookmarks=Default bookmarks
BookmarkManager.list=List of bookmarks
BookmarkManager.listLong=A list of bookmarked freesites
BookmarkManager.malformedBookmark=Malformed Bookmark
Bookmarks.Defaults.Name.categoryIndexes=Directories of websites on Freenet
Bookmarks.Defaults.Name.categoryDocumentation=Freenet related documentation
Bookmarks.Defaults.Name.categorySoftware=Freenet related software
Bookmarks.Defaults.Name.categoryBlogs=Freenet team's blogs
Bookmarks.Defaults.Description.TUFI=A one-page index with a menu including categories
Bookmarks.Defaults.Description.AFK=An index of freenet sites with categories (outdated, use Enzo)
Bookmarks.Defaults.Description.Enzo=An index of Freenet sites with categories
Bookmarks.Defaults.Description.Gantros=An index of Freenet sites with categories
Bookmarks.Defaults.Description.Linkageddon=A large, regularly updated index, linking to absolutely everything, including some very offensive sites. Some sites may not have accurate descriptions. Be careful!
Bookmarks.Defaults.Description.TheFilteredIndex=An index without pornographic or shocking sites, maintained by NoXe
Bookmarks.Defaults.Description.Nerdageddon=An index which reuses the listings from other indexes and removes the most offensive content, as well as dropping a few sites the author considers boring
Bookmarks.Defaults.Description.ISF=A small French index with descriptions
Bookmarks.Defaults.Description.FMS=The official freesite of FMS, a spam resistant message board system for Freenet
Bookmarks.Defaults.Description.Fniki=Older Freenet-based wiki
Bookmarks.Defaults.Description.Freemail=The official site for Freemail - email over Freenet
Bookmarks.Defaults.Description.unofficialfmsguide=Tutorials and explanations for the Freenet Message System
Bookmarks.Defaults.Description.PrivacyAndSoftware=Techniques for protecting your privacy when using Freenet
Bookmarks.Defaults.Description.freenetprojectorg=A mirror of the official Freenet Website with news and documentation
Bookmarks.Defaults.Description.Publish=Simple guide to publishing web sites to Freenet
Bookmarks.Defaults.Description.FreesiteHOWTO=A more detailed explanation of publishing freesites
Bookmarks.Defaults.Description.Sone=Fast anonymous social chat over Freenet
Bookmarks.Defaults.Description.freenetdocwiki=A Wiki about Freenet (needs some tools to edit)
Bookmarks.Defaults.Description.FSNG=An illustrated guide to setting up social networking tools
Bookmarks.Defaults.Description.jSite=Tool for uploading freesites (Freenet websites)
Bookmarks.Defaults.Description.Flog.Toad=Toad's flog
Bookmarks.Defaults.Description.Flog.Bombe=Bombe's flog
Bookmarks.Defaults.Description.Flog.Xor=Flog of the main Freetalk & Web Of Trust developer
Bookmarks.Defaults.Description.Flog.Operhiem1=Flog of the Freenet release manager
Bookmarks.Defaults.Description.Flog.ArneBab=ArneBab's notes
Bookmarks.Defaults.ShortDescription.Linkageddon=Links to every Freenet website, sorted by when they were last updated, including some very offensive sites. Be careful what you click on!
Bookmarks.Defaults.ShortDescription.TheFilteredIndex=An index without pornographic or shocking sites
Bookmarks.Defaults.ShortDescription.Nerdageddon=An index with the most offensive content removed
Bookmarks.Defaults.ShortDescription.AFK=Links to most Freenet web sites, sorted by category to make it easier to find what you want. (Outdated, use Enzo)
Bookmarks.Defaults.ShortDescription.Enzo=Links to most Freenet web sites, sorted by category to make it easier to find what you want
Bookmarks.Defaults.ShortDescription.Gantros=Links to most Freenet web sites, sorted by category to make it easier to find what you want
Bookmarks.Defaults.ShortDescription.TUFI=Older Freenet sites
Bookmarks.Defaults.ShortDescription.ISF=Index of French sites
Bookmarks.Defaults.ShortDescription.FMS=Message boards over Freenet
Bookmarks.Defaults.ShortDescription.Fniki=An older Wiki about Freenet
Bookmarks.Defaults.ShortDescription.Freemail=Email over Freenet
Bookmarks.Defaults.ShortDescription.unofficialfmsguide=The Unofficial Guide to FMS (Forums over Freenet)
Bookmarks.Defaults.ShortDescription.PrivacyAndSoftware=Best Practices for Freenet Users
Bookmarks.Defaults.ShortDescription.freenetprojectorg=The official Freenet Project website
Bookmarks.Defaults.ShortDescription.Publish=How to publish web sites on freenet
Bookmarks.Defaults.ShortDescription.FreesiteHOWTO=Another guide to publishing a website to Freenet
Bookmarks.Defaults.ShortDescription.Sone=Social chat over Freenet
Bookmarks.Defaults.ShortDescription.freenetdocwiki=Freenet documentation wiki
Bookmarks.Defaults.ShortDescription.FSNG=Step by step guide to how to set up anonymous email, forums, chat, social tools etc on Freenet. Strongly recommended!
Bookmarks.Defaults.ShortDescription.jSite=Essential tool for uploading websites to Freenet
Bookmarks.Defaults.ShortDescription.Flog.Toad=Former chief Freenet developer's personal blog
Bookmarks.Defaults.ShortDescription.Flog.Bombe=Sone developer's personal blog
Bookmarks.Defaults.ShortDescription.Flog.Xor=Freetalk and Web of Trust developer's blog
Bookmarks.Defaults.ShortDescription.Flog.Operhiem1=Freenet release manager's blog
Bookmarks.Defaults.ShortDescription.Flog.ArneBab=Maintainer of pyFreenet and infocalypse (and stuff)
BooleanOption.parseError=Unrecognized boolean: ${val} - try true or false
ChatForumsToadlet.title=Talk to other people on Freenet
ChatForumsToadlet.frost=${frost-freenet}Frost${/frost-freenet} (${frost-web}web link${/frost-web}) - The original Freenet discussion boards client. This has severe spam and denial of service problems, we strongly recommend you run one of the others. Like FMS, this is not part of Freenet, so you will have to install and run it yourself.
ChatForumsToadlet.fms=${fms}FMS${/fms} - The Freenet Message System is a message boards client, which is actively maintained and has a largish community. It is not part of Freenet, so you will have to download it and run it yourself.
ChatForumsToadlet.fsng=${fsng}Freenet Social Networking Guide${/fsng} - This unofficial guide can be very helpful in setting up these and other Freenet communication tools.
ChatForumsToadlet.sone=${sone}Sone${/sone} - A person and follower centered discussion-system. This is a plugin for Freenet. It requires the WebOfTrust plugin.
ChatForumsToadlet.content2=The Freenet team did not write or review Frost, FMS, or Sone, so we cannot guarantee their quality. There are many other Freenet plugins and apps (such as wikis) which one can find by browsing Freenet.
CSSTokenizerFilter.deletedDisallowedString=Deleted disallowed string
CSSTokenizerFilter.deletedUnmatchedChar=ignored unmatched char:
CSSTokenizerFilter.deletedUnofficialIdent=Deleted unofficial ident
CSSTokenizerFilter.deletedUnofficialIdentWithURL=Deleted unofficial ident with url
CSSTokenizerFilter.invalidURLContents=Invalid contents of url()
CSSTokenizerFilter.supplementalCharsNotSupported=UCS-4 CHARACTERS OVER 0xFFFF NOT SUPPORTED!
CSSTokenizerFilter.unknownAtIdentifierLabel=Unknown @identifier:
ConfigToadlet.appliedFailureExceptions=Your configuration changes were applied with the following exceptions:
ConfigToadlet.appliedFailureTitle=Configuration Not Applied
ConfigToadlet.appliedSuccess=Configuration changes were applied successfully.
ConfigToadlet.appliedTitle=Configuration Applied
ConfigToadlet.apply=Apply
ConfigToadlet.confirmReset=Are you sure you want to reset all settings on this page to their default values?
ConfigToadlet.confirmResetTitle=Reset to defaults?
ConfigToadlet.console=Console interface
ConfigToadlet.defaultIs=Default: '${default}'.
ConfigToadlet.false=false
ConfigToadlet.fcp=FCP
ConfigToadlet.fproxy=Web interface
ConfigToadlet.fullTitle=Freenet Node Configuration
ConfigToadlet.logger=Logs
ConfigToadlet.needRestartTitle=Node restart required
ConfigToadlet.needRestart=Some config need restart to activate, please restart Freenet immediately.
ConfigToadlet.needRestartShort=Some config need restart to activate, please restart Freenet immediately.
ConfigToadlet.restartNode=Restart Now
ConfigToadlet.selectDirectory=Select directory
PageMaker.modeSimple=Simple interface
PageMaker.modeSimpleTooltip=A simple interface all users can use
PageMaker.modeAdvanced=Advanced interface
PageMaker.modeAdvancedTooltip=An advanced interface that only experienced Freenet users and developers will need to use
ConfigToadlet.node=Core settings
ConfigToadlet.node.install=Installation settings
ConfigToadlet.node.load=Load management
ConfigToadlet.node.opennet=Opennet
ConfigToadlet.node.scheduler=Request scheduling
ConfigToadlet.node.testnet=Testnet mode
ConfigToadlet.node.updater=Auto-update
ConfigToadlet.pluginmanager=Plugins
ConfigToadlet.possibilitiesTitle=Continue
ConfigToadlet.resetToDefaults=Reset to defaults
ConfigToadlet.returnToNodeConfig=Return to configuration page
ConfigToadlet.shortTitle=Configuration
ConfigToadlet.ssl=SSL (restart required)
ConfigToadlet.title=Freenet Node Configuration
ConfigToadlet.title.node=Configure core settings e.g. bandwidth usage
ConfigToadlet.title.node.install=Installation settings, e.g. readonly program directory locations
ConfigToadlet.title.node.load=Settings for controlling the amount of traffic through your Freenet node
ConfigToadlet.title.node.opennet=Settings related to connecting to nodes other than Friends
ConfigToadlet.title.node.scheduler=Settings related to choosing local requests to run
ConfigToadlet.title.node.updater=Configure the auto-update system
ConfigToadlet.title.ssl=Configure SSL
ConfigToadlet.title.fcp=Configure Freenet Client Protocol (used for client applications to talk to Freenet)
ConfigToadlet.title.fproxy=Configure the web interface
ConfigToadlet.title.logger=Configure the amount of information kept by Freenet for troubleshooting purposes
ConfigToadlet.title.console=Configure the console interface
ConfigToadlet.title.toadletsymlinker=Configure web interface aliases
ConfigToadlet.toadletsymlinker=Web interface aliases
ConfigToadlet.true=true
ConfigToadlet.undo=Undo unsaved changes
ConfigToadlet.wrapper=Java settings
ConfigurablePersister.doesNotExistCannotCreate=File does not exist and cannot be created
ConfigurablePersister.existsCannotReadWrite=File exists and cannot read/write it
ConnectivityToadlet.byIPTitle=Packets for ${ip} by IP address - ${status} (minimum tunnel lifetime ${tunnelLength})
ConnectivityToadlet.title=Internet connection status
ConnectivityToadlet.connectivity=Status of your internet connection (port forwarding etc)
ConnectivityToadlet.connectivityTitle=Internet connection
ConnectivityToadlet.firstSendLeadTime=Startup to first send
ConnectivityToadlet.firstReceiveLeadTime=Online to first receive
ConnectivityToadlet.localRemoteTitle=Local/remote
ConnectivityToadlet.addressTitle=Address
ConnectivityToadlet.sentReceivedTitle=Sent/received packets
ConnectivityToadlet.byPortTitle=Packets for ${port} by port - ${status} (minimum tunnel lifetime ${tunnelLength})
ConnectivityToadlet.local=LOCAL
ConnectivityToadlet.remote=REMOTE
ConnectivityToadlet.noreply=NO REPLY
ConnectivityToadlet.summaryTitle=Connectivity
ConnectivityToadlet.status.DEFINITELY_PORT_FORWARDED=Port forwarded
ConnectivityToadlet.status.MAYBE_PORT_FORWARDED=Maybe port forwarded
ConnectivityToadlet.status.MAYBE_NATED=Maybe behind NAT
ConnectivityToadlet.status.DEFINITELY_NATED=Behind NAT
ConnectivityToadlet.status.DONT_KNOW=Status unknown
ConnectionsToadlet.nodeStatus.CONNECTED=CONNECTED
ConnectionsToadlet.nodeStatus.BACKED_OFF=BACKED OFF
ConnectionsToadlet.nodeStatus.NO_LOAD_STATS=NO LOAD STATS
ConnectionsToadlet.nodeStatus.TOO_NEW=TOO NEW
ConnectionsToadlet.nodeStatus.TOO_OLD=TOO OLD
ConnectionsToadlet.nodeStatus.DISCONNECTED=DISCONNECTED
ConnectionsToadlet.nodeStatus.NEVER_CONNECTED=NEVER CONNECTED
ConnectionsToadlet.nodeStatus.DISABLED=DISABLED
ConnectionsToadlet.nodeStatus.LISTEN_ONLY=LISTEN ONLY
ConnectionsToadlet.nodeStatus.LISTENING=LISTENING
ConnectionsToadlet.nodeStatus.BURSTING=BURSTING
ConnectionsToadlet.nodeStatus.CLOCK_PROBLEM=CLOCK PROBLEM
ConnectionsToadlet.nodeStatus.CONNECTION_ERROR=CONNECTION ERROR
ConnectionsToadlet.nodeStatus.DISCONNECTING=DISCONNECTING
ConnectionsToadlet.nodeStatus.UNKNOWN_STATUS=UNKNOWN STATUS
ConnectionsToadlet.nodeStatus.BUSY=BUSY
ConnectionsToadlet.nodeStatus.ROUTING_DISABLED=NOT ROUTING TRAFFIC
ContentDataFilter.unknownCharset=The page you are about to display has an unknown character set. This means that we are not able to filter the page, and it may compromise your anonymity.
ContentDataFilter.unknownCharsetTitle=Unknown character set!
ContentDataFilter.warningUnknownCharsetTitle=Warning: Unknown character set (${charset})
ContentFilter.applicationPdfReadAdvice=Adobe(R) PDF document - VERY DANGEROUS!
ContentFilter.applicationPdfWriteAdvice=Adobe(R) PDF document - VERY DANGEROUS!
ContentFilter.audioMP3ReadAdvice=MP3 music/audio file - probably not dangerous but can contain metadata which might include URLs of unencrypted content; the filter will strip these out
ContentFilter.audioMP3WriteAdvice=MP3 music/audio file - probably not dangerous but can contain metadata which might include URLs of unencrypted content; the filter will strip these out
ContentFilter.EOFMessage=Unexpected end of file
ContentFilter.EOFDescription=The filter needed more data from the file you were accessing than was available. The file may be malformed or corrupted.
ContentFilter.imageBMPReadAdvice=BMP image - probably not dangerous
ContentFilter.imageBMPWriteAdvice=BMP image - probably not dangerous
ContentFilter.imageGifReadAdvice=GIF image - probably not dangerous
ContentFilter.imageGifWriteAdvice=GIF image - probably not dangerous but you should wipe any comments
ContentFilter.imageIcoReadAdvice=Icon file - probably not dangerous
ContentFilter.imageIcoWriteAdvice=Icon file - probably not dangerous (but can contain other data due to offset?)
ContentFilter.imageJpegReadAdvice=JPEG image - probably not dangerous
ContentFilter.imageJpegWriteAdvice=JPEG image - probably not dangerous but can contain EXIF data
ContentFilter.imagePngReadAdvice=PNG image - probably not dangerous
ContentFilter.imagePngWriteAdvice=PNG image - probably not dangerous but you should wipe any comments or text blocks
ContentFilter.textCssReadAdvice=CSS (cascading style sheet, usually used with HTML) - probably not dangerous if filtered, but the filter is not a whitelist filter so take care
ContentFilter.textCssWriteAdvice=CSS (cascading style sheet, usually used with HTML) - this can probably contain metadata, check it by hand
ContentFilter.textHtmlReadAdvice=HTML - not dangerous if filtered
ContentFilter.textHtmlWriteAdvice=HTML - may contain dangerous metadata etc; suggest you check it by hand
ContentFilter.textPlainReadAdvice=Plain text - should not be dangerous unless you are running certain browsers (e.g. Internet Explorer)
ContentFilter.textPlainWriteAdvice=Plain text - not dangerous unless you include compromising information
ContentFilterToadlet.displayResultLabel=Display the result in the browser
ContentFilterToadlet.errorBadRequest=The request was invalid.
ContentFilterToadlet.errorBadRequestTitle=Bad request
ContentFilterToadlet.errorMustSpecifyFilterOperation=Use READ to apply the read filter. Use WRITE to apply the write filter. Use BOTH to apply them both.
ContentFilterToadlet.errorMustSpecifyFilterOperationTitle=You must specify what sort of filtering to apply when filtering a file!
ContentFilterToadlet.errorMustSpecifyResultHandling=Use DISPLAY to view the output in the browser. Use SAVE to download the output to a file.
ContentFilterToadlet.errorMustSpecifyResultHandlingTitle=You must specify what to do with the result when filtering a file!
ContentFilterToadlet.errorNoFileOrCannotRead=Freenet cannot read the file "${file}".
ContentFilterToadlet.errorNoFileOrCannotReadTitle=The file does not exist or it cannot be read
ContentFilterToadlet.errorNoFileSelected=You did not select a file to filter.
ContentFilterToadlet.errorNoFileSelectedTitle=No file selected
ContentFilterToadlet.errorUnsafeContent=The content filter has determined that the file is unsafe to display.
ContentFilterToadlet.errorUnsafeContentTitle=Unsafe content
ContentFilterToadlet.filterFile=Test the content filter on a file
ContentFilterToadlet.filterFileBrowseButton=Browse files
ContentFilterToadlet.filterFileBrowseLabel=Filter a file from disk
ContentFilterToadlet.filterFileFilterLabel=Filter File
ContentFilterToadlet.filterFileUploadLabel=Or filter a file through the browser
ContentFilterToadlet.mimeTypeLabel=Treat the file as this MIME type
ContentFilterToadlet.mimeTypeText=Leave this blank to let Freenet auto-detect the MIME type.
ContentFilterToadlet.pageTitle=Test the Content Filter
ContentFilterToadlet.saveResultLabel=Save the result to disk
ContentFilterToadlet.selectFile=Filter
ContentFilterToadlet.tryAgainFilterFilePage=${link}Try again${/link} to filter a file.
DarknetAddRefToadlet.title=Connect to a Friend
DarknetAddRefToadlet.explainBoxTitle=Why you should connect to your friends running Freenet
DarknetAddRefToadlet.explainBox1=You can improve Freenet's security by connecting to your friends. That is, to people you actually know who also run Freenet. These can be online acquaintances, but do not add connections to total strangers, as adding strangers as Friends will not improve security much and will cause problems for the network as a whole if lots of people do it. When you have added enough Friends, so that at least 5 are online at all times, you can increase your network security level to HIGH, and only connect to Friends, which is called "darknet mode". This makes it much harder for an attacker to even find out that you are running Freenet, and makes most attacks against your anonymity much harder. Freenet will make encrypted connections to your friends directly over the Internet, so only add people you can already be easily connected to (family, coworkers, real life friends, online friends).
DarknetAddRefToadlet.explainInstallerWindows=You can find the latest Windows installer in ${filename} or click ${get-windows}here${/get-windows}.
DarknetAddRefToadlet.explainInstallerWindowsNotYet=Freenet has not yet managed to download the Windows installer, however you can get it over Freenet ${link}here${/link}.
DarknetAddRefToadlet.explainInstallerNonWindows=You can find the latest non-Windows installer in ${filename} or click ${get-nonwindows}here${/get-nonwindows}. This is a jar file which must be opened with java; hopefully your friend can double click on it, but if that doesn't work try opening a command line and typing "java -jar ${shortfilename}".
DarknetAddRefToadlet.explainInstallerNonWindowsNotYet=Freenet has not yet managed to download the non-Windows installer, however you can get it over Freenet ${link}here${/link}. This is a jar file which must be opened with java; hopefully your friend can double click on it, but if that doesn't work try opening a command line and typing "java -jar ${shortfilename}".
DarknetAddRefToadlet.explainBox2=In order to connect to a Friend, you need to exchange noderefs with them. A noderef is a small file which contains the information needed for their copy of Freenet ("Freenet node") to connect to yours. You must add their noderef and they must add your noderef, for the two nodes to connect. See below for your noderef.
DarknetConnectionsToadlet.addAnotherFriend=Add another Friend
DarknetConnectionsToadlet.goFriendConnectionStatus=Go to the Friends page to see whether this friend connects
DarknetConnectionsToadlet.activityTitle=Current Activity
DarknetConnectionsToadlet.add=Add
DarknetConnectionsToadlet.addPeerTitle=Connect to a Friend
DarknetConnectionsToadlet.addOpennetPeerTitle=Manually connect to a Stranger (not recommended!)
DarknetConnectionsToadlet.alreadyInReferences=We already have the given reference.
DarknetConnectionsToadlet.backedOff=Connected but backed off: These peers are connected but we're backed off from them, so Freenet is not routing requests to them.
DarknetConnectionsToadlet.backedOffShort=Backed off
DarknetConnectionsToadlet.bracketedMoreDetailed=(more detailed)
DarknetConnectionsToadlet.bursting=Not connected and bursting: this node is, for a short period, trying to connect to these peers because the user has set BurstOnly on them.
DarknetConnectionsToadlet.burstingShort=Bursting
DarknetConnectionsToadlet.busy=Busy: These peers are connected but they are too busy to serve our requests, so Freenet is not routing requests to them.
DarknetConnectionsToadlet.busyShort=Busy
DarknetConnectionsToadlet.cantFetchNoderefURL=Unable to retrieve node reference from ${url}. Please try again.
DarknetConnectionsToadlet.cantParseTryAgain=Unable to parse the given text as a node reference: (${error}). Please try again.
DarknetConnectionsToadlet.cantParseWrongEnding=Unable to parse the node reference: It should end with End on a line by itself, but it ends with: ${end}
DarknetConnectionsToadlet.changeMyName=Change
DarknetConnectionsToadlet.changeTrustButton=Change trust to
DarknetConnectionsToadlet.changeVisibilityButton=Change visibility to
DarknetConnectionsToadlet.clockProblem=Your clock and the node's clock differ by more than 24 hours. We have disabled the connection as this may cause problems with updating and clients.
DarknetConnectionsToadlet.clockProblemShort=Clock Problem
DarknetConnectionsToadlet.confirmRemoveNode=Are you sure you wish to remove "${name}"? Before it has at least one week downtime, it's not recommended to do so, as it may be down only temporarily, and many users cannot run their nodes 24x7.
DarknetConnectionsToadlet.confirmRemoveNodeTitle=Please confirm
DarknetConnectionsToadlet.confirmRemoveNodeWarningTitle=Node Removal
DarknetConnectionsToadlet.connected=Connected: We're successfully connected to these nodes
DarknetConnectionsToadlet.connectedShort=Connected
DarknetConnectionsToadlet.countTitle=Count
DarknetConnectionsToadlet.darknetFnpPort=Darknet FNP: ${port}/UDP (used to connect to trusted peers i.e. Friends; forward this port if you can)
DarknetConnectionsToadlet.disabled=Not connected and disabled: because you have instructed Freenet not to connect to these peers.
DarknetConnectionsToadlet.disabledShort=Disabled
DarknetConnectionsToadlet.enterDescription=Enter description:
DarknetConnectionsToadlet.foafReachableThroughTitle=Reachable Through
DarknetConnectionsToadlet.connError=Connection failed (buggy node?)
DarknetConnectionsToadlet.routingDisabled=Not routing traffic (we are currently connected to the node but we or it refuse to route traffic)
DarknetConnectionsToadlet.routingDisabledShort=Not routing traffic
DarknetConnectionsToadlet.noLoadStats=Don't know how many requests we can send so can't send any
DarknetConnectionsToadlet.noLoadStatsShort=No load stats
DarknetConnectionsToadlet.myName=Nickname for this node: ${name}
DarknetConnectionsToadlet.disconnectingShort=Disconnecting
DarknetConnectionsToadlet.disconnecting=Disconnecting (we are currently removing the node, we need to tell it to go away and this can take a short time)
DarknetConnectionsToadlet.connErrorShort=Connection Error
DarknetConnectionsToadlet.failedToAddNodeInternalError=Unable to parse the given text as a node reference. Please report the following to the developers:
DarknetConnectionsToadlet.failedToAddNodeInternalErrorTitle=Failed to Add Node: Internal Error
DarknetConnectionsToadlet.failedToAddNodeTitle=Failed To Add Node
DarknetConnectionsToadlet.fcpDisabled=FCP is disabled (for Freenet clients such as Frost and Thaw)
DarknetConnectionsToadlet.fcpPort=FCP: ${port}/TCP (for Freenet clients such as Frost and Thaw)
DarknetConnectionsToadlet.fileReference=OR browse for the node reference file here:
DarknetConnectionsToadlet.forceRemove=Force Remove
DarknetConnectionsToadlet.fproxyDisabled=FProxy is disabled (this web interface)
DarknetConnectionsToadlet.fproxyPort=FProxy: ${port}/TCP (this web interface)
DarknetConnectionsToadlet.fullTitle=${counts} Friends (Trusted Peers)
DarknetConnectionsToadlet.go=Go
DarknetConnectionsToadlet.idleTime=How long since the node connected or was last seen
DarknetConnectionsToadlet.idleTimeTitle=Connected / Idle
DarknetConnectionsToadlet.invalidSignature=Unable to verify the signature of the given reference (${error}).
DarknetConnectionsToadlet.ipAddress=The node's network address as IP:Port
DarknetConnectionsToadlet.ipAddressTitle=Address
DarknetConnectionsToadlet.listenOnly=Not connected and listen only: this node won't try to connect to these peers at all because the user has set ListenOnly on them.
DarknetConnectionsToadlet.listenOnlyShort=ListenOnly
DarknetConnectionsToadlet.listening=Not connected but listening: this node won't try to connect to these peers very often because the user has set BurstOnly on them.
DarknetConnectionsToadlet.listeningShort=Listening
DarknetConnectionsToadlet.locationTitle=Location
DarknetConnectionsToadlet.myFriends=My Friends (trusted peers added by me)
DarknetConnectionsToadlet.myReferenceHeader=${linkref}My Node Reference${/linkref} (${linktext}as text${/linktext})
DarknetConnectionsToadlet.nameClickToMessage=The node's name. Click on the name link to send the node a N2NTM (Node To Node Text Message)
DarknetConnectionsToadlet.nameTitle=Name
DarknetConnectionsToadlet.neverConnected=Never Connected: Freenet has never connected to these peers.
DarknetConnectionsToadlet.neverConnectedShort=Never connected
DarknetConnectionsToadlet.noderefLink=noderef
DarknetConnectionsToadlet.noPeersWithHomepageLink=Freenet can not work as you have not added any peers so far. Please go to the ${link}node homepage${/link} and read the top infobox to see how it is done.
DarknetConnectionsToadlet.noRefOrURL=Could not detect either a node reference or a URL. Please try again.
DarknetConnectionsToadlet.nodePortsTitle=Ports used by your Freenet node
DarknetConnectionsToadlet.notConnected=Not connected: No connection so far but this node is continuously trying to connect.
DarknetConnectionsToadlet.notConnectedShort=Disconnected
DarknetConnectionsToadlet.noTrustLevelAddingFriendTitle=You must set a trust level for your friend's node
DarknetConnectionsToadlet.noTrustLevelAddingFriend=You must set a trust level - LOW, NORMAL or HIGH. This is simply how much you trust this friend. Higher trust levels give better performance but also less security if the friend decides to attack you, e.g. to try to find out what you are doing on Freenet. If your friend is only a casual acquaintance you might want to set LOW; if you trust them completely you should set HIGH. If you know they don't look after their computer properly and constantly get viruses etc you should reduce it a bit since it might not be them you are connecting to but somebody who has broken into their computer!
DarknetConnectionsToadlet.noVisibilityLevelAddingFriendTitle=You must set a visibility level for your friend's node
DarknetConnectionsToadlet.noVisibilityLevelAddingFriend=You must set a visibility level for your friend - YES (your other friends can see them, provided they also have YES), NAME ONLY (they can see the name of the peer and offer to get connected if they know each other), or NO (your other friends cannot see this node). Making your friends visible to your friends improves performance and makes it easier to get connected both to Freenet and to people you know once you are on Freenet.
DarknetConnectionsToadlet.opennetFnpPort=Opennet FNP: ${port}/UDP (used to connect to untrusted peers i.e. Strangers; forward this port if you can)
DarknetConnectionsToadlet.pasteReference=Enter node reference directly:
DarknetConnectionsToadlet.peersEnable=Enable selected peers
DarknetConnectionsToadlet.peersDisable=Disable selected peers
DarknetConnectionsToadlet.peersSetBurstOnly=On selected peers, set BurstOnly (only set this if you have a static IP and are not NATed and neither is the peer)
DarknetConnectionsToadlet.peersClearBurstOnly=On selected peers, clear BurstOnly
DarknetConnectionsToadlet.peersSetListenOnly=On selected peers, set ListenOnly (not recommended)
DarknetConnectionsToadlet.peersClearListenOnly=On selected peers, clear ListenOnly
DarknetConnectionsToadlet.peersSetAllowLocal=On selected peers, set allowLocalAddresses (useful if you are connecting to another node on the same LAN)
DarknetConnectionsToadlet.peersClearAllowLocal=On selected peers, clear allowLocalAddresses
DarknetConnectionsToadlet.peersSetIgnoreSourcePort=On selected peers, set ignoreSourcePort (try this if behind an evil corporate firewall; otherwise not recommended)
DarknetConnectionsToadlet.peersClearIgnoreSourcePort=On selected peers, clear ignoreSourcePort
DarknetConnectionsToadlet.peersSetDontRoute=On selected peers, set dontRoute (you shouldn't use that unless you know what you're doing, really!)
DarknetConnectionsToadlet.peersClearDontRoute=On selected peers, clear dontRoute
DarknetConnectionsToadlet.peerTrustTitle=How much do you trust this friend?
DarknetConnectionsToadlet.peerTrustIntroduction=A higher trust level will improve performance for you and your friend. But this makes you more vulnerable if they are untrustworthy, or their computer is hacked or seized.
DarknetConnectionsToadlet.peerTrustExplain.LOW=I don't trust my friend. Share as little as possible. Lower performance. Note that this is still safer than connecting to strangers in almost all cases.
DarknetConnectionsToadlet.peerTrustExplain.NORMAL=I trust my friend a little. Share some information, but take some precautions. Moderate performance gain.
DarknetConnectionsToadlet.peerTrustExplain.HIGH=I trust my friend, and I trust his ability to secure his computer. Share as much information as possible to maximise performance.
DarknetConnectionsToadlet.peerTrust.LOW=LOW
DarknetConnectionsToadlet.peerTrust.NORMAL=NORMAL
DarknetConnectionsToadlet.peerTrust.HIGH=HIGH
DarknetConnectionsToadlet.peerVisibilityTitle=Do you want your other friends to be able to see and connect to this friend?
DarknetConnectionsToadlet.peerVisibilityIntroduction=If you let your friends see this friend, and this friend see your friends, it will improve performance significantly. However you might not want your other friends to know about this one (but bear in mind that anyone who can see your internet connection might be able to link you). (S)he can also disable being seen by your friends.
DarknetConnectionsToadlet.peerVisibility.NO=NO
DarknetConnectionsToadlet.peerVisibility.YES=YES
DarknetConnectionsToadlet.peerVisibility.NAME_ONLY=NAME ONLY
DarknetConnectionsToadlet.peerVisibilityExplain.NO=Don't tell my friends about this friend, and don't let them tell their other friends about me: they are a secret contact.
DarknetConnectionsToadlet.peerVisibilityExplain.NAME_ONLY=Tell this friend our other friends' nicknames, and tell our other friends this friend's nickname, so they can connect if they know each other.
DarknetConnectionsToadlet.peerVisibilityExplain.YES=Tell my other friends about this friend, and tell this friend about my other friends. They will be able to connect immediately even if I am offline, improving performance significantly.
DarknetConnectionsToadlet.privateNote=A private note concerning this peer
DarknetConnectionsToadlet.privateNoteTitle=Private Note
DarknetConnectionsToadlet.referenceCopyWarning=Node reference must be copied ${bold}AS IS${/bold}. Modifying it will make it ${bold}useless${/bold}.
DarknetConnectionsToadlet.remove=Remove it!
DarknetConnectionsToadlet.removePeers=Remove selected peers
DarknetConnectionsToadlet.returnToAddAFriendPage=Try again (return to the add a friend page)
DarknetConnectionsToadlet.secondDegreeAlsoOurs=${count} locations likely also our peers (in bold)
DarknetConnectionsToadlet.secondDegreeConnectionsCountTitle=${count} Second-Degree Connections
DarknetConnectionsToadlet.secondDegreeTrivialHiddenCount=${count} non-overlapping connections potentially hidden
DarknetConnectionsToadlet.secondDegreeNonTrivialCount=${count} reachable through more than one peer
DarknetConnectionsToadlet.seedServers=Nodes we are using as seednodes.
DarknetConnectionsToadlet.seedServersShort=Seednodes
DarknetConnectionsToadlet.seedClients=Nodes we are acting as a seednode for.
DarknetConnectionsToadlet.seedClientsShort=Seeding for
DarknetConnectionsToadlet.selectAction=-- Select action --
DarknetConnectionsToadlet.sendMessageTitle=Send Node to Node Text Message
DarknetConnectionsToadlet.sendMessageToPeers=Send N2NTM to selected peers
DarknetConnectionsToadlet.separator=-- -- --
DarknetConnectionsToadlet.statusTitle=Status
DarknetConnectionsToadlet.tmciDisabled=TMCI is disabled (simple telnet-based command-line interface)
DarknetConnectionsToadlet.tmciPort=TMCI: ${port}/TCP (simple telnet-based command-line interface)
DarknetConnectionsToadlet.tooNew=Connected but too new: These peers' minimum mandatory build is higher than this node's build number.
DarknetConnectionsToadlet.tooNewShort=Too new
DarknetConnectionsToadlet.tooOld=Connected but too old: This node's minimum mandatory build is higher than these peers' build numbers. This node is not routing requests to them.
DarknetConnectionsToadlet.tooOldShort=Too old
DarknetConnectionsToadlet.triedToAddSelf=You can't add your own node to the list of remote peers.
DarknetConnectionsToadlet.trustTitle=Trust level
DarknetConnectionsToadlet.trustMessage=Higher trust = more information shared, better performance but less security if the friend is a bad guy or is seized or compromised
DarknetConnectionsToadlet.unknownAddress=(unknown address)
DarknetConnectionsToadlet.updateChangedPrivnotes=Update changed private notes
DarknetConnectionsToadlet.urlReference=OR enter the URL of the node reference here:
DarknetConnectionsToadlet.versionTitle=Version
DarknetConnectionsToadlet.reportOfNodeAddition=Added some Friends
DarknetConnectionsToadlet.returnToPrevPage=Return to previous page
DarknetConnectionsToadlet.peerAdditionCode.OK=Added successfully
DarknetConnectionsToadlet.peerAdditionCode.TRY_TO_ADD_SELF=Tried to add self
DarknetConnectionsToadlet.peerAdditionCode.WRONG_ENCODING=Wrong encoding
DarknetConnectionsToadlet.peerAdditionCode.CANT_PARSE=Can't parse
DarknetConnectionsToadlet.peerAdditionCode.INTERNAL_ERROR=Internal error
DarknetConnectionsToadlet.peerAdditionCode.INVALID_SIGNATURE=Invalid signature
DarknetConnectionsToadlet.peerAdditionCode.ALREADY_IN_REFERENCE=Already added reference
DarknetConnectionsToadlet.resultName=Name of result
DarknetConnectionsToadlet.numOfResults=Number of results
DarknetConnectionsToadlet.visibilityTitle=Visible to friends?
DarknetConnectionsToadlet.visibilityMessageSimple=Is this friend visible to our other friends? (We use the stricter of our setting and theirs, see more in advanced mode)
DarknetConnectionsToadlet.visibilityMessageAdvanced=Is this friend visible to our other friends? (We use the stricter of our setting and theirs, theirs is in brackets)
DiskSpaceUserAlert.title=Please free up some disk space!
DiskSpaceUserAlert.notEnoughSpaceIn=There is not enough free space available in ${where}.
DiskSpaceUserAlert.action=Please delete or move some files. Alternatively you can change the disk space limit on the Configuration page ("Minimum free disk space" etc under Core Settings in advanced mode).
DiskSpaceUserAlert.explanation.OK=
DiskSpaceUserAlert.explanation.PERSISTENT=Starting new downloads will not work until you free up some disk space.
DiskSpaceUserAlert.explanation.TRANSIENT=Browsing Freenet, starting new downloads etc will not work reliably until you free up some disk space.
DiskSpaceUserAlert.explanation.PERSISTENT_COMPLETION=Completing downloads will not work until you free up some disk space.
DownloadFeedUserAlert.delete=Delete
DownloadFeedUserAlert.fileDescription=Description:
DownloadFeedUserAlert.fileURI=URI:
DownloadFeedUserAlert.title=${from} recommends you a file
DroppedOldPeersUserAlert.droppingOldFriendTitle=Warning: Dropping ${count} connection(s) due to new encryption protocol (your friend(s) haven't upgraded or connected since ${buildDate}).
DroppedOldPeersUserAlert.droppingOldFriendFull=Freenet has dropped ${count} friend connection(s) because they haven't updated since ${buildDate}. Build ${buildNumber} included an important change to Freenet's encryption, and we cannot maintain backwards compatibility to really old nodes because older encryption protocols are vulnerable to attack. The old node references have been saved in ${filename}.
DroppedOldPeersUserAlert.droppingOldFriendList=Peers dropped:
FileInsertWizardToadlet.filterFileLabel=You can run the content filter in advance to see what the uploaded file will look like:
FileInsertWizardToadlet.insertCanonicalTitle=Insert a canonical key
FileInsertWizardToadlet.insertCanonical=This will always produce the same key for the same file, so is convenient for filesharing. However, if the bad guys can predict what files you are going to insert, they may be able to use this to trace you a lot more easily.
FileInsertWizardToadlet.insertCanonicalAdvanced=(Inserts to CHK@, with the encryption keys derived from the content)
FileInsertWizardToadlet.insertIntro=There are several different ways to upload (insert) a file to Freenet depending on whether you have uploaded the file before and what your security requirements are:
FileInsertWizardToadlet.insertRandomTitle=Insert a random, safe key
FileInsertWizardToadlet.insertRandom=This is much safer than the first option, but the key will be different every time you or somebody else inserts the key. Use this if you are the original source of some sensitive data.
FileInsertWizardToadlet.insertRandomAdvanced=(Inserts to a random SSK, with the encryption keys created randomly)
FileInsertWizardToadlet.insertSpecificKeyTitle=Specify a key
FileInsertWizardToadlet.insertSpecificKey=If you know the exact key you want to insert to, please specify it here. If it is an SSK, USK or KSK, all the data under it will be encrypted randomly as with "Insert a random, safe key".
FileInsertWizardToadlet.previewFilterFile=Filter a file
FileInsertWizardToadlet.splitfileCryptoKeyLabel=(optional) Splitfile encryption key (hex)
FileInsertWizardToadlet.pageTitle=Upload a file to Freenet
FirstTimeWizardToadlet.homepageTitle=Set Up Freenet
FirstTimeWizardToadlet.autodetectedSuggestedLimit=(Recommended)
FirstTimeWizardToadlet.autoUpdate=Auto-update
FirstTimeWizardToadlet.autoUpdateAutodeploy=Keep Freenet up to date automatically
FirstTimeWizardToadlet.autoUpdateNoAutodeploy=Ask when a new version is available
FirstTimeWizardToadlet.autoUpdateLong=Freenet can automatically keep itself up to date. Do you want it to:
FirstTimeWizardToadlet.bandwidthCapPrompt=Does your internet connection have a monthly data limit?
FirstTimeWizardToadlet.bandwidthLimitMonthlyTitle=Monthly Data Limit
FirstTimeWizardToadlet.bandwidthLimitMonthly=Freenet can be configured to not exceed a data limit. How much data do you want to allow Freenet to use each month? Freenet may have to be very slow in order to stay under a given limit. The bandwidth limits will be set with the assumption that Freenet is always online, so actual bandwidth usage may be lower. You can adjust these limits at any time from the ${bold}${coreSettings}${/bold} page.
FirstTimeWizardToadlet.bandwidthLimitRateTitle=Transfer Rate Limit
FirstTimeWizardToadlet.bandwidthLimitRate=How fast is your Internet connection? Freenet should use no more than half of it. You can change this setting later on the ${bold}${coreSettings}${/bold} page. Note that 1 megabit per second (1 Mbps) = 125 kilobytes per second (125 KB/s).
FirstTimeWizardToadlet.bandwidthConnectionHeader=Connection type
FirstTimeWizardToadlet.bandwidthDetected=Detected speed (use half)
FirstTimeWizardToadlet.bandwidthConnectionDialUp=Dial up modem (NOT RECOMMENDED!)
FirstTimeWizardToadlet.bandwidthConnectionISDN=ISDN (rare)
FirstTimeWizardToadlet.bandwidthConnectionSlow256=256kbps semi-broadband
FirstTimeWizardToadlet.bandwidthConnectionSlow512=512kbps slow broadband
FirstTimeWizardToadlet.bandwidthConnection1M=1 megabit
FirstTimeWizardToadlet.bandwidthConnection2M=2 megabits
FirstTimeWizardToadlet.bandwidthConnection4M=4 megabits
FirstTimeWizardToadlet.bandwidthConnection6M=6 megabits (average ADSL1)
FirstTimeWizardToadlet.bandwidthConnection8M=8 megabits (fast ADSL1)
FirstTimeWizardToadlet.bandwidthConnection12M=12 megabits (slow ADSL2)
FirstTimeWizardToadlet.bandwidthConnection20M=20 megabits (fast ADSL2, fast cable)
FirstTimeWizardToadlet.bandwidthConnectionVDSL=VDSL (20/5)
FirstTimeWizardToadlet.bandwidthConnection100M=100 megabits (fibre)
FirstTimeWizardToadlet.bandwidthCurrent=Current bandwidth limit
FirstTimeWizardToadlet.bandwidthCustom=Enter a custom bandwidth limit
FirstTimeWizardToadlet.bandwidthDownloadHeader=Download limit
FirstTimeWizardToadlet.bandwidthMonthlyLow=The requested monthly limit of ${requested} GB/month is too low. With bandwidth limits set to the minimum, Freenet may use around ${minimum} GB/month if it is always online. If Freenet isn't always online it can be set to use higher bandwidth limits. To use the minimum limits, click ${useMinimum}.
FirstTimeWizardToadlet.bandwidthMonthlyUseMinimum=Use Minimum
FirstTimeWizardToadlet.bandwidthUploadHeader=Upload limit
FirstTimeWizardToadlet.bandwidthSelect=Select
FirstTimeWizardToadlet.bandwidthPerSecond=/s
FirstTimeWizardToadlet.bandwidthMonthlyNetTransfer=Monthly Net Transfer
FirstTimeWizardToadlet.bandwidthCouldNotParse=Unable to parse limit "${limit}", please try again.
FirstTimeWizardToadlet.bandwidthErrorSettingTitle=Error Setting Bandwidth Limit
FirstTimeWizardToadlet.browserWarningPageTitle=Browser Security Advisory
FirstTimeWizardToadlet.browserWarningShort=You must use a separate browser (or a browser with privacy/incognito mode) for Freenet!
FirstTimeWizardToadlet.browserWarningShortRelativelySafe=You could use privacy mode or a separate browser to improve security
FirstTimeWizardToadlet.browserWarningIncognitoShort=You are using a browser with incognito mode for Freenet (this is good)
FirstTimeWizardToadlet.browserWarning=We ${bold}strongly${/bold} recommend that you do not use the same web browser to both browse the ordinary web and access Freenet, unless it is in incognito/privacy mode. Browser history stealing attacks in particular may enable malicious websites to determine which Freenet-based websites ("freesites") you have recently visited, breaking your anonymity. Please use a separate browser to access the Freenet web interface. For example, on Windows, the Browse Freenet option in the rabbit icon (in the system tray) will automatically open Google Chrome in incognito mode if it is installed.
FirstTimeWizardToadlet.browserWarningMaybeSafe=You are using a reasonably recent browser which should be relatively safe. However it will record what you browse on Freenet in its history. You could use privacy/incognito mode to prevent this. It can also be cleared manually but this will usually leave some traces.
FirstTimeWizardToadlet.browserWarningIncognito=You seem to be using a browser in privacy/incognito mode (check in the title bar). This should be relatively safe, but do not use the same browser for the web and Freenet, unless it is in privacy mode.
FirstTimeWizardToadlet.browserWarningIncognitoMaybeSafe=You seem to be using a recent browser in privacy/incognito mode (check in the title bar). This should be relatively safe. On older browsers (before Firefox 4), do not use the same browser for both the web and Freenet, unless they are in privacy mode.
FirstTimeWizardToadlet.browserWarningFirefoxMightHaveClobberedTabs=Freenet has tried to launch Firefox in privacy mode. This should prevent your browser keeping records of what you are browsing on Freenet. On some versions, it may have shut down any browser windows and tabs you already had open. You can get them back by going to the Tools menu and clicking on Stop Private Browsing. If Firefox is in privacy mode it should say so in the title bar or on a tab. If it doesn't you can open it manually in privacy mode and then open ${url}, or use a separate browser (or browser profile) just for Freenet.
FirstTimeWizardToadlet.browserWarningOldFirefox=You are using a relatively old version of Firefox (3 or earlier). Firefox 4 or later has an important privacy enhancement, the CSS history leak fix. You should upgrade if possible.
FirstTimeWizardToadlet.browserWarningOldFirefoxNewerHasPrivacyMode=Newer versions of Firefox also support privacy mode, which can be helpful.
FirstTimeWizardToadlet.browserWarningSuggestion=Most web browsers, apart from Microsoft Internet Explorer, will work adequately with Freenet, for example Firefox, Opera, Safari, Chrome, and Lynx are known to work. You should install one of these, then copy the current URL from the location bar, and open it in your new browser.
FirstTimeWizardToadlet.browserWarningIncognitoSuggestion=Most web browsers, apart from Microsoft Internet Explorer, will work adequately with Freenet, for example Firefox, Opera, Safari, Chrome, and Lynx are known to work.
FirstTimeWizardToadlet.chooseNodeName=Node name required!
FirstTimeWizardToadlet.chooseNodeNameLong=Please enter a node name in the field below (we recommend a nickname possibly with an email address). This is so that your friends (trusted peers, which you have manually added) can easily tell your node from their other nodes. This is not visible to strangers (untrusted automatically added peers). Note that any friend or stranger may trivially identify you from your IP address, since you are connected to them, but they cannot easily tell what you are requesting.
FirstTimeWizardToadlet.connectToStrangers=Connect to strangers?
FirstTimeWizardToadlet.connectToStrangersLong=To run Freenet, you must connect to at least five other nodes.  These should ideally be run by people whom you know and trust.  If you don't know enough friends running Freenet, you can choose to connect to strangers' nodes as well.  However, connecting to strangers allows others to find out that you are using Freenet and adds some additional security risks.  If you want to keep your use of Freenet secret, this may get you into trouble.
FirstTimeWizardToadlet.enableOpennet=It is possible to turn off stranger connections later on, once you have added enough friends, although you will already have revealed some information to strangers in the meantime.  Freenet is still experimental, and we offer no guarantees about security.
FirstTimeWizardToadlet.enableUPnP=Enable Universal Plug and Play (UPnP). Set this if you have a router on your local network. Don't set it if you are directly connected to your ISP e.g. via dial-up modem, or have untrusted people on your local network (e.g. some student accomodation).
FirstTimeWizardToadlet.opennetYes=I want Freenet to automatically find strangers to connect to.
FirstTimeWizardToadlet.opennetNo=I have at least 5 friends already using Freenet and I will add their details on the Friends page.
FirstTimeWizardToadlet.bandwidthLimit=Bandwidth Limits
FirstTimeWizardToadlet.continue=Continue
FirstTimeWizardToadlet.currentPrefix=Current size:
FirstTimeWizardToadlet.currentSpeed=Current limit:
FirstTimeWizardToadlet.datastoreSize=Datastore size
FirstTimeWizardToadlet.datastoreSizeLong=Please select a size for your datastore. Recommended values lie between 1GiB and 20GiB. A smaller datastore can result in problems downloading files, a larger datastore is beneficial to the network but might slow down your computer due to high filesystem load, especially in the first few hours after installation. The datastore acts like a cache; storing data for the network will help you to get better throughput when requesting popular files. The more space you can afford the better it is for the community and the faster your node and especially your downloads will go.
FirstTimeWizardToadlet.enableAutoUpdater=Enable auto updater on first startup?
FirstTimeWizardToadlet.enableAutoUpdaterLong=Whether to enable the auto updater on first startup. This can be disabled by custom configurations for environments in which auto updating is not available.
FirstTimeWizardToadlet.highNetworkThreatLevelWarning=${bold}PLEASE NOTE:${/bold} In high security mode, Freenet only connects to your Friends. Your Friends are people you trust whom you have added through the ${bold}${addAFriend}${/bold} page in the ${bold}${friends}${/bold} menu. In high security mode Freenet will not function until you have added at least one Friend, and you should add at least 3 - preferably 5 to 10 - for better performance. Freenet cannot hide connections made to others, only what is transferred through them. Do not connect to anyone you do not trust or would not want to be publicly linked to in real life.
FirstTimeWizardToadlet.highNetworkThreatLevelCheckbox=I trust at least one person already using Freenet, and I will add them through the ${bold}${addAFriend}${/bold} page.
FirstTimeWizardToadlet.isNetworkTrusted=Is your local network trusted?
FirstTimeWizardToadlet.isNetworkTrustedLong=Is your local network trusted? If you answer yes here all the services provided by your node will be wide open to everyone willing to access them on the given network. You will be able to do selective access controls from the configuration page when the wizard is over.
FirstTimeWizardToadlet.noNetworkIF=No additional network interface found
FirstTimeWizardToadlet.noNetworkIFLong=Freenet hasn't found any additional network interface. It will assume that you will connect to it from your computer and only from it.
FirstTimeWizardToadlet.iDoTrust=Do you trust people connected to ${interface} (${ip})?
FirstTimeWizardToadlet.loadUPnPPlugin=Load the UPnP plugin on first startup?
FirstTimeWizardToadlet.loadUPnPPluginLong=Whether to load the UPnP plugin on first startup. This can be disabled by custom configurations for environments in which UPnP routers are not available.
FirstTimeWizardToadlet.memory.64M=64MiB - only if desperate
FirstTimeWizardToadlet.memory.128M=128MiB - bare minimum
FirstTimeWizardToadlet.memory.192M=192MiB - reasonable default
FirstTimeWizardToadlet.memory.256M=256MiB - if you have at least 1GiB of RAM
FirstTimeWizardToadlet.memory.512M=512MiB - if you have lots of RAM
FirstTimeWizardToadlet.memoryLimit=Memory usage
FirstTimeWizardToadlet.memoryLimitLong=How much memory would you like to allow Freenet to use? If you have many downloads or uploads queued, Freenet will need more memory. We suggest you not set this below 128MiB unless you are really short of RAM. If you have 1GiB or more, you should probably set this to at least 256MiB. This will take effect after restarting Freenet.
FirstTimeWizardToadlet.networkThreatLevelConfirmTitle.HIGH=Add friends or Freenet cannot connect!
FirstTimeWizardToadlet.networkThreatLevelConfirmTitle.MAXIMUM=Add friends or Freenet cannot connect!
FirstTimeWizardToadlet.networkThreatLevelIntroOpennet=Freenet will connect to strangers, so security will be relatively low. You can add friends later if you want. How concerned are you about people you don't know trying to trace you?
FirstTimeWizardToadlet.networkThreatLevelIntroDarknet=Freenet will only connect to your friends, making it very difficult for anyone to trace your Freenet usage. How concerned are you about people you don't know trying to trace you?
FirstTimeWizardToadlet.networkThreatLevelHeaderOpennet=Protection against a stranger attacking you over the internet (connect to strangers)
FirstTimeWizardToadlet.networkThreatLevelHeaderDarknet=Protection against a stranger attacking you over the internet (only connect to friends)
FirstTimeWizardToadlet.networkSecurityPageTitle=Network Security
FirstTimeWizardToadlet.opennetChoicePageTitle=Who should Freenet connect to?
FirstTimeWizardToadlet.opennetChoiceTitle=Who should Freenet connect to?
FirstTimeWizardToadlet.opennetChoiceIntroduction=Freenet is designed to prevent your chat messages, downloads, browsing etc from being traced back to you. Freenet can only provide strong protection when you know the people you are directly connected to.
FirstTimeWizardToadlet.opennetChoiceConnectFriends=Only connect to your friends
FirstTimeWizardToadlet.opennetChoiceConnectStrangers=Connect to strangers
FirstTimeWizardToadlet.opennetChoiceConnectFriendsPRO=Very hard to trace anything on Freenet back to you.
FirstTimeWizardToadlet.opennetChoiceConnectFriendsCON=You need at least ${minfriends} friends that use Freenet.
FirstTimeWizardToadlet.opennetChoiceConnectStrangersPRO=No need to know anyone that uses Freenet.
FirstTimeWizardToadlet.opennetChoiceConnectStrangersCON=Much easier to trace your messages, files, etc back to you.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetToggle=Freenet provides reasonable anonymity and is very hard to block, IF: (touch to see)
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetStupid=You don't do anything that could reveal your identity, e.g. use your real name, post your home address on a chat board or talk about people you know personally. Other personally identifying information includes common sense stuff like where you went to school but also your IP address, your Freenet port numbers, and in some cases your Freenet logs and statistics. If you have a problem with Freenet you should usually make a new identity before asking for help.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetFriends=You only connect to your friends.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetTrustworthy=Your friends are trustworthy (but strangers are always worse than friends).
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetNoSuspect=Possible attackers don't already know or suspect who or where you are: they only know you are a particular identity on Freenet.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetChangeID=You change your anonymous identity occasionally (e.g. on forums).
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetSSK=You always upload files safely. Freenet will remind you how to do this.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetOS=Your friends keep their computers secure.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetBigPriv=You are part of a big network (e.g. the main Freenet which you get if enabling connecting to strangers) or part of a private network which the attackers do not know about.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetDistant=You are not too close to strangers. If for instance your friends connect to strangers, you may not be safe against a very powerful attacker. Most people shouldn't worry too much about this, it will improve as your friends connect their friends and no longer need strangers.
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetBugs=There aren't any horrible bugs in Freenet. Every program of reasonable size contains bugs. We hope no serious ones which would affect your anonymity are left in freenet, but we might have missed them. You have been warned!
FirstTimeWizardToadlet.opennetChoiceHowSafeIsFreenetFoot2=For now you probably want to connect to strangers just to get connected. However, a determined attacker may be able to trace your uploads/downloads/chat/etc back to you, so don't do this if you are planning to upload dangerous content. In the long term we hope everyone will connect only to their friends as this is much safer.
FirstTimeWizardToadlet.opennetChoicePro=Advantage
FirstTimeWizardToadlet.opennetChoiceCon=Disadvantage
FirstTimeWizardToadlet.friendsSecurityPageTitle=Security With Friends
FirstTimeWizardToadlet.physicalSecurityPageTitle=Physical Security
FirstTimeWizardToadlet.plugins=Plugins
FirstTimeWizardToadlet.pluginsLong=Plugins are optional extensions to Freenet that enhance it in some way. Some of them may have security issues for some users, see below.
FirstTimeWizardToadlet.presetTitleLow=Connect to any Freenet user: (low security)
FirstTimeWizardToadlet.presetChooseLow=Choose low security
FirstTimeWizardToadlet.presetLow=If you live in a relatively free country where running Freenet is legal, you can choose this option. It is much safer than traditional P2P software like BitTorrent or Gnutella, but an attacker with moderate resources may be able to trace your activity on Freenet back to you. If you have friends who also run Freenet, you can improve security by adding them as Friends, then connecting only to them.
FirstTimeWizardToadlet.presetTitleHigh=Connect only to friends: (high security)
FirstTimeWizardToadlet.presetChooseHigh=Choose high security
FirstTimeWizardToadlet.presetHigh=If you know several people you want to connect to, this setting allows you to create your own Freenet darknet for vastly improved security. If you only have a few people it may not be very useful, but if some of them know others, or have low security set, you can have a very large network.
FirstTimeWizardToadlet.presetTitleNone=Detailed settings: (custom)
FirstTimeWizardToadlet.presetNone=If you want more fine-grained control, this option lets you set up Freenet according to your own privacy needs. It will take a bit longer than the other two options.
FirstTimeWizardToadlet.presetChooseNone=Choose custom security
FirstTimeWizardToadlet.step1Title=Friends And Strangers
FirstTimeWizardToadlet.step2Title=Name Your Node
FirstTimeWizardToadlet.step3Title=Bandwidth Limits
FirstTimeWizardToadlet.step4Title=Datastore Size
FirstTimeWizardToadlet.stepMiscTitle=Updating And Plugins
FirstTimeWizardToadlet.tenPercentDisk=(= 10% of free disk space)
FirstTimeWizardToadlet.fivePercentDisk=(= 5% of free disk space)
FirstTimeWizardToadlet.backToSecurityLevels=Don't set a password and return to the wizard.
FProxyToadlet.abortToHomepage=Abort and return to the Freenet home page
FProxyToadlet.addFriendTitle=Add a Friend
FProxyToadlet.addFriend=Connect to a friend running Freenet to improve your security
FProxyToadlet.alertsTitle=Messages
FProxyToadlet.alerts=Detailed status alerts and messages from your Friends
FProxyToadlet.backToFProxy=${link}Click here${/link} to go to the Freenet home page.
FProxyToadlet.backToReferrer=${link}Click here${/link} to go back to the referring page.
FProxyToadlet.blocksDetail=Blocks: ${fetched} / ${required} (total ${total} failed ${failed} fatally failed ${fatallyfailed})
FProxyToadlet.cantBindPort=Can't bind the web interface on that port!
FProxyToadlet.categoryBrowsing=Browsing
FProxyToadlet.categoryTitleBrowsing=Browse Freenet
FProxyToadlet.categoryChat=Discussion
FProxyToadlet.categoryTitleChat=Talk with other people over Freenet on message boards
FProxyToadlet.categoryStatus=Status
FProxyToadlet.categoryTitleStatus=Status information
FProxyToadlet.categoryQueue=Filesharing
FProxyToadlet.categoryTitleQueue=Uploads and downloads
FProxyToadlet.categoryConfig=Configuration
FProxyToadlet.categoryTitleConfig=Configure Freenet
FProxyToadlet.categoryFriends=Friends
FProxyToadlet.categoryTitleFriends=Connect to your friends to improve Freenet's performance and security
FProxyToadlet.chatForumsTitle=Forums
FProxyToadlet.chatForums=How to talk to other Freenet users anonymously over chat forums
FProxyToadlet.config=configure your node
FProxyToadlet.configTitle=Configuration
FProxyToadlet.contentTypeLabel=Content type:
FProxyToadlet.dangerousContentTitle=Potentially Dangerous Content
FProxyToadlet.dangerousRSS=Freenet has detected that the file you are trying to fetch might be RSS. RSS cannot be properly filtered by Freenet, and may contain web-bugs (inline images etc which may expose your IP address to a malicious site author and therefore break your anonymity). Firefox 2.0 and Internet Explorer 7.0 will open the file as RSS even though its content type is "${type}".
FProxyToadlet.dangerousRSSSubtitle=RSS feed may be dangerous
FProxyToadlet.dangerousRSSTitle=Potentially Dangerous Content (RSS)
FProxyToadlet.diagnostic=Diagnostics to send to developers
FProxyToadlet.diagnosticTitle=Diagnostic
FProxyToadlet.downloadInBackgroundToDiskButton=Download
FProxyToadlet.downloadInBackgroundToDisk=Download the file in the background and store in ${dir}. You will be notified when the download completes, and can follow its progress on the ${page}downloads page${/page}.
FProxyToadlet.downloadInBackgroundToTempSpaceButton=Fetch
FProxyToadlet.downloadInBackgroundToTempSpace=Fetch the file in the background. It will be accessible ${bold}only${/bold} through the ${page}downloads page${/page}, and will be lost if you uninstall Freenet, click the panic button, or lose the master password. You will be notified when the fetch completes.
FProxyToadlet.downloadToDiskWarningNotFiltered=${bold}Warning${/bold}: The file downloaded to disk will not be filtered. Be careful when you open it as it might cause your web browser or other software to breach your anonymity, give away your IP address, or if it is an executable may contain virii, trojans, etc.
FProxyToadlet.downloadToDiskSecurityWarning=${bold}Warning${/bold}: this will store the file unencrypted on your hard disk, and may present a security risk if you are not using full-disk encryption.
FProxyToadlet.downloadsTitle=Downloads
FProxyToadlet.downloads=Files being downloaded from Freenet
FProxyToadlet.errorIsFatal= This is a fatal error. It is unlikely that retrying will solve the problem.
FProxyToadlet.errorWithReason=Error: ${error}
FProxyToadlet.expectedKeyButGot=Expected a Freenet key, but got:
FProxyToadlet.expectedMimeType=Expected type: ${mime}
FProxyToadlet.explanationTitle=Explanation
FProxyToadlet.fetchingPageTitle=Downloading a page
FProxyToadlet.fetchingPageBox=Freenet is downloading the page you requested
FProxyToadlet.fetchingPageOptions=Your options
FProxyToadlet.fetchLargeFileAnywayAndDisplay=Open the file in the browser. This may take some time and the file may be large.
FProxyToadlet.fetchLargeFileAnywayAndDisplayButton=Display
FProxyToadlet.fileInformationTitle=File Information
FProxyToadlet.filenameLabel=Filename:
FProxyToadlet.filterFile=Run a file through the content filter
FProxyToadlet.filterFileTitle=Filter a file
FProxyToadlet.filterData=Filter data:
FProxyToadlet.filterDataMessage=Select this to run your request through the content filter. The filter will try to prevent your computer from running anything which might harm it, or break your anonymity. Keeping this checked is strongly recommended.
FProxyToadlet.friends=Connections to your friends' nodes
FProxyToadlet.friendsTitle=Connections to friends
FProxyToadlet.goBack=Go back
FProxyToadlet.goBackToPrev=Go back to the previous page
FProxyToadlet.help=Help
FProxyToadlet.insertFreesiteTitle=Upload a Freesite
FProxyToadlet.insertFreesite=Upload a web site anonymously to Freenet
FProxyToadlet.invalidKeyTitle=Invalid Key
FProxyToadlet.invalidKeyWithReason=Invalid key: ${reason}
FProxyToadlet.largeFile=Large file
FProxyToadlet.largeFileExplanationAndOptions=The Freenet key you requested refers to a large file. Files of this size cannot generally be sent directly to your browser since they take too long for your Freenet node to retrieve. The following options are available:
FProxyToadlet.mayChange= (may change)
FProxyToadlet.mimeType=Content type: ${mime}
FProxyToadlet.notFoundTitle=Not Found
FProxyToadlet.openAsText=${link}Click here${/link} to open the file as plain text (this should not be dangerous but it may be garbled).
FProxyToadlet.openAsThawIndex=${link}Click here${/link} to open the file with thaw index browser (read warning above!).
FProxyToadlet.openForce=${link}Click here${/link} to open the file as ${mime} without filtering (NOT RECOMMENDED: read the warning above!).
FProxyToadlet.openForceDisk=${link}Click here${/link} to force your browser to download the file to disk.
FProxyToadlet.openPossRSSForceDisk=${link}Click here${/link} to try to force your browser to download the file to disk (this ${bold}may be dangerous${/bold}).
FProxyToadlet.openPossRSSAsPlainText=${link}Click here${/link} to open the file as plain text (this ${bold}may be dangerous${/bold} if you are running IE7).
FProxyToadlet.openRSSAsRSS=${link}Click here${/link} to open the file as RSS (this ${bold}is dangerous${/bold} if the site author is malicious as Freenet does not know how to filter RSS yet).
FProxyToadlet.openRSSForce=${link}Click here${/link} to open the file as ${mime} (this ${bold}may be dangerous${/bold} on IE7 or FF2).
FProxyToadlet.opennet=Connections to nodes you have no reason to trust
FProxyToadlet.opennetTitle=Connections to strangers
FProxyToadlet.openWithKeyExplorer=${link}Click here${/link} to open the Freenet uri with key explorer.
FProxyToadlet.openWithSiteExplorer=${link}Click here${/link} to open the Freenet uri with site explorer.
FProxyToadlet.options=Your options are:
FProxyToadlet.pathNotFound=The specified path does not exist.
FProxyToadlet.pathNotFoundTitle=Path Not Found
FProxyToadlet.plugins=Configure plugins
FProxyToadlet.pluginsTitle=Plugins
FProxyToadlet.progressCheckingStore=Your computer is checking your local cache for this page or file. If it is not stored there, it will try to download it from Freenet.
FProxyToadlet.lastRefresh=Last refresh was {0} ago
FProxyToadlet.progressDownloading=Your computer is downloading this page or file from Freenet. This could take seconds or minutes depending on how big and how popular the page or file is - the more often something is accessed in Freenet, the better is its availability and download speed.
FProxyToadlet.progressNotFinalized=The progress bar will jump around until we have downloaded enough blocks to determine the size of the file.
FProxyToadlet.progressOptionZero=You can wait for the requested page. This status page will be refreshed until the file is fetched or Freenet gives up searching. Alternatively:
FProxyToadlet.uploadsTitle=Uploads
FProxyToadlet.uploads=Files being uploaded to Freenet
FProxyToadlet.uploadFileWizardTitle=Upload a file
FProxyToadlet.uploadFileWizard=Upload a file to Freenet
FProxyToadlet.retryNow=Retry now
FProxyToadlet.seclevelsTitle=Security Levels
FProxyToadlet.seclevels=Configure the level of security provided by Freenet
FProxyToadlet.sizeLabel=Size:
FProxyToadlet.sizeUnknown=Size: unknown
FProxyToadlet.stats=Detailed statistics about your Freenet node
FProxyToadlet.statsTitle=Statistics
FProxyToadlet.timeElapsedLabel=Time elapsed:
FProxyToadlet.unableToRetrieve=Freenet was unable to retrieve this file.
FProxyToadlet.unableToSafelyDisplay=Freenet cannot guarantee that this file is safe: it may cause your browser to give away your IP address and breach your anonymity!
FProxyToadlet.unknownMIMEType=Content type: unknown
FProxyToadlet.welcome=Browse and search Freesites, web sites hosted anonymously on Freenet
FProxyToadlet.welcomeTitle=Browse Freenet
FProxyToadlet.imageinitializing=Initializing
FcpServer.allowedHosts=Allowed hosts (read the warning!)
FcpServer.allowedHostsFullAccess=Hosts allowed full access
FcpServer.allowedHostsFullAccessLong=IP addresses which are allowed full access to your Freenet node. Clients on these IPs may restart Freenet, reconfigure it, etc. Note that ALL clients are allowed to do direct disk I/O!
FcpServer.allowedHostsLong=IP addresses that are allowed to connect to the FCP server. May be a comma-separated list of single IPs and CIDR masked IPs like 192.168.0.0/24. WARNING! Anyone who has access to FCP can upload any file your Freenet node has access to, or download files to disk (but the node will try not to overwrite existing files).
FcpServer.assumeDownloadDDAIsAllowed=Assume that download DDA is allowed?
FcpServer.assumeDownloadDDAIsAllowedLong=Assume that download DDA is allowed? if false, you have to issue a TestDDARequest before making any DDA access.
FcpServer.assumeUploadDDAIsAllowed=Assume that upload DDA is allowed?
FcpServer.assumeUploadDDAIsAllowedLong=Assume that upload DDA is allowed? if false, you have to issue a TestDDARequest before making any DDA access.
FcpServer.bindTo=IP address to bind to
FcpServer.bindToLong=IP address to bind the FCP server to.
FcpServer.cannotStartOrStopOnTheFly=Cannot start or stop the FCP server on the fly
FcpServer.couldNotChangeBindTo=Could not change FCP bind address: Some of the IP addresses given could not be bound to: ${failedInterfaces}. Maybe you mistyped an IP address or a network connection is down?
FcpServer.enablePersistentDownload=Enable persistent downloads?
FcpServer.enablePersistentDownloadLong=Whether to enable Persistence=forever for FCP requests. Meaning whether to support requests which persist over node restarts; they must be written to disk and this may constitute a security risk for some people.
FcpServer.isEnabled=Enable FCP?
FcpServer.isEnabledLong=Enable the Freenet Client Protocol server
FcpServer.portNumber=FCP port
FcpServer.portNumberLong=The TCP port the FCP server should listen on
FcpServer.ssl=Enable SSL?
FcpServer.sslLong=Enable SSL on the FCP server. You will need the 'Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files' for it to work.
FcpServer.maxMessageQueueLength=Maximum number of queued FCP messages per connection
FcpServer.maxMessageQueueLengthLong=Above this queue length either drop messages or log an ERROR depending on the "Never drop an FCP message" option.
FcpServer.neverDropAMessage=Never drop an FCP message?
FcpServer.neverDropAMessageLong=Enable this to cache all messages for any FCP connection forever even if it causes the node to run out of memory. Not a good idea but useful for debugging in some cases.
FetchException.longError.10=File not in archive
FetchException.longError.11=Too many path components - not a manifest? Try removing one
FetchException.longError.12=Internal temp files error, maybe disk full or permissions problem?
FetchException.longError.13=Data not found
FetchException.longError.14=Route not found - could not find enough nodes to be sure the data doesn't exist
FetchException.longError.15=A node was overloaded or timed out
FetchException.longError.16=Too many redirects - loop?
FetchException.longError.17=Internal error, probably a bug
FetchException.longError.18=Found the file, but lost it while receiving the data
FetchException.longError.19=Splitfile error
FetchException.longError.1=Too many levels of recursion into archives
FetchException.longError.20=Invalid URI
FetchException.longError.21=Too big
FetchException.longError.22=Metadata too big
FetchException.longError.23=Too many blocks per segment
FetchException.longError.24=Give more path components in URI
FetchException.longError.25=Cancelled
FetchException.longError.26=Archive restarted
FetchException.longError.27=Permanent redirect: use the new URI
FetchException.longError.28=Some of the data was found, but not enough to fetch the key.
FetchException.longError.29=Wrong content type: The key was not in the list of allowed content types provided by the client
FetchException.longError.2=Don't know what to do with splitfile
FetchException.longError.30=The request was terminated by a node because it had recently received a request for the same key and that request had failed
FetchException.longError.31=The page (or file) appears to be corrupt, but might be dangerous; you should not open this page unless you know what you are doing. Normally Freenet can filter pages of this type, but this page is so broken that we are unable to make it safe. If you open it anyway it won't be filtered, so it may give away your IP address.
FetchException.longError.32=The data is of an unknown type which might be dangerous
FetchException.longError.33=The data is of a type known to be dangerous, so the content filter has stopped the request
FetchException.longError.34=The hashes in the metadata do not match the actual data. The data may have been corrupted during download, or it may have been broken when it was inserted for example if the node inserting was broken or the data changed on disk mid-insert.
FetchException.longError.35=Splitfile decoding produced a data block that wasn't in the original list of keys. It is likely that the insert was corrupted, but it is possible that this is a bug or hardware failure on your computer.
FetchException.longError.36=The file claims to have a safe MIME type but is being downloaded to disk with a file extension not compatible with that type. For example, "virus.exe" claiming to be a text file would trigger this error. This might just be a bad filename, but it might be a malicious file trying to get past the content filter.
FetchException.longError.37=There is not enough disk space to start a download or to start the next stage of a download. Please free up some disk space and restart the request.
FetchException.longError.3=Don't know what to do with metadata
FetchException.longError.4=Failed to parse metadata
FetchException.longError.5=Failure in extracting files from an archive
FetchException.longError.6=Failed to decode a block
FetchException.longError.7=Too many levels of split metadata
FetchException.longError.8=Request was restarted too many times due to archives changing
FetchException.longError.9=Too many redirects (too much recursion)
FetchException.shortError.10=Not in archive
FetchException.shortError.11=Too many path components
FetchException.shortError.12=Temporary files error
FetchException.shortError.13=Data not found
FetchException.shortError.14=Route not found
FetchException.shortError.15=Timeout or overload
FetchException.shortError.16=Too many redirects
FetchException.shortError.17=Internal error
FetchException.shortError.18=Transfer failed
FetchException.shortError.19=Splitfile error
FetchException.shortError.1=Too deep archive recursion
FetchException.shortError.20=Invalid URI
FetchException.shortError.21=Too big
FetchException.shortError.22=Metadata too big
FetchException.shortError.23=Too many blocks per segment
FetchException.shortError.24=Not enough path components
FetchException.shortError.25=Cancelled by caller
FetchException.shortError.26=Archive restarted
FetchException.shortError.27=New URI
FetchException.shortError.28=Not enough data found
FetchException.shortError.29=Wrong content type
FetchException.shortError.2=Unknown splitfile metadata
FetchException.shortError.30=Data not found (recently failed)
FetchException.shortError.31=Content sanitization failed
FetchException.shortError.32=Content filter encountered unknown type
FetchException.shortError.33=Content filter encountered dangerous type
FetchException.shortError.34=Content does not match hashes in metadata
FetchException.shortError.35=Splitfile decode error
FetchException.shortError.36=Filename doesn't match MIME type for filtered download to disk
FetchException.shortError.37=Not enough disk space
FetchException.shortError.3=Unknown metadata
FetchException.shortError.4=Invalid metadata
FetchException.shortError.5=Archive failure
FetchException.shortError.6=Block decode error
FetchException.shortError.7=Too many metadata levels
FetchException.shortError.8=Too many archive restarts
FetchException.shortError.9=Too much recursion
FetchException.unsafeContentDetails=If you are the original author of the file, you may be interested in the details of why we think it is corrupt (but no matter how trivial this is, it does NOT make the file safe!):
FileOffer.askUserTitle=Direct file transfer
FileOffer.offeredFileHeader=The node ${name} has offered a file:
FileOffer.offeredFileShort=Your friend ${node} has offered the file ${filename}.
FileOffer.fileLabel=File:
FileOffer.fileSavedToLabel=Saved to:
FileOffer.senderLabel=Sender:
FileOffer.commentLabel=Comment:
FileOffer.mimeLabel=Content Type:
FileOffer.sizeLabel=Size:
FileOffer.acceptTransferButton=Accept Transfer
FileOffer.rejectTransferButton=Reject Transfer
FileOffer.failedReceiveHeader=The transfer of the file ${filename} from ${node} has failed.
FileOffer.failedReceiveTitle=Failed to receive file
FileOffer.failedReceiveShort=The transfer of the file ${filename} from ${node} has failed.
FileOffer.succeededReceiveTitle=Successfully received file
FileOffer.succeededReceiveHeader=The transfer of the file ${filename} from ${node} was a success.
FileOffer.succeededReceiveShort=Successfully received ${filename} from ${node}.
GIFFilter.invalidHeader=The file does not contain a valid GIF header.
GIFFilter.invalidHeaderTitle=Invalid header
GIFFilter.notGif=The file you tried to fetch is not a valid GIF. It might be some other file format, and your browser may do something dangerous with it, therefore we have blocked it.
GIFFilter.unexpectedEOF=The GIF file ended before it was read completely. The file may be truncated, damaged or malicious.
GIFFilter.unexpectedEOFTitle=File ended unexpectedly
GIFFilter.noData=The filtered GIF file does not contain valid image data. The file may be truncated, damaged or malicious.
GIFFilter.noDataTitle=No valid image data
GIFFilter.unterminatedGif=The GIF file does not end with a termination character. It may be truncated, damaged, or malicious.
GIFFilter.unterminatedGifTitle=Unterminated GIF file
GenericReadFilterCallback.bogusBaseHref=Unacceptable base href
GenericReadFilterCallback.couldNotParseAbsoluteFreenetURI=Could not parse as an absolute Freenet URI
GenericReadFilterCallback.couldNotParseFormURIWithError=Filter could not parse form URI: ${error}
GenericReadFilterCallback.couldNotParseRelativeFreenetURI=Could not parse as a relative Freenet URI
GenericReadFilterCallback.couldNotParseURIWithError=Filter could not parse URI: ${error}
GenericReadFilterCallback.deletedURI=Deleted invalid or dangerous URI
GenericReadFilterCallback.invalidFormURI=Invalid form URI: points to external resource
GenericReadFilterCallback.invalidFormURIAttemptToEscape=Attempt to escape directory structure
GenericReadFilterCallback.malformedAbsoluteURL=Malformed URL (absolute): ${error}
GenericReadFilterCallback.malformedRelativeURL=Malformed URL (relative): ${error}
GenericReadFilterCallback.protocolNotEscaped=Not an escaped protocol: ${protocol}
HTMLFilter.couldNotParseStyle=Could not match input style
HTMLFilter.deletedUnknownStyle=deleted unknown style
HTMLFilter.failedToParseLabel=Corrupt or malicious web page (unable to filter the page)!
HTMLFilter.invalidMetaType=Invalid content type in meta tag, not a known HTML format.
HTMLFilter.metaOutsideHead=<meta> tag outside <head>. This is not allowed and can cause problems with different character sets / languages.
HTMLFilter.multipleCharsetsInMeta=Multiple <meta> charset declarations. This is confusing, invalid, unsafe and not allowed.
HTMLFilter.textBeforeHTML=Invalid HTML document: Text before <html> tag. We only allow valid HTML documents and not fragments because this makes for more reliable filtering (particularly avoiding charset ambiguity).
HTMLFilter.tooManyNestedStyleOrScriptTags=Too many nested style or script tags - ambiguous or invalid parsing
HTMLFilter.tooManyNestedStyleOrScriptTagsLong=Too many nested </style> tags - ambiguous or invalid parsing, can't reliably filter so removing the inner tags - garbage may appear in browser
HTMLFilter.unknownTag=unknown tag ${tag}
HTMLFilter.wrongCharsetInMeta=A meta tag indicates the wrong charset
InsertContext.CompatibilityMode.COMPAT_CURRENT=Current (latest, most efficient)
InsertContext.CompatibilityMode.COMPAT_UNKNOWN=Unknown
InsertContext.CompatibilityMode.COMPAT_1250_EXACT=Pre-1250 (exact)
InsertContext.CompatibilityMode.COMPAT_1250=Pre-1250 (with even splitting)
InsertContext.CompatibilityMode.COMPAT_1251=1251
InsertContext.CompatibilityMode.COMPAT_1255=1255
InsertContext.CompatibilityMode.COMPAT_1416=1416
InsertContext.CompatibilityMode.COMPAT_1468=1468
InsertFreesiteToadlet.title=Upload a freesite
InsertFreesiteToadlet.content1=You can anonymously upload a web site to Freenet ("insert a Freesite"). Once it has been uploaded, it will remain on Freenet for as long as people continue to access it occasionally. It is distributed across the network and therefore also available if your computer is turned off. And the most important fact: If the security level of Freenet has been configured properly it should be very difficult to find out who has uploaded a Freesite.
InsertFreesiteToadlet.contentFlogHelper=If you just want to create a simple blog, we recommend you use FlogHelper. You can load this on the ${plugins}plugins page${/plugins}, and then use it from the menu.
InsertFreesiteToadlet.content2=If you want to upload a website you have mirrored from somewhere, or something larger or more complex, you will need a tool called jSite. Get it from ${jsite-http}our web site${/jsite-http}, or you can get version ${jsite-freenet-version} ${jsite-freenet}from Freenet${/jsite-freenet} (${jsite-info}more information${/jsite-info}).
InsertFreesiteToadlet.content3=Once you have downloaded jSite, and constructed your website using an HTML editor such as KompoZer (free), work through one of the following tutorials which are hosted on Freenet:
InsertFreesiteToadlet.contentThingamablog=Alternatively, Thingamablog is a user-friendly blog generator, you can download a Freenet-compatible version ${thingamablog}here${/thingamablog} or ${thingamablog-freenet}over Freenet${/thingamablog-freenet}.
InsertFreesiteToadlet.publishExplanation=A short tutorial on how to insert freesites
InsertFreesiteToadlet.freesiteHowtoExplanation=Another, longer tutorial on how to insert freesites
IPDetectorPluginManager.direct=You appear to be directly connected to the internet. Congratulations, you should be able to connect to any other Freenet node.
IPDetectorPluginManager.directTitle=Direct internet connection detected
IPDetectorPluginManager.fullCone=Your internet connection appears to be behind a "full cone" NAT (router). Congratulations, your node should be able to connect to any other Freenet node.
IPDetectorPluginManager.fullConeTitle=Full cone NAT detected
IPDetectorPluginManager.noConnectivity=Your internet connection does not appear to support UDP. Unless this detection is wrong, it is unlikely that Freenet will work on your computer at present.
IPDetectorPluginManager.noConnectivityTitle=No UDP connectivity
IPDetectorPluginManager.noConnectivityshort=Severe connection problems: No UDP connectivity, Freenet will not work!
IPDetectorPluginManager.portRestricted=Your internet connection appears to be behind a port-restricted NAT (router). You will be able to connect to most other users, but not those behind symmetric NATs.
IPDetectorPluginManager.portRestrictedTitle=Port restricted cone NAT detected
IPDetectorPluginManager.restricted=Your internet connection appears to be behind a "restricted cone" NAT (router). You should be able to connect to most other users.
IPDetectorPluginManager.restrictedTitle=Restricted cone NAT detected
IPDetectorPluginManager.suggestForwardPort= You may want to forward the port (UDP port number ${port}) manually. (See http://wiki.freenetproject.org/FirewallAndRouterIssues ).
IPDetectorPluginManager.suggestForwardTwoPorts= You may want to forward the ports (UDP port numbers ${port1} and ${port2}) manually. (See http://wiki.freenetproject.org/FirewallAndRouterIssues ).
IPDetectorPluginManager.suggestForwardPortWithLink= You may want to ${link}forward the port${/link} (UDP port number ${port}) manually (or you may already have done so, Freenet cannot easily detect this).
IPDetectorPluginManager.suggestForwardTwoPortsWithLink= You may want to ${link}forward the ports${/link} (UDP port numbers ${port1} and ${port2}) manually (or you may already have done so, Freenet cannot easily detect this).
IPDetectorPluginManager.symmetric=Your internet connection appears to be behind a symmetric NAT or firewall. You will probably only be able to connect to users directly connected to the internet or behind restricted cone NATs.
IPDetectorPluginManager.symmetricTitle=Symmetric firewall detected
IPDetectorPluginManager.seriousConnectionProblems=Serious connection problems:
IPDetectorPluginManager.connectionProblems=Connection problems:
IPDetectorPluginManager.forwardPortShortMaybeForwarded=Please forward UDP port ${port} (you may have already done this).
IPDetectorPluginManager.forwardPortShortNotForwarded=Please forward UDP port ${port} (it is probably not forwarded).
IPDetectorPluginManager.forwardTwoPortsShortMaybeForwarded=Please forward UDP ports ${port1} and ${port2} (you may have already done this).
IPDetectorPluginManager.forwardTwoPortsShortNotForwarded=Please forward UDP ports ${port1} and ${port2} (they appear not to be forwarded).
IPDetectorPluginManager.forwardPortMaybeForwarded=Your node appears to be behind some sort of NAT (see the connectivity page for details). You should forward UDP (not TCP) port ${port} if possible to improve connectivity. It is possible you have already done this; it takes a while for Freenet to detect a port forward. See ${link}here${/link} for some more information.
IPDetectorPluginManager.forwardPortNotForwarded=Your node appears to be behind some sort of NAT (see the connectivity page for details). You should forward UDP (not TCP) port ${port} if possible to improve connectivity. It appears that the port has not been forwarded, although Freenet cannot be sure. See ${link}here${/link} for some more information. It may take up to 24 hours for Freenet to recognise that you have successfully forwarded the ports.
IPDetectorPluginManager.maybeAlreadyForwarded=You may have already done this (it is hard for Freenet to detect).
IPDetectorPluginManager.forwardTwoPortsMaybeForwarded=Your node appears to be behind some sort of NAT (see ${connectivity}the connectivity page${/connectivity} for details). You should forward UDP (not TCP) ports ${port1} and ${port2} if possible to improve connectivity. It is possible you have already done this; it takes a while for Freenet to detect a port forward. See ${link}here${/link} for some more information.
IPDetectorPluginManager.forwardTwoPortsNotForwarded=Your node appears to be behind some sort of NAT (see ${connectivity}the connectivity page${/connectivity} for details). You should forward UDP (not TCP) ports ${port1} and ${port2} if possible to improve connectivity. It appears that the ports have not been forwarded, although Freenet cannot be sure. See ${link}here${/link} for some more information.
IPDetectorPluginManager.portForwardHelpURL=http://wiki.freenetproject.org/FirewallAndRouterIssues
IPDetectorPluginManager.symmetricPS=Your node is behind a symmetric NAT, which is especially problematic, so if you don't forward the port(s), you may not be able to connect to most nodes!
IPUndetectedUserAlert.detecting=Freenet is currently attempting to detect your external IP address. If this takes more than a few minutes there is something wrong...
IPUndetectedUserAlert.detectingShort=Freenet is currently attempting to detect your external IP address.
IPUndetectedUserAlert.detectingWithConfigLink=Freenet is currently attempting to detect your external IP address. If this takes more than a few minutes there is something wrong and you can use the Temporary IP Address Hint ${link}configuration parameter${/link}.
IPUndetectedUserAlert.loadDetectPlugins=No IP detection plugins are currently loaded. Please go to the ${plugins}Plugins page${/plugins} and load the UPnP plugin.
IPUndetectedUserAlert.loadJSTUN=You could load the JSTUN plugin on the ${plugins}Plugins page${/plugins}, but please read the warnings about it first as it may not be safe.
IPUndetectedUserAlert.noIPMaybeFromPeers=Freenet should be able to detect it from your ${number} friends, but they may be offline or not port forwarded.
IPUndetectedUserAlert.noDetectorPlugins=Freenet is unable to detect your IP address! Please load the UPnP plugin!
IPUndetectedUserAlert.unknownAddress=Freenet was unable to determine your external IP address (or the IP address of your router or Firewall). You can still exchange references with your friends, however this may not always work if your friend is behind a router or firewall. As soon as you have connected to one other user in this way, Freenet will be able to determine your external IP address. You can determine your current IP address and tell your node with the 'Temporary IP address hint' on the config page. Alternatively if you have a static IP address or domain name, please tell Freenet about it using the "IP address override" option.
IPUndetectedUserAlert.unknownAddressTitle=Unknown external address
IPUndetectedUserAlert.unknownAddressWithConfigLink=Freenet was unable to determine your external IP address (or the IP address of your router or firewall). You can still exchange references with your friends, however this may not always work if your friend is behind a router or firewall. As soon as you have connected to one other user in this way, Freenet will be able to determine your external IP address. You can determine your current IP address and tell your node with the 'Temporary IP address hint' on ${link}the config page${/link}, or enter it below. Alternatively if you have a static IP address or domain name, please tell Freenet about it using the "IP address override" option.
IPUndetectedUserAlert.unknownAddressShort=Freenet was unable to determine your IP address. You may have problems connecting.
IPUndetectedUserAlert.suggestForwardPort=Also, it would be a good idea to forward the port ${port} (UDP) on your router to make it easier to connect to your node.
IPUndetectedUserAlert.suggestForwardTwoPorts=Also, it would be a good idea to forward the ports ${port1} and ${port2} (UDP) on your router to make it easier to connect to your node.
InsertException.longError.10=Cancelled by user
InsertException.longError.11=Path component (most likely a '/') used in the URI
InsertException.longError.12=Binary blob format error
InsertException.longError.13=Too many files in a single folder on a freesite insert
InsertException.longError.14=Uploading files larger than 64TB not supported at present
InsertException.longError.1=Caller supplied a URI we cannot use
InsertException.longError.2=Internal bucket error: out of disk space/permissions problem?
InsertException.longError.3=Internal error
InsertException.longError.4=A downstream node timed out or was severely overloaded
InsertException.longError.5=Could not propagate the insert to enough nodes (normal on small networks, try fetching it anyway)
InsertException.longError.6=Fatal errors in a splitfile insert
InsertException.longError.7=Could not insert splitfile: ran out of retries (nonfatal errors)
InsertException.longError.8=Insert could not leave this Freenet node at all
InsertException.longError.9=Insert collided with different, pre-existing data at the same key
InsertException.shortError.10=Cancelled
InsertException.shortError.11=Meta string used in the key
InsertException.shortError.12=Binary blob format error
InsertException.shortError.13=Too many files in a single folder
InsertException.shortError.14=File is too large
InsertException.shortError.1=Invalid URI
InsertException.shortError.2=Temp files error
InsertException.shortError.3=Internal error
InsertException.shortError.4=Timeout or overload
InsertException.shortError.5=Route not found
InsertException.shortError.6=Some blocks failed fatally
InsertException.shortError.7=Some blocks ran out of retries
InsertException.shortError.8=Request could not leave the node
InsertException.shortError.9=Collided with existing data
InvalidAddressOverrideUserAlert.unknownAddress=Freenet has determined that the currently configured ipAddressOverride value is invalid, meaning that it does not match the syntax for a valid hostname, IPv4 address or IPv6 address (in the opinion of the current implementation of the function that checks the IPv6 address syntax).
InvalidAddressOverrideUserAlert.unknownAddressTitle=Invalid Address Override Value
InvalidAddressOverrideUserAlert.unknownAddressWithConfigLink=Freenet has determined that the currently configured ipAddressOverride value is invalid, meaning that it does not match the syntax for a valid hostname, IPv4 address or IPv6 address (in the opinion of the current implementation of the function that checks the IPv6 address syntax). You can correct the 'IP address override' ${link}configuration parameter${/link}.
InvalidAddressOverrideUserAlert.unknownAddressShort=Your ipAddressOverride is bogus. Please fix it.
IntOption.parseError=The value specified can't be parsed as a 32-bit integer : ${val}
JavaEOLAlert.body=Your Java version ${current} is at its "End Of Life" and is no longer receiving updates to fix security problems. Freenet will require version ${new} or higher in a future update, so it will stop working with this one. Please upgrade your Java installation.
JavaEOLAlert.title=Freenet will stop working with your outdated Java version
JPEGFilter.notJpeg=The file you tried to fetch is not a JPEG. It might be some other file format, and your browser may do something dangerous with it, therefore we have blocked it.
KnownUnsafeContentTypeException.dangerousInlines=This type of content can contain inline images or videos, and can therefore load content from the non-anonymous open Web, exposing your IP address.
KnownUnsafeContentTypeException.dangerousInlinesLabel=Dangerous inlines:
KnownUnsafeContentTypeException.dangerousLinks=This type of content can contain links to the non-anonymous Web; if you click on them (and they may be disguised), this may expose your IP address.
KnownUnsafeContentTypeException.dangerousLinksLabel=Dangerous links:
KnownUnsafeContentTypeException.dangerousMetadata=This type of content can contain metadata which may be displayed by some browsers or other software, which may contain dangerous links or inlines.
KnownUnsafeContentTypeException.dangerousMetadataLabel=Dangerous metadata:
KnownUnsafeContentTypeException.dangerousScripts=This type of content can contain dangerous scripts which when executed may compromise your anonymity by connecting to the open Web or otherwise breach security.
KnownUnsafeContentTypeException.dangerousScriptsLabel=Dangerous scripting:
KnownUnsafeContentTypeException.knownUnsafe=This is a potentially dangerous content type. If Freenet lets it through, your browser may do bad things leading to compromise of your anonymity, and your IP address being exposed in connection with this page. In particular:
KnownUnsafeContentTypeException.noFilter=Since there is no built-in filter for this data, you should take the utmost of care!
KnownUnsafeContentTypeException.title=Known dangerous type: ${type}
LocalFileInsertToadlet.checkPathExist=Check that the specified path does exist.
LocalFileInsertToadlet.checkPathIsDir=Check that the specified path is a directory.
LocalFileInsertToadlet.checkPathReadable=Check that the specified path is readable by the user running Freenet.
LocalFileInsertToadlet.dirAccessDenied=You cannot browse this directory.
LocalFileInsertToadlet.dirCannotBeRead=The directory "${path}" cannot be read.
LocalFileInsertToadlet.fileHeader=File
LocalFileInsertToadlet.insert=Insert
LocalFileInsertToadlet.listing=Directory Listing: ${path}
LocalFileInsertToadlet.listingTitle=Listing of ${path}
LocalFileInsertToadlet.sizeHeader=Size
LogConfigHandler.detaildPriorityThreshold=Detailed priority thresholds
LogConfigHandler.detaildPriorityThresholdLong=Detailed priority thresholds, example freenet:normal,freenet.node:minor
LogConfigHandler.dirName=Logging directory
LogConfigHandler.dirNameLong=Directory into which to put log files
LogConfigHandler.enabled=Enable logging?
LogConfigHandler.enabledLong=Set to false to completely disable logging
LogConfigHandler.maxBacklogNotBusy=Max time between writing logs (milliseconds)
LogConfigHandler.maxBacklogNotBusyLong=Maximum time between writing logs if log writing load is not heavy. (milliseconds)
LogConfigHandler.maxCachedBytes=Max cached log bytes in RAM
LogConfigHandler.maxCachedBytesLong=Maximum number of bytes of logging cached in RAM
LogConfigHandler.maxCachedLines=Max cached log lines in RAM
LogConfigHandler.maxCachedLinesLong=Maximum number of lines of logging cached in RAM
LogConfigHandler.maxZippedLogsSize=Maximum disk space used by old logs
LogConfigHandler.maxZippedLogsSizeLong=Maximum disk space used by old logs
LogConfigHandler.minLoggingPriority=Minimum priority to log messages at
LogConfigHandler.minLoggingPriorityLong=Minimum priority at which messages are logged. Options are debug, minor, normal, warning, error, in order of diminishing verbosity. Generally you only need to change this if something is broken and you need to gather more information for the developers. If you are worried about your computer being seized, set this to ERROR to minimise any possible information leakage.
LogConfigHandler.rotationInterval=Log rotation interval
LogConfigHandler.rotationIntervalLong=Log rotation interval - period after which logs are rotated. We keep the last two log files (current and prev), plus lots of compressed logfiles up to maxZippedLogsSize
LoggerHook.unrecognizedPriority=Unrecognised priority name: ${name}.
LongOption.parseError=The value specified can't be parsed as a 64-bit integer : ${val}
MainJarUpdater.ConfirmMultiFileUpdater.title.wrapper-update-unix=Please update the wrapper files
MainJarUpdater.ConfirmMultiFileUpdater.text.wrapper-update-unix=Freenet has downloaded an update to the Java Service Wrapper binaries. These are a set of files involved in running and updating Freenet. Updating these files may fix some important bugs especially on Linux/FreeBSD, particularly a bug that often causes Freenet to restart repeatedly after an update. We strongly recommend that you allow Freenet to update these files as soon as is convenient.
MeaningfulNodeNameUserAlert.noNodeNick=Please set a name for your node so that your friends can identify your node, e.g. if you send them a message or a file. This will only be visible to your Friends who you manually connect to via the Add a Friend page, and possibly to their Friends. Your node's nickname will not be visible to strangers, that is, Freenet connections added automatically in the lower security levels.
MeaningfulNodeNameUserAlert.noNodeNickTitle=Please set a name for your Freenet node.
MeaningfulNodeNameUserAlert.noNodeNickShort=Please set a name for your Freenet node.
MP3Filter.bogusMP3NoFrames=Doesn't look like an MP3.
MP3Filter.bogusMP3NoFramesExplanation=This does not look like an MP3 file. It might be corrupt or somebody might be trying to mask some other kind of (potentially dangerous) file as an mp3 file to breach your anonymity.
MP3Filter.freeBitrateNotSupported=Free format bitstream MP3 files not supported by filter
MP3Filter.freeBitrateNotSupportedExplanation=The file appears to be an mp3 file with the "freeformat" bitstream extension, which allows non-standard bitrates. These are not supported by most players and so are relatively rare. Nonetheless the file is probably safe if you are careful and your player doesn't do silly things, like rendering web URLs as links.
N2NTMToadlet.composingMessageLabel=Composing N2NTM to send to the following peers:
N2NTMToadlet.delayed=Backed off: Sending of message possibly delayed to peer
N2NTMToadlet.delayedTitle=Delayed
N2NTMToadlet.failed=Message not sent to peer: peer not connected
N2NTMToadlet.failedTitle=Failed
N2NTMToadlet.friends=Friends
N2NTMToadlet.mayAttachFile=You may attach a file, but you don't have to.
N2NTMToadlet.noSuchFileOrCannotRead=Unable to send the file: Either it does not exist or it can't be read.
N2NTMToadlet.peerName=Peer Name
N2NTMToadlet.peerNotFoundTitle=Peer not found
N2NTMToadlet.peerNotFoundWithHash=The peer with the hash code "${hash}" could not be found.
N2NTMToadlet.processingSend=Send Node to Node Text Message Processing
N2NTMToadlet.queued=Queued: Peer not connected, so message queued for when it connects
N2NTMToadlet.queuedTitle=Queued
N2NTMToadlet.returnToFriends=Return to Friends list
N2NTMToadlet.sendMessage=Send Node to Node Text Message
N2NTMToadlet.sendMessageShort=Send message
N2NTMToadlet.sendStatus=N2NTM Send Status
N2NTMToadlet.sent=Message sent to peer
N2NTMToadlet.sentTitle=Sent
N2NTMToadlet.tooLong=N2NTMs are limited to 1024 characters
N2NTMToadlet.tooLongTitle=Too Long
N2NTMToadlet.tooLarge=The file you have uploaded through your browser is ${attempt}, but the limit is ${limit}. Please upload from disk.
N2NTMToadlet.sizeWarning=Please note that browser-based uploading has a limit of ${limit}.
N2NTMToadlet.uploadFailed=Failed to upload file.
N2NTMUserAlert.delete=Delete
N2NTMUserAlert.header=From: ${from} (${composed})
N2NTMUserAlert.headerShort=Message from ${from}
N2NTMUserAlert.reply=Reply
N2NTMUserAlert.title=Node to Node Text Message ${number} from ${peername} (${peer})
Node.acceptSeedConnectionsShort=Be a seednode?
Node.acceptSeedConnections=If true, the node will accept connections from new insecure-mode nodes and help to bootstrap them onto the network. This allows any node with your noderef to connect, but only for purposes of announcement: it can only do requests to nodes that it gets through the announcement (possibly including this node if we don't have many Strangers).
Node.alwaysAllowLocalAddresses=Always allow connecting to nodes via local addresses?
Node.alwaysAllowLocalAddressesLong=If true, Freenet will attempt to connect to other nodes via their local (localhost, LAN) addresses as well as their public IPs. If this is not set, you can still enable it for specific darknet peers (but not opennet peers). Set this if you want to connect to other nodes on the same LAN or computer, and don't mind that bogus references can cause your node to send UDP packets to machines on your LAN.
Node.assumeNATed=Assume the port is not forwarded.
Node.assumeNATedLong=Should Freenet assume the port is NATed and not forwarded, and always send handshakes aggressively (every 10-30 seconds), regardless of any evidence to the contrary?
Node.bandwidthLimitMustBePositiveOrMinusOne=Download bandwidth limit must be positive or -1.
Node.bandwidthMinimum=The requested bandwidth limit of ${limit} bytes/second is too low. Bandwidth limits must be at least ${minimum} bytes/second because lower limits than this cannot properly connect to the network.
Node.bindTo=IP address to bind to
Node.bindToLong=IP address to bind to
Node.bwlimitMustBePositive=Upload bandwidth limit must be positive.
Node.cachingFreenetStoreMaxSize=Maximum size of the in-memory write cache for each store (there are 9 such stores).
Node.cachingFreenetStoreMaxSizeLong=Maximum size of the in-memory write cache for each store (there are 9 such stores). 0 for no in-memory cache (e.g. if you have a solid-state disk). Keys are of various sizes, so e.g. if the limit is between 2K and 32K it will only be used for storing small keys (SSKs and public keys).
Node.cachingFreenetStorePeriod=Maximum time blocks will be kept in the in-memory datastore cache before being written to the store on disk (in milliseconds).
Node.clientCacheType=Client cache type?
Node.clientCacheTypeLong=If you set this to none there will be less evidence if your computer is seized, but your node will need to re-fetch every page you visit every time you visit it, reducing performance and making your requests more visible on the network; if you set it to ram, cached pages will only be remembered until shutting down this Freenet node and will take up RAM; the first-time wizard sets it to salt-hash, which stores visited freesites on disk, but encrypted and possibly passworded according to the physical security level (so securely deleting master.keys will wipe the client cache).
Node.clientCacheSize=Client cache size (bytes, MB, GB, TB, etc)
Node.clientCacheSizeLong=Set the size of the client cache. This is used to cache freesites you visit so that they won't need to be requested next time, and therefore will load faster and won't be visible on the network. If the client cache type is "none", this option is ignored; if it is "ram", this option is the size in RAM of the client cache (part of the overall maximum memory limit, so increase that if you need to); if it is "salt-hash", this option is the size of the client-cache on disk.
Node.connectToSeednodesCannotBeChangedMustDisableOpennetOrReboot=Connect to seednodes setting: Cannot disable while opennet is running, either disable and then re-enable opennet or restart Freenet.
Node.databaseMemory=Datastore maximum memory usage (OBSOLETE: bdbje-index only!)
Node.databaseMemoryLong=Only valid with bdbje-index datastore type. Maximum memory usage of the database backing the datastore indexes, 0 means no limit (limited to ~ 30% of maximum memory)
Node.deadlockTitle=Deadlocking likely due to buggy JVM/kernel combination
Node.defragDatabaseOnStartup=Defragment the downloads database during the next startup?
Node.defragDatabaseOnStartupLong=If true, the database will be defragmented during the next startup (or after the password is entered).
Node.defragOnce=Defrag once only (set above option as well!)
Node.defragOnceLong=If this and the above option is true, we will defragment on the next startup and then turn off the defragment option.
Node.disablePHTLS=Disable probabilistic HTL
Node.disablePHTLSLong=Disable probabilistic HTL (don't touch this unless you know what you are doing)
Node.dropPacketEvery=Testing packet drop frequency
Node.dropPacketEveryLong=Frequency of dropping packets. Testing option used by devs to simulate packet loss. 0 means never artificially drop a packet. Don't touch this!
Node.enableARKs=Enable ARKs? (DON'T TURN THIS OFF!)
Node.enableARKsLong=Enable ARKs? (DON'T TURN THIS OFF!).
Node.enableOpennetFailedTitle=Enabling opennet failed
Node.enableOpennetFailed=Freenet failed to enable opennet, and cannot connect to strangers. You will need to fix this, report a bug, or stick with connecting only to Friends. Details: ${message}
Node.enableNewLoadManagementRT=Enable new load management (for realtime requests)? (EXPERIMENTAL!)
Node.enableNewLoadManagementRTLong=Turn this on to test the new load management code for realtime requests. This is highly experimental and may severely break your node or dramatically reduce or increase its performance! Good luck, and tell us what happens!
Node.enableNewLoadManagementBulk=Enable new load management (for bulk requests)? (EXPERIMENTAL!)
Node.enableNewLoadManagementBulkLong=Turn this on to test the new load management code for bulk requests. This is highly experimental and may severely break your node or dramatically reduce or increase its performance! Good luck, and tell us what happens!
Node.enablePacketCoalescing=Enable packet coalescing?
Node.enablePacketCoalescingLong=Enable packet coalescing? Packet coalescing increases bandwidth efficiency, reduces CPU usage and gains some resistance to traffic analysis at a small cost in message latency. Don't turn this off unless you know what you're doing.
Node.enablePerNodeFailureTables=Enable per-node failure tables?
Node.enablePerNodeFailureTablesLong=Enable automatically rerouting around nodes that failed a request within the last 10 minutes?
Node.enableRoutedPing=Enable FNPRoutedPing?
Node.enableRoutedPingLong=Enable FNPRoutedPing? Only useful in simulations, not on the real network. Turn it off.
Node.enableSwapping=Enable location swapping?
Node.enableSwappingLong=Enable location swapping?
Node.enableSwapQueueing=Enable queueing of swap requests?
Node.enableSwapQueueingLong=Enable queueing of swap requests?
Node.enableULPRDataPropagation=Enable ULPR data propagation?
Node.enableULPRDataPropagationLong=Enable fast propagation of recently requested keys to those nodes which have asked for them when the data is eventually found? (Ultra-Lightweight Persistent Requests; this is particularly important for chat clients). This also enables RecentlyFailed, which will squash requests which have recently failed.
Node.errorApplyingConfig=Error while applying the new config : ${error}
Node.forceBigShrink=Do large store shrinks immediately (bdbje-index store type only)
Node.forceBigShrinkLong=Whether to do large store shrinks (over 10%) immediately (rather than waiting for the next node restart). Online shrinks do not preserve the most recently used data, so this is not recommended; use it only if you must have an immediate result. Specific to bdbje-index store type.
Node.inBWLimit=Download bandwidth limit
Node.inBWLimitLong=Download bandwidth limit. Freenet will try not to exceed this, but it is not very accurate. If set to -1 the download bandwidth limit will be 4x the upload bandwidth limit. Without units this is in bytes/second, and SI and IEC units are accepted, so things like 10 KiB/s or 1.5 Mbps (meaning 10 kibibytes/sec and 1.5 megabits/sec respectively) are okay.
Node.invalidStoreSize=Store size must be at least 32MB
Node.invalidMemoryCacheSize=Memory cache size must be at least 0. We won't actually cache any keys unless it is at least ~ 1200 bytes, and we won't cache CHKs unless it is ~ 33KB.
Node.l10nLanguage=The language Freenet will use to display messages
Node.l10nLanguageLong=This setting will change the language used to display messages.
Node.masterKeyFile=Location of the master keys file
Node.masterKeyFileLong=Filename for the master keys file. This contains the encryption keys for the cache of recently visited sites (client-cache), the download queue etc. These may be passworded through the security levels page, but securely deleting the keys file will make elements encrypted with it useless even with the password. (If this is a relative path, it will be taken relative to the user data directory.)
Node.maxHTL=Maximum HTL
Node.maxHTLLong=Maximum HTL
Node.maxOpennetPeers=Maximum number of Opennet peers
Node.maxOpennetPeersLong=Maximum number of Opennet peers (must be between 0 and ${default} inclusive, the actual limit will depend on the number of Friends and your bandwidth limit, and will be shown on the statistics page).
Node.maxOpennetPeersMustBeTwentyOrLess=Must be ${maxpeers} or less
Node.mustBePositive=Config value must be positive
Node.nodeDir=Node-reference directory
Node.nodeDirLong=Path of directory for node-related information (e.g. node identity, peers).
Node.cfgDir=Config directory
Node.cfgDirLong=Path of directory for user-editable config (e.g. language overrides).
Node.userDir=User data directory
Node.userDirLong=Path of directory for user data (e.g. bookmarks, download lists).
Node.runDir=Run-time state directory
Node.runDirLong=Path of directory for run-time state. This can be cleared out when Freenet is not running.
Node.pluginDir=Plugin directory
Node.pluginDirLong=Path of directory for plugins.
Node.probeBandwidthShort=Respond to probe requests for bandwidth limit
Node.probeBandwidthLong=If true Freenet will respond to requests for the outgoing bandwidth limit. This is to improve knowledge of network conditions and allow simulations to better reflect the actual network. It will add a small amount of random noise to make the information less identifiable but still useful for diagnostics. If false it will respond with a refusal.
Node.probeBuildShort=Respond to probe requests for build
Node.probeBuildLong=If true Freenet will respond to probe requests for the build. This is to measure update propagation. If false it will respond with a refusal.
Node.probeIdentifierShort=Randomly assigned identifier for probe requests
Node.probeIdentifierLong=This identifier is only used in probe requests for an identifier. If set to -1 it will select a new random value.
Node.probeRespondIdentifierShort=Respond to probe requests for an identifier
Node.probeRespondIdentifierLong=If true Freenet will respond to probe requests for an identifier and very low-precision uptime information. It will add a small amount of random noise to the uptime information to make it less identifiable but still useful for diagnostics. This is useful for estimations of network size and churn. If false it will respond with a refusal.
Node.probeLinkLengthsShort=Respond to probe requests for link lengths
Node.probeLinkLengthsLong=If true Freenet will respond to probe requests for link lengths. This is to improve knowledge of network conditions, and allow simulations to better reflect the actual network. It will add a small amount of random noise to make the information less identifiable but still useful for diagnostics. If false it will respond with a refusal.
Node.probeLocationShort=Respond to probe requests for location
Node.probeLocationLong=If true Freenet will respond to probe requests for low-precision location. This is to allow measurement of the network location distribution, and contains no information other than location. If false it will respond with a refusal.
Node.respondOverallBulkOutputCapacityUsage=Respond to probe requests for overall capacity usage and very approximate bandwidth limit
Node.respondOverallBulkOutputCapacityUsageLong=If true Freenet will respond to probe requests for the overall capacity usage (bandwidth liability, this is a guesstimate of how much bandwidth would be used if all running requests succeeded), and a rough idea of the bandwidth limit (as an integer, divided by 10KB/s, min 1 max 10).
Node.probeStoreSizeShort=Respond to probe requests for store size
Node.probeStoreSizeLong=If true freenet will respond to probe requests for store size. This is to improve knowledge of network conditions, and allow simulations to better reflect the actual network. It will add a small amount of random noise to make the information less identifiable but still useful for diagnostics. If false it will respond with a refusal.
Node.probeUptimeShort=Respond to probe requests for uptime
Node.probeUptimeLong=If true freenet will respond to probe requests for 48-hour or 7-day uptime percentage. This is to improve knowledge of network conditions, and allow simulations to better reflect the actual network. It will add a small amount of random noise to make the information less identifiable but still useful for diagnostics. If false it will respond with a refusal.
Node.probeRejectStatsShort=Respond to probe requests for proportion of requests of various kinds rejected.
Node.probeRejectStatsLong=If true, Freenet will respond to probe requests for the proportion of various kinds of requests which are being rejected.
Node.trafficClass=The TrafficClass value to pass to Socket.setTrafficClass() for both darknet and opennet.
Node.trafficClassLong=The TrafficClass value to pass to Socket.setTrafficClass() for both darknet and opennet. The value set won't be taken into account until the node restarts.
Node.nodeName=Nickname for this Freenet node
Node.nodeNameLong=Node nickname. This will be visible to your friends only.
Node.maxPacketSize=Maximum packet size (aka MTU)
Node.maxPacketSizeLong=Maximum size of the UDP packets Freenet sends, assuming UDP/IP headers are 28 bytes. We will use the MTU of the interface if we can detect it, but mostly obstructions happen elsewhere, and unfortunately we cannot easily detect the path MTU.
Node.notUsingWrapperTitle=Not using the wrapper!
Node.notUsingWrapper=You are running Freenet without the wrapper. This is not recommended. Freenet will not be able to restart itself, so auto-updating won't work, and if Java crashes, it won't get restarted either. Also Freenet can't generate stack dumps in some places so debugging will be marginally harder.
Node.notUsingWrapperShort=Freenet is running without the wrapper. This is not recommended.
Node.oneConnectionPerIP=Limit to one connection per address? (friends) (NOT RECOMMENDED)
Node.oneConnectionPerIPLong=Automatically drop friend connections when other friends have the same (external) IP address.
Node.opennetEnabled=Enable insecure mode (automatically connect to untrusted nodes)?
Node.opennetEnabledLong=Enable insecure mode (aka opennet)? If this is enabled, your Freenet node will automatically exchange node references with other untrusted nodes (Strangers as opposed to Friends). But this means that the fact that you are running a node is no longer private, and many attacks are much easier. If you know enough people running Freenet, you should stick to trusted (Friends) connections to them, and turn this off.
Node.outBWLimit=Upload bandwidth limit
Node.outBWLimitLong=Hard upload bandwidth limit. Freenet should almost never exceed this. Normally you should set this to no more than half your internet connection's upload bandwidth, which is usually much less than your download bandwidth. Without units this is in bytes/second, and SI and IEC units are accepted, so things like 10 KiB/s or 1.5 Mbps (meaning 10 kibibytes/sec and 1.5 megabits/sec respectively) are okay.
Node.paddDataPackets=Pad data packets sent by this Freenet node with random data of random length? (READ WARNING BEFORE TURNING OFF!)
Node.paddDataPacketsLong=Pad data packets sent by this Freenet node with random-length content? For security, on a single node, turning this off is bad; if a large part of the network starts doing it, we become very vulnerable to a passive attacker. However, it should improve performance, particularly the payload percentage. You have been warned!
Node.passOpennetPeersThroughDarknet=Relay opennet noderefs through darknet peers?
Node.passOpennetPeersThroughDarknetLong=If true, opennet noderefs (NEVER our own darknet noderef) will be relayed through our darknet peers. So a node (this node, or its peers) can get opennet peers from its darknet peers. This is useful because it allows us to bootstrap new opennet peers after having lost our peers due to downtime, for example. However, it may make traffic analysis slightly easier, so turn it off if you are paranoid.
Node.port=Darknet port number (UDP)
Node.portLong=UDP port used by Freenet to communicate with your Friends' nodes. This port should be forwarded in your router if possible. We use a separate port for connections to Strangers.
Node.opennetPort=Opennet port number (UDP)
Node.opennetPortLong=UDP port used by Freenet to communicate with Strangers i.e. freenet nodes running in opennet mode. This port should be forwarded in your router if possible. We use a separate port for connections to your Friends' nodes.
Node.publishOurPeersLocation=Shall we send our peers' locations to our peers?
Node.publishOurPeersLocationLong=Shall we send our peers' locations to our peers? Doing so helps routing but gives some information away to a potential attacker.
Node.pleaseSetPeersVisibilityAlertTitle=Please set the visibility mode for your friends
Node.pleaseSetPeersVisibilityAlert=Freenet can now connect to your friends' friends in order to improve performance and make your connection more reliable, but it needs to know which of your peers it is safe to do this with. Please go to the Connections to Friends page and set the visibility mode for your friends. You should generally set them to YES so that Freenet can connect to their friends and they can connect to your friends, but if you don't want your friends to know about a friend set it to NO.
Node.showFriendsVisibilityAlert=Show an alert when friends' visibility settings are missing?
Node.routeAccordingToOurPeersLocation=Shall we take the locations of the peers of our peers into account for routing purposes?
Node.routeAccordingToOurPeersLocationLong=Doing so helps routing but might help a potential attacker.
Node.skipWrapperWarning=Skip "not using the wrapper" warning?
Node.skipWrapperWarningLong=If true, the "not using the wrapper" warning will not be shown. Note that this will only hide the warning from the next restart on.
Node.slashdotCacheLifetime=How long to keep data in the recent requests cache?
Node.slashdotCacheLifetimeLong=How long to keep data in the recent requests cache (milliseconds, use k for seconds)? Note that this goes away on restart anyway.
Node.slashdotCacheSize=Maximum size of the recent requests cache (in bytes, KB MB GB TB etc)
Node.slashdotCacheSizeLong=Maximum size of the recent requests cache (note that there is also a time limit).
Node.storeDirectory=Store directory
Node.storeDirectoryLong=Path of directory for the datastore files, which holds data (keys, blocks, etc) served to other freenet users.
Node.storeMaxMemTooHigh=Giving more than 80% of your ram to BDB is probably not what you want to do!
Node.storePreallocate=Preallocate space for datastore
Node.storePreallocateLong=Preallocate space for datastore
Node.storeSaltHashResizeOnStart=Resize store on node start (salt-hash only)
Node.storeSaltHashResizeOnStartLong=Resize store on node start (salt-hash only). If this is true, Freenet will complete resizing the datastore during startup. This will complete much faster than doing it "on the fly", but on the other hand your Freenet node will not be available for some time while it completes the resize.
Node.storeSize=Freenet datastore size (bytes, MB, GB, TB, etc)
Node.storeSizeLong=Size of the Freenet datastore, which includes the store and cache, and stores data passing through your node. Freenet uses disk space for many other things, such as temporary files and your downloads, which are separate.
Node.storeType=Datastore type
Node.storeTypeLong=Datastore type. Currently this can be salt-hash (this is the default, stores data on disk with a lossy hashtable and a Bloom filter), or ram (FOR TESTING ONLY, keep the index and the data in memory, not on disk). Only use ram if you know what you are doing and have enough RAM to store all your data (and note it will not be saved on shutdown)! Changes will not take effect until Freenet has been restarted.
Node.storeBloomFilterSize=Bloom filter size (total) in bytes
Node.storeBloomFilterSizeLong=Bloom filter size (total) in bytes. Usually 1/2048th the size of data store is more than enough. Set this to zero to disable bloom filter. Set this to -1 to reset to default.
Node.storeBloomFilterCounting=Use counting bloom filter?
Node.storeBloomFilterCountingLong=Use 2-bit counting bloom filter? (don't touch this unless you know what you are doing)
Node.storeUseSlotFilters=Use slot filters? (Strongly recommended)
Node.storeUseSlotFiltersLong=This greatly reduces disk I/O for the salted-hash store, at a memory and disk cost of around 4 bytes for every key i.e. 1/3000th of the store size. This is strongly recommended, unless your RAM is small and you have a fast SSD.
Node.storeSaltHashSlotFilterPersistenceTime=Persistence interval for slot filters
Node.storeSaltHashSlotFilterPersistenceTimeLong=How often should the slot filters be written for the store? -1 = write immediately. 0 = write at shutdown. >0 = write every n milliseconds. So e.g. 60000 = every minute. Note that if Freenet is shut down uncleanly, and this is not set to write immediately, the slot filter will be rebuilt on the next start-up, which will cause a significant amount of disk access.
Node.slotFilterPersistenceTimeError=Slot filter persistence time must be -1, 0, or positive.
Node.swapRInterval=Swap request send interval (ms)
Node.swapRIntervalLong=Interval in milliseconds between sending swap requests.
Node.throttleLocalTraffic=Throttle local traffic?
Node.throttleLocalTrafficLong=Throttle local traffic? If enabled, even LAN and localhost traffic will be subject to bandwidth limiting.
Node.useSlashdotCache=Cache all requests for 30 minutes?
Node.useSlashdotCacheLong=Replies to requests with high HTL are not eligible to be stored in the datastore. If this option is true, they will be stored in the recent requests cache, a special short-term cache. If this option is false then only ULPR responses (i.e. delayed answers to requests) will be stored in this cache. This is enabled by default unless network security level is MAXIMUM, as it is important for performance when a key becomes popular suddenly. However, it does have some security impact, in that if an attacker can get close to the target within 30 minutes (unlikely in most cases), this mechanism may help him to confirm his guesses.
Node.usingGCJTitle=Running Freenet under GCJ is not recommended
Node.usingGCJ=You are running Freenet under GCJ (a free Java compiler). This is buggy and likely to cause problems. We recommend switching to OpenJDK (which is also free, and less likely to have odd bugs).
Node.usingOracleTitle=You are running Freenet under the official Oracle Java Virtual Machine. Please switch to OpenJDK if possible.
Node.usingOracle=You are running Freenet under the official Oracle Java Virtual Machine. The official JVM has deliberately crippled encryption code because of export restrictions, so we have to use the built-in Freenet encryption code, which may be slower. You should switch to OpenJDK if possible (e.g. install it through your package manager).
Node.withAnnouncement=Allow Freenet to bootstrap itself using seednodes?
Node.withAnnouncementLong=Allow your Freenet node to bootstrap itself using seednodes? To get onto the opennet (the Strangers network, automatic Freenet connection on low/normal network security level), we contact public nodes chosen from a small list shipped with Freenet. Obviously this is somewhat insecure, but if you are using opennet, you probably need it: if your node is down for a while, especially if it is NATed and/or changes its IP address, it will probably need to reseed. If you want better security, you need to connect to your friends and enable high network security.
Node.writeLocalToDatastore=Write local and nearby requests to the datastore?
Node.writeLocalToDatastoreLong=Whether to write data returned by high HTL (local and nearby) requests to the main persistent datastore. We strongly recommend you keep this option disabled unless you don't care about either datastore seizure or store probing attacks. This will be enabled by default only if the network security level and physical security level are both LOW.
NodeClientCore.alwaysCommit=Commit after every database job?
NodeClientCore.alwaysCommitLong=If this option is false, we commit the database to disk every 30 seconds. If it is true we commit it after every database job. This will reduce performance but will ensure that no progress is lost on an unclean shutdown, and slightly reduce memory usage. Normally this should be false, to reduce disk access.
NodeClientCore.maxArchiveSize=Maximum size of any given archive
NodeClientCore.maxArchiveSizeLong=Maximum size of any given archive
NodeClientCore.couldNotFindOrCreateDir=Could not find or create directory
NodeClientCore.downloadAllowedDirs=Directories downloading is allowed to
NodeClientCore.downloadAllowedDirsLong=Semicolon separated list of directories to which downloading is allowed. "downloads" means downloadsDir, empty means no downloading to disk allowed, "all" means downloading to anywhere is allowed. WARNING! If this is set to "all" any user with access to FCP can download any file to anywhere on your computer!
NodeClientCore.downloadsDir=Default download directory
NodeClientCore.downloadsDirLong=The directory to save downloaded files into by default
NodeClientCore.encryptPersistentTempBuckets=Encrypt the persistent temporary buckets?
NodeClientCore.encryptPersistentTempBucketsLong=Encrypt the persistent temporary buckets? In some cases (if you use hard-drive and swap encryption) it might not make sense to encrypt persistent temporary buckets.
NodeClientCore.encryptTempBuckets=Encrypt the temporary buckets?
NodeClientCore.encryptTempBucketsLong=Encrypt the temporary buckets? In some cases (if you use hard-drive and swap encryption) it might not make sense to encrypt temporary buckets.
NodeClientCore.fileForClientStats=File to store client statistics in
NodeClientCore.fileForClientStatsLong=File to store client throttling statistics in (used to decide how often to send requests)
NodeClientCore.lazyStartDatastoreChecker=Start the datastore checker thread on demand?
NodeClientCore.lazyStartDatastoreCheckerLong=Start the datastore checker thread on demand? Useful mainly for simulations, or if threads are extremely costly. Most nodes should have this turned off.
NodeClientCore.lazyStartDatastoreCheckerMustRestartNode=You must restart Freenet to change the "start the datastore checker on demand" setting.
NodeClientCore.maxUSKFetchers=Maximum number of temporary  USK fetchers
NodeClientCore.maxUSKFetchersLong=Maximum number of temporary background fetches for recently visited USKs (e.g. freesites). Note that clients and plugins (e.g. WebOfTrust) can subscribe to USKs, which does not count towards the limit.
NodeClientCore.maxUSKFetchersMustBeGreaterThanZero=Must be greater than zero
NodeClientCore.memoryLimitedJobThreadLimit=Max FEC threads
NodeClientCore.memoryLimitedJobThreadLimitLong=Maximum number of threads used for memory-intensive operations such as FEC decoding/encoding (i.e. decoding a big file from blocks downloaded from the network using Forward Error Correction).
NodeClientCore.memoryLimitedJobThreadLimitMustBe1Plus=You must allow FEC decodes at least 1 thread
NodeClientCore.memoryLimitedJobMemoryLimit=Max memory used for FEC threads
NodeClientCore.memoryLimitedJobMemoryLimitLong=Maximum amount of memory used for memory-intensive operations such as FEC decoding/encoding (i.e. decoding a big file from blocks downloaded from the network using Forward Error Correction).
NodeClientCore.memoryLimitedJobMemoryLimitMustBeAtLeast=FEC decodes need at least ${min} memory (as a single large segment will need this much memory to decode/encode)
NodeClientCore.minDiskFreeLongTerm=Minimum free disk space 
NodeClientCore.minDiskFreeLongTermLong=Minimum amount of free disk space over the long term. RAM buckets for downloads in progress are counted toward this limit.
NodeClientCore.minDiskFreeShortTerm=Minimum free disk space during decode 
NodeClientCore.minDiskFreeShortTermLong=Minimum free disk space over a brief period, when doing disk-intensive but short-lived operations such as finishing a download. We recommend that this is smaller than the long-term limit.
NodeClientCore.movingTempDirOnTheFlyNotSupported=Moving temp directory on the fly not supported at present
NodeClientCore.persistentTempDir=Persistent temp files directory
NodeClientCore.persistentTempDirLong=Path of directory to put persistent temp files in. Persistent means that this should be kept even when Freenet is not running.
NodeClientCore.pluginStoresDir=Plugin data folder
NodeClientCore.pluginStoresDirLong=Path to directory to store plugins' data in. Note that not all plugins use this mechanism, some create their own files.
NodeClientCore.maxRAMBucketSize=Maximum size of a RAMBucket (bytes, KB MB etc allowed)
NodeClientCore.maxRAMBucketSizeLong=Maximum size of a RAMBucket (bigger buckets will be kept as files on the disk)
NodeClientCore.ramBucketPoolSize=Amount of RAM to dedicate to temporary buckets (bytes, KB MB etc allowed)
NodeClientCore.ramBucketPoolSizeLong=Amount of RAM to dedicate to temporary buckets. The tradeoff is more memory usage against more IOs.
NodeClientCore.startingUpTitle=Freenet is starting up
NodeClientCore.startingUp=Please allow Freenet a few moments to complete the startup process, in the meantime some things may not work and Freenet may be slower than usual.
NodeClientCore.startingUpShort=Freenet is starting up, some things may not work and it may be slow.
NodeClientCore.tempDir=Temp files directory. This can be cleared out when Freenet is not running.
NodeClientCore.tempDirLong=Name of directory to put temporary files in
NodeClientCore.uploadAllowedDirs=Directories uploading is allowed from
NodeClientCore.uploadAllowedDirsLong=Semicolon separated list of directories from which uploading is allowed. Empty means no uploading from disk allowed, "all" means uploading from anywhere (including system files etc!) is allowed. WARNING! If this is set to "all" any file on your computer can be uploaded by any user with access to FCP.
NodeClientCore.useAIMDsRT=Use AIMDs for real-time requests? (EXPERTS ONLY)
NodeClientCore.useAIMDsRTLong=Enable originator-level throttling of request starters based on TCP-style Additive Increase Multiplicative Decrease rate estimation (for realtime requests). This enables or disables a key part of the old load management system. EXPERTS ONLY!!!
NodeClientCore.useAIMDsBulk=Use AIMDs for bulk requests? (EXPERTS ONLY)
NodeClientCore.useAIMDsBulkLong=Enable originator-level throttling of request starters based on TCP-style Additive Increase Multiplicative Decrease rate estimation (for bulk requests). This enables or disables a key part of the old load management system. EXPERTS ONLY!!!
NodeIPDectector.inclLocalAddress=Include local addresses in noderef
NodeIPDectector.inclLocalAddressLong=Whether to include local addresses (LAN and localhost) in node references. This will not be useful unless the both sides set allowLocalAddresses=true for the respective references (use the Friends page in advanced mode to set this flag).
NodeIPDectector.ipOverride=IP address override
NodeIPDectector.ipOverrideLong=IP address override (not usually needed) - set this if you have a *static* IP address or a domain name (e.g. via dyndns), and you are behind a firewall. Note that Freenet will still include other detected IP addresses unless you use the "bind to" option.
NodeIPDectector.tempAddressHint=Temporary IP address hint
NodeIPDectector.tempAddressHintLong=Temporary hint to what our IP might be; deleted after use
NodeIPDetector.maybeSymmetric=It looks like your node may be behind a symmetric NAT. You may have connection problems: If you are behind a symmetric NAT you will probably only be able to connect to peers which are open to the internet.
NodeIPDetector.maybeSymmetricTitle=Connection problems
NodeIPDetector.maybeSymmetricShort=Connection problems: You may be behind a symmetric NAT.
NodeIPDetector.unknownHostErrorInIPOverride=Unknown host: ${error}
NodeStat.aggressiveGC=AggressiveGC modificator
NodeStat.aggressiveGCLong=Allows the user to tweak the time in between GC and forced finalization. SHOULD NOT BE CHANGED unless you know what you're doing! -1 means: disable forced call to System.gc() and System.runFinalization()
NodeStat.ignoreLocalVsRemoteBandwidthLiability=Treat local requests as remote requests for bandwidth liability limiting?
NodeStat.ignoreLocalVsRemoteBandwidthLiabilityLong=Enable this for significantly lower bandwidth usage and slightly more security against request starting timing attacks (mostly you don't need to worry about them as correlation attacks are probably easier)
NodeStat.freeHeapBytesThreshold=Free heap bytes threshold
NodeStat.freeHeapBytesThresholdLong=Freenet will try to keep its free heap bytes above the threshold by refusing new requests
NodeStat.freeHeapPercentThreshold=Free heap percent threshold
NodeStat.freeHeapPercentThresholdLong=Freenet will try to keep its free heap percentage (of max heap bytes allowed) above the threshold by refusing new requests
NodeStat.maxPingTime=Maximum ping time?
NodeStat.maxPingTimeLong=Freenet will reject all requests if the average ping time to its peers goes above this level. Ping times have proven a reliable indicator of both system and network load, but if your internet connection is unusually slow, you should increase this. Measured in milliseconds.
NodeStat.subMaxPingTime=Start rejecting requests at what ping time?
NodeStat.subMaxPingTimeLong=Freenet will start to reject some requests when the average ping time to its peers goes beyond this time. Increase it if your internet connection is unusually slow. Measured in milliseconds.
NodeStat.memCheck=Enable the Memory check
NodeStat.memCheckLong=Enable the memory check (writes a message in logfile, mandatory for aggressiveGCModificator to have any effect!)
NodeStat.statsPersister=File to store node statistics in
NodeStat.statsPersisterLong=File to store node statistics in (not client statistics, and these are used to decide whether to accept requests so please don't delete)
NodeStat.threadLimit=Thread limit
NodeStat.threadLimitLong=Freenet will try to limit its thread usage to the specified value by refusing new requests when it is using too many threads.
NodeStats.allRequests=All requests
NodeStats.averageHeader=Average
NodeStats.bulkSends=Bulk sends
NodeStats.blockTransfersRT=Block transfers (RT)
NodeStats.blockTransfersBulk=Block transfers (Bulk)
NodeStats.blockTransfersLocal=Block transfers (Local)
NodeStats.bulkHeader=Bulk
NodeStats.count=Count
NodeStats.delayTimes=Delay times
NodeStats.group=Group
NodeStats.localHeader=Local
NodeStats.localCHKs=Local CHKs
NodeStats.localSSKs=Local SSKs
NodeStats.mustBePercentValueNotFull=This value must be a percentage between 0 and 99.
NodeStats.pSuccess=P(Success)
NodeStats.realTimeHeader=Real-time
NodeStats.remoteHeader=Remote
NodeStats.remoteCHKs=Remote CHKs
NodeStats.remoteSSKs=Remote SSKs
NodeStats.slotsWaiting=Requests waiting for slots: ${local} local, ${remote} remote.
NodeStats.successfulHeader=Successful
NodeStats.timeoutFractions=Timeouts in queueing
NodeStats.transfersTimedOut=Transfers timed out
NodeStats.unsuccessfulHeader=Unsuccessful
NodeStats.valueTooLow=This value is too low for that setting, increase it!
MainJarUpdater.fetchingDependencies=Fetching jars required by the new build
MainJarUpdater.fetchingFromUOM=Fetching directly from a more up to date node ("Update Over Mandatory")
NodeUpdateManager.enabled=Check for, and download new versions
NodeUpdateManager.enabledLong=Should your node automatically check for new versions of Freenet. If yes, new versions will be automatically detected and downloaded, but not necessarily installed. This setting resets itself always back to false unless your Freenet node runs within the wrapper.
NodeUpdateManager.installNewVersions=Automatically install new versions
NodeUpdateManager.installNewVersionsLong=Should your node automatically update to the newest version of Freenet, without asking?
NodeUpdateManager.invalidRevocationURI=Invalid revocation URI: ${error}
NodeUpdateManager.invalidUpdateURI=Invalid update URI: ${error}
NodeUpdateManager.noUpdateWithoutWrapper=Cannot update because not running under the Java Service Wrapper
NodeUpdateManager.revocationURI=Where should Freenet look for the revocation key?
NodeUpdateManager.revocationURILong=URI for the revocation key. If this is found it means the auto-update system has been compromised, and Freenet will display its contents and disable the auto-updater.
NodeUpdateManager.updateCatastropheTitle=Catastrophic Update Failure!
NodeUpdateManager.updateFailed=Update Failed: ${reason}
NodeUpdateManager.updateFailedTitle=Update Failed!
NodeUpdateManager.updateFailedShort=Update Failed: ${reason}
NodeUpdateManager.updateSeednodes=Update the seednodes automatically?
NodeUpdateManager.updateSeednodesLong=Update the seednodes.fref file automatically over Freenet?
NodeUpdateManager.updateInstallers=Download the latest installers over Freenet?
NodeUpdateManager.updateInstallersLong=Download the latest installers over Freenet? These will be linked from the "Add a Friend" page.
NodeUpdateManager.updateURI=Where should Freenet look for updates?
NodeUpdateManager.updateURILong=Where should your Freenet node look for updates? This should be a Freenet URI where updates can be downloaded from. The default URI ends in /jar/(version number). To download the source code for an update, you can copy the key below, and change "jar" to "update-source". Similarly, "changelog" gives you the user-facing list of changes, "fullchangelog" gives you the long, developer-friendly list of changes, and "installer", "wininstaller", "seednodes" and "iptocountryv4" give other files.
NodeUpdateManager.updateURIMustBeAUSK=Update URI must be a USK!
NodeUpdateManager.updateURIMustHaveNoMetaStrings=Update URI must not have extra path components, e.g. USK@blah,blah,blah/update/1430 not USK@blah,blah,blah/update/1430/
NodeUpdateManager.updateFailedInternalError=FAILED TO UPDATE FREENET. INTERNAL ERROR: ${reason}
NotEnoughNiceLevelsUserAlert.title=Not enough Nice levels available!
NotEnoughNiceLevelsUserAlert.short=Not enough Nice levels available! Please run Freenet at a lower nice level.
NotEnoughNiceLevelsUserAlert.content=Your node has detected that it is running at a high nice level. It can't perform well if they aren't enough levels available. Please lower the nice level you're node is running at (Look for PRIORITY in the run.sh file and lower its value)! Currently your node has ${available} levels to play with whereas it would need ${required}.
OpennetManager.oneConnectionPerIP=Limit to one connection per address? (strangers)
OpennetManager.oneConnectionPerIPLong=Don't allow more than one stranger connection per address? This will make it slightly harder for an attacker to connect more than once to your node as different identities, in order to dominate your routing or make harvesting easier. Also prevents having the same node connected on as a friend and stranger simultaneously.
OpennetConnectionsToadlet.successTimeTitle=Last success
OpennetConnectionsToadlet.successTime=Last time there was a successful CHK fetch from the node
OpennetConnectionsToadlet.fullTitle=${counts} Strangers (Untrusted Peers)
OpennetConnectionsToadlet.peersListTitle=My Opennet Peers (untrusted peers added by Freenet in low/normal network security level)
PNGFilter.invalidHeader=The file you tried to fetch is not a PNG. It does not include a valid PNG header. It might be some other file format, and your browser may do something dangerous with it, therefore we have blocked it.
PNGFilter.invalidHeaderTitle=Not a PNG - invalid header
PeerManagerUserAlert.connErrorTitle=Some peers cannot connect
PeerManagerUserAlert.connError=${count} of your peers cannot connect for an unknown reason, possibly because of a buggy node or a corrupt node reference.
PeerManagerUserAlert.clockProblemTitle=Clock problem
PeerManagerUserAlert.clockProblem=${count} of your nodes are unable to connect because their system clock is more than 24 hours different to yours. Please check whether your computer has the correct time. Incorrect time will cause many node and client mechanisms to fail.
PeerManagerUserAlert.noConns=This node has not been able to connect to any other nodes so far; it will not be able to function normally. Hopefully some of your peers will connect soon; if not, try to get some more peers. You need at least 3 peers at any time, and should aim for 5-10.
PeerManagerUserAlert.noConnsTitle=No open connections
PeerManagerUserAlert.noPeersDarknet=Your Freenet node has no friends to connect to, therefore it will not be able to work normally. You need at least 3 connected friends at all times, and ideally 5-10. These should be people you know who also run Freenet. Alternatively you could set the network security level to NORMAL or LOW to enable connecting to strangers and quickly get some connections.
PeerManagerUserAlert.noPeersTitle=No friends found
PeerManagerUserAlert.oneConn=This node only has one connection. Performance will be impaired, and you have no anonymity nor even plausible deniability if that one person is malicious. Your node is attached to the network like a "leaf" and does not contribute to the network's health. Try to get at least 3 (ideally more like 5-10) connected peers at any given time.
PeerManagerUserAlert.onlyFewConnsTitle=Only ${count} open connection(s)
PeerManagerUserAlert.outdatedUpdateTitle=Freenet needs updating! Please turn on the updater on the "auto-update" configuration page.
PeerManagerUserAlert.outdatedUpdate=Freenet appears to be out of date, and may not work correctly until it is updated. Freenet can update itself automatically by downloading the update from other Freenet nodes but this is currently turned off. You should turn on the updater on the "Auto-update" configuration page. It may take an hour or two for the update to work after that. As a last resort you can use the update.sh or update.cmd script, but this is not recommended, and is less secure.
PeerManagerUserAlert.tooHighBwlimitDelayTime=This node has to wait too long for available bandwidth (${delay}ms > ${max}ms). Increase your output bandwidth limit and/or remove some peers to improve the situation.
PeerManagerUserAlert.tooHighBwlimitDelayTimeTitle=bwlimitDelayTime too high
PeerManagerUserAlert.tooHighPingTime=Freenet is having trouble talking with its peers quickly enough (${ping}ms > ${max}ms). Your upload bandwidth limit may be too low, in which case you should increase it, or too high, in which case you should decrease it. Normally you should not allow Freenet more than half your upload bandwidth. Also, this problem can be caused by high processor usage (by other applications or because Freenet's memory limit in wrapper.conf is too low), excessive swapping or by network problems outside of Freenet's control, or possibly by bugs in Freenet. You should try to resolve this as Freenet will work very badly until it is fixed.
PeerManagerUserAlert.tooHighPingTimeTitle=Internet connection problems: Ping time too high
PeerManagerUserAlert.tooManyConns=There are too many connections (${count} > ${max}). Adding large numbers of nodes automatically does not produce a small-world topology, hurts routing, and risks producing single points of failure.
PeerManagerUserAlert.tooManyConnsTitle=Too many open connections
PeerManagerUserAlert.tooManyDisconnected=This node has too many disconnected peers (${count} > ${max}). This will have a slight impact on your performance as disconnected peers also consume a small amount of bandwidth and CPU. Consider "cleaning up" your peer list. Note that ideally you should connect to nodes run by people you know. Even if not, adding lots of nodes automatically is bad as it does not produce an optimal topology.
PeerManagerUserAlert.tooManyDisconnectedTitle=Too many disconnected peers
PeerManagerUserAlert.tooManyNeverConnected=Many of this node's peers have never connected even once: ${count}. You should not add peers unless you know that they have also added your reference. Otherwise they will not connect.
PeerManagerUserAlert.tooManyNeverConnectedTitle=Many peers have not connected once yet
PeerManagerUserAlert.tooManyNeverConnectedWithLink=Many of this node's peers have never connected even once: ${count}. You should not add peers unless you know that they have also added ${link}your reference${/link}. Otherwise they will not connect.
PeerManagerUserAlert.tooOldNeverConnectedPeers=One or more of your node's peers have never connected in the two weeks since they were added.  Consider removing them since they are marginally affecting performance (wasting packets talking to nodes that aren't there).
PeerManagerUserAlert.tooOldNeverConnectedPeersTitle=Never connected peer(s) too old
PeerManagerUserAlert.twoConns=This node has only two connections. Performance and security will not be very good, and your node is not doing any routing for other nodes. Your node is embedded like a 'chain' in the network and does not contribute (much) to the network's health. Try to get at least 3 (ideally more like 5-10) connected peers at any given time.
PeersSayKeyBlownAlert.intro=One or more of your peers says that the auto-update system has been compromised! This means that an attacker may know the private key for the auto-update system and can therefore cause your node to run code of his choice (if you update)! The auto-update system has been disabled to prevent this. It is also possible that your peers are deliberately lying about it.
PeersSayKeyBlownAlert.fetching=Your node is attempting to download the revocation certificate to find out more details.
PeersSayKeyBlownAlert.failedFetch=Your node has been unable to download the revocation certificate. Possible causes include an attack on your node to try to get you to update despite the key being compromised, or your nodes lying about the key being compromised. Please contact the developers or other Freenet users to sort out this mess.
PeersSayKeyBlownAlert.connectedSayBlownLabel=These connected nodes say that the auto-update key has been compromised (we are trying to download the revocation certificate from them):
PeersSayKeyBlownAlert.disconnectedSayBlownLabel=These nodes told us that the auto-update key has been compromised, but then disconnected, so we could not fetch the revocation certificate:
PeersSayKeyBlownAlert.failedTransferSayBlownLabel=These nodes told us that the auto-update key has been compromised, but then failed to transfer the revocation certificate:
PeersSayKeyBlownAlert.titleWithCount=Auto-update key compromised according to ${count} peer(s)!
PeersSayKeyBlownAlert.short=According to some of your peers it is not safe to auto-update. Auto-update has been disabled until we know if they are lying.
PluginConfig.configFile=Plugins configuration file
PluginConfig.configFileLong=Path/Filename for the file which stores the plugin configuration
PluginConfig.installDir=Plugins installation directory
PluginConfig.installDirLong=Directory where to install the plugins
PluginJarUpdater.pluginUpdatedShortText=A new version of the ${name} plugin is available!
PluginJarUpdater.pluginUpdatedText=Click below to update to the latest version (${newVersion}) of ${name}.
PluginJarUpdater.pluginUpdatedTitle=A new version of the ${name} plugin is available!
PluginJarUpdater.updatePlugin=Update plugin after final security checks
PluginJarUpdater.willDeployAfterRevocationCheck=The plugin ${name} will be deployed as soon as we have finished double-checking that the auto-update system has not been compromised.
PluginManager.alwaysLoadPluginsFromCentralServer=Always load plugins over the web? (NOT RECOMMENDED!)
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=Cannot set the plugins list once loaded
PluginManager.deleteFailedPluginButton=Don't try again on next startup
PluginManager.loadedOnStartup=Plugins to load on startup
PluginManager.loadedOnStartupLong=Classpath, name and location for plugins to load when node starts up
PluginManager.loadedPlugins=Plugins to load on start up
PluginManager.loadedPluginsLong=A list of plugins that are started when Freenet starts
PluginManager.pluginReqNewerJVM=The plugin ${name} seems to require a later Java version. Please install at least Oracle Java 1.8, or remove the plugin.
PluginManager.pluginReqNewerJVMTitle=Later Java version required by plugin ${name}.
PluginManager.pluginLoadingFailedTitle=Could not load plugin!
PluginManager.pluginLoadingFailedShort=Could not load plugin ${name}!
PluginManager.pluginLoadingFailed=The plugin ${name} could not be loaded
PluginManager.pluginLoadingFailedStillTryingOverFreenet=We are still trying to load the plugin over Freenet.
PluginManager.pluginLoadingFailedWithMessage=The plugin ${name} could not be loaded: ${message}
PluginManager.officialPluginLoadFailedSuggestTryAgainFreenet=You can try again over Freenet, or you can fetch it over the web.
PluginManager.officialPluginLoadFailedSuggestTryAgainHTTPS=You can fetch the plugin over Freenet, or you can try again over the web.
PluginManager.officialPluginLoadFailedTryAgainFreenet=Load the plugin from Freenet
PluginManager.officialPluginLoadFailedTryAgain=Load the plugin over the web from our server (NOT ANONYMOUS!)
PluginToadlet.addPluginTitle=Add a plugin
PluginToadlet.failedToLoadPlugin=Failed to load plugin.
PluginToadlet.failedToLoadPluginCheckClass=The plugin you requested could not be loaded. Please verify the name of the plugin's class and the URL, if you gave one.
PluginToadlet.failedToLoadPluginTitle=Failed to load plugin
PluginToadlet.internalNameTitle=Internal Name
PluginToadlet.loadPluginCommand=Load Plugin
PluginToadlet.noWebInterface=The plugin does not have a web interface, so there is nothing to show.
PluginToadlet.noWebInterfaceTitle=Plugin has no web interface
PluginToadlet.pluginList=Plugin list
PluginToadlet.pluginListTitle=Plugins currently loaded
PluginToadlet.pluginNameTitle=Plugin Name
PluginToadlet.pluginNotFound=The requested plugin could not be found.
PluginToadlet.pluginNotFoundTitle=Plugin not found
PluginToadlet.returnToPluginsWithLinks=Please ${link}return${/link} to the list of plugins.
PluginToadlet.unsupportedMethod=Unsupported method.
PluginToadlet.unsupportedMethodTitle=Unsupported Method
PluginToadlet.visit=Visit
PproxyToadlet.changeReloadOnStartup=Change
PproxyToadlet.classNameTitle=Class Name
PproxyToadlet.downloadNotAllowedFromRemoteServer=Download of plugins is only allowed from our server.
PproxyToadlet.Error=Error
PproxyToadlet.fileonly=local files only
PproxyToadlet.internalIDTitle=Internal ID
PproxyToadlet.Load=Load
PproxyToadlet.loadFreenetPlugin=Add an Unofficial Plugin from Freenet
PproxyToadlet.loadFreenetPluginText=Here you can enter the Freenet key of a plugin you want to load. These plugins are not even remotely supported or checked for privacy leaks by us, so if you load a remote plugin here, you are basically on your own.
PproxyToadlet.loadFreenetURLLabel=Plugin Key
PproxyToadlet.loadLabelDeprecated=deprecated
PproxyToadlet.loadLabelExperimental=experimental
PproxyToadlet.loadOfficialPlugin=Add an Official Plugin
PproxyToadlet.loadOfficialPluginText=You can load any of these official plugins. We believe these plugins are free of privacy leaks, although bugs are possible and we make no guarantees. You can also load unofficial plugins, see below.
PproxyToadlet.loadOfficialPluginLabel=Load an official plugin
PproxyToadlet.loadOtherPlugin=Add an Unofficial Plugin
PproxyToadlet.loadOtherPluginText=Here you can enter the filename or internet address (URL) of a plugin you want to load. Other plugins than the ones listed above are not even remotely supported or checked for privacy leaks by us, so if you load a remote plugin here, you are basically on your own.
PproxyToadlet.loadOtherURLLabel=Plugin URL
PproxyToadlet.noPlugins=No plugins loaded
PproxyToadlet.noVersion=N/A
PluginManager.changePluginManagerEnabledInConfig=You must shut down Freenet and edit freenet.ini to change the plugins enabled setting. Add a line "pluginmanager.enabled=false" to disable plugin support, or "pluginmanager.enabled=true" to enable it.
PluginManager.enabled=Enable plugins?
PluginManager.enabledLong=Enable plugins? This should be enabled for nearly all nodes, but can be disabled for simulations.
PluginManager.pluginDesc.Freemail=Old version (v0.1) of email over Freenet. Requires an email client (e.g. Thunderbird). The only reason to install this is if you want to talk to people using the old Freemail, since the new Freemail isn't compatible with the old Freemail. Note that you can have both loaded at the same time as they use different ports to talk to your email client.
PluginManager.pluginDesc.Freemail_wot=Email over Freenet. Requires the WebOfTrust plugin. Has a basic web interface, or you can use an email client; see FSNG for details on how to set this up.
PluginManager.pluginDesc.HelloWorld=Test plugin. Does nothing useful, only for developers of new plugins.
PluginManager.pluginDesc.HelloFCP=FCP test plugin. Does nothing useful, only for developers of new plugins.
PluginManager.pluginDesc.JSTUN=Uses centralised STUN servers to detect your IP address and connectivity. It is important, especially on darknet, for Freenet to know what your IP address is (but it may be able to pick it up from your peers, especially if you have a lot of connections or are using opennet). STUN is used by other applications but this is centralised so could be used to find your node. If you can use UPnP instead then do so, but if UPnP can't find your IP address reliably you could load this as well.
PluginManager.pluginDesc.KeyUtils=A useful tool for examining Freenet keys, e.g. to list the pages in a freesite.
PluginManager.pluginDesc.MDNSDiscovery=Announces Freenet on your local network (LAN) so that clients can automatically connect to it. Not used much at the moment.
PluginManager.pluginDesc.SNMP=Enables you to remotely monitor your Freenet node's status via tools such as MRTG.
PluginManager.pluginDesc.TestGallery=Simple gallery page plugin, not currently used.
PluginManager.pluginDesc.ThawIndexBrowser=Lets you browse Thaw file indexes, and download files from them, from within the Freenet web interface, without having to install Thaw.
PluginManager.pluginDesc.UPnP=Talks to your router to discover your IP address and try to automatically forward your UDP ports to improve connectivity. You should have this enabled unless your LAN is untrusted. This is usually safe, unlike JSTUN.
PluginManager.pluginDesc.Freereader=Tool to insert RSS and ATOM feeds as freesites.
PluginManager.pluginDesc.Library=Tool to search Freenet using old or new format search indexes.
PluginManager.pluginDesc.Spider=Tool to create and automatically upload new format freesite search indexes, by automatically following links from your bookmarks. Causes very heavy load on your Freenet node, don't use it unless you have a powerful computer! Requires that the Library plugin also be loaded.
PluginManager.pluginDesc.Freetalk=Experimental anonymous forum. Currently has severe performance and reliability problems. Requires WebOfTrust.
PluginManager.pluginDesc.WebOfTrust=Allows you to create an anonymous identity. These identities can trust each other, or not, and hence avoid spam and DoS attacks. Backend for chat and social applications over Freenet.
PluginManager.pluginDesc.WebOfTrustTesting=Very new versions of the Web of Trust plugin, for testing purposes. Compiled by developer "xor". ATTENTION: These are not compiled on a high security computer. There is no key revocation mechanism for their update USK - if it gets hacked, you are in trouble. Updates will be installed at every restart of Freenet, even if auto-updating is disabled in configuration! Can only be fetched over Freenet, not from our central servers. Please unload WebOfTrust first before trying to load this plugin.
PluginManager.pluginDesc.FlogHelper=Easy to use tool for creating a blog on Freenet. Uses WebOfTrust to automatically announce your new flog so it should show up on the freesite indexes.
PluginManager.pluginDesc.Sharesite=Tool to publish and update single-page sites. Based on the ShareWiki plugin.
PluginManager.pluginName.Freemail=Freemail v0.1 (old!)
PluginManager.pluginName.Freemail_wot=Freemail
PluginManager.pluginName.HelloWorld=HelloWorld
PluginManager.pluginName.HelloFCP=HelloFCP
PluginManager.pluginName.JSTUN=JSTUN
PluginManager.pluginName.KeyUtils=KeyUtils
PluginManager.pluginName.MDNSDiscovery=MDNSDiscovery
PluginManager.pluginName.SNMP=SNMP
PluginManager.pluginName.TestGallery=TestGallery
PluginManager.pluginName.ThawIndexBrowser=ThawIndexBrowser
PluginManager.pluginName.UPnP=UPnP
PluginManager.pluginName.Freereader=Freereader
PluginManager.pluginName.Library=Library
PluginManager.pluginName.Spider=Spider
PluginManager.pluginName.Freetalk=Freetalk
PluginManager.pluginName.WebOfTrust=WebOfTrust
PluginManager.pluginName.WebOfTrustTesting=WebOfTrust Testing Versions
PluginManager.pluginName.FlogHelper=FlogHelper
PluginManager.pluginName.Sharesite=Sharesite
PproxyToadlet.pluginFilename=Name
PproxyToadlet.pluginGroup.communication=Communication
PproxyToadlet.pluginGroup.connectivity=Connectivity
PproxyToadlet.pluginGroup.example=Example
PproxyToadlet.pluginGroup.file-transfer=File Transfer
PproxyToadlet.pluginGroup.index=Indexing
PproxyToadlet.pluginGroup.technical=Technical
PproxyToadlet.pluginGroupTitle=${pluginGroup} Plugins
PproxyToadlet.pluginVersion=version
PproxyToadlet.pluginNotFoundReload=The specified plugin could not be located in order to reload it.
PproxyToadlet.pluginNotFoundReloadTitle=Plugin Not Found (reloading)
PproxyToadlet.pluginNotFoundUpdatingTitle=Plugin Not Found (updating)
PproxyToadlet.pluginNotFoundUpdating=The plugin you are trying to update isn't loaded!
PproxyToadlet.pluginSourceChoice=You can either fetch the plugin over Freenet or from our central servers:
PproxyToadlet.pluginSourceFreenet=Fetch over Freenet. This is difficult to trace, safe, and may be slow.
PproxyToadlet.pluginSourceHTTPS=Fetch over the web from our central servers.
PproxyToadlet.pluginSourceHTTPSWarning=WARNING: This will give away the fact that you are running Freenet, and won't work if our website is blocked! It may even be possible for a wiretapper to tell what you are trying to load, and thus connect it with when e.g. a Freemail identity was created.
PproxyToadlet.pluginUnloaded=Plugin unloaded
PproxyToadlet.pluginUnloadedWithName=The plugin ${name} has been unloaded.
PproxyToadlet.pluginFilesWarning=WARNING: If this plugin stored files on disk, they have NOT been deleted.
PproxyToadlet.plugins=Plugins
PproxyToadlet.reloadOnStartupShort=Reload on Startup
PproxyToadlet.reload=Reload
PproxyToadlet.reloadPluginTitle=Reload Plugin
PproxyToadlet.reloadExplanation=Reloading a plugin is the same as unloading it and then loading it again.
PproxyToadlet.reloadWarning=Be warned that some plugins do not handle a reload gracefully!
PproxyToadlet.reloadPurgeWarning=Remove the plugin from the cache before reloading. You need to set this if you want to update a plugin that was loaded from Freenet. If the plugin was loaded from the internet it will be downloaded again!
PproxyToadlet.refreshOnStartup=Reload from server on startup
PproxyToadlet.returnToPluginPage=Return to plugin page
PproxyToadlet.startedAtTitle=Started at
PproxyToadlet.startingPluginsTitle=Starting Plugins
PproxyToadlet.startingPluginName=Plugin name
PproxyToadlet.startingPluginStatus=Current status
PproxyToadlet.startingPluginStatus.downloading=downloading
PproxyToadlet.startingPluginStatus.starting=starting
PproxyToadlet.startingPluginTime=Time spent
PproxyToadlet.pluginDirectoryNotCreated=The plugin directory could not be created.
PproxyToadlet.pluginNotDownloaded=The plugin could not be downloaded.
PproxyToadlet.pluginStopping=Plugin Stopping
PproxyToadlet.unload=Unload
PproxyToadlet.unloadPluginTitle=Unload plugin?
PproxyToadlet.unloadPluginWithName=Are you sure you wish to unload ${name}?
PproxyToadlet.unloadPurge=Remove plugin from cache
PproxyToadlet.versionTitle=Version
SaltedHashFreenetStore.shortResizeProgress=Datastore(${name}) resize in progress: ${processed}/${total}
SaltedHashFreenetStore.shortRebuildProgressNew=Datastore(${name}) maintenance in progress: ${processed}/${total} (converting to new format)
SaltedHashFreenetStore.shortRebuildProgress=Datastore(${name}) maintenance in progress: ${processed}/${total} (after an unclean shutdown)
SaltedHashFreenetStore.longResizeProgress=Datastore(${name}) resize in progress: ${processed}/${total}. Freenet may be a little bit slower than usual during the process. Avoid restarting Freenet during this if you do not want to lose the progress.
SaltedHashFreenetStore.longRebuildProgressNew=Datastore(${name}) maintenance in progress: ${processed}/${total}. We have changed the datastore so that it will cause less load on your computer (particularly disk accesses), but we have to rebuild the indexes first, which will be quite heavy for some time depending on the size of your datastore. Your Freenet node will be slower than usual during the process. Avoid restarting the node during this if you do not want to lose the progress.
SaltedHashFreenetStore.longRebuildProgress=Datastore(${name}) maintenance in progress: ${processed}/${total}. Freenet is rebuilding the "slot filter" index for your datastore, probably because Freenet did not shut down properly at some point. This allows Freenet to access the disk a lot less, but rebuilding the indexes will involve some extra disk access for some time, depending on the size of your datastore. Your Freenet node may be slower than usual during this process, please avoid restarting Freenet.
SaltedHashFreenetStore.cleanerAlertTitle=Datastore maintenance running
QueueToadlet.awaitingCompression=Waiting
QueueToadlet.awaitingPasswordTitleDownloads=Password required to access the download queue
QueueToadlet.awaitingPasswordTitleUploads=Password required to access the upload queue
QueueToadlet.badMIMETypeIntro=The following downloads are of type ${type}. Freenet does not have any built in support for making this type safe, and we know that it can contain many dangerous things that can compromise your anonymity. If you are sure you want to download these files anyway, check the box next to each download, and click Restart.
QueueToadlet.backToUploadsPage=Back to the uploads page
QueueToadlet.backToDownloadsPage=Back to the downloads page
QueueToadlet.bulkDownloadSelectOptionDisk=to disk
QueueToadlet.bulkDownloadSelectOptionDirect=to temporary space
QueueToadlet.DUinProgress=Directory uploads in progress (${size})
QueueToadlet.DinProgress=Downloads in progress (${size})
QueueToadlet.UinProgress=Uploads in progress (${size})
QueueToadlet.cancelSelected=Cancel
QueueToadlet.compatModeLabel=Compatibility mode
QueueToadlet.compatibilityMode=Compatibility mode
QueueToadlet.change=Change
QueueToadlet.changeDownloadPriorities=Change priority of downloads
QueueToadlet.changeUploadPriorities=Change priority of uploads
QueueToadlet.completedDU=Completed directory uploads (${size})
QueueToadlet.completedDinDownloadDirectory=Completed downloads to download directory (${size})
QueueToadlet.completedDinTempDirectory=Completed fetches to temporary space (${size})
QueueToadlet.completedDtoDisk=Completed downloads to disk (${size})
QueueToadlet.completedDtoTemp=Completed fetches to temp (${size})
QueueToadlet.completedU=Completed uploads (${size})
QueueToadlet.completedUDirectory=Completed directory uploads (${size})
QueueToadlet.compressing=Compressing
QueueToadlet.confirmDeleteTitle=Are you sure you want to delete this file?
QueueToadlet.confirmDelete=Do you want to delete this file from Freenet's encrypted temporary space? It may take some time to re-fetch it if you change your mind later.
QueueToadlet.deleteFileFromTemp=DELETE FILE
QueueToadlet.deleteFilesFromTemp=DELETE SELECTED FILES
QueueToadlet.disableFilter=Yes I want to download potentially unsafe content (${type})!
QueueToadlet.dontCompressInCompatCell=don't compress
QueueToadlet.download=Download
QueueToadlet.downloadDisallowed=Downloading to "${directory}" is disallowed by your settings.
QueueToadlet.downloadFiles=Bulk downloads
QueueToadlet.downloadFilesInstructions=You can paste a list of keys to download in the box below (one per line)
QueueToadlet.downloadSucceededTitle=Download succeeded: ${filename}
QueueToadlet.downloadsSucceededTitle=${nr} downloads succeeded
QueueToadlet.downloadSucceeded=The file ${origlink}${filename}${/origlink} has been downloaded successfully. ${link}Click here${/link} to open the file (${size}).
QueueToadlet.enqueuedSuccessfully=The following ${number} keys have been enqueued sucessfully:
QueueToadlet.enqueuedFailure=The following ${number} keys could not be enqueued:
QueueToadlet.errorAccessDenied=Error: Access Denied!
QueueToadlet.errorAccessDeniedFile=Freenet's current configuration prohibits you from uploading the file "${file}".
QueueToadlet.errorDToDisk=Cannot download to disk
QueueToadlet.errorDToDiskConfig=Freenet's current configuration does not allow you to download files to the downloads directory.
QueueToadlet.errorDownloadNotCompleted=Download Not Completed
QueueToadlet.errorDownloadNotFound=Download Not Found
QueueToadlet.errorDownloadNotFoundExplanation=The download could not be found. Maybe it was already deleted?
QueueToadlet.errorInvalidURI=Invalid URI
QueueToadlet.errorInvalidURIToD=The URI is invalid and can not be downloaded.
QueueToadlet.errorInvalidURIToU=You did not specify a valid URI to insert the file to.
QueueToadlet.tooManyFilesInOneFolder=Cannot start insert: Too many files in one folder (directory).
QueueToadlet.errorMustSpecifyKeyTypeTitle=You must specify what key type to use when uploading a file!
QueueToadlet.errorMustSpecifyKeyType=You must specify what key type to use when uploading a file! Use SSK if you are not sure as it is more secure. Use CHK if you want it to be the same key every time (good for filesharing) but only if you don't care about security.
QueueToadlet.errorNoFileOrCannotRead=The file does not exist or it cannot be read
QueueToadlet.errorNoFileSelected=No file selected
QueueToadlet.errorNoFileSelectedU=You did not select a file to upload.
QueueToadlet.errorNoKey=No key specified to download
QueueToadlet.errorNoKeyToD=You did not specify a key to download.
QueueToadlet.failedD=Failed downloads (${size})
QueueToadlet.failedDUnknownMIME=Failed downloads: unknown type ${type} (${size})
QueueToadlet.failedDBadMIME=Failed downloads: known dangerous type ${type} (${size})
QueueToadlet.failedDU=Failed directory uploads (${size})
QueueToadlet.failedToRemove=Failed to remove ${id}: ${message}
QueueToadlet.failedToRemoveId=Failed to remove: ${id}
QueueToadlet.failedToRemoveAll=Failed to remove all requests. Either delete them manually, or shutdown and delete the client database file (client.dat) manually.
QueueToadlet.failedToRemoveRequest=Failed to remove request
QueueToadlet.failedToRestart=Failed to restart: ${id}
QueueToadlet.failedToRestartRequest=Failed to restart request
QueueToadlet.failedU=Failed uploads (${size})
QueueToadlet.fcpIsMissing=FCP server is missing
QueueToadlet.fileName=Local path
QueueToadlet.files=Files
QueueToadlet.filterData=Filter:
QueueToadlet.filterDataMessage=Select this to run your request through the content filter. The filter will try to prevent your computer from running anything which might harm it, or break your anonymity. Keeping this checked is strongly recommended.
QueueToadlet.follow=Follow Redirect
QueueToadlet.globalQueueIsEmpty=No queued downloads/uploads on the global queue.
QueueToadlet.identifier=Identifier
QueueToadlet.insertAs=Insert as:
QueueToadlet.insertFile=Upload a file to Freenet
QueueToadlet.insertFileLabel=Or upload a file through the browser (SLOW)
QueueToadlet.insertFileCompressLabel=Compress
QueueToadlet.insertFileInsertFileLabel=Insert File
QueueToadlet.insertFileBrowseLabel=Upload a file from disk
QueueToadlet.insertFileBrowseButton=Browse files
QueueToadlet.insertFileResetForm=Reset Form
QueueToadlet.key=Key
QueueToadlet.lastActivity=Last Progress
QueueToadlet.lastActivity.unknown=unknown
QueueToadlet.lastActivity.ago=${time} ago
QueueToadlet.lastFailure=Last Failure
QueueToadlet.lastFailure.never=never
QueueToadlet.lastFailure.ago=${time} ago
QueueToadlet.legend=Legend
QueueToadlet.mimeProblemFetchAnyway=You can ask Freenet to fetch the files anyway by clicking Restart (READ THE WARNING ABOVE FIRST!).
QueueToadlet.mimeType=Content Type
QueueToadlet.noTaskOnGlobalQueue=There is no task queued on the global queue at the moment.
QueueToadlet.none=none
QueueToadlet.openKeyList=Open key list as text
QueueToadlet.overriddenCryptoKeyInCompatCell=random crypto key
QueueToadlet.panicButtonTitle=Panic button
QueueToadlet.panicButtonNoConfirmation=Click to remove all downloads/uploads and clear all incriminating data without confirmation!
QueueToadlet.panicButtonWithConfirmation=Click to remove all downloads/uploads and clear all incriminating data!
QueueToadlet.confirmPanicButtonPageTitle=Confirm the panic button
QueueToadlet.confirmPanicButton=Clicking yes below will wipe the cache of recently visited sites, delete the master keys file, remove all downloads and uploads and remove any residual evidence of old downloads and uploads, and then restart Freenet. Are you sure?
QueueToadlet.confirmPanicButtonYes=Yes, delete everything
QueueToadlet.confirmPanicButtonNo=No, don't delete anything
QueueToadlet.persistence=Persistence
QueueToadlet.persistenceForever=forever
QueueToadlet.persistenceNone=none
QueueToadlet.persistenceReboot=reboot
QueueToadlet.persistenceBrokenTitle=Download/upload queue database corrupted!
QueueToadlet.persistenceBrokenShortAlert=Download/upload queue broken due to database corruption! Click for details on how to fix!
QueueToadlet.persistenceBroken=Freenet failed to load the database in which it stores persistent downloads and uploads. This is usually caused by data corruption on disk due to things like power failure. The problem is in the ${TEMPDIR} directory and ${DBFILE} file. Please shut down Freenet, then either restore them from backup or delete them. Also check whether you are out of disk space. This message sometimes happens harmlessly while Freenet is shutting down.
QueueToadlet.pleaseEnableFCP=You need to enable the FCP server to access this page
QueueToadlet.panicButton=PANIC!
QueueToadlet.priority0=emergency
QueueToadlet.priority1=very high
QueueToadlet.priority2=high
QueueToadlet.priority3=medium
QueueToadlet.priority4=low
QueueToadlet.priority5=very low
QueueToadlet.priority6=paused
QueueToadlet.priority=Priority
QueueToadlet.progress=Progress
QueueToadlet.progressbarAccurate=This progress value is accurate
QueueToadlet.progressbarNotAccurate=This progress value is likely to change as the download finds more blocks
QueueToadlet.uploadProgressbarNotAccurate=This progress value is likely to change as the upload encodes more blocks
QueueToadlet.reason=Reason
QueueToadlet.remove=Remove from list
QueueToadlet.removeFilesFromList=Remove from list
QueueToadlet.removeFinishedDownloads=Remove all finished downloads
QueueToadlet.removeFinishedUploads=Remove all finished uploads
QueueToadlet.requestNavigation=Request Navigation and Totals
QueueToadlet.restart=Restart
QueueToadlet.restartSelected=Restart
QueueToadlet.returnToQueuePage=Return to ${link}queue page${/link}.
QueueToadlet.tryAgainUploadFilePage=${link}Try again${/link} to upload a file.
QueueToadlet.recommend=Recommend
QueueToadlet.recommendAFileToFriends=Recommend a file to friends
QueueToadlet.recommendDescription=Description of the file:
QueueToadlet.recommendToFriends=Recommend to friends
QueueToadlet.recommendFilesToFriends=Recommend files to friends
QueueToadlet.browseToChange=Browse to change
QueueToadlet.siteUploadSucceededTitle=Freesite insert succeeded: ${filename}
QueueToadlet.sitesUploadSucceededTitle=${nr} freesite inserts succeeded
QueueToadlet.siteUploadSucceeded=Your freesite ${filename} (${files} files, ${size} total size) has been successfully uploaded to Freenet. ${link}Click here${/link} to open the site homepage.
QueueToadlet.size=Size
QueueToadlet.shuttingDownTitle=Freenet is shutting down.
QueueToadlet.shuttingDown=The download/upload queue is not available because Freenet is shutting down.
QueueToadlet.starting=STARTING
QueueToadlet.title=Downloads and uploads
QueueToadlet.titleUploads=Uploads
QueueToadlet.titleDownloads=Downloads
QueueToadlet.totalQueuedDownloads=Total queued downloads: ${size}
QueueToadlet.totalQueuedUploads=Total queued uploads: ${size}
QueueToadlet.totalSize=Total Size
QueueToadlet.unknown=Unknown
QueueToadlet.uploadSucceededTitle=Insert succeeded: ${filename}
QueueToadlet.uploadsSucceededTitle=${nr} inserts succeeded
QueueToadlet.uploadSucceeded=Your file ${filename} (size ${size}) has been successfully uploaded to Freenet. ${link}Click here${/link} to open the file.
QueueToadlet.warningUnsafeContent=Potentially Unsafe Content
QueueToadlet.warningUnsafeContentExplanation=The file you want to download is currently not filtered by Freenet's content filter! That means that your anonymity can be compromised by opening the file!
QueueToadlet.wipD=Running Downloads (${size})
QueueToadlet.wipDU=Running Directory Uploads (${size})
QueueToadlet.wipU=Running Uploads (${size})
RevocationChecker.revocationFetchFailedMaybeInternalError=The auto-update system has failed due to an unexpected error: "${detail}". This might be because the auto-update key has been compromised (e.g. the keys have been stolen), so we have turned off auto-update as it may not be safe. However it might also be due to a local problem such as running out of disk space. If this is true, please fix the problem and restart Freenet. If this message does not go away, please check the website ( https://freenetproject.org/ ) and seek help. It might be useful to try fetching the key manually, but bear in mind it might have been inserted by the person who stole the keys: ${key}
RevocationChecker.revocationFetchFailedFatally=The auto-update system has been compromised! The private key may have been stolen, so auto-update has been turned off permanently. The file that should explain what has happened cannot be fetched due to an unexpected error: "${detail}". Please try fetching the revocation key manually (the key might have been inserted incorrectly e.g. be too big; for safety's sake we have to turn off auto-update straight away rather than wait for the whole revocation key): ${key}
RequestStatus.unknownFilename=unknown filename
RequestStarterGroup.schedulerSSKInserts=Priority policy of the scheduler (SSK inserts)
RequestStarterGroup.schedulerSSKRequests=Priority policy of the scheduler (SSK requests)
RequestStarterGroup.schedulerCHKInserts=Priority policy of the scheduler (CHK inserts)
RequestStarterGroup.schedulerCHKRequests=Priority policy of the scheduler (CHK requests)
RequestStarterGroup.scheduler=Priority policy of the scheduler: hard (strictly by priority) or soft (randomize the priorities a bit)
RequestStarterGroup.schedulerLong=Set the priority policy scheme used by the scheduler.
RevocationKeyFoundUserAlert.text=The Freenet auto-update system appears to have been compromised! A trusted member of the Freenet team has uploaded a special signed message to Freenet to say that the keys for the auto-updater have been stolen, leaked, or somebody has them who shouldn't. We have turned off auto-update to prevent malware from being installed on your computer. Please check the website ( https://freenetproject.org/ ) for updates (if you can do so safely), but be careful as that may not be secure either. The thief might even have the keys for the message below, so please don't blindly follow instructions given without confirmation. Sorry we messed up!
RevocationKeyFoundUserAlert.textDetail=The message is: ${message}
RevocationKeyFoundUserAlert.textDisabled=The auto-updater has been disabled. This might be because of a local problem, such as running out of disk space, or the auto-updating system may have been compromised.
RevocationKeyFoundUserAlert.textDisabledDetail=The reason is: ${message}.
RevocationKeyFoundUserAlert.title=URGENT: The Freenet auto-update system has been compromised!
RevocationKeyFoundUserAlert.titleDisabled=The auto-updater may have been compromised! We have turned it off for now, please click for more details.
SecurityLevels.title=Security levels
SecurityLevels.tooltip=Configure your Freenet node's degree of security
SecurityLevels.networkThreatLevelShort=Protection against a stranger attacking you over the Internet
SecurityLevels.networkThreatLevel=How much security do you need against people and organisations trying to trace what you are doing on Freenet?
SecurityLevels.networkThreatLevel.name.MAXIMUM=MAXIMUM
SecurityLevels.networkThreatLevel.name.HIGH=HIGH
SecurityLevels.networkThreatLevel.name.NORMAL=NORMAL
SecurityLevels.networkThreatLevel.name.LOW=LOW
SecurityLevels.networkThreatLevel.choice.MAXIMUM=I intend to access information that could get me arrested, imprisoned, or worse. I understand that Freenet is experimental and cannot ensure security against certain known attacks, but I accept the risks compared to the alternatives.
SecurityLevels.networkThreatLevel.desc.MAXIMUM=Freenet will be ${bold}significantly${/bold} slower than in HIGH, as well as only connecting to Friends. Your real identity should be relatively safe provided you only connect to people you trust. For a more detailed explanation of Freenet's security, see the bottom of the ${link}"who should Freenet connect to?" page${/link} of the wizard.
SecurityLevels.networkThreatLevel.choice.HIGH=I would like to make it much more difficult for others to monitor my communications, or I am worried about ISPs and/or governments trying to block Freenet.
SecurityLevels.networkThreatLevel.desc.HIGH=Only connecting to Friends massively improves security, but Freenet will be slow unless you add at least 5-10 friends.
SecurityLevels.networkThreatLevel.choice.NORMAL=I live in a relatively free country, but I would like to make it more difficult for others to monitor my communications.
SecurityLevels.networkThreatLevel.desc.NORMAL=Freenet will be reasonably careful to protect your anonymity, at some performance cost. You should add friends running Freenet and upgrade to HIGH when you are able.
SecurityLevels.networkThreatLevel.choice.LOW=I do not care about monitoring and want maximum performance.
SecurityLevels.networkThreatLevel.desc.LOW=It may be quite easy for others to discover your identity!
SecurityLevels.networkThreatLevel.opennetIntro=Do you know personally anyone who already uses Freenet? If you know at least 3 people who already use Freenet, you can enable darknet mode, so Freenet will only connect to your Friends, greatly improving security. However, if you don't know anyone already on Freenet, or if you want maximum performance, you should enable opennet mode, and Freenet will automatically connect to other Freenet nodes run by strangers (as well as your Friends).
SecurityLevels.networkThreatLevel.opennetFriendsWarning=Adding people as Friends who you don't know outside of Freenet will not improve security and will reduce performance!
SecurityLevels.networkThreatLevel.opennetLabel=Opennet mode (connect to strangers and friends)
SecurityLevels.networkThreatLevel.opennetExplain=I don't know anyone who already uses Freenet: Connect to other Freenet nodes automatically.
SecurityLevels.networkThreatLevel.darknetLabel=Darknet mode (connect to friends only)
SecurityLevels.networkThreatLevel.darknetExplain=I know at least 3 people (10+ for good performance) who already use Freenet: Connect only to Friends.
SecurityLevels.noFriendsWarning=You have not added any Friends. If you set the network security level to high or maximum, you will be unable to connect to Freenet until you have at least one connected Friend! Note that for there to be any meaningful security benefit, these must be people you actually know and at least marginally trust, and for good performance you will need at least 5-10 of them connected at any time. Are you sure?
SecurityLevels.noFriendsCheckbox=I am sure, enable high network security level, I will add some Friends ASAP.
SecurityLevels.noConnectedFriendsWarning=You do not have any connected Friends, although you have added ${added} friends. If you set the network security level to high or maximum, you will only be able to connect to Freenet when your friends are online, which they are not at the moment. You should add additional Friends, only use Freenet when your friends are connected, or not upgrade to high security. Note that for there to be any meaningful security benefit, your Friends must be people you actually know and at least marginally trust, and for good performance you will need at least 5-10 of them connected at any time. Are you sure?
SecurityLevels.noConnectedFriendsCheckbox=I am sure, I will add more Friends and/or I accept that Freenet will only be online when my existing Friends are online.
SecurityLevels.fewConnectedFriendsWarning=You only have ${connected} connected Friends right now, and you have added ${added} friends in total. If you set the network security level to high or maximum, Freenet will only connect to your Friends, so your performance may be significantly reduced, and if all your Friends are offline then it will not be able to connect at all. Note that Friends must be people you know and at least marginally trust for there to be any real security benefit, and you will need at least 5-10 connected Friends for good performance. Are you sure?
SecurityLevels.fewConnectedFriendsCheckbox=I am sure, I will add more Friends and/or I accept the performance cost and the fact that Freenet may not connect when my Friends are offline.
SecurityLevels.networkThreatLevelLowWarning=You are about to downgrade your node's network security level to low. This means that it will be easy for strangers to attack your anonymity over the Internet. Are you sure?
SecurityLevels.networkThreatLevelLowCheckbox=I am sure, I want more speed and I don't care who can tell what I'm doing with Freenet!
SecurityLevels.networkThreatLevelConfirmTitle=WARNING: Setting network security level to ${mode}
SecurityLevels.maximumNetworkThreatLevelWarning=${bold}WARNING:${/bold} You are about to set the maximum network security level! This will ${bold}significantly${/bold} slow down Freenet for you! Please do not do this unless you really need the security!
SecurityLevels.maxSecurityYouNeedFriends=${bold}You must know at least one person already running Freenet${/bold}, preferably 3, 5-10 for good performance. You must add them on the Friends page. These must be people you already know and at least marginally trust.
SecurityLevels.maximumNetworkThreatLevelCheckbox=Yes I really want to enable maximum security, I understand that Freenet is still experimental and it may still be possible to trace me, and that this setting may dramatically reduce Freenet's performance!
SecurityLevels.physicalThreatLevelShort=Protection of your downloads, uploads and Freenet browsing cache
SecurityLevels.physicalThreatLevel=How concerned are you about people stealing or seizing your computer?
SecurityLevels.physicalThreatLevelFDE=We strongly recommend you encrypt your hard disk using full disk encryption software (${link}Wikipedia${/link}). This will provide the best protection, especially if you use third party apps and plugins such as Sone and FMS, but may take some time to set up. Otherwise, you can set a password for your downloads, uploads, and cache of recently visited Freenet websites.
SecurityLevels.physicalThreatLevelFDELink=https://en.wikipedia.org/wiki/Comparison_of_disk_encryption_software
SecurityLevels.physicalThreatLevelSwapfile=Also, you should encrypt your swap space if possible (this is a temporary file used by ${operatingSystem} to provide extra space if it runs out of memory). This may be easier to set up than full disk encryption.
SecurityLevels.physicalThreatLevelSwapfileWindows=On some versions of Windows you can encrypt your swapfile with the command "fsutil behavior set encryptpagingfile 1".
SecurityLevels.physicalThreatLevel.name.LOW=NONE
SecurityLevels.physicalThreatLevel.choice.LOW=Don't encrypt anything. (Choose only if you are using full disk encryption)
SecurityLevels.physicalThreatLevel.desc.LOW=Freenet will be slightly faster and depend on your existing full disk encryption.
SecurityLevels.physicalThreatLevel.name.NORMAL=LOW
SecurityLevels.physicalThreatLevel.choice.NORMAL=Protect the downloads, uploads, and Freenet browsing cache, with a persistent encryption key so they can be wiped quickly.
SecurityLevels.physicalThreatLevel.desc.NORMAL=You can quickly wipe this data by using the panic button or securely deleting the file master.keys. We recommend you "Fetch" big files rather than "Downloading" them, so that they are encrypted and can be viewed through the downloads page. However if your computer is seized, unless you have been able to use the Panic button, they will be able to see what you have been doing on Freenet.
SecurityLevels.physicalThreatLevel.name.HIGH=HIGH
SecurityLevels.physicalThreatLevel.choice.HIGH=Protect the downloads, uploads, and Freenet browsing cache with a password.
SecurityLevels.physicalThreatLevel.desc.HIGH=You will have to enter the password to access your download queue (and the cache of recently visited sites). You can also use the panic button. We recommend you "Fetch" big files rather than "Downloading" them, so that they are encrypted and can be viewed through the downloads page. If your computer is seized they will need the password.
SecurityLevels.physicalThreatLevel.name.MAXIMUM=MAXIMUM
SecurityLevels.physicalThreatLevel.choice.MAXIMUM=Use a temporary encryption key, so that downloads, uploads and Freenet browsing cache are wiped on restarting Freenet.
SecurityLevels.physicalThreatLevel.desc.MAXIMUM=Freenet will keep the encryption keys in RAM only, and will never store the keys to disk. All downloads and uploads will persist only until restart, and Freenet will refuse to write files to disk. You should take care to avoid saving content from Freenet to disk accidentally. Please consider installing full disk encryption software (https://en.wikipedia.org/wiki/Comparison_of_disk_encryption_software), especially if you are going to use third party plugins and apps over Freenet such as FMS and Sone!
SecurityLevels.physicalThreatLevelEnd=You should follow standard security precautions (keep updated, run an anti-virus, don't open files you don't trust etc), and note that if they capture your computer while it is switched on and running Freenet, no amount of encryption will help you!
OperatingSystemName.Windows=Windows
OperatingSystemName.Linux=Linux
OperatingSystemName.MacOS=MacOS
OperatingSystemName.FreeBSD=FreeBSD
OperatingSystemName.GenericUnix=UNIX
OperatingSystemName.Unknown=your operating system
SecurityLevels.userAlertShortText=Security levels: Network: ${network}, Friends: ${friends}, Physical: ${physical}
SecurityLevels.userAlertNetworkThreatLevel=Protection against a stranger attacking you over the Internet: ${level}
SecurityLevels.userAlertPhysicalThreatLevel=Protection if your computer is seized or stolen: ${level}
SecurityLevels.userAlertExtro=You can change these settings on ${link}the config page${/link}.
SecurityLevels.passwordPageTitle=Please enter master password
SecurityLevels.passwordSubmit=Ok
SecurityLevels.passwordWrongTitle=Wrong password entered
SecurityLevels.enterPasswordTitle=Enter the master password to access cached content and queued downloads/uploads
SecurityLevels.passwordWrong=You entered the wrong password. Please enter the correct password to enable access to the client-cache and improve browsing performance.
SecurityLevels.enterPassword=Please enter the master password to enable access to downloads and uploads and to improve performance by enabling the recently browsed freesites cache.
SecurityLevels.setPasswordLabel=Set the password
SecurityLevels.confirmPasswordLabel=Confirm password
SecurityLevels.passwordLabel=Password
SecurityLevels.setPassword=Please set the master password, which will be used to protect cached content. The stronger the password the stronger the protection: lots of letters and numbers and punctuation is best.
SecurityLevels.passwordNotZeroLength=The password must be at least one character long i.e. it must not be "".
SecurityLevels.passwordsDoNotMatch=The password pair provided does not match.
SecurityLevels.passwordForDecryptTitle=Please enter the old password
SecurityLevels.passwordForDecrypt=In order to un-password the client cache etc, we need the old password.
SecurityLevels.cantWriteNewMasterKeysFileTitle=Unable to write the new master.keys file!
SecurityLevels.cantWriteNewMasterKeysFile=Something went wrong - maybe out of disk space or a hard disk problem. See the following error message for details:
SecurityLevels.oldPasswordLabel=Old password:
SecurityLevels.newPasswordLabel=New password:
SecurityLevels.confirmNewPasswordLabel=Confirm Password:
SecurityLevels.setPasswordTitle=Set a new master password
SecurityLevels.changePasswordButton=Change password
SecurityLevels.changePasswordTitle=Change the master password
SecurityLevels.backToSecurityLevels=Don't set or change the password and return to the security levels page.
SecurityLevels.passwordFileCorruptedTitle=Master password file corrupted
SecurityLevels.passwordFileCorrupted=The master password file ${file} has been corrupted. You can delete it and lose the client-cache and the downloads and uploads queues, or you can restore it from a backup.
SecurityLevels.wrongOldPassword=You entered the wrong old password. If you have lost the password you can remove the master.keys file to set a new password, but you will lose all the data protected by the old password - the recently visited sites cache and the download queue in particular.
SecurityLevels.cantDeletePasswordFileTitle=Unable to delete master password file!
SecurityLevels.cantDeletePasswordFile=Freenet was not able to delete the master password file ${filename}. You must securely delete it by hand, otherwise if your computer is seized the attacker will be able to decrypt your cache of recently visited sites and your downloads and uploads. Please delete ${filename} manually.
SecurityLevels.cantDeletePasswordFileButton=Try again
SecurityLevels.warningMaximumWillDeleteQueue=Warning: Freenet will delete your download/upload queue on the next restart if you select this security level!
SecurityLevelsToadlet.fullTitle=Security levels
SecurityLevels.statusBarPrefix=Security levels:
StringArrOption.parseError=Cannot parse value as a string array: ${error}
ShortOption.unrecognisedShort=The value specified can't be parsed as a 16-bit integer : ${val}
SimpleHelpToadlet.CHK=CHK = Content Hash Key - A static key derived by a mathematical hash of a file.
SimpleHelpToadlet.SSK=SSK = Signed Subspace Key -
SimpleHelpToadlet.USK=USK = Updateable Subspace Key -
SimpleHelpToadlet.connectivityText=Testing. Test.   Blah blah blah, etc etc etc
SimpleHelpToadlet.connectivityTitle=Connectivity
SimpleHelpToadlet.definitionsTitle=Definitions
SimpleHelpToadlet.descriptionText=This page should provide basic info for you to get started with Freenet.  There are many other places for more in-depth information such as the offical Freenet website http://freenetproject.org, the offical wiki http://wiki.freenetproject.org or various in-Freenet Freesites.
SimpleHelpToadlet.descriptionTitle=Description
SimpleToadletServer.advancedMode=Enable Advanced Mode?
SimpleToadletServer.advancedModeLong=Enables display of advanced options and information in the web interface by default. This setting should be turned to false in most cases.
SimpleToadletServer.allowedFullAccess=Hosts having a full access to the Freenet web interface (read warning)
SimpleToadletServer.allowedFullAccessLong=Hosts granted full access (i.e. change config settings, restart, etc) to your Freenet node. WARNING: Be very careful who you give full web interface access to!
SimpleToadletServer.allowedHosts=Hostnames or IP addresses that are allowed to connect to the web interface.
SimpleToadletServer.allowedHostsLong=May be a comma-separated list of single IPs and CIDR masked IPs like 192.168.0.0/24. Note that these can access the hard disk within the limits set by other config options. They can also see your bookmarks.
SimpleToadletServer.bindTo=IP address to bind to
SimpleToadletServer.bindToLong=IP address to bind to
SimpleToadletServer.cannotChangePortOnTheFly=Cannot change web interface port number on the fly
SimpleToadletServer.couldNotChangeBindTo=Could not change web interface bind address: Some of the IP addresses given could not be bound to: ${failedInterfaces}. Maybe you mis-typed an IP address or a network connection is down?
SimpleToadletServer.cssName=Web interface theme
SimpleToadletServer.cssNameLong=Select a theme for the Freenet web interface
SimpleToadletServer.cssOverride=Override the CSS with a custom one (WARNING!)
SimpleToadletServer.cssOverrideCantRead=We cannot read the given CSS override file: ${filename}
SimpleToadletServer.cssOverrideLong=That setting allows you to override Freenet's CSS with a custom file. WARNING: CSS can be dangerous, and this one won't be filtered! Use at your own risk. We will allow access to the CSS file from /static/override/ (plus the filename within the folder the file is in), so you can refer to images, @include other CSS files etc. If you make a nice theme, consider mailing devl@freenetproject.org to get it included in the main distribution.
SimpleToadletServer.cssOverrideNotInUploads=We can't let you set that setting: "${filename}" isn't in a directory from which uploads are allowed!
SimpleToadletServer.cssOverrideCantUseRootDir=You cannot put the override file in the root folder (${filename}). Please move it to a folder within that. This is for security.
SimpleToadletServer.disableProgressPage=Disable progress page when loading pages?
SimpleToadletServer.disableProgressPageLong=Set to not show a progress page when loading a page. NOTE: The progress page improves the browsing experience by giving feedback on fetch progress and allowing better use of the limited number of parallel connections most browsers will make to Freenet.
SimpleToadletServer.doRobots=Exclude robots via robots.txt?
SimpleToadletServer.doRobotsLong=Whether to serve a /robots.txt telling google, spiders, wget, etc to go away
SimpleToadletServer.enableActivelinks=Enable activelinks?
SimpleToadletServer.enableActivelinksLong=Should the Browse Freenet page show icons for each bookmarked page? The page will load faster if it doesn't show the icons...
SimpleToadletServer.enableJS=Enable web interface use of JavaScript?
SimpleToadletServer.enableJSLong=Whether or not the web interface should use JavaScript "helpers". This setting should be turned to false in most cases. Note that freesites may not use JavaScript even if this is enabled.
SimpleToadletServer.enableWP=Enable web interface use of web pushing (experimental)?
SimpleToadletServer.enableWPLong=Whether or not the web interface should use JavaScript web pushing to update displayed data without reloading. It requires that JavaScript is turned on. It is experimental and use at your own risk.
SimpleToadletServer.enabled=Enable the web interface (FProxy)?
SimpleToadletServer.enabledLong=Whether to enable the web interface and related HTTP services. The web interface is the user interface to Freenet which you can access with your browser.
SimpleToadletServer.enableExtendedMethodHandling=Enable extended HTTP method handling?
SimpleToadletServer.enableExtendedMethodHandlingLong=Enable this to allow HTTP methods other than GET and POST to be handled. Required for WebDAV and other HTTP extensions.
SimpleToadletServer.enableInlinePrefetch=Enable prefetching of inline images?
SimpleToadletServer.enableInlinePrefetchLong=This may help if your browser only uses a small number of connections to talk to Freenet. On the other hand it may not.
SimpleToadletServer.enablePersistentConnections=Enable persistent HTTP connections? (Read detailed description)
SimpleToadletServer.enablePersistentConnectionsLong=Don't enable this unless your browser is configured to use lots of connections even if they are persistent.
SimpleToadletServer.hasCompletedWizard=Have you completed the first-time configuration wizard yet?
SimpleToadletServer.hasCompletedWizardLong=Have you completed the first-time configuration wizard yet? If not, the web interface will redirect all your requests to it.
SimpleToadletServer.illegalCSSName=CSS name must not contain slashes or colons!
SimpleToadletServer.maxFproxyConnections=Maximum fproxy connections
SimpleToadletServer.maxFproxyConnectionsLong=Maximum number of fproxy connections we will serve at once. Each uses a thread.
SimpleToadletServer.metaRefreshSamePageInterval=Allow freesites to refresh themselves periodically: Minimum interval in seconds or -1 for disabled.
SimpleToadletServer.metaRefreshSamePageIntervalLong=Allow freesites to refresh themselves periodically with HTML meta refresh: Minimum interval in seconds or -1 for disabled.
SimpleToadletServer.metaRefreshRedirectInterval=Allow freesites to redirect to other freesites after a delay: Minimum interval in seconds or -1 for disabled.
SimpleToadletServer.metaRefreshRedirectIntervalLong=Allow freesites to redirect to other freesites after a delay with HTML meta refresh: Minimum interval in seconds or -1 for disabled.
SimpleToadletServer.panicButton=Show the panic button?
SimpleToadletServer.panicButtonLong=Shows a 'panic button' on the queue page that will remove all downloads and uploads, wipe the cache of recently visited freesites, and clear the master keys file.
SimpleToadletServer.noConfirmPanic=No confirmation on panic button?
SimpleToadletServer.noConfirmPanicLong=If true, the panic button will not ask for confirmation but will act immediately.
SimpleToadletServer.passthroughMaxSize=Maximum size for transparent pass-through in the web interface where we cannot show progress (e.g. images)
SimpleToadletServer.passthroughMaxSizeLong=Maximum size for images etc on the Freenet web interface. If an image, style sheet etc is larger than this threshold, it will fail, and if possible Freenet will show an error. This is to prevent your browser from waiting forever for a page full of enormous images.
SimpleToadletServer.passthroughMaxSizeProgress=Maximum size for transparent pass-through in the web interface where we can show a progress bar (e.g. HTML pages)
SimpleToadletServer.passthroughMaxSizeProgressLong=Maximum size of an HTML page or file, where Freenet can show a progress bar. If the file is larger than this it will ask you whether you want to download it in the background, e.g. to your downloads folder.
SimpleToadletServer.port=Web interface port
SimpleToadletServer.portLong=The TCP port the web interface should listen on
SimpleToadletServer.publicGatewayMode=Public gateway mode? (Only applies to allowed but non-full-access connections)
SimpleToadletServer.publicGatewayModeLong=Should we enable public gateway mode? For IPs which are allowed to access Freenet, but are not allowed full access, this option disables the download queue and anything else that might conceivably be abused to attack the Freenet node, while still allowing browsing freesites. They will also only see the default bookmarks, not your bookmarks. IP addresses with full access will be allowed to configure the node. You will still need to configure allowed addresses and bind address to get a true public gateway; you should do this after restarting.
SimpleToadletServer.publicGatewayModeNeedsRestart=Enabling or disabling public gateway mode requires that you restart Freenet. Until then, it will not apply, so you should not change your other fproxy settings.
SimpleToadletServer.refilterPolicy=What should fproxy do when a downloaded file matches the key being fetched, but it has already been filtered?
SimpleToadletServer.refilterPolicyLong=What should fproxy do when a downloaded file matches the key being fetched, but it has already been filtered? RE_FILTER = filter it anyway, since the filter may have been improved since the original download, ACCEPT_OLD = accept the old data (maximum performance), RE_FETCH = ignore the old data.
SimpleToadletServer.sendAllThemes=Send all themes to browser?
SimpleToadletServer.sendAllThemesLong=If set true, all available themes will be loaded by the browser when viewing the FProxy UI pages, and switchable using your browser's page style selection options.
SimpleToadletServer.ssl=Enable SSL?
SimpleToadletServer.sslLong=Enable SSL on the web interface. You will need the 'Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files' for it to work.
SSL.enable=Activate SSL support?
SSL.keyStore=Path to the key store
SSL.keyStorePass=Key store password
SSL.keyPass=Private key password
SSL.version=Version of SSL
SSL.versionLong=Version of SSL, SSLv3 or TLSv1 (default SSLv3)
StartupToadlet.entropyErrorTitle=Freenet is waiting for more entropy before it can start up
StartupToadlet.entropyErrorContent=Freenet is currently waiting for more entropy (randomness) from your computer. Freenet needs entropy so that it can generate cryptographic keys safely. Freenet will try to gather entropy by reading the disk. See wrapper.log for details.
StartupToadlet.isStartingUp=Your Freenet node is starting up, please hold on.
StartupToadlet.title=Freenet is starting up
StaticToadlet.pathInvalidChars=The given URI contains disallowed characters.
StaticToadlet.pathNotFound=The path you specified doesn't exist.
StaticToadlet.pathNotFoundTitle=Path Not Found
StatisticsToadlet.accessRate=Access Rate
StatisticsToadlet.ackOnlyBytes=Ack-only packets: ${total}
StatisticsToadlet.activityInserts=Inserts: ${CHKhandlers} CHK handlers, ${SSKhandlers} SSK handlers (${local} local)
StatisticsToadlet.activityRequests=Requests: ${CHKhandlers} CHK handlers, ${SSKhandlers} SSK handlers (${local} local)
StatisticsToadlet.adminBytes=Admin bytes: ${initial} initial messages, ${changedIP} IP change messages, ${disconn} disconnection notifications, ${routingStatus} routing status
StatisticsToadlet.allocMemory=Allocated Java memory: ${memory}
StatisticsToadlet.announceBytes=Announcement output: ${total} (transferring node refs payload ${payload})
StatisticsToadlet.authBytes=Connection setup: ${total} output
StatisticsToadlet.avgDist=Avg. Distance
StatisticsToadlet.avgLocation=Avg. Location
StatisticsToadlet.avgSuccessLoc=Avg. Success Loc.
StatisticsToadlet.avgTime=Avg. Time
StatisticsToadlet.bandwidthTitle=Bandwidth
StatisticsToadlet.CACHE=Cache
StatisticsToadlet.capacity=Capacity
StatisticsToadlet.CHK=CHK
StatisticsToadlet.chkCache=Cache (CHK)
StatisticsToadlet.chkDetailTiming=Detailed timings (local fetches)
StatisticsToadlet.CLIENT=Client cache
StatisticsToadlet.clientRequesterObjects=ClientRequester Objects
StatisticsToadlet.clientRequesters.age=Age
StatisticsToadlet.clientRequesters.class=Class
StatisticsToadlet.clientRequesters.priorityClass=Priority Class
StatisticsToadlet.clientRequesters.realtimeFlag=Realtime Flag?
StatisticsToadlet.clientRequesters.uri=URI
StatisticsToadlet.count=Count
StatisticsToadlet.cpus=Available CPUs: ${count}
StatisticsToadlet.cryptoUsingBuiltin=Encryption: Using built-in code.
StatisticsToadlet.cryptoUsingJCA=Encryption: Using JCA (${provider}).
StatisticsToadlet.datasize=Data Size
StatisticsToadlet.datastore=Datastore
StatisticsToadlet.databaseJobsByPriority=Database jobs
StatisticsToadlet.debuggingBytes=Debugging bytes: ${netColoring} network coloring, ${ping} ping, ${probe} probe requests, ${routed} routed test messages.
StatisticsToadlet.distanceStats=Distance Stats
StatisticsToadlet.falsePos=False Pos.
StatisticsToadlet.foafBytes=FOAF related: ${total}
StatisticsToadlet.fullTitle=Statistics
StatisticsToadlet.furthestSuccess=Furthest Success
StatisticsToadlet.getLogs=Get latest node's logfile
StatisticsToadlet.globalWindow=Global window
StatisticsToadlet.inputRate=Input Rate: ${rate}/s (of ${max}/s)
StatisticsToadlet.insertOutput=Insert output (excluding payload): CHK ${chk} SSK ${ssk}.
StatisticsToadlet.jobType=Job Type
StatisticsToadlet.jvmInfoTitle=Java Info
StatisticsToadlet.jvmName=Java VM Name: ${name}
StatisticsToadlet.jvmVendor=Java VM Vendor: ${vendor}
StatisticsToadlet.javaVersion=Java Version: ${version}
StatisticsToadlet.jvmVersion=Java VM Version: ${version}
StatisticsToadlet.keys=Keys
StatisticsToadlet.mandatoryBackoffReason=Mandatory Backoff Reason
StatisticsToadlet.maxMemory=Maximum Java memory: ${memory}
StatisticsToadlet.maxTotalPeers=Max peers
StatisticsToadlet.maxOpennetPeers=Max strangers
StatisticsToadlet.newLoadManagementTitle=New load management stats
StatisticsToadlet.nodeToNodeBytes=Node to node messages: ${total}
StatisticsToadlet.notBackedOff=Good, your node is not backed off from any peers!
StatisticsToadlet.loadAllocationNoticesBytes=Load allocation notices: ${total}
StatisticsToadlet.noRequests=Your node is not processing any requests right now.
StatisticsToadlet.offerReplys=Running offer replys: ${chk} CHK, ${ssk} SSK.
StatisticsToadlet.offeredKeyOutput=Offered keys: sending keys ${total}, sending offers ${offered}
StatisticsToadlet.opennetStats=Opennet stats
StatisticsToadlet.osArch=OS Architecture: ${arch}
StatisticsToadlet.osName=OS Name: ${name}
StatisticsToadlet.osVersion=OS Version: ${version}
StatisticsToadlet.outputRate=Output Rate: ${rate}/s (of ${max}/s)
StatisticsToadlet.payloadOutput=Payload Output: ${total} (${rate}/sec)(${percent}%)
StatisticsToadlet.peerStatsTitle=Peer statistics
StatisticsToadlet.priority=Priority
StatisticsToadlet.PUB_KEY=Pubkey
StatisticsToadlet.queuedCount=Queued Count
StatisticsToadlet.readRequests=Read-Requests
StatisticsToadlet.realGlobalWindow=Real global window
StatisticsToadlet.requestOutput=Request output (excluding payload): CHK ${chk} SSK ${ssk}.
StatisticsToadlet.resendBytes=Resent bytes: ${total} (${percent}%)
StatisticsToadlet.routingBackoffReason=Routing Backoff Reason
StatisticsToadlet.routingDisabled=Not routing traffic (we are currently connected to the node but we or it refuse to route traffic)
StatisticsToadlet.routingDisabledShort=Not routing traffic
StatisticsToadlet.running=Running
StatisticsToadlet.runningBlockTransfers=Block transfers: ${sends} sends, ${receives} receives
StatisticsToadlet.seedStats=Seed stats
StatisticsToadlet.seedTableIP=IP
StatisticsToadlet.seedTableConnections=Connected
StatisticsToadlet.seedTableAnnouncements=Announced
StatisticsToadlet.seedTableAccepted=Accepted
StatisticsToadlet.seedTableCompleted=Completed
StatisticsToadlet.seedTableForwarded=Sent refs
StatisticsToadlet.seedTableVersion=Version
StatisticsToadlet.SLASHDOT=Slashdot cache
StatisticsToadlet.statisticGatheringTitle=Statistics Gathering
StatisticsToadlet.SSK=SSK
StatisticsToadlet.STORE=Store
StatisticsToadlet.storeJobsByPriority=Store checker jobs by priority
StatisticsToadlet.successByHTLRT=Success rates by HTL (remote realtime fetches)
StatisticsToadlet.successByHTLBulk=Success rates by HTL (remote bulk fetches)
StatisticsToadlet.successfulReads=Successful Reads
StatisticsToadlet.successRate=Success Rate
StatisticsToadlet.swapOutput=Swapping Output: ${total}.
StatisticsToadlet.threadDumpButton=Generate a Thread Dump
StatisticsToadlet.threads=Running threads: ${running}/${max}
StatisticsToadlet.threadsByPriority=Pooled threads by priority
StatisticsToadlet.totalInput=Global Total Input: ${total}
StatisticsToadlet.totalInputSession=Session Total Input: ${total} (${rate}/s average)
StatisticsToadlet.totalOutput=Global Total Output: ${total}
StatisticsToadlet.totalOutputSession=Session Total Output: ${total} (${rate}/s average)
StatisticsToadlet.totalOverhead=Total non-request overhead: ${rate}/sec (${percent}%).
StatisticsToadlet.totalTime=Total Time
StatisticsToadlet.transferBackoffReason=Transfer Backoff Reason
StatisticsToadlet.transferringRequests=Transferring Requests: sending ${senders}, receiving ${receivers}
StatisticsToadlet.uomBytes=Updater Output: ${total}
StatisticsToadlet.unaccountedBytes=Other output: ${total} (${percent}%)
StatisticsToadlet.usedMemory=Used Java memory: ${memory}
StatisticsToadlet.utilization=Utilization
StatisticsToadlet.versionTitle=Node Version Information
StatisticsToadlet.waiting=Waiting
StatisticsToadlet.writeRate=Write Rate
StatisticsToadlet.writes=Writes
StatusBar.alerts=Messages:
StatusBar.connectedPeers=We are currently connected to ${X} friends and ${Y} strangers.
StatusBar.switchToAdvancedMode=Switch to advanced mode
StatusBar.switchToSimpleMode=Switch to simple mode
SymlinkerToadlet.symlinks=Symlinks in ToadletServer
SymlinkerToadlet.symlinksLong=A list of "alias#target"'s that forms a bunch of symlinks
TestnetHandler.cannotEnableDisableOnTheFly=On-line enable/disable of testnet mode impossible; restart Freenet and get new connections
TestnetHandler.enable=Enable testnet mode? (DANGEROUS)
TestnetHandler.enableLong=Whether to enable testnet mode (DANGEROUS!). Testnet mode eliminates your anonymity in exchange for greatly assisting the developers in debugging Freenet.
TestnetHandler.port=Testnet port
TestnetHandler.portLong=Testnet port number (-1 = listenPort+1000)
TextModeClientInterfaceServer.allowedHosts=Allowed hosts
TextModeClientInterfaceServer.allowedHostsLong=Hostnames or IP addresses that are allowed to connect to the TMCI. May be a comma-separated list of hostnames, single IPs and even CIDR masked IPs like 192.168.0.0/24
TextModeClientInterfaceServer.bindTo=IP address to bind to
TextModeClientInterfaceServer.bindToLong=IP address to bind to
TextModeClientInterfaceServer.enableInputOutput=Enable on stdout/stdin?
TextModeClientInterfaceServer.enableInputOutputLong=Enable text mode client interface on standard input/output? (enabled refers to providing a telnet-style server, this runs it over a socket)
TextModeClientInterfaceServer.enabled=Enable TMCI?
TextModeClientInterfaceServer.enabledLong=Enable the Text Mode Client Interface
TextModeClientInterfaceServer.ssl=Enable SSL?
TextModeClientInterfaceServer.sslLong=Enable SSL on the TMCI server. You will need the 'Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files' for it to work.
TextModeClientInterfaceServer.telnetPortNumber=TMCI port
TextModeClientInterfaceServer.telnetPortNumberLong=The TCP port the TMCI server should listen on
TimeSkewDetectedUserAlert.title=Wrong date and time
TimeSkewDetectedUserAlert.text=Your computer's clock seems to be wrong. Freenet cannot connect to the network correctly. Please set your computer's clock to the correct date and time, then restart Freenet.
TimeSkewDetectedUserAlert.shortText=Freenet cannot connect because your computer's clock is wrong.
Toadlet.yes=Yes
Toadlet.no=No
Toadlet.back=Back
Toadlet.next=Next
Toadlet.cancel=Cancel
Toadlet.clickHere=Click here
Toadlet.internalErrorPleaseReport=Internal error: please report
Toadlet.internalErrorTitle=Internal Error
Toadlet.nodeHomepage=Freenet Homepage
Toadlet.notSupportedTitle=Not Supported
Toadlet.notSupportedWithClass=Your browser sent a request that Freenet (${class}) could not understand.
Toadlet.ok=Ok
Toadlet.permRedirectWithReason=Permanent redirect: ${reason}
Toadlet.returnToNodeHomepage=Return to your Freenet homepage
Toadlet.returnToQueuepage=Return to queue page
Toadlet.returnToPrevPage=Return to the previous page
Toadlet.tempRedirectWithReason=Temporary redirect: ${reason}
Toadlet.unauthorizedTitle=Unauthorized
Toadlet.unauthorized=You are not permitted access to this page.
Toadlet.homepage=Homepage
ToadletContextImpl.cannotParseContentLength=Content-length parse error: ${error}
ToadletContextImpl.cannotParseContentLengthWithError=Cannot parse the content-length: ${error}
ToadletContextImpl.headersLineTooLong=Line too long parsing headers
ToadletContextImpl.methodNotAllowed=HTTP Method Not Allowed
ToadletContextImpl.noContentLengthInPOST=No content-length in POST
ToadletContextImpl.noSuchToadlet=No Toadlet of that name
ToadletContextImpl.parseErrorWithError=Parse error: ${error}
ToadletContextImpl.uriParseErrorTitle=URI Parse Error
TranslationToadlet.title=Translation
TranslationToadlet.titleLong=Contribute to the translation
TranslationToadlet.bracketRemoveOverride= (Remove the translation override!)
TranslationToadlet.bracketTranslateIt= (translate it in your native language!)
TranslationToadlet.bracketUpdateTranslation= (update the translation)
TranslationToadlet.confirmRemoveOverride=Are you sure that you want to remove the following translation key: (${key} - ${value})?
TranslationToadlet.contributingToLabelWithLang=You are currently contributing to the ${lang} translation:
TranslationToadlet.currentTranslationLabel=Current translation
TranslationToadlet.downloadTranslationsFile=Download your translations
TranslationToadlet.gotoNext=Go to next untranslated String?
TranslationToadlet.hideAlreadyTranslated=Hide already translated strings
TranslationToadlet.noCustomTranslations=There is no custom translation available.
TranslationToadlet.originalVersionLabel=Original (English version)
TranslationToadlet.reEdit=Re-edit the translation
TranslationToadlet.remove=Remove
TranslationToadlet.removeOverrideTitle=Remove a translation override key
TranslationToadlet.removeOverrideWarningTitle=You are about to remove a translation override key!
TranslationToadlet.returnToTranslations=Return to the translation page
TranslationToadlet.selectTranslation=Select translation
TranslationToadlet.showEverything=Show everything, including already translated strings
TranslationToadlet.showTranslationOf=Show the translation of :
TranslationToadlet.translationKeyLabel=Translation key
TranslationToadlet.translationUpdateTitle=Translation update
TranslationToadlet.translationUpdatedTitle=Translation updated!
TranslationToadlet.updateTranslationCommand=Update the translation!
UndetectableCharsetException.title=Could not detect charset, looks like ${charset} but isn't
UndetectableCharsetException.explanation=Detected first few bytes of charset declaration but is invalid, ignoring the style sheet as per CSS 2.1 section 4.4.
UnknownContentTypeException.explanation=Your Freenet node does not know anything about the type ${type}. This means that your browser might do something dangerous in response to downloading this file. For example, many formats can contain embedded images or videos, which are downloaded from the web; this is by no means innocuous, because they can ruin your anonymity and expose your IP address (if the attacker runs the web site or has access to its logs). Hyperlinks to the Web can also be a threat, for much the same reason, as can scripting, for this and other reasons.
UnknownContentTypeException.title=Unknown and potentially dangerous content type: ${type}
UnsupportedCharsetInFilterException.title=Unsupported text character set: ${charset}.
UnsupportedCharsetInFilterException.explanation=This is a very rare character set, not supported by Java, and it is quite likely that this is an attempt to bypass the content filter, or just corrupt data.
UpdateDeployContext.cannotUpdateNoMainJar=Could not find freenet.jar in wrapper.conf
UpdateDeployContext.updateCatastrophe=CATASTROPHIC ERROR: Deleted ${old} but cannot rename ${new} to ${old} therefore FREENET WILL NOT START! Please resolve the problem by renaming ${new} to ${old} manually.
UpdateDeployContext.updateFailedCannotDeleteOldConfig=Cannot delete ${old} so cannot rename over it. Update failed.
UpdateDeployContext.updateFailedNonStandardConfig=Not able to update because of non-standard config: written main=${main} - should not happen! Report this to the devs, include your wrapper.conf.
UpdatedVersionAvailableUserAlert.armed=Your node will automatically restart as soon as it has finished downloading and verifying the new version of Freenet.
UpdatedVersionAvailableUserAlert.changelog=Release announcement
UpdatedVersionAvailableUserAlert.devchangelog=Developer details
UpdatedVersionAvailableUserAlert.clickToUpdateASAP=Click below to update your node as soon as the update has been verified.
UpdatedVersionAvailableUserAlert.clickToUpdateNow=Click below to update your node immediately.
UpdatedVersionAvailableUserAlert.brokenDependencies=There has been some sort of problem fetching the jars required for the next version, so Freenet cannot update itself to build ${version}. However, if it finds a later version, it will try again. You can see more details in wrapper.log.
UpdatedVersionAvailableUserAlert.downloadedNewJar=Your node has downloaded a new version of Freenet, version ${version}.
UpdatedVersionAvailableUserAlert.fetchingNewNode=Your node is currently downloading a new version of Freenet (node version ${nodeVersion}).
UpdatedVersionAvailableUserAlert.fetchingUOM=Freenet is downloading a new version from your peers. Your copy of Freenet is seriously out of date, so your peers may not show up as connected, but we can still fetch the update from them. This can take up to an hour. In the meantime you may not be able to use Freenet normally. If all else fails you can try the update script ${updateScript} but it is much safer to wait for the update.
UpdatedVersionAvailableUserAlert.finalCheck=Your node is currently doing a final check to verify the security of the update (${count} of ${max}, maximum time remaining ${time}).
UpdatedVersionAvailableUserAlert.notLatest=It seems that your node isn't running the latest version of the software.
UpdatedVersionAvailableUserAlert.shortArmed=Your node is downloading a new version of Freenet and will restart once it has it.
UpdatedVersionAvailableUserAlert.shortReadyNotArmed=Your node has downloaded a new version of Freenet but needs your permission to use the new build.
UpdatedVersionAvailableUserAlert.shortNotReadyNotArmed=Your node is downloading a new version of Freenet but needs permission to use the new build.
UpdatedVersionAvailableUserAlert.title=A new stable version of Freenet is available
UpdatedVersionAvailableUserAlert.updateASAPButton=Update ASAP
UpdatedVersionAvailableUserAlert.updateASAPQuestion=Would you like Freenet to automatically restart as soon as it has downloaded the update?
UpdatedVersionAvailableUserAlert.updateNowButton=Update Now!
UpdatedVersionAvailableUserAlert.updateIsUrgent=Please update soon, or your Freenet node may be left behind, unable to talk to the rest of the network!
UserAlert.apply=Apply
UserAlert.hide=Hide
UserAlert.reset=Reset
UserAlertManager.alertsOnAlertsPage=See them on ${link}the alerts page${/link}.
UserAlertManager.alertsTitle=Outstanding alerts
UserAlertManager.clickForMore=Click on an item for more information or to get rid of it.
UserAlertManager.criticalErrorCountLabel=Critical Errors:
UserAlertManager.dumpEventsButton=Remove trivial notifications
UserAlertManager.errorCountLabel=Errors:
UserAlertManager.feedTitle=Freenet
UserAlertManager.minorCountLabel=Minor:
UserAlertManager.totalLabel=Total:
UserAlertManager.warningCountLabel=Warnings:
UserAlertsToadlet.title=Status messages
UserAlertsToadlet.noMessages=No messages
WelcomeToadlet.activityTitle=Current Activity
WelcomeToadlet.arkFetchCount=ARK Fetchers: ${total}
WelcomeToadlet.alertsSummary=Status messages summary (click for details or to change something)
WelcomeToadlet.confirmAddBookmarkSubTitle=Confirm Bookmark Addition
WelcomeToadlet.confirmAddBookmarkTitle=Add a Bookmark
WelcomeToadlet.confirmAddBookmarkWithKey=Please confirm that you want to add the key ${key}  to your bookmarks and enter the description that you would prefer:
WelcomeToadlet.confirmExternalLinkSubTitle=Confirm external link
WelcomeToadlet.confirmExternalLinkTitle=WARNING: External link
WelcomeToadlet.confirmExternalLinkWithURL=Please confirm that you want to go to ${url}. WARNING: You are leaving FREENET! Clicking on this link WILL seriously jeopardize your anonymity! It is strongly recommended not to do so!
WelcomeToadlet.confirmFIN=Do you want to insert the following Frost message?
WelcomeToadlet.disabledAlert=Disabled alert
WelcomeToadlet.extVersion=Freenet-ext Build #${build} r${rev}
WelcomeToadlet.fetch=Fetch
WelcomeToadlet.fetchKeyLabel=Visit a freesite or download a file (if you know the key)
WelcomeToadlet.finInsertSuccessWithKey=The message has been inserted successfully into ${key}.
WelcomeToadlet.finInsertedTitle=Insertion
WelcomeToadlet.finTitle=Frost Instant Note insert
WelcomeToadlet.fromHeader=From
WelcomeToadlet.goToExternalLink=Go to the specified link
WelcomeToadlet.homepageFullTitle=Freenet
WelcomeToadlet.ieWarning=You appear to be using Microsoft Internet Explorer. This means that some sites within Freenet may be able to compromise your anonymity!
WelcomeToadlet.ieWarningTitle=Security Risk!
WelcomeToadlet.insertCount=Inserts: ${total}
WelcomeToadlet.insertFailedTitle=Insert Failed
WelcomeToadlet.insertFailedWithMessage=The insert failed with the message: ${message}
WelcomeToadlet.insertSucceededTitle=Insert Succeeded
WelcomeToadlet.insertedTitle=Insertion
WelcomeToadlet.invalidURI=Invalid URI!
WelcomeToadlet.invalidURILong=This URI doesn't look like a valid freenet key!
WelcomeToadlet.keyInsertedSuccessfullyWithKeyAndName=The key ${link}${name}${/link} has been inserted successfully.
WelcomeToadlet.keyRequestLabel=Key:
WelcomeToadlet.messageHeader=Message
WelcomeToadlet.nodeUpdateConfirm=Are you sure you wish to update your Freenet node?
WelcomeToadlet.nodeUpdateConfirmTitle=Confirm Node Update
WelcomeToadlet.privateKeyHeader=Private Key
WelcomeToadlet.publicKeyHeader=Public Key
WelcomeToadlet.requestCount=Requests: ${total}
WelcomeToadlet.restart=Restart
WelcomeToadlet.restartConfirm=Are you sure you want to restart your Freenet node?
WelcomeToadlet.restartConfirmTitle=Node Restart
WelcomeToadlet.restartNode=Restart Freenet
WelcomeToadlet.restarting=Please wait a moment while your Freenet node is being restarted.  This screen should refresh automatically.  Thank you for using Freenet.
WelcomeToadlet.restartingTitle=The Freenet node is being restarted.
WelcomeToadlet.searchBoxLabel=Search Freenet (experimental)
WelcomeToadlet.searchBoxWarningSlow=Searching can be slow and unreliable, so this will open a new window. You should have a look at the bookmarks while you wait for the search. WARNING: This search, like the rest of Freenet, is not filtered, and could find offensive or illegal content. Be careful!
WelcomeToadlet.searchPluginNotLoaded=The plugin needed to search Freenet is not loaded. Please load Library on ${link}the Plugins page${/link}.
WelcomeToadlet.searchPluginLoading=The plugin needed to search Freenet is not yet loaded, probably because it is being updated. Please reload the page a few times, or go to ${link}the Plugins page${/link} to see the current progress.
WelcomeToadlet.searchFreenet=Search Freenet!
WelcomeToadlet.shutdown=Shutdown
WelcomeToadlet.shutdownConfirm=Are you sure you wish to shut down your Freenet node?
WelcomeToadlet.shutdownConfirmTitle=Node Shutdown
WelcomeToadlet.shutdownDone=The Freenet node is being shut down.
WelcomeToadlet.shutdownNode=Shutdown Freenet
WelcomeToadlet.splitfileErrorLabel=Splitfile-specific error:
WelcomeToadlet.startIndexHeader=Index to start at
WelcomeToadlet.subjectHeader=Subject
WelcomeToadlet.targetBoardHeader=Target Board
WelcomeToadlet.testnetWarning=runs in testnet mode. This WILL seriously jeopardize your anonymity!
WelcomeToadlet.testnetWarningTitle=Testnet Mode
WelcomeToadlet.thanks=Thank you for using Freenet.
WelcomeToadlet.threadDumpNotUsingWrapper=It's not possible to make Freenet generate a thread dump if you aren't using the wrapper!
WelcomeToadlet.threadDumpSubTitle=Thread Dump generation
WelcomeToadlet.threadDumpTitle=Get a Thread Dump
WelcomeToadlet.threadDumpWithFilename=A thread dump has been generated, it's available in ${filename}.
WelcomeToadlet.transferringRequestCount=Transferring Requests: ${total}
WelcomeToadlet.update=Update
WelcomeToadlet.updating=The Freenet node is being updated and will self-restart. The restart process may take up to 10 minutes, because Freenet will try to fetch a revocation key before updating.
WelcomeToadlet.updatingTitle=Node Updating
WelcomeToadlet.uriWouldHaveBeen=The URI would have been: ${uri}
WelcomeToadlet.version=Freenet ${fullVersion} Build #${build} ${rev}
WelcomeToadlet.versionHeader=Version Information & Node Control
WrapperConfig.wrapper.java.maxmemory.short=Maximum memory usage (in megabytes)
WrapperConfig.wrapper.java.maxmemory.long=Limit on memory used by Freenet. Freenet will need more memory if you have more queued requests, or use chat forums and other plugins, and to a lesser extent if you have a larger datastore or a fast connection. Changes will not take effect until Freenet has been restarted.
fproxy.push.hide=Hide
fproxy.push.show=Show
fproxy.push.imageprogress=Image loading progress:
fproxy.push.pushingCancelled=Pushing cancelled
End
