package Ymodem;
|
import java.awt.Color;
|
import java.io.*;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
|
class Modem {
|
|
/* Protocol characters used */
|
protected static final byte SOH = 0x01; /* Start Of Header */
|
protected static final byte STX = 0x02; /* Start Of Text (used like SOH but means 1024 block size) */
|
protected static final byte EOT = 0x04; /* End Of Transmission */
|
protected static final byte ACK = 0x06; /* ACKnowlege */
|
protected static final byte NAK = 0x15; /* Negative AcKnowlege */
|
protected static final byte CAN = 0x18; /* CANcel character */
|
|
protected static final byte CPMEOF = 0x1A;
|
protected static final byte ST_C = 'C';
|
|
protected static final int MAXERRORS = 10;
|
|
protected static final int BLOCK_TIMEOUT = 1000;
|
protected static final int REQUEST_TIMEOUT = 3000;
|
protected static final int WAIT_FOR_RECEIVER_TIMEOUT = 60_000;
|
protected static final int SEND_BLOCK_TIMEOUT = 10_000;
|
|
private final InputStream inputStream;
|
private final OutputStream outputStream;
|
|
private final byte[] shortBlockBuffer;
|
private final byte[] longBlockBuffer;
|
|
/**
|
* Constructor
|
*
|
* @param inputStream stream for reading received data from other side
|
* @param outputStream stream for writing data to other side
|
*/
|
protected Modem(InputStream inputStream, OutputStream outputStream) {
|
this.inputStream = inputStream;
|
this.outputStream = outputStream;
|
shortBlockBuffer = new byte[128];
|
longBlockBuffer = new byte[1024];
|
}
|
|
|
/**
|
* Wait for receiver request for transmission
|
*
|
* @param timer
|
* @return TRUE if receiver requested CRC-16 checksum, FALSE if 8bit checksum
|
* @throws IOException
|
*/
|
protected boolean waitReceiverRequest(Timer timer) throws IOException {
|
int character;
|
while (true) {
|
try {
|
character = readByte(timer);
|
if (character == NAK)
|
return false;
|
if (character == ST_C) {
|
return true;
|
}
|
} catch (TimeoutException e) {
|
|
}
|
}
|
}
|
|
|
/**
|
* Send a file. <br/>
|
* <p>
|
* This method support correct thread interruption, when thread is interrupted "cancel of transmission" will be send.
|
* So you can move long transmission to other thread and interrupt it according to your algorithm.
|
*
|
* @param file
|
* @param useBlock1K
|
* @throws IOException
|
*/
|
protected void send(Path file, boolean useBlock1K) throws IOException {
|
//open file
|
try (DataInputStream dataStream = new DataInputStream(Files.newInputStream(file))) {
|
Timer timer = new Timer(WAIT_FOR_RECEIVER_TIMEOUT).start();
|
|
boolean useCRC16 = waitReceiverRequest(timer);
|
CRC crc;
|
if (useCRC16)
|
crc = new CRC16();
|
else
|
crc = new CRC8();
|
|
byte[] block;
|
if (useBlock1K)
|
block = new byte[1024];
|
else
|
block = new byte[128];
|
sendDataBlocks(dataStream, 1, crc, block, dataStream.available());
|
|
sendEOT();
|
}
|
}
|
|
protected void sendDataBlocks(DataInputStream dataStream, int blockNumber, CRC crc, byte[] block, int zu) throws IOException {
|
int dataLength;
|
byte[] bytes = new byte[128];
|
int index = 0;
|
int aaa = zu/100;
|
int ccc = 0;
|
while ((dataLength = dataStream.read(block)) != -1) {
|
ccc += dataLength;
|
if(dataLength >128 && dataLength <=896){
|
while (index<dataLength){
|
System.arraycopy(block,index,bytes,0,Math.min(128,dataLength-index));
|
sendBlock(blockNumber++, bytes, Math.min(128,dataLength-index), crc);
|
index += 128;
|
}
|
}else if(dataLength <= 128){
|
System.arraycopy(block,0,bytes,0,dataLength);
|
sendBlock(blockNumber++, bytes, dataLength, crc);
|
}else {
|
sendBlock(blockNumber++, block, dataLength, crc);
|
}
|
}
|
}
|
|
protected void sendEOT() throws IOException {
|
int errorCount = 0;
|
Timer timer = new Timer(BLOCK_TIMEOUT);
|
int character;
|
while (errorCount < 10) {
|
sendByte(EOT);
|
try {
|
character = readByte(timer.start());
|
|
if (character == ACK) {
|
return;
|
} else if (character == CAN) {
|
throw new IOException("Transmission terminated");
|
}
|
} catch (TimeoutException ignored) {
|
}
|
errorCount++;
|
}
|
}
|
|
protected void sendBlock(int blockNumber, byte[] block, int dataLength, CRC crc) throws IOException {
|
int errorCount;
|
int character;
|
Timer timer = new Timer(SEND_BLOCK_TIMEOUT);
|
|
if (dataLength < block.length) {
|
for (int i=0;i<block.length-dataLength;i++){
|
block[dataLength+i] = CPMEOF;
|
}
|
}
|
errorCount = 0;
|
|
while (errorCount < MAXERRORS) {
|
timer.start();
|
|
if (block.length == 1024)
|
outputStream.write(STX);
|
else //128
|
outputStream.write(SOH);
|
outputStream.write(blockNumber);
|
outputStream.write(~blockNumber);
|
|
outputStream.write(block);
|
writeCRC(block, crc);
|
outputStream.flush();
|
|
while (true) {
|
try {
|
character = readByte(timer);
|
if (character == ACK) {
|
return;
|
} else if (character == NAK) {
|
errorCount++;
|
break;
|
} else if (character == CAN) {
|
|
}
|
} catch (TimeoutException e) {
|
errorCount++;
|
break;
|
}
|
}
|
|
}
|
|
}
|
|
private void writeCRC(byte[] block, CRC crc) throws IOException {
|
byte[] crcBytes = new byte[crc.getCRCLength()];
|
long crcValue = crc.calcCRC(block);
|
for (int i = 0; i < crc.getCRCLength(); i++) {
|
crcBytes[crc.getCRCLength() - i - 1] = (byte) ((crcValue >> (8 * i)) & 0xFF);
|
}
|
outputStream.write(crcBytes);
|
}
|
|
/**
|
* Receive file <br/>
|
* <p>
|
* This method support correct thread interruption, when thread is interrupted "cancel of transmission" will be send.
|
* So you can move long transmission to other thread and interrupt it according to your algorithm.
|
*
|
* @param file file path for storing
|
* @throws IOException
|
*/
|
protected void receive(Path file, boolean useCRC16) throws IOException {
|
try (DataOutputStream dataOutput = new DataOutputStream(Files.newOutputStream(file))) {
|
int available;
|
// clean input stream
|
if ((available = inputStream.available()) > 0) {
|
inputStream.skip(available);
|
}
|
|
int character = requestTransmissionStart(useCRC16);
|
|
CRC crc;
|
if (useCRC16)
|
crc = new CRC16();
|
else
|
crc = new CRC8();
|
|
|
processDataBlocks(crc, 1, character, dataOutput);
|
}
|
}
|
|
protected void processDataBlocks(CRC crc, int blockNumber, int blockInitialCharacter, DataOutputStream dataOutput) throws IOException {
|
// read blocks until EOT
|
boolean result = false;
|
boolean shortBlock;
|
byte[] block;
|
while (true) {
|
int errorCount = 0;
|
if (blockInitialCharacter == EOT) {
|
// end of transmission
|
sendByte(ACK);
|
return;
|
}
|
|
//read and process block
|
shortBlock = (blockInitialCharacter == SOH);
|
try {
|
block = readBlock(blockNumber, shortBlock, crc);
|
dataOutput.write(block);
|
blockNumber++;
|
errorCount = 0;
|
result = true;
|
sendByte(ACK);
|
} catch (TimeoutException | InvalidBlockException e) {
|
errorCount++;
|
if (errorCount == MAXERRORS) {
|
interruptTransmission();
|
throw new IOException("Transmission aborted, error count exceeded max");
|
}
|
sendByte(NAK);
|
result = false;
|
} catch (RepeatedBlockException e) {
|
//thats ok, accept and wait for next block
|
sendByte(ACK);
|
} catch (SynchronizationLostException e) {
|
//fatal transmission error
|
interruptTransmission();
|
throw new IOException("Fatal transmission error", e);
|
}
|
|
//wait for next block
|
blockInitialCharacter = readNextBlockStart(result);
|
}
|
}
|
|
protected void sendByte(byte b) throws IOException {
|
outputStream.write(b);
|
outputStream.flush();
|
}
|
|
/**
|
* Request transmission start and return first byte of "first" block from sender (block 1 for XModem, block 0 for YModem)
|
*
|
* @param useCRC16
|
* @return
|
* @throws IOException
|
*/
|
protected int requestTransmissionStart(boolean useCRC16) throws IOException {
|
int character;
|
int errorCount = 0;
|
byte requestStartByte;
|
if (!useCRC16) {
|
requestStartByte = NAK;
|
} else {
|
requestStartByte = ST_C;
|
}
|
|
// wait for first block start
|
Timer timer = new Timer(REQUEST_TIMEOUT);
|
while (errorCount < MAXERRORS) {
|
// request transmission start (will be repeated after 10 second timeout for 10 times)
|
sendByte(requestStartByte);
|
timer.start();
|
try {
|
while (true) {
|
character = readByte(timer);
|
|
if (character == SOH || character == STX) {
|
return character;
|
}
|
}
|
} catch (TimeoutException ignored) {
|
errorCount++;
|
}
|
}
|
interruptTransmission();
|
throw new RuntimeException("Timeout, no data received from transmitter");
|
}
|
|
protected int readNextBlockStart(boolean lastBlockResult) throws IOException {
|
int character;
|
int errorCount = 0;
|
Timer timer = new Timer(BLOCK_TIMEOUT);
|
while (true) {
|
timer.start();
|
try {
|
while (true) {
|
character = readByte(timer);
|
|
if (character == SOH || character == STX || character == EOT) {
|
return character;
|
}
|
}
|
} catch (TimeoutException ignored) {
|
// repeat last block result and wait for next block one more time
|
if (++errorCount < MAXERRORS) {
|
sendByte(lastBlockResult ? ACK : NAK);
|
} else {
|
interruptTransmission();
|
throw new RuntimeException("Timeout, no data received from transmitter");
|
}
|
}
|
}
|
}
|
|
private void shortSleep() {
|
try {
|
Thread.sleep(10);
|
} catch (InterruptedException e) {
|
try {
|
interruptTransmission();
|
} catch (IOException ignore) {
|
}
|
throw new RuntimeException("Transmission was interrupted", e);
|
}
|
}
|
|
/**
|
* send CAN to interrupt seance
|
*
|
* @throws IOException
|
*/
|
protected void interruptTransmission() throws IOException {
|
sendByte(CAN);
|
sendByte(CAN);
|
}
|
|
protected byte[] readBlock(int blockNumber, boolean shortBlock, CRC crc) throws IOException, TimeoutException, RepeatedBlockException, SynchronizationLostException, InvalidBlockException {
|
byte[] block;
|
Timer timer = new Timer(BLOCK_TIMEOUT).start();
|
|
if (shortBlock) {
|
block = shortBlockBuffer;
|
} else {
|
block = longBlockBuffer;
|
}
|
byte character;
|
|
character = readByte(timer);
|
|
if (character == blockNumber - 1) {
|
// this is repeating of last block, possible ACK lost
|
throw new RepeatedBlockException();
|
}
|
if (character != blockNumber) {
|
// wrong block - fatal loss of synchronization
|
throw new SynchronizationLostException();
|
}
|
|
character = readByte(timer);
|
|
if (character != ~blockNumber) {
|
throw new InvalidBlockException();
|
}
|
|
// data
|
for (int i = 0; i < block.length; i++) {
|
block[i] = readByte(timer);
|
}
|
|
while (true) {
|
if (inputStream.available() >= crc.getCRCLength()) {
|
if (crc.calcCRC(block) != readCRC(crc)) {
|
throw new InvalidBlockException();
|
}
|
break;
|
}
|
|
shortSleep();
|
|
if (timer.isExpired()) {
|
throw new TimeoutException();
|
}
|
}
|
|
return block;
|
}
|
|
private long readCRC(CRC crc) throws IOException {
|
long checkSumma = 0;
|
for (int j = 0; j < crc.getCRCLength(); j++) {
|
checkSumma = (checkSumma << 8) + inputStream.read();
|
}
|
return checkSumma;
|
}
|
|
private byte readByte(Timer timer) throws IOException, TimeoutException {
|
while (true) {
|
if (inputStream.available() > 0) {
|
int b = inputStream.read();
|
return (byte) b;
|
}
|
if (timer.isExpired()) {
|
throw new TimeoutException();
|
}
|
shortSleep();
|
}
|
}
|
|
class RepeatedBlockException extends Exception {
|
|
/**
|
*
|
*/
|
private static final long serialVersionUID = 1L;
|
}
|
|
class SynchronizationLostException extends Exception {
|
|
/**
|
*
|
*/
|
private static final long serialVersionUID = 1L;
|
}
|
|
class InvalidBlockException extends Exception {
|
|
/**
|
*
|
*/
|
private static final long serialVersionUID = 1L;
|
}
|
|
}
|
