Part A - Networking Projects - Implement Tcp/Ip Stack In C

C/C++ Linux Project, Network Socket Programming, Build TCP/IP Stack, Final Year Project, L2 & L3 Implementation in C

What you'll learn

Implement Layer 2/3 of TCP/IP Stack by yourself from Scratch

Writing Custom CLI commands to configure network topology

Building Network Topology from Scratch

Implement Routing and Switching Algorithms - The practical way

Timers, GLthreads, Library integration, Makefile, Project modularization Techniques

Managing and developing a big source code from scratch using git, a Version control System

This is 100% Coding Course with minimal Theory

In Every other interview in Networking Domain, You shall be asked to explain Basic Routing Concepts, So Do not miss this Course !

Requirements

Basic L2 and L3 routing knowledge is very essential

Good in Coding in C or any one main stream language

Must know how to work with git - atleast basics

Good with Pointers and Memory management Skills in C

Description

      Student Level: Intermediate to Advanced to Working Professionals, Beginners in Coding pls excuse this course.      Talk to your Prof: Use this Project as your Final Year Under-Grad Project      Note: If you are buying this course, pls do not buy my other course on - "Integrate CLI interface to you C/C+++ Project". It's all videos that are already included in this course.This is a 100% Coding based Course in C in which we will develop a TCP/IP Stack from scratch having Data Link Layer, Network Layer and Application Layer in Operation. This is one big project split up into 6 mini-projects. The development of the sister course (Part-B) is in progress. This Course will set you ready for a core network developer's role in the industry. If you are thorough with basics of L2 Routing including ARP, L3 routing, then probably you already have the required knowledge for this project-based course. If not, you should enroll in to my course - "Networking Concepts and Programming from Scratch" and at-least do section number : 3 to 5. For VLANs implementation section 6,7, and 8 is required. We shall be implementing this theory in C now. If you have some other favorite language, feel free to do this course in that, I don't mind, but I shall be explaining logic and showing the demos in C only.In this course, We shall be implementing a TCP/IP Stack demo through 6 Networking Projects. All Below Projects should be done in the same sequence as listed.Project 1 : Build a MultiNode Topology Emulation of Routers and Switches Project 2 : Implement DataLink Layer (L2 routing), including ARPProject 3 : Implement L2 Switching (Mac-based Learning and Forwarding)Project 4 : Implement Vlan Based Mac learning and ForwardingProject 5 : Implement Network Layer (L3 routing)Project 6 : Case Study : Implement IP-Tunnelling (Optional)In these mini Projects, we shall be implementing the packet Journey Upwards and Downwards through layers of TCP/IP Stack (= OSI Model). We shall be implementing the TCP/IP Stack !! There is minimal Socket Programming in this course. Not every Networking project has to be socket programming based. Along the way, we shall be discussing and implementing the solution to new challenges we encounter while solving the problem. Based on how this course is accepted by students, I would add more projects to this course based on the student's feedback.After Doing These Projects, you shall be able to :1. Tell why you need Data link layer and Network Layer2. How to design a new Application protocol on a TCP/IP stack (just like ICMP, HTTP, etc all work on TCP/IP Stack)3. Get your hands dirty with industry-level network programming.4. Learn cooking up, parsing and reading the packet buffers5. Understand End-To-End Architecture and Design of Network Application and TCP/IP Stack6. Conquer Interviews for the role of Network Developer Engineer7. Decorate your GitHub, and add a strong project to your HAT, Expected LOCs of this course shall exceed 10k !This project will fill up the gap between theoretical knowledge and the Implementation version of it. How does it sound that you have written code by your own hands to resolve ARP, packet forwarding, etc. Decorate your resume and GitHub with this project.This course is divided into Two Parts :Part A - In this part of the course, we shall be building up the Network topology Infrastructure comprising of routers, switches, and links connecting them. Nodes can also exchange packets with their neighbors. Basically, we want to simulate a fully programmable and configurable network topology in this part of the course. This is Project 1.Part B - The Configurable Network Topology build in Part A of the course shall be used to implement the Remaining five Projects [2-6] as listed above.We shall be setting up all the required infrastructure to mimic the network topology - and that itself is a mini project altogether. We shall be creating nodes, links connecting nodes, configuring network parameters on nodes, sending and receiving traffic streams - All in one project. This is Megaproject, expected LOC may go to tens of thousands if we keep on adding TCP/IP stack features onto it. The sky is the limit.The best thing about this project is - You will learn many other things along the journey, including setting up Timers, Network Topology Construction, Glthreads - A Glue way of Linked lists, Building Project using Makefile and I am not even talking about learning Software Designing skills. Additional Material has been added in the Appendix Section of the course. We shall be modularizing the project in separate folders, each folder contains code implementing a particular OSI Layer functionality, and Yes, We shall be doing it all from scratch.Warning : 1. Absolute beginners, struggling with basic data structures and pointers, pls excuse this course. You are not prepared for this project. Pls, invest your time into learning basics first.2. Machine Used: Ubuntu 19.04, GCC compiler.  So my codes may not compile on your machine if you are using some other compiler or machine. Table Of Contents :********PART A********[ PROJECT 1] Section 1. KYC (Know your Course)                            Section 2. Developing a Generic Graph TopologyGraph Data structuresGraph related APIsCreating our first static graphSection 3. Construction of a Network Graph TopologyAdding Network topology details to the graphAPIs to configure Network TopologyGet ready without first Hello World Network Topology                              Section 4. Command-Line IntegrationIntegrate CLI Interface to the projectWrite Custom Commands to Display Network Topology detailSection 5. Communication SetupSending a packet to Nbr node on the outgoing interface    Listening and Monitoring Multiple SocketsReceiving a packet on an interface    ********     PART B    ********Section 6. Agenda of Part B[ PROJECT 2] Section 7. Getting Started with TCP/IP Stack DevelopmentInterface ModesEthernet Header FormatAssignment on Ethernet Header ManipulationPacket Processing CriteriaPacket Buffer ManagementSection 8. Implement Layer 2 (DataLink Layer) - ARP                         Get started with ARP ImplementationARP Message Format and ExampleCreating ARP TablesCRUD APIs on ARP TablesCLIs to work with ARP                                                         ARP Cycle and ARP APIsPreparing and Sending ARP Broadcast request msgProcessing ARP Broadcast Request msgSending ARP reply MsgAPI to Start Ingress Journey of the FrameProcessing ARP reply msg and create an ARP entry in ARP tableARP in Action[ PROJECT 3] Section 9. Implement Layer 2 (DataLink Layer) - L2 Switching                 APIs to configure node as L2 switchesSetting up the new Topology with L2 switches and host machinesImplementing MAC learning and Forwarding algorithmsMAC Table Management of L2 switchesTesting L2 switching behavior using ARP[ PROJECT 4] Section 10. Layer 2 - Implementing Vlan Based ForwardingGoals and Pre-requisites802.1Q Vlan hdr formatVlan Tagged Ethernet Header Data StructuresAPI to determine Tagged Vs Untagged framesTagged <–> Untagged Frame Conversion                       Vlan Based MAC Forwarding - Further RoadmapFrame Ingress Condition TableFrame Ingress CompletionFrame Egress Condition TableEgress Frame CompletionTest Vlan Based Forwarding[ PROJECT 5] Section 11. Setting Up Layer 3 Routing Infrastructure (Network Layer)                                  Goals and Pre-requisitesL3 Routing Table SetupCRUD APIs for Routing Table MgmtL3 Route Installation Defining IP HDr format                    Adding Ping CLINetwork and Application Layer InteractionL3 Routing Concepts Revisited Forwarding CaseDirect Host Delivery CaseLocal Delivery CaseSelf-Ping CaseL3 Routing FlowchartsSection 12. Layer 3 Routing Flowcharts Implementation                    Payload Data Transfer from L2 to L3                                   Layer 3 Flowchart Implementation - Step by StepLayer 3 Operations Flowchart ImplementationLayer 2 Operations Flowchart ImplementationTesting Beta Version of our ProjectSection 13. On-Demand ARP ResolutionProblem StatementSolution Strategy                                   Data Structure EnhancementsARP Sane Entry CreationARP Pending List ProcessingFinal Demo of our Complete Project[Project 6]Section 14. Implement IP-IN-IP Encapsulation (Tunneling)Implement IP-IN-IP Encapsulation (Tunneling)Future Extension of the Project. Students are supposed to take this forward on their own.Section 15. Routing between two Vlans (Inter Vlan Routing)

