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@139:1f87c6bc8db3, 2017-08-20 (annotated)

Committer:: nixnax
Date:: Sun Aug 20 19:54:45 2017 +0000
Revision:: 139:1f87c6bc8db3
Parent:: 137:eda0cfcf4d3c
Child:: 140:f526e9ecfebb

Moved text-align in root web page to center everything.

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

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.