Hola:

Estoy realizando un curso de comunicacion de procesos en C, y pues me he desidido a postear aqui los avances .

Pido de favor que, cualquier aclaracion sobre el curso, aviso de errores de ortografia y mas delitos , sean avisados en otro POST que creare, referente a los errores, y arreglos para con el curso de comunicacion de procesos. Del mismo modo, acepto ideas, comentarios y criticas para aumentar el conocimiento de este curso que estoy desarrollando.

Mas que nada lo planteo asi, para que NO se mezclen los POST de ustedes, con los POST referentes al TUTO.

El Enlace al POST para aclaraciones, consejos, comentarios. Aqui:

-----> http://foro.elhacker.net/index.php/topic,89319.0.html <-----

NOTA 1: si deseas resolver dudas, respecto a sus codigos practicos o dudas del lado teorico o de comprension misma, porfavor crear otro POST. Ya que este POST que pongo arriba, es solo para CONSEJOS, AVISOS, IMPLEMENTACIONES.

Planteo Dudas, Resolucion de Dudas, Planteo de Codigos Propios y dudas de mismod codigos, porfavor Crear su propio POST .

Ya estoy a punto de terminar el Curso, con el fin de entrar de lleno al: Analizis de Sockets en C .

byeeee

1.1 Teoria

Un Proceso es: un programa en ejecucion o la instancia de un programa funcionando en un ordenador.

Los Estados de un procesos son:

• Nuevo
• Ejecucion
• Bloqueado
• Listo
• Terminado

*Nuevo
   Cuando se crea un nuevo proceso, es admitida por el S.O y esta en espera de ser utilizado.

*Ejecucion
   Cuando el proceso esta siendo utilizado.

*Bloqueado
   Cuando el procesos NO se puede ejecutar, hasta que presente algun suceso.

*Listo
   Cuando el proceso esta en espera de ser utilizado.

*Terminado
   Cuando el proceso es excluido por el S.O del Grupo de Procesos.
   


Cada procesos que se cree, tiene su propio espacio en memoria, por lo cual ahi varios puntos a con-
siderar en la creacion de un proceso, que son:

• Asignar un Unico Identificador al Nuevo Proceso ( un ID )
• Asignar Espacio para el Nuevo Proceso
• Iniciar el Bloque de Control de Procesos
• Establecer los Enlazes Apropiados
• Crear o Ampliar otras Estructuras de Datos

   
Al ejecutar un programa el S.O automaticamente le asigna un ID a nuestro programa ( realiza operaciones
de creacion de proceso ), de este modo obtenemos un ID, que sera el proceso PADRE, que sera la instancia
de nuestro programa. Asi despues desde codigo con solamente invocar la funcion fork(); nosotros
crearemos procesos Hijos para nuestro procesos PADRE.

Ventajas/Aportaciones de la Creacion de un Proceso

• Trabajo Interactivo y en Segundo Plano
• Procesamiento Asincrono
• Aceleracion de la Ejecucion
• Estructuracion Modular del Programa

---

1.2 EL Proceso ID

Unix identifica el proceso mediante un entero unico denominado ID, para poder ver el ID de los procesos
Padres e hijo(s) se utilizan las funciones:

      
   
Unix asocia cada proceso con un usuario en particulas, de este modo cada usuario posee un ID, este ID de
usuario lo podemos llamar mediante:

   getuid();  ----->  uid_t getuid( void );

Como vimos, existe el ID del usuario que es el que ejecuta el programa, pero de igual manera tambien
un ID de Usuario Efectivo, que viene siendo el que determina los privilegios que el proceso tiene para
el acceso de recursos. Para acceder a el ID de Usuario Efectivo se utiliza:

   geteuid();  ----->  uid_t geteuid( void );

Codigo: ps_001.c
Programa que imprime IDs de: proceso, padre, usuario y usuario efectivo

---

1.3 Analisis de los Estados de un Proceso

Como mencionamos en el capitulo 1.1, los estados son:

• Nuevo
• Ejecucion
• Bloqueado
• Listo
• Terminado

   
Ahora veremos una explicacion mas practica dentro del SO.

=== NUEVO ===
Cuando se crea un proceso nuevo, una vez creado el proceso, nuestro SO asigna un ID al
proceso, asigna espacio, etc, etc... y lo manda a la COLA DE PROCESOS LISTOS, osea en esa
cola  se colocal los procesos que estan listos o preparados para ser ejecutados.

=== LISTO ===
Una ves pasado el proceso a la COLA DE PROCESOS LISTOS, el proceso pasa al estado de LISTO
que es el momento en el que el proceso es ejecutado o puesto en uso.

=== EJECUCION ===
Una ves que es tomado de la COLA DE PROCESOS LISTOS, el procesos deja el estado de LISTO y
pasa al estado de EJECUCION, que es el momento en el que el proceso esta siendo utilizado
dentro del CPU.

=== BLOQUEADO ===
Durante la Ejecucion del proceso le surge la necesidad de esperar por algun suceso o evento,
en ese momento pasa al estado de BLOQUEADO, en el cual este estado depende de que se produzca
dicho suceso o evento para dejar este estado. Un proceso puede moverse al estado de BLOQUEADO
con solo hacer una llamda a la funcion: sleep();.

=== TERMINADO ===
Cuando el proceso es finalizado por le usuario o el SO. ( el mas facil de todos o_O  xD ).

---

1.4 Creacion de un Proceso

Unix crea un proceso atravez de la llamada ala funcion: fork();.

Un Proceso Padre ---> es el proceso que a sido iniciado y tiene un ID asignado por el SO.
Un Proceso Hijo ---> es el proceso copia del proceso padre y tiene un ID similar al Proceso Padre.

Un Proceso Hijo debe ser finalizado primero y despues finalizar su Proceso Padre, de este modo la
Operacion del Proceso es Correcta. Cuando esto ocurre al reves se toman los siguientes nombre a los
procesos y significativos:

Un Proceso Huerfano ---> es un proceso que a sido finalizado por el proceso PADRE, y es adoptado
   por el Demonio del Sistema que es: init, este Demonio finalizara dicho proceso. init es
   identificado como Proceso Padre con ID=1.
   
Un Proceso Zombi ---> es un proceso hijo que se ha quedado parado o bloqueado en la tabla de PROCESOS
   y espera la finalizacion de su proceso PADRE.
   
