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@134:af9d1f8d451d, 2017-08-16 (annotated)

Committer:: nixnax
Date:: Wed Aug 16 11:14:39 2017 +0000
Revision:: 134:af9d1f8d451d
Parent:: 133:0f5b4085b6d3
Child:: 135:6c3eec2fa634

serial port monitor = no.

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

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.