{"id":275,"date":"2009-06-02T11:32:54","date_gmt":"2009-06-02T10:32:54","guid":{"rendered":"http:\/\/www.oscene.net\/it\/?p=275"},"modified":"2010-09-20T22:27:17","modified_gmt":"2010-09-20T21:27:17","slug":"come-programmare-le-socket-in-ambienti-gnulinux","status":"publish","type":"post","link":"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux","title":{"rendered":"Come programmare le socket in ambienti GNU\/Linux (Parte 1)"},"content":{"rendered":"

Introduzione<\/strong><\/h2>\n

La socket<\/em> (in inglese “presa<\/em>“) \u00c3\u00a8 una particolare astrazione software che permette ai processi messi in comunicazione di inviare e ricevere dati. Le socket sono nate intorno agli anni ’80, il primo kernel a implementarle fu BSD 4.2 nel 1983.<\/p>\n

Client\/Server<\/strong><\/h2>\n

La struttura base di funzionamento delle socket \u00c3\u00a8 di tipo Client\/Server<\/em>. Supponiamo di avere due processi p1 e p2. Il processo p2 ha bisogno del processo p1 per eseguire un determinato compito. Il processo p1 offrir\u00c3\u00a0 al processo p2 tale servizio, esso perci\u00c3\u00b2 sar\u00c3\u00a0 il “Servente” ovvero il Server. Il processo p2 che richiede il servizio sar\u00c3\u00a0 dunque il “Cliente”, ovvero il Client.<\/p>\n

Tipologie di socket<\/strong><\/h2>\n

Esistono quattro tipologie di socket:<\/p>\n

    \n
  1. Socket che utilizzano i protocolli ARPA di internet (come TCP e UDP).<\/li>\n
  2. Gli Unix Domain Socket. Queste socket vengono usate in ambienti POSIX per la comunicazione in locale dei processi.<\/li>\n
  3. Socket che utilizzano i protocolli di Xerox Network System.<\/li>\n
  4. L’ultima tipologia \u00c3\u00a8 quella che utilizza i protocolli della Internationa Standard Association (fa riferimento al modello ISO\/OSI).<\/li>\n<\/ol>\n

    In questo articolo andremo a vedere solo la prima tipologia.<\/p>\n

    Come programmare con le socket<\/strong><\/h2>\n

    Lato server:<\/h3>\n

    – Si genera la socket e la si associa al processo (binding, in italiano “legare”).
    \n– Si mette in ascolto il server per delle nuove connessioni da parte dei client, specificandone il numero.
    \n– A questo punto si accettano le connessioni e avviene la comunicazione.<\/p>\n

    Lato client:<\/h3>\n

    – Si genera anche qui la socket (in questo caso si definisce l’indirizzo ip del server) e la si associa al processo.
    \n– Si effettua una connessione al server, se viene accettata pu\u00c3\u00b2 incominciare la comunicazione.<\/p>\n

    Al termine della sessione di comunicazione vengono chiuse tutte le socket aperte ed i vari stream (nel caso di invii di file).<\/p>\n

    Le funzioni da utilizzare<\/h2>\n

    Funzione Socket<\/strong><\/h3>\n

    La prima funzione che si va ad analizzare \u00c3\u00a8:<\/p>\n

    int<\/span> <\/strong>socket(int<\/span> <\/strong>domain, int<\/span> <\/strong>type, int<\/span> <\/strong>protocol)<\/strong>;\r\n<\/strong><\/pre>\n
    La funzione restituisce un intero che ne identifica la socket. Questo intero viene chiamato socket descriptor<\/em>. La funzione richiede tre argomenti:<\/p>\n
    Argomento: domain<\/em><\/h4>\n
    Questo parametro serve a identificare quale tipo di famiglia di protocolli si vuole utilizzare (vedi, “Tipologie di socket”).<\/p>\n
      \n
    • AF_INET: Protocolli ARPA di internet.<\/li>\n
    • AF_UNIX: Protocolli interni di sistemi POSIX.<\/li>\n
    • AF_NS: Protocolli di Xerox Network System.<\/li>\n
    • AF_ISO: Protocolli della International Standard Association.<\/li>\n<\/ul>\n
      Il prefisso AF sta per address family. Esistono anche un altro gruppo con prefisso PF. L’uso dei due prefissi \u00c3\u00a8 indifferente.<\/p>\n
      Argomento: type<\/em><\/h4>\n
      Questo parametro serve a specificare quale tipo di connessione deve essere stabilita. Pu\u00c3\u00b2 assumere i seguenti valori:<\/p>\n
        \n
      • SOCK_STREAM: Connessione sequenzia (TCP)<\/li>\n
      •  SOCK_DGRAM: Connessione trmite datagramma (UDP)<\/li>\n
      • SOCK_RAW: Connessione tramite protocollo IP<\/li>\n<\/ul>\n
        Esistono anche altri due tipi che non si vedranno.<\/p>\n
        Argomento: protocol<\/em><\/h4>\n
        Serve a specificare quale protocollo usare. Le possibili opzioni sono:<\/p>\n
          \n
        • IPPROTO_TCP: Protocollo TCP.<\/li>\n
        • IPPROTO_UDP: Protocollo UDP.<\/li>\n
        • IPPROTO_ICMP: Protocollo ICMP.<\/li>\n
        • IPPROTO_RAW: Protocollo IP.<\/li>\n
        • 0: Il sistema sceglie il protocollo adatto, in base alla comppia degli argomenti domain e type. Infatti, AF_INET e SOCK_STREAM identificano un protocollo TCP (IPPROTO_TCP), AF_INET e SOCK_DGRAM identificano un protocollo UDP (IPPROTO_UDP).<\/li>\n<\/ul>\n
          Funzione Bind<\/h3>\n
          Questa funzione permette di associare una socket ad un processo. La sua sintassi \u00c3\u00a8 la seguente:<\/p>\n
          int<\/span> <\/strong>bind(int<\/span> <\/strong>sd, struct<\/span> <\/strong>sockaddr *my_addr, int<\/span> <\/strong>addr_lenght)<\/strong>;<\/pre>\n
          Come si pu\u00c3\u00b2 notare richiede 3 argomenti:<\/p>\n
          Argomento: sd<\/em><\/h4>\n
          Ossia il socket descriptor<\/em> ottenuto dalla funzione socket.<\/p>\n
          Argomento: *my_addr<\/em><\/h4>\n
          \u00c3\u02c6 una struttura che contiene informazioni come l’indirizzo al quale si vuole connettere, la famiglia a cui appartiene (AF_xxx) e la porta. Tramite casting viene passata una struttura sockaddr_in:<\/p>\n
          struct<\/span> <\/strong>sockaddr_in {<\/strong><\/pre>\n
          short int<\/span> <\/strong>sin_family; \/* famiglia AF_xxx *\/<\/span><\/strong><\/pre>\n
          unsigned short int<\/span> <\/strong>sin_port; \/* numero di porta *\/<\/span><\/strong><\/pre>\n
          struct<\/span> <\/strong>in_addr sin_addr; \/* l'indirizzo al quale ci si connette (dipende dal protocollo) *\/<\/span><\/strong><\/pre>\n
          char<\/span> <\/strong>sin_zero[8] \/* non usato *\/<\/span><\/strong><\/pre>\n
          }<\/strong>;<\/pre>\n
          Questa struttura attraverso il casting viene trasformata in quest’altra struttura:<\/p>\n
          struct<\/span> <\/strong>sockaddr {<\/strong><\/pre>\n
          uint8_t sa_len;<\/pre>\n
          sa_family_t sa_family; \/* famiglia AF_xxx *\/<\/span><\/strong><\/pre>\n
          char<\/span> <\/strong>sa_data[14]; \/* l'indirizzo al quale ci si connette (dipende dal protocollo) *\/<\/span><\/strong><\/pre>\n
          };<\/strong><\/pre>\n
          Argomento: addr_lenght<\/em><\/h4>\n
          \u00c3\u02c6 la dimensione della struttura passata come secondo argomento. La dimensione della struttura si ricava utilizzando la funzione sizeof.<\/p>\n
          Funzione Listen<\/h3>\n
           int<\/span> <\/strong>listen(int<\/span> <\/strong>sd, int<\/span> <\/strong>queue)<\/strong>;<\/pre>\n
          Una volta creata la socket e associata al processo, quest’ultimo viene messo in ascolto per eventuali connessioni da parte dei client. Accetta solo due argomenti:<\/p>\n
          Argomento: sd<\/em><\/h4>\n
          Il socket descriptor<\/em> generato dalla funzione socket<\/p>\n
          Argomento: queue<\/em><\/h4>\n
          Il numero di connessioni massime che ammette il processo.<\/p>\n
          Funzione Accept<\/h3>\n
          Questa funzione consente di accettare le connessioni da parte dei client. Una volta messo in ascolto il processo viene eseguita questa funzione che genera un socket descriptor associato al client connesso.<\/p>\n
          int<\/span> <\/strong>accept(int<\/span> <\/strong>sd, struct<\/span> <\/strong>sockaddr *client_addr, int<\/span> <\/strong>client_addr_lenght)<\/strong>;<\/pre>\n
          Gli argomenti che vengono richiesti sono:<\/p>\n
          Argomento: sd<\/em><\/h4>\n
          Il solito socket descriptor generato dalla funzione socket<\/p>\n
          Argomento: client_addr<\/em><\/h4>\n
          Una struttura che conterr\u00c3\u00a0 alcune informazioni del client. Come quelle viste in precedenza nella funzione bind.<\/p>\n
          Argomento: client_addr_lenght<\/em><\/h4>\n
          La dimensione della struttura che si passa come secondo argomento.<\/p>\n
          Funzione Connect<\/h3>\n
          Consente ad un client di connettersi ad un server.<\/p>\n
          int<\/span> <\/strong>connect(int<\/span> <\/strong>sdc, sockaddr *server_addr, int<\/span> <\/strong>server_addr_lenght)<\/strong>;<\/pre>\n
          Richiede tre argomenti:<\/p>\n
          Argomento: sdc<\/em><\/h4>\n
          \u00c3\u02c6 il socket descriptor generato dalla funzione socket richiamata all’interno del client.<\/p>\n
          Argomento: server_addr<\/em><\/h4>\n
          \u00c3\u02c6 la struttura che conterr\u00c3\u00a0 l’indirizzo a cui connettersi e la porta del server.<\/p>\n
          Argomento: server_addr_lenght<\/em><\/h4>\n
          \u00c3\u02c6 la lunghezza della struttura passato come secondo argomento.<\/p>\n
          Le funzioni Recv e Send<\/h3>\n
          Vengono usate sia dal server che dal client per inviare informazioni:<\/p>\n
          int<\/span> <\/strong>recv(int<\/span> <\/strong>sd, void<\/span> <\/strong>*msg, int<\/span> <\/strong>msg_lenght, int<\/span> <\/strong>flag)<\/strong>;<\/pre>\n
          int<\/span> <\/strong>send(int<\/span> <\/strong>sd, void<\/span> <\/strong>*msg, int<\/span> <\/strong>msg_lenght, int<\/span> <\/strong>flag)<\/strong>;<\/pre>\n
          Richiedono tre argomenti:<\/p>\n
          Argomento: sd<\/em><\/h4>\n
          Il socket descriptor;<\/em><\/p>\n
          Argomento: msg<\/em><\/h4>\n
          Per quanto riguarda la funzione recv sono i dati da ricevere, quindi \u00c3\u00a8 la variabile nella quale verrano memorizzati.
          \nPer quanto riguarda la funzione send sono i dati da inviare.<\/p>\n
          Argomento: flag<\/em><\/h4>\n
          Generalmente \u00c3\u00a8 posto a 0. Le opzioni possibili non saranno trattate in questo articolo.<\/p>\n
          Esempio<\/h2>\n
          Di seguito sono mostrati i codici sorgente di un server e di un client. Basta rinominarli rispettivamente in server.c<\/em> e client.c<\/em>. Da terminale basta dare i seguenti comandi:<\/p>\n
          $gcc server.c -o server<\/pre>\n
          $gcc client.c -o client<\/pre>\n
          Ecco i sorgenti:<\/p>\n
          Il file server.c<\/strong><\/span><\/h3>\n
          \/*\r\n * File: server.c\r\n * Autore: Iezzi Alessandro\r\n * Server d'esempio\r\n *\/\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\/*#include *\/ \/* Se si vuole visualizzare l'indirizzo ip del client, decommentare questa riga *\/\r\n\r\n#define MAX 8192 \/* in bytes, 8KB *\/\r\n\r\nint main()\r\n{\r\n\tchar buff[MAX]; \/* dati di invio e ricezione *\/\r\n\tstruct sockaddr_in server_addr; \/* indirizzo del server *\/\r\n\tstruct sockaddr_in client_addr; \/* indirizzo del client *\/\r\n\tint sd_server, sd_client; \/* i socket descriptor usati per identificare server e client *\/\r\n\r\n\/*\r\n * Creazione socket descriptor per il server.\r\n * AF_INET + SOCK_STREAM --> TCP, utilizzo del protocollo TCP (IPPROTO_TCP)\r\n *\/\r\n\tif((sd_server = socket(AF_INET, SOCK_STREAM, 0)) < 0)\r\n\t\tprintf(\"Errore nella creazione del server\\n\");\r\n\r\n\/*\r\n * Inseriamo nella struttura alcune informazioni\r\n *\/\r\n\tserver_addr.sin_family = AF_INET; \/* la famiglia dei protocolli *\/\r\n\tserver_addr.sin_port = htons(1745); \/* la porta in ascolto *\/\r\n\tserver_addr.sin_addr.s_addr = INADDR_ANY; \/* dato che \u00c3\u00a8 un server bisogna associargli l'indirizzo della macchina su cui sta girando *\/\r\n\r\n\/*\r\n * Assegnazione del processo alla socket tramite la funzione BIND\r\n *\/\r\n\tif(bind(sd_server, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)\r\n\t\tprintf(\"Errore di binding\\n\");\r\n\r\n\/*\r\n * Si mette in ascolto con un massimo di 20 connessioni\r\n *\/\r\n\tlisten (sd_server, 20);\r\n\r\n\/*\r\n * Essendo un server monothreading, accetter\u00c3\u00a0 una sola connessione per volta\r\n *\/\r\n\tint address_size = sizeof(client_addr); \/* dimensione della struttura client_addr *\/\r\n\/* Con opportune modifiche si potrebbe vedere anche l'ip del client *\/\r\n\tif((sd_client = accept(sd_server, (struct sockaddr *)&client_addr, &address_size)) < 0)\r\n\t\tprintf(\"Errore nella chiamata accept\\n\");\r\n\/* si ricevono i dati dal client *\/\r\n\trecv(sd_client, buff, sizeof(buff), 0);\r\n\tprintf(\"Dati ricevuti: %s\\n\", buff);\r\n\/* Decommentare queste due righe per visualizzare l'indirizzo ip del client *\/\r\n\t\/*char *ip_address = inet_ntoa(client_addr.sin_addr);\r\n\tprintf(\"IP del client: %s\\n\", ip_address);*\/\r\n\/* si spedisce un messaggio *\/\r\n\tstrcpy(buff, \"Tutto OK!\");\r\n\tsend(sd_client, buff, strlen(buff), 0);\r\n\/* chiusura del socket descriptor *\/\r\n\tclose(sd_client);\r\n\tclose(sd_server);\r\n\r\n\treturn EXIT_SUCCESS;\r\n}<\/pre>\n
          Il file client.c<\/span><\/h3>\n
          \/*\r\n * File: client.c\r\n * Autore: Iezzi Alessandro\r\n * Client d'esempio\r\n *\/\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#define MAX 8192 \/* in bytes, 8KB *\/\r\n\r\nint main() {\r\n\tint sd; \/* Il socket descriptor del client *\/\r\n\tstruct sockaddr_in server_addr; \/* l'indirizzo del server *\/\r\n\tchar buff[MAX]; \/* dati di invio e ricezione *\/\r\n\r\n\/* Utilizzando la struttura hostent si definisce l'indirizzo del server *\/\r\n\tstruct hostent *hp;\r\n\thp = gethostbyname(\"127.0.0.1\");\r\n\r\n\tserver_addr.sin_family = AF_INET;\r\n\tserver_addr.sin_port = htons(1745);\r\n\/* successivamente viene memorizzato nella struttura server_addr *\/\r\n\tserver_addr.sin_addr.s_addr = ((struct in_addr*)(hp->h_addr)) -> s_addr;\r\n\r\n\/* Viene creato il socket descriptor *\/\r\n\tif((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)\r\n\t\tprintf(\"Errore nella creazione della socket\\n\");\r\n\r\n\/* Viene connesso al server *\/\r\n\tif(connect(sd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)\r\n\t\tprintf(\"Errore di connessione al server\\n\");\r\n\r\n\/* Si inviano alcuni dati *\/\r\n\tsend(sd, \"Dati inviati dal client\", strlen(\"Dati inviati dal client\"), 0);\r\n\r\n\/* Si riceve la risposta *\/\r\n\trecv(sd, buff, sizeof(buff), 0);\r\n\tprintf(\"Risposta del server: %s\\n\", buff);\r\n\tclose(sd);\r\n\treturn EXIT_SUCCESS;\r\n}<\/pre>\n
          Questo \u00c3\u00a8 tutto, alla prossima.<\/p>\n","protected":false},"excerpt":{"rendered":"
          Introduzione La socket (in inglese “presa“) \u00c3\u00a8 una particolare astrazione software che permette ai processi messi in comunicazione di inviare e ricevere dati. Le socket sono nate intorno agli anni ’80, il primo kernel a implementarle fu BSD 4.2 nel 1983. Client\/Server La struttura base di funzionamento delle socket \u00c3\u00a8 di tipo Client\/Server. Supponiamo di […]<\/p>\n","protected":false},"author":4,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11],"tags":[121,120,119],"yoast_head":"\nCome programmare le socket in ambienti GNU\/Linux (Parte 1) - OScene.net<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Come programmare le socket in ambienti GNU\/Linux (Parte 1) - OScene.net\" \/>\n<meta property=\"og:description\" content=\"Introduzione La socket (in inglese “presa“) \u00c3\u00a8 una particolare astrazione software che permette ai processi messi in comunicazione di inviare e ricevere dati. Le socket sono nate intorno agli anni ’80, il primo kernel a implementarle fu BSD 4.2 nel 1983. Client\/Server La struttura base di funzionamento delle socket \u00c3\u00a8 di tipo Client\/Server. Supponiamo di […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux\" \/>\n<meta property=\"og:site_name\" content=\"OScene.net\" \/>\n<meta property=\"article:published_time\" content=\"2009-06-02T10:32:54+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2010-09-20T21:27:17+00:00\" \/>\n<meta name=\"author\" content=\"Alessandro Iezzi\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Scritto da\" \/>\n\t<meta name=\"twitter:data1\" content=\"Alessandro Iezzi\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux\",\"url\":\"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux\",\"name\":\"Come programmare le socket in ambienti GNU\/Linux (Parte 1) - OScene.net\",\"isPartOf\":{\"@id\":\"https:\/\/www.oscene.net\/it\/#website\"},\"datePublished\":\"2009-06-02T10:32:54+00:00\",\"dateModified\":\"2010-09-20T21:27:17+00:00\",\"author\":{\"@id\":\"https:\/\/www.oscene.net\/it\/#\/schema\/person\/fcc8bb436ed9b2f965fbf1f271db0e52\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.oscene.net\/it\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Come programmare le socket in ambienti GNU\/Linux (Parte 1)\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.oscene.net\/it\/#website\",\"url\":\"https:\/\/www.oscene.net\/it\/\",\"name\":\"OScene.net\",\"description\":\"Ope(rating)n S(ystem)ource Scenario\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.oscene.net\/it\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"it-IT\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.oscene.net\/it\/#\/schema\/person\/fcc8bb436ed9b2f965fbf1f271db0e52\",\"name\":\"Alessandro Iezzi\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/www.oscene.net\/it\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/7befe097eb2c9851e9b096e4d5383f7f?s=96&d=retro&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/7befe097eb2c9851e9b096e4d5383f7f?s=96&d=retro&r=g\",\"caption\":\"Alessandro Iezzi\"},\"sameAs\":[\"http:\/\/iezziweb.webhop.org\"],\"url\":\"https:\/\/www.oscene.net\/it\/author\/gray_fox\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Come programmare le socket in ambienti GNU\/Linux (Parte 1) - OScene.net","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux","og_locale":"it_IT","og_type":"article","og_title":"Come programmare le socket in ambienti GNU\/Linux (Parte 1) - OScene.net","og_description":"Introduzione La socket (in inglese “presa“) \u00c3\u00a8 una particolare astrazione software che permette ai processi messi in comunicazione di inviare e ricevere dati. Le socket sono nate intorno agli anni ’80, il primo kernel a implementarle fu BSD 4.2 nel 1983. Client\/Server La struttura base di funzionamento delle socket \u00c3\u00a8 di tipo Client\/Server. Supponiamo di […]","og_url":"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux","og_site_name":"OScene.net","article_published_time":"2009-06-02T10:32:54+00:00","article_modified_time":"2010-09-20T21:27:17+00:00","author":"Alessandro Iezzi","twitter_card":"summary_large_image","twitter_misc":{"Scritto da":"Alessandro Iezzi","Tempo di lettura stimato":"8 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux","url":"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux","name":"Come programmare le socket in ambienti GNU\/Linux (Parte 1) - OScene.net","isPartOf":{"@id":"https:\/\/www.oscene.net\/it\/#website"},"datePublished":"2009-06-02T10:32:54+00:00","dateModified":"2010-09-20T21:27:17+00:00","author":{"@id":"https:\/\/www.oscene.net\/it\/#\/schema\/person\/fcc8bb436ed9b2f965fbf1f271db0e52"},"breadcrumb":{"@id":"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.oscene.net\/it\/programmazione\/c\/come-programmare-le-socket-in-ambienti-gnulinux#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.oscene.net\/it"},{"@type":"ListItem","position":2,"name":"Come programmare le socket in ambienti GNU\/Linux (Parte 1)"}]},{"@type":"WebSite","@id":"https:\/\/www.oscene.net\/it\/#website","url":"https:\/\/www.oscene.net\/it\/","name":"OScene.net","description":"Ope(rating)n S(ystem)ource Scenario","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.oscene.net\/it\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"it-IT"},{"@type":"Person","@id":"https:\/\/www.oscene.net\/it\/#\/schema\/person\/fcc8bb436ed9b2f965fbf1f271db0e52","name":"Alessandro Iezzi","image":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/www.oscene.net\/it\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/7befe097eb2c9851e9b096e4d5383f7f?s=96&d=retro&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/7befe097eb2c9851e9b096e4d5383f7f?s=96&d=retro&r=g","caption":"Alessandro Iezzi"},"sameAs":["http:\/\/iezziweb.webhop.org"],"url":"https:\/\/www.oscene.net\/it\/author\/gray_fox"}]}},"_links":{"self":[{"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/posts\/275"}],"collection":[{"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/comments?post=275"}],"version-history":[{"count":27,"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/posts\/275\/revisions"}],"predecessor-version":[{"id":297,"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/posts\/275\/revisions\/297"}],"wp:attachment":[{"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/media?parent=275"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/categories?post=275"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.oscene.net\/it\/wp-json\/wp\/v2\/tags?post=275"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}