Overview

Section 1: What is this Course About ?

Lecture 1 Agenda

Lecture 2 Sequel Course

Lecture 3 Thanks Giving

Lecture 4 Pre-requisites

Lecture 5 Future Project Extensions

Lecture 6 Project Goals

Lecture 7 Join Telegram Group

Section 2: Generic Graph Construction

Lecture 8 Starting With Generic Graphs

Lecture 9 Feel the End Product of this Course

Lecture 10 Graph Modelling

Lecture 11 Graph Data Structures and Repository Access

Lecture 12 Graph Construction

Lecture 13 Graph APIs

Lecture 14 Makefile - Project Compilation

Section 3: Construction of Networking Topology

Lecture 15 Adding Networking Properties to Graph

Lecture 16 APIs to Add Networking Properties

Lecture 17 Code Walk to construct Network Graph

Section 4: Command Line Integration

Lecture 18 Introducing LibCli Library

Lecture 19 Steps To Integrate LibCLI library with our Project

Lecture 20 Implementing our first CLI

Section 5: Communication Setup

Lecture 21 Goals of this Section

Lecture 22 Design Discussion - Logical and Physical View

Lecture 23 Design Discussion - Physical View in Detail

Lecture 24 8 steps of Implementation

Lecture 25 Implementing Step 1 and 2 - Sockets Creation

