Language/Python/Networking-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Networking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Introduction\n",
    "The term **Networking** in general is defined as the process of interacting with others to exchange information. Similarly, in terms of computers, networking is the process of *exchanging information*, whether it be from **client-client**, **client-server** or even **client to itself**.\n",
    "\n",
    "**Client**: Client is defined as that part of a software or machine which interacts with the user. For eg- the interface of any website that you see is the client side of the website. \n",
    "\n",
    "**Server**: Server is defined as that part of a software or machine which provides the service to the clients. For eg- when you search any query on Google you enter the query on the interface (client side) which is then passed to the server (server side) where the computations are done to find relevant results. The results are then again sent back to the client side for the user to see.  \n",
    "\n",
    "As seen in the above example, networking is an important concept required for exchange of information!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Networking we do everyday (but don't necessarily notice): \n",
    "1. Skype: Skype user peer-to-peer (client-client) networking model in which the video input from users is recieved from one device and communicated to other devices on the call. The video input recieved is not received by the server, that is why the networking model is called peer-to-peer.\n",
    "2. Whatsapp: Whatsapp uses client-server networking model in which the chats sent from one device (client) are sent to the server for storing in the database. These chats are then sent to the other device (client) from the server.\n",
    "3. Gaming: Games like PubG and CS:Go use peer-to-peer (client-client) networking models while playing online. The movement information of one player is continuously sent to all the other players currently in the same game. This enables the other person to see other players move. \n",
    "\n",
    "#### Why do you think Whatsapp uses client-server networking model and not  peer-to-peer?\n",
    "1. Not every person is in connection to the internet (network) all the time. So in case of peer-to-peer there might be a case that the send data from one device might not be received by other.\n",
    "2. The data needs to be stored in Whatsapp servers so it is a better way to send data to server rather than the client directly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Socket\n",
    "Socket is defined as one endpoint of a two-way communication link between two programs running on the network.\n",
    "A socket is bound to a port number so that the TCP layer can identify the application that is destined to be sent to. An endpoint is a combination of an IP address and a port number. \n",
    "\n",
    "Some important terms:\n",
    "\n",
    "**IP address** - All computers connected to a network are provided an IP address which acts as a unique identity for the computer.\n",
    "\n",
    "**Port number** - A port number is a communication endpoint which can help in directing the data towards a particular service (running on that particular port). It is provided along with the IP address. Port 1 to 1023 are reserved by the system.\n",
    "\n",
    "**TCP** - Transmission Control Protocol is a connection-oriented communications protocol that facilitates the exchange of messages between computing devices in a network.\n",
    "\n",
    "**UCP** - Universal Control Protocol is a standard for transmitting short messages over cellular networks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) Socket Module\n",
    "The Socket Module is present in every major language. These modules when imported, help us to network/communicate with others. \n",
    "For eg - Java, Python, Javascript, etc.\n",
    "Here we will understand the working of Socket Module in Python language.\n",
    "\n",
    "**Socket** module enables us to connect two nodes of a network to communicate with each other. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import socket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4) Methods in Socket Module\n",
    "These are the methods that are present in the Socket Module to enable you to do various tasks -\n",
    "\n",
    "#### A) socket.socket() - \n",
    "This creates a socket object that needs to be created both on client as well as server side.\n",
    "#### B) socket.bind() - \n",
    "Used to bind the address to the port number for a connection.\n",
    "#### C) socket.accept() - \n",
    "Used to accept a connection and returns a pair of values (conn and address)\n",
    "#### D) socket.connect() - \n",
    "This method initiates the connection.\n",
    "#### E) socket.listen() - \n",
    "Used to listen to the remote address specified as the parameter.\n",
    "#### F) socket.close() - \n",
    "Used to close the socket connection.\n",
    "#### G) socket.gethostname() - \n",
    "Used as the host in the *bind* function when the server and client are on the same computer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**-\n",
    "socket.socket() method requires 2 arguments for socket_family and socket_type\n",
    "\n",
    "#### 1) The options for socket family are- \n",
    "    a) AF_INET - AF stands for Address Family\n",
    "    b) PF_INET - PF stands for Protocol Family\n",
    "    c) PF_UNIX\n",
    "    d) PF_X25, etc\n",
    "#### 2) The options for socket_type are-\n",
    "    a) SOCK_STREAM - For connection oriented protocols\n",
    "    b) SOCK_DGRAM - For connectionless protocols\n",
    "    c) SOCK_RAW \n",
    "    d) SOCK_RDM, etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5) Client and Server\n",
    "A typical **Server side** Socket code would look like this..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import socket\n",
    "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "s.bind((socket.gethostname(), 5000)\n",
    "s.listen(5)\n",
    "while True:\n",
    "    clt, adr = s.accept()\n",
    "    print(f\"Connection to {adr} established\")\n",
    "    clt.send(bytes(\"Socket Programming in Python\", \"utf-8\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the **Server Side** we create an object of Socket by providing the *socket_family* and *socket_type* (options provided above). This object is then used to bind the *host* with the the port number as the data would be accessed by the computer by the port number. \n",
    "\n",
    "\n",
    "Then we use this object to execute the *accept* method which returns the client-socket and the address. The client socket needs to run on the same port number to be found by the server. \n",
    "\n",
    "We can then use the client side socket obtained from the accept method to send byte data to the client.\n",
    "\n",
    "This script can be run by the following command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "python SERVER_FILENAME.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A typical **Client side** Socket code would look like this..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import socket\n",
    "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "s.connect((socket.gethostname(), 5000))\n",
    "msg = s.recv(100)\n",
    "print(msg.decode(\"utf-8\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the **Client Side** first we create an object of Socket exactly as the server side.\n",
    "\n",
    "The *connect* method is then used (similar to bind method) that tells the socket which port to run on. The port needs to be same which you used in bind function on server side. This helps the server to find the client and communicate. \n",
    "\n",
    "We can then recieve the byte data sent from server side and decode it with utf-8 encoding pattern.\n",
    "\n",
    "The script can be run by the following command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "python CLIENT_FILENAME.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make the Server code and Client code communicate you need to run both the scripts from seperate python files in seperate command prompts to see the communication results.\n",
    "\n",
    "run server using-\n",
    "*python SERVER_FILENAME.py*\n",
    "\n",
    "run client using-\n",
    "*python CLIENT_FILENAME.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6) Internet Modules\n",
    "Internet modules are extremely important to understand and remember as these modules help you communicate with the mentioned protocols\n",
    "\n",
    "|Protocol | Function| Port number|Module|\n",
    "|---|---|---|---|\n",
    "|HTTP|Web Pages|80|httplib, urllib, xmlrpclib|\n",
    "|NNTP|Usene news|119|nntplib|\n",
    "|FTP\t|File transfers|20|\tftplib, urllib|\n",
    "|SMTP\t|Sending email|\t25\t|smtplib|\n",
    "|POP3\t|Fetching email\t|110\t|poplib|\n",
    "|IMAP4\t|Fetching email\t|143\t|imaplib|\n",
    "|Telnet\t|Command lines\t|23\t|telnetlib|\n",
    "|Gopher\t|Document transfers|\t70\t|gopherlib, urllib|\n",
    "\n",
    "These port numbers mentioned are reserved by system for the protocol mentioned. You can use these mentioned python modules and the associated ports to perform the mentioned function/action. \n",
    "\n",
    "For eg- You can use *urllib* module to connect to Google through the port number which is fixed in all systems for HTTP Protocols. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">This tutorial is intended to be a public resource. As such, if you see any glaring inaccuracies or if a critical topic is missing, please feel free to point it out or (preferably) submit a pull request to improve the tutorial. Also, we are always looking to improve the scope of this article. For anything feel free to mail us @ colearninglounge@gmail.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Author of this article is Yash Sonar. You can follow him on [LinkedIn](https://www.linkedin.com/in/yash-sonar-b89265176/), [Medium](https://medium.com/@yashsonar213) and [Github](https://github.com/Yash-567) "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}