TP2 Grupo4

SISTEMAS OPERATIVOS
LLAMADAS AL SISTEMA
2012 2DO. CUATRIMESTRE (T: TARDE)
FERRERO, LUCRECIA
e-mail: lucrefer2@yahoo.com.ar
MNDOLA, SILVINA
e-mail: silvinamandola@gmail.com
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
TP2: llamadas al sistema
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
ARGUMENTOS POR LNEA DE COMANDO (ARGC ARGV OPCIONES)

EJERCICIO 1.
Deber generar un programa en C que le permitir manejar
opciones y argumentos a travs de la lnea de comandos.
Sintaxis de ejecucin (suponiendo que se lo compila con el
nombre ej1):
ej1 [-cl] [-s nombre_archivo]
opciones:
c: indicar la cantidad de argumentos con el que fue
llamado ej1 (incluyendo tambin el primer argumento
reservado para el nombre del programa)
l: listar cada argumento indicando el nmero que
representa.
s: almacenar en el archivo: nombre_archivo los
argumentos con el que se llama el programa incluyendo
el nombre del programa. El archivo deber ser creado al
momento de esta accin ya que debe contener slo la
informacin correspondiente a la corrida actual.
Si no se especifican opciones, deber imprimir por pantalla un
mensaje con la sintaxis del programa.
ej1 [-cl] [-s nombre_archivo]

#include
#include
#include
#include
#include
#include
<sys/types.h>
<unistd.h>
<stdio.h>
<string.h>
<stdlib.h>
<fcntl.h>
int main(int argc, char *argv[])