Lecture 26 Implementing Step 3 - Starting a Socket Monitoring Thread

Lecture 27 Implementing Step 4 - Packet Transmission

Lecture 28 Implementation Steps 5 - 8

Lecture 29 Test Demo

Lecture 30 Summary

Section 6: Part B - Agenda

Lecture 31 Part B - Agenda

Section 7: Getting Started with TCP/IP Stack Development

Lecture 32 Getting Started with ARP Implementation

Lecture 33 Interface Modes

Lecture 34 Ethernet Header Format

Lecture 35 Packet Processing Criteria

Lecture 36 Packet Buffer Management

Lecture 37 Right Shift of Packet Buffers

Lecture 38 A word of Warning !

Section 8: Layer 2 - Implementing ARP

Lecture 39 ARP Message Format

Lecture 40 ARP Message Format Example

Lecture 41 Creating ARP Tables

Lecture 42 ARP Table - CRUD APIs Prototypes

Lecture 43 ARP Table - CRUD APIs Implementation

Lecture 44 API to trigger ARP Resolution

Lecture 45 ARP CLIs to Add

Lecture 46 ARP Cycle

Lecture 47 ARP APIs - Sending ARP Request

Lecture 48 ARP APIs - Processing ARP Request

Lecture 49 ARP APIs - Sending ARP Reply

Lecture 50 ARP APIs - Processing ARP Reply

Lecture 51 Theory - Starting a Frame's Ingress Journey in TCP/IP Stack

Lecture 52 Implementation - Starting a Frame's Ingress Journey in TCP/IP Stack

Lecture 53 Demo - ARP In Action

Lecture 54 Summary

Section 9: Layer 2 - Implementation of L2 Switching

Lecture 55 Goals of this Section

Lecture 56 Pre-Requisites

Lecture 57 L2 Switch Vs L3 router

Lecture 58 Code Access For this Section

Lecture 59 Interface Modes

Lecture 60 L2 Switch Based Topology

Lecture 61 Mac Tables Setup

Lecture 62 Mac Learning and Forwarding - Quick Revision

Lecture 63 Entry Point for L2 Switching

Lecture 64 Implementing L2 Switching Algorithm

Section 10: Layer 2 - Implementing Vlan Based Forwarding

Lecture 65 Goals and Pre-requisites

Lecture 66 802.1Q Vlan hdr format

Lecture 67 Vlan Tagged Ethernet Header Data Structure

Lecture 68 API to determine Tagged Vs Untagged Ethernet frame

Lecture 69 Tagged <–> Untagged Frame Conversion

Lecture 70 Tagged <–> Untagged Frame Conversion Steps

Lecture 71 APIs to Configure Vlan Memberships

Lecture 72 L2 Switching Topology

Lecture 73 Vlan Based MAC Forwarding - Further Roadmap

Lecture 74 Frame Ingress Condition Table

Lecture 75 Frame Ingress - Quick Code Walk

Lecture 76 Frame Ingress Completion

Lecture 77 Starting with Frame Egress

Lecture 78 Frame Egress Condition Table

Lecture 79 Frame Egress Condition Table - A Quick Code Walk

Lecture 80 Egress Frame Completion

Section 11: Layer 3 - Setting up L3 Routing Infrastructure

Lecture 81 Goals and Pre-requisites

Lecture 82 Phases of This Section

Lecture 83 Code Access For this Section

Lecture 84 Fix : Slight Code Reorganization

Lecture 85 Phase 1 : L3 Routing Table Setup - Data Structures

Lecture 86 Phase 1 : CRUD APIs for Routing Table

Lecture 87 Phase 2 : L3 Route Installation - CLIs and APIs

Lecture 88 Phase 2 : L3 Route Configuration

Lecture 89 Phase 3 : Defining IP Header

Lecture 90 Phase 4 : Topology Used and ARP Assumption

Lecture 91 Phase 5 : Introducing Ping Application

Lecture 92 Phase 5 : Ping CLIs

Lecture 93 Phase 5 : Ping packet Layout

Lecture 94 Phase 5 : Ping Packet Journey from Src to Dst

Lecture 95 Phase 6 : Application <–> Network Layer Interaction

Lecture 96 Phase 6 : Network Layer <–> Data Link Layer Interaction

