GIF3001_API_Socket.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/flparen/gif3001-projets/blob/master/GIF3001_API_Socket.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pSJu5jXpgviD"
      },
      "source": [
        "# API socket\n",
        "L'API socket a été introduit dans BSD UNIX 4.1 en 1981. L'API offre une abstraction des fonctions d'émission et de réception de données. \n",
        "\n",
        "Un **socket** est une interface de communication utilisé par un processus utilisateur. Cette interface prend la forme d'un descripteur de fichier, et est utilisé pour la transmission et réception de données.\n",
        "\n",
        "\n",
        "![alt text](https://github.com/flparen/gif3001-socketapi/raw/master/socket_interface.png)\n",
        "\n",
        "\n",
        "\n",
        "La documentation officielle de l'API socket de Python 3 est disponible à l'adresse https://docs.python.org/3/library/socket.html\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wW306rN8gviF"
      },
      "source": [
        "Le tableau suivant résume quelques fonctions offertent par l'API socket de Python. Ces fontions utilisent les fonctions correspondantes du système d'exploitation. Nous allons examiner l'utilisation de ces fonctions dans le contexte d'une application client/serveur TCP et UDP.\n",
        "\n",
        "|**Fonction**|**Description**|**client?**|**serveur?**|\n",
        "|:-----------|--------------|:---------:|:----------:|\n",
        "|socket()|Crée un socket|oui|oui|\n",
        "|connect()|Initie une connexion (TCP)|oui|non|\n",
        "|bind()|Lie le socket sur un adresse IP locale|opt|oui|\n",
        "|listen()|Place le socket en mode écoute pour recevoir des connexions client|non|oui|\n",
        "|accept()|Accepte une connexion client|non|oui|\n",
        "|recv(), send(), ...|Reçoit et envoie des données|oui|oui|\n",
        "|close()|Ferme le socket|oui|oui|\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z51aD95QgviH"
      },
      "source": [
        "\n",
        "Il existe plusieurs familles de socket. Ceux que nous allons utiliser ici sont les sockets de type **IPv4 et IPv6**.\n",
        "\n",
        "|**Famille**|**Description**|\n",
        "|:---------:|:-------------:|\n",
        "|socket.AF\\_INET|IPv4|\n",
        "|socket.AF\\_INET6|IPv6|\n",
        "|socket.AF\\_UNIX|Communication locale|\n",
        "|socket.AF\\_PACKET|Utilisé pour la transmission et réception de packet à la couche liaison (_paquet bas-niveau_)|\n",
        "\n",
        "Python utilise une paire (hôte, port) pour désigner une adresse socket IPv4. *hôte* désigne l'adresse IPv4 ou le nom de la machine, alors que *port* indique le numéro de port du service (ex: 80 pour HTTP).\n",
        "\n",
        "Pour IPv6, l'adresse socket est représenté par (hôte, port, flowinfo, scopeid), où *hôte* et l'adresse IPv6 ou le nom de la machine, et *port* est le numéro de port du service (semblable à IPv4).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lXqfm4K1gviI"
      },
      "source": [
        "Pour utiliser l'interface socket en Python, il est nécessaire d'importer le module `socket`\n",
        "```python\n",
        "import socket\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TVqoQiPAH1ub"
      },
      "source": [
        "## Client TCP\n",
        "\n",
        "Le schéma suivant démontre l'interaction entre un client et serveur TCP du point de vue de l'API socket.\n",
        "\n",
        "![alt text](https://github.com/flparen/gif3001-socketapi/raw/master/client_serveur_TCP.png)\n",
        "\n",
        "Regardons l'implémentation du client en Python\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "c-wCAGaigviK"
      },
      "outputs": [],
      "source": [
        "import socket\n",
        "\n",
        "SERVEUR = \"chat.gif3001.net\"\n",
        "PORT = 3001\n",
        "\n",
        "s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pF-3ZdWoH1ub"
      },
      "source": [
        "L'objet socket est créé. Un socket de type TCP doit être **connecté** pour pouvoir transmettre des données. La fonction *connect()* indique au système d'exploitation d'établir une connexion TCP vers le serveur et le numéro de port indiqué en paramètre."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 172
        },
        "id": "HpORJuBxH1uc",
        "outputId": "61581e3c-8ae7-407a-ea8a-ac32a7b5650f"
      },
      "outputs": [
        {
          "ename": "TimeoutError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTimeoutError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-4e896bf09cfa>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconnect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSERVEUR\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPORT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTimeoutError\u001b[0m: [Errno 110] Connection timed out"
          ]
        }
      ],
      "source": [
        "s.connect((SERVEUR, PORT))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7s8rh-f9H1uc"
      },
      "source": [
        "L'objet socket est maintenant connecté. Nous pouvons utiliser la fonction *send()* pour transmettre des données. Les données doivent être de type *octet* (bytes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j9mtAE5VH1uc"
      },
      "outputs": [],
      "source": [
        "s.send(\"Test en classe\".encode())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jUxaxL1AH1uc"
      },
      "outputs": [],
      "source": [
        "data = s.recv(1024)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Sp0kW9KvH1uc"
      },
      "outputs": [],
      "source": [
        "print (data)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ccEj0PLGH1ud"
      },
      "outputs": [],
      "source": [
        "s.close()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q2lv8BYaH1ud"
      },
      "source": [
        "## Client UDP\n",
        "\n",
        "Le schéma suivant démontre l'interaction entre un client et serveur UDP.\n",
        "\n",
        "![alt text](https://github.com/flparen/gif3001-socketapi/raw/master/client_serveur_UDP.png)\n",
        "\n",
        "Du côté client, la fonction ```connect()``` n'est pas utilisé car UDP est un protocole **sans connexion**. Le code client doit alors spécifier l'adresse et le numéro de port pour chaque données transmises au socket via la fonction ```sendto()``` \n",
        "\n",
        "Les données reçues sur le socket UDP sont lues par l'application via la fonction ```recvfrom()```. En plus de retourner les données reçues, cette fonction retourne également l'adresse et le numéro de port identifiant l'envoyeur des données. Cette information est importante afin de pouvoir transmettre une réponse, le cas échéant."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m3UfxJ-FH1ud"
      },
      "outputs": [],
      "source": [
        "import socket\n",
        "\n",
        "SERVEUR = \"chat.gif3001.net\"\n",
        "PORT = 3001\n",
        "\n",
        "s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LnLOOn54H1ud"
      },
      "outputs": [],
      "source": [
        "s.sendto(\"Test en classe\".encode(), (SERVEUR,PORT))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "x79wpNsTH1ud"
      },
      "outputs": [],
      "source": [
        "data, adresse = s.recvfrom(1024)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sCZyRCuoH1ud"
      },
      "outputs": [],
      "source": [
        "print (data)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ep72OR3TH1ue"
      },
      "outputs": [],
      "source": [
        "print (adresse)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0So3AR0TH1ue"
      },
      "outputs": [],
      "source": [
        "s.close()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oxpLNIhsH1ue"
      },
      "source": [
        "## Fonctions de résolution de nom et adresse\n",
        "\n",
        "### getaddrinfo()\n",
        "```getaddrinfo(host, port, family=0, type=0, proto=0, flags=0)``` est utilisé pour obtenir une liste d'adresse IP et numéro de port à partir d'un **nom de machine** (ex: www.ulaval.ca) et du **nom d'un service** (ex: http). La résolution d'adresse DNS est utilisé par le système d'exploitation pour obtenir les adresses IP.\n",
        "\n",
        "```getaddrinfo()``` retourne un tuple de 5 éléments: ```(family, type, proto, canonname, sockaddr)``` Ces éléments offrent toutes les informations nécessaires pour créer un socket et établir la connexion vers le service identifié. \n",
        "\n",
        "* ```family, type, proto``` sont les informations nécessaires pour la fonction ```socket()```\n",
        "* ```sockaddr``` est l'adresse socket utilisée pour les fonctions ```connect()``` ou ```sendto()``` \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OZQozFgTH1ue",
        "outputId": "950bcf0f-d4d6-4214-fe5c-72ae7c40007b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[(<AddressFamily.AF_INET: 2>,\n",
              "  <SocketKind.SOCK_STREAM: 1>,\n",
              "  6,\n",
              "  '',\n",
              "  ('132.203.210.123', 443))]"
            ]
          },
          "execution_count": 7,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import socket\n",
        "\n",
        "socket.getaddrinfo(\"www.gelgif.ulaval.ca\", 443, type=socket.SOCK_STREAM)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOZsQSIQH8D6"
      },
      "source": [
        "L'exemple du code client TCP peut être écrit pour supporter IPv4 et IPv6"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 172
        },
        "id": "ZQDdIREMIRni",
        "outputId": "8c4bebb1-68e0-469d-931a-de81052dd570"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "La création du socket a échoué\n"
          ]
        },
        {
          "ename": "SystemExit",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "An exception has occurred, use %tb to see the full traceback.\n",
            "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m 1\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/IPython/core/interactiveshell.py:2890: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
            "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
          ]
        }
      ],
      "source": [
        "import socket\n",
        "import sys\n",
        "\n",
        "SERVEUR = \"chat.gif3001.net\"\n",
        "PORT = 3001\n",
        "\n",
        "s = None\n",
        "for res in socket.getaddrinfo(SERVEUR, PORT, type=socket.SOCK_STREAM):\n",
        "    af, socktype, proto, canonname, sa = res\n",
        "    try:\n",
        "        s = socket.socket(af, socktype, proto)\n",
        "    except OSError as msg:\n",
        "        s = None\n",
        "        continue\n",
        "    try:\n",
        "        s.connect(sa)\n",
        "    except OSError as msg:\n",
        "        s.close()\n",
        "        s = None\n",
        "        continue\n",
        "    break\n",
        "if s is None:\n",
        "    print('La création du socket a échoué')\n",
        "    sys.exit(1)\n",
        "with s:\n",
        "    s.send(\"Test en classe\".encode())\n",
        "    data = s.recv(1024)\n",
        "print('Reçu: ', repr(data))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J80t0Oi-H1ue"
      },
      "source": [
        "### getnameinfo()\n",
        "\n",
        "```getnameinfo(sockaddr, flags)``` permet l'opération inverse de getaddrinfo(), c'est à dire retourner le nom de la machine et le nom du service à partir d'une adresse socket IPv4 ou IPv6. La résolution d'adresse DNS est utilisé par le système d'exploitation pour obtenir le nom correspondant à l'adresse IP. Si le nom n'existe pas, l'adresse IP est retournée.\n",
        "\n",
        "Plus d'information est disponible sur cette fonction avec la commande ```man getnameinfo``` sur un poste Linux.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SbwVWN2mH1ue"
      },
      "outputs": [],
      "source": [
        "import socket\n",
        "\n",
        "socket.getnameinfo(('132.203.244.29', 25), 0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M-mTm_wgH1ue"
      },
      "outputs": [],
      "source": [
        "socket.getnameinfo(('2620:0:1af0:dc00::2', 80), 0)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "include_colab_link": true,
      "name": "GIF3001_API_Socket.ipynb",
      "provenance": []
    },
    "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.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}