/**
* Get a set of introduction puzzle IDs which the given own identity might solve.
*
* <p>The puzzle's data is not returned because when generating HTML for displaying the puzzles we
* must reference them with a IMG-tag and we cannot embed the data of the puzzles in the IMG-tag
* because embedding image-data has only recently been added to browsers and many do not support
* it yet.
*
* @param ownIdentity The identity which wants to solve the puzzles.
* @param amount The amount of puzzles to request.
* @return A list of the IDs of the puzzles. The amount might be less than the requested amount
* and even zero if WoT has not downloaded puzzles yet.
* @throws Exception
*/
public List<String> getIntroductionPuzzles(WoTOwnIdentity ownIdentity, int amount)
throws Exception {
ArrayList<String> puzzleIDs = new ArrayList<String>(amount + 1);
SimpleFieldSet params = new SimpleFieldSet(true);
params.putOverwrite("Message", "GetIntroductionPuzzles");
params.putOverwrite("Identity", ownIdentity.getID());
params.putOverwrite("Type", "Captcha"); // TODO: Don't hardcode the String
params.put("Amount", amount);
try {
SimpleFieldSet result = sendFCPMessageBlocking(params, null, "IntroductionPuzzles").params;
for (int idx = 0; ; idx++) {
String id = result.get("Puzzle" + idx);
if (id == null
|| id.equals("")) /* TODO: Figure out whether the second condition is necessary */
break;
puzzleIDs.add(id);
}
} catch (PluginNotFoundException e) {
Logger.error(this, "Getting puzzles failed", e);
}
return puzzleIDs;
}
private synchronized void addFreetalkContext(WoTIdentity oid) throws Exception {
SimpleFieldSet params = new SimpleFieldSet(true);
params.putOverwrite("Message", "AddContext");
params.putOverwrite("Identity", oid.getID());
params.putOverwrite("Context", Freetalk.WOT_CONTEXT);
sendFCPMessageBlocking(params, null, "ContextAdded");
}
/**
* Not synchronized, the involved identity might be deleted during the query - which is not really
* a problem.
*/
public List<WoTTrust> getReceivedTrusts(Identity trustee) throws Exception {
List<WoTTrust> result = new ArrayList<WoTTrust>();
SimpleFieldSet request = new SimpleFieldSet(true);
request.putOverwrite("Message", "GetTrusters");
request.putOverwrite("Context", "");
request.putOverwrite("Identity", trustee.getID());
try {
SimpleFieldSet answer = sendFCPMessageBlocking(request, null, "Identities").params;
for (int idx = 0; ; idx++) {
String id = answer.get("Identity" + idx);
if (id == null
|| id.equals("")) /* TODO: Figure out whether the second condition is necessary */
break;
try {
final WoTTrust trust =
new WoTTrust(
getIdentity(id),
trustee,
(byte) Integer.parseInt(answer.get("Value" + idx)),
answer.get("Comment" + idx));
mWoTCache.putTrust(trust);
result.add(trust);
} catch (NoSuchIdentityException e) {
} catch (InvalidParameterException e) {
}
}
} catch (PluginNotFoundException e) {
throw new WoTDisconnectedException();
}
return result;
}
/**
* Register the frirc context with an identity of your own
*
* @param own_identity
*/
public void addOwnIdentityContext(Map<String, String> own_identity) {
SimpleFieldSet sfs = new SimpleFieldSet(true);
sfs.putOverwrite("Message", "AddContext");
sfs.putOverwrite("Identity", own_identity.get("Identity"));
sfs.putOverwrite("Context", "FrIRC");
talker.send(sfs, null);
}
/**
* Not synchronized, the involved identities might be deleted during the query - which is not
* really a problem.
*/
private String getProperty(OwnIdentity truster, Identity target, String property)
throws Exception {
SimpleFieldSet sfs = new SimpleFieldSet(true);
sfs.putOverwrite("Message", "GetIdentity");
sfs.putOverwrite("Truster", truster.getID());
sfs.putOverwrite("Identity", target.getID());
return sendFCPMessageBlocking(sfs, null, "Identity").params.get(property);
}
public void solveIntroductionPuzzle(WoTOwnIdentity ownIdentity, String puzzleID, String solution)
throws Exception {
SimpleFieldSet params = new SimpleFieldSet(true);
params.putOverwrite("Message", "SolveIntroductionPuzzle");
params.putOverwrite("Identity", ownIdentity.getID());
params.putOverwrite("Puzzle", puzzleID);
params.putOverwrite("Solution", solution);
sendFCPMessageBlocking(params, null, "PuzzleSolved");
}
/**
* Not synchronized, the involved identity might be deleted during the query - which is not really
* a problem.
*/
public int getReceivedTrustsCount(Identity trustee) throws Exception {
SimpleFieldSet request = new SimpleFieldSet(true);
request.putOverwrite("Message", "GetTrustersCount");
request.putOverwrite("Identity", trustee.getID());
request.putOverwrite("Context", Freetalk.WOT_CONTEXT);
try {
SimpleFieldSet answer = sendFCPMessageBlocking(request, null, "TrustersCount").params;
return Integer.parseInt(answer.get("Value"));
} catch (PluginNotFoundException e) {
throw new WoTDisconnectedException();
}
}
public synchronized WoTOwnIdentity createOwnIdentity(
String newNickname,
boolean publishesTrustList,
boolean publishesIntroductionPuzzles,
boolean autoSubscribeToNewBoards,
boolean displayImages)
throws Exception {
Logger.normal(this, "Creating new own identity via FCP, nickname: " + newNickname);
SimpleFieldSet params = new SimpleFieldSet(true);
params.putOverwrite("Message", "CreateIdentity");
params.putOverwrite("Nickname", newNickname);
params.putOverwrite("PublishTrustList", publishesTrustList ? "true" : "false");
params.putOverwrite(
"PublishIntroductionPuzzles", publishesIntroductionPuzzles ? "true" : "false");
params.putOverwrite("Context", Freetalk.WOT_CONTEXT);
PluginTalkerBlocking.Result result = sendFCPMessageBlocking(params, null, "IdentityCreated");
WoTOwnIdentity identity =
new WoTOwnIdentity(
result.params.get("ID"),
new FreenetURI(result.params.get("RequestURI")),
new FreenetURI(result.params.get("InsertURI")),
newNickname,
autoSubscribeToNewBoards,
displayImages);
identity.initializeTransient(mFreetalk);
Logger.normal(this, "Created WoTOwnidentity via FCP, now storing... " + identity);
synchronized (mFreetalk.getTaskManager()) { // Required by onNewOwnidentityAdded
synchronized (db.lock()) {
try {
identity.initializeTransient(mFreetalk);
identity.storeWithoutCommit();
onNewOwnIdentityAdded(identity);
identity.checkedCommit(this);
Logger.normal(this, "Stored new WoTOwnIdentity " + identity);
} catch (RuntimeException e) {
Persistent.checkedRollbackAndThrow(db, this, e);
}
}
}
return identity;
}
/**
* Not synchronized, the involved identities might be deleted during the query or some other WoT
* client might modify the trust value during the query - which is not really a problem, you
* should not be modifying trust values of your own identity with multiple clients simultaneously.
*/
public void setTrust(OwnIdentity truster, Identity trustee, byte trust, String comment)
throws Exception {
WoTOwnIdentity wotTruster = (WoTOwnIdentity) truster;
WoTIdentity wotTrustee = (WoTIdentity) trustee;
SimpleFieldSet request = new SimpleFieldSet(true);
request.putOverwrite("Message", "SetTrust");
request.putOverwrite("Truster", wotTruster.getID());
request.putOverwrite("Trustee", wotTrustee.getID());
request.putOverwrite("Value", Integer.toString(trust));
request.putOverwrite("Comment", comment);
sendFCPMessageBlocking(request, null, "TrustSet");
mWoTCache.putTrust(wotTruster, wotTrustee, trust);
}
/**
* Fetches the identities with positive score from WoT and stores them in the database.
*
* @throws Exception
*/
private void fetchIdentities() throws Exception {
// parseIdentities() acquires and frees the WoTIdentityManager-lock for each identity to allow
// other threads to access the identity manager while the
// parsing is in progress. Therefore, we do not take the lock for the whole execution of this
// function.
synchronized (this) {
if (mIdentityFetchInProgress) return;
long now = CurrentTimeUTC.getInMillis();
if ((now - mLastIdentityFetchTime) < MINIMAL_IDENTITY_FETCH_DELAY) return;
mIdentityFetchInProgress = true;
}
try {
Logger.normal(this, "Requesting identities with positive score from WoT ...");
SimpleFieldSet p1 = new SimpleFieldSet(true);
p1.putOverwrite("Message", "GetIdentitiesByScore");
p1.putOverwrite("Selection", "+");
p1.putOverwrite("Context", Freetalk.WOT_CONTEXT);
parseIdentities(sendFCPMessageBlocking(p1, null, "Identities").params, false);
synchronized (this) {
// We must update the fetch-time after the parsing and only if the parsing succeeded:
// If we updated before the parsing and parsing failed or took ages (the thread sometimes
// takes 2 hours to execute, don't ask me why)
// then the garbage collector would delete identities.
mLastIdentityFetchTime = CurrentTimeUTC.getInMillis();
}
} finally {
synchronized (this) {
mIdentityFetchInProgress = false;
}
}
// We usually call garbageCollectIdentities() after calling this function, it updates the cache
// already...
// if(mShortestUniqueNicknameCacheNeedsUpdate)
// updateShortestUniqueNicknameCache();
}
public synchronized WoTOwnIdentity createOwnIdentity(
String newNickname,
boolean publishesTrustList,
boolean publishesIntroductionPuzzles,
boolean autoSubscribeToNewBoards,
boolean displayImages,
FreenetURI newRequestURI,
FreenetURI newInsertURI)
throws Exception {
Logger.normal(this, "Creating new own identity via FCP, nickname: " + newNickname);
SimpleFieldSet params = new SimpleFieldSet(true);
params.putOverwrite("Message", "CreateIdentity");
params.putOverwrite("Nickname", newNickname);
params.putOverwrite("PublishTrustList", publishesTrustList ? "true" : "false");
params.putOverwrite(
"PublishIntroductionPuzzles",
publishesTrustList && publishesIntroductionPuzzles ? "true" : "false");
params.putOverwrite("Context", Freetalk.WOT_CONTEXT);
params.putOverwrite("RequestURI", newRequestURI.toString());
params.putOverwrite("InsertURI", newInsertURI.toString());
PluginTalkerBlocking.Result result = sendFCPMessageBlocking(params, null, "IdentityCreated");
/* We take the URIs which were returned by the WoT plugin instead of the requested ones because this allows the identity to work
* even if the WoT plugin ignores our requested URIs: If we just stored the URIs we requested, we would store an identity with
* wrong URIs which would result in the identity not being useable. */
WoTOwnIdentity identity =
new WoTOwnIdentity(
result.params.get("ID"),
new FreenetURI(result.params.get("RequestURI")),
new FreenetURI(result.params.get("InsertURI")),
newNickname,
autoSubscribeToNewBoards,
displayImages);
identity.initializeTransient(mFreetalk);
Logger.normal(this, "Created WoTOwnidentity via FCP, now storing... " + identity);
synchronized (mFreetalk.getTaskManager()) {
synchronized (db.lock()) {
try {
identity.storeWithoutCommit();
onNewOwnIdentityAdded(identity);
identity.checkedCommit(this);
Logger.normal(this, "Stored new WoTOwnIdentity " + identity);
} catch (RuntimeException e) {
Persistent.checkedRollback(db, this, e);
}
}
}
return identity;
}
private synchronized void sendFCPAllIdentities(Map<String, String> identity) {
PluginTalker talker;
try {
talker = pr.getPluginTalker(this, Frirc.WoT_NAMESPACE, "");
SimpleFieldSet sfs = new SimpleFieldSet(true);
sfs.putOverwrite("Message", "GetTrustees");
sfs.putOverwrite(
"Identity",
identity.get("ID")
.split(",")[
0]); // a personal identity (associated through source) (only pass the ID, not the
// full SSK)
sfs.putOverwrite(
"Context", "FrIRC"); // empty means selecting all identities no matter the context
talker.send(sfs, null); // send message to WoT plugin
if (Frirc.DEBUG)
System.out.println("requested identities for identity " + identity.get("ID").split(",")[0]);
} catch (PluginNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public IntroductionPuzzle getIntroductionPuzzle(String id) throws Exception {
SimpleFieldSet params = new SimpleFieldSet(true);
params.putOverwrite("Message", "GetIntroductionPuzzle");
params.putOverwrite("Puzzle", id);
try {
SimpleFieldSet result = sendFCPMessageBlocking(params, null, "IntroductionPuzzle").params;
try {
return new IntroductionPuzzle(
id, result.get("MimeType"), Base64.decodeStandard(result.get("Data")));
} catch (RuntimeException e) {
Logger.error(this, "Parsing puzzle failed", e);
} catch (IllegalBase64Exception e) {
Logger.error(this, "Parsing puzzle failed", e);
}
return null;
} catch (PluginNotFoundException e) {
Logger.error(this, "Getting puzzles failed", e);
return null;
}
}
// This is distinct from the ClientGetMessage code, as later on it will be radically
// different (it can store detailed state).
@Override
public synchronized SimpleFieldSet getFieldSet() {
SimpleFieldSet fs = new SimpleFieldSet(false); // we will need multi-level later...
fs.putSingle("Type", "GET");
fs.putSingle("URI", uri.toString(false, false));
fs.putSingle("Identifier", identifier);
fs.putSingle("Verbosity", Integer.toString(verbosity));
fs.putSingle("PriorityClass", Short.toString(priorityClass));
fs.putSingle("ReturnType", ClientGetMessage.returnTypeString(returnType));
fs.putSingle("Persistence", persistenceTypeString(persistenceType));
fs.putSingle("ClientName", client.name);
if (targetFile != null) fs.putSingle("Filename", targetFile.getPath());
if (tempFile != null) fs.putSingle("TempFilename", tempFile.getPath());
if (clientToken != null) fs.putSingle("ClientToken", clientToken);
fs.putSingle("IgnoreDS", Boolean.toString(fctx.ignoreStore));
fs.putSingle("DSOnly", Boolean.toString(fctx.localRequestOnly));
fs.putSingle("MaxRetries", Integer.toString(fctx.maxNonSplitfileRetries));
fs.putSingle("Finished", Boolean.toString(finished));
fs.putSingle("Succeeded", Boolean.toString(succeeded));
if (fctx.allowedMIMETypes != null)
fs.putOverwrite(
"AllowedMIMETypes",
(String[]) fctx.allowedMIMETypes.toArray(new String[fctx.allowedMIMETypes.size()]));
if (finished) {
if (succeeded) {
fs.putSingle("FoundDataLength", Long.toString(foundDataLength));
fs.putSingle("FoundDataMimeType", foundDataMimeType);
if (postFetchProtocolErrorMessage != null) {
fs.put("PostFetchProtocolError", postFetchProtocolErrorMessage.getFieldSet());
}
} else {
if (getFailedMessage != null) {
fs.put("GetFailed", getFailedMessage.getFieldSet(false));
}
}
}
// Return bucket
if (returnType == ClientGetMessage.RETURN_TYPE_DIRECT
&& !(succeeded == false && returnBucket == null)) {
bucketToFS(fs, "ReturnBucket", false, returnBucket);
}
fs.putSingle("Global", Boolean.toString(client.isGlobalQueue));
fs.put("BinaryBlob", binaryBlob);
fs.put("StartupTime", startupTime);
if (finished) fs.put("CompletionTime", completionTime);
return fs;
}
public void update() {
logMINOR = Logger.shouldLog(Logger.MINOR, this);
if (logMINOR) Logger.minor(this, "update()");
if (!checkIPUpdated()) return;
// We'll broadcast the new physical.udp entry to our connected peers via a differential node
// reference
// We'll err on the side of caution and not update our peer to an empty physical.udp entry using
// a differential node reference
SimpleFieldSet nfs = crypto.exportPublicFieldSet(false, false, true);
String[] entries = nfs.getAll("physical.udp");
if (entries != null) {
SimpleFieldSet fs = new SimpleFieldSet(true);
fs.putOverwrite("physical.udp", entries);
if (logMINOR)
Logger.minor(this, darknetOpennetString + " ref's physical.udp is '" + fs.toString() + "'");
node.peers.locallyBroadcastDiffNodeRef(fs, !crypto.isOpennet, crypto.isOpennet);
} else {
if (logMINOR) Logger.minor(this, darknetOpennetString + " ref's physical.udp is null");
}
// Proceed with inserting the ARK
if (logMINOR)
Logger.minor(this, "Inserting " + darknetOpennetString + " ARK because peers list changed");
if (inserter != null) {
// Already inserting.
// Re-insert after finished.
synchronized (this) {
shouldInsert = true;
}
return;
}
// Otherwise need to start an insert
if (node.noConnectedPeers()) {
// Can't start an insert yet
synchronized (this) {
shouldInsert = true;
}
return;
}
startInserter();
}
private synchronized boolean connectToWoT() {
if (mTalker != null) {
/* Old connection exists */
SimpleFieldSet sfs = new SimpleFieldSet(true);
sfs.putOverwrite("Message", "Ping");
try {
mTalker.sendBlocking(sfs, null); /* Verify that the old connection is still alive */
return true;
} catch (PluginNotFoundException e) {
mTalker = null;
/* Do not return, try to reconnect in next try{} block */
}
}
try {
mTalker = new PluginTalkerBlocking(mFreetalk.getPluginRespirator());
mFreetalk.handleWotConnected();
return true;
} catch (PluginNotFoundException e) {
mFreetalk.handleWotDisconnected();
return false;
}
}
/** Retrieve the personal WoT identities to associate with nicknames */
private void sendFCPOwnIdentities() {
SimpleFieldSet sfs = new SimpleFieldSet(true);
sfs.putOverwrite("Message", "GetOwnIdentities");
talker.send(sfs, null);
}