1222 lines
46 KiB
Plaintext
1222 lines
46 KiB
Plaintext
{{
|
|
Ethernet TCP/IP Socket Layer Driver (IPv4)
|
|
------------------------------------------
|
|
|
|
Copyright (c) 2006-2009 Harrison Pham <harrison@harrisonpham.com>
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
|
|
The latest version of this software can be obtained from
|
|
http://hdpham.com/PropTCP and http://obex.parallax.com/
|
|
}}
|
|
|
|
'' NOTICE: All buffer sizes must be a power of 2!
|
|
|
|
CON
|
|
' ***************************************
|
|
' ** Versioning Information **
|
|
' ***************************************
|
|
version = 5 ' major version
|
|
release = 2 ' minor version
|
|
apiversion = 8 ' api compatibility version
|
|
|
|
' ***************************************
|
|
' ** User Definable Settings **
|
|
' ***************************************
|
|
sNumSockets = 2 ' max number of concurrent registered sockets (max of 255)
|
|
|
|
' *** End of user definable settings, don't edit anything below this line!!!
|
|
' *** All IP/MAC settings are defined by calling the start(...) method
|
|
|
|
CON
|
|
' ***************************************
|
|
' ** Return Codes / Errors **
|
|
' ***************************************
|
|
|
|
RETBUFFEREMPTY = -1 ' no data available
|
|
RETBUFFERFULL = -1 ' buffer full
|
|
|
|
ERRGENERIC = -1 ' generic errors
|
|
|
|
ERR = -100 ' error codes start at -100
|
|
ERRBADHANDLE = ERR - 1 ' bad socket handle
|
|
ERROUTOFSOCKETS = ERR - 2 ' no free sockets available
|
|
ERRSOCKETCLOSED = ERR - 3 ' socket closed, could not perform operation
|
|
|
|
OBJ
|
|
nic : "driver_enc28j60"
|
|
|
|
'ser : "SerialMirror"
|
|
'stk : "Stack Length"
|
|
|
|
CON
|
|
' ***************************************
|
|
' ** Socket Constants and Offsets **
|
|
' ***************************************
|
|
|
|
' Socket states (user should never touch these)
|
|
SCLOSED = 0 ' closed, handle not used
|
|
SLISTEN = 1 ' listening, in server mode
|
|
SSYNSENT = 2 ' SYN sent, server mode, waits for ACK
|
|
SSYNSENTCL = 3 ' SYN sent, client mode, waits for SYN+ACK
|
|
SESTABLISHED = 4 ' established connection (either SYN+ACK, or ACK+Data)
|
|
SCLOSING = 5 ' connection is being forced closed by code
|
|
SCLOSING2 = 6 ' closing, we are waiting for a fin now
|
|
SFORCECLOSE = 7 ' force connection close (just RSTs, no waiting for FIN or anything)
|
|
SCONNECTINGARP1 = 8 ' connecting, next step: send arp request
|
|
SCONNECTINGARP2 = 9 ' connecting, next step: arp request sent, waiting for response
|
|
SCONNECTINGARP2G = 10 ' connecting, next step: arp request sent, waiting for response [GATEWAY REQUEST]
|
|
SCONNECTING = 11 ' connecting, next step: got mac address, send SYN
|
|
|
|
' ***************************************
|
|
' ** TCP State Management Constants **
|
|
' ***************************************
|
|
TIMEOUTMS = 500 ' (milliseconds) timeout before a retransmit occurs
|
|
RSTTIMEOUTMS = 2000 ' (milliseconds) timeout before a RST is sent to close the connection
|
|
WINDOWUPDATEMS = 25 ' (milliseconds) window advertisement frequency
|
|
|
|
MAXUNACKS = 6 ' max number of unacknowledged retransmits before the stack auto closes the socket
|
|
' timeout = TIMEOUTMS * MAXUNACKS (default: 500ms * 5 = 3000ms)
|
|
|
|
EPHPORTSTART = 49152 ' ephemeral port start
|
|
EPHPORTEND = 65535 ' end
|
|
|
|
MAXPAYLOAD = 1200 ' maximum TCP payload (data) in bytes, this only applies when your txbuffer_length > payload size
|
|
|
|
DAT
|
|
' ***************************************
|
|
' ** Global Variables **
|
|
' ***************************************
|
|
cog long 0 ' cog index (for stopping / starting)
|
|
stack long 0[128] ' stack for new cog (currently ~74 longs, using 128 for expansion)
|
|
|
|
mac_ptr long 0 ' mac address pointer
|
|
|
|
pkt_id long 0 ' packet fragmentation id
|
|
pkt_isn long 0 ' packet initial sequence number
|
|
|
|
ip_ephport word 0 ' packet ephemeral port number (49152 to 65535)
|
|
|
|
pkt_count byte 0 ' packet count
|
|
|
|
lock_id byte 0 ' socket handle lock
|
|
|
|
packet byte 0[nic#MAXFRAME] ' the ethernet frame
|
|
|
|
' ***************************************
|
|
' ** IP Address Defaults **
|
|
' ***************************************
|
|
' NOTE: All of the MAC/IP variables here contain default values that will
|
|
' be used if override values are not provided as parameters in start().
|
|
long ' long alignment for addresses
|
|
ip_addr byte 10, 10, 1, 4 ' device's ip address
|
|
ip_subnet byte 255, 255, 255, 0 ' network subnet
|
|
ip_gateway byte 10, 10, 1, 254 ' network gateway (router)
|
|
ip_dns byte 10, 10, 1, 254 ' network dns
|
|
|
|
' ***************************************
|
|
' ** Socket Data Arrays **
|
|
' ***************************************
|
|
|
|
long
|
|
SocketArrayStart
|
|
lMySeqNum long 0[sNumSockets]
|
|
lMyAckNum long 0[sNumSockets]
|
|
lSrcIp long 0[sNumSockets]
|
|
lTime long 0[sNumSockets]
|
|
|
|
word
|
|
wSrcPort word 0[sNumSockets]
|
|
wDstPort word 0[sNumSockets]
|
|
wLastWin word 0[sNumSockets]
|
|
wLastTxLen word 0[sNumSockets]
|
|
wNotAcked word 0[sNumSockets]
|
|
|
|
byte
|
|
bSrcMac byte 0[sNumSockets * 6]
|
|
bConState byte 0[sNumSockets]
|
|
SocketArrayEnd
|
|
|
|
' ***************************************
|
|
' ** Circular Buffer Arrays **
|
|
' ***************************************
|
|
word
|
|
FifoDataStart
|
|
rx_head word 0[sNumSockets] ' rx head array
|
|
rx_tail word 0[sNumSockets] ' rx tail array
|
|
tx_head word 0[sNumSockets] ' tx head array
|
|
tx_tail word 0[sNumSockets] ' tx tail array
|
|
|
|
tx_tailnew word 0[sNumSockets] ' the new tx_tail value (unacked data)
|
|
|
|
rxbuffer_length word 0[sNumSockets] ' each socket's buffer sizes
|
|
txbuffer_length word 0[sNumSockets]
|
|
|
|
rxbuffer_mask word 0[sNumSockets] ' each socket's buffer masks for capping buffer sizes
|
|
txbuffer_mask word 0[sNumSockets]
|
|
|
|
long
|
|
tx_bufferptr long 0[sNumSockets] ' pointer addresses to each socket's buffer spaces
|
|
rx_bufferptr long 0[sNumSockets]
|
|
FifoDataEnd
|
|
|
|
PUB start(cs, sck, si, so, xtalout, macptr, ipconfigptr)
|
|
'' Start the TCP/IP Stack (requires 2 cogs)
|
|
'' Only call this once, otherwise you will get conflicts
|
|
'' macptr = HUB memory pointer (address) to 6 contiguous mac address bytes
|
|
'' ipconfigptr = HUB memory pointer (address) to ip configuration block (16 bytes)
|
|
'' Must be in order: ip_addr, ip_subnet, ip_gateway, ip_dns
|
|
|
|
stop
|
|
'stk.Init(@stack, 128)
|
|
|
|
' zero socket data arrays (clean up any dead stuff from previous instance)
|
|
bytefill(@SocketArrayStart, 0, @SocketArrayEnd - @SocketArrayStart)
|
|
|
|
' reset buffer pointers, zeros a contigous set of bytes, starting at rx_head
|
|
bytefill(@FifoDataStart, 0, @FifoDataEnd - @FifoDataStart)
|
|
|
|
' start new cog with tcp stack
|
|
cog := cognew(engine(cs, sck, si, so, xtalout, macptr, ipconfigptr), @stack) + 1
|
|
|
|
PUB stop
|
|
'' Stop the driver
|
|
|
|
if cog
|
|
cogstop(cog~ - 1) ' stop the tcp engine
|
|
nic.stop ' stop nic driver (kills spi engine)
|
|
lockclr(lock_id) ' clear lock before returning it to the pool
|
|
lockret(lock_id) ' return the lock to the lock pool
|
|
|
|
PRI engine(cs, sck, si, so, xtalout, macptr, ipconfigptr) | i
|
|
|
|
lock_id := locknew ' checkout a lock from the HUB
|
|
lockclr(lock_id) ' clear the lock, just in case it was in a bad state
|
|
|
|
' Start the ENC28J60 driver in a new cog
|
|
nic.start(cs, sck, si, so, xtalout, macptr) ' init the nic
|
|
|
|
if ipconfigptr > -1 ' init ip configuration
|
|
bytemove(@ip_addr, ipconfigptr, 16)
|
|
|
|
mac_ptr := nic.get_mac_pointer ' get the local mac address pointer
|
|
|
|
ip_ephport := EPHPORTSTART ' set initial ephemeral port number (might want to random seed this later)
|
|
|
|
i := 0
|
|
nic.banksel(nic#EPKTCNT) ' select packet count bank
|
|
repeat
|
|
pkt_count := nic.rd_cntlreg(nic#EPKTCNT)
|
|
if pkt_count > 0
|
|
service_packet ' handle packet
|
|
nic.banksel(nic#EPKTCNT) ' re-select the packet count bank
|
|
|
|
++i
|
|
if i > 10 ' perform send tick
|
|
repeat while lockset(lock_id)
|
|
tick_tcpsend ' occurs every 10 cycles, since incoming packets more important
|
|
lockclr(lock_id)
|
|
|
|
i := 0
|
|
nic.banksel(nic#EPKTCNT) ' re-select the packet count bank
|
|
|
|
PRI service_packet
|
|
|
|
' lets process this frame
|
|
nic.get_frame(@packet)
|
|
|
|
' check for arp packet type (highest priority obviously)
|
|
if packet[enetpacketType0] == $08 AND packet[enetpacketType1] == $06
|
|
if packet[constant(arp_hwtype + 1)] == $01 AND packet[arp_prtype] == $08 AND packet[constant(arp_prtype + 1)] == $00 AND packet[arp_hwlen] == $06 AND packet[arp_prlen] == $04
|
|
if packet[arp_tipaddr] == ip_addr[0] AND packet[constant(arp_tipaddr + 1)] == ip_addr[1] AND packet[constant(arp_tipaddr + 2)] == ip_addr[2] AND packet[constant(arp_tipaddr + 3)] == ip_addr[3]
|
|
case packet[constant(arp_op + 1)]
|
|
$01 : handle_arp
|
|
$02 : repeat while lockset(lock_id)
|
|
handle_arpreply
|
|
lockclr(lock_id)
|
|
'++count_arp
|
|
else
|
|
if packet[enetpacketType0] == $08 AND packet[enetpacketType1] == $00
|
|
if packet[ip_destaddr] == ip_addr[0] AND packet[constant(ip_destaddr + 1)] == ip_addr[1] AND packet[constant(ip_destaddr + 2)] == ip_addr[2] AND packet[constant(ip_destaddr + 3)] == ip_addr[3]
|
|
case packet[ip_proto]
|
|
'PROT_ICMP : 'handle_ping
|
|
'ser.str(stk.GetLength(0, 0))
|
|
'stk.GetLength(30, 19200)
|
|
'++count_ping
|
|
PROT_TCP : repeat while lockset(lock_id)
|
|
\handle_tcp ' handles abort out of tcp handlers (no socket found)
|
|
lockclr(lock_id)
|
|
'++count_tcp
|
|
'PROT_UDP : ++count_udp
|
|
|
|
' *******************************
|
|
' ** Protocol Receive Handlers **
|
|
' *******************************
|
|
PRI handle_arp | i
|
|
nic.start_frame
|
|
|
|
' destination mac address
|
|
repeat i from 0 to 5
|
|
nic.wr_frame(packet[enetpacketSrc0 + i])
|
|
|
|
' source mac address
|
|
repeat i from 0 to 5
|
|
nic.wr_frame(BYTE[mac_ptr][i])
|
|
|
|
nic.wr_frame($08) ' arp packet
|
|
nic.wr_frame($06)
|
|
|
|
nic.wr_frame($00) ' 10mb ethernet
|
|
nic.wr_frame($01)
|
|
|
|
nic.wr_frame($08) ' ip proto
|
|
nic.wr_frame($00)
|
|
|
|
nic.wr_frame($06) ' mac addr len
|
|
nic.wr_frame($04) ' proto addr len
|
|
|
|
nic.wr_frame($00) ' arp reply
|
|
nic.wr_frame($02)
|
|
|
|
' write ethernet module mac address
|
|
repeat i from 0 to 5
|
|
nic.wr_frame(BYTE[mac_ptr][i])
|
|
|
|
' write ethernet module ip address
|
|
repeat i from 0 to 3
|
|
nic.wr_frame(ip_addr[i])
|
|
|
|
' write remote mac address
|
|
repeat i from 0 to 5
|
|
nic.wr_frame(packet[enetpacketSrc0 + i])
|
|
|
|
' write remote ip address
|
|
repeat i from 0 to 3
|
|
nic.wr_frame(packet[arp_sipaddr + i])
|
|
|
|
return nic.send_frame
|
|
|
|
PRI handle_arpreply | handle, ip, found
|
|
' Gets arp reply if it is a response to an ip we have
|
|
|
|
ip := (packet[constant(arp_sipaddr + 3)] << 24) + (packet[constant(arp_sipaddr + 2)] << 16) + (packet[constant(arp_sipaddr + 1)] << 8) + (packet[arp_sipaddr])
|
|
|
|
found := false
|
|
if ip == LONG[@ip_gateway]
|
|
' find a handle that wants gateway mac
|
|
repeat handle from 0 to constant(sNumSockets - 1)
|
|
if bConState[handle] == SCONNECTINGARP2G
|
|
found := true
|
|
quit
|
|
else
|
|
' find the one that wants this arp
|
|
repeat handle from 0 to constant(sNumSockets - 1)
|
|
if bConState[handle] == SCONNECTINGARP2
|
|
if lSrcIp[handle] == ip
|
|
found := true
|
|
quit
|
|
|
|
if found
|
|
bytemove(@bSrcMac[handle * 6], @packet + arp_shaddr, 6)
|
|
bConState[handle] := SCONNECTING
|
|
|
|
'PRI handle_ping
|
|
' Not implemented yet (save on space!)
|
|
|
|
PRI handle_tcp | i, ptr, handle, srcip, dstport, srcport, datain_len
|
|
' Handles incoming TCP packets
|
|
|
|
srcip := packet[ip_srcaddr] << 24 + packet[constant(ip_srcaddr + 1)] << 16 + packet[constant(ip_srcaddr + 2)] << 8 + packet[constant(ip_srcaddr + 3)]
|
|
dstport := packet[TCP_destport] << 8 + packet[constant(TCP_destport + 1)]
|
|
srcport := packet[TCP_srcport] << 8 + packet[constant(TCP_srcport + 1)]
|
|
|
|
handle := find_socket(srcip, dstport, srcport) ' if no sockets avail, it will abort out of this function
|
|
|
|
' at this point we assume we have an active socket, or a socket available to be used
|
|
datain_len := ((packet[ip_pktlen] << 8) + packet[constant(ip_pktlen + 1)]) - ((packet[ip_vers_len] & $0F) * 4) - (((packet[TCP_hdrlen] & $F0) >> 4) * 4)
|
|
|
|
if (bConState[handle] == SSYNSENT OR bConState[handle] == SESTABLISHED) AND (packet[TCP_hdrflags] & TCP_ACK) AND datain_len > 0
|
|
' ACK, without SYN, with data
|
|
|
|
' set socket state, established session
|
|
bConState[handle] := SESTABLISHED
|
|
|
|
i := packet[constant(TCP_seqnum + 3)] << 24 + packet[constant(TCP_seqnum + 2)] << 16 + packet[constant(TCP_seqnum + 1)] << 8 + packet[TCP_seqnum]
|
|
if lMyAckNum[handle] == i
|
|
if datain_len =< (rxbuffer_mask[handle] - ((rx_head[handle] - rx_tail[handle]) & rxbuffer_mask[handle]))
|
|
' we have buffer space
|
|
ptr := rx_bufferptr[handle]
|
|
if (datain_len + rx_head[handle]) > rxbuffer_length[handle]
|
|
bytemove(ptr + rx_head[handle], @packet[TCP_data], rxbuffer_length[handle] - rx_head[handle])
|
|
bytemove(ptr, @packet[TCP_data] + (rxbuffer_length[handle] - rx_head[handle]), datain_len - (rxbuffer_length[handle] - rx_head[handle]))
|
|
else
|
|
bytemove(ptr + rx_head[handle], @packet[TCP_data], datain_len)
|
|
rx_head[handle] := (rx_head[handle] + datain_len) & rxbuffer_mask[handle]
|
|
else
|
|
datain_len := 0
|
|
|
|
else
|
|
' we had a bad ack number, meaning lost or out of order packet
|
|
' we have to wait for the remote host to retransmit in order
|
|
datain_len := 0
|
|
|
|
' recalculate ack number
|
|
lMyAckNum[handle] := conv_endianlong(conv_endianlong(lMyAckNum[handle]) + datain_len)
|
|
|
|
' ACK response
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, TCP_ACK)
|
|
send_tcpfinal(handle, 0)
|
|
|
|
elseif (bConState[handle] == SSYNSENTCL) AND (packet[TCP_hdrflags] & TCP_SYN) AND (packet[TCP_hdrflags] & TCP_ACK)
|
|
' We got a server response, so we ACK it
|
|
|
|
bytemove(@lMySeqNum[handle], @packet + TCP_acknum, 4)
|
|
bytemove(@lMyAckNum[handle], @packet + TCP_seqnum, 4)
|
|
|
|
lMyAckNum[handle] := conv_endianlong(conv_endianlong(lMyAckNum[handle]) + 1)
|
|
|
|
' ACK response
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, TCP_ACK)
|
|
send_tcpfinal(handle, 0)
|
|
|
|
' set socket state, established session
|
|
bConState[handle] := SESTABLISHED
|
|
|
|
elseif (bConState[handle] == SLISTEN) AND (packet[TCP_hdrflags] & TCP_SYN)
|
|
' Reply to SYN with SYN + ACK
|
|
|
|
' copy mac address so we don't have to keep an ARP table
|
|
bytemove(@bSrcMac[handle * 6], @packet + enetpacketSrc0, 6)
|
|
|
|
' copy ip, port data
|
|
bytemove(@lSrcIp[handle], @packet + ip_srcaddr, 4)
|
|
bytemove(@wSrcPort[handle], @packet + TCP_srcport, 2)
|
|
bytemove(@wDstPort[handle], @packet + TCP_destport, 2)
|
|
|
|
' get updated ack numbers
|
|
bytemove(@lMyAckNum[handle], @packet + TCP_seqnum, 4)
|
|
|
|
lMyAckNum[handle] := conv_endianlong(conv_endianlong(lMyAckNum[handle]) + 1)
|
|
lMySeqNum[handle] := conv_endianlong(++pkt_isn) ' Initial seq num (random)
|
|
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, constant(TCP_SYN | TCP_ACK))
|
|
send_tcpfinal(handle, 0)
|
|
|
|
' incremement the sequence number for the next packet (it will be for an established connection)
|
|
lMySeqNum[handle] := conv_endianlong(conv_endianlong(lMySeqNum[handle]) + 1)
|
|
|
|
' set socket state, waiting for establish
|
|
bConState[handle] := SSYNSENT
|
|
|
|
elseif (bConState[handle] == SESTABLISHED OR bConState[handle] == SCLOSING2) AND (packet[TCP_hdrflags] & TCP_FIN)
|
|
' Reply to FIN with RST
|
|
|
|
' get updated sequence and ack numbers (gaurantee we have correct ones to kill connection with)
|
|
bytemove(@lMySeqNum[handle], @packet + TCP_acknum, 4)
|
|
bytemove(@lMyAckNum[handle], @packet + TCP_seqnum, 4)
|
|
|
|
'LONG[handle_addr + sMyAckNum] := conv_endianlong(conv_endianlong(LONG[handle_addr + sMyAckNum]) + 1)
|
|
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, TCP_RST)
|
|
send_tcpfinal(handle, 0)
|
|
|
|
' set socket state, now free
|
|
bConState[handle] := SCLOSED
|
|
return
|
|
|
|
elseif (bConState[handle] == SSYNSENT) AND (packet[TCP_hdrflags] & TCP_ACK)
|
|
' if just an ack, and we sent a syn before, then it's established
|
|
' this just gives us the ability to send on connect
|
|
bConState[handle] := SESTABLISHED
|
|
|
|
elseif (packet[TCP_hdrflags] & TCP_RST)
|
|
' Reset, reset states
|
|
bConState[handle] := SCLOSED
|
|
return
|
|
|
|
if (bConState[handle] == SESTABLISHED OR bConState[handle] == SCLOSING) AND (packet[TCP_hdrflags] & TCP_ACK)
|
|
wNotAcked[handle] := 0 ' reset retransmit counter
|
|
' check to see if our last sent data has been ack'd
|
|
i := packet[TCP_acknum] << 24 + packet[constant(TCP_acknum + 1)] << 16 + packet[constant(TCP_acknum + 2)] << 8 + packet[constant(TCP_acknum + 3)]
|
|
if i == (conv_endianlong(lMySeqNum[handle]) + wLastTxLen[handle])
|
|
' we received an ack for our last sent packet, so we update our sequence number and buffer pointers
|
|
lMySeqNum[handle] := conv_endianlong(conv_endianlong(lMySeqNum[handle]) + wLastTxLen[handle])
|
|
tx_tail[handle] := tx_tailnew[handle]
|
|
wLastTxLen[handle] := 0
|
|
|
|
tcpsend(handle) ' send data
|
|
|
|
PRI build_ipheaderskeleton(handle) | hdrlen, hdr_chksum
|
|
|
|
bytemove(@packet + ip_destaddr, @lSrcIp[handle], 4) ' Set destination address
|
|
|
|
bytemove(@packet + ip_srcaddr, @ip_addr, 4) ' Set source address
|
|
|
|
bytemove(@packet + enetpacketDest0, @bSrcMac[handle * 6], 6) ' Set destination mac address
|
|
|
|
bytemove(@packet + enetpacketSrc0, mac_ptr, 6) ' Set source mac address
|
|
|
|
packet[enetpacketType0] := $08
|
|
packet[constant(enetpacketType0 + 1)] := $00
|
|
|
|
packet[ip_vers_len] := $45
|
|
packet[ip_tos] := $00
|
|
|
|
++pkt_id
|
|
|
|
packet[ip_id] := pkt_id >> 8 ' Used for fragmentation
|
|
packet[constant(ip_id + 1)] := pkt_id
|
|
|
|
packet[ip_frag_offset] := $40 ' Don't fragment
|
|
packet[constant(ip_frag_offset + 1)] := 0
|
|
|
|
packet[ip_ttl] := $80 ' TTL = 128
|
|
|
|
packet[ip_proto] := $06 ' TCP protocol
|
|
|
|
PRI build_tcpskeleton(handle, flags) | size
|
|
|
|
bytemove(@packet + TCP_srcport, @wDstPort[handle], 2) ' Source port
|
|
bytemove(@packet + TCP_destport, @wSrcPort[handle], 2) ' Destination port
|
|
|
|
bytemove(@packet + TCP_seqnum, @lMySeqNum[handle], 4) ' Seq Num
|
|
bytemove(@packet + TCP_acknum, @lMyAckNum[handle], 4) ' Ack Num
|
|
|
|
packet[TCP_hdrlen] := $50 ' Header length
|
|
|
|
packet[TCP_hdrflags] := flags ' TCP state flags
|
|
|
|
' we have to recalculate the window size often otherwise our stack
|
|
' might explode from too much data :(
|
|
size := (rxbuffer_mask[handle] - ((rx_head[handle] - rx_tail[handle]) & rxbuffer_mask[handle]))
|
|
wLastWin[handle] := size
|
|
|
|
packet[TCP_window] := (size & $FF00) >> 8
|
|
packet[constant(TCP_window + 1)] := size & $FF
|
|
|
|
PRI send_tcpfinal(handle, datalen) | i, tcplen, hdrlen, hdr_chksum
|
|
|
|
tcplen := 40 + datalen ' real length = data + headers
|
|
|
|
packet[ip_pktlen] := tcplen >> 8
|
|
packet[constant(ip_pktlen + 1)] := tcplen
|
|
|
|
' calc ip header checksum
|
|
packet[ip_hdr_cksum] := $00
|
|
packet[constant(ip_hdr_cksum + 1)] := $00
|
|
hdrlen := (packet[ip_vers_len] & $0F) * 4
|
|
hdr_chksum := calc_chksum(@packet[ip_vers_len], hdrlen)
|
|
packet[ip_hdr_cksum] := hdr_chksum >> 8
|
|
packet[constant(ip_hdr_cksum + 1)] := hdr_chksum
|
|
|
|
' calc checksum
|
|
packet[TCP_cksum] := $00
|
|
packet[constant(TCP_cksum + 1)] := $00
|
|
hdr_chksum := nic.chksum_add(@packet[ip_srcaddr], 8)
|
|
hdr_chksum += packet[ip_proto]
|
|
i := tcplen - ((packet[ip_vers_len] & $0F) * 4)
|
|
hdr_chksum += i
|
|
hdr_chksum += nic.chksum_add(@packet[TCP_srcport], i)
|
|
hdr_chksum := calc_chksumfinal(hdr_chksum)
|
|
packet[TCP_cksum] := hdr_chksum >> 8
|
|
packet[constant(TCP_cksum + 1)] := hdr_chksum
|
|
|
|
tcplen += 14
|
|
if tcplen < 60
|
|
tcplen := 60
|
|
|
|
' protect from buffer overrun
|
|
if tcplen => nic#TX_BUFFER_SIZE
|
|
return
|
|
|
|
' send the packet
|
|
nic.start_frame
|
|
nic.wr_block(@packet, tcplen)
|
|
nic.send_frame
|
|
|
|
lTime[handle] := cnt ' update last sent time (for timeout detection)
|
|
|
|
PRI find_socket(srcip, dstport, srcport) | handle, free_handle, listen_handle
|
|
' Search for socket, matches ip address, port states
|
|
' Returns handle address (start memory location of socket)
|
|
' If no matches, will abort with -1
|
|
' If supplied with srcip = 0 then will return free unused handle, aborts with -1 if none avail
|
|
|
|
free_handle := -1
|
|
listen_handle := -1
|
|
repeat handle from 0 to constant(sNumSockets - 1)
|
|
if bConState[handle] <> SCLOSED
|
|
if (lSrcIp[handle] == 0) OR (lSrcIp[handle] == conv_endianlong(srcip))
|
|
' ip match, ip socket srcip = 0, then will try to match dst port (find listening socket)
|
|
if (wDstPort[handle] == conv_endianword(dstport)) {AND (WORD[handle_addr + sSrcPort] == 0 OR WORD[handle_addr + sSrcPort] == conv_endianword(srcport))}
|
|
if wSrcPort[handle] == conv_endianword(srcport)
|
|
' found exact socket match (established socket)
|
|
return handle
|
|
elseif wSrcPort[handle] == 0
|
|
' found a partial match (listening socket with no peer)
|
|
listen_handle := handle
|
|
elseif srcip == 0
|
|
' found a closed (unallocated) socket, save this as a free handle if we are searching for a free handle
|
|
free_handle := handle ' we found a free handle, may need this later
|
|
|
|
if srcip <> 0
|
|
' return the listening handle we found
|
|
if listen_handle <> -1
|
|
return listen_handle
|
|
else
|
|
' searched for a free handle
|
|
if free_handle <> -1
|
|
return free_handle
|
|
|
|
' could not find a matching socket / free socket...
|
|
abort -1
|
|
|
|
' ******************************
|
|
' ** Transmit Buffer Handlers **
|
|
' ******************************
|
|
PRI tcpsend(handle) | ptr, len
|
|
' Check buffers for data to send (called in main loop)
|
|
|
|
if tx_tail[handle] == tx_head[handle]
|
|
' no data in buffer, so just quit
|
|
return
|
|
|
|
' we have data to send, so send it
|
|
ptr := tx_bufferptr[handle]
|
|
len := ((tx_head[handle] - tx_tail[handle]) & txbuffer_mask[handle]) <# MAXPAYLOAD
|
|
if (len + tx_tail[handle]) > txbuffer_length[handle]
|
|
bytemove(@packet[TCP_data], ptr + tx_tail[handle], txbuffer_length[handle] - tx_tail[handle])
|
|
bytemove(@packet[TCP_data] + (txbuffer_length[handle] - tx_tail[handle]), ptr, len - (txbuffer_length[handle] - tx_tail[handle]))
|
|
else
|
|
bytemove(@packet[TCP_data], ptr + tx_tail[handle], len)
|
|
tx_tailnew[handle] := (tx_tail[handle] + len) & txbuffer_mask[handle]
|
|
|
|
wLastTxLen[handle] := len
|
|
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, TCP_ACK {constant(TCP_ACK | TCP_PSH)})
|
|
send_tcpfinal(handle, len) ' send actual data
|
|
|
|
send_tcpfinal(handle, 0) ' send an empty packet to force the other side to ACK (hack to get around delayed acks)
|
|
|
|
wNotAcked[handle]++ ' increment unacked packet counter
|
|
|
|
PRI tick_tcpsend | handle, state, len
|
|
|
|
repeat handle from 0 to constant(sNumSockets - 1)
|
|
state := bConState[handle]
|
|
|
|
if state == SESTABLISHED OR state == SCLOSING
|
|
len := (rxbuffer_mask[handle] - ((rx_head[handle] - rx_tail[handle]) & rxbuffer_mask[handle]))
|
|
if wLastWin[handle] <> len AND len => (rxbuffer_length[handle] / 2) AND ((cnt - lTime[handle]) / (clkfreq / 1000) > WINDOWUPDATEMS)
|
|
' update window size
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, TCP_ACK)
|
|
send_tcpfinal(handle, 0)
|
|
|
|
if ((cnt - lTime[handle]) / (clkfreq / 1000) > TIMEOUTMS) OR wLastTxLen[handle] == 0
|
|
' send new data OR retransmit our last packet since the other side seems to have lost it
|
|
' the remote host will respond with another dup ack, and we will get back on track (hopefully)
|
|
tcpsend(handle)
|
|
|
|
if (state == SCLOSING)
|
|
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, constant(TCP_ACK | TCP_FIN))
|
|
send_tcpfinal(handle, 0)
|
|
|
|
' we now wait for the other side to terminate
|
|
bConState[handle] := SCLOSING2
|
|
|
|
elseif state == SCONNECTINGARP1
|
|
' We need to send an arp request
|
|
|
|
arp_request_checkgateway(handle)
|
|
|
|
elseif state == SCONNECTING
|
|
' Yea! We got an arp response previously, so now we can send the SYN
|
|
|
|
lMySeqNum[handle] := conv_endianlong(++pkt_isn)
|
|
lMyAckNum[handle] := 0
|
|
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, TCP_SYN)
|
|
send_tcpfinal(handle, 0)
|
|
|
|
bConState[handle] := SSYNSENTCL
|
|
|
|
elseif (state == SFORCECLOSE) OR (state == SESTABLISHED AND wNotAcked[handle] => MAXUNACKS) OR (lookdown(state: SCLOSING2, SSYNSENT, SSYNSENTCL, SCONNECTINGARP2, SCONNECTINGARP2G) {(state == SCLOSING2 OR state == SSYNSENT)} AND ((cnt - lTime[handle]) / (clkfreq / 1000) > RSTTIMEOUTMS))
|
|
' Force close (send RST, and say the socket is closed!)
|
|
|
|
' This is triggered when any of the following happens:
|
|
' 1 - we don't get a response to our SSYNSENT state
|
|
' 2 - we exceeded MAXUNACKS tcp retransmits (remote host lost)
|
|
' 3 - we get stuck in the SSCLOSING2 state
|
|
' 4 - we don't get a response to our client SYNSENTCL state
|
|
' 5 - we don't get an ARP response state SCONNECTINGARP2 or SCONNECTINGARP2G
|
|
|
|
build_ipheaderskeleton(handle)
|
|
build_tcpskeleton(handle, TCP_RST)
|
|
send_tcpfinal(handle, 0)
|
|
|
|
bConState[handle] := SCLOSED
|
|
|
|
PRI arp_request_checkgateway(handle) | ip_ptr
|
|
|
|
ip_ptr := @lSrcIp[handle]
|
|
|
|
if (BYTE[ip_ptr] & ip_subnet[0]) == (ip_addr[0] & ip_subnet[0]) AND (BYTE[ip_ptr + 1] & ip_subnet[1]) == (ip_addr[1] & ip_subnet[1]) AND (BYTE[ip_ptr + 2] & ip_subnet[2]) == (ip_addr[2] & ip_subnet[2]) AND (BYTE[ip_ptr + 3] & ip_subnet[3]) == (ip_addr[3] & ip_subnet[3])
|
|
arp_request(conv_endianlong(LONG[ip_ptr]))
|
|
bConState[handle] := SCONNECTINGARP2
|
|
else
|
|
arp_request(conv_endianlong(LONG[@ip_gateway]))
|
|
bConState[handle] := SCONNECTINGARP2G
|
|
|
|
lTime[handle] := cnt
|
|
|
|
PRI arp_request(ip) | i
|
|
nic.start_frame
|
|
|
|
' destination mac address (broadcast mac)
|
|
repeat i from 0 to 5
|
|
nic.wr_frame($FF)
|
|
|
|
' source mac address (this device)
|
|
repeat i from 0 to 5
|
|
nic.wr_frame(BYTE[mac_ptr][i])
|
|
|
|
nic.wr_frame($08) ' arp packet
|
|
nic.wr_frame($06)
|
|
|
|
nic.wr_frame($00) ' 10mb ethernet
|
|
nic.wr_frame($01)
|
|
|
|
nic.wr_frame($08) ' ip proto
|
|
nic.wr_frame($00)
|
|
|
|
nic.wr_frame($06) ' mac addr len
|
|
nic.wr_frame($04) ' proto addr len
|
|
|
|
nic.wr_frame($00) ' arp request
|
|
nic.wr_frame($01)
|
|
|
|
' source mac address (this device)
|
|
repeat i from 0 to 5
|
|
nic.wr_frame(BYTE[mac_ptr][i])
|
|
|
|
' source ip address (this device)
|
|
repeat i from 0 to 3
|
|
nic.wr_frame(ip_addr[i])
|
|
|
|
' unknown mac address area
|
|
repeat i from 0 to 5
|
|
nic.wr_frame($00)
|
|
|
|
' figure out if we need router arp request or host arp request
|
|
' this means some subnet masking
|
|
|
|
' dest ip address
|
|
repeat i from 3 to 0
|
|
nic.wr_frame(ip.byte[i])
|
|
|
|
' send the request
|
|
return nic.send_frame
|
|
|
|
' *******************************
|
|
' ** IP Packet Helpers (Calcs) **
|
|
' *******************************
|
|
PRI calc_chksum(ptr, hdrlen) : chksum
|
|
' Calculates IP checksums
|
|
' packet = pointer to IP packet
|
|
' returns: chksum
|
|
' http://www.geocities.com/SiliconValley/2072/bit33.txt
|
|
'chksum := calc_chksumhalf(packet, hdrlen)
|
|
chksum := nic.chksum_add(ptr, hdrlen)
|
|
chksum := calc_chksumfinal(chksum)
|
|
|
|
PRI calc_chksumfinal(chksumin) : chksum
|
|
' Performs the final part of checksums
|
|
chksum := (chksumin >> 16) + (chksumin & $FFFF)
|
|
chksum := (!chksum) & $FFFF
|
|
|
|
{PRI calc_chksumhalf(packet, hdrlen) : chksum
|
|
' Calculates checksum without doing the final stage of calculations
|
|
chksum := 0
|
|
repeat while hdrlen > 1
|
|
chksum += (BYTE[packet++] << 8) + BYTE[packet++]
|
|
chksum := (chksum >> 16) + (chksum & $FFFF)
|
|
hdrlen -= 2
|
|
if hdrlen > 0
|
|
chksum += BYTE[packet] << 8}
|
|
|
|
' ***************************
|
|
' ** Memory Access Helpers **
|
|
' ***************************
|
|
PRI conv_endianlong(in)
|
|
'return (in << 24) + ((in & $FF00) << 8) + ((in & $FF0000) >> 8) + (in >> 24) ' we can sometimes get away with shifting without masking, since shifts kill extra bits anyways
|
|
return (in.byte[0] << 24) + (in.byte[1] << 16) + (in.byte[2] << 8) + (in.byte[3])
|
|
|
|
PRI conv_endianword(in)
|
|
'return ((in & $FF) << 8) + ((in & $FF00) >> 8)
|
|
return (in.byte[0] << 8) + (in.byte[1])
|
|
|
|
PRI _handleConvert(userHandle, ptrHandle) | handle
|
|
' Checks to see if a handle index is valid
|
|
' Aborts if the handle is invalid
|
|
|
|
handle := userHandle.byte[0] ' extract the handle index from the lower 8 bits
|
|
|
|
if handle < 0 OR handle > constant(sNumSockets - 1) ' check the handle index to make sure we don't go out of bounds
|
|
abort ERRBADHANDLE
|
|
|
|
' check handle to make sure it's the one we want (rid ourselves of bad user handles)
|
|
' the current check method is as follows:
|
|
' - compare sDstPort
|
|
|
|
if wDstPort[handle] <> ((userHandle.byte[2] << 8) + userHandle.byte[1])
|
|
abort ERRBADHANDLE
|
|
|
|
' if we got here without aborting then we can assume the handle is good
|
|
LONG[ptrHandle] := handle
|
|
|
|
' ************************************
|
|
' ** Public Accessors (Thread Safe) **
|
|
' ************************************
|
|
PUB listen(port, _ptrrxbuff, _rxlen, _ptrtxbuff, _txlen) | handle
|
|
'' Sets up a socket for listening on a port
|
|
'' port = port number to listen on
|
|
'' ptrrxbuff = pointer to the rxbuffer array
|
|
'' rxlen = length of the rxbuffer array (must be power of 2)
|
|
'' ptrtxbuff = pointer to the txbuffer array
|
|
'' txlen = length of the txbuffer array (must be power of 2)
|
|
'' Returns handle if available, ERROUTOFSOCKETS if none available
|
|
'' Nonblocking
|
|
|
|
repeat while lockset(lock_id)
|
|
|
|
' just find any avail closed socket
|
|
handle := \find_socket(0, 0, 0)
|
|
|
|
if handle < 0
|
|
lockclr(lock_id)
|
|
abort ERROUTOFSOCKETS
|
|
|
|
rx_bufferptr[handle] := _ptrrxbuff
|
|
tx_bufferptr[handle] := _ptrtxbuff
|
|
rxbuffer_length[handle] := _rxlen
|
|
txbuffer_length[handle] := _txlen
|
|
rxbuffer_mask[handle] := _rxlen - 1
|
|
txbuffer_mask[handle] := _txlen - 1
|
|
|
|
lMySeqNum[handle] := 0
|
|
lMyAckNum[handle] := 0
|
|
lSrcIp[handle] := 0
|
|
lTime[handle] := 0
|
|
wLastTxLen[handle] := 0
|
|
wNotAcked[handle] := 0
|
|
bytefill(@bSrcMac[handle * 6], 0, 6)
|
|
|
|
wSrcPort[handle] := 0 ' no source port yet
|
|
wDstPort[handle] := conv_endianword(port) ' we do have a dest port though
|
|
|
|
wLastWin[handle] := rxbuffer_length[handle]
|
|
|
|
tx_head[handle] := 0
|
|
tx_tail[handle] := 0
|
|
tx_tailnew[handle] := 0
|
|
rx_head[handle] := 0
|
|
rx_tail[handle] := 0
|
|
|
|
' it's now listening
|
|
bConState[handle] := SLISTEN
|
|
|
|
lockclr(lock_id)
|
|
|
|
return ((port.byte[0] << 16) + (port.byte[1] << 8)) + handle
|
|
|
|
PUB connect(ipaddr, remoteport, _ptrrxbuff, _rxlen, _ptrtxbuff, _txlen) | handle, user_handle
|
|
'' Connect to remote host
|
|
'' ipaddr = ipv4 address packed into a long (ie: 1.2.3.4 => $01_02_03_04)
|
|
'' remoteport = port number to connect to
|
|
'' ptrrxbuff = pointer to the rxbuffer array
|
|
'' rxlen = length of the rxbuffer array (must be power of 2)
|
|
'' ptrtxbuff = pointer to the txbuffer array
|
|
'' txlen = length of the txbuffer array (must be power of 2)
|
|
'' Returns handle to new socket, ERROUTOFSOCKETS if no socket available
|
|
'' Nonblocking
|
|
|
|
repeat while lockset(lock_id)
|
|
|
|
' just find any avail closed socket
|
|
handle := \find_socket(0, 0, 0)
|
|
|
|
if handle < 0
|
|
lockclr(lock_id)
|
|
abort ERROUTOFSOCKETS
|
|
|
|
rx_bufferptr[handle] := _ptrrxbuff
|
|
tx_bufferptr[handle] := _ptrtxbuff
|
|
rxbuffer_length[handle] := _rxlen
|
|
txbuffer_length[handle] := _txlen
|
|
rxbuffer_mask[handle] := _rxlen - 1
|
|
txbuffer_mask[handle] := _txlen - 1
|
|
|
|
lMySeqNum[handle] := 0
|
|
lMyAckNum[handle] := 0
|
|
lTime[handle] := 0
|
|
wLastTxLen[handle] := 0
|
|
wNotAcked[handle] := 0
|
|
bytefill(@bSrcMac[handle * 6], 0, 6)
|
|
|
|
if(ip_ephport => EPHPORTEND) ' constrain ephport to specified range
|
|
ip_ephport := EPHPORTSTART
|
|
|
|
user_handle := ((ip_ephport.byte[0] << 16) + (ip_ephport.byte[1] << 8)) + handle
|
|
|
|
' copy in ip, port data (with respect to the remote host, since we use same code as server)
|
|
lSrcIp[handle] := conv_endianlong(ipaddr)
|
|
wSrcPort[handle] := conv_endianword(remoteport)
|
|
wDstPort[handle] := conv_endianword(ip_ephport++)
|
|
|
|
wLastWin[handle] := rxbuffer_length[handle]
|
|
|
|
tx_head[handle] := 0
|
|
tx_tail[handle] := 0
|
|
tx_tailnew[handle] := 0
|
|
rx_head[handle] := 0
|
|
rx_tail[handle] := 0
|
|
|
|
bConState[handle] := SCONNECTINGARP1
|
|
|
|
lockclr(lock_id)
|
|
|
|
return user_handle
|
|
|
|
PUB close(user_handle) | handle, state
|
|
'' Closes a connection
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
repeat while lockset(lock_id)
|
|
|
|
state := bConState[handle]
|
|
|
|
if state == SESTABLISHED
|
|
' try to gracefully close the connection
|
|
bConState[handle] := SCLOSING
|
|
elseif state <> SCLOSING AND state <> SCLOSING2
|
|
' we only do an ungraceful close if we are not in ESTABLISHED, CLOSING, or CLOSING2
|
|
bConState[handle] := SCLOSED
|
|
|
|
lockclr(lock_id)
|
|
|
|
' wait for the socket to close, this is very important to prevent the client app from reusing the buffers
|
|
repeat until (bConState[handle] == SCLOSING2) or (bConState[handle] == SCLOSED)
|
|
|
|
PUB isConnected(user_handle) | handle
|
|
'' Returns true if the socket is connected, false otherwise
|
|
|
|
if \_handleConvert(user_handle, @handle) <> 0
|
|
return false
|
|
|
|
return (bConState[handle] == SESTABLISHED)
|
|
|
|
PUB isValidHandle(user_handle) | handle
|
|
'' Checks to see if the handle is valid, handles will become invalid once they are used
|
|
'' In other words, a closed listening socket is now invalid, etc
|
|
|
|
{if handle < 0 OR handle > constant(sNumSockets - 1)
|
|
' obviously the handle index is out of range, so it's not valid!
|
|
return false}
|
|
|
|
if \_handleConvert(user_handle, @handle) < 0
|
|
return false
|
|
|
|
return (bConState[handle] <> SCLOSED)
|
|
|
|
PUB readDataNonBlocking(user_handle, ptr, maxlen) | handle, len, rxptr
|
|
'' Reads bytes from the socket
|
|
'' Returns number of read bytes
|
|
'' Not blocking (returns RETBUFFEREMPTY if no data)
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
if rx_tail[handle] == rx_head[handle]
|
|
return RETBUFFEREMPTY
|
|
|
|
len := (rx_head[handle] - rx_tail[handle]) & rxbuffer_mask[handle]
|
|
if maxlen < len
|
|
len := maxlen
|
|
|
|
rxptr := rx_bufferptr[handle]
|
|
|
|
if (len + rx_tail[handle]) > rxbuffer_length[handle]
|
|
bytemove(ptr, rxptr + rx_tail[handle], rxbuffer_length[handle] - rx_tail[handle])
|
|
bytemove(ptr + (rxbuffer_length[handle] - rx_tail[handle]), rxptr, len - (rxbuffer_length[handle] - rx_tail[handle]))
|
|
else
|
|
bytemove(ptr, rxptr + rx_tail[handle], len)
|
|
|
|
rx_tail[handle] := (rx_tail[handle] + len) & rxbuffer_mask[handle]
|
|
|
|
return len
|
|
|
|
PUB readData(user_handle, ptr, maxlen) : len | handle
|
|
'' Reads bytes from the socket
|
|
'' Returns the number of read bytes
|
|
'' Will block until data is received
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
repeat while (len := readDataNonBlocking(user_handle, ptr, maxlen)) < 0
|
|
ifnot isConnected(user_handle)
|
|
abort ERRSOCKETCLOSED
|
|
|
|
PUB readByteNonBlocking(user_handle) : rxbyte | handle, ptr
|
|
'' Read a byte from the specified socket
|
|
'' Will not block (returns RETBUFFEREMPTY if no byte avail)
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
rxbyte := RETBUFFEREMPTY
|
|
if rx_tail[handle] <> rx_head[handle]
|
|
ptr := rx_bufferptr[handle]
|
|
rxbyte := BYTE[ptr][rx_tail[handle]]
|
|
rx_tail[handle] := (rx_tail[handle] + 1) & rxbuffer_mask[handle]
|
|
|
|
PUB readByte(user_handle) : rxbyte | handle, ptr
|
|
'' Read a byte from the specified socket
|
|
'' Will block until a byte is received
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
repeat while (rxbyte := readByteNonBlocking(user_handle)) < 0
|
|
ifnot isConnected(user_handle)
|
|
abort ERRSOCKETCLOSED
|
|
|
|
PUB writeDataNonBlocking(user_handle, ptr, len) | handle, txptr
|
|
'' Writes bytes to the socket
|
|
'' Will not write anything unless your data fits in the buffer
|
|
'' Non blocking (returns RETBUFFERFULL if can't fit data)
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
if (txbuffer_mask[handle] - ((tx_head[handle] - tx_tail[handle]) & txbuffer_mask[handle])) < len
|
|
return RETBUFFERFULL
|
|
|
|
txptr := tx_bufferptr[handle]
|
|
|
|
if (len + tx_head[handle]) > txbuffer_length[handle]
|
|
bytemove(txptr + tx_head[handle], ptr, txbuffer_length[handle] - tx_head[handle])
|
|
bytemove(txptr, ptr + (txbuffer_length[handle] - tx_head[handle]), len - (txbuffer_length[handle] - tx_head[handle]))
|
|
else
|
|
bytemove(txptr + tx_head[handle], ptr, len)
|
|
|
|
tx_head[handle] := (tx_head[handle] + len) & txbuffer_mask[handle]
|
|
|
|
return len
|
|
|
|
PUB writeData(user_handle, ptr, len) | handle
|
|
'' Writes data to the specified socket
|
|
'' Will block until all data is queued to be sent
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
repeat while len > txbuffer_mask[handle]
|
|
repeat while writeDataNonBlocking(user_handle, ptr, txbuffer_mask[handle]) < 0
|
|
ifnot isConnected(user_handle)
|
|
abort ERRSOCKETCLOSED
|
|
len -= txbuffer_mask[handle]
|
|
ptr += txbuffer_mask[handle]
|
|
|
|
repeat while writeDataNonBlocking(user_handle, ptr, len) < 0
|
|
ifnot isConnected(user_handle)
|
|
abort ERRSOCKETCLOSED
|
|
|
|
PUB writeByteNonBlocking(user_handle, txbyte) | handle, ptr
|
|
'' Writes a byte to the specified socket
|
|
'' Will not block (returns RETBUFFERFULL if no buffer space available)
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
ifnot (tx_tail[handle] <> (tx_head[handle] + 1) & txbuffer_mask[handle])
|
|
return RETBUFFERFULL
|
|
|
|
ptr := tx_bufferptr[handle]
|
|
BYTE[ptr][tx_head[handle]] := txbyte
|
|
tx_head[handle] := (tx_head[handle] + 1) & txbuffer_mask[handle]
|
|
|
|
return txbyte
|
|
|
|
PUB writeByte(user_handle, txbyte) | handle
|
|
'' Write a byte to the specified socket
|
|
'' Will block until space is available for byte to be sent
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
repeat while writeByteNonBlocking(user_handle, txbyte) < 0
|
|
ifnot isConnected(user_handle)
|
|
abort ERRSOCKETCLOSED
|
|
|
|
PUB resetBuffers(user_handle) | handle
|
|
'' Resets send/receive buffers for the specified socket
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
rx_tail[handle] := rx_head[handle]
|
|
tx_head[handle] := tx_tail[handle]
|
|
|
|
PUB flush(user_handle) | handle
|
|
'' Flushes the send buffer (waits till the buffer is empty)
|
|
'' Will block until all tx data is sent
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
repeat while isConnected(user_handle) AND tx_tail[handle] <> tx_head[handle]
|
|
|
|
PUB getSocketState(user_handle) | handle
|
|
'' Gets the socket state (internal state numbers)
|
|
'' You can include driver_socket in any object and use the S... state constants for comparison
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
return bConState[handle]
|
|
|
|
PUB getReceiveBufferCount(user_handle) | handle
|
|
'' Returns the number of bytes in the receive buffer
|
|
|
|
_handleConvert(user_handle, @handle)
|
|
|
|
return (rx_head[handle] - rx_tail[handle]) & rxbuffer_mask[handle]
|
|
|
|
CON
|
|
'******************************************************************
|
|
'* TCP Flags
|
|
'******************************************************************
|
|
TCP_FIN = 1
|
|
TCP_SYN = 2
|
|
TCP_RST = 4
|
|
TCP_PSH = 8
|
|
TCP_ACK = 16
|
|
TCP_URG = 32
|
|
TCP_ECE = 64
|
|
TCP_CWR = 128
|
|
'******************************************************************
|
|
'* Ethernet Header Layout
|
|
'******************************************************************
|
|
enetpacketDest0 = $00 'destination mac address
|
|
enetpacketDest1 = $01
|
|
enetpacketDest2 = $02
|
|
enetpacketDest3 = $03
|
|
enetpacketDest4 = $04
|
|
enetpacketDest5 = $05
|
|
enetpacketSrc0 = $06 'source mac address
|
|
enetpacketSrc1 = $07
|
|
enetpacketSrc2 = $08
|
|
enetpacketSrc3 = $09
|
|
enetpacketSrc4 = $0A
|
|
enetpacketSrc5 = $0B
|
|
enetpacketType0 = $0C 'type/length field
|
|
enetpacketType1 = $0D
|
|
enetpacketData = $0E 'IP data area begins here
|
|
'******************************************************************
|
|
'* ARP Layout
|
|
'******************************************************************
|
|
arp_hwtype = $0E
|
|
arp_prtype = $10
|
|
arp_hwlen = $12
|
|
arp_prlen = $13
|
|
arp_op = $14
|
|
arp_shaddr = $16 'arp source mac address
|
|
arp_sipaddr = $1C 'arp source ip address
|
|
arp_thaddr = $20 'arp target mac address
|
|
arp_tipaddr = $26 'arp target ip address
|
|
'******************************************************************
|
|
'* IP Header Layout
|
|
'******************************************************************
|
|
ip_vers_len = $0E 'IP version and header length 1a19
|
|
ip_tos = $0F 'IP type of service
|
|
ip_pktlen = $10 'packet length
|
|
ip_id = $12 'datagram id
|
|
ip_frag_offset = $14 'fragment offset
|
|
ip_ttl = $16 'time to live
|
|
ip_proto = $17 'protocol (ICMP=1, TCP=6, UDP=11)
|
|
ip_hdr_cksum = $18 'header checksum 1a23
|
|
ip_srcaddr = $1A 'IP address of source
|
|
ip_destaddr = $1E 'IP addess of destination
|
|
ip_data = $22 'IP data area
|
|
'******************************************************************
|
|
'* TCP Header Layout
|
|
'******************************************************************
|
|
TCP_srcport = $22 'TCP source port
|
|
TCP_destport = $24 'TCP destination port
|
|
TCP_seqnum = $26 'sequence number
|
|
TCP_acknum = $2A 'acknowledgement number
|
|
TCP_hdrlen = $2E '4-bit header len (upper 4 bits)
|
|
TCP_hdrflags = $2F 'TCP flags
|
|
TCP_window = $30 'window size
|
|
TCP_cksum = $32 'TCP checksum
|
|
TCP_urgentptr = $34 'urgent pointer
|
|
TCP_data = $36 'option/data
|
|
'******************************************************************
|
|
'* IP Protocol Types
|
|
'******************************************************************
|
|
PROT_ICMP = $01
|
|
PROT_TCP = $06
|
|
PROT_UDP = $11
|
|
'******************************************************************
|
|
'* ICMP Header
|
|
'******************************************************************
|
|
ICMP_type = ip_data
|
|
ICMP_code = ICMP_type+1
|
|
ICMP_cksum = ICMP_code+1
|
|
ICMP_id = ICMP_cksum+2
|
|
ICMP_seqnum = ICMP_id+2
|
|
ICMP_data = ICMP_seqnum+2
|
|
'******************************************************************
|
|
'* UDP Header
|
|
'******************************************************************
|
|
UDP_srcport = ip_data
|
|
UDP_destport = UDP_srcport+2
|
|
UDP_len = UDP_destport+2
|
|
UDP_cksum = UDP_len+2
|
|
UDP_data = UDP_cksum+2
|
|
'******************************************************************
|
|
'* DHCP Message
|
|
'******************************************************************
|
|
DHCP_op = UDP_data
|
|
DHCP_htype = DHCP_op+1
|
|
DHCP_hlen = DHCP_htype+1
|
|
DHCP_hops = DHCP_hlen+1
|
|
DHCP_xid = DHCP_hops+1
|
|
DHCP_secs = DHCP_xid+4
|
|
DHCP_flags = DHCP_secs+2
|
|
DHCP_ciaddr = DHCP_flags+2
|
|
DHCP_yiaddr = DHCP_ciaddr+4
|
|
DHCP_siaddr = DHCP_yiaddr+4
|
|
DHCP_giaddr = DHCP_siaddr+4
|
|
DHCP_chaddr = DHCP_giaddr+4
|
|
DHCP_sname = DHCP_chaddr+16
|
|
DHCP_file = DHCP_sname+64
|
|
DHCP_options = DHCP_file+128
|
|
DHCP_message_end = DHCP_options+312
|