import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
void sendRelayCellTo(RelayCell cell, CircuitNode targetNode) {
	relaySendLock.lock();
	try {
		logRelayCell("Sending:     ", cell);
		cell.setLength();
		targetNode.updateForwardDigest(cell);
		cell.setDigest(targetNode.getForwardDigestBytes());

		for(CircuitNode node = targetNode; node != null; node = node.getPreviousNode())
			node.encryptForwardCell(cell);

		if(cell.getRelayCommand() == RelayCell.RELAY_DATA) 
			targetNode.waitForSendWindowAndDecrement();
		
		sendCell(cell);
	} finally {
		relaySendLock.unlock();
	}
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
void sendRelayCellTo(RelayCell cell, CircuitNode targetNode) {
	synchronized(relaySendLock) {
		logRelayCell("Sending:     ", cell);
		cell.setLength();
		targetNode.updateForwardDigest(cell);
		cell.setDigest(targetNode.getForwardDigestBytes());

		for(CircuitNode node = targetNode; node != null; node = node.getPreviousNode())
			node.encryptForwardCell(cell);

		if(cell.getRelayCommand() == RelayCell.RELAY_DATA) 
			targetNode.waitForSendWindowAndDecrement();
		
		sendCell(cell);
	}
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
CircuitNode extendTo() {
	final byte[] onion = kex.createOnionSkin();
	if(finalRouterSupportsExtend2()) {
		logger.fine("Extending circuit to "+ router.getNickname() + " with NTor inside RELAY_EXTEND2");
		return extendWithExtend2(onion);
	} else {
		logger.fine("Extending circuit to "+ router.getNickname() + " with NTor inside RELAY_EXTEND");
		return extendWithTunneledExtend(onion);
	}
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private CircuitNode processExtended2(RelayCell cell) {
	final int payloadLength = cell.getShort();
	if(payloadLength > cell.cellBytesRemaining()) {
		throw new TorException("Incorrect payload length value in RELAY_EXTENED2 cell");
	}
	byte[] payload = new byte[payloadLength];
	cell.getByteArray(payload);

	return processPayload(payload);
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private CircuitNode processPayload(byte[] payload) {
	final byte[] keyMaterial = new byte[CircuitNodeCryptoState.KEY_MATERIAL_SIZE];
	final byte[] verifyDigest = new byte[TorMessageDigest.TOR_DIGEST_SIZE];
	if(!kex.deriveKeysFromHandshakeResponse(payload, keyMaterial, verifyDigest)) {
		return null;
	}
	return extender.createNewNode(router, keyMaterial, verifyDigest);
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private void buildCircuit(Router firstRouter) throws TorException {
	notifyInitialization();
	final CircuitNode firstNode = extender.createFastTo(firstRouter);
	creationRequest.nodeAdded(firstNode);
	
	for(int i = 1; i < creationRequest.getPathLength(); i++) {
		final CircuitNode extendedNode = extender.extendTo(creationRequest.getPathElement(i));
		creationRequest.nodeAdded(extendedNode);
	}
	creationRequest.circuitBuildCompleted(circuit);
	notifyDone();
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
protected String pathToString() {
	final StringBuilder sb = new StringBuilder();
	sb.append("[");
	for(CircuitNode node: nodeList) {
		if(sb.length() > 1)
			sb.append(",");
		sb.append(node.toString());
	}
	sb.append("]");
	return sb.toString();
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
public RelayCellImpl(CircuitNode node, int circuit, int stream, int relayCommand, boolean isRelayEarly) {
	super(circuit, (isRelayEarly) ? (Cell.RELAY_EARLY) : (Cell.RELAY));
	this.circuitNode = node;
	this.relayCommand = relayCommand;
	this.streamId = stream;
	this.isOutgoing = true;
	putByte(relayCommand);	// Command
	putShort(0);			// 'Recognized'
	putShort(stream);		// Stream
	putInt(0);				// Digest
	putShort(0);			// Length	
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private CircuitNodeImpl(Router router, CircuitNode previous, CircuitNodeCryptoState cryptoState) {
	previousNode = previous;
	this.router = router;
	this.cryptoState = cryptoState;
	windowLock = new Object();
	packageWindow = CIRCWINDOW_START;
	deliverWindow = CIRCWINDOW_START;
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
public HiddenServiceCircuit connectHiddenService(CircuitNode node) {
	if(type != InternalType.UNUSED) {
		throw new IllegalStateException("Cannot connect hidden service from internal circuit type "+ type);
	}
	appendNode(node);
	type = InternalType.HS_CIRCUIT;
	return this;
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private CircuitNode receiveAndProcessCreateFastResponse(Router targetRouter, TorKeyAgreement kex) {
	final Cell cell = circuit.receiveControlCellResponse();
	if(cell == null) {
		throw new TorException("Timeout building circuit waiting for CREATE_FAST response from "+ targetRouter);
	}

	return processCreatedFastCell(targetRouter, cell, kex);
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private CircuitNode processCreatedFastCell(Router targetRouter, Cell cell, TorKeyAgreement kex) {
	final byte[] payload = new byte[TorMessageDigest.TOR_DIGEST_SIZE * 2];
	final byte[] keyMaterial = new byte[CircuitNodeCryptoState.KEY_MATERIAL_SIZE];
	final byte[] verifyHash = new byte[TorMessageDigest.TOR_DIGEST_SIZE];
	cell.getByteArray(payload);
	if(!kex.deriveKeysFromHandshakeResponse(payload, keyMaterial, verifyHash)) {
		// XXX
		return null;
	}
	final CircuitNode node = CircuitNodeImpl.createFirstHop(targetRouter, keyMaterial, verifyHash);
	circuit.appendNode(node);
	return node;
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
CircuitNode extendTo(Router targetRouter) {
	if(circuit.getCircuitLength() == 0) {
		throw new TorException("Cannot EXTEND an empty circuit");
	}
	
	if(useNtor(targetRouter)) {
		final NTorCircuitExtender nce = new NTorCircuitExtender(this, targetRouter);
		return nce.extendTo();
	} else {
		final TapCircuitExtender tce = new TapCircuitExtender(this, targetRouter);
		return tce.extendTo();
	}
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private String nodeToName(CircuitNode node) {
	if(node == null || node.getRouter() == null) {
		return "(null)";
	}
	final Router router = node.getRouter();
	return router.getNickname();
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
public CircuitNode createNewNode(Router r, byte[] keyMaterial, byte[] verifyDigest) {
	final CircuitNode node = CircuitNodeImpl.createNode(r, circuit.getFinalCircuitNode(), keyMaterial, verifyDigest);
	logger.fine("Adding new circuit node for "+ r.getNickname());
	circuit.appendNode(node);
	return node;

}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
Router getFinalRouter() {
	final CircuitNode node = circuit.getFinalCircuitNode();
	if(node != null) {
		return node.getRouter();
	} else {
		return null;
	}
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private RelayCell decryptRelayCell(Cell cell) {
	for(CircuitNode node: circuit.getNodeList()) {
		if(node.decryptBackwardCell(cell)) {
			return RelayCellImpl.createFromCell(node, cell);
		}
	}
	destroyCircuit();
	throw new TorException("Could not decrypt relay cell");
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
public CircuitNode extendTo() {
	logger.fine("Extending to "+ router.getNickname() + " with TAP");
	final RelayCell cell = createRelayExtendCell();
	extender.sendRelayCell(cell);
	final RelayCell response = extender.receiveRelayResponse(RelayCell.RELAY_EXTENDED, router);
	if(response == null) {
		return null;
	}
	return processExtendResponse(response);
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
private CircuitNode processExtendResponse(RelayCell response) {
	final byte[] handshakeResponse = new byte[TorTapKeyAgreement.DH_LEN + TorMessageDigest.TOR_DIGEST_SIZE];
	response.getByteArray(handshakeResponse);
	
	final byte[] keyMaterial = new byte[CircuitNodeCryptoState.KEY_MATERIAL_SIZE];
	final byte[] verifyDigest = new byte[TorMessageDigest.TOR_DIGEST_SIZE];
	if(!kex.deriveKeysFromHandshakeResponse(handshakeResponse, keyMaterial, verifyDigest)) {
		return null;
	}
	return extender.createNewNode(router, keyMaterial, verifyDigest);
}
 

import com.subgraph.orchid.CircuitNode; //导入依赖的package包/类
StreamImpl(CircuitImpl circuit, CircuitNode targetNode, int streamId, boolean autoclose) {
	this.circuit = circuit;
	this.targetNode = targetNode;
	this.streamId = streamId;
	this.autoclose = autoclose;
	this.inputStream = new TorInputStream(this);
	this.outputStream = new TorOutputStream(this);
	packageWindow = STREAMWINDOW_START;
	deliverWindow = STREAMWINDOW_START;
}