Programmazione di sistema
|
|
- Ornella Novelli
- 6 anni fa
- Visualizzazioni
Transcript
1 Programmazione di sistema Prof. Gerardo Pelosi & Ing. Michele Scandale Il materiale illustrato a lezione e in queste note contiene anche esempi di Fabrizio Castro, Luca Fossati, Vittorio Zaccaria. Esercizio 1 Scrivere un programma con le seguenti caratteristiche: il processo principale apre un file F in scrittura e genera N processi figli e attende la loro attesa, con F, N parametri ricavati da linea di comando ogni processo figlio, aggiorna il file aperto scrivendo un numero casuale r [0, 255] di caratteri e comunica al processo padre tale numero il processo principale confronta somma i valori restituiti dai figli con la lunghezza attuale del file Soluzione #include <wait.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <stdarg.h> static void print_usage(const char *name) { printf("usage: %s CHILD_NUM FILE\n", name); exit( EXIT_SUCCESS); static void notifyerror(const char *format,...) { va_list args; va_start(args, format); vfprintf(stderr, format, args); va_end(args); int main(int argc, char ** argv) { if (argc < 3) print_usage(argv[0]); int N = atoi(argv[1]); if (N < 1) notifyerror("!\n"); printf("(%d) Creating %d children.\n", getpid(), N); char buffer [256] = {0; 1
2 int fd = open(argv[2], O_CREAT O_TRUNC O_WRONLY O_APPEND, 0644); if (fd < 0) notifyerror("unable to open file %s.\n", argv[2]); pid_t pid; for (int i = 0; i < N; ++i) { pid = fork(); if (pid == -1) notifyerror("fork error!.\n"); if (pid == 0) { // Why this? break; pid_t this_pid = getpid(); if (pid) { printf("(%d) Has %d children.\n", this_pid, N); long sum = 0; for (int i = 0; i!= N; ++i) { int status; pid_t child_pid = wait(& status); printf("(%d) Child %d: terminated with exit value %d.\n", this_pid, child_pid, WEXITSTATUS(status)); if ( WIFEXITED(status)) sum += WEXITSTATUS(status); printf("(%d) Bytes written: %ld\n", this_pid, sum); long size = lseek(fd, 0L, SEEK_END); printf("(%d) File size: %ld bytes\n", this_pid, size); else { pid_t parent_pid = getppid(); printf("(%d) Hello world! My parent is %d\n", this_pid, parent_pid); srand(this_pid); ssize_t written = write(fd, buffer, rand() % 256); printf("(%d) Written %ld bytes in file.\n", this_pid, written); exit(written); 2
3 Esercizio 2 Scrivere un programma per simulare il comportamento di una serie di processi produttori-consumatori con le seguenti caratteristiche: il processo principale predispone un buffer infinito rappresentato da un file il processo principale prosegue creando N processi produttori ciascuno dei quali esegue, tramite exec, un altro eseguibile che svolge il ruolo di produttore il produttore legge da standard input un carattere e lo scrive nel file indicato dal file-descriptor passatogli come argomento il processo principale prosegue poi creando N processi consumatori, il cui codice provvederà a leggere un singolo carattere dal buffer condiviso (se disponibile) e a riportarlo sullo standard output Soluzione Programma principale: #include <fcntl.h> #include <sys/wait.h> void usleep(int); int main(int argc, char ** argv) { if (argc < 2) { printf("usage: %s FILENAME NUM_CHILD\n\n", argv[0]); int N = atoi(argv[2]); if (N < 1) { fprintf(stderr, "Error opening file %s.\n", argv[1]); int fd = open(argv[1], O_CREAT O_TRUNC O_APPEND O_WRONLY); if (fd < 0) { fprintf(stderr, "Error opening file %s.\n", argv[1]); for (int id = 0; id!= N; ++id) { pid_t pid = fork(); if (pid) continue; char fdbuf [128]; char idbuf [128]; snprintf(fdbuf, 128, "%d", fd); snprintf(idbuf, 128, "%d", id); execlp("./es2 - producer", "es2 - producer", fdbuf, idbuf, NULL); // Is this executed? fd = open(argv[1], O_RDONLY); pid_t pid; 3
4 for (int id = 0; id!= N; ++id) { pid = fork(); if (!pid) { char cur; do { usleep (10000); while (read(fd, &cur, 1)!= 1); printf("(%d) Consumer %d: char %c read from file.\n", getpid(), id, cur); exit( EXIT_SUCCESS); // Is it needed a check for pid!= 0? for (int i = 0; i!= 2 * N; ++i) wait(null); Programma produttore: #define FD_STDIN 0 int main(int argc, char ** argv) { if (argc < 3) { fprintf(stderr, "Too few parameters!!!\n"); int fd = atoi(argv[1]); int id = atoi(argv[2]); char cur; ssize_t n_read = 0; while (n_read!= 1 cur == \n cur == \r ) n_read = read(fd_stdin, &cur, 1); printf("(%d) Producer %d: char %c read from stdin buffer\n", getpid(), id, cur); write(fd, &cur, 1); 4
5 Esercizio 3 Scrivere un server di rete TCP/IP che svolga la seguente funzione: rimanga in attesa di connessione dai client TELNET (ogni client è servito in parallelo) per ogni client rimanga in attesa di comandi. Un comando è composto da due stringhe: nome completo del programma da eseguire parametro da passare al programma Per ogni comando ricevuto, il server esegue il programma specificato mediante execv e poi si mette in attesa per comandi successivi la connessione con il client viene chiusa quando il server riceve la stringa q come nome del programma. Si assuma per semplicità che tutte le stringhe siano di lunghezza inferiore a 40 caratteri. Soluzione pid_t wait(int *stat_loc) restituisce nella locazione stat_loc l informazione relativa allo stato di uscita del processo figlio su cui è stata effettuata la wait stessa. Le macro WIFEXITED e WEXITSTATUS consentono rispettivamente di sapere se il processo è terminato mediante una exit e con che valore questo ha terminato. Vi sono altre macro per avere altre informazioni: man 3 wait. #include <stdint.h> #include <string.h> #include <sys/socket.h> #include <netinet/in.h> #include <wait.h> #define SERVER_PORT 4000 #define MAX_CONN 10 #define MAX_CMD_SIZE 40 #define MAX_PARAM_SIZE 40 static int setup_server_socket( uint16_t port) { struct sockaddr_in addr; addr. sin_family = AF_INET; addr. sin_port = htons(port); addr. sin_addr.s_addr = htonl( INADDR_ANY); int sock = socket(af_inet, SOCK_STREAM, 0); if (sock == -1) { fprintf(stderr, "Error on creating socket!\n"); if (bind(sock, (const struct sockaddr *)&addr, sizeof(addr)) == -1) { fprintf(stderr, "Error on binding socket!\n"); return sock; static void sanitize_eol(char *str) { size_t len = strlen(str); if (len > 0 && str[len - 1] == \n ) 5
6 str[len - 1] = \0 ; if (len > 1 && str[len - 2] == \r ) str[len - 2] = \0 ; static ssize_t safe_recv(int sd, char *buffer, size_t len, int flags, char *term) { ssize_t l = 0; ssize_t i = 0; size_t t_len = term? strlen(term) : 0; for (; i < len; i += l) { l = recv(sd, buffer + i, len - i, flags); if (l == -1) return -1; if (term && memcmp(buffer + l - t_len, term, t_len) == 0) return l; return i; static void server_cmd_exec(int client_sock, char *cmd) { char param[ MAX_PARAM_SIZE]; ssize_t l = safe_recv(client_sock, param, MAX_PARAM_SIZE, 0, "\r\n"); close( client_sock); if (l > 0) { pid_t this_pid = getpid(); param[l] = \0 ; sanitize_eol(param); printf("(%d) Received param: %s\n", this_pid, param); char *argv[3]; argv[0] = cmd; argv[1] = param; argv[2] = NULL; printf("(%d) Requested command line: %s %s\n", this_pid, cmd, param); if (execvp(cmd, argv) == -1) printf("(%d) Exec error\n", this_pid); int main(int argc, const char ** argv) { int server_sock = setup_server_socket( SERVER_PORT); if (listen(server_sock, MAX_CONN)) { fprintf(stderr, "Error on listening!\n"); while (1) { struct sockaddr_in client_addr; socklen_t client_addr_size = sizeof( client_addr_size); int client_sock = accept(server_sock, (struct sockaddr*)&client_addr, & client_addr_size); pid_t pid = fork(); if (pid) { close( client_sock); continue; char cmd[ MAX_CMD_SIZE]; ssize_t l; pid_t this_pid = getpid(); 6
7 while (1) { l = safe_recv(client_sock, cmd, MAX_CMD_SIZE, 0, "\r\n"); if (l <= 0) cmd[l] = \0 ; sanitize_eol(cmd); if (!strcmp("q", cmd)) { printf("(%d) Received a QUIT from client\n", this_pid); break; printf("(%d) Received from client: %s\n", this_pid, cmd); pid_t pid2 = fork(); if (!pid2) { server_cmd_exec(client_sock, cmd); else { int status; wait(&status); if (! WIFEXITED(status) WEXITSTATUS(status)) printf("(%d) Unknown command %s.\n", this_pid, cmd); close( client_sock); exit( EXIT_SUCCESS); 7
8 Esercizio 4 Scrivere due programmi di rete (client e server) con le seguenti caratteristiche: il processo principale lancia 1000 processi server ogniuno in ascolto su una porta nel range [4000, 4999] i server scrivono tutti su uno stesso file un messaggio che contiene l indirizzo e la porta del client, il proprio pid e la propria porta i server ricevono poi dal client un singolo carattere: a questo punto il server invoca execlp per eseguire un programma esterno che riceve i dati necessari per poter rispondere al client un messaggio che contiene le occorrenze all interno del file del carattere ricevuto dal client stesso Soluzione Programma server: #include <string.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <wait.h> #include <fcntl.h> #define SERVER_PORT 4000 #define MAX_CONN 1000 #define N_SERVER 1000 static int setup_server_socket(uint16_t port) { struct sockaddr_in addr; addr. sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl( INADDR_ANY); int sock = socket(af_inet, SOCK_STREAM, 0); if (sock == -1) { fprintf(stderr, "Error on creating socket!\n"); if (bind(sock, (const struct sockaddr *)&addr, sizeof(addr)) == -1) { fprintf(stderr, "Error on binding socket!\n"); return sock; static ssize_t safe_recv(int sd, char *buffer, size_t len, int flags, char *term) { ssize_t l = 0; ssize_t i = 0; size_t t_len = term? strlen(term) : 0; for (; i < len; i += l) { l = recv(sd, buffer + i, len - i, flags); if (l == -1) return -1; if (term && memcmp(buffer + l - t_len, term, t_len) == 0) return l; 8
9 return i; static void run_server(unsigned id, int fd) { int server_sock = setup_server_socket( SERVER_PORT + id); if (listen(server_sock, MAX_CONN)) { fprintf(stderr, "Error on listening!\n"); while (1) { struct sockaddr_in client_addr; socklen_t client_addr_size = sizeof( client_addr_size); int client_sock = accept(server_sock, (struct sockaddr*)&client_addr, & client_addr_size); pid_t pid = fork(); if (pid) { close( client_sock); continue; if ( client_sock < 0) char buffer [2048]; snprintf(buffer, 2048, "client: %s:%d - pid: %d - port: %d\n", inet_ntoa( client_addr.sin_addr), ntohs( client_addr.sin_port), getpid(), SERVER_PORT + id); write(fd, buffer, strlen(buffer)); if ( safe_recv(client_sock, buffer, 1, 0, NULL) == -1) { printf("(%d) Unable to receive a char from client.\n", getpid()); buffer[1] = \0 ; snprintf(buffer + 2, 20, "%d", client_sock); execlp("./es4 -counter", "es4 -counter", buffer, buffer + 2, NULL); // es4 -counter will close the client -socket, but in case of failure... printf("(%d) Error execlp\n", getpid()); close( client_sock); exit( EXIT_SUCCESS); int main(int argc, const char ** argv) { int fd = open("es4 -server.log", O_CREAT O_TRUNC O_WRONLY O_APPEND, 0644); for (unsigned i = 0; i!= N_SERVER; ++i) { pid_t pid = fork(); if (! pid) run_server(i, fd); for (unsigned i = 0; i!= N_SERVER; ++i) wait(null); 9
10 Programma invocato dal server: #include <string.h> #include <sys/socket.h> static ssize_t safe_send(int sd, const char *buffer, size_t len, int flags) { ssize_t l = 0; ssize_t i = 0; for (; i < len; i += l) { l = send(sd, buffer + i, len - i, flags); if (l == -1) return -1; return i; int main(int argc, char ** argv) { FILE *f = fopen("es4 -server.log", "r"); if (!f) { fprintf(stderr, "Unable to open es4 -server.log \n"); unsigned counter = 0; while (!feof(f)) counter += ( fgetc(f) == argv[1][0] ); fclose(f); int sd = atoi(argv[2]); char buffer [2048]; snprintf(buffer, 2048, "Number of occurences: %u\n", counter); if ( safe_send(sd, buffer, strlen(buffer), 0) == -1) { printf("error while sending...\n"); close(sd); 10
11 Programma client: #define _POSIX_SOURCE #include <sys/types.h> #include <sys/socket.h> #include <netdb.h> #include <string.h> int setup_connection(const char *host, const char *port) { struct addrinfo hints; memset(&hints, 0, sizeof(struct addrinfo)); hints. ai_family = AF_INET; hints. ai_socktype = SOCK_STREAM; hints.ai_flags = 0; hints. ai_protocol = 0; struct addrinfo *result; int err = getaddrinfo(host, port, &hints, &result); if (err) { fprintf(stderr, " getaddrinfo: %s\n", gai_strerror(err)); int sfd = -1; struct addrinfo *rp; for (rp = result; rp!= NULL; rp = rp->ai_next) { sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); if (sfd == -1) continue; if (connect(sfd, rp->ai_addr, rp->ai_addrlen)!= -1) break; close(sfd); freeaddrinfo(result); if (rp == NULL) sfd = -1; return sfd; static ssize_t safe_recv(int sd, char *buffer, size_t len, int flags, char *term) { ssize_t l = 0; ssize_t i = 0; size_t t_len = term? strlen(term) : 0; for (; i < len; i += l) { l = recv(sd, buffer + i, len - i, flags); if (l == -1) return -1; if (term && memcmp(buffer + l - t_len, term, t_len) == 0) return l; return i; static ssize_t safe_send(int sd, const char *buffer, size_t len, int flags) { ssize_t l = 0; ssize_t i = 0; for (; i < len; i += l) { l = send(sd, buffer + i, len - i, flags); if (l == -1) return -1; return i; 11
12 static void sanitize_eol(char *str) { size_t len = strlen(str); if (len > 0 && str[len - 1] == \n ) str[len - 1] = \0 ; if (len > 1 && str[len - 2] == \r ) str[len - 2] = \0 ; int main(int argc, char ** argv) { if (argc < 3) { printf("usage: %s HOST PORT", argv[0]); int sd = setup_connection(argv[1], argv[2]); if (sd == -1) { fprintf(stderr, "Unable to connect to server.\n"); printf("insert a character: "); char c; scanf("%c%*c", &c); ssize_t l; l = safe_send(sd, &c, 1, 0); if (l == -1) { fprintf(stderr, "Unable to receive message from server.\n"); char buffer [2048]; l = safe_recv(sd, buffer, 2048, 0, "\n"); if (l == -1) { fprintf(stderr, "Unable to receive message from server.\n"); buffer[l] = \0 ; sanitize_eol(buffer); printf("received: %s\n", buffer); 12
Una semplice applicazione client/server 1
Una semplice applicazione client/server 1 Il nostro obiettivo In questa parte del corso implementeremo un applicazione client/server che usa i socket Internet disponibili nei sistemi Unix/Linux. Nello
DettagliSocket. Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server.
Socket Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server. Tale architettura consente ai sistemi di condividere risorse e cooperare per il raggiungimento
DettagliSocket. Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server.
Socket Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server. Tale architettura consente ai sistemi di condividere risorse e cooperare per il raggiungimento
DettagliCreare un'elementare backdoor in C in ambiente UNIX
Creare un'elementare backdoor in C in ambiente UNIX DISCLAIMER: Questo tutorial è a solo scopo didattico. L'autore NON si prende alcuna responsabilità circa usi errati o non legali delle informazioni qui
DettagliLa sincronizzazione è legata alla implementazione delle pipe: int pipe(int fd[2]);
int pipe(int fd[2]); Le pipe sono canali di comunicazione unidirezionali che costituiscono un primo strumento di comunicazione (con diverse limitazioni), basato sullo scambio di messaggi, tra processi
DettagliEsempio 1: stampa locale di file remoto
Alcuni esempi di uso di Socket Esempio 1: stampa locale di file remoto Visualizzazione locale del contenuto di un file remoto. Il client deve richiedere la creazione della connessione e successivamente
DettagliCORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3. 1 strace : visualizzazione delle system call invocate da un processo
UNIVERSITÀ DEGLI STUDI DI PARMA Facoltà di Ingegneria Corso di Laurea in Ingegneria Informatica a.a. 2005-2006 CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3 1 strace : visualizzazione delle system call
DettagliLab. di Sistemi Operativi - Esercitazione n 7- -Gestione dei processi Unix-
Lab. di Sistemi Operativi - Esercitazione n 7- -Gestione dei processi Unix- 1 Sommario Esercizi sulla gestione dei processi Creazione di un nuovo processo: fork Sincronizzazione tra processi: wait 2 -
Dettagli(VHUFLWD]LRQLGLEDVHVXOOH6RFNHWLQ&
(VHUFLWD]LRQLGLEDVHVXOOH6RFNHWLQ& 3ULPRHVHUFL]LR6RFNHWVWUHDPFRQULGLUH]LRQH Si progetti un applicazione distribuita Client/Server per una rete di workstation UNIX (BSD oppure System V). In particolare,
DettagliCORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3
UNIVERSITÀ DEGLI STUDI DI PARMA Facoltà di Ingegneria Corso di Laurea in Ingegneria Elettronica-Informatica-Telecomunicazioni a.a. 2001-2002 CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 3 1 Trasferimento
DettagliInterazione con il DNS Conversioni di Nomi ed Indirizzi
a.a. 2003/04 Interazione con il DNS Conversioni di Nomi ed Indirizzi Prof. Vincenzo Auletta auletta@dia.unisa.it http://www.dia.unisa.it/professori/auletta/ Università degli studi di Salerno Laurea in
Dettagliunsigned long inet_addr(cp) char *cp;
/* bcopystru.c #include struct point int x; char *y; ; struct point a, b; struct pint *pta, *ptb; a.x = 5; a.y = pippo ; b = a; printf i valori del secondo point sono: %d %s\n,b.x,b.y); pta=
DettagliIn generale può essere utile che i due processi eseguano del codice diverso
System call FORK P fork() ha l aspetto di una funzione C, in realtà è una system call, una chiamata al sistema operativo fork() P P Il processo P' è una copia di P esegue lo stesso codice e possiede una
DettagliCorso di Laboratorio di Sistemi Operativi
Corso di Laboratorio di Sistemi Operativi Lezione 5 Alessandro Dal Palù email: alessandro.dalpalu@unipr.it web: www.unipr.it/~dalpalu Processi in Unix Approfondimenti: http://gapil.gnulinux.it/download/
DettagliINTERNET DOMAIN SOCKETS (Cap.59)
INTERNET DOMAIN SOCKETS (Cap.59) Internet Domain Stream Socket TCP Internet Domain Datagram Socket UDP A differenza degli UDDS I datagrams possono essere persi duplicati o arrivare in un ordine diverso
DettagliElementi di programmazione con interfaccia Socket
Struttura generale per stream sockets Socket() Well-Known Port Bind() Elementi di programmazione con interfaccia Socket Cenni di programmazione secondo la nuova interfaccia Socket definita nella RFC 2553
DettagliCorso di Programmazione Concorrente Processi. Valter Crescenzi
Corso di Programmazione Concorrente Processi Valter Crescenzi http://crescenzi.inf.uniroma3.it Sommario Processi vs Thread Creazione e terminazione di processi chiamata di sistema fork() chiamata di sistema
DettagliInterazione (TCP) Client-Server con le socket
Interazione (TCP) Client-Server con le socket D. Gendarmi Interazione TCP Client/Server Server 2. Assegnare un local address alla socket 3. Settare la socket all ascolto 4. Iterativamente: a. Accettare
DettagliCREAZIONE DI UN FILE
#include #include CREAZIONE DI UN FILE fd = creat(filename, mode); int fd, mode; char *filename; La primitiva creat crea un file, se non ne esiste uno col nome specificato, oppure
DettagliIPC Inter Process Communication
Il protocollo TCP controlla che la trasmissione tra due end points avvenga correttamente. Non stabilisce alcun criterio su chi deve iniziare la comunicazione. Questo compito è svolto dalle applicazioni
DettagliGestione dei processi
Gestione dei processi Dormire unsigned int sleep(unsigned int); Attende un numero specificato di secondi a meno che non si verifichi un segnale Restituisce 0 se l'attesa è terminata senza interruzioni,
DettagliLaboratorio di Sistemi Operativi 29-01-2009. Cognome Nome Mat.
Il compito è costituito da domande chiuse, domande aperte ed esercizi. Non è consentito l uso di libri, manuali, appunti., etc. Tempo massimo 2 ore. Domande chiuse: ogni domanda corrisponde ad un punteggio
DettagliLaboratorio di Reti di Calcolatori
Laboratorio di Reti di Calcolatori Funzioni utili, server ricorsivi, echo client ed echo server. Paolo D Arco Abstract Scopo della lezione è presentare alcune funzioni di utilità generale (e.g., funzioni
DettagliEsercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012. - Comunicazione Tra Processi (IPC) - - 2 Parte -
Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012 - Comunicazione Tra Processi (IPC) - - 2 Parte - 1 Sommario Comunicazione tra processi su macchine diverse in rete: Socket TCP o Socket Stream
DettagliEsercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012. - Comunicazione Tra Processi (IPC)- - 1 Parte -
Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012 - Comunicazione Tra Processi (IPC)- - 1 Parte - 1 Sommario Comunicazione tra processi sulla stessa macchina: fifo (qualunque insieme di processi)
DettagliApplicazione Client-Server con Server Concorrente Specifiche
Applicazione Client-Server con Server Concorrente Specifiche Il progetto consiste nello sviluppo di un'applicazione client/server. Client e server devono comunicare tramite socket TCP.. Il server deve
DettagliSC per Inter Process Comminication. Comunicazione fra macchine diverse: socket
SC per Inter Process Comminication Comunicazione fra macchine diverse: socket 1 Sockets File speciali utilizzati per connettere due o più processi con un canale di comunicazione i processi possono risiedere
DettagliEsercitazioni Socket
Esercitazioni Socket Ping-Pong TCP Si realizzi una coppia di processi: il primo e' un server che pubblica un socket (SOCK_STREAM, TCP) ad un certo indirizzo (porta passata come parametro sulla riga di
DettagliCOMUNICAZIONE TRA PROCESSI REMOTI IN UNIX
A cura del prof. Gino Tombolini 1 COMUNICAZIONE TRA PROCESSI REMOTI IN UNIX Il sistema UNIX TCP/IP fornisce un meccanismo di comunicazione tra processi residenti su nodi distinti di una rete, compatibili
DettagliCORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 6
UNIVERSITÀ DEGLI STUDI DI PARMA Facoltà di Ingegneria Corso di Laurea in Ingegneria Informatica, Elettronica e delle Telecomunicazioni a.a. 2005-2006 CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 6 1 Socket
DettagliChiamate di sistema per la Inter Process Communication (IPC) in POSIX. E.Mumolo, DEEI mumolo@units.it
Chiamate di sistema per la Inter Process Communication (IPC) in POSIX E.Mumolo, DEEI mumolo@units.it Pipe Cos'è un pipe? E' un canale di comunicazione che unisce due processi Caratteristiche: La più vecchia
DettagliESERCITAZIONE 2 RIPASSO. EX. 1 Un processo padre (parent) crea due processi figli (children) e attende la loro terminazione. Se, e solo se,...
ESERCITAZIONE DEL 23 MARZO 2002 ESERCITAZIONE 2 RIPASSO EX. 1 Un processo padre (parent) crea due processi figli (children) e attende la loro terminazione. Se, e solo se,. EX. 2 Un server di rete attende
DettagliPOSIX Systems Programming. geek evening 0x0d. ambienti POSIX. By lord_dex ZEI e Salug! presentano:
POSIX Systems Programming Syscall e fondamenti della ambienti POSIX programmazione in By lord_dex f.apollonio@salug.it ZEI e Salug! presentano: geek evening 0x0d INDICE Processi e Thread Creazione ed utilizzo
DettagliEsercitazione Laboratorio di Sistemi Operativi 20-01-2014. Cognome Nome Mat.
Il compito è costituito da domande chiuse e domande aperte. Non è consentito l uso di libri, manuali, appunti., etc. Tempo massimo 2 ore. Domande chiuse: ogni domanda corrisponde ad un punteggio di 1 punto
DettagliLab. di Sistemi Operativi - Esercitazione n 9- -Thread-
Lab. di Sistemi Operativi - Esercitazione n 9- -Thread- 1 Sommario Esercizi su: Comunicazione tra processi: la funzione pipe() Condivisione dati e codice tra due o più processi: concetto di Thread 2 -
DettagliSocket TCP. prima parte
Socket TCP prima parte Cosa cambia: socket int fd = socket(pf_inet, SOCK_STREAM, 0); if (fd
DettagliAXO. Operativo. Architetture dei Calcolatori e Sistema. programmazione di sistema
AXO Architetture dei Calcolatori e Sistema Operativo programmazione di sistema Il sistema operativo Il Sistema Operativo è un insieme di programmi (moduli software) che svolgono funzioni di servizio nel
DettagliInter-process communication: socket
Le Socket Inter-process communication: socket Abbiamo visti alcune tipologie di Inter-process communication: Anonymous pipes FIFOs o named pipes Le socket di comunicazione si pongono nell'ipc per realizzare:
DettagliSviluppo di Applicazioni su Rete. Introduzione all API socket di Berkeley. Interazione tra Processi. Modello Client-Server
a.a. 2003/04 Introduzione all API socket di Berkeley Prof. Vincenzo Auletta auletta@dia.unisa.it http://www.dia.unisa.it/professori/auletta/ Università degli studi di Salerno Laurea e Diploma in Informatica
DettagliProcessi UNIX. I Processi nel SO UNIX. Gerarchie di processi UNIX. Modello di processo in UNIX
Processi UNIX I Processi nel SO UNIX UNIX è un sistema operativo multiprogrammato a divisione di tempo: unità di computazione è il processo Caratteristiche del processo UNIX: processo pesante con codice
DettagliChiamate di sistema per la Gestione dei processi in POSIX. E.Mumolo, DEEI mumolo@units.it
Chiamate di sistema per la Gestione dei processi in POSIX E.Mumolo, DEEI mumolo@units.it Process id ed altri identificatori pid_t getpid(); // Process id del processo chiamante pid_t getppid(); // Process
DettagliReti (già Reti di Calcolatori )
Reti (già Reti di Calcolatori ) Cenni di Socket Programming Renato Lo Cigno http://disi.unitn.it/locigno/index.php/teaching-duties/computer-networks Socket API Programmazione dei socket Obiettivo:imparare
Dettaglirequest reply richiesta client processo di servizio processo server principale From - Valeria Cardellini, Corso Sist. Distr. A.A.
Applicazioni di rete Forniscono i servizi di alto livello utilizzati dagli utenti Determinano la percezione di qualità del servizio (QoS) che gli utenti hanno della rete sottostante Programmazione di applicazioni
DettagliEsercitazione [6] Client/Server con Socket
Esercitazione [6] Client/Server con Socket Leonardo Aniello - aniello@dis.uniroma1.it Daniele Cono D'Elia - delia@dis.uniroma1.it Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di
DettagliFile I/O. M. R. Guarracino: File I/O 1
File I/O M. R. Guarracino: File I/O 1 File I/O Gran parte delle operazioni su file in ambiente UNIX possono essere eseguite utilizzando solo cinque funzioni: open read write lseek close M. R. Guarracino:
DettagliScrivere alla fine di un file Vi sono due modi per scrivere alla fine di un file:
Scrivere alla fine di un file Vi sono due modi per scrivere alla fine di un file: usare lseek per spostarsi alla fine del file e poi scrivere: lseek(filedes, (off_t)0, SEEK_END); write(filedes, buf, BUFSIZE);
DettagliEsercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012
Sommario: Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012 - System Call Parte 1 open (apertura file) creat (creazione file) close (chiusura file) write (scrittura file) read (lettura file)
DettagliServer Iterativi. Server TCP Ricorsivi. Fork. Server Ricorsivi. un server iterativo gestisce una connessione alla volta. Prof.
Università degli studi di Salerno Laurea in Informatica a.a. 2003/04 TCP Ricorsivi Prof. Vincenzo Auletta auletta@dia.unisa.it http://www.dia.unisa.it/professori/auletta/ 1 Iterativi un server iterativo
DettagliProgrammazione di applicazioni di rete
Programmazione di applicazioni di rete Valeria Cardellini Università di Roma Tor Vergata Applicazioni di rete Applicazioni di rete - forniscono i servizi di alto livello utilizzati dagli utenti - determinano
DettagliProgrammazione di Sistema 3
Programmazione di Sistema 3 Gestione dei Processi Paolo Baldan Università Ca Foscari Venezia Corso di Laurea in Informatica Parte di questo materiale è rielaborato dalle slide del Corso di Laboratorio
DettagliNuker v1.0 by ALwarrior
Nuker v1.0 by ALwarrior Avvertenze: Declino ogni responsabilità da un uso improprio di questa guida, a fini di danneggiare altri sistemi o provocare perdita di dati ad altri utenti. Introduzione: Cos è
DettagliDigressione: man (2)...
Syscall File I/O Digressione: man (2)... Le funzioni della libreria standard UNIX associate alle system call di Linux sono documentate nella sezione 2 di man e.g.: man 2 open Ogni manpage di system call
Dettagliprogrammazione distribuita Introduzione Introduzione alla programmazione distribuita
Reti Informatiche Introduzione alla programmazione distribuita Introduzione Richiami di Programmazione C Differenze principali C/C++ 2 1 Definizioni di variabili Le variabili possono essere definite solo
DettagliCREAZIONE PROCESSI IN UNIX 20
CREAZIONE PROCESSI IN UNIX 20 STRUTTURE DATI PER PROCESSI Un processo puo' essere in escuzione in 2 modi: kernel e utente. Un processo ha almeno 3 regioni: codice, dati e stack Lo stack è allocato dinamicamente.
DettagliProcessi: Exit, Wait, Exec
Processi: Exit, Wait, Exec Contiene lucidi tratti da: 2005-07 Giuseppe Schmid (Univ. Federico II), 2005-2007 Francesco Pedulla, Massimo Verola (Uniroma2), 2001-2005 Renzo Davoli (Universita di Bologna),
DettagliProcessi e Sincronizzazione. Laboratorio Software 2008-2009 C. Brandolese M. Grotto
Processi e Sincronizzazione C. Brandolese M. Grotto Sommario 1. Processi Concetti fondamentali Stati in GNU/Linux 2. Creazione Descrizione Creazione con system() Creazione con fork() Effetto di fork()
DettagliLaboratorio di Reti di Calcolatori
Laboratorio di Reti di Calcolatori Socket UDP. Paolo D Arco Abstract Scopo della lezione è descrivere le funzioni che l interfaccia dei socket offre per far interagire client e server attraverso il protocollo
DettagliProgetto fine al superamento del corso di Sistemi Operativi. Http server proxy Http web monitor
Progetto fine al superamento del corso di Sistemi Operativi Http server proxy Http web monitor Sviluppato da: Santoro Carlo Maurizio Sviluppo terminato in Luglio/2006 Obiettivo: Progettare ed implementare
DettagliReti di Calcolatori - Laboratorio. Lezione 5. Gennaro Oliva
Reti di Calcolatori - Laboratorio Lezione 5 Gennaro Oliva Server basato su I/O Multiplex Per realizzare un server è possibile utilizzare l'i/o Multiplex Un unico processo iterativo gestisce il socket che
DettagliDigressione: man 2...
Syscall File I/O Digressione: man 2... Le funzioni della libreria standard UNIX associate alle system call di Linux sono documentate nella sezione 2 di man e.g.: man 2 open Ogni manpage di system call
DettagliProgram m azione di Sistem a 6
Program m azione di Sistem a 6 Lucidi per il corso di Laboratorio di Sistemi Operativi tenuto da Paolo Baldan presso l'università Ca' Foscari di Venezia, anno accademico 2004/ 2005. Parte di questo materiale
DettagliBasi di network programming sotto Unix/Linux (draft version) Claudio Piciarelli
Basi di network programming sotto Unix/Linux (draft version) Claudio Piciarelli 20 dicembre 2004 ii Indice 1 Introduzione 1 1.1 Notazioni e terminologia..................................... 1 2 Un po di
DettagliIntroduzione ai Device Drivers in Linux. E.Mumolo, DEEI mumolo@units.it
Introduzione ai Device Drivers in Linux E.Mumolo, DEEI mumolo@units.it 1 Device Drivers Moduli software che gestiscono le periferiche attraverso il file system Tutte le periferiche sono viste come file
DettagliDATAGRAM SOCKET. Angelastro Sergio Diomede Antonio Viterbo Tommaso
DATAGRAM SOCKET Angelastro Sergio Diomede Antonio Viterbo Tommaso Definizione supporta i datagram privo di connessione messaggi inaffidabili di una lunghezza massima prefissata il protocollo UDP supporta
DettagliSistemi di Elaborazione. Introduzione alla Programmazione distribuita
Sistemi di Elaborazione Introduzione alla Programmazione distribuita Obiettivi Introdurre i concetti di base su programmazione distribuita Modello Client-Server Interfaccia Socket Progettare e realizzare
DettagliSocket II MIDLAB. Sirio Scipioni. M I D L A B.
Socket II Sirio Scipioni scipioni@dis.uniroma1.it http://www.dis.uniroma1.it/~scipioni MIDLAB http://www.dis.uniroma1.it/~midlab Sommario Richiami sui processi Echo server TCP (multi processo) Richiami
DettagliProgram m azione di Sistem a 3
Program m azione di Sistem a 3 Lucidi per il corso di Laboratorio di Sistemi Operativi tenuto da Paolo Baldan presso l'università Ca' Foscari di Venezia, anno accademico 2004/ 2005. Parte di questo materiale
DettagliControllo dei Processi. M. R. Guarracino - Primitive di Controllo dei Processi
Controllo dei Processi Introduzione Come possiamo creare nuovi processi? Come possiamo eseguire un programma? Come possiamo terminare un processo? Introduzione Unix fornisce le primitive per la creazione
DettagliProgettazione di un client TCP. Progettazione di un server TCP. Esempio: daytime TCP. Client TCP daytime
Progettazione di un client TCP Progettazione di un server TCP Passi per la progettazione di un client TCP 1. Creazione di un endpoint Richiesta al sistema operativo 2. Creazione della connessione Implementazione
DettagliIPC System V. Code di messaggi
IPC System V Code di messaggi Panoramica coda di messaggi una lista concatenata di messaggi, FIFO semaforo un contatore condiviso, atomicamente modificabile memoria condivisa uno spazio di memoria accessibile
DettagliEsercitazione sulle Socket
Esercitazione sulle Socket Sommario Echo Server Specifica Descrizione programma (TCP Socket) Client UNIX/WIN Server UNIX/WIN Server multithread UNIX/WIN Descrizione programma (UDP Socket) 2 Interazione
DettagliCreare una applicazione Winsock di base
Creare una applicazione Winsock di base Usiamo le API Winsock incluse in Creare un progetto per una Socket Windows (in Dev C++) Selezionare la file New Projects Selezionare Empty Project Salvare
DettagliI/O su Socket TCP: read()
I/O su Socket TCP: read() I socket TCP, una volta che la connessione TCP sia stata instaurata, sono accedibili come se fossero dei file, mediante un descrittore di file (un intero) ottenuto tramite una
DettagliLe system call: fork(), wait(), exit()
Le system call: fork(), wait(), exit() Di seguito viene mostrato un programma che fa uso di puntatori a funzione, nel quale si mette in evidenza il loro utilizzo. Programma A1 #include int add(a,b,c)
DettagliBasic Sniffer Tutorial
Basic Sniffer Tutorial LnZ Aspinall S.P.I.N.E. Research Group April 2, 2003 Abstract Con questo semplice esempio cerchero di mostrarvi l uso di base delle
DettagliSulla libreria standard, III. Manipolare file con stdio.h
Sulla libreria standard, III Manipolare file con stdio.h 1 Libreria per input/output Con libreria si intende una collezione di sottoprogrammi che vengono utilizzati per lo sviluppo di software non eseguibili,
DettagliGestione dei processi
Capitolo 1 Gestione dei processi 1.1 Creazione di un processo I principali eventi che possono dare luogo ad un nuovo processo sono: inizializzazione del sistema; esecuzione di una primitiva di sistema
DettagliEsercizio sulla gestione di file in Unix
Esercizio sulla gestione di file in Unix 1 Esercizio Si vuole realizzare un programma C che, utilizzando le system call di Unix, realizzi uno schema di comunicazione tra due processi (padre e figlio) mediante
DettagliProgrammazione multiprocesso
DTI / ISIN / Titolo principale della presentazione 1 Programmazione multiprocesso Amos Brocco, Ricercatore, DTI / ISIN 20 febbraio 2012 2 Processi Cos'è un processo? Un programma in esecuzione Spazio di
DettagliSocket TCP. seconda parte
Socket TCP seconda parte Schema della connessione Computer 1 127.43.18.1 indirizzo I1 indirizzo I2 Computer 2 143.225.5.3 porta 45000 socket porta 5200 socket processo client processo server socket(...)
DettagliComunicazione tra processi: pipe Le pipe sono un meccanismo UNIX di Inter Process Communication (IPC)
Comunicazione tra processi: pipe Le pipe sono un meccanismo UNIX di Inter Process Communication (IPC) Le pipe sono canali di comunicazione unidirezionali Limitazione pipe: permettono la comunicazione solo
DettagliEsercitazione di Lab. di Sistemi Operativi a.a. 2012/2013. - I processi Unix -
Esercitazione di Lab. di Sistemi Operativi a.a. 2012/2013 - I processi Unix - 1 Sommario Gestione dei processi: Creazione di un nuovo processo: fork Sincronizzazione tra processi: wait Esercizi: fork fork
DettagliLaboratorio di Sistemi Operativi
II Semestre - Marzo/Giugno 2008 Matricole congr. 0 mod 3 File & Directory #include #include stat,fstat e lstat int stat (const char *pathname, struct stat *buf); int fstat (int
DettagliProgettazione di Applicazioni Robuste. Applicazione Echo. Schema Generale di un Server TCP Ricorsivo 1. Applicazione echo
a.a. 2003/04 Applicazione Echo Prof. Vincenzo Auletta auletta@dia.unisa.it http://www.dia.unisa.it/professori/auletta/ Progettazione di Applicazioni Robuste nel progettare applicazioni su rete robuste
DettagliDomain Name Service. Mapping nomi/indirizzi con Socket API in C
Domain Name Service Mapping nomi/indirizzi con Socket API in C 1 Risoluzione di nomi simbolici TCP/IP ha bisogno di rappresentazioni numeriche per gli indirizzi (es. 193.204.187.189) e per le porte (es.
DettagliEsercitazione [5] Input/Output su Socket
Esercitazione [5] Input/Output su Socket Leonardo Aniello - aniello@dis.uniroma1.it Daniele Cono D'Elia - delia@dis.uniroma1.it Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di Calcolo
DettagliESERCIZI RISOLTI IN C LANGUAGE (programmazione avanzata)
ESERCIZI RISOLTI IN C LANGUAGE (programmazione avanzata) 1. Gestione file a basso livello 1) Scrivere un programma che carichi in un file binario, gestito a basso livello, una serie di numeri interi contenuti
DettagliESERCIZI SULLA PROGRAMMAZIONE DI SISTEMA GNU/LINUX
Autore: Classe: Luciano VIVIANI QUARTA INFORMATICA (4IB) Anno scolastico: 2004/2005 Scuola: Itis Euganeo ESERCIZI SULLA PROGRAMMAZIONE DI SISTEMA GNU/LINUX Questa dispensa non vuole essere un manuale di
DettagliAcknowledgment: Prof Vincenzo Auletta, Università di Salerno. Approfondimento alla programmazione distribuita
Reti Informatiche Approfondimento alla programmazione distribuita Acknowledgment: Prof Vincenzo Auletta, Università di Salerno Introduzione API send e receive bloccanti e non API select Socket UDP Esempio
DettagliSistemi Operativi. Esercitazione 2 Compilazione, Makefile e Processi
Sistemi Operativi Esercitazione 2 Compilazione, Makefile e Processi Percorso Compilazione programmi in c Makefiles Processi definizione gestione creazione Compilazione di programmi in C Compilazione e
DettagliSistemi Operativi. Des crizione e controllo dei proces s i
Sistemi Operativi Des crizione e controllo dei proces s i Servizi di un Sistema Operativo Permettere ad un utente di creare processi (lanciare programmi) Interallacciare l esecuzione di diversi processi,
DettagliPuntatori. Un puntatore contiene un numero che indica la locazione di memoria dove è presente la variabile puntata
Puntatori int i = 10; int * pi = &i; pi i = 10 116 int * pi = pi contiene un informazione che mi permette di accedere ( puntare ) ad una variabile intera Un puntatore contiene un numero che indica la locazione
DettagliSocket per TCP: Fondamenti
Socket per TCP: Fondamenti Network Applications Molte applicazioni di rete sono formate da due programmi distinti (che lavorano su due diversi host) uno detto server ed uno detto client. Il server si mette
DettagliCosa e un processo? Stato del processo
Cosa e un processo? LABORATORIO DI PROGRAMMAZIONE 2 Corso di laurea in matematica Un sistema operativo esegue programmi di varia natura: Compilatori, word processor, programmi utente, programmi di sistema,
DettagliIl sistema operativo LINUX Indice
Il sistema operativo LINUX Giorgio Di Natale Stefano Di Carlo Politecnico di Torino Dip. Automatica e Informatica Processo Un processo è un programma in esecuzione:
DettagliINGEGNERIA DEL WEB. VinX
INGEGNERIA DEL WEB VinX Indice 1 Programmazione di applicazioni di rete 1 1.1 Applicazioni di rete........................................ 1 1.2 Modello Client/Server......................................
DettagliT.A.R.I. Socket (ICT, AL)
Internet Applications (Client-Server Concept, Use of Protocol Ports, Socket API, DNS, E-mail, TELNET, FTP) Funzionalità Livello di trasporto e livelli sottostanti Comunicazione base Disponibilità Livello
DettagliProcessi in Linux. Stru/ura file eseguibili
SISTEMI OPERATIVI Processi in Linux Stru/ura file eseguibili» ELF - Executable and Linking Format formato di default degli eseguibili in Linux definizione nel file include » StruGura un header contenente
Dettaglirsystem Maximiliano Marchesi maximiliano.marchesi@studenti.unipr.it
Maximiliano Marchesi 28 Settembre 2005 Diario delle Revisioni Revisione 1.2 28 Settembre 2005 maximiliano.marchesi@studenti.unipr.it Sommario Introduzione..................................................................................
DettagliPrecedenza e associatività. Complementi sul C - 2. Esempi. Esempi
Complementi sul C - 2 Ver. 2.4 2010 - Claudio Fornaro - Corso di programmazione in C Precedenza e associatività () [] ->. S D! ~ ++ + * & (cast ) sizeof S D * / % S D + - (somma e sottrazione) S D >
Dettagli