import com.subgraph.orchid.Cell; //导入依赖的package包/类
public void sendCell(Cell cell) throws ConnectionIOException  {
	if(!socket.isConnected()) {
		throw new ConnectionIOException("Cannot send cell because connection is not connected");
	}
	updateLastActivity();
	outputLock.lock();
	try {
		try {
			output.write(cell.getCellBytes());
		} catch (IOException e) {
			logger.fine("IOException writing cell to connection "+ e.getMessage());
			closeSocket();
			throw new ConnectionIOException(e.getClass().getName() + " : "+ e.getMessage());
		}
	} finally {
		outputLock.unlock();
	}
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
void recvCerts() throws ConnectionHandshakeException  {
	final Cell cell = expectCell(Cell.CERTS);
	final int ncerts = cell.getByte();
	if(ncerts != 2) {
		throw new ConnectionHandshakeException("Expecting 2 certificates and got "+ ncerts);
	}

	linkCertificate = null;
	identityCertificate = null;
	
	for(int i = 0; i < ncerts; i++) {
		int type = cell.getByte();
		if(type == 1) {
			linkCertificate = testAndReadCertificate(cell, linkCertificate, "Link (type = 1)");
		} else if(type == 2) {
			identityCertificate = testAndReadCertificate(cell, identityCertificate, "Identity (type = 2)");
		} else {
			throw new ConnectionHandshakeException("Unexpected certificate type = "+ type + " in CERTS cell");
		}
	}
	
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
public RelayCell receiveRelayResponse(int expectedCommand, Router extendTarget) {
	final RelayCell cell = circuit.receiveRelayCell();
	if(cell == null) {
		throw new TorException("Timeout building circuit");
	}
	final int command = cell.getRelayCommand();
	if(command == RelayCell.RELAY_TRUNCATED) {
		final int code = cell.getByte() & 0xFF;
		final String msg = CellImpl.errorToDescription(code);
		final String source = nodeToName(cell.getCircuitNode());
		if(code == Cell.ERROR_PROTOCOL) {
			logProtocolViolation(source, extendTarget);
		}
		throw new TorException("Error from ("+ source +") while extending to ("+ extendTarget.getNickname() + "): "+ msg);
	} else if(command != expectedCommand) {
		final String expected = RelayCellImpl.commandToDescription(expectedCommand);
		final String received = RelayCellImpl.commandToDescription(command);
		throw new TorException("Received incorrect extend response, expecting "+ expected + " but received "+ received);
	} else {
		return cell;
	}
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
private ByteBuffer createIntroductionBuffer(int timestamp, Router rr, byte[] cookie, byte[] dhPublic) {
	final ByteBuffer buffer = ByteBuffer.allocate(Cell.CELL_LEN);
	final byte[] rpAddress = rr.getAddress().getAddressDataBytes();
	final short rpPort = (short) rr.getOnionPort();
	final byte[] rpIdentity = rr.getIdentityHash().getRawBytes();
	final byte[] rpOnionKey = rr.getOnionKey().getRawBytes();
	
	buffer.put((byte) INTRODUCTION_PROTOCOL_VERSION);  // VER    Version byte: set to 3.        [1 octet]
	addAuthentication(buffer);
	//buffer.put((byte) 0);                              // AUTHT  The auth type that is used     [1 octet]
	buffer.putInt(timestamp);                          // TS     A timestamp                   [4 octets]
	buffer.put(rpAddress);                             // IP     Rendezvous point's address    [4 octets]
	buffer.putShort(rpPort);                           // PORT   Rendezvous point's OR port    [2 octets]
	buffer.put(rpIdentity);                            // ID     Rendezvous point identity ID [20 octets]
	buffer.putShort((short) rpOnionKey.length);		   // KLEN   Length of onion key           [2 octets]
	buffer.put(rpOnionKey); 		                   // KEY    Rendezvous point onion key [KLEN octets]
	buffer.put(cookie); 		                       // RC     Rendezvous cookie            [20 octets]
	buffer.put(dhPublic); 		                       // g^x    Diffie-Hellman data, part 1 [128 octets]
	
	return buffer;
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
public ConnectionImpl(TorConfig config, SSLSocket socket, Router router, TorInitializationTracker tracker, boolean isDirectoryConnection) {
	this.config = config;
	this.socket = socket;
	this.router = router;
	this.circuitMap = new HashMap<Integer, Circuit>();
	this.readCellsThread = new Thread(createReadCellsRunnable());
	this.readCellsThread.setDaemon(true);
	this.connectionControlCells = new LinkedBlockingQueue<Cell>();
	this.initializationTracker = tracker;
	this.isDirectoryConnection = isDirectoryConnection;
	initializeCurrentCircuitId();
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
Cell readConnectionControlCell() throws ConnectionIOException {
	try {
		return connectionControlCells.take();
	} catch (InterruptedException e) {
		closeSocket();
		throw new ConnectionIOException();
	}
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
private void processCell(Cell cell) {
	updateLastActivity();
	final int command = cell.getCommand();

	if(command == Cell.RELAY) {
		processRelayCell(cell);
		return;
	}

	switch(command) {
	case Cell.NETINFO:
	case Cell.VERSIONS:
	case Cell.CERTS:
	case Cell.AUTH_CHALLENGE:
		connectionControlCells.add(cell);
		break;

	case Cell.CREATED:
	case Cell.CREATED_FAST:
	case Cell.DESTROY:
		processControlCell(cell);
		break;
	default:
		// Ignore everything else
		break;
	}
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
private void processRelayCell(Cell cell) {
	Circuit circuit;
	circuitsLock.lock();
	try {
		circuit = circuitMap.get(cell.getCircuitId());
		if(circuit == null) {
			logger.warning("Could not deliver relay cell for circuit id = "+ cell.getCircuitId() +" on connection "+ this +". Circuit not found");
			return;
		}
	} finally {
		circuitsLock.unlock();
	}

	circuit.deliverRelayCell(cell);
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
private void processControlCell(Cell cell) {
	Circuit circuit;
	circuitsLock.lock();
	try {
		circuit = circuitMap.get(cell.getCircuitId());
	} finally {
		circuitsLock.unlock();
	}

	if(circuit != null) {
		circuit.deliverControlCell(cell);
	}
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
private X509Certificate testAndReadCertificate(Cell cell, X509Certificate currentValue, String type) throws ConnectionHandshakeException {
	if(currentValue == null) {
		return readCertificateFromCell(cell);
	} else {
		throw new ConnectionHandshakeException("Duplicate "+ type + " certificates in CERTS cell");
	}
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
private X509Certificate readCertificateFromCell(Cell cell) {
	try {
		final CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
		final int clen = cell.getShort();
		final byte[] certificateBuffer = new byte[clen];
		cell.getByteArray(certificateBuffer);
		final ByteArrayInputStream bis = new ByteArrayInputStream(certificateBuffer);
		return (X509Certificate) certificateFactory.generateCertificate(bis);
	} catch (CertificateException e) {
		return null;
	}
	
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
void recvAuthChallengeAndNetinfo() throws ConnectionHandshakeException {
	final Cell cell = expectCell(Cell.AUTH_CHALLENGE, Cell.NETINFO);
	if(cell.getCommand() == Cell.NETINFO) {
		processNetInfo(cell);
		return;
	}
	final Cell netinfo = expectCell(Cell.NETINFO);
	processNetInfo(netinfo);
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
protected Cell expectCell(Integer... expectedTypes) throws ConnectionHandshakeException {
	try {
		final Cell c = connection.readConnectionControlCell();
		for(int t: expectedTypes) {
			if(c.getCommand() == t) {
				return c;
			}
		}
		final List<Integer> expected = Arrays.asList(expectedTypes);
		throw new ConnectionHandshakeException("Expecting Cell command "+ expected + " and got [ "+ c.getCommand() +" ] instead");
	} catch (ConnectionIOException e) {
		throw new ConnectionHandshakeException("Connection exception while performing handshake "+ e);
	}
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
protected  void sendVersions(int... versions) throws ConnectionIOException {
	final Cell cell = CellImpl.createVarCell(0, Cell.VERSIONS, versions.length * 2);
	for(int v: versions) {
		cell.putShort(v);
	}
	connection.sendCell(cell);
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
protected void sendNetinfo() throws ConnectionIOException {
	final Cell cell = CellImpl.createCell(0, Cell.NETINFO);
	putTimestamp(cell);
	putIPv4Address(cell, connection.getRouter().getAddress());
	putMyAddresses(cell);
	connection.sendCell(cell);
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
protected void processNetInfo(Cell netinfoCell) {
	remoteTimestamp = netinfoCell.getInt();
	myAddress = readAddress(netinfoCell);
	final int addressCount = netinfoCell.getByte();
	for(int i = 0; i < addressCount; i++) {
		IPv4Address addr = readAddress(netinfoCell);
		if(addr != null) {
			remoteAddresses.add(addr);
		}
	}
}
 

import com.subgraph.orchid.Cell; //导入依赖的package包/类
private IPv4Address readAddress(Cell cell) {
	final int type = cell.getByte();
	final int len = cell.getByte();
	if(type == Cell.ADDRESS_TYPE_IPV4 && len == 4) {
		return new IPv4Address(cell.getInt());
	}
	final byte[] buffer = new byte[len];
	cell.getByteArray(buffer);
	return null;
}
 

import com.subgraph.orchid.Cell; //导入依赖的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.Cell; //导入依赖的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.Cell; //导入依赖的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;
}