NOTA: es importante resaltar que un proceso hijo reside dentro de un Proceso Padre o Principal, y debemos
tomar en cuenta que un proceso hijo pude crear Otros Procesos Hijos, dentro del mismo Proceso.

La funcion fork(); realiza una llamada al SO donde copia la imagen en memoria que tiene el Proceso
Padre. El nuevo proceso recive una COPIA del espacio de direccion en memoria que tenia el Proceso
Padre. Los procesos continuan su ejecucion en la instruccion que esta despues del fork();.

Debe quedarnos claro que desde el momento en que EJECUTAMOS nuestro programa ( el que sea ) automa-
ticamente se crea un proceso para nuestro programa y un ID de dicho proceso, por lo cual al momento de
llamar a getpid() ANTES de la llamada a fork() podemos ver el ID de nuestro proceso PADRE
( osea el proceso que corresponde a nuestro programa principal ).


El fork(); es de tipo: pid_t.

   *fork(); ----->  pid_t fork( void );

fork(); devuelve un 0 al proceso hijo y un valor diferente de 0 al proceso padre.


Codigo: ps_002.c
Programa que crea un proceso Hijo e imprime el ID del proceso Padre e Hijo creado con fork();

=== Explicacion ===
Al iniciar nuestro programa ( ejecutarlo ), automaticamente se crea un proceso para la instancia de nuestro programa dentro de la
PC, con esto automaticamente obtenemos un ID de Proceso ( esto sucede con cualquier programa que hemos ejecutado ), ahora como se
muestra en le codigo, se imprime "Inicia el Programa con Proceso Padre PID : 7737", donde 7737 es el ID que tiene nuestro programa
y lo consideramos como el PROCESO PADRE. Ahora viene la llamada a fork();, la cual vuelve a crear otro proceso pero con un ID
diferente, NOTESE que al crearse otro proceso imaginemos que volvemos a crear otro EJECUTABLE . Ahora como solo se creo el Nuevo
Proceso, el programa pasa a la parte de ELSE e imprime "Continua el Proceso Padre PID 7737". Ahora nuestro Proceso Hijo llega a la
parte de fork(); y ve que NO puede continuar a crear otro proceso, ya que los procesos HIJOS tienen 0 y los Procesos Padre tiene
un numero diferente de 1. Por lo tanto entra el IF e imprime "He Creado el Proceso Hijo PID 7739 y Mi Padre PID 7737", ahora nuestro
Proceso Padre ( programa principal ) llega ala antepenultima linea que es: "Termino el Proceso 7737", y finaliza, despues llega a la
misma posicion el Proceso Hijo ( por decirlo asi, el proceso IMAGEN o VIRTUAL ) e imprime: "Termino el Proceso 7739" y finaliza.

Algunas veces puede Inicia primero el Proceso Padre y despues el Proceso Hijo, o al reves, pero siempre finaliza primero el proceso
HIJO y despues el Proceso Padre .

