PPP-Blinky - Small Internet Protocol Stack using a standard se…

Users » nixnax » Code » PPP-Blinky

Nicolas Nackel / Mbed 2 deprecated PPP-Blinky

Small Internet Protocol Stack using a standard serial port.

PPP-Blinky - TCP/IP Networking Over a Serial Port

Note: The source code is at the bottom of this page.

/media/uploads/nixnax/blinky-connected.gif
A Windows desktop showing PPP-Blinky in the network connections list.

Describe PPP-Blinky in Three Sentences

PPP-Blinky is a tiny library that enables Internet protocols (IPv4) to any mbed target hardware by using only a serial port.

The code runs on processors with as little as 8k RAM, for example the Nucleo-L053R8 board.

PPP-Blinky uses the industry-standard PPP (Point-to-Point) Protocol and a tiny "stateless" TCP/IP stack.

No Ethernet Port Required

No ethernet port is required - PPP-Blinky uses a serial port to send IP packets to your PC.

PPP-Blinky emulates a standard dial-up modem and therefore connects to Windows, Linux or Adroid machines.

The code runs on most ARM mbed platforms such as the LPC11U24 shown in the picture below:

/media/uploads/nixnax/blinky-to-laptop1.jpg mbed LPC11u24 acting as a webserver to a Windows laptop.

Webserver

The Webserver and WebSocket functions are ideal for building browser-based GUIs on mbed-enabled hardware.

PPP-Blinky's HTTP webserver works with most web clients such as Internet Explorer, Mozilla Firefox, Google Chrome, Safari, Curl, wget and Lynx as well as Microsoft Powershell Invoke-Webrequest command.

In the image below Firefox web browser displays the main web page embedded into PPP-Blinky's code:

/media/uploads/nixnax/ppp-blinky-firefox.jpg Firefox web browser displays a web page embedded into PPP-Blinky's code

WebSocket Service

WebSocket is the most popular protocol standard for real-time bidirectional TCP/IP communication between clients and servers.
In the image below a small Internet Explorer script has connected to PPP-Blinky's WebSocket Service.
A websocket message was then sent by the browser and was echoed back by the WebSocket, triggering the onmessage event in the script.
The WebSocket service enables bidirectional real-time interaction between PPP-Blinky and any element in the browser DOM via JavaScript.
If you already have PPP-Blinky up and running you can test your WebSocket service using this: http://jsfiddle.net/d26cyuh2/112/embedded/result
Websockets are ideal for building browser-based GUIs for mbed hardware.

/media/uploads/nixnax/ppp-blinky-websocke-2.gif

Trying PPP-Blinky on your mbed board

You will need an mbed-enabled hardware board: https://developer.mbed.org/platforms/

Establish a serial port connection between your host PC and your mbed board. The easiest way is to use mbed hardware with a USB serial debug port. I've tried the ST-Micro Nucleo-L476RG, Nucleo-L152RE, Nucleo-F401RE, Nucleo-L432KC, Nucleo-L053R8, mbed-LPC11U24 and mbed-LPC1768 boards and they all work out of the box. Use the mbed online compiler to compile the software for your target board. Save the compiled binary to your hardware.

Before establishing a network connection, you can verify the operation of the code by opening a terminal program such as Tera Term, and setting the baud rate of the COM port on your mbed board to 115200 baud. LED1 should toggle for every two 0x7E (~) (i.e. tilde) characters you type, as 0x7E is the PPP frame start/end marker. Don't forget to close the port when your'e done testing, or else Windows Dial-up Networking will report that the COM port is in use by another program when you try to connect.

Once you are certain that the serial port and firmware is working, proceed to creating a new network connection on your PC -see below.

Creating a Dial-up Connection in Windows

/media/uploads/nixnax/modem.jpg

Setting up Dial-Up Networking (DUN) on your Windows 7 or 8 PC is essentially a two-step process: First, you create a new modem device, because PPP-blinky partially emulates a standard Windows serial port modem device. Second, you create a new Internet connection (in practice, a new network adapter) which is associated with your new "modem".

Step-by-step description of how to configure Windows for PPP-Blinky here:

/users/nixnax/code/PPP-Blinky/wiki/Configuring-Windows-Dial-Up-Networking

There is also a screen on how to set up Linux dial-up networking near the bottom of this page.

Connecting to PPP-Blinky from your PC

Once Windows networking is configured you can establish a dial-up connection to your mbed board over the USB virtual com port.

The IP address you manually assigned to the new dial-up network adapter (172.10.10.1) functions as a gateway to any valid IP address on that subnet. In the screen capture below, I'm sending pings from the Windows 8 command line to my ST-Micro Nucleo-L476RG board over the USB virtual serial Port. I'm also using a second serial port and Tera Term to capture the debug output from a second serial port on the hardware. The optional debug output from the board prints out the IP source and destination address and the first few bytes of the data payload. Note that the source is the adapter IP address, (172.10.10.1 in this case) and the destination is some other address on that subnet - all packets to the subnet are sent to our mbed hardware. For example, you could also ping 172.10.10.123 or, if your PPP-Blinky is running, simply click on this link: http://172.10.10.123

/media/uploads/nixnax/ping-cap-3.gif

One Million Pings!

In the image below the ICMP ("ping") echo reply service was tested by sending one million pings to ppp-Blinky. This took over two hours.
The ping tool used on the Windows 8 PC was psping.exe from PsTools by Mark Russinovich - http://bit.ly/PingFast
The average reply time for a short ping (1 byte of payload data) was 11 milliseconds at 115200 baud on the $10 Nucleo-L053R8 board - barely enough time for 130 bytes to be sent over the port!

/media/uploads/nixnax/ppp-blinky-ping-results.jpg

Monitoring PPP-Blinky Packets

The image below is from a Microsoft Network Monitor 3.4 capture session.

Responses from PPP-Blinky are shown in blue.

Frame 2 - Internet Explorer at IP 172.10.10.1 (the Dial-Up Adapter IP) requests a TCP connection by sending an S (SYN) flag.
Frame 3 - PPP-Blinky at IP 172.10.10.2 responds with an ACK in frame 3. One direction of the link is now established.
Frame 4 - The PC acknowledges the SYN sent by PPP-Blinky in frame 3. The TCP link is now fully established.
Frame 5 - The browser "pushes" (P flag is set) an HTTP GET request to PPP-Blinky.
Frame 6 - PPP-Blinky responds with a standard HTTP response "pushes" (P flag set) back a small web page. It also sets the A (ACK) flag to acknowledge the message sent in frame 6.
Frame 7 - The PC acknowledges reception of the HTTP payload.
Frame 8 - The PC starts to shut down the TCP connection by sending a FIN flag.
Frame 9 - PPP-Blinky acknowledges the FIN request - the connection is now closed in one direction. It also sets a FIN flag in the response to request closure of the opposite direction of the connection.
Frame 10 - The PC acknowledges the FIN request. The closing of the TCP connection is now confirmed in both directions.

/media/uploads/nixnax/ms-network-monitor-http-get-1.gif

Debug Output

PPP-Blinky can output handy debug information to an optional second serial port.
The image below shows the debug output (Ident, Source, Destination, TCP Flags) for a complete HTTP conversation.
The PC messages are displayed in black. PPP-Blinky messages are blue.
Notice how PPP-blinky automatically inserts a blank line after each full HTTP conversation.

/media/uploads/nixnax/tcp-data-3.gif

Creating a Dial-Up Connection in Linux

The screen below shows the required pppd command to connect to PPP-Blinky from a Linux machine. This was much simpler than Windows! The USB serial port of the mbed LPC1768 board registered as /dev/ttyACM0 on my Linux box. Do a websearch on pppd if you want to learn more about pppd, the Linux PPP handler. Near the bottom of the screen below, two webpages are fetched (/ and /y) by using the curl command on the command line. Gnome Webkit and Firefox work fine, too. Also try echo GET / HTTP/1.1 | nc 172.10.10.2 which uses netcat, the "Swiss army knife" of networking tools. PPP-Blinky was also tested with ApacheBench, the Apache server benchmark software. After 100000 fetches, the mean page fetch rate was reported as 6 page fetches per second for a small page.

/media/uploads/nixnax/pppd-screen.png

Caveats

PPP Blinky is an extremely sparse implementation (1.5k lines) of HTTP,WebSocket,TCP, UDP, ICMP, IPCP and LCP over PPP, requiring around 8kB of RAM. The minimum functionality required to establish connectivity is implemented. These are often acceptable tradeoffs for embedded projects as well as a handy tool to learn the practical details of everyday networking implementations.

main.cpp@135:6c3eec2fa634, 2017-08-16 (annotated)

Committer:: nixnax
Date:: Wed Aug 16 11:56:14 2017 +0000
Revision:: 135:6c3eec2fa634
Parent:: 134:af9d1f8d451d
Child:: 136:28a838086979

Added menu to root page

Who changed what in which revision?

User	Revision	Line number	New contents of line
nixnax	93:9675adc36882	1	// PPP-Blinky - "The Most Basic Internet Of Things"
nixnax	0:2cf4880c312a	2
nixnax	128:e5958d143e9d	3	// A Tiny HTTP Webserver Using Windows XP/7/8/10/Linux Dial-Up Networking Over A Serial Port.
nixnax	41:e58a5a09f411	4	// Also receives UDP packets and responds to ping (ICMP Echo requests)
nixnax	128:e5958d143e9d	5	// Also: WebSocket Service - see https://en.wikipedia.org/wiki/WebSocket
nixnax	4:a469050d5b80	6
nixnax	93:9675adc36882	7	// Copyright 2016/2017 Nicolas Nackel aka Nixnax. 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.
nixnax	81:9ede60e9a2c8	8
nixnax	41:e58a5a09f411	9	// Notes and Instructions
nixnax	41:e58a5a09f411	10	// http://bit.ly/PPP-Blinky-Instructions
nixnax	114:8a5d70bbc1b2	11	// http://bit.ly/win-rasdial-config
nixnax	0:2cf4880c312a	12
nixnax	41:e58a5a09f411	13	// Handy reading material
nixnax	6:fba4c2e817b8	14	// https://technet.microsoft.com/en-us/library/cc957992.aspx
nixnax	9:0992486d4a30	15	// https://en.wikibooks.org/wiki/Serial_Programming/IP_Over_Serial_Connections
nixnax	39:b90183d35f1e	16	// http://bit.ly/dialup777error - how to solve Dial Up Error 777 in Windows 7/8/10
nixnax	41:e58a5a09f411	17	// http://atari.kensclassics.org/wcomlog.htm
nixnax	6:fba4c2e817b8	18
nixnax	29:30de79d658f6	19	// Handy tools
nixnax	44:d0c61ae49ea5	20	// https://ttssh2.osdn.jp/index.html.en - Tera Term, a good terminal program to monitor the debug output from the second serial port with!
nixnax	109:644a59ebb5b1	21	// https://www.microsoft.com/en-us/download/details.aspx?id=4865 - Microsoft network monitor - real-time monitoring of PPP packets
nixnax	29:30de79d658f6	22	// http://pingtester.net/ - nice tool for high rate ping testing
nixnax	95:40af49390daf	23	// http://www.sunshine2k.de/coding/javascript/crc/crc_js.html - Correctly calculates the 16-bit FCS (crc) on our frames (Choose CRC16_CCITT_FALSE), then custom relected-in=1, reflected-out=1
nixnax	29:30de79d658f6	24	// https://technet.microsoft.com/en-us/sysinternals/pstools.aspx - psping for fast testing of ICMP ping function
nixnax	41:e58a5a09f411	25	// https://eternallybored.org/misc/netcat/ - use netcat -u 172.10.10.1 80 to send/receive UDP packets from PPP-Blinky
nixnax	91:5141ae9fba53	26	// Windows Powershell invoke-webrequest command - use it to stress test the webserver like this: while (1){ invoke-webrequest -uri 172.10.10.1/x }
nixnax	41:e58a5a09f411	27
nixnax	92:cb962b365cce	28	// Connecting PPP-Blinky to Linux
nixnax	93:9675adc36882	29	// PPP-Blinky can be made to talk to Linux - tested on Fedora - the following command, which uses pppd, works:
nixnax	93:9675adc36882	30	// pppd /dev/ttyACM0 115200 debug dump local passive noccp novj nodetach nocrtscts 172.10.10.1:172.10.10.2
nixnax	92:cb962b365cce	31	// in the above command 172.10.10.1 is the adapter IP, and 172.10.10.2 is the IP of PPP-Blinky.
nixnax	93:9675adc36882	32	// See also https://en.wikipedia.org/wiki/Point-to-Point_Protocol_daemon
nixnax	93:9675adc36882	33
nixnax	133:0f5b4085b6d3	34	// Special pages in PPP-Blinky
nixnax	133:0f5b4085b6d3	35	// 172.10.10.2/x returns a number that increments every time you request a page - this is handy for testing
nixnax	133:0f5b4085b6d3	36	// 172.10.10.2/xb also returns a number, but issues a fast refresh command. This allows you to use your browser to benchmark page load speed
nixnax	133:0f5b4085b6d3	37	// 172.10.10.2/ws brings up a simple websocket demo
nixnax	128:e5958d143e9d	38
nixnax	93:9675adc36882	39	// Ok, enough talking, time to check out some code!!
nixnax	106:d14e6b597ca3	40
nixnax	81:9ede60e9a2c8	41	#include "mbed.h"
nixnax	128:e5958d143e9d	42	#include "sha1.h"
nixnax	130:45ee0d648a72	43	#include "BufferedSerial.h"
nixnax	131:134b6d0c11e9	44
nixnax	93:9675adc36882	45	// The #define below enables/disables a second (OPTIONAL) serial port that prints out interesting diagnostic messages.
nixnax	66:f005b9fdf4d1	46	// Change to SERIAL_PORT_MONITOR_YES to enable diagnostics messages. You need to wire a second serial port to your mbed hardware to monitor this.
nixnax	110:baec959e1915	47	// Note - the LPC11U24 does NOT have a second serial port
nixnax	134:af9d1f8d451d	48	#define SERIAL_PORT_MONITOR_NO /* change to SERIAL_PORT_MONITOR_YES for debug messages */
nixnax	0:2cf4880c312a	49
nixnax	93:9675adc36882	50	// here we define the OPTIONAL, second debug serial port for the various target boards
nixnax	93:9675adc36882	51	// insert your target board's port here if it's not in yet - if it works, please send it to me - thanks!!!
nixnax	129:b8a0b0e8cff1	52	// note - if you enable this, some packets may initially be missed which will cause some retransmits
nixnax	114:8a5d70bbc1b2	53	#ifdef SERIAL_PORT_MONITOR_YES
nixnax	128:e5958d143e9d	54	#if defined(TARGET_LPC1768)
nixnax	117:c819ae068336	55	Serial xx(p9, p10); // Second serial port on LPC1768 - not required to run, if you get compile error here, change #define SERIAL_PORT_MONITOR_YES to #define SERIAL_PORT_MONITOR_NO
nixnax	117:c819ae068336	56	#elif defined(TARGET_NUCLEO_F446RE) \|\| defined(TARGET_NUCLEO_L152RE) \|\| defined(TARGET_NUCLEO_L053R8) \|\| defined(TARGET_NUCLEO_L476RG) \|\| defined(TARGET_NUCLEO_F401RE)
nixnax	117:c819ae068336	57	Serial xx(PC_10, PC_11); // Second serial port on NUCLEO boards - not required to run, if you get compile error here, change #define SERIAL_PORT_MONITOR_YES to #define SERIAL_PORT_MONITOR_NO
nixnax	117:c819ae068336	58	#elif defined(TARGET_LPC11U24)
nixnax	117:c819ae068336	59	#error The LPC11U24 does not have a second serial port to use for debugging - change SERIAL_PORT_MONITOR_YES back to SERIAL_PORT_MONITOR_NO
nixnax	128:e5958d143e9d	60	#elif defined (TARGET_KL46Z) \|\| (TARGET_KL25Z)
nixnax	128:e5958d143e9d	61	Serial xx(PTE0,PTE1); // Second serial port on FRDM-KL46Z board
nixnax	118:54d1936e3768	62	#elif defined(YOUR_TARGET_BOARD_NAME_HERE)
nixnax	118:54d1936e3768	63	Serial xx(p9, p10); // insert your board's debug serial port pins here - and please send it to me if it works
nixnax	85:53e57ff1cf05	64	#else
nixnax	117:c819ae068336	65	#error Add your target board's second serial port here if you want to use debugging - or choose SERIAL_PORT_MONITOR_NO
nixnax	117:c819ae068336	66	#endif
nixnax	119:e14dd2bf0ea3	67	#define debugPrintf(x...) xx.printf (x) /* if we have a serial port we print debug messages */
nixnax	119:e14dd2bf0ea3	68	#define debugPutc(x...) xx.putc(x)
nixnax	118:54d1936e3768	69	#define debugBaudRate(x...) xx.baud(x)
nixnax	117:c819ae068336	70	#else
nixnax	119:e14dd2bf0ea3	71	// if we don't have a debug port the debug print functions do nothing
nixnax	119:e14dd2bf0ea3	72	#define debugPrintf(x...) {}
nixnax	119:e14dd2bf0ea3	73	#define debugPutc(x...) {}
nixnax	118:54d1936e3768	74	#define debugBaudRate(x...) {}
nixnax	41:e58a5a09f411	75	#endif
nixnax	41:e58a5a09f411	76
nixnax	110:baec959e1915	77	// verbosity flags used in debug printouts - change to 1 to see increasingly more detailed debug info.
nixnax	112:30172f36bd33	78	#define v0 1
nixnax	124:18ef53f1d8b7	79	#define v1 0
nixnax	77:abf92baebb42	80	#define v2 0
nixnax	114:8a5d70bbc1b2	81	#define IP_HEADER_DUMP_YES /* YES for ip header dump */
nixnax	114:8a5d70bbc1b2	82	#define TCP_HEADER_DUMP_YES /* YES for tcp header dump */
nixnax	29:30de79d658f6	83
nixnax	93:9675adc36882	84	// this is the webpage we serve when we get an HTTP request to root (/)
nixnax	93:9675adc36882	85	// keep size under ~900 bytes to fit into a single PPP packet
nixnax	133:0f5b4085b6d3	86
nixnax	93:9675adc36882	87	const static char rootWebPage[] = "\
nixnax	66:f005b9fdf4d1	88	<!DOCTYPE html>\
nixnax	66:f005b9fdf4d1	89	<html>\
nixnax	66:f005b9fdf4d1	90	<head>\
nixnax	128:e5958d143e9d	91	<title>mbed PPP-Blinky</title>\
nixnax	66:f005b9fdf4d1	92	<script>\
nixnax	66:f005b9fdf4d1	93	window.onload=function(){\
nixnax	66:f005b9fdf4d1	94	setInterval(function(){function x(){return document.getElementById('w');};\
nixnax	128:e5958d143e9d	95	x().textContent=parseInt(x().textContent)+1;},100);};\
nixnax	66:f005b9fdf4d1	96	</script>\
nixnax	66:f005b9fdf4d1	97	</head>\
nixnax	135:6c3eec2fa634	98	<body style=\"font-family: sans-serif; font-size:25px; color:#807070\">\
nixnax	66:f005b9fdf4d1	99	<h1>mbed PPP-Blinky Up and Running</h1>\
nixnax	66:f005b9fdf4d1	100	<h1 id=\"w\" style=\"text-align:center;\">0</h1>\
nixnax	66:f005b9fdf4d1	101	<h1><a href=\"http://bit.ly/pppBlink2\">Source on mbed</a></h1>\
nixnax	135:6c3eec2fa634	102	<h1><a href=\"/ws\">WebSocket Demo</a></h1>\
nixnax	135:6c3eec2fa634	103	<h1><a href=\"/x\">Benchmark 1</a></h1>\
nixnax	135:6c3eec2fa634	104	<h1><a href=\"/xb\">Benchmark 2</a></h1>\
nixnax	66:f005b9fdf4d1	105	</body>\
nixnax	133:0f5b4085b6d3	106	</html>"; // 460 characters plus 1 null byte = 461
nixnax	133:0f5b4085b6d3	107
nixnax	133:0f5b4085b6d3	108	const static char webSocketPage[] = "\
nixnax	133:0f5b4085b6d3	109	<!DOCTYPE html>\
nixnax	133:0f5b4085b6d3	110	<html>\
nixnax	133:0f5b4085b6d3	111	<head>\
nixnax	133:0f5b4085b6d3	112	<title>mbed PPP-Blinky</title>\
nixnax	133:0f5b4085b6d3	113	<script>\
nixnax	133:0f5b4085b6d3	114	window.onload=function(){\
nixnax	133:0f5b4085b6d3	115	var url=\"ws://172.10.10.2\";\
nixnax	133:0f5b4085b6d3	116	var sts=document.getElementById(\"sts\");\
nixnax	133:0f5b4085b6d3	117	var btn=document.getElementById(\"btn\");\
nixnax	133:0f5b4085b6d3	118	var ctr=0;\
nixnax	133:0f5b4085b6d3	119	function show(text){sts.textContent=text;}\
nixnax	133:0f5b4085b6d3	120	btn.onclick=function(){\
nixnax	133:0f5b4085b6d3	121	if(btn.textContent==\"Connect\"){\
nixnax	133:0f5b4085b6d3	122	x=new WebSocket(url);\
nixnax	133:0f5b4085b6d3	123	x.onopen=function(){\
nixnax	133:0f5b4085b6d3	124	show(\"Connected to : \"+url);\
nixnax	133:0f5b4085b6d3	125	btn.textContent=\"Send \\\"\"+ctr+\"\\\"\";\
nixnax	133:0f5b4085b6d3	126	};\
nixnax	133:0f5b4085b6d3	127	x.onclose=function(){show(\"closed\");};\
nixnax	133:0f5b4085b6d3	128	x.onmessage=function(msg){show(\"PPP-Blinky Sent: \\\"\"+msg.data+\"\\\"\");};\
nixnax	133:0f5b4085b6d3	129	} else {\
nixnax	133:0f5b4085b6d3	130	x.send(ctr);\
nixnax	133:0f5b4085b6d3	131	ctr=ctr+1;\
nixnax	133:0f5b4085b6d3	132	btn.textContent=\"Send \\\"\"+ctr+\"\\\"\";\
nixnax	133:0f5b4085b6d3	133	}\
nixnax	133:0f5b4085b6d3	134	};\
nixnax	133:0f5b4085b6d3	135	};\
nixnax	133:0f5b4085b6d3	136	</script>\
nixnax	135:6c3eec2fa634	137	<body style=\"font-family: sans-serif; font-size:25px; color:#807070\">\
nixnax	135:6c3eec2fa634	138	<h1>PPP-Blinky WebSocket Test</h1>\
nixnax	133:0f5b4085b6d3	139	<div id=\"sts\">Idle</div>\
nixnax	133:0f5b4085b6d3	140	<button id=\"btn\" style=\"font-size: 100%; margin-top: 55px; margin-bottom: 55px;\">Connect</button>\
nixnax	133:0f5b4085b6d3	141	<h4><a href=\"/\">PPP-Blinky home</a></h4>\
nixnax	133:0f5b4085b6d3	142	</body>\
nixnax	133:0f5b4085b6d3	143	</html>";
nixnax	69:23f560087c16	144
nixnax	73:2f56ec87dbe9	145	// The serial port on your mbed hardware. Your PC should be configured to view this port as a standard dial-up networking modem.
nixnax	73:2f56ec87dbe9	146	// On Windows the model type of the modem should be selected as "Communications cable between two computers"
nixnax	72:ad3d12753acf	147	// The modem baud rate should be set to 115200 baud
nixnax	72:ad3d12753acf	148	// See instructions at the top.
nixnax	73:2f56ec87dbe9	149	// On a typical mbed hardware platform this serial port is a USB virtual com port (VCP) and the USB serial driver is supplied by the board vendor.
nixnax	132:09b66cc5cf4a	150	BufferedSerial pc(USBTX, USBRX, 100); // usb virtual com port for mbed hardware
nixnax	29:30de79d658f6	151
nixnax	29:30de79d658f6	152	DigitalOut led1(LED1); // this led toggles when a packet is received
nixnax	4:a469050d5b80	153
nixnax	66:f005b9fdf4d1	154	// the standard hdlc frame start/end character. It's the tilde character "~"
nixnax	4:a469050d5b80	155	#define FRAME_7E (0x7e)
nixnax	29:30de79d658f6	156
nixnax	29:30de79d658f6	157	// a structure to keep all our ppp globals in
nixnax	29:30de79d658f6	158	struct pppType {
nixnax	38:ab582987926e	159	int online; // we hunt for a PPP connection if this is zero
nixnax	38:ab582987926e	160	int crc; // for calculating IP and TCP CRCs
nixnax	38:ab582987926e	161	int ledState; // state of LED1
nixnax	98:3babad0d1bd4	162	int httpPageCount;
nixnax	119:e14dd2bf0ea3	163	int firstFrame; // cleared after first frame
nixnax	4:a469050d5b80	164	struct {
nixnax	126:4e1058fa2128	165	#define RXBUFLEN (1<<11)
nixnax	117:c819ae068336	166	// the serial port receive buffer and packet buffer, size is RXBUFLEN (currently 2048 bytes)
nixnax	85:53e57ff1cf05	167	char buf[RXBUFLEN]; // RXBUFLEN MUST be a power of two because we use & operator for fast wrap-around in ring buffer
nixnax	93:9675adc36882	168	int head;
nixnax	93:9675adc36882	169	int tail;
nixnax	95:40af49390daf	170	int rtail;
nixnax	93:9675adc36882	171	int buflevel;
nixnax	38:ab582987926e	172	} rx; // serial port objects
nixnax	4:a469050d5b80	173	struct {
nixnax	38:ab582987926e	174	int len; // number of bytes in buffer
nixnax	38:ab582987926e	175	int crc; // PPP CRC (frame check)
nixnax	122:963abcbff21e	176	#define PPP_max_size 2500
nixnax	123:fc64fc6caae0	177	// we are assuming 1000 bytes more than MTU size of 1500 - due to the PPP encoding of special bytes
nixnax	122:963abcbff21e	178	char buf[PPP_max_size]; // send and receive buffer large enough for raw, encoded PPP/HDLC frames
nixnax	38:ab582987926e	179	} pkt; // ppp buffer objects
nixnax	50:ad4e7c3c88e5	180	struct {
nixnax	50:ad4e7c3c88e5	181	int frameStartIndex; // frame start marker
nixnax	50:ad4e7c3c88e5	182	int frameEndIndex; // frame end marker
nixnax	50:ad4e7c3c88e5	183	} hdlc; // hdlc frame objects
nixnax	114:8a5d70bbc1b2	184	struct {
nixnax	114:8a5d70bbc1b2	185	unsigned int ident; // our IP ident value (outgoing frame count)
nixnax	114:8a5d70bbc1b2	186	} ip; // ip related object
nixnax	29:30de79d658f6	187	};
nixnax	31:e000c1b9c565	188
nixnax	29:30de79d658f6	189	pppType ppp; // our global - definitely not thread safe
nixnax	0:2cf4880c312a	190
nixnax	93:9675adc36882	191	// Initialize our global structure, clear the buffer, etc.
nixnax	29:30de79d658f6	192	void pppInitStruct()
nixnax	29:30de79d658f6	193	{
nixnax	81:9ede60e9a2c8	194	memset( ppp.rx.buf, 0, RXBUFLEN);
nixnax	29:30de79d658f6	195	ppp.online=0;
nixnax	29:30de79d658f6	196	ppp.rx.tail=0;
nixnax	93:9675adc36882	197	ppp.rx.rtail=0;
nixnax	29:30de79d658f6	198	ppp.rx.head=0;
nixnax	81:9ede60e9a2c8	199	ppp.rx.buflevel=0;
nixnax	29:30de79d658f6	200	ppp.pkt.len=0;
nixnax	114:8a5d70bbc1b2	201	ppp.ip.ident=10000; // easy to recognize in ip packet dumps
nixnax	29:30de79d658f6	202	ppp.ledState=0;
nixnax	81:9ede60e9a2c8	203	ppp.hdlc.frameStartIndex=0;
nixnax	98:3babad0d1bd4	204	ppp.httpPageCount=0;
nixnax	119:e14dd2bf0ea3	205	ppp.firstFrame=1;
nixnax	29:30de79d658f6	206	}
nixnax	26:11f4eb2663a7	207
nixnax	43:aa57db08995d	208	void led1Toggle()
nixnax	43:aa57db08995d	209	{
nixnax	43:aa57db08995d	210	ppp.ledState = ppp.ledState? 0 : 1;
nixnax	93:9675adc36882	211	led1 = ppp.ledState; // toggle led
nixnax	43:aa57db08995d	212	}
nixnax	43:aa57db08995d	213
nixnax	85:53e57ff1cf05	214	// fill our own receive buffer with characters from the PPP serial port
nixnax	85:53e57ff1cf05	215	void fillbuf()
nixnax	0:2cf4880c312a	216	{
nixnax	107:5fe806713d49	217	char ch;
nixnax	85:53e57ff1cf05	218	if ( pc.readable() ) {
nixnax	85:53e57ff1cf05	219	int hd = (ppp.rx.head+1)&(RXBUFLEN-1); // increment/wrap head index
nixnax	93:9675adc36882	220	if ( hd == ppp.rx.rtail ) {
nixnax	119:e14dd2bf0ea3	221	debugPrintf("\nReceive buffer full\n");
nixnax	85:53e57ff1cf05	222	return;
nixnax	83:cdcb81d1910f	223	}
nixnax	107:5fe806713d49	224	ch = pc.getc(); // read new character
nixnax	107:5fe806713d49	225	ppp.rx.buf[ppp.rx.head] = ch; // insert in our receive buffer
nixnax	107:5fe806713d49	226	if ( ppp.online == 0 ) {
nixnax	107:5fe806713d49	227	if (ch == 0x7E) {
nixnax	107:5fe806713d49	228	ppp.online = 1;
nixnax	114:8a5d70bbc1b2	229	}
nixnax	114:8a5d70bbc1b2	230	}
nixnax	20:5db9b77b38a6	231	ppp.rx.head = hd; // update head pointer
nixnax	81:9ede60e9a2c8	232	ppp.rx.buflevel++;
nixnax	15:b0154c910143	233	}
nixnax	0:2cf4880c312a	234	}
nixnax	0:2cf4880c312a	235
nixnax	118:54d1936e3768	236	// print to debug port while checking for incoming characters
nixnax	119:e14dd2bf0ea3	237	void putcWhileCheckingInput( char outByte )
nixnax	119:e14dd2bf0ea3	238	{
nixnax	119:e14dd2bf0ea3	239	#ifdef SERIAL_PORT_MONITOR_YES
nixnax	119:e14dd2bf0ea3	240	fillbuf();
nixnax	119:e14dd2bf0ea3	241	debugPutc( outByte );
nixnax	119:e14dd2bf0ea3	242	fillbuf();
nixnax	119:e14dd2bf0ea3	243	#endif
nixnax	119:e14dd2bf0ea3	244	}
nixnax	119:e14dd2bf0ea3	245
nixnax	125:ea88200b1df6	246	void putsWhileCheckingInput( char * data )
nixnax	118:54d1936e3768	247	{
nixnax	118:54d1936e3768	248	#ifdef SERIAL_PORT_MONITOR_YES
nixnax	118:54d1936e3768	249	char * nextChar = data;
nixnax	118:54d1936e3768	250	while( *nextChar != 0 ) {
nixnax	119:e14dd2bf0ea3	251	putcWhileCheckingInput( *nextChar ); // write one character to debug port while checking input
nixnax	118:54d1936e3768	252	nextChar++;
nixnax	128:e5958d143e9d	253	}
nixnax	118:54d1936e3768	254	#endif
nixnax	118:54d1936e3768	255	}
nixnax	118:54d1936e3768	256
nixnax	124:18ef53f1d8b7	257	// a sniffer tool to assist in figuring out where in the code we are having characters in the input buffer
nixnax	124:18ef53f1d8b7	258	void qq()
nixnax	124:18ef53f1d8b7	259	{
nixnax	125:ea88200b1df6	260	if ( pc.readable() ) putsWhileCheckingInput( "Character available!\n" );
nixnax	124:18ef53f1d8b7	261	}
nixnax	124:18ef53f1d8b7	262
nixnax	118:54d1936e3768	263	void crcReset()
nixnax	118:54d1936e3768	264	{
nixnax	118:54d1936e3768	265	ppp.crc=0xffff; // crc restart
nixnax	118:54d1936e3768	266	}
nixnax	118:54d1936e3768	267
nixnax	118:54d1936e3768	268	void crcDo(int x) // cumulative crc
nixnax	118:54d1936e3768	269	{
nixnax	118:54d1936e3768	270	for (int i=0; i<8; i++) {
nixnax	118:54d1936e3768	271	ppp.crc=((ppp.crc&1)^(x&1))?(ppp.crc>>1)^0x8408:ppp.crc>>1; // crc calculator
nixnax	118:54d1936e3768	272	x>>=1;
nixnax	118:54d1936e3768	273	}
nixnax	124:18ef53f1d8b7	274	fillbuf(); // handle input
nixnax	118:54d1936e3768	275	}
nixnax	118:54d1936e3768	276
nixnax	118:54d1936e3768	277	int crcBuf(char * buf, int size) // crc on an entire block of memory
nixnax	118:54d1936e3768	278	{
nixnax	118:54d1936e3768	279	crcReset();
nixnax	118:54d1936e3768	280	for(int i=0; i<size; i++)crcDo(*buf++);
nixnax	118:54d1936e3768	281	return ppp.crc;
nixnax	118:54d1936e3768	282	}
nixnax	118:54d1936e3768	283
nixnax	85:53e57ff1cf05	284	int pc_getBuf() // get one character from the buffer
nixnax	0:2cf4880c312a	285	{
nixnax	63:9253b0e1b7d8	286	int x = ppp.rx.buf[ ppp.rx.tail ];
nixnax	81:9ede60e9a2c8	287	ppp.rx.tail=(ppp.rx.tail+1)&(RXBUFLEN-1);
nixnax	81:9ede60e9a2c8	288	ppp.rx.buflevel--;
nixnax	63:9253b0e1b7d8	289	return x;
nixnax	0:2cf4880c312a	290	}
nixnax	0:2cf4880c312a	291
nixnax	95:40af49390daf	292	// Note - the hex output of dumpPPPFrame() can be imported into WireShark
nixnax	95:40af49390daf	293	// Capture the frame's hex output in your terminal program and save as a text file
nixnax	95:40af49390daf	294	// In WireShark, use "Import Hex File". Options are: Offset=None, Protocol=PPP.
nixnax	95:40af49390daf	295	void dumpPPPFrame()
nixnax	95:40af49390daf	296	{
nixnax	120:bef89e4c906e	297	char pbuf[30];
nixnax	120:bef89e4c906e	298	for(int i=0; i<ppp.pkt.len; i++) {
nixnax	124:18ef53f1d8b7	299	fillbuf();
nixnax	124:18ef53f1d8b7	300	sprintf(pbuf, "%02x ", ppp.pkt.buf[i]);
nixnax	124:18ef53f1d8b7	301	fillbuf();
nixnax	125:ea88200b1df6	302	putsWhileCheckingInput(pbuf);
nixnax	124:18ef53f1d8b7	303	}
nixnax	124:18ef53f1d8b7	304	fillbuf();
nixnax	124:18ef53f1d8b7	305	sprintf(pbuf, " CRC=%04x Len=%d\n", ppp.pkt.crc, ppp.pkt.len);
nixnax	124:18ef53f1d8b7	306	fillbuf();
nixnax	125:ea88200b1df6	307	putsWhileCheckingInput(pbuf);
nixnax	95:40af49390daf	308	}
nixnax	95:40af49390daf	309
nixnax	119:e14dd2bf0ea3	310	void processPPPFrame(int start, int end) // process received frame
nixnax	29:30de79d658f6	311	{
nixnax	38:ab582987926e	312	led1Toggle(); // change led1 state on every frame we receive
nixnax	29:30de79d658f6	313	if(start==end) {
nixnax	111:6a3b77c065c0	314	return; // empty frame
nixnax	29:30de79d658f6	315	}
nixnax	9:0992486d4a30	316	crcReset();
nixnax	9:0992486d4a30	317	char * dest = ppp.pkt.buf;
nixnax	9:0992486d4a30	318	ppp.pkt.len=0;
nixnax	9:0992486d4a30	319	int unstuff=0;
nixnax	17:4918c893d802	320	int idx = start;
nixnax	17:4918c893d802	321	while(1) {
nixnax	124:18ef53f1d8b7	322	fillbuf();
nixnax	9:0992486d4a30	323	if (unstuff==0) {
nixnax	72:ad3d12753acf	324	if (ppp.rx.buf[idx]==0x7d) unstuff=1;
nixnax	29:30de79d658f6	325	else {
nixnax	72:ad3d12753acf	326	*dest = ppp.rx.buf[idx];
nixnax	29:30de79d658f6	327	ppp.pkt.len++;
nixnax	29:30de79d658f6	328	dest++;
nixnax	72:ad3d12753acf	329	crcDo(ppp.rx.buf[idx]);
nixnax	29:30de79d658f6	330	}
nixnax	66:f005b9fdf4d1	331	} else { // unstuff characters prefixed with 0x7d
nixnax	72:ad3d12753acf	332	*dest = ppp.rx.buf[idx]^0x20;
nixnax	29:30de79d658f6	333	ppp.pkt.len++;
nixnax	29:30de79d658f6	334	dest++;
nixnax	72:ad3d12753acf	335	crcDo(ppp.rx.buf[idx]^0x20);
nixnax	9:0992486d4a30	336	unstuff=0;
nixnax	9:0992486d4a30	337	}
nixnax	81:9ede60e9a2c8	338	idx = (idx+1) & (RXBUFLEN-1);
nixnax	17:4918c893d802	339	if (idx == end) break;
nixnax	9:0992486d4a30	340	}
nixnax	29:30de79d658f6	341	ppp.pkt.crc = ppp.crc & 0xffff;
nixnax	120:bef89e4c906e	342	if(0) dumpPPPFrame(); // set to 1 to dump ALL ppp frames
nixnax	9:0992486d4a30	343	if (ppp.pkt.crc == 0xf0b8) { // check for good CRC
nixnax	16:cb0b80c24ba2	344	void determinePacketType(); // declaration only
nixnax	9:0992486d4a30	345	determinePacketType();
nixnax	90:55e0f243a7ce	346	} else {
nixnax	130:45ee0d648a72	347	#define REPORT_FCS_ERROR_YES
nixnax	128:e5958d143e9d	348	#ifdef REPORT_FCS_ERROR_YES
nixnax	128:e5958d143e9d	349	char pbuf[50]; // local print buffer
nixnax	128:e5958d143e9d	350	fillbuf();
nixnax	128:e5958d143e9d	351	sprintf(pbuf, "\nPPP FCS(crc) Error CRC=%x Length = %d\n",ppp.pkt.crc,ppp.pkt.len); // print a debug line
nixnax	128:e5958d143e9d	352	fillbuf();
nixnax	128:e5958d143e9d	353	putsWhileCheckingInput( pbuf );
nixnax	128:e5958d143e9d	354	if(0) dumpPPPFrame(); // set to 1 to dump frames with errors in them
nixnax	128:e5958d143e9d	355	#endif
nixnax	9:0992486d4a30	356	}
nixnax	9:0992486d4a30	357	}
nixnax	9:0992486d4a30	358
nixnax	124:18ef53f1d8b7	359	void pcPutcWhileCheckingInput(int ch)
nixnax	124:18ef53f1d8b7	360	{
nixnax	124:18ef53f1d8b7	361	fillbuf(); // check input
nixnax	124:18ef53f1d8b7	362	pc.putc(ch);
nixnax	124:18ef53f1d8b7	363	fillbuf();
nixnax	124:18ef53f1d8b7	364	}
nixnax	124:18ef53f1d8b7	365
nixnax	29:30de79d658f6	366	void hdlcPut(int ch) // do hdlc handling of special (flag) characters
nixnax	29:30de79d658f6	367	{
nixnax	29:30de79d658f6	368	if ( (ch<0x20) \|\| (ch==0x7d) \|\| (ch==0x7e) ) {
nixnax	124:18ef53f1d8b7	369	pcPutcWhileCheckingInput(0x7d);
nixnax	124:18ef53f1d8b7	370	pcPutcWhileCheckingInput(ch^0x20); // these characters need special handling
nixnax	29:30de79d658f6	371	} else {
nixnax	124:18ef53f1d8b7	372	pcPutcWhileCheckingInput(ch);
nixnax	29:30de79d658f6	373	}
nixnax	11:f58998c24f0b	374	}
nixnax	9:0992486d4a30	375
nixnax	93:9675adc36882	376	void send_pppFrame() // send a PPP frame in HDLC format
nixnax	133:0f5b4085b6d3	377	{
nixnax	17:4918c893d802	378	int crc = crcBuf(ppp.pkt.buf, ppp.pkt.len-2); // update crc
nixnax	12:db0dc91f0231	379	ppp.pkt.buf[ ppp.pkt.len-2 ] = (~crc>>0); // fcs lo (crc)
nixnax	12:db0dc91f0231	380	ppp.pkt.buf[ ppp.pkt.len-1 ] = (~crc>>8); // fcs hi (crc)
nixnax	124:18ef53f1d8b7	381	pcPutcWhileCheckingInput(0x7e); // hdlc start-of-frame "flag"
nixnax	95:40af49390daf	382	for(int i=0; i<ppp.pkt.len; i++) {
nixnax	133:0f5b4085b6d3	383	wait_us(86); // wait one character time
nixnax	133:0f5b4085b6d3	384	fillbuf();
nixnax	93:9675adc36882	385	hdlcPut( ppp.pkt.buf[i] ); // send a character
nixnax	93:9675adc36882	386	}
nixnax	124:18ef53f1d8b7	387	pcPutcWhileCheckingInput(0x7e); // hdlc end-of-frame "flag"
nixnax	9:0992486d4a30	388	}
nixnax	9:0992486d4a30	389
nixnax	93:9675adc36882	390	void ipcpConfigRequestHandler()
nixnax	29:30de79d658f6	391	{
nixnax	119:e14dd2bf0ea3	392	debugPrintf("Their IPCP Config Req, Our Ack\n");
nixnax	92:cb962b365cce	393	ppp.pkt.buf[4]=2; // change code to ack
nixnax	108:f77ec4605945	394	send_pppFrame(); // acknowledge everything they ask for - assume it's IP addresses
nixnax	106:d14e6b597ca3	395
nixnax	119:e14dd2bf0ea3	396	debugPrintf("Our IPCP Ask (no options)\n");
nixnax	92:cb962b365cce	397	ppp.pkt.buf[4]=1; // change code to request
nixnax	106:d14e6b597ca3	398	ppp.pkt.buf[7]=4; // no options in this request
nixnax	106:d14e6b597ca3	399	ppp.pkt.len=10; // no options in this request shortest ipcp packet possible (4 ppp + 4 ipcp + 2 crc)
nixnax	128:e5958d143e9d	400	send_pppFrame(); // send our request
nixnax	9:0992486d4a30	401	}
nixnax	9:0992486d4a30	402
nixnax	93:9675adc36882	403	void ipcpAckHandler()
nixnax	29:30de79d658f6	404	{
nixnax	119:e14dd2bf0ea3	405	debugPrintf("Their IPCP Grant\n");
nixnax	29:30de79d658f6	406	}
nixnax	9:0992486d4a30	407
nixnax	93:9675adc36882	408	void ipcpNackHandler()
nixnax	29:30de79d658f6	409	{
nixnax	119:e14dd2bf0ea3	410	debugPrintf("Their IPCP Nack, Our ACK\n");
nixnax	107:5fe806713d49	411	if (ppp.pkt.buf[8]==3) { // check if the NACK contains an IP address parameter
nixnax	106:d14e6b597ca3	412	ppp.pkt.buf[4]=1; // assume the NACK contains our "suggested" IP address
nixnax	106:d14e6b597ca3	413	send_pppFrame(); // let's request this IP address as ours
nixnax	106:d14e6b597ca3	414	} // if it's not an IP nack we ignore it
nixnax	29:30de79d658f6	415	}
nixnax	9:0992486d4a30	416
nixnax	93:9675adc36882	417	void ipcpDefaultHandler()
nixnax	29:30de79d658f6	418	{
nixnax	119:e14dd2bf0ea3	419	debugPrintf("Their IPCP Other\n");
nixnax	29:30de79d658f6	420	}
nixnax	29:30de79d658f6	421
nixnax	29:30de79d658f6	422	void IPCPframe()
nixnax	29:30de79d658f6	423	{
nixnax	9:0992486d4a30	424	int code = ppp.pkt.buf[4]; // packet type is here
nixnax	9:0992486d4a30	425	switch (code) {
nixnax	29:30de79d658f6	426	case 1:
nixnax	93:9675adc36882	427	ipcpConfigRequestHandler();
nixnax	29:30de79d658f6	428	break;
nixnax	29:30de79d658f6	429	case 2:
nixnax	93:9675adc36882	430	ipcpAckHandler();
nixnax	29:30de79d658f6	431	break;
nixnax	29:30de79d658f6	432	case 3:
nixnax	93:9675adc36882	433	ipcpNackHandler();
nixnax	29:30de79d658f6	434	break;
nixnax	29:30de79d658f6	435	default:
nixnax	93:9675adc36882	436	ipcpDefaultHandler();
nixnax	9:0992486d4a30	437	}
nixnax	29:30de79d658f6	438	}
nixnax	9:0992486d4a30	439
nixnax	29:30de79d658f6	440	void UDPpacket()
nixnax	29:30de79d658f6	441	{
nixnax	12:db0dc91f0231	442	char * udpPkt = ppp.pkt.buf+4; // udp packet start
nixnax	16:cb0b80c24ba2	443	int headerSizeIP = (( udpPkt[0]&0xf)*4);
nixnax	29:30de79d658f6	444	char * udpBlock = udpPkt + headerSizeIP; // udp info start
nixnax	118:54d1936e3768	445	#ifdef SERIAL_PORT_MONITOR_YES
nixnax	12:db0dc91f0231	446	char * udpSrc = udpBlock; // source port
nixnax	12:db0dc91f0231	447	char * udpDst = udpBlock+2; // destination port
nixnax	63:9253b0e1b7d8	448	#endif
nixnax	12:db0dc91f0231	449	char * udpLen = udpBlock+4; // udp data length
nixnax	12:db0dc91f0231	450	char * udpInf = udpBlock+8; // actual start of info
nixnax	118:54d1936e3768	451	#ifdef SERIAL_PORT_MONITOR_YES
nixnax	12:db0dc91f0231	452	int srcPort = (udpSrc[0]<<8) \| udpSrc[1];
nixnax	12:db0dc91f0231	453	int dstPort = (udpDst[0]<<8) \| udpDst[1];
nixnax	12:db0dc91f0231	454	char * srcIP = udpPkt+12; // udp src addr
nixnax	12:db0dc91f0231	455	char * dstIP = udpPkt+16; // udp dst addr
nixnax	55:43faae812be3	456	#endif
nixnax	29:30de79d658f6	457	#define UDP_HEADER_SIZE 8
nixnax	12:db0dc91f0231	458	int udpLength = ((udpLen[0]<<8) \| udpLen[1]) - UDP_HEADER_SIZE; // size of the actual udp data
nixnax	119:e14dd2bf0ea3	459	if(v0) debugPrintf("UDP %d.%d.%d.%d:%d ", srcIP[0],srcIP[1],srcIP[2],srcIP[3],srcPort);
nixnax	119:e14dd2bf0ea3	460	if(v0) debugPrintf("%d.%d.%d.%d:%d ", dstIP[0],dstIP[1],dstIP[2],dstIP[3],dstPort);
nixnax	119:e14dd2bf0ea3	461	if(v0) debugPrintf("Len %03d", udpLength);
nixnax	29:30de79d658f6	462	int printSize = udpLength;
nixnax	29:30de79d658f6	463	if (printSize > 20) printSize = 20; // print only first 20 characters
nixnax	81:9ede60e9a2c8	464	if (v1) {
nixnax	29:30de79d658f6	465	for (int i=0; i<printSize; i++) {
nixnax	29:30de79d658f6	466	char ch = udpInf[i];
nixnax	29:30de79d658f6	467	if (ch>31 && ch<127) {
nixnax	119:e14dd2bf0ea3	468	debugPrintf("%c", ch);
nixnax	29:30de79d658f6	469	} else {
nixnax	119:e14dd2bf0ea3	470	debugPrintf("_");
nixnax	29:30de79d658f6	471	}
nixnax	29:30de79d658f6	472	}
nixnax	29:30de79d658f6	473	}
nixnax	119:e14dd2bf0ea3	474	if (v0) debugPrintf("\n");
nixnax	12:db0dc91f0231	475	}
nixnax	11:f58998c24f0b	476
nixnax	76:00e208cceb8b	477	unsigned int dataCheckSum(unsigned char * ptr, int len)
nixnax	29:30de79d658f6	478	{
nixnax	128:e5958d143e9d	479	unsigned int i,hi,lo,sum;
nixnax	76:00e208cceb8b	480	unsigned char placeHolder;
nixnax	29:30de79d658f6	481	if (len&1) {
nixnax	128:e5958d143e9d	482	placeHolder = ptr[len];
nixnax	128:e5958d143e9d	483	ptr[len]=0; // if the byte count is odd, insert one extra zero byte is after the last real byte because we sum byte PAIRS
nixnax	29:30de79d658f6	484	}
nixnax	128:e5958d143e9d	485	sum=0;
nixnax	128:e5958d143e9d	486	i=0;
nixnax	128:e5958d143e9d	487	while ( i<len ) {
nixnax	124:18ef53f1d8b7	488	fillbuf();
nixnax	128:e5958d143e9d	489	hi = ptr[i++];
nixnax	128:e5958d143e9d	490	lo = ptr[i++];
nixnax	128:e5958d143e9d	491	sum = sum + ( (hi<<8) \| lo );
nixnax	11:f58998c24f0b	492	}
nixnax	29:30de79d658f6	493	if (len&1) {
nixnax	128:e5958d143e9d	494	ptr[len] = placeHolder; // restore the extra byte we made zero
nixnax	29:30de79d658f6	495	}
nixnax	76:00e208cceb8b	496	sum = (sum & 0xffff) + (sum>>16);
nixnax	76:00e208cceb8b	497	sum = (sum & 0xffff) + (sum>>16); // sum one more time to catch any carry from the carry
nixnax	12:db0dc91f0231	498	return ~sum;
nixnax	29:30de79d658f6	499	}
nixnax	11:f58998c24f0b	500
nixnax	29:30de79d658f6	501	void headerCheckSum()
nixnax	29:30de79d658f6	502	{
nixnax	11:f58998c24f0b	503	int len =(ppp.pkt.buf[4]&0xf)*4; // length of header in bytes
nixnax	11:f58998c24f0b	504	char * ptr = ppp.pkt.buf+4; // start of ip packet
nixnax	11:f58998c24f0b	505	int sum=0;
nixnax	11:f58998c24f0b	506
nixnax	29:30de79d658f6	507	for (int i=0; i<len/2; i++) {
nixnax	29:30de79d658f6	508	int hi = *ptr;
nixnax	29:30de79d658f6	509	ptr++;
nixnax	29:30de79d658f6	510	int lo = *ptr;
nixnax	29:30de79d658f6	511	ptr++;
nixnax	11:f58998c24f0b	512	int val = ( lo & 0xff ) \| ( (hi<<8) & 0xff00 );
nixnax	11:f58998c24f0b	513	sum = sum + val;
nixnax	124:18ef53f1d8b7	514	fillbuf();
nixnax	11:f58998c24f0b	515	}
nixnax	11:f58998c24f0b	516	sum = sum + (sum>>16);
nixnax	11:f58998c24f0b	517	sum = ~sum;
nixnax	11:f58998c24f0b	518	ppp.pkt.buf[14]= (sum>>8);
nixnax	11:f58998c24f0b	519	ppp.pkt.buf[15]= (sum );
nixnax	29:30de79d658f6	520	}
nixnax	9:0992486d4a30	521
nixnax	29:30de79d658f6	522	void ICMPpacket() // internet control message protocol
nixnax	128:e5958d143e9d	523	{
nixnax	12:db0dc91f0231	524	char * ipPkt = ppp.pkt.buf+4; // ip packet start
nixnax	12:db0dc91f0231	525	char * pktLen = ipPkt+2;
nixnax	12:db0dc91f0231	526	int packetLength = (pktLen[0]<<8) \| pktLen[1]; // icmp packet length
nixnax	16:cb0b80c24ba2	527	int headerSizeIP = (( ipPkt[0]&0xf)*4);
nixnax	16:cb0b80c24ba2	528	char * icmpType = ipPkt + headerSizeIP; // icmp data start
nixnax	13:d882b8a042b4	529	char * icmpSum = icmpType+2; // icmp checksum
nixnax	29:30de79d658f6	530	#define ICMP_TYPE_PING_REQUEST 8
nixnax	29:30de79d658f6	531	if ( icmpType[0] == ICMP_TYPE_PING_REQUEST ) {
nixnax	12:db0dc91f0231	532	char * ipTTL = ipPkt+8; // time to live
nixnax	12:db0dc91f0231	533	ipTTL[0]--; // decrement time to live
nixnax	12:db0dc91f0231	534	char * srcAdr = ipPkt+12;
nixnax	12:db0dc91f0231	535	char * dstAdr = ipPkt+16;
nixnax	124:18ef53f1d8b7	536	#ifdef SERIAL_PORT_MONITOR_YES
nixnax	18:3e35de1bc877	537	int icmpIdent = (icmpType[4]<<8)\|icmpType[5];
nixnax	29:30de79d658f6	538	int icmpSequence = (icmpType[6]<<8)\|icmpType[7];
nixnax	125:ea88200b1df6	539	if(1) {
nixnax	124:18ef53f1d8b7	540	char pbuf[50];
nixnax	124:18ef53f1d8b7	541	fillbuf();
nixnax	124:18ef53f1d8b7	542	sprintf(pbuf, "ICMP PING %d.%d.%d.%d %d.%d.%d.%d ", srcAdr[0],srcAdr[1],srcAdr[2],srcAdr[3],dstAdr[0],dstAdr[1],dstAdr[2],dstAdr[3]);
nixnax	125:ea88200b1df6	543	putsWhileCheckingInput( pbuf );
nixnax	124:18ef53f1d8b7	544	fillbuf();
nixnax	125:ea88200b1df6	545	sprintf(pbuf, "Ident %04x Sequence %04d \n",icmpIdent,icmpSequence);
nixnax	124:18ef53f1d8b7	546	fillbuf();
nixnax	125:ea88200b1df6	547	putsWhileCheckingInput( pbuf );
nixnax	124:18ef53f1d8b7	548	}
nixnax	128:e5958d143e9d	549	#endif
nixnax	29:30de79d658f6	550	char src[4];
nixnax	29:30de79d658f6	551	char dst[4];
nixnax	12:db0dc91f0231	552	memcpy(src, srcAdr,4);
nixnax	12:db0dc91f0231	553	memcpy(dst, dstAdr,4);
nixnax	12:db0dc91f0231	554	memcpy(srcAdr, dst,4);
nixnax	12:db0dc91f0231	555	memcpy(dstAdr, src,4); // swap src & dest ip
nixnax	12:db0dc91f0231	556	char * chkSum = ipPkt+10;
nixnax	29:30de79d658f6	557	chkSum[0]=0;
nixnax	29:30de79d658f6	558	chkSum[1]=0;
nixnax	12:db0dc91f0231	559	headerCheckSum(); // new ip header checksum
nixnax	29:30de79d658f6	560	#define ICMP_TYPE_ECHO_REPLY 0
nixnax	16:cb0b80c24ba2	561	icmpType[0]=ICMP_TYPE_ECHO_REPLY; // icmp echo reply
nixnax	29:30de79d658f6	562	icmpSum[0]=0;
nixnax	29:30de79d658f6	563	icmpSum[1]=0; // zero the checksum for recalculation
nixnax	16:cb0b80c24ba2	564	int icmpLength = packetLength - headerSizeIP; // length of ICMP data portion
nixnax	76:00e208cceb8b	565	unsigned int sum = dataCheckSum( (unsigned char *)icmpType, icmpLength); // this checksum on icmp data portion
nixnax	76:00e208cceb8b	566	icmpSum[0]=(sum>>8)&0xff;
nixnax	76:00e208cceb8b	567	icmpSum[1]=(sum )&0xff; // new checksum for ICMP data portion
nixnax	16:cb0b80c24ba2	568
nixnax	16:cb0b80c24ba2	569	int printSize = icmpLength-8; // exclude size of icmp header
nixnax	25:0b0450e1b08b	570	char * icmpData = icmpType+8; // the actual payload data is after the header
nixnax	25:0b0450e1b08b	571	if (printSize > 10) printSize = 10; // print up to 20 characters
nixnax	124:18ef53f1d8b7	572	if (0) {
nixnax	29:30de79d658f6	573	for (int i=0; i<printSize; i++) {
nixnax	29:30de79d658f6	574	char ch = icmpData[i];
nixnax	29:30de79d658f6	575	if (ch>31 && ch<127) {
nixnax	124:18ef53f1d8b7	576	putcWhileCheckingInput(ch);
nixnax	29:30de79d658f6	577	} else {
nixnax	124:18ef53f1d8b7	578	putcWhileCheckingInput('_');
nixnax	29:30de79d658f6	579	}
nixnax	29:30de79d658f6	580	}
nixnax	124:18ef53f1d8b7	581	putcWhileCheckingInput('\n');
nixnax	29:30de79d658f6	582	}
nixnax	93:9675adc36882	583	send_pppFrame(); // reply to the ping
nixnax	12:db0dc91f0231	584	} else {
nixnax	29:30de79d658f6	585	if (v0) {
nixnax	119:e14dd2bf0ea3	586	debugPrintf("ICMP type=%d \n", icmpType[0]);
nixnax	29:30de79d658f6	587	}
nixnax	128:e5958d143e9d	588	}
nixnax	11:f58998c24f0b	589	}
nixnax	11:f58998c24f0b	590
nixnax	29:30de79d658f6	591	void IGMPpacket() // internet group management protocol
nixnax	29:30de79d658f6	592	{
nixnax	119:e14dd2bf0ea3	593	if (v0) debugPrintf("IGMP type=%d \n", ppp.pkt.buf[28]);
nixnax	29:30de79d658f6	594	}
nixnax	11:f58998c24f0b	595
nixnax	114:8a5d70bbc1b2	596	void dumpHeaderIP (int outGoing)
nixnax	29:30de79d658f6	597	{
nixnax	114:8a5d70bbc1b2	598	#if defined(IP_HEADER_DUMP_YES) && defined(SERIAL_PORT_MONITOR_YES)
nixnax	119:e14dd2bf0ea3	599	fillbuf(); // we are expecting the first character of the next packet
nixnax	114:8a5d70bbc1b2	600	char * ipPkt = ppp.pkt.buf+4; // ip packet start
nixnax	114:8a5d70bbc1b2	601	char * ident = ipPkt+4; // 2 bytes
nixnax	118:54d1936e3768	602	#ifdef UNUSED_IP_VARIABLES
nixnax	114:8a5d70bbc1b2	603	char * srcAdr = ipPkt+12; // 4 bytes
nixnax	114:8a5d70bbc1b2	604	char * dstAdr = ipPkt+16; // 4 bytes = total of 20 bytes
nixnax	114:8a5d70bbc1b2	605	char * version = ipPkt; // top 4 bits
nixnax	114:8a5d70bbc1b2	606	char * ihl = ipPkt; // bottom 4 bits
nixnax	114:8a5d70bbc1b2	607	char * dscp = ipPkt+1; // top 6 bits
nixnax	114:8a5d70bbc1b2	608	char * ecn = ipPkt+1; // lower 2 bits
nixnax	114:8a5d70bbc1b2	609	char * pktLen = ipPkt+2; // 2 bytes
nixnax	114:8a5d70bbc1b2	610	char * flags = ipPkt+6; // 2 bits
nixnax	114:8a5d70bbc1b2	611	char * ttl = ipPkt+8; // 1 byte
nixnax	114:8a5d70bbc1b2	612	char * protocol = ipPkt+9; // 1 byte
nixnax	114:8a5d70bbc1b2	613	char * headercheck= ipPkt+10; // 2 bytes
nixnax	114:8a5d70bbc1b2	614	int versionIP = (version[0]>>4)&0xf;
nixnax	114:8a5d70bbc1b2	615	int headerSizeIP = (ihl[0]&0xf)*4;
nixnax	114:8a5d70bbc1b2	616	int dscpIP = (dscp[0]>>2)&0x3f;
nixnax	114:8a5d70bbc1b2	617	int ecnIP = ecn[0]&3;
nixnax	114:8a5d70bbc1b2	618	int packetLength = (pktLen[0]<<8)\|pktLen[1]; // ip total packet length
nixnax	114:8a5d70bbc1b2	619	int flagsIP = flags[0]>>14&3;
nixnax	114:8a5d70bbc1b2	620	int ttlIP = ttl[0];
nixnax	114:8a5d70bbc1b2	621	int protocolIP = protocol[0];
nixnax	114:8a5d70bbc1b2	622	unsigned int checksumIP = (headercheck[0]<<8)\|headercheck[1];
nixnax	63:9253b0e1b7d8	623	#endif
nixnax	119:e14dd2bf0ea3	624	int IPv4Id = (ident[0]<<8)\|ident[1];
nixnax	119:e14dd2bf0ea3	625	char pbuf[50]; // local print buffer
nixnax	118:54d1936e3768	626	int n=0;
nixnax	119:e14dd2bf0ea3	627	n=n+sprintf(pbuf+n, outGoing ? "\x1b[34m" : "\x1b[30m" ); // VT100 color code, print black for incoming, blue for outgoing headers
nixnax	119:e14dd2bf0ea3	628	n=n+sprintf(pbuf+n, "%05d ",IPv4Id); // IPv4Id is a good way to correlate our dumps with net monitor or wireshark traces
nixnax	119:e14dd2bf0ea3	629	#define DUMP_FULL_IP_ADDRESS_YES
nixnax	119:e14dd2bf0ea3	630	#ifdef DUMP_FULL_IP_ADDRESS_YES
nixnax	119:e14dd2bf0ea3	631	char * srcAdr = ipPkt+12; // 4 bytes
nixnax	119:e14dd2bf0ea3	632	char * dstAdr = ipPkt+16; // 4 bytes = total of 20 bytes
nixnax	119:e14dd2bf0ea3	633	n=n+sprintf(pbuf+n, " %d.%d.%d.%d %d.%d.%d.%d ",srcAdr[0],srcAdr[1],srcAdr[2],srcAdr[3], dstAdr[0],dstAdr[1],dstAdr[2],dstAdr[3]); // full ip addresses
nixnax	55:43faae812be3	634	#endif
nixnax	125:ea88200b1df6	635	putsWhileCheckingInput( pbuf );
nixnax	114:8a5d70bbc1b2	636	#ifndef TCP_HEADER_DUMP_YES
nixnax	125:ea88200b1df6	637	putsWhileCheckingInput('\x1b[30m\n'); // there is no TCP header dump, so terminate the line with \n and VT100 code for black
nixnax	114:8a5d70bbc1b2	638	#endif
nixnax	114:8a5d70bbc1b2	639	#endif
nixnax	29:30de79d658f6	640	}
nixnax	26:11f4eb2663a7	641
nixnax	114:8a5d70bbc1b2	642	void dumpHeaderTCP(int outGoing)
nixnax	29:30de79d658f6	643	{
nixnax	114:8a5d70bbc1b2	644	#if defined(TCP_HEADER_DUMP_YES) && defined(SERIAL_PORT_MONITOR_YES)
nixnax	114:8a5d70bbc1b2	645	int headerSizeIP = (ppp.pkt.buf[4]&0xf)*4; // header size of ip portion
nixnax	114:8a5d70bbc1b2	646	char * tcpStart = ppp.pkt.buf+4+headerSizeIP; // start of tcp packet
nixnax	114:8a5d70bbc1b2	647	char * seqtcp = tcpStart + 4; // 4 bytes
nixnax	114:8a5d70bbc1b2	648	char * acktcp = tcpStart + 8; // 4 bytes
nixnax	114:8a5d70bbc1b2	649	char * flagbitstcp = tcpStart + 12; // 9 bits
nixnax	114:8a5d70bbc1b2	650	unsigned int seq = (seqtcp[0]<<24)\|(seqtcp[1]<<16)\|(seqtcp[2]<<8)\|(seqtcp[3]);
nixnax	114:8a5d70bbc1b2	651	unsigned int ack = (acktcp[0]<<24)\|(acktcp[1]<<16)\|(acktcp[2]<<8)\|(acktcp[3]);
nixnax	114:8a5d70bbc1b2	652	if (seq && ack) {} // shut up the compiler about unused variables
nixnax	114:8a5d70bbc1b2	653	int flags = ((flagbitstcp[0]&1)<<8)\|flagbitstcp[1];
nixnax	119:e14dd2bf0ea3	654	char flagInfo[9]; // text string presenting the 8 most important TCP flags
nixnax	119:e14dd2bf0ea3	655	#define PRINT_ALL_TCP_FLAGS_YES
nixnax	119:e14dd2bf0ea3	656	#ifdef PRINT_ALL_TCP_FLAGS_YES
nixnax	114:8a5d70bbc1b2	657	memset(flagInfo,'.', 8); // fill string with "........"
nixnax	114:8a5d70bbc1b2	658	flagInfo[8]=0; // null terminate string
nixnax	114:8a5d70bbc1b2	659	if (flags & (1<<0)) flagInfo[7]='F';
nixnax	114:8a5d70bbc1b2	660	if (flags & (1<<1)) flagInfo[6]='S';
nixnax	114:8a5d70bbc1b2	661	if (flags & (1<<2)) flagInfo[5]='R';
nixnax	114:8a5d70bbc1b2	662	if (flags & (1<<3)) flagInfo[4]='P';
nixnax	114:8a5d70bbc1b2	663	if (flags & (1<<4)) flagInfo[3]='A';
nixnax	114:8a5d70bbc1b2	664	if (flags & (1<<5)) flagInfo[2]='U';
nixnax	114:8a5d70bbc1b2	665	if (flags & (1<<6)) flagInfo[1]='E';
nixnax	114:8a5d70bbc1b2	666	if (flags & (1<<7)) flagInfo[0]='C';
nixnax	118:54d1936e3768	667	#else
nixnax	119:e14dd2bf0ea3	668	if (flags & (1<<4)) flagInfo[0]='A'; // choose the most important flag to print
nixnax	119:e14dd2bf0ea3	669	if (flags & (1<<1)) flagInfo[0]='S';
nixnax	119:e14dd2bf0ea3	670	if (flags & (1<<0)) flagInfo[0]='F';
nixnax	119:e14dd2bf0ea3	671	if (flags & (1<<3)) flagInfo[0]='P';
nixnax	119:e14dd2bf0ea3	672	if (flags & (1<<2)) flagInfo[0]='R';
nixnax	124:18ef53f1d8b7	673	flagInfo[1]=0; // ' '
nixnax	119:e14dd2bf0ea3	674	flagInfo[2]=0;
nixnax	118:54d1936e3768	675	#endif
nixnax	125:ea88200b1df6	676	putsWhileCheckingInput( flagInfo );
nixnax	119:e14dd2bf0ea3	677	#define EVERY_PACKET_ON_A_NEW_LINE_YES
nixnax	119:e14dd2bf0ea3	678	#ifdef EVERY_PACKET_ON_A_NEW_LINE_YES
nixnax	125:ea88200b1df6	679	putsWhileCheckingInput("\x1b[30m\n"); // write a black color and newline after every packet
nixnax	119:e14dd2bf0ea3	680	#endif
nixnax	119:e14dd2bf0ea3	681	if( outGoing && ( flags == 0x11 ) ) { // ACK/FIN - if this is an outgoing ACK/FIN its the end of a tcp conversation
nixnax	119:e14dd2bf0ea3	682	putcWhileCheckingInput('\n'); // insert an extra new line to mark the end of an HTTP the conversation
nixnax	118:54d1936e3768	683	}
nixnax	114:8a5d70bbc1b2	684	#endif
nixnax	29:30de79d658f6	685	}
nixnax	29:30de79d658f6	686
nixnax	128:e5958d143e9d	687	void enc64(char * in, char * out, int len)
nixnax	128:e5958d143e9d	688	{
nixnax	128:e5958d143e9d	689	const static char lut [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
nixnax	128:e5958d143e9d	690	int i,j,a,b,c;
nixnax	128:e5958d143e9d	691	i=0;
nixnax	128:e5958d143e9d	692	j=0;
nixnax	128:e5958d143e9d	693	while(1) {
nixnax	128:e5958d143e9d	694	if (i<len) {
nixnax	128:e5958d143e9d	695	a = in[i++];
nixnax	128:e5958d143e9d	696	out[j++] = lut[ ( (a >> 2) & 0x3f) ];
nixnax	128:e5958d143e9d	697	} else break;
nixnax	128:e5958d143e9d	698	if (i<len) {
nixnax	128:e5958d143e9d	699	b = in[i++];
nixnax	128:e5958d143e9d	700	out[j++] = lut[ ( (a << 4) & 0x30) \| ( (b >> 4) & 0x0f) ];
nixnax	128:e5958d143e9d	701	out[j++] = lut[ ( (b << 2) & 0x3c) ];
nixnax	128:e5958d143e9d	702	} else out[j++] = '=';
nixnax	128:e5958d143e9d	703	if (i<len) {
nixnax	128:e5958d143e9d	704	c = in[i++];
nixnax	128:e5958d143e9d	705	j--;
nixnax	128:e5958d143e9d	706	out[j++] = lut[ ( (b << 2) & 0x3c) \| ( (c >> 6) & 0x03) ];
nixnax	128:e5958d143e9d	707	out[j++] = lut[ ( (c >> 0) & 0x3f) ];
nixnax	128:e5958d143e9d	708	} else out[j++] = '=';
nixnax	128:e5958d143e9d	709	}
nixnax	128:e5958d143e9d	710	out[j]=0;
nixnax	128:e5958d143e9d	711	}
nixnax	128:e5958d143e9d	712
nixnax	128:e5958d143e9d	713	// we end up here if we enter the following javascript in a web browser console: x = new WebSocket("ws://172.10.10.2");
nixnax	128:e5958d143e9d	714	int webSocketHandler(char * dataStart)
nixnax	128:e5958d143e9d	715	{
nixnax	128:e5958d143e9d	716	int n=0; // byte counter
nixnax	128:e5958d143e9d	717	char * key = strstr(dataStart, "Sec-WebSocket-Key: "); // search for the key in the payload
nixnax	128:e5958d143e9d	718	if (key != NULL) {
nixnax	129:b8a0b0e8cff1	719	if (v0) putsWhileCheckingInput("WebSocket Request\n");
nixnax	128:e5958d143e9d	720	char challenge [70];
nixnax	128:e5958d143e9d	721	strncpy(challenge,key+19,70); // a local buffer
nixnax	128:e5958d143e9d	722	*strchr(challenge,'\r')=0; // insert null so we can use sprintf
nixnax	128:e5958d143e9d	723	strncat(challenge,"258EAFA5-E914-47DA-95CA-C5AB0DC85B11",70); // append websocket gui code
nixnax	128:e5958d143e9d	724	char shaOutput [20]; // sha1 output
nixnax	128:e5958d143e9d	725	sha1( shaOutput, challenge, strlen(challenge));
nixnax	128:e5958d143e9d	726	char encOut[50];
nixnax	128:e5958d143e9d	727	enc64( shaOutput, encOut, 20);
nixnax	128:e5958d143e9d	728	char * versionstring = strstr(dataStart, "Sec-WebSocket-Version:");
nixnax	128:e5958d143e9d	729	char * version = challenge;
nixnax	128:e5958d143e9d	730	strncpy(version, versionstring,70); // copy version string
nixnax	128:e5958d143e9d	731	*strchr(version,'\r')=0; // null terminate so we can sprintf it
nixnax	128:e5958d143e9d	732	memset(dataStart,0,500); // blank out old data befor send the websocket response header
nixnax	128:e5958d143e9d	733	n=n+sprintf(dataStart+n, "HTTP/1.1 101 Switching Protocols\r\n");
nixnax	128:e5958d143e9d	734	n=n+sprintf(dataStart+n, "Upgrade: websocket\r\n");
nixnax	128:e5958d143e9d	735	n=n+sprintf(dataStart+n, "Connection: Upgrade\r\n");
nixnax	128:e5958d143e9d	736	n=n+sprintf(dataStart+n, "Sec-WebSocket-Accept: %s\r\n",encOut);
nixnax	128:e5958d143e9d	737	n=n+sprintf(dataStart+n, "%s\r\n",version);
nixnax	128:e5958d143e9d	738	n=n+sprintf(dataStart+n, "mbed-Code: PPP-Blinky\r\n");
nixnax	128:e5958d143e9d	739	n=n+sprintf(dataStart+n, "\r\n"); // websocket response header ending
nixnax	128:e5958d143e9d	740	}
nixnax	128:e5958d143e9d	741	return n; // this response should satisfy a web browser's websocket protocol request
nixnax	128:e5958d143e9d	742	}
nixnax	128:e5958d143e9d	743
nixnax	128:e5958d143e9d	744	#define TCP_FLAG_ACK (1<<4)
nixnax	128:e5958d143e9d	745	#define TCP_FLAG_SYN (1<<1)
nixnax	128:e5958d143e9d	746	#define TCP_FLAG_PSH (1<<3)
nixnax	128:e5958d143e9d	747	#define TCP_FLAG_RST (1<<2)
nixnax	128:e5958d143e9d	748	#define TCP_FLAG_FIN (1<<0)
nixnax	128:e5958d143e9d	749
nixnax	68:0b74763ae67f	750	int httpResponse(char * dataStart)
nixnax	67:a63e3486bcda	751	{
nixnax	67:a63e3486bcda	752	int n=0; // number of bytes we have printed so far
nixnax	128:e5958d143e9d	753	n = webSocketHandler( dataStart ); // test for and handle WebSocket upgrade requests
nixnax	128:e5958d143e9d	754	if (n>0) return n; // if it's a WebSocket we already have the response, so return
nixnax	128:e5958d143e9d	755
nixnax	77:abf92baebb42	756	int nHeader; // byte size of HTTP header
nixnax	83:cdcb81d1910f	757	int contentLengthStart; // index where HTML starts
nixnax	133:0f5b4085b6d3	758	int httpGet5,httpGet6,httpGetx, httpGetRoot; // temporary storage of strncmp results
nixnax	85:53e57ff1cf05	759
nixnax	98:3babad0d1bd4	760	ppp.httpPageCount++; // increment the number of frames we have made
nixnax	85:53e57ff1cf05	761
nixnax	128:e5958d143e9d	762	httpGetRoot = strncmp(dataStart, "GET / HTTP/1.", 13); // found a GET to the root directory
nixnax	128:e5958d143e9d	763	httpGetx = strncmp(dataStart, "GET /x", 6); // found a GET to /x which we will treat special (anything starting with /x, e.g. /x, /xyz, /xABC?pqr=123
nixnax	133:0f5b4085b6d3	764	httpGet5 = dataStart[5]; // the first character in the path name, we use it for special functions later on
nixnax	133:0f5b4085b6d3	765	httpGet6 = dataStart[6]; // the second character in the path name, we use it for special functions later on
nixnax	119:e14dd2bf0ea3	766	// for example, you could try this using netcat (nc): echo "GET /x" \| nc 172.10.10.2
nixnax	128:e5958d143e9d	767	if( (httpGetRoot==0) \|\| (httpGetx==0) ) {
nixnax	133:0f5b4085b6d3	768	n=n+sprintf(n+dataStart,"HTTP/1.1 200 OK\r\nServer: mbed-PPP-Blinky-v1\r\n"); // 200 OK header
nixnax	83:cdcb81d1910f	769	} else {
nixnax	89:2c8dd0c2a426	770	n=n+sprintf(n+dataStart,"HTTP/1.1 404 Not Found\r\nServer: mbed-PPP-Blinky\r\n"); // 404 header
nixnax	83:cdcb81d1910f	771	}
nixnax	83:cdcb81d1910f	772	n=n+sprintf(n+dataStart,"Content-Length: "); // http header
nixnax	83:cdcb81d1910f	773	contentLengthStart = n; // remember where Content-Length is in buffer
nixnax	83:cdcb81d1910f	774	n=n+sprintf(n+dataStart,"?????\r\n"); // leave five spaces for content length - will be updated later
nixnax	83:cdcb81d1910f	775	n=n+sprintf(n+dataStart,"Connection: close\r\n"); // close connection immediately
nixnax	83:cdcb81d1910f	776	n=n+sprintf(n+dataStart,"Content-Type: text/html; charset=us-ascii\r\n\r\n"); // http header must end with empty line (\r\n)
nixnax	83:cdcb81d1910f	777	nHeader=n; // size of HTTP header
nixnax	93:9675adc36882	778	if( httpGetRoot == 0 ) {
nixnax	83:cdcb81d1910f	779	// this is where we insert our web page into the buffer
nixnax	93:9675adc36882	780	memcpy(n+dataStart,rootWebPage,sizeof(rootWebPage));
nixnax	133:0f5b4085b6d3	781	n = n + sizeof(rootWebPage)-1; // one less than sizeof because we don't count the null byte at the end
nixnax	133:0f5b4085b6d3	782	} else if ( (httpGet5 == 'w') && (httpGet6 == 's') ) { // "ws" is a special page for websocket demo
nixnax	133:0f5b4085b6d3	783	memcpy(n+dataStart,webSocketPage,sizeof(webSocketPage));
nixnax	133:0f5b4085b6d3	784	n = n + sizeof(webSocketPage)-1; // one less than size
nixnax	85:53e57ff1cf05	785	} else {
nixnax	128:e5958d143e9d	786	if (httpGetx == 0) { // the page request started with "GET /x" - here we treat anything starting with /x special:
nixnax	89:2c8dd0c2a426	787
nixnax	89:2c8dd0c2a426	788	#define W3C_COMPLIANT_RESPONSE_NO
nixnax	89:2c8dd0c2a426	789	// change the above to W3C_COMPLIANT_RESPONSE_YES if you want a W3C.org compliant HTTP response
nixnax	89:2c8dd0c2a426	790	#ifdef W3C_COMPLIANT_RESPONSE_YES
nixnax	128:e5958d143e9d	791	n=n+sprintf(n+dataStart,"<!DOCTYPE html><title>mbed PPP-Blinky</title>"); // html title (W3C.org required elements)
nixnax	98:3babad0d1bd4	792	n=n+sprintf(n+dataStart,"<body>%d</body>",ppp.httpPageCount); // body = the http frame count
nixnax	89:2c8dd0c2a426	793	#else
nixnax	133:0f5b4085b6d3	794	if( httpGet6 == 'b' ) { // if the fetched page is "xb" send a meta command to let the browser continuously reload
nixnax	133:0f5b4085b6d3	795	n=n+sprintf(n+dataStart, "<meta http-equiv=\"refresh\" content=\"0\">"); // reload loop - handy for benchmarking
nixnax	133:0f5b4085b6d3	796	}
nixnax	128:e5958d143e9d	797	// /x is a very short page, in fact, it is only a decimal number showing the http Page count
nixnax	133:0f5b4085b6d3	798	n=n+sprintf(n+dataStart,"%d ",ppp.httpPageCount); // not really valid html but most browsers and curl are ok with it
nixnax	89:2c8dd0c2a426	799	#endif
nixnax	89:2c8dd0c2a426	800	} else {
nixnax	89:2c8dd0c2a426	801	// all other requests get 404 Not Found response with a http frame count - nice for debugging
nixnax	128:e5958d143e9d	802	n=n+sprintf(n+dataStart,"<!DOCTYPE html><title>mbed PPP-Blinky</title>"); // html title (required element)
nixnax	89:2c8dd0c2a426	803	n=n+sprintf(n+dataStart,"<body>Not Found</body>"); // not found message
nixnax	89:2c8dd0c2a426	804	}
nixnax	83:cdcb81d1910f	805	}
nixnax	83:cdcb81d1910f	806	#define CONTENTLENGTHSIZE 5
nixnax	83:cdcb81d1910f	807	char contentLengthString[CONTENTLENGTHSIZE+1];
nixnax	83:cdcb81d1910f	808	snprintf(contentLengthString,CONTENTLENGTHSIZE+1,"%*d",CONTENTLENGTHSIZE,n-nHeader); // print Content-Length with leading spaces and fixed width equal to csize
nixnax	83:cdcb81d1910f	809	memcpy(dataStart+contentLengthStart, contentLengthString, CONTENTLENGTHSIZE); // copy Content-Length to it's place in the send buffer
nixnax	67:a63e3486bcda	810	return n; // total byte size of our response
nixnax	67:a63e3486bcda	811	}
nixnax	67:a63e3486bcda	812
nixnax	128:e5958d143e9d	813	// this is the response if we have TCP data but it's not an HTTP GET
nixnax	98:3babad0d1bd4	814	// this is handy when you for example want to use netcat (nc.exe) to talk to PPP-Blinky
nixnax	128:e5958d143e9d	815	// this could also be a websocket receive event - especially if the first byte is 0x81 (websocket data push)
nixnax	128:e5958d143e9d	816	int tcpResponse(char * dataStart, int len, int * outFlags)
nixnax	98:3babad0d1bd4	817	{
nixnax	98:3babad0d1bd4	818	int n=0; // number of bytes we have printed so far
nixnax	128:e5958d143e9d	819	if (dataStart[0] == 0x81) { // check if this is a websocket push message
nixnax	128:e5958d143e9d	820	// this is most likely a websocket push message. you get this when you enter this in your browser console: x.send("my message");
nixnax	128:e5958d143e9d	821	if (0) putsWhileCheckingInput( "Got data from websocket send()\n" );
nixnax	128:e5958d143e9d	822
nixnax	128:e5958d143e9d	823	// for now we simply echo the websocket data back to the client - the client should therefore see an onmessage event
nixnax	128:e5958d143e9d	824	// to display the echoed data in your browser, enter the following into the browser console: x.onmessage = function(msg){ console.log( msg.data ); }
nixnax	128:e5958d143e9d	825	if (1) {
nixnax	128:e5958d143e9d	826	char mask [4];
nixnax	128:e5958d143e9d	827	memcpy ( mask, dataStart+2, 4); // websocket messages are "masked", so first we obtain the 4-byte mask
nixnax	128:e5958d143e9d	828	int websocketMessageSize = len - 6; // 1 byte prefix (0x81), 1 byte, 4 bytes mask = 6 bytes
nixnax	128:e5958d143e9d	829	if((dataStart[1]&0x80)==0x80) // test if the mask bit is set, which means all data is xor'ed with the mask
nixnax	128:e5958d143e9d	830	for (int i=0; i<websocketMessageSize; i++) dataStart[i+6]^= mask[i%4]; // unmask each byte with one of the mask bytes
nixnax	128:e5958d143e9d	831	dataStart[1] = len-2; // add four extra bytes to the message length because we don't use mask bytes for the send
nixnax	128:e5958d143e9d	832	memcpy(dataStart+2, "Got:",4); // insert our own text into the four mask bytes
nixnax	128:e5958d143e9d	833	n = len; // our response size remains exactly the same length as what we received
nixnax	128:e5958d143e9d	834	}
nixnax	128:e5958d143e9d	835	} else if ( (dataStart[0]==0x88) && (dataStart[1]==0x80) && (len == 6) ) { // test for a websocket close request
nixnax	131:134b6d0c11e9	836	n=2; // our close command is only two bytes long because we don't use the four mask bytes
nixnax	131:134b6d0c11e9	837	dataStart[1]=0; // we don't have mask bytes on
nixnax	128:e5958d143e9d	838	} else if (v1) putsWhileCheckingInput("TCP data received\n");
nixnax	98:3babad0d1bd4	839	return n; // total byte size of our response
nixnax	98:3babad0d1bd4	840	}
nixnax	98:3babad0d1bd4	841
nixnax	29:30de79d658f6	842	void tcpHandler()
nixnax	29:30de79d658f6	843	{
nixnax	87:9f5ac1fabd95	844	// IP header
nixnax	26:11f4eb2663a7	845	char * ipPkt = ppp.pkt.buf+4; // ip packet start
nixnax	26:11f4eb2663a7	846	char * ihl = ipPkt; // bottom 4 bits
nixnax	83:cdcb81d1910f	847	char * pktLen = ipPkt+2; // 2 bytes
nixnax	26:11f4eb2663a7	848	char * ident = ipPkt+4; // 2 bytes
nixnax	28:1aa629be05e7	849	char * protocol = ipPkt+9; // 1 byte
nixnax	83:cdcb81d1910f	850	char * headercheck= ipPkt+10; // 2 bytes
nixnax	26:11f4eb2663a7	851	char * srcAdr = ipPkt+12; // 4 bytes
nixnax	26:11f4eb2663a7	852	char * dstAdr = ipPkt+16; // 4 bytes = total of 20 bytes
nixnax	26:11f4eb2663a7	853	int headerSizeIP = (ihl[0]&0xf)*4;
nixnax	26:11f4eb2663a7	854	int packetLength = (pktLen[0]<<8)\|pktLen[1]; // ip total packet length
nixnax	26:11f4eb2663a7	855
nixnax	87:9f5ac1fabd95	856	// TCP header
nixnax	87:9f5ac1fabd95	857	char * tcp = ppp.pkt.buf+4+headerSizeIP; // start of tcp packet
nixnax	87:9f5ac1fabd95	858	char * srctcp = tcp + 0; // 2 bytes
nixnax	87:9f5ac1fabd95	859	char * dsttcp = tcp + 2; // 2 bytes
nixnax	87:9f5ac1fabd95	860	char * seqtcp = tcp + 4; // 4 bytes
nixnax	87:9f5ac1fabd95	861	char * acktcp = tcp + 8; // 4 bytes
nixnax	87:9f5ac1fabd95	862	char * offset = tcp + 12; // 4 bits
nixnax	87:9f5ac1fabd95	863	char * flagbitstcp = tcp + 12; // 9 bits
nixnax	87:9f5ac1fabd95	864	char * windowsizetcp = tcp + 14; // 2 bytes
nixnax	87:9f5ac1fabd95	865	char * checksumtcp = tcp + 16; // 2 bytes
nixnax	128:e5958d143e9d	866
nixnax	124:18ef53f1d8b7	867	if(ident) {}; // shut up unused variable reference warning
nixnax	26:11f4eb2663a7	868	int tcpSize = packetLength - headerSizeIP;
nixnax	35:e7068df4d971	869	int headerSizeTCP = ((offset[0]>>4)&0x0f)*4; // size of tcp header only
nixnax	61:b3c1a04efd0a	870	int protocolIP = protocol[0];
nixnax	87:9f5ac1fabd95	871	char * tcpDataIn = tcp + headerSizeTCP; // start of data block after TCP header
nixnax	67:a63e3486bcda	872	int tcpDataSize = tcpSize - headerSizeTCP; // size of data block after TCP header
nixnax	87:9f5ac1fabd95	873	char * tcpDataOut = tcp + 20; // start of outgoing data
nixnax	85:53e57ff1cf05	874	unsigned int seq_in = (seqtcp[0]<<24)\|(seqtcp[1]<<16)\|(seqtcp[2]<<8)\|(seqtcp[3]);
nixnax	85:53e57ff1cf05	875	unsigned int ack_in = (acktcp[0]<<24)\|(acktcp[1]<<16)\|(acktcp[2]<<8)\|(acktcp[3]);
nixnax	85:53e57ff1cf05	876	unsigned int ack_out = seq_in + tcpDataSize;
nixnax	87:9f5ac1fabd95	877	unsigned int seq_out = ack_in; // use their version of our current sequence number
nixnax	81:9ede60e9a2c8	878
nixnax	128:e5958d143e9d	879	// first we shorten the TCP response header to only 20 bytes. This means we ignore all TCP option requests
nixnax	87:9f5ac1fabd95	880	tcpSize = 20; // shorten total TCP packet size to 20 bytes (no data)
nixnax	87:9f5ac1fabd95	881	headerSizeTCP = 20; // shorten outgoing TCP header size 20 bytes
nixnax	87:9f5ac1fabd95	882	offset[0] = (headerSizeTCP/4)<<4; // shorten tcp header size to 20 bytes
nixnax	87:9f5ac1fabd95	883	packetLength = 40; // shorten total packet size to 40 bytes (20 ip + 20 tcp)
nixnax	87:9f5ac1fabd95	884	pktLen[1] = 40; // set total packet size to 40 bytes (20 ip + 20 tcp)
nixnax	87:9f5ac1fabd95	885	pktLen[0] = 0; // set total packet size to 40 bytes (20 ip + 20 tcp)
nixnax	87:9f5ac1fabd95	886
nixnax	35:e7068df4d971	887	int dataLen = 0; // most of our responses will have zero TCP data, only a header
nixnax	38:ab582987926e	888	int flagsOut = TCP_FLAG_ACK; // the default case is an ACK packet
nixnax	87:9f5ac1fabd95	889	int flagsTCP = ((flagbitstcp[0]&1)<<8)\|flagbitstcp[1]; // the tcp flags we received
nixnax	119:e14dd2bf0ea3	890	windowsizetcp[0] = (700 >> 8 ); // tcp window size hi byte
nixnax	119:e14dd2bf0ea3	891	windowsizetcp[1] = (700 & 0xff); // tcp window size lo byte
nixnax	38:ab582987926e	892
nixnax	106:d14e6b597ca3	893	// A sparse TCP flag interpreter that implements stateless TCP connections
nixnax	77:abf92baebb42	894
nixnax	69:23f560087c16	895	switch ( flagsTCP ) {
nixnax	128:e5958d143e9d	896	case TCP_FLAG_ACK:
nixnax	128:e5958d143e9d	897	return;
nixnax	69:23f560087c16	898	case TCP_FLAG_SYN:
nixnax	87:9f5ac1fabd95	899	flagsOut = TCP_FLAG_SYN \| TCP_FLAG_ACK; // something wants to connect - acknowledge it
nixnax	119:e14dd2bf0ea3	900	seq_out = seq_in+0x10000000U; // create a new sequence number using their sequence as a starting point, increase the highest digit
nixnax	85:53e57ff1cf05	901	ack_out++; // for SYN flag we have to increase the sequence by 1
nixnax	69:23f560087c16	902	break;
nixnax	77:abf92baebb42	903	case TCP_FLAG_ACK \| TCP_FLAG_PSH:
nixnax	128:e5958d143e9d	904	if ( (strncmp(tcpDataIn, "GET /", 5) == 0) ) { // check for an http GET command
nixnax	128:e5958d143e9d	905	flagsOut = TCP_FLAG_ACK \| TCP_FLAG_PSH; // set outgoing FIN flag to ask them to close from their side
nixnax	87:9f5ac1fabd95	906	dataLen = httpResponse(tcpDataOut); // send an http response
nixnax	98:3babad0d1bd4	907	} else {
nixnax	128:e5958d143e9d	908	dataLen = tcpResponse(tcpDataOut,tcpDataSize, &flagsOut); // not a web request, send a packet reporting number of received bytes
nixnax	69:23f560087c16	909	}
nixnax	69:23f560087c16	910	break;
nixnax	116:1272e9f7ad70	911	case TCP_FLAG_FIN:
nixnax	116:1272e9f7ad70	912	case TCP_FLAG_FIN \| TCP_FLAG_ACK:
nixnax	98:3babad0d1bd4	913	case TCP_FLAG_FIN \| TCP_FLAG_PSH \| TCP_FLAG_ACK:
nixnax	117:c819ae068336	914	flagsOut = TCP_FLAG_ACK \| TCP_FLAG_FIN; // set outgoing FIN flag to ask them to close from their side
nixnax	128:e5958d143e9d	915	ack_out++; // for FIN flag we have to increase the sequence by 1
nixnax	69:23f560087c16	916	break;
nixnax	77:abf92baebb42	917	default:
nixnax	69:23f560087c16	918	return; // ignore remaining packets
nixnax	93:9675adc36882	919	} // switch
nixnax	77:abf92baebb42	920
nixnax	69:23f560087c16	921	// The TCP flag handling is now done
nixnax	105:45001195b325	922	// first we swap source and destination TCP addresses and insert the new ack and seq numbers
nixnax	65:23b17c43aa0f	923	char tempHold[12]; // it's 12 long because we later reuse it when building the TCP pseudo-header
nixnax	60:2b770949c911	924	memcpy(tempHold, srcAdr,4);
nixnax	65:23b17c43aa0f	925	memcpy(srcAdr, dstAdr,4);
nixnax	60:2b770949c911	926	memcpy(dstAdr, tempHold,4); // swap ip address source/dest
nixnax	60:2b770949c911	927	memcpy(tempHold, srctcp,2);
nixnax	65:23b17c43aa0f	928	memcpy(srctcp, dsttcp,2);
nixnax	60:2b770949c911	929	memcpy(dsttcp, tempHold,2); // swap ip port source/dest
nixnax	95:40af49390daf	930
nixnax	85:53e57ff1cf05	931	acktcp[0]=ack_out>>24;
nixnax	85:53e57ff1cf05	932	acktcp[1]=ack_out>>16;
nixnax	85:53e57ff1cf05	933	acktcp[2]=ack_out>>8;
nixnax	85:53e57ff1cf05	934	acktcp[3]=ack_out>>0; // save ack 32-bit integer
nixnax	85:53e57ff1cf05	935	seqtcp[0]=seq_out>>24;
nixnax	85:53e57ff1cf05	936	seqtcp[1]=seq_out>>16;
nixnax	85:53e57ff1cf05	937	seqtcp[2]=seq_out>>8;
nixnax	85:53e57ff1cf05	938	seqtcp[3]=seq_out>>0; // save seq 32-bit integer
nixnax	38:ab582987926e	939
nixnax	93:9675adc36882	940	flagbitstcp[1] = flagsOut; // update the TCP flags
nixnax	93:9675adc36882	941
nixnax	114:8a5d70bbc1b2	942	// increment our outgoing ip packet counter
nixnax	114:8a5d70bbc1b2	943	ppp.ip.ident++; // get next ident number for our packet
nixnax	93:9675adc36882	944
nixnax	106:d14e6b597ca3	945	// Now we recalculate all the header sizes
nixnax	133:0f5b4085b6d3	946	tcpSize = headerSizeTCP + dataLen; // tcp packet size
nixnax	133:0f5b4085b6d3	947	int newPacketSize = headerSizeIP + tcpSize; // calculate size of the outgoing packet
nixnax	36:2a9b457f8276	948	pktLen[0] = (newPacketSize>>8);
nixnax	36:2a9b457f8276	949	pktLen[1]=newPacketSize; // ip total packet size
nixnax	133:0f5b4085b6d3	950	ppp.pkt.len = newPacketSize+4+2; // ip packet length + 4-byte ppp prefix (ff 03 00 21) + 2 fcs (crc) bytes bytes at the end of the packet
nixnax	36:2a9b457f8276	951
nixnax	38:ab582987926e	952	// the header is all set up, now do the IP and TCP checksums
nixnax	61:b3c1a04efd0a	953	headercheck[0]=0; // IP header checksum
nixnax	61:b3c1a04efd0a	954	headercheck[1]=0; // IP header checksum
nixnax	61:b3c1a04efd0a	955	headerCheckSum(); // calculate the IP header checksum
nixnax	63:9253b0e1b7d8	956
nixnax	64:677b9713a120	957	// now we have to build the so-called 12-byte TCP "pseudo-header" in front of the TCP header (containing some IP header values) in order to correctly calculate the TCP checksum
nixnax	63:9253b0e1b7d8	958	// this header contains the most important parts of the IP header, i.e. source and destination address, protocol number and data length.
nixnax	87:9f5ac1fabd95	959	char * pseudoHeader = tcp-12; // mark the start of the TCP pseudo-header
nixnax	67:a63e3486bcda	960	memcpy(tempHold, pseudoHeader, 12); // preserve the 12 bytes of the IP header where the TCP pseudo-Header will be built
nixnax	61:b3c1a04efd0a	961	memcpy( pseudoHeader+0, srcAdr, 8); // IP source and destination addresses from IP header
nixnax	61:b3c1a04efd0a	962	memset( pseudoHeader+8, 0, 1); // reserved, set to zero
nixnax	61:b3c1a04efd0a	963	memset( pseudoHeader+9, protocolIP, 1); // protocol from IP header
nixnax	62:f192926e42f1	964	memset( pseudoHeader+10, tcpSize>>8, 1); // size of IP data (TCP packet size)
nixnax	62:f192926e42f1	965	memset( pseudoHeader+11, tcpSize, 1); // size of IP data (TCP packet size)
nixnax	38:ab582987926e	966
nixnax	61:b3c1a04efd0a	967	// pseudo-header built, now we can calculate TCP checksum
nixnax	29:30de79d658f6	968	checksumtcp[0]=0;
nixnax	29:30de79d658f6	969	checksumtcp[1]=0;
nixnax	76:00e208cceb8b	970	unsigned int pseudoHeaderSum=dataCheckSum((unsigned char *)pseudoHeader,tcpSize+12); // calculate the TCP checksum starting at the pseudo-header
nixnax	61:b3c1a04efd0a	971	checksumtcp[0]=pseudoHeaderSum>>8;
nixnax	61:b3c1a04efd0a	972	checksumtcp[1]=pseudoHeaderSum;
nixnax	87:9f5ac1fabd95	973	memcpy( tcp-12, tempHold, 12); // restore the 12 bytes that the pseudo-header overwrote
nixnax	114:8a5d70bbc1b2	974	dumpHeaderIP(1); // dump outgoing IP header
nixnax	114:8a5d70bbc1b2	975	dumpHeaderTCP(1); // dump outgoing TCP header
nixnax	124:18ef53f1d8b7	976	for (int i=0; i<70*1000/10; i++) { // 70 ms delay before sending frame - a typical internet delay time
nixnax	119:e14dd2bf0ea3	977	fillbuf(); // catch any incoming characters
nixnax	124:18ef53f1d8b7	978	wait_us(10); // wait less than 1 character duration at 115200
nixnax	119:e14dd2bf0ea3	979	}
nixnax	93:9675adc36882	980	send_pppFrame(); // All preparation complete - send the TCP response
nixnax	133:0f5b4085b6d3	981	if(0) dumpPPPFrame(); // set to 1 to dump transmitted ppp frame
nixnax	128:e5958d143e9d	982	memset(ppp.pkt.buf+44,0,500); // flush out traces of previous data that we may scan for
nixnax	29:30de79d658f6	983	}
nixnax	26:11f4eb2663a7	984
nixnax	29:30de79d658f6	985	void dumpDataTCP()
nixnax	29:30de79d658f6	986	{
nixnax	26:11f4eb2663a7	987	int ipPktLen = (ppp.pkt.buf[6]<<8)\|ppp.pkt.buf[7]; // overall length of ip packet
nixnax	26:11f4eb2663a7	988	int ipHeaderLen = (ppp.pkt.buf[4]&0xf)*4; // length of ip header
nixnax	35:e7068df4d971	989	int headerSizeTCP = ((ppp.pkt.buf[4+ipHeaderLen+12]>>4)&0xf)*4;; // length of tcp header
nixnax	35:e7068df4d971	990	int dataLen = ipPktLen - ipHeaderLen - headerSizeTCP; // data is what's left after the two headers
nixnax	29:30de79d658f6	991	if (v1) {
nixnax	120:bef89e4c906e	992	char pbuf[50]; // local print buffer
nixnax	120:bef89e4c906e	993	fillbuf();
nixnax	120:bef89e4c906e	994	sprintf(pbuf, "TCP %d ipHeader %d tcpHeader %d Data %d\n", ipPktLen, ipHeaderLen, headerSizeTCP, dataLen); // 1 for more verbose
nixnax	120:bef89e4c906e	995	fillbuf();
nixnax	125:ea88200b1df6	996	putsWhileCheckingInput( pbuf );
nixnax	29:30de79d658f6	997	}
nixnax	29:30de79d658f6	998	if (dataLen > 0) {
nixnax	47:00a5ca075f8f	999	ppp.pkt.buf[4+ipHeaderLen+headerSizeTCP+dataLen]=0; // insert a null after the data so debug printf stops printing after the data
nixnax	125:ea88200b1df6	1000	putsWhileCheckingInput( ppp.pkt.buf+4+ipHeaderLen+headerSizeTCP ); // print the tcp payload data
nixnax	125:ea88200b1df6	1001	putsWhileCheckingInput("\n");
nixnax	29:30de79d658f6	1002	}
nixnax	29:30de79d658f6	1003	}
nixnax	26:11f4eb2663a7	1004
nixnax	29:30de79d658f6	1005	void TCPpacket()
nixnax	128:e5958d143e9d	1006	{
nixnax	114:8a5d70bbc1b2	1007	dumpHeaderIP(0); // dump incoming packet header
nixnax	114:8a5d70bbc1b2	1008	dumpHeaderTCP(0); // dump incoming packet header
nixnax	128:e5958d143e9d	1009	if (v2) dumpDataTCP();
nixnax	26:11f4eb2663a7	1010	tcpHandler();
nixnax	11:f58998c24f0b	1011	}
nixnax	11:f58998c24f0b	1012
nixnax	29:30de79d658f6	1013	void otherProtocol()
nixnax	29:30de79d658f6	1014	{
nixnax	119:e14dd2bf0ea3	1015	debugPrintf("Other IP protocol");
nixnax	29:30de79d658f6	1016	}
nixnax	26:11f4eb2663a7	1017
nixnax	29:30de79d658f6	1018	void IPframe()
nixnax	29:30de79d658f6	1019	{
nixnax	10:74f8233f72c0	1020	int protocol = ppp.pkt.buf[13];
nixnax	10:74f8233f72c0	1021	switch (protocol) {
nixnax	29:30de79d658f6	1022	case 1:
nixnax	29:30de79d658f6	1023	ICMPpacket();
nixnax	29:30de79d658f6	1024	break;
nixnax	29:30de79d658f6	1025	case 2:
nixnax	29:30de79d658f6	1026	IGMPpacket();
nixnax	29:30de79d658f6	1027	break;
nixnax	29:30de79d658f6	1028	case 17:
nixnax	29:30de79d658f6	1029	UDPpacket();
nixnax	29:30de79d658f6	1030	break;
nixnax	29:30de79d658f6	1031	case 6:
nixnax	29:30de79d658f6	1032	TCPpacket();
nixnax	29:30de79d658f6	1033	break;
nixnax	29:30de79d658f6	1034	default:
nixnax	29:30de79d658f6	1035	otherProtocol();
nixnax	29:30de79d658f6	1036	}
nixnax	29:30de79d658f6	1037	}
nixnax	9:0992486d4a30	1038
nixnax	29:30de79d658f6	1039	void LCPconfReq()
nixnax	29:30de79d658f6	1040	{
nixnax	119:e14dd2bf0ea3	1041	debugPrintf("LCP Config ");
nixnax	9:0992486d4a30	1042	if (ppp.pkt.buf[7] != 4) {
nixnax	111:6a3b77c065c0	1043	ppp.pkt.buf[4]=4; // allow only "no options" which means Maximum Receive Unit (MRU) is default 1500 bytes
nixnax	119:e14dd2bf0ea3	1044	debugPrintf("Reject\n");
nixnax	93:9675adc36882	1045	send_pppFrame();
nixnax	9:0992486d4a30	1046	} else {
nixnax	9:0992486d4a30	1047	ppp.pkt.buf[4]=2; // ack zero conf
nixnax	119:e14dd2bf0ea3	1048	debugPrintf("Ack\n");
nixnax	93:9675adc36882	1049	send_pppFrame();
nixnax	119:e14dd2bf0ea3	1050	debugPrintf("LCP Ask\n");
nixnax	11:f58998c24f0b	1051	ppp.pkt.buf[4]=1; // request no options
nixnax	93:9675adc36882	1052	send_pppFrame();
nixnax	9:0992486d4a30	1053	}
nixnax	9:0992486d4a30	1054	}
nixnax	9:0992486d4a30	1055
nixnax	29:30de79d658f6	1056	void LCPconfAck()
nixnax	29:30de79d658f6	1057	{
nixnax	119:e14dd2bf0ea3	1058	debugPrintf("LCP Ack\n");
nixnax	29:30de79d658f6	1059	}
nixnax	9:0992486d4a30	1060
nixnax	29:30de79d658f6	1061	void LCPend()
nixnax	29:30de79d658f6	1062	{
nixnax	29:30de79d658f6	1063	ppp.pkt.buf[4]=6;
nixnax	93:9675adc36882	1064	send_pppFrame(); // acknowledge
nixnax	81:9ede60e9a2c8	1065	ppp.online=0; // start hunting for connect string again
nixnax	81:9ede60e9a2c8	1066	pppInitStruct(); // flush the receive buffer
nixnax	119:e14dd2bf0ea3	1067	debugPrintf("LCP End\n");
nixnax	9:0992486d4a30	1068	}
nixnax	9:0992486d4a30	1069
nixnax	29:30de79d658f6	1070	void LCPother()
nixnax	29:30de79d658f6	1071	{
nixnax	119:e14dd2bf0ea3	1072	debugPrintf("LCP Other\n");
nixnax	95:40af49390daf	1073	dumpPPPFrame();
nixnax	29:30de79d658f6	1074	}
nixnax	29:30de79d658f6	1075
nixnax	29:30de79d658f6	1076	void LCPframe()
nixnax	29:30de79d658f6	1077	{
nixnax	29:30de79d658f6	1078	int code = ppp.pkt.buf[4];
nixnax	29:30de79d658f6	1079	switch (code) {
nixnax	29:30de79d658f6	1080	case 1:
nixnax	29:30de79d658f6	1081	LCPconfReq();
nixnax	29:30de79d658f6	1082	break; // config request
nixnax	29:30de79d658f6	1083	case 2:
nixnax	29:30de79d658f6	1084	LCPconfAck();
nixnax	29:30de79d658f6	1085	break; // config ack
nixnax	29:30de79d658f6	1086	case 5:
nixnax	29:30de79d658f6	1087	LCPend();
nixnax	29:30de79d658f6	1088	break; // end connection
nixnax	29:30de79d658f6	1089	default:
nixnax	29:30de79d658f6	1090	LCPother();
nixnax	29:30de79d658f6	1091	}
nixnax	9:0992486d4a30	1092	}
nixnax	9:0992486d4a30	1093
nixnax	29:30de79d658f6	1094	void discardedFrame()
nixnax	29:30de79d658f6	1095	{
nixnax	128:e5958d143e9d	1096	if (v0) debugPrintf("Frame is not IP, IPCP or LCP: %02x %02x %02x %02x\n", ppp.pkt.buf[0],ppp.pkt.buf[1],ppp.pkt.buf[2],ppp.pkt.buf[3]);
nixnax	9:0992486d4a30	1097	}
nixnax	9:0992486d4a30	1098
nixnax	29:30de79d658f6	1099	void determinePacketType()
nixnax	29:30de79d658f6	1100	{
nixnax	29:30de79d658f6	1101	if ( ppp.pkt.buf[0] != 0xff ) {
nixnax	119:e14dd2bf0ea3	1102	debugPrintf("byte0 != ff\n");
nixnax	29:30de79d658f6	1103	return;
nixnax	29:30de79d658f6	1104	}
nixnax	29:30de79d658f6	1105	if ( ppp.pkt.buf[1] != 3 ) {
nixnax	119:e14dd2bf0ea3	1106	debugPrintf("byte1 != 3\n");
nixnax	29:30de79d658f6	1107	return;
nixnax	29:30de79d658f6	1108	}
nixnax	29:30de79d658f6	1109	if ( ppp.pkt.buf[3] != 0x21 ) {
nixnax	119:e14dd2bf0ea3	1110	debugPrintf("byte2 != 21\n");
nixnax	29:30de79d658f6	1111	return;
nixnax	29:30de79d658f6	1112	}
nixnax	9:0992486d4a30	1113	int packetType = ppp.pkt.buf[2];
nixnax	9:0992486d4a30	1114	switch (packetType) {
nixnax	29:30de79d658f6	1115	case 0xc0:
nixnax	29:30de79d658f6	1116	LCPframe();
nixnax	29:30de79d658f6	1117	break; // link control
nixnax	29:30de79d658f6	1118	case 0x80:
nixnax	29:30de79d658f6	1119	IPCPframe();
nixnax	29:30de79d658f6	1120	break; // IP control
nixnax	29:30de79d658f6	1121	case 0x00:
nixnax	29:30de79d658f6	1122	IPframe();
nixnax	29:30de79d658f6	1123	break; // IP itself
nixnax	29:30de79d658f6	1124	default:
nixnax	29:30de79d658f6	1125	discardedFrame();
nixnax	9:0992486d4a30	1126	}
nixnax	29:30de79d658f6	1127	}
nixnax	9:0992486d4a30	1128
nixnax	128:e5958d143e9d	1129	void wait_for_PPP_frame() // scan the PPP serial input stream for frame start markers
nixnax	50:ad4e7c3c88e5	1130	{
nixnax	85:53e57ff1cf05	1131	while(1) {
nixnax	93:9675adc36882	1132	fillbuf(); // handle received characters
nixnax	124:18ef53f1d8b7	1133	if ( ppp.rx.head != ppp.rx.tail ) {
nixnax	81:9ede60e9a2c8	1134	int oldTail = ppp.rx.tail; // remember where the character is located in the buffer
nixnax	81:9ede60e9a2c8	1135	int rx = pc_getBuf(); // get the character
nixnax	50:ad4e7c3c88e5	1136	if (rx==FRAME_7E) {
nixnax	120:bef89e4c906e	1137	if (ppp.firstFrame) { // is this the start of the first frame start
nixnax	119:e14dd2bf0ea3	1138	ppp.firstFrame=0;
nixnax	128:e5958d143e9d	1139	ppp.rx.rtail = ppp.rx.tail; // update real-time tail with the virtual tail
nixnax	120:bef89e4c906e	1140	ppp.hdlc.frameStartIndex = ppp.rx.tail; // remember where first frame started
nixnax	119:e14dd2bf0ea3	1141	} else {
nixnax	119:e14dd2bf0ea3	1142	ppp.hdlc.frameEndIndex=oldTail; // mark the frame end character
nixnax	119:e14dd2bf0ea3	1143	processPPPFrame(ppp.hdlc.frameStartIndex, ppp.hdlc.frameEndIndex); // process the frame
nixnax	128:e5958d143e9d	1144	ppp.rx.rtail = ppp.rx.tail; // update real-time tail with the virtual tail
nixnax	128:e5958d143e9d	1145	ppp.hdlc.frameStartIndex = ppp.rx.tail; // remember where next frame started
nixnax	119:e14dd2bf0ea3	1146	break;
nixnax	119:e14dd2bf0ea3	1147	}
nixnax	50:ad4e7c3c88e5	1148	}
nixnax	50:ad4e7c3c88e5	1149	}
nixnax	85:53e57ff1cf05	1150	}
nixnax	50:ad4e7c3c88e5	1151	}
nixnax	50:ad4e7c3c88e5	1152
nixnax	29:30de79d658f6	1153	void scanForConnectString()
nixnax	29:30de79d658f6	1154	{
nixnax	81:9ede60e9a2c8	1155	while(ppp.online == 0) {
nixnax	114:8a5d70bbc1b2	1156	fillbuf(); // gather received characters
nixnax	81:9ede60e9a2c8	1157	// search for Windows Dialup Networking "Direct Connection Between Two Computers" expected connect string
nixnax	106:d14e6b597ca3	1158	char * found1 = strstr( (char *)ppp.rx.buf, "CLIENT" );
nixnax	107:5fe806713d49	1159	if (found1 != NULL) {
nixnax	107:5fe806713d49	1160	// respond with Windows Dialup networking expected "Direct Connection Between Two Computers" response string
nixnax	119:e14dd2bf0ea3	1161	if (v0) debugPrintf("Found connect string \"CLIENT\", sent \"CLIENTSERVER\"\n");
nixnax	107:5fe806713d49	1162	pc.puts("CLIENTSERVER");
nixnax	120:bef89e4c906e	1163	ppp.online=1; // we are connected - set flag so we stop looking for the connect string
nixnax	119:e14dd2bf0ea3	1164	fillbuf();
nixnax	9:0992486d4a30	1165	}
nixnax	9:0992486d4a30	1166	}
nixnax	103:4f5512dd11cf	1167	}
nixnax	81:9ede60e9a2c8	1168
nixnax	0:2cf4880c312a	1169	int main()
nixnax	0:2cf4880c312a	1170	{
nixnax	128:e5958d143e9d	1171	pc.baud(115200); // USB serial port to pc
nixnax	128:e5958d143e9d	1172	debugBaudRate(115200); // baud rate for our (optional) debug port
nixnax	128:e5958d143e9d	1173	debugPrintf("\x1b[2J\x1b[H\x1b[30mmbed PPP-Blinky HTTP & WebSocket server ready :)\n"); // VT100 codes for clear_screen, home, black_text - Tera Term is a handy VT100 terminal
nixnax	133:0f5b4085b6d3	1174
nixnax	9:0992486d4a30	1175	pppInitStruct(); // initialize all the PPP properties
nixnax	0:2cf4880c312a	1176	while(1) {
nixnax	128:e5958d143e9d	1177	scanForConnectString(); // wait for connect from PC dial-up networking
nixnax	81:9ede60e9a2c8	1178	while(ppp.online) {
nixnax	120:bef89e4c906e	1179	wait_for_PPP_frame(); // wait for a PPP frame
nixnax	81:9ede60e9a2c8	1180	}
nixnax	7:ab147f5e97ac	1181	}
nixnax	105:45001195b325	1182	}

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed 2 deprecated
Created:	27 Dec 2016
Imports:	426
Forks:	1
Commits:	276
Dependents:	0
Dependencies:	1
Followers:	22

The code in this repository is MIT licensed.