Lecture 97 Phase 6 : Placing API Signatures in Project Code

Lecture 98 Phase 7 : Layer 3 Routing - Revision of 4 Cases

Lecture 99 Phase 7 : L3 Routing Revision : Case 1 : Forwarding

Lecture 100 Phase 7 : L3 Routing Revision : Case 2 : Direct Host Delivery

Lecture 101 Phase 7 : L3 Routing Revision : Case 3 : Local Delivery

Lecture 102 Phase 7 : L3 Routing Revision : Case 4 : Self-Ping

Lecture 103 Phase 8 : Layer 3 Routing Flowcharts

Section 12: Final Push - Implementing Layer 2 & 3 Routing flowcharts

Lecture 104 Code Access For this Section

Lecture 105 Payload Data Transfer from L2 to L3

Lecture 106 Layer 3 Operation Flowchart 1 Implementation

Lecture 107 Layer 3 Operation Flowchart 2 Implementation

Lecture 108 Layer 2 Routing - Algorithm/Flowchart Discussion

Lecture 109 Part 1 - Layer 2 Routing - Algorithm/Flowchart Implementation

Lecture 110 Part 2 - Layer 2 Routing - Algorithm/Flowchart Implementation

Lecture 111 Demo - Testing Beta Version of our Project

Section 13: On-Demand ARP Resolution

Lecture 112 Problem Statement

Lecture 113 Solution Strategy

Lecture 114 Data Structures Enhancements

Lecture 115 ARP Sane Entry Creation

Lecture 116 ARP Pending List Processing

Lecture 117 Final Project Demo

Section 14: Project - Implement IP-In-IP encapsulation

Lecture 118 IP-IN-IP Encapsulation - Implement in 3 Steps

Lecture 119 Step 1/3 - CLI Requirement

Lecture 120 Step 2/3 - Backend Handler

Lecture 121 Step 3/3 - TCP/IP Stack Changes

Section 15: Project Extension and Home Work for you !

Lecture 122 Inter-Vlan Routing

Section 16: Appendix A : Makefile - Quick Tutorial

Lecture 123 Makefile - Quick Tutorial

Lecture 124 Makefile Analogy - Dependency Tree

Lecture 125 Makefile Assignment - part1

Lecture 126 Makefile Assignment - part2

Lecture 127 Final Makefile

Section 17: Appendix B : GLThreads - a Glue way of Linked List

Lecture 128 Introduction

Lecture 129 Glthreads Definition

Lecture 130 Difference - Traditional Vs Glue Based DLL

Lecture 131 Structure Field Offset

Lecture 132 GLNode Insertion

Lecture 133 GL Node Insertion Code

Lecture 134 GLThread Iteration

Lecture 135 GLNode Removal

Lecture 136 Code Walk - Demo

Lecture 137 Traditional List Problems

Lecture 138 GLThread Benefits

Section 18: Appendix C : Creation and Linking of Libraries

Lecture 139 Resuming with Doubly Linked List Library

Lecture 140 Static and Dynamic Libraries - Quick Creation

Lecture 141 Linking with Static Library

Lecture 142 Linking with Dynamic Library

Lecture 143 Summary

Section 19: Appendix D : The Header File Management

Lecture 144 Duplicate Inclusion of Header File - The Problem

Lecture 145 Duplicate Inclusion of Header File - Solution

Lecture 146 Recursive Dependency - The Problem Statement

Lecture 147 Solution to Recursive Dependency

Section 20: Appendix E : Section 1 - Integrate CLI interface to your C/C++ Projects

Lecture 148 Introduction - What is this Course all about ?

Lecture 149 Command Types

Lecture 150 Command Tree

Lecture 151 Param Types

Lecture 152 Leaf Param Constraint

Lecture 153 Library Capabilities

Section 21: Appendix E : Section 2 - Integrate CLI interface to your C/C++ Projects

Lecture 154 Building A LibCli Library

Lecture 155 Including Header Files and Importing Hooks

Lecture 156 Show Command Addition Example

Lecture 157 Show Command Demo

Lecture 158 Understanding DataFlow from CLI to Backend

Lecture 159 Backend Command Handler Implementation

Lecture 160 Config Command Addition Example

Section 22: Appendix F : Local and Remote Subnets

Lecture 161 Local and Remote Subnets

Section 23: Appendix G : IP-in-IP Encapsulation Theory

Lecture 162 Introduction

Lecture 163 How IP-in-IP Encapsulation works

Section 24: Bonus - Get my other courses for free.

Lecture 164 Bonus - Get my other courses for free.

Students who have done Networking Course in their UG,Working Professionals trying to break into Networking Development Role,Those who want to separate them from the crowd,Those who want to achieve excellence , at par from others