De la misma manera al iniciar el programa como dije anteriormente, se crea el proceso y obtenemos un ID para nuestro programa en
ejecucion, despues llega a la parte del "if( fork() == 0 )" y se crea un proceso nuevo, en este caso lo podemos nombrar
como: "Proceso Hijo", de esta forma imaginemos que creamos un nuevo PROGRAMA ( osea ejecutamos en otra ventana ), y tenemos 2 procesos funcionado, el Proceso Padre ( nuestro programa principal ) y el Proceso Hijo ( el nuevo proceso realizado por la llamada a fork();,
de este modo conseguimos el Trabajo en Segundo Plano . Ya que interactucamos con dos procesos a la ves . No es complicado, simplemente
imaginemos que tenemos 2 programas, y en nuestro Proceso Padre ( programa principal ) ejecuta el fork(); y crea un Proceso Nuevo
(osea el Hijo) por lo tanto el fork(); nos retorna un 0, ya que creo un nuevo proceso y logicamente entra el IF e imprime:
"He Creado el Proceso Hijo PID: 7739, Mi Padre PID: 7737", despues entra el " sleep()"  y espera 1 segundo, en el transcurso de ese
segundo le da tiempo suficiente al padre para continuar con su codigo, que en  este caso sera el ELSE , y pues imprime:
"Continua el Proceso Padre: 7737", despues el proceso padre llamada a sleep(); y espera 1 segundo, durante ese segundo de espera, el proceso Hijo Continua su ejecucion y lo primero que ve es que, finaliza el IF y lega al exit(0); por lo tanto termina el
Proceso Hijo Primero, despues termina el segundo de espera del Proceso Padre y continua su codigo y ve que termina el ELSE y continua
el codigo y se encuentra el exit(0); y finaliza.

El sleep(); nos sirve para poder visualizar de una formas mas entendible el funcionamiento del programa, ya que al iniciar el programa
, lo primero que hace es mostrarte el inicio del proceso HIJO y del proceso PADRE, espera 1 segundo y realiza la finalizacion.

Codigo: ps_003.c
Programa que Ilustra un PROCESO HUERFANO, y vemos que es tomado por INIT, ver IDs

=== Explicacion ===
Bueno primero imprime el ID del proceso Padre, despues llama al " fork() " y crea al HIJO, continua con IF e imprime
"Inicia el Hijo con PID: 8766 y Padre PID: 8764", despues entra el sleep();, espera un segundo. En seguida entra el ELSE, e imprime "Continua el Padre PID: 8764" y finaliza el Proceso Padre ( nuestro programa principal ), ahora regresa el Proceso Hijo y por lo tanto el Proceso Hijo es tomado por init, y e imprime: "Nuevamente el Hijo PID: 8766 y Padr PID: 1" fuera de nuestro programa y dentro de la Shell .

Notese que una la cadena: "Nuevamente el Hijo PID: 8766 y Padre PID: 1" es mostrado despues de la finalizacion del programa,
dentro de la consola Unix . Ya que el procedimiento ese lo realiza init .


Codigo: ps_004.c
Programa que crea una lista de Procesos


=== Explicacion ===
Este programa crea una lista de procesos, en el que conforme se va creando procesos el proceso actual pasa a ser un Hijo y al
crear otro proceso, el proceso anterior pasa a ser Padre del Proceso Actualmente creado.
Prosiguiendo con el codigo, el programa infoca al fork(); siempre y cuando sea un proceso padre... if( fork() ), de este modo
creamos procesos padres en el que un procoso esta enlazado con otro, recordemos nuevamente que un proceso padre es independiente
del un proceso anterior, pero se enlazan los procesos ya que corresponden a un mismo programa, en el cual solo como diferenciador
se le asigna un numero de identificacion ( ID ) de un valor+1 del proceso anterior. ( Ejm: 5393, 5394m etc.., etc... ).
De esta forma creamos una LISTA de procesos xD. La finalizacion se realiza desde el Ultimo Proceso Creado hasta el Primer Proceso
Que es La Instancia o Proceso de Nuestro Programa en Ejecucion .


Codigo: ps_005.c
Programa que Crea Varios Procesos Hijos dentro de un mismo Proceso

=== Explicacion ===
Este Programa crea Hijos dentro de un mismo proceso. Debemos tomar en cuenta que para la creacion de Procesos Hijos, lo
diferenciamos cuando  fork();  devuelve 0, esto indica la creacion de un proceso hijo .
Siguiendo el codigo encontramos  if( fork() == 0 )  siempre y cuando se cree un proceso Hijo entrara el IF e imprimira
el PID del Proceso Hijo, despues Frena el FOR e imprime Finalizado el Proceso con PID:, espera 1 segundo, tiempo justo para
que el programa pueda crear otro proceso Hijos y terminarlo conforme se pidan .
Al final solo finaliza nuestra Istancia/Proceso Padre Principal xD.

---

1.5 La Llamada    wait   al Sistema

La llamada al sistema  wait  detiene al proceso hasta que sus procesos hijo termine o se detenga, wait() retorna un valor positivo en caso que su proceso hijo haya finalizado correctamente, dicho valor positivo corresponde al ID del Proceso Hijo, y retorna un valor -1 en caso que se haya presentado algun error, suspencion o interrupcion inesperada. Cuando wait() retorna un -1 setea a " errno " con un valor que mas abajo se explican.

Se debe utilizar una de las siguientes funciones.


estado ---> es un puntero a un valor entero.

Caracteristicas de wait:

• Wait regresa de inmediato si el proceso no contiene procesos hijos o si el hijo termina o se detiene.
• Wait regresa debido a la terminacion de un hijo.

   
Valores de errno:

• ECHILD --> indica que no existen procesos hijos a los cuales esperar
• EINTR --> indica que la llamada/espera fue interrumpida por un senal.

   
Para analizar de una mejor manera el estado de un proceso hijo correspondiente al valor devuelvo al estado se utiliza
POSIX, en el cual especifica los siguiente macros:

   *WIFEXITED( int estado ) --> El Hijo termino normalment, el estado devuelto es 0.
   *WEXITSTATUS( int estado ) --> Devuelve el estado del proceso, lo normal es 0.
   *WIFSIGNALED( int estado ) --> El Hijo termino debido a una senal no atrapada.
   *WTERMSIG( int estado ) -->
   *WIFSTOPPED( int estado ) -->
   *WSTOPSIG( int estado ) -->

Codigo: ps_006.c
Programa que Ilustra un poco el uso del wait() xD

=== Explicacion ===

Bueno ene ste caso no podemos dar un resultado en ejecucion, ya que ahi varios resultados posibles, pero aki los mencionare
todos los posibles y el porke , conforme el codigo se lee, va sucediendo asi:

1. Si fork() falla entonces retorna una valor -1 y muestra: " Fork Fallo ".

2. En caso que fork() realize el proceso con exito, imprime al Hijo y entra el wait(), el wait para el proceso padre hasta
que el proceso hijotermine, ene se mometno retorna le valor positivo a wait() ( que es el ID dle proceso Hijo ), y continua
el codigo he imprime el texto del Padre... en Conclusión seria asi:


3. Se crea el proceso Hijo y por consecuencia se imprime el proceso Hijo, ahora entra wait() y si sucede alguna interrupcion
o error en la espera entonces imprime el fprintf() frl wait() . En ejecucion seria asi:


4. Ahora ahi otra opcion, y esta ilustra una de las variantes de la creacion de procesos , que es: " La velocidad relativa
de un proceso ", esto consiste en que tanto el proceso padre y/o el proceso hijo, ejecuten con mas rapidez sus instrucciones,
en alguno casos se puede imprimir primero el padre y despues el Hijo, y en otros ( que es el mas frecuente ) se imprime el
Proceso Hijo y al final el Padre, pero esto varia dependiendo la velocidad del proceso ( aki no tomes encuenta la potencia
que tenga tu Ordenador ). Bueno basandose en lo explicado, en alguno casos se creara el Proceso Hijo y antes de llegar
al seguno condicional el Proceso Padre llegara rapidamente al tercer condicional ( que es donde se comprueba el wait() ), en
este momento posiblemente si surge algun error imprimira el fprintf() del wait() y despues el fprintf() del Hijo y finalizara
el programa. En la ejecucion seria asi:



La Siguiente Instruccion reinicia un proceso hasta que finalize dicho proceso, asi el Proceso Padre pase a finalizar.


Codigo: ps_007.c
Programa que Ilustra el uso de los POSIX, para determinar la razon de la terminacion del Proceso Hijo

== Explicacion ==
Este codigo resulta un poco mas detallado, a la hora de saber el PORQUE ? se detuvo o finalizo el proceso inesperadamente,
como anteriormente vimo, el wait() nos ayuda a saber el estado de un proceso, asi podemos determinar si finalizo BIEN o
si finalizo debido a una senal o interrupcion, pero mas NO sabemos la razon exacta del porke o una mejor vicion del PORQUE
finalizo de esa forma. Con una pequena implementacion del wait() junto con los POSIX podemos tener una respuesta un poco
mas detallada y concreta sobre el PORQUE de la finalizacion o interrupcion de nuestro Proceso.

Con forme al Codigo ps_009.c podemos notar que despues del IF del hijo, el siguiente condicional es donde se SUPONE debemos
poner el codigo del PADRE, pero ponemos el codigo de wait() ( ya que asi se maneja ), y el condicional este nos indica que
entrara dicho condicional aunque el proceso haya finalizado BIEN o MAL, una ves entrando se escriben las siguientes sintaxis que
podemos ver en el codigo del uso de los POSIX como: WIFEXITED y WIFSIGNALED, los cuales evaluaran el PORQUE finalizo el Proceso, de este modo tedremos una mejor idea mas concreta del PORQUE .

---

1.6 La Llamada    exec   al Sistema

La Llamada exec al sistema permite trasladar al proceso con un modulo ejecutable nuevo . De esta forma un proceso hijo ( o los que tu desees ) podra ejecutar codigo diferente al de su Proceso Padre. La manera de utilizar el exec es dejar que el Proceso Hijo ejecute el exec para el nuevo programa, mientras que el Padre continua con la ejecucion del codigo original.

Existen 6 formas o variaciones para pasar los argumentos de linea de comando y el ambiente, de igual forma la ruta de acceso
( path o directorio ) y el nombre del ejecutable. A continuacion mencionare las 6 formas o variantes:

Estas 3 formas permiten pasar los argumentos de linea de comando en forma de lista y son utiles si se conoce el numero de argumentos de
linea de comando.


Estas 3 formas permiten pasar los argumentos de linea de comando en forma de arreglo o vector de argumentos xD.


Vemos un sencillo ejemplo .

Codigo: ps_008.c
Programa que ilustra execl(), creando un proceso hijo y ejecutando el comando: ls -l ( listar archivos en forma de lista )

== Explicacion ==

Aqui utilizaremos un poco nuestra nueva funcion ... execl(); que mas bien, viene siendo algo parecido a la funcion:
system();, solo que un poco mejor la funcion "execl()", no explicare el porke ya que solo es un tuto de introduccion y no me
abaracre a explicar mucho otras funciones para ahorrar hojas .

Ok, empezamos a leer el codigo, y vemos el primer condicional, este condicional se cumple a menos que NO se haya podido realizar
el Proceso, de este modo fork(); regresara un -1 como error xD. Continuando con el 2do condicional, este entra cuando el hijo
funcionando o en circulacion el Proceso Hijo, una ves entre el Condicional nos imprimira los 3 fprintf(); y esperara que le
introduscamos alguna cadenita sin espacios ( scanf(); ), de este modo segun mi ejemplo, introducimos: "/home" y ENTER.

Ahora ejecuta la funcion execl(); con 4 parametro, que explicare :
"/bin/ls" ---> es el directorio del ejecutable "ls"
"ls" --> el comando de ese ejecutable que pusimos en el parametro 1
cad ---> es un argumento alterno o argn que es ejecutado en seguida del ls, osea vendria quedando: ls cad ( ls /home )
NULL ---> es solo un termino NULO.

En caso de error la funcion execl(); retorna un valor menor que 0.

Antes de Pasar a ver un siguiente ejemplo de la utilizacion de "execv()", explicare el funcionamiento de las 3 funciones de "execl(); con parametros establecidos y el funcionamiento.

execl( "/bin/ls", "ls", cad, NULL );
Esta funcion tiene como punto principal el primer PARAMETRO, que es la ruta del ejecutable principal ( en este caso ls ), y la
caracteristica principal es que esta funcion busca el nombre del programa con la ruta especificada o relativa al directorio de
trabajo.

execlp( "/bin/ls", "ls", cad, NULL );
Esta funcion tiene los mismo parametros que "execl()", solo que esta funcion busca el directorio del ejecutable a llamar o utilizar
en la shell utilizando la variable de entorno PATH como de la misma manera que lo hace la SHELL al realizar un comando.

execle( "/bin/ls", "ls" , cad, NULL );
Esta funcion tiene los mismo parametros que "execl()", solo que el primer parametro es tipo file... este puede ser un 2do programa
en C o una bach script a ejecutar dentro de nuestro codigo, y que tambien tiene la caracteristica de que usando "execle()", el nuevo
programa hereda el ambiente del Proceso Padre .

Codigo: ps_009.c
Programa que ilustra el uso de execlp(), creando un proceso y realizando ls desde un bash script

== Explicacion ==

Pues el programa se ejecuta, el caso que NO se peuda crear el Proceso Hijo, fork(); retorna un -1 e imprime el primer fprintf();, de lo contrario crea el Proceso hijo y el 2do condiciona entra e imprime los 3 fprintf();, despues espera que le pases una cadena
sin espacios ( osea: /home ), despues ejecuta la funcion "execlp()" y aqui la funcion en caso de error retorna un valor menor que
0. Pero en caso de EXITO realiza lo siguiente: En el primero para metro manda llamar al ejecutable y envia un 1, osease pasas desa-
persivido el parametro 1, ya que el SCRIPT hara el ls , despues el parametro 3 ( osea argn ), le envias la cadena que seria: "/home"
y mas o menos realizara esto: "./test.sh /home".

Ahora explicare el sencillisimo bash script, que solamente realiza una llamada a "ls" y le pasa el primer argumento ( osea /home ), que en este caso lo identifica como: " $1 ". Y por consecuencia el primer parametro viene siendo " /home " . Despues finaliza el script
con una llamda a exit; .

Como ultimo condicional examina la terminacion del Proceso Hijo con una llamda a wait() .

Ahora explicare la utilizacion de los siguientes 3 tipos de exec() que utilizan un array en donde guardan el argumento, la exlicacion sera conforme al ejemplo que encontraran mas abajo :


execv( "/bin/ls", &argv[0] );
Esta funcion toma 2 parametro que son: la ruta del ejecutable y como segundo parametro un argumento.

execvp( "direccion/del/script/test.sh", &argv[0] );
Este ejecutable toma como primer parametro la ruta del archivo tipo FILE alterno, en nuestro ejemplo utilizamos un bash script ,
y como segundo parametro un argumento.

execve( "/bin/ls", &argv[0], envp[] );
Esta funcion es igual que execv(), sol que tiene un 3er argumento que sirve para especificar el ambiente del proceso creado.

Codigo: ps_010.c
Programa que ilustra el uso de execv(), creando un proceso y haciendo ls a un directorio

== Explicacion ==

Pues bueno, es un 90% parecido a los demas jajajaj , lo unico es que execv() utiliza un array, y ahi guarda los argumentos
conforme al ejemplo de nuestro codigo es, pasar el primer argumento ( arg[0] ) y se le realiza: ls al argumento pasado .

En este caso quedaria asi: execv( "/bin/ls", &argv[0] ), execv(); solo utiliza 2 parametro, como ya habiamos explicado .


Codig: ps_011.c
Programa que ilustra el uso de execvp(), creando un proceso, y realizando ls por medio de un Bash Script

== Explicacion ==
Pues nuevaente los mismo que el ejemplo "ps_010.c" solo que la funcion: execvp(); realiza ls al por medio del bash script,
al programa en C, se le pasa un argumento ( argv[0], que es /home ), despues este es pasado al script ( $1 ), y se
realiza el ls dentro del directorio .

3.1 Teoria

Los Archivos son una de las caracteristicas mas importantes de UNIX, ya que se pueden realizar llamadas de E/S por medio de los
"Descriptores de Archivos", estos abarcan:

• -Terminales
• -Discos
• -Cintas
• -Audio
• -Comunicacion por Red
• -etc....

Esto hace un enfasis a lo que dicen por ahi: "Unix es un Archivo".

Otra caracteristica es su independiencia de los Dispositivos, ya que utilizando las llamadas a Archivos se logra un control de una
Interfaze de Dispositivo.

Un Dispositivo Periferico es una pieza de hardware conectada a un ordenador.

Una Pequena lista de Dispositivos Perifericos son:

• -Discos (CD-ROMs )
• -Cintas
• -Pantallas
• -Teclados
• -Impresoras
• -Ratones
• -Interfaces de Red
• -etc....

Estos Dispositivos son manejados por los Programas de los Usuarios, estos programas realizan el Control de E/S, estos mismo programas
hacen llamadas a ciertos programas del Sistema Operativos, denominados: Controladores de Dispositivo ( Device Driver ).

En base a esto, cada Programador debe aprender un conjunto de llamadas para el control de Dispositivo, Unix a simplificado del mismo modo la Interfaze de Dispositivo, al proporcionar un acceso uniforme a muchos Dispositivos a traves de 5 llamadas que son:

• -open
• -close
• -read
• -write
• -ioctl

Todos los Dispositivos en Unix estan representados por Archivos denominados "Archivos Especiales", los cuales estan localizados en: /dev

---

3.2 Directorios y Rutas de Acceso

Unix Organiza los Archivos y Programas en directorios dentro del Disco Duro ( HDD ), estos arcvhios/programas/directorios, tiene una ruta de acceso a ellos, y estos los Organiza mediante una Organizacion de Arbol, el cual se relacionan con el Archivo a Buscar.

La forma de Arbol que adopta la Organizacion de Archivos es Unix es:


/
Es el nodo principal o raiz del S.O. en la Organizacion de Archivos.

Apartir de aqui podremos formar una ruta de acceso para llegar a un archivo.

Por ejemplo:
Si queremos llegar al archivo: "archivo_01.txt" su ruta es:"/dir_A/dir_B/" y su sintaxis en la shell ( linea de comandos ) es:


Recordemos que una "Ruta de Acceso" es la direccion para llegar a un dato o archivo. Esta direccion puede ser corta o larga, no ahi atajos sino un acceso rapido siempre y cuando sepas su ruta exacta.

Los comandos "cd", "ls" y "pwd" nos seran de utilidad, ya que sus funciones son:

cd
Accesa o Sale de/a un directorio.

ls
Lista los archivos de un directorio o de donde estes posicionado.

pwd
Nos dice la hubicacion que tenemos o donde estamos posicionados.

La funcion getcwd(); nos devuelve la ruta de acceso del directorio de trabajo activo.


size_t size
Especifica la longitud maxima del nombre de la ruta de acceso que puede emplear quien la llama.

char *buf
Si "buf" no es NULL, getcwd(); copia el nombre en "buf".
Si el nombre es mayor que "size" getcwd(); devuelve -1.
Si getcwd(); tiene exito, devuelve el apuntador al nombre de la ruta de acceso.

Codigo: ps_016.c
Imprime la ruta de acceso del directorio de trabajo activo

== Explicacion ==
Bueno la explicacion de codigo es.
Declaramos una Array de Cadena: "char ruta[MAX];", donde MAX esta definido con una dimension de 250. Despues sigue el codigo
y llega el primero codificional, donde realiza la Resolucion de la Ruta de Acceso, que como vemos, antes de correr el programa, accesamos a
"/home/mi_user/bin", y despues ejecutamos el archivo: ./ps_016, donde como resultado nos devuelve la Ruta de Acceso o posiciona donde estamos en la shell. . Los parametro que pasamos a getcwd(); fueron, "ruta", que es la variable ( array cadena ) donde se almacenara la direccion y MAX que es la dimension maxima del buffer ( ruta ).


A continuacion veremos algunas funciones relacionadas con el manejo de Directorios, son:


Proporciona un identificador de bloque al directorio para las funciones de Directorio. Null en caso de error.

Devuelve un apuntador a una estructura que contiene la informacion sobre la siguiente entrada del Directorio. Devuelve NULL al llegar al final del Directorio.

Para posicionar el apuntador al Inicio del Directorio.

Cerrar el identificador.

Devuelva el desplazamiento dentro del Directorio de la Entrada en Uso.

Reposiciona las entradas en uso del Directorio, a la posicion especifica por "loc".

NOTA: las funciones telldir(); y seekdir(); no son parte de POSIX.

Ahora veremos unos ejemplos .

Codigo: ps_017.c
Programa que imprime la lista de Archivos contenidos en un Directorio

== Explicacion ==
Este programa imprime la lista de los directorios/archivos contenidos en un DIRECTORIO xD. Describiremos las partes importabtes del codigo, empezando por el "DIR *dirp;", esta variable es de tipo DIR para usarla junto con la funcion "opendir();", despues se declara una variable para la estrcutura "struct dirent *direntp;" que la obtenemos de "dirent.h", llegamos a la linea donde nos pide el nombre dle directorio, y es guardada en la variable "char dir[80];", despues se le pasa el contenido a la funcion opendir(), "dirp= opendir(dir);", y esta misma devuelve un identificador que sera utilizado en las funciones de Manejo de Directorios. En seguida lee el directorio llamando a "direntp= readdir(dirp);", esta funcion devuelve un puntero a la estructura que contiene el apuntador y es imprimida su informacion llamando al miembro: "direntp->d_name". Y listo, finaliza el programa cerrando el identificador "closedir(dirp);".

---

3.3 Busquedas de Rutas de Acceso y Variable de Ambiente

Bueno antes de empezar , les adelanto que este tema no tiene codigo xD, es mas teorico y de conocimiento de tu sistema unix, de cierta forma puede ser un buen tip o solo un buen conocimiento sobre como busca unix los comandos y lo llama, aqui mismo entra la variable de ambiente que es: "PATH". Asi que si desiden brincarlo, pues perfecto , no ahi problema .

Como todos sabemos, Unix es un sistema que se basa en comandos ( por lo general, aunque cuenta con modo grafico ), y por lo general los usuarios que utilizan UNIX, lo utilizan mas el modo consola ( shell ), y cuando llamamos a programas en la linea de comandos, como por ejemplo:"ls" ( lista archivos ), nosotros llamamos directamente desde la shell a "ls", mas NO lo llamamos desde su ubicacion exacta, que seria( "/usr/bin/ls" ). Aqui es donde entra las Busquedas de Rutas de Acceso de manera sistematica, el sistema unix busca el programa en las rutas contenidas en la variable de ambiente "PATH", utilizando cada uno de ellos. "PATH"  contiene los nomrbes completos de las rutas de acceso de los directorios mas importantes, separados por dos puntos.


Segu nuestra el contenido de la variable de ambiente "PATH", cuando ejecutemos por ejemplo: "ls", va ir a buscar primero al directorio: "/usr/bin", en caso que NO se encuentre ahi, entonces pasa al siguiente directorio: "/etc" y asi sucesivamente. Si tienes cursiosidad por saber la ubicacion de algun programa, solo escribe en la shell: "which programa".

Ejemplo:

Ahora sabemos que la mayoria de los programas de unix estan contenidos en: "/usr/bin", osea que, si por ejemplo hacemos un programa cualquiera y le ponemos: "mi_programa", despues este ejecutable lo pasamos a: /usr/bin.... Con esto nos evitariamos la molesta de llamar a nuestro programa desde su direccion exacta que era ( "./home/user/carpeta/mi_programa" ), asi solamente en la shell escribimos: mi_programa y neustro programa correra de inmediato . Cada ves que actuelicemos nuestro codigo fuente del programa y lo compilemos, ese EJECUTABLE lo copiamos/sustituimos en "/usr/bin" y tendremos nuestro programita actualizado y funcional dentro de la SHELL como cualquier otro programa.

Ejecucion de Nuestro programa antiguamente:

Ejecucion de Nuestro programa contenido originalmente en "/usr/bin"

Si desean saber las rutas a las que accede su variable de ambiente PATH, solo basta hacer esto:


Y de este modo ustedes desiden donde situar nuestro script o programa en C, para ocuparlo futuramente .

---

3.4 Representacion de Archivos en Unix

Unix maneja 2 tipo de archivos que son:

• Archivos Ordinarios
• Archivos Especiales

• Archivos Especiales por Caracter
• Archivos Especiales por Bloque
• Archivos Especiales FIFO

[/list]

*Archivos Ordinario
Estos son archivos comunes realizados por el usuario, archivos de trabajo, documentos, etc...

*Archivos Especiales
Estos archivos representan dispositivos, pero existen 3 derivados que son:

*Archivos Especiales por Caracter
Estos archivos especiales representan dispositivos como terminales.

*Archivos Especiales por Bloque
Estos archivos representando dispositivos de disco.

*Archivos Especiales FIFO
Estos archivos se utilizan para la comunicacion entre procesos.

Unix representa y diferencia los archivos por medio de un inodo, un inodo es una estructura que contiene informacion acerca de un archivo, informacion como:

• tamano
• localizacion
• propietario
• fecha de creacion
• permisos
• fecha de modificacion

Dato importante , tomemos en cuenta que tanto archivos como directorios tienen con ellos asociado un inodo, mas adelante veremos sus diferencias y como los reconoce UNIX.

Para recuperar la informacion contenida en un inodo de un archivo, utilizaremos a sistema stat();


La Estructura "struct stat" contiene los mienbros siguientes:


Funcion para abrir directorio unicamente ( no archivos )

Funcion para abrir archivos y directorios.

Funcion para abrir ligas simbolicas, esta funcion NO es parte de POSIX

Codigo: ps_018.c
Programa que realiza la apertura de un directorio

=== Explicacion ===
La forma de utilizacion es: "./pas_018 directorio".Segun el docido, "struct stat *buf" es una variable a la estructura stat para tomar sus distintos miembros ( segun la tablita ya vista ). En caso de errores para el primer condicional o segundo. En el segundo condicional "if( stat( arg[1], &buf ) == -1 )", si el nombre pasado como argumento NO existe entonces se cumple en este mismo condicional se le pasan dos parametros a stat(), que son: "nombre_del_directorio" y estructura que sera rellenada por medio de buf. en el Tercer condicional "if( buf.st_mode & S_IFDIR )" es solo para comprobar si el modo del archivo a abrir es un fichero o directorio, en este caso "S_IFDIR" comprueba que sea un directorio xD . En caso de exito pues muetra los printf()s , y el ultimo condicional, pues cuando el archivo pasado como argumento NO cumplo con ningun otro condicional, ya que es ovio que NO es un directorio, sino un fichero xD.

Si deseas hacer un ejemplo, pero para abrir ficheros, entonces modifica las lineas siguientes:


Y pues NO es necesari el:  if( buf.st_mode & S_IFDIR )

Ni tampoco necesitas el ultimo condicional "else()", ya que "fstat()" abre tanto ficheros como directorios .

---

3.5 Representacion de Directorios y Enlaces o Ligas

En Unix un directorio es un archivo que contiene una serie de nombres e inodos que se corresponden.

Un Enlace o Liga es una asociacion entre el nombre de un archivo y su inodo, UNIX tiene dos tipos de enlaces o ligas y son:

• Ligas Duras.
• -Ligas Simbolicas ( o suaves ).

Las Ligas Duras, estas ligan directamente lso nombres de los archivos con inodos.

Las Ligas simbolicas ( o suaves ) utilizan el archivo como un apuntador a otro nombre de archivo.

Con el comando "ln" o la llamada al sistema "link", los usuarios pueden crear ligas duras adicionales para archivos.

---

3.6 Representacion de Archivos con Identificadores

Dentro de la Programacion en C, los archivos estan designados por apuntadores de archivo o por descriptores de archivo.

Los Designados por Apuntadores de Archivo, utilizan la Biblioteca estandar de E/S para ANSI C, como son:

• fopen
• fclose
• fscanf
• fprintf
• fread
• fwrite

Y sus Identificadores para los Apuntadores de Archivo de la entrada, salida y el errr estandares son:

• stdin
• stdout
• stderr

Y estan definidos en stdio.h

Los Designados por Descriptores de Archivo, utilizan la Biblioteca estandar de E/S de UNIX, somo son:

• open
• close
• read
• write
• ioctl

Los Identificadores para los Descriptores de Archivo de la entrada, salida y error estandar son:

• STDIN_FILENO
• STDOUT_FILENO
• STDERR_FILENO

Y estan definidos en unistd.h

Por lo tanto los Apuntadores y Descriptores proporcionan Nombres Logicos o Identificadores para llevar acabo la entrada y salida independiente del Dispositivo. Asi del mismo modo un fopen() o un open() proporcionan:

• Una asociacion entre un archivo o dispositivo fisico y
• El Identificador Logico utilizado en el Programa.

Y como es ovio, en Archivos AVANZADOS, se trata el uso de Descriptores de Archivos .

En open() el identificador es un indice en una tabla de descriptores de archivo.
En fopen() el identificado es un apuntador hacia una estructura de archivo.

---

3.7 Descriptores de Archivo

La llamada al sistema open(), asocia un descriptor de archivo con un archivo o dispositivo fisico.


const char *path
Es el archivo o dispositivo fisico al que le asociaremos un descriptor de archivo.

int oflag
Los valores POSIX.1 para oflag estan definidos en fcntl.h, e incluyen:


Se tiene que especificar exactamente una de las banderas o tambien puede especificar varias banderas para obtener un efecto combinado, utilizando el OR ( | ).

...
Este tercer parametro extra, solo se peude activar cuando el campo "oflag" tiene o es O_CREAT, de estemodo se incluira este tercer parametro extra que es de tipo "mode_t" y es el que especifica los Permisos para el Archivo como un valor mode_t.

En Unix los Privilegios posibles son:

• read (lectura), representado por una:  r
• write (escritura), representado por una:  w
• execution (ejecucion), representado por una:  x

Y estos permisos, son aplicados a estos tres tipos:

• Usuario ( el propietario ).
• Grupo ( un grupo, qu esta constituido por un grupo de usuarios ).
• -Otros ( los dema usuarios que NO son miembros de algun grupo, o no son del sistema ).

Estos privilegios estan especificados por separado con la siguiente mascara que esta especificada en POSIX.1:


Estos nombres estan definidos en sys/stat.h y a coninuacion veremos una tabla de los nombres simbolicos y su significado:


La llamada al sistema close();, realiza el cierre de un Descriptor de Fichero.

Acontinuacion veremos un ejemplo sencillo, que ilustre open() y close().

Codigo: ps_019.c
Programa que ilustra el uso de OPEN() y CLOSE(). Si existe se abre, sino solo se crea

== Explicacion ==
Bueno pues no tiene mucha ciencia xD, simplemente open() tiene 3 parametros que son: ubicacion del archivo *.dat, modo en que se tratara el archivo ( Lectura Solamente y/o Se Creara ), y como incluimos el modo O_CREAT, por lo tanto se tiene que introducir un 3er parametro que define los privilegios que tendran los 3 tipos de usuarios para con el archivo, y por los cuales establecimos los modos de: Lecutra Para Usuario Propietario, Lectura para el Gurpo, Lectura para Otros Usuarios. En caso de error nos dira: "Problemas para abrir el archivo...". Se cierra el descriptor y finaliza el programa.

---

3.7.1 Lectura de Ficheros

La llamada a la funcion read(), devuelve la longitud de la cadena leida del descriptor en un valor entero, su sintaxis es la siguiente:

• int fd
es el descriptor de archivo


• void *buffer
es un puntero al buffer donde contendremos la info leida del descriptor


• size_t buffer
es el tamano del buffer

Veremos un codigo......

Codigo: ps_020.c
Programa que ilustra el uso de read()

== Explicacion ==
Se realiza la apertura del archivo en modo de Solo Lectura, se realiza la llamada a read() la cual consigo lleva 3 parametros que son: el Descriptor, el Buffer, y el Tamano del Buffer que tenemos para guardar el archivo, recordemos que el archivo a leer NO debe sobrepasar el tamano que le destinamos al buffer ( el 3er parametro ), sino solo leera hasta el Tamano Especificado, del mismo modo read() retorna el numero de bytes leidos ( pero lee hasta maximo el 3er parametro establecido ). Despues Realizo 2 operaciones que son: Imprimir el Contenido del Archivo y Mostrar el Salto o Saltos que tiene el fichero, y se cierra el fichero.

La llamada a la funcion write() escribe al descriptor abierto con permiso de escritura y retorna el numero de bytes escritos en el fichero, del buffer donde tenemos contenidos los datos a escribir con write(). Su sintaxis es:


Para una mejor comprencion veremos un par de ejemplos.

Codigo: ps_021
Programa que permite leer y escribir en un fichero

== Explicacion ==
Usaremos 2 buffers, BUF es donde almacenaremos los bytes del archivo y BUF2 es donde guardaremos los datos a escribir.
Primeramente realizamos la apertura dle fichero en modo de Lectura y Escritura ( O_RDWR ) y en el caso que NO exista se creara con permisos de Lectura, Escritura y Ejecucion para Usuarios y de Lectura para el Grupos y Otros, se lee el fichero y se reciven los bytes leidos en "bytesrecv", despues se imprime el los bytes leidos.

NOTA: la sintaxis: "buf[bytesrecv]='\0';" inserta el Fin de Linea a los datos del archivo, asi evitamos se impriman datos o residuos indeseados de la memoria.

Despues se pide la cadena nueva a introducir al fichero y, pues cabe mencionar que NO usamos: gets( buf2 ); ya que no es recomendable, usaremos fgets( char *buf, int buf_size, FILE *stream ), en "stream" incluimos la entrada estandart (stdin).
En seguida le realizamos una modificacion a nuestra cadena a introducir, le agregaremos un SALTO DE LINEA AL FINAL y el Fin de Linea , asi al escribirse en el fichero nos brincaremos al proximo renglon con el fin de que en un futuro que se vulva a realizar la misma u otra operacion podamos interactuar con el siguiente renglon y no tener que hacer llamdas especiales para agregar un salto de linea (\n) al fichero . Y por ultimo escribirmos los datos y la funcion write() nos retornara los bytes escritos ( bytesenv ).

Ahora como veremos otro ejemplo bueno xD, este nos ensena la forma de abrir dos descriptores y leer un archivo y copiarlo a otra posicion... seraya con COPY & PASTE con descriptores .

Codigo: ps_022.c


== Explicacion ==
Creo que no es tan necesaria, pero bueno ....

Pues como ya sabemos el archivo a leer es pasado como Argumento 1 y el archivo de Escritura Destino es pasado como Argumento 2, en base a esto se lee el Argumento 1 y la funcion "read()" al leer retorna el peso del archivo expresado en un valor de tipo ENTERO y que viene siendo en bytes . Lo mismo "write()", retorna el peso del archivo Escrito expresado en un valor de tipo ENTERO y que viene siendo en bytes . Ahora, al momento de leer ( read() ), el peso lo guardamos en "bytesrecv" y el contenido en "buf", ahora al momento de escribir ( write() ) como 2do parametro ponemos lo datos ( buf ) y el peso de los datos o bien el tamano del fichero ( bytesrecv ) y write() nos retornara un valor que contendra "bytesenv", con este valor podemos asegurar si la infomacion se escribio correctamente ( ya que debe retornar el mismo valor que contiene "bytesrecv" ). Y al final ya tenemos nuestro archivo copiado en otro directorio. o_O

Veremos otro codigo que ilustra la forma de realizar: lectura, escritura e insercion de texto en el fichero, pero en esta ocacion solo utilizaremos 2 argumentos, el de la OPCION y el FICHERO de entrada .

Codigo: ps_023.c
Programa que realiza copia de ficheros con desciptores

== Explicacion ==
Pues realiza casi lo mismo que el codigo anterior, solo que este utiliza argumentos , y raliza:

• Lectura ( solo lee y muestra informacion/contenido del archivo
• Copia el fichero en otro con el nombre que quieras
• Elimina un fichero
• Escribe datos en un fichero existente ( vaya, Anida )

Lo unico relevante e interesante es que observen bien la forma en que se le pasa el NOMBRE del fichero a crear, al segundo Descriptor de Fichero ( fd_out ), lo que se realiza ANTES de la llamada a dicho OPEN(), de ese modo NO cometamos el error de guardar el nombre mal ( creyendo nosotros que hiria bien ). Por ultimo solo ver como se utiliza READ(), WRITE() y REMOVE().



La funcion ioctl() nos proporciona un medio para obtener informacion sobre el estado de un dispositivo o para establecer opciones de control para el mismo.

En caso de exito "ioctl()" retorna un 0 y en caso de error un -1 y setea a "errno" con un valor de los siguientes:


Otras funciones interesantes a ioctl() son:

La funcion ioperm() establece el bit de permiso de acceso a los Puertos para el proceso para "num" bytes, empezando desde la direccion del puerto "desde", al valor "encender". Su utilizacion requiere permisos de "root".
Devuelve 0 en caso de exito y un -1 en caso de error, y setea a "errno" con un valor.

Solo se pueden especificar los primeor puertos 0x3fff puertos de E/S, para utilizar mas puertos se debe utilizar iopl(). Dato importante tambien es que los permisos se Hereda en un fork(), pero si estan en un exec().


La funcion iopl() cambia el nivel del privilegio de E/S del Proceso en Curso, La funcion iopl() tiene que emplearse cuando se desea acceder a los puertos que estan mas haya del rango 0x3ff. Ademas los permisos son heredados por fork() y exec().

La funcion iopl() devuelve 0 en caso de exito y devuelve -1 en caso de error, y setea a "errno" con un valor apopiado:

---

3.7.2 Entradas y Salidas sin Bloqueo

Antes de empezar con el temita . Quiero recalcar que es muy importante poner atencion y entender bien este tema ya que los siguientes temas se basaran mucho en este, por la razon de que empezaremosa  ver codigos donde realizaremos aperturas de descriptores de archivos desde nuestros Procesos . Asi que debemos dejar claras algunas cosillas en este tema .

Cuando un procesos intenta leer de un bufferm este lo bloquea, hasta esperar a que la entreda de lectura este disponible para leer, osea, esperara en el "read()". Dicho de otro modo seria que, imaginemos que tenemos 2 Procesos, ene ste caso si intentamos leer un fichero ( abierto previamente ), dependiendo quien lo haga primero, uno de los dos Procesos tiene que esperar a que el Proceso que esta leyendo, termine, y asi continua a realizar la lectura el Procesos que sigue, asi continuamente deben ir Esperando a que se desocupe la entrada para poder realizar la lectura ( read() ).

El Bloque de E/S presneta un problema para un proceso, ya que peude darse el caso que un proceso este vigilando varias entradas para realizar una lectura. El Proceso no tiene la oportunidad de saber que Entrada es la que llega primero, ya que si al intentar leer de un buffer resulta que este esta ocupado, puede darse el caso en que el Proceso se vea Congelado Indefinidamente.

En este punto entra el Emple de E/S sin Bloqueo, que nos ayuda a resolver el Problema de que un Procesos espera para poder Leer, o bien evitar congelamientos Indeifinidos. Para resolver este problema solo es cuestion de configurar las Banderas de Control apropiadas, de esta forma el read() puede intentar realizar una lectura, y si se esta ocupada la entrada, el read() no se vera en la necesidad de bloquear ( esperar o congelarse ), solamente regresara de inmediato ya que NO se encontro disponible la entrada .

Para llevar acabo la operacion de E/S sin Bloqueo se debe utilizar la bandera O_NONBLOCK asociada con el Descriptor de Archivo. Del mismo modo la llamada a fcntl() realiza modificaciones a las Banderas al estar ya asociadas con un objeto que tiene un Descriptor de Archivo.


La funcion fcntl() realiza mucha soperaciones sobre los Descriptores de Archivos dependiendo el "comando" que se le introduzca ( pero recordemos que nosotros solo modificaremos banderas, para evitar Bloqueos ).

int fd
[li]Es el Descriptor de Fichero asociado.[/li]

int comando
[li]Es el comando a introducir para realizar una operacion sobre el Descriptor de Archivo, sus comandos son:[/li]


long arg|struct flock *lock
[li]Es el valor a enviar, puede ser del tipo ARGUMENTO o ESTRUCTURA, dependiendo la funcion a realizar . Mas informacio en la tablita de arriba .[/li][/list]

La funcion fcntl() en caso de exito retornara un valor que cuyo exito dependera del COMANDO que se utiliza y el valor que se espera, ejemplo:

F_DUPFD
[li]El valor del nuevo Descriptor.[/li]

F_GETFD
[li]El valor de la Bandera.[/li]

F_GETFL
[li]El valor de la Bandera.[/li]

F_GETOWN
[li]El valor del Propietario del Descriptor.[/li]

F_GETSIG
[li]Valor de la Senal Enviada, cuando la lectura o la escritura son posibles, o 0 para el comportamiento tradicional de SIGIO.[/li]

CUALQUIER OTRA ORDEN
[li]Cero[/li][/list]

Y en caso de Error se devolvera un -1 y setara a errno con un valor: