Additions:
if (res > 0)
Deletions:
if (res < s)
Additions:
// 0640: user => rw, group => r, others => nessuno
Deletions:
// 0644: user => rw, group => r, others => nessuno
No differences.
Additions:
Versione ##4##: implementazione comando interno ##mypwd## e ##echo##
for (i=1; argv[i]!=NULL; ++i) {
if (i > 1) printf(" ");
printf("%s", argv[i]);
printf("\n");
if (strcmp(myargv[0],"mypwd") == 0) {
if (strcmp(myargv[0], "echo") == 0) {
Deletions:
Versione ##4##: implementazione comando interno ##mypwd##
void get_cmd_line(char* myargv[]) {
char cmd[MAX_LINE_LEN];
for (i=1; i
for (i=1; argv[i]!=NULL; ++i)
printf("%s\n",argv[i]);
get_cmd_line(myargv);
if (strcmp(myargv[0],"mypwd")==0) {
if (strcmp(myargv[0],"echo")==0) {
Deletions:
printf("argv[0] = %s\n", myargv[0]);
Additions:
Versione ##3d##: generalizzazione a comando con un numero arbitrario (ma limitato) di argomenti
Versione ##3e##: versione modularizzata
void get_cmd_line(char * cmd, char* myargv[]) {
if (myargv[0] == NULL) return;
for (i = 1; i < MAX_NUM_ARGS; i++) {
if (i == MAX_NUM_ARGS)
myargv[MAX_NUM_ARGS - 1] = NULL;
get_cmd_line(cmd, myargv);
printf("argv[0] = %s\n", myargv[0]);
Deletions:
Versione ##3c##: generalizzazione a comando con un numero arbitrario (ma limitato) di argomenti
Versione ##3d##: versione modularizzata
Additions:
cmd[strlen(cmd)-1] = '\0'; // man fgets: If a newline is read, it is stored into the buffer.
Additions:
Versione ##3a##: shell che prende comandi senza argomenti
Versione ##3b##: uso di ##fgets## al posto di ##scanf## (unsafe)
Versione ##3c##: comando con un argomento
Versione ##3c##: generalizzazione a comando con un numero arbitrario (ma limitato) di argomenti
Versione ##3d##: versione modularizzata
Versione ##4##: implementazione comando interno ##mypwd##
Deletions:
Shell che prende comandi senza argomenti:
Idem, con fgets invece di scanf:
Comando al più un argomento:
Generalizzazione a un numero arbitrario (ma limitato) di argomenti:
Versione modularizzata:
Aggiunta di comandi interni:
Additions:
Versione ##2## (gestione ##EINTR##):
Deletions:
Versione ##2##:
Additions:
if (res == 0) break; // EOF: read indica la fine del file utilizzando la costante zero
if (write(STDOUT_FILENO, buffer, res) == -1) { // vedere esempio su write per gestire anche qui EINTR correttamente
Deletions:
if (res == 0) break; // EOF
if (write(STDOUT_FILENO, buffer, res) == -1) {
Additions:
int flags = O_WRONLY | O_CREAT | O_TRUNC;
mode_t mode = 0640;
ssize_t byte_scritti = 0;
ssize_t byte_da_scrivere = sizeof(text); // sizeof funziona correttamente solo text e' dichiarato come array e non un puntatore ad una stringa!
printf("Byte da scrivere: %d\n", byte_da_scrivere);
while (byte_scritti < byte_da_scrivere) {
ssize_t res = write(fd, text + byte_scritti, sizeof(text) - byte_scritti);
if (res == -1) { // errore
// analizziamo la causa dell'errore
switch (errno) {
case EINTR:
// se e' arrivato un segnale, non e' un errore fatale possiamo ritentare la scrittura
continue;
break;
default:
// consideriamo le altre cause come errori fatali non recuperabili
perror("errore write");
exit(EXIT_FAILURE);
}
byte_scritti += res;
printf("Byte scritti: %d\n", res);
Deletions:
int fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0640);
if (write(fd, text, sizeof(text)) != sizeof(text)) { // verifica che abbiamo scritto scritto tutto quello che volevamo scrivere
Additions:
Versione ##1##:
#include // perror
int flags = O_WRONLY | O_CREAT | O_TRUNC; // O_WRONLY: file aperto in sola scrittura
// O_CREAT: se il file non esiste, verra' creato
// O_TRUNC: se il file esiste, trancare il contenuto
// se il file non esiste, allora dobbiamo indicare i permessi
mode_t mode = 0640; // Una costante che inizia con 0 (e non 0x) in C e' in notazione ottale
// 0644: user => rw, group => r, others => nessuno
// alternativa ad usare numero ottale: usare le costanti definite da POSIX
// mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP; // corrisponde a 0644
int fd = open("test.txt", flags, mode);
Versione ##2##:
Deletions:
= Versione 1=
= Versione 2=
Additions:
if (write(fd, text, sizeof(text)) != sizeof(text)) { // verifica che abbiamo scritto tutto quello che volevamo scrivere
Additions:
#include
#define USE_PERROR 0 // vedere anche quando: valore 1
#if USE_PERROR
perror("causa errore pause");
#else
switch (errno) {
case EINTR:
printf("Interrotta da segnale.\n");
break;
// pause ammette solo EINTR come errore, vedere: man pause
// quindi SOLO per questa system call ha poco considerare casi errno != EINTR
default:
perror("causa errore pause");
#endif
Deletions:
if (res == -1) perror("causa errore pause");
Additions:
res = pause();
printf("return value pause: %d\n", res);
if (res == -1) perror("causa errore pause");
===System call ##open##, ##read##, ##write##, ##close##===
= Versione 1=
if (write(fd, text, sizeof(text)) != sizeof(text)) { // verifica che abbiamo scritto scritto tutto quello che volevamo scrivere
// se non e' cosi', terminiamo...
= Versione 2=
if (write(fd, text, sizeof(text)) != sizeof(text)) { // verifica che abbiamo scritto scritto tutto quello che volevamo scrivere
// se non e' cosi', terminiamo...
Deletions:
// installiamo gestore per segnale SIGINT (generato ca CTRL+C)
res = pause(); // premendo CTRL+C si esce dalla system call, poiché la ricezione di un segnale non ignorato provoca l'uscita dalla system call
printf("%d\n", res);
perror("dopo la pause");
===System call ##open##, ##read##, ##close##===
if (write(fd, text, sizeof(text)) != sizeof(text)) {
Additions:
===System call ##open##, ##read##, ##close##===
Additions:
===System call interrotte da segnali===
Deletions:
==System call interrotte da segnali==
Additions:
== Esempio: gestore SIGCHLD, interruzione system call==
%%(c;sigaction-3.c)
void myhandler(int signo) {
printf("figlio e' terminato\n");
struct sigaction sa = {0};
sa.sa_handler = myhandler;
int res = sigaction(SIGCHLD, &sa, NULL);
printf("[pid=%d] genitore\n", getpid());
pid_t pid = fork();
if (pid == -1) {
perror("errore nella fork");
exit(EXIT_FAILURE);
if (pid == 0) { // processo figlio
printf("[pid=%d] figlio\n", getpid());
_exit(EXIT_SUCCESS);
int s = 30;
res = sleep(s); // genitore potrebbe fare qualcosa di piu' utile
// in questo esempio invoca una system call
if (res < s)
printf("Genitore termina: sleep terminata prematuramente dopo %d secondi\n", s - res);
else
printf("Genitore termina: sleep eseguita interamente per %d secondi\n", s);
== Esempio: gestore SIGINT, interruzione system call ##pause##==
Additions:
==Scrittura di file==
char text[] = "This is a test\n";
int fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0640);
if (write(fd, text, sizeof(text)) != sizeof(text)) {
perror("Error in write");