{
int parametro;
if ( argc == 1 )
{
printf("%s", "uso: [-cl]
}
if ( argc >= 1 && argc <= 4 )
{
[-s nombre_archivo]\n");
Ferrero, Lucrecia
Mndola, Silvina
argc);
UTN-FRSF
while ((parametro = getopt (argc, argv, "cls:")) != -1)

{
switch (parametro)
{
case 'c':
printf("%s%d", "cantidad de argumento:",
printf("\n");
break;
case 'l':
printf("%s%s", "argumento: 0- ",
argv[0]);
printf("\n");
printf("%s%s", "argumento: 1 ", argv[1]);
printf("\n");
break;
case 's':
if ( argc == 2 )
{
printf("%s%s", argv[0], ": option
requires an argument --s \n");
printf("\n");
}
else
{
int fd = creat(argv[2], O_CREAT +
O_WRONLY);
write(fd, argv[0], 5);
write(fd, argv[1], 5);
}
break;
default: printf("%s", "uso: [-cl] [-s
nombre_archivo]\n");
}
}
}
if ( argc > 3 )
{
printf("%s", "uso: [-cl]
}
[-s nombre_archivo]\n");
return 0;
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
GESTIN DE PROCESOS
EJERCICIO 2.
Genere un programa en C: ej2.c que mostrar a travs del
siguiente rbol de jerarqua de procesos, los diferentes
resultados para la variable VALOR:
rbol:
Nodo R (Raz): corresponde al proceso principal,
imprimir el valor inicial para la variable. Este valor ser
recibido como argumento por lnea de comando.
Nodo 1: es el primer hijo del proceso principal, que a su
vez ser raz del subrbol 1. Imprimir el incremento en
100 de la variable VALOR.
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
o Nodo 1.1: corresponde al primer hijo del Nodo 1 e

imprimir el doble de la variable VALOR calculado
en el Nodo 1.
o Nodo 1.2: corresponde al segundo hijo del Nodo 1 e
imprimir la mitad de la variable VALOR. calculado
en el Nodo 1.
Nodo 2: es el segundo hijo del proceso principal,
mostrar el decremento en 100 de la variable VALOR.
En cada resultado que se muestre se deber indicar el nodo
en que se est realizando el clculo, adems de la
identificacin del proceso. Para los procesos hijos tambin se
deber identificar al padre.
La variable VALOR slo puede definirse una sola vez.
nombre ej2):
ej2 nro
ej2 nro
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
void
void
void
void
ChildProcessleft(int valor);
ChildProcessright(int valor);
Grandsonleft(int valor);
Grandsonright(int valor);
int main(int argc, int *argv[])

{
pid_t pid;
int valor = atoi(argv[1]);
printf("\n");
printf("%s%d", "NODO R - VALOR = ", valor);
printf("\n");
printf("%s%d","ID Proceso Principal = ", getpid());
printf("\n");
pid = fork();
if (pid == 0)
{
ChildProcessleft(valor);
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
}
else
{
ChildProcessright(valor);
}
return 0;
void ChildProcessleft(int valor)

{
pid_t pid;
int valorp = valor + 100;
printf("\n");
printf("%s%d"," NODO 1 - VALOR = ", valorp);
printf("\n");
printf("%s%d%s%d"," ID NODO 1 = ", getpid(), "- ID Padre NODO 1
(NODO R): ", getppid());
printf("\n");
pid = fork();
if (pid == 0)
{
Grandsonleft(valorp);
}
else
{
Grandsonright(valorp);
}
}
void ChildProcessright(int valor)

{
pid_t pidr;
pidr = fork();
if (pidr == 0)
{
printf("\n");
printf("%s%d"," NODO 2 - VALOR = ", valor - 100);
printf("\n");
printf("%s%d%s%d"," ID NODO 2 = ", getpid(), "- ID Padre
NODO 2 (NODO R): ", getppid());
printf("\n");
printf("\n");
}
}
void Grandsonleft(int valor)
{
printf("\n");
printf("%s%d"," NODO 1.1 - VALOR = ", valor * 2);
printf("\n");
printf("%s%d%s%d"," ID NODO 1.1 = ", getpid(), "- ID Padre NODO
1.1 (NODO 1): ", getppid());
printf("\n");
}
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
void Grandsonright(int valor)

{
pid_t pids;
pids = fork();
if (pids == 0)
{
printf("\n");
printf("%s%d"," NODO 1.2 - VALOR = ", valor / 2);
printf("\n");
printf("%s%d%s%d"," ID NODO 1.2 = ", getpid(), "- ID Padre
NODO 1.2 (NODO 1): ", getppid());
printf("\n");
}
}
EJERCICIO 3.
Deber generar un programa que calcula el factorial del
siguiente rango de numeracin: 1 a 10.
El programa se llamar factorial.c. Antes de finalizar y luego
de realizado el clculo en caso de que se haya recibido un
nmero valido, deber imprimir el nmero de su identificacin
de proceso. En caso de que no sea un nmero vlido mostrar
un mensaje de error y tambin deber imprimir el nmero de
ID.
Este programa (factorial) ser invocado desde ej3.c
reemplazndolo (ej3 ser sustituido por factorial). Antes de
invocar al programa factorial, ej3 deber mostrar su propio
nmero de identificacin de proceso. En caso de error se
deber indicar que factorial no ha podido ejecutarse.
Al finalizar la corrida, deber incluir en el archivo de texto de
resolucin del TP una breve conclusin sobre los nmeros de
procesos que fueron identificados.
nombre ej3):
ej3 nmero
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
factorial.c
#include
#include
#include
#include
<sys/types.h>
<unistd.h>
<fcntl.h>
<stdio.h>
int factorial(int valor);

int main(int argc, char* argv[])
{
if ( argc == 1 )
{
printf("%s", "Error. Usar ./Nombre_Pgr_Invoca [numero]:
\n");
printf("%s%d", "Id de Prg-Factorial: ", getpid());
printf("\n");
}
if (argc > 1)
{
int valor = atoi(argv[1]);
int resultado;
if (valor >= 1 && valor <= 10)
{
resultado = factorial(valor);
printf("%s%d%s%d", "Factorial de ", valor, " = ",
resultado);
printf("\n");
}
else
{
printf("%s%d", "Numero fuera de rango: ", valor);
printf("\n");
}
printf("%s%d", "Id de Prg-Factorial: ", getpid());
printf("\n");
}
return 0;
}
int factorial(int valor)
{
if (valor == 0 || valor == 1)
{
return 1;
}
else
{
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
return (valor * factorial(valor - 1));

}
ej3.c.
#include
#include
#include
#include
<sys/types.h>
<unistd.h>
<fcntl.h>
<stdio.h>
int main(int argc, char *argv[], char *envp[])

{
if ( argc > 1 )
{
printf("%s%d", "Id proceso que invoca: ", getpid());
printf("\n");
}
execve("./factorial", argv, envp);
return 0;
}
10
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
GESTIN DE ARCHIVOS, DIRECTORIOS Y SISTEMA DE ARCHIVOS

EJERCICIO 4.
Genere el programa ej4.c que permitir listar el contenido de
un directorio, tendr la siguiente sintaxis de ejecucin:
ej4 [opciones] [pathname]
Opciones:
l: lista el contenido del directorio.
t: tipo.
Listar el contenido del directorio especificando el tipo de
cada archivo (Regular, directorio, especial de dispositivo de
caracteres, especial de dispositivo de bloques, enlace
simblico, etc.)
i: nmero de inodo
Pathname: ser el nombre de un directorio, en caso de que
sea invlido deber mostrar el mensaje de error
correspondiente. Si no se especifica al momento de la
ejecucin deber ejecutarse sobre el directorio actual.
nombre ej3):
ej4 [-lti] [dir_name]
ej4 [-lti] [dir_name]

#include <stdio.h>
11
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
#include <dirent.h>
void tipo (int argc, char *argv[]);
void directorios (int argc, char *argv[]);
void inodo (int argc, char *argv[]);
{
int parametro;
if ( argc == 1 )
{
printf("%s", "uso: [-lti] [nombre_directorio]\n");
}
if ( argc >= 1 && argc <= 3 )
{
while ((parametro = getopt (argc, argv, "lti:")) != -1)
{
switch (parametro)
{
case 'l':
directorios (argc, argv);
break;
case 't':
tipo (argc, argv);
break;
case 's':
inodo (argc, argv);
break;
}
}
}
else
{
printf("%s", "uso: [-lti] [nombre_directorio]\n");
}
}
void tipo (int argc, char *argv[])
{
static unsigned char tipoID[7] = {DT_BLK, DT_CHR, DT_DIR,
DT_FIFO, DT_LNK, DT_REG, DT_SOCK};
static char *tipoSTRs[7] = {"Dispositivo de bloques",
"Dispositivo de caracteres", "Directorio", "FIFO", "Enlace", "Archivo
Regular", "Socket Unix"};
DIR *pd; //ptro a fichero directorio
struct dirent *dirdatos; //info sobre 1 entrada en el directorio
if (argc == 1)
{
fprintf (stderr, "numero de parametro erroneo \n");
fprintf (stderr, "Uso %s <Directorio>\n", argv[0]);
exit(1);
}
pd = opendir(argv[2]);
if(pd == NULL)
{
perror(argv[2]);
exit(1);
}
dirdatos = readdir(pd);
12
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
printf("%s%s", "Tipos de arhivos del directorio: ", argv[2]);

printf("\n");
while (dirdatos != NULL)
{
int tipo = dirdatos->d_type;
switch (tipo)
{
case 1:
printf ("%s%s%s \n", dirdatos-> d_name, " " ,tipoSTRs[0]);
case 2:
case 3:
case 4:
" ,tipoSTRs[4]);
case 5:
printf ("%s%s%s \n", dirdatos-> d_name, " dirdatos = readdir(pd);
case 6:
printf ("%s%s%s \n", dirdatos-> d_name, " -
" ,tipoSTRs[5]);
" ,tipoSTRs[6]);
case 7:
printf ("%s%s%s \n", dirdatos-> d_name, " dirdatos = readdir(pd);
}
if (dirdatos-> d_type & DT_REG)
{
printf ("%s%s \n", dirdatos-> d_name, " - Regular");
}
}
closedir (pd);
}
void directorios (int argc, char *argv[])
{
if (argc == 1)
{

exit(1);
13
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
if(pd == NULL)
{
perror(argv[2]);
exit(1);
}
printf("%s%s", "Listado del directorio: ", argv[2]);
printf("\n");
{
printf ("%s \n", dirdatos-> d_name);
}
closedir (pd);
void inodo (int argc, char *argv[])

{
if (argc == 1)
{
exit(1);
}
if(pd == NULL)
{
perror(argv[2]);
exit(1);
}
printf("%s%s", "Numero de inodo de archivos del directorio: ",
argv[2]);
printf("\n");
{
printf ("%s - %d \n", dirdatos-> d_name, dirdatos-> d_ino);
}
closedir (pd);
}
GESTIN DE SEALES
EJERCICIO 5.
A los huspedes del hotel se les ofrece entre otros tantos
servicios, el desayuno buffete. Una de las principales
preferencias elegidas por los visitantes son las tostadas para
poder acompaar con una gran variedad de mermeladas
regionales de diferentes sabores.
14
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
Deber simular el comportamiento de la tostadora que tiene

ciertas particularidades, teniendo en cuenta las siguientes
condiciones:
1 de cada 5 huspedes elige pan negro para tostar.
Cada tostada de pan negro demora, para la graduacin
de temperatura ya estipulada: 30 segundos (representar
en la simulacin por 1 seg) en tostarse, mientras que la
de pan blanco tarda 45 segundos (representar en la
simulacin por 2 seg).
La tostadora se programa de acuerdo a uno u otro tipo
de pan.
Las tostadas se preparan por pares, pero solamente
admite un tipo de programacin (blanco/negro).
Cada vez que finaliza la tostadora de tostar el pan, emite una
alarma indicando que la tostada est hecha.
Datos para la simulacin:
La tostadora ser un proceso a la espera de las seales
de los huspedes (segundo proceso) cuando van a
realizar las tostadas (pan blanco SIGURSR1- / pan negro
SIGURSR2). Por cada seal imprimir el siguiente
mensaje:
Tostar pan blanco
Tostar pan negro
Los huspedes enviarn una seal cuando quieran una
tostada:
Pedido de tostadas de pan blanco
Pedido de tostadas de pan negro
Se solicita simular la situacin promedio de 30 tostadas
por da que son solicitadas por los huspedes.
nombre tostadora y huesped):
./tostadora
./huesped [pid_tostadora]
./tostadora
#include
#include
#include
#include
<sys/types.h>
<unistd.h>
<signal.h>
<stdio.h>
int tostadas = 0;
int lista = 1;
void tostar (int sig);
void man_alarm (int sig);
int main()
{
signal(SIGUSR1,
signal(SIGUSR2,
signal(SIGALRM,
while( tostadas
&tostar);
&tostar);
&man_alarm);
< 15 )
15
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
{
if (lista) printf("Tostadora libre, esperando pan.\n");
pause();
}
return 0;
}
void man_alarm (int sig)
{
lista = 1;
printf ("Tostadas listas\n");
}
void tostar (int sig)
{
tostadas ++;
lista = 0;
switch (sig)
{
case SIGUSR1:
printf("\n");
printf("Deseo tostadas de pan blanco.\n");
printf("Tostada de pan blanco (%d) \n",
tostadas);
alarm(2);
break;
case SIGUSR2:
printf("\n");
printf("Deseo tostadas de pan negro.\n");
printf("Tostada de pan negro: (%d)\n",
tostadas);
alarm(1);
break;
./huesped [pid_tostadora]
#include
#include
#include
#include
#include
<sys/types.h>
<signal.h>
<stdio.h>
<unistd.h>
<stdlib.h>
int main (int argc, char *argv[])

{
int pid_m, i;
pid_m = atoi(argv[1]);
for (i=1; i < 16; i++)
{
if ((i % 5) != 0)
{
printf("%s%d\n","Pedido de tostadas de pan
Blanco. Huesped: ", i);
16
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
kill(pid_m, SIGUSR1);
}
else
{
printf("%s%d\n","Pedido de tostadas de pan
Negro. Huesped: ", i);
kill(pid_m, SIGUSR2);
}
Sleep(2);
}
return 0;
REDIRECCIN DE ENTRADA Y SALIDA.

EJERCICIO 6.
Una lnea area cubre el transporte de pasajeros en el centro
del pas, con una flota de aeronaves de mediano porte como
la que se muestra en la imagen.
La aeronave cuenta con 33 plazas y tiene una alta demanda
de pedidos. Para agilizar los trmites de los pasajeros la
compaa cuenta con la opcin de Web check-in, para lo que
previamente se debe contar con el cdigo de la reserva.
Se solicita modelar la situacin descripta anteriormente con
la generacin de 3 programas, suponiendo que se trata del
vuelo AR234, para lo que se deber generar:
El programa reservas.c agregar al nombre del pasajero
y el cdigo de reserva la identificacin del vuelo.
El programa checkin.c agregar por cada nombre del
pasajero y el cdigo de reserva el nmero de asiento.
Se supone que se cuenta con el archivo pasajeros.txt que
contiene la siguiente informacin (para el vuelo que se desea
programar):
LEIVA,JUAN_KLRZI
DIAZ,MAIRA_KLRZI
SANCHEZ,ESTEBAN_QWERO
DIEGUEZ,DARIO_FRTYU
MENDEZ,ELBA_YTHGJ
17
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
NOTA: los elementos antes del _ corresponden a los

nombres de los pasajeros y las 5 letras siguientes a la
reserva.
nombre reservas y checkin respectivamente):
./reservas
./checkin
Finalmente, el programa plandevuelo.c , realizar las dos
acciones anteriores tomando desde el archivo pasajeros.txt la
informacin y almacenndola en el archivo plandevuelo.txt.
nombre plandevuelo): ./plandevuelo rc plandevuelo.txt
./reservas
#include
#include
#include
#include
<sys/types.h>
<unistd.h>
<fcntl.h>
<stdio.h>
int main(void)
{
int fd, newfd;
while ((getc(stdin) != -1 ))
{
char *c[50];
scanf("%[^\n]", c);
printf("%s%s\n", c, "_AR234");
}
return 0;
}
./checkin
#include
#include
#include
#include
<sys/types.h>
<unistd.h>
<fcntl.h>
<stdio.h>
int main(void)
{
int asiento = 1;
char linea[50] = getline(stdin, 50);
printf("%s\n", linea);
while (getc(stdin) != -1 )
{
char *c[50];
scanf("%[^\n]\n", c);
printf("%s%s%d\n", c, "_", asiento);
asiento ++;
}
return 0;
}
./plandevuelo rc plandevuelo.txt
18
Ferrero, Lucrecia
Mndola, Silvina
#include
#include
#include
#include
#include
#include
UTN-FRSF
<stdio.h>
<stdlib.h>
<unistd.h>
<sys/types.h>
<string.h>
<fcntl.h>
void checkin (char *archivo[]);

void reservas(char *archivo[]);
void reservascheckin (char *archivo[]);
{
int parametro;
char *archivo[] = {argv[2]};
if (argc < 3 || argc > 4)
{
printf("Nro de parametros incorrecto\n");
return 0;
}
if (strcmp(argv[1], "-r") == 0)
{
reservas (archivo);
}
if (strcmp(argv[1], "-c") == 0)
{
checkin (archivo);
}
if (strcmp(argv[1], "-rc") == 0)
{
reservascheckin (archivo);
}
return 0;
}
void checkin (char *archivo[])
{
FILE *fl;
pid_t pid;
int tuberia[2];
pipe (tuberia);
pid = fork();
if (pid) //padre
{
char linea [150];

fl = fopen ("pasajeros.txt", "r"); // abrimos el archivo de pasajeros
close(tuberia[0]); // cierra pipe de lectura
close(1);
dup(tuberia[1]);
while (feof(fl) == 0 )
{
fgets(linea, 150, fl);
printf("%s", linea);
}
fclose(fl); // cierra el archivo
}
else //hijo
{
19
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
close(tuberia[1]); //cierra el pipe de escritura

close(1); // cierra la salida estandar
int fd = creat(archivo[0], O_CREAT + O_WRONLY); // crea el archivo
plandevuelo.txt
dup(fd); // ponemos el file descriptor en la salida estandar
close(0); //cierro la entrada estandar
dup(tuberia[0]); // pone el file descriptor en la entrada estandar.
execve("./checkin", archivo, NULL);
}
}
void reservas (char *archivo[])
{
FILE *fl;
pid_t pid;
int tuberia[2];
pipe (tuberia);
pid = fork();
if (pid) //padre
{
char linea [150];
fl = fopen ("pasajeros.txt", "r"); // abrimos el archivo de pasajeros
close(tuberia[0]); // cierra pipe de lectura
close(1);
dup(tuberia[1]);
while (feof(fl) == 0 )
{
fgets(linea, 150, fl);
printf("%s", linea);
}
fclose(fl); // cierra el archivo
}
else //hijo
{
close(tuberia[1]); //cierra el pipe de escritura
int fd = creat(archivo[0], O_CREAT + O_WRONLY); // crea el archivo
plandevuelo.xt
dup(fd); // ponemos el file descriptor en la salida estandar
close(0); //cierro la entrada estandar
dup(tuberia[0]); // pone el file descriptor en la entrada estandar.
execve("./reservas", archivo, NULL);
}
}
void reservascheckin (char *archivo[])
{
FILE *fl;
pid_t pid;
20
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
int tuberia[2];
pipe (tuberia);
pid = fork();
if (pid==0) //hijo
{
pid_t pid2;
int fd = creat("reservas.txt", O_CREAT + O_WRONLY); // crea
el archivo plandevuelo.txt
dup(tuberia[0]); //conecto la entrada estandar al archivo
dup(fd); // ponemos el file descriptor en la salida
estandar
execve("./reservas", archivo, NULL);
}
else //padre
{
char linea [150];
fl = fopen ("pasajeros.txt", "r"); // abrimos el archivo de
pasajeros
close(1);//cierra salida estandar
dup(tuberia[1]);// pone el file descriptor en la entrada
estandar.
fl = fopen ("reservas.txt", "r"); // abrimos el archivo de
pasajeros
dup(tuberia[1]); // pone el file descriptor en la salida
estandar.
execve("./checkin", archivo, NULL);
}
}
21
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
En esta seccin dejamos en claro lo siguiente:

22
Ferrero, Lucrecia
Mndola, Silvina
UTN-FRSF
CONCLUSION EJERCICIO 3:
Es que el ID del Proceso que invoca y el ID del Prg-Factorial
son iguales, lo que significa que al llamar a execve, no cambia
de proceso sino que se sigue ejecutando el mismo.
Fuentes desde donde nos guiamos para la sintaxis de
algunas funciones:
http://www.forosdelweb.com/f96/mostrar-directorios-contenido-ficherostxt-765146/
http://totaki.com/poesiabinaria/2011/09/listar-archivos-dentro-de-undirectorio-o-carpeta-en-c/
Ejercicio 6:
Realizamos la codificacin de los 3 programas: reservas.c,
checkin.c y plandevuelo.c.
reservas.c y checkin.c funcionan correctamente en
plandevuelo.c. Hemos dedicado tiempo investigando,
realizando consultas y pruebas, pero no logramos que
funcione con la opcin -rc. Sin embargo dejamos expuesta
su codificacin en la imagen (.img) y en este documento.
23

TP2 Grupo4

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

TP2 Grupo4

Diunggah oleh

Hak Cipta:

Format Tersedia

SISTEMAS OPERATIVOS

2012 2DO. CUATRIMESTRE (T: TARDE)

ARGUMENTOS POR LNEA DE COMANDO (ARGC ARGV OPCIONES)

ej1 [-cl] [-s nombre_archivo]

int main(int argc, char *argv[])

while ((parametro = getopt (argc, argv, "cls:")) != -1)

o Nodo 1.1: corresponde al primer hijo del Nodo 1 e

int main(int argc, int *argv[])

void ChildProcessleft(int valor)

void ChildProcessright(int valor)

void Grandsonright(int valor)

int factorial(int valor);

return (valor * factorial(valor - 1));

int main(int argc, char *argv[], char *envp[])

GESTIN DE ARCHIVOS, DIRECTORIOS Y SISTEMA DE ARCHIVOS

ej4 [-lti] [dir_name]

printf("%s%s", "Tipos de arhivos del directorio: ", argv[2]);

fprintf (stderr, "numero de parametro erroneo \n");

void inodo (int argc, char *argv[])

Deber simular el comportamiento de la tostadora que tiene

int main (int argc, char *argv[])

REDIRECCIN DE ENTRADA Y SALIDA.

NOTA: los elementos antes del _ corresponden a los

void checkin (char *archivo[]);

char linea [150];

close(tuberia[1]); //cierra el pipe de escritura

En esta seccin dejamos en claro lo siguiente:

Anda mungkin juga menyukai

int main(int argc, char argv[], char envp[])