| |
Six
Registered: Apr 2002
Posts: 289 |
Punter File Transfer Protocol
Reading the doc here: http://cbmfiles.com/genie/geniefiles/TelcomTools/C1-PROTOCOL-DE..
it outlines what seems like a very simple protocol. Seems easy to implement from scratch. To that end, I set up two tcpser instances, two instance of VICE with CCGMS 11, and began a transfer, observing the logging output of TCPSER.
What Steve Punter describes should go like this:
SENDER
[dummy packet 1]---ACK---[filetype packet]---ACK---[First file packet]---ACK---[Second file packet]....
RECEIVER
----------------GOO---S/B-----------------GOO---S/B------------------GOO---S/B-- ------------------GOO...
Where dummy packet 1 would be just the two checksums, 8 for the "next block size", and a block number of 0000, filetype packet is much the same, but with the filetype as the payload and a larger "next block size"
But what I'm observing looks more like this:
SENDER
--------------------------------------------------0x91---ACK---[odd data block]---ACK---SYN---S/B---ACK---[data block 1]
RECEIVER
GOO(over and over again until the transfer starts)----GOO---S/B---------------GOO---S/B---SYN---GOO---S/B----
Where the odd data block has a next block size of 4, and a block number of 0xffff and appears to have the file type in it.
My next step is going to be to try multi-punter on the same setup, then try a few different terms and see if the peculiarities are specific to this implementation of punter on CCGMS 11.
Has anyone else dug into this, or have any insight into the how/why? Is there a comprehensive documentation of this protocol anywhere? |
|
| |
Frantic
Registered: Mar 2003
Posts: 1646 |
The only thing I know about this is that the c*base implementation is available as sourcecode. |
| |
MagerValp
Registered: Dec 2001
Posts: 1074 |
Yeah Steve Punter's documentation is a joke. It's inaccurate in several places and upload is as far as I can tell unspecified. I managed to get download working in CGTerm (see punter.c) but I didn't have the patience to figure out how uploads work. |
| |
Six
Registered: Apr 2002
Posts: 289 |
MV: Aye, I noticed that. You may have caught my comment regarding as much in the usual place. "now I know why he balked at punter send" ;)
Certainly it can be reverse-engineered. I have looked over the c-base implementation, even started commenting over it and doing a rough convert to c, but only as a guide.
The end goal here is full documentation of the protocol and all of its variants, so that future implementations have a good starting point. Guess I'll keep slogging away at it unless anyone has some docs. |
| |
morphfrog
Registered: Mar 2002
Posts: 33 |
Hi
I know Soundemon did a c64 punter implementation for some time ago in skyterm, please ask him , probably can assist. |
| |
Six
Registered: Apr 2002
Posts: 289 |
Update:
First, Punter's explanation of the protocol is bunk. It may have applied to an earlier revision for the PET. Hell, he may have just been high as fuck when he wrote it, who knows?
Anyway, my implementation of punter SEND is now functioning up to the last block. (where I continue to work out the final handshaking)
How this REALLY works is as follows:
Sender waits for the receiver GOO.
Sender ACKs that GOO.
Receiver says S/B.
Sender sends an initial packet to indicate coming filetype. It is constructed in the following odd way:
Standard 7 byte header, with a next block size of 4(no idea why), and a block number of 0xffff (again, no idea why). The payload is one byte to indicate file type (1 for PRG, 2 for SEQ or also 3, but don't worry about 3)
The receiver will now GOO (or bad if there's line noise)
Sender ACKs that GOO.
Receiver says S/B.
[Here's wheRE iT gEtS sHittY...]
Sender SYN's that GOO.
Receiver responds with SYN.
Sender S/B's to that SYN.
Receiver will GOO.
Sender ACK's that goo.
Sender S/B to request sending file blocks.
Then we go into the file loop.
Sender Sends a block.
Receiver will GOO or BAD depending if the block was received properly.
Sender either resends until it gets a GOO, aborts, or ACKs the GOO.
Receiver requests another block with S/B
I'm working out the final block handshaking now, but I believe it mirrors the initial handshaking. Once I've got it fully figured out, I'll write up a formal protocol description for reference, as finding any solid documentation on this protocol has been akin to pushing butter up a tiger's ass with a burning stick. |
| |
Six
Registered: Apr 2002
Posts: 289 |
Handling the final block.
You're unlikely to run a whole file through in 248-byte sections, there's bound to be some slop at the end. So...
On the next-to-the-last block, make sure to set your NEXT_BLOCK_SIZE to the number of file bytes left + 7 (for the header)
On the last block, set the high-byte of your block number to 0xff, and the NEXT_BLOCK_SIZE to 0x00. When you receive the GOO for the last block, ACK it, then the receiver will S/B. Respond to that with SYN. The receiver will respond with SYN. Respond to that with S/B, and the transfer ends.
Next up, multi-punter, and a cleaned-up description. |
| |
Frantic
Registered: Mar 2003
Posts: 1646 |
@Magervalp: Looking forward to an updated version of CGTerm once Six has worked this out completely. ;) |
| |
Six
Registered: Apr 2002
Posts: 289 |
Note: There are numerous variations on this protocol. This post covers the version used in CCGMS 11.0 only. It has not thus-far been tested on other versions.
RECEIVER: GOO
SENDER: ACK
RECEIVER: S/B
SENDER: [filetype packet]
RECEIVER: GOO
SENDER: ACK
RECEIVER: S/B
SENDER: SYN
RECEIVER: SYN
SENDER: S/B
RECEIVER: GOO
SENDER: ACK
RECEIVER: S/B
SENDER: [dummy packet]
RECEIVER: GOO
SENDER: ACK
Loop<---------------------------------
RECEIVER: S/B |
SENDER: [file data packet] |
RECEIVER: GOO |
SENDER: ACK |
-------------------------------------|
RECEIVER: S/B
SENDER: [final data packet]
RECEIVER: GOO
SENDER: ACK
RECEIVER: S/B
SENDER: SYN
RECEIVER:SYN
SENDER: S/B
[filetype packet]
Normal packet, one-byte payload, 1 for prg, 2 for seq, next block size of 4, block number of 0xffff
[dummy packet]
Normal packet, no payload, next block size as needed for the sent file, block number of 0x0000
[final packet]
Normal packet, next block size of 0x00, and upper nybble of block number set to 0xff
[file data packet, Normal packet]
bytes 00, 01 : Additive checksum LO/HI
bytes 02, 03 : CRC Checksum LO/HI
byte 04 : Next block size
bytes 05, 06 : block number LO/HI
Checksums are calculated on all bytes from the Next Block Size forward to the end of the packet. Assuming TempPacket is your byte array of packet data and AdditiveChecksum and CLCChecksum are ushorts, checksum can be generated as follows (thanks to MagerValp for the original on this)
public void Generate_Checksum()
{
AdditiveChecksum = 0;
CLCChecksum = 0;
for (int i = 4; i < TempPacket.Length; i++)
{
AdditiveChecksum += TempPacket[i];
CLCChecksum ^= TempPacket[i];
CLCChecksum =
(ushort)((CLCChecksum << 1) | (CLCChecksum >> 15));
}
}
Validating received packets:
Received packets should pass a checksum test, and be the proper length specified in the preceeding packet.
Handshaking considerations:
You may receive handshakes out-of-sync (KCA, CAK, etc...), your handshaking routines should be able to deal with this.
|
| |
Six
Registered: Apr 2002
Posts: 289 |
For receivers, dealing with bad packets.
RECEIVER: BAD<---------------|
SENDER: ACK |
RECEIVER: S/B |
SENDER: RESENDS SAME PACKET |
RECEIVER: (BAD OR GOO)-------|
|
| |
Tao
Registered: Aug 2002
Posts: 115 |
@Six: I'd be happy if you'd have a look at the C*Base punter implementation; I have a slight recollection of something being wrong with it... |
... 26 posts hidden. Click here to view all posts....
|
| Previous - 1 | 2 | 3 | 4 - Next |
