/** * 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); }