HALT !

Fork, como un tenedor

El fork es una de las herramientas que nos brinda linux para manejar varios procesos, es tremendamente simple la sintaxis: 

pid_t fork(void);

Lo dificil no es entender como funciona si no que hace, segun el manual de linux: 
    
    - crea un nuevo proceso duplicando el proceso original
    - el proceso hijo tiene su propio pid
    - el ppid() del proceso hijo es el pid del proceso original
    - el hijo no tiene señales pendientes
    - el hijo no hereda el valor de los semaforos

Valor de retorno:
    En el padre: pid del hijo
    en el hijo: 0


Y nada mejor que un ejemplo:

#include ...

int main(){

 int hijo;


printf("soy un solo proceso ! \n");
sleep(1);

hijo=fork();//hacemos un proceso hijo

printf("somos dos procesos!\n");
sleep(1);


if (hijo==0){//vemos si es el hijo

printf("soy el hijo!\n");
sleep(1);
printf("sigo vivo");
}
else{//si no es el padre

printf("soy el padre\n");

}

printf("ya morí ... :S \n");//ambos ejecutan esto

return 0;};
  


espero que sirva para aclarar algo, den +1.

Directorios y C

 Por  momentos uno quiere saber donde se encuetra, buscar archivos, ect ...

 Para eso usaremos dirent.h una libreria para manejar directorios.

#include <sys/types>
#include <dirent.h>

int main(){

 DIR *my_dir; // estructura que guarda el directorio
 struct dirent *my_file;
 
 my_dir=opendir("/home/un_dir"); // abrir un directorio

my_file=readdir(my_dir); //leemos el primer nodo del directorio

do{

    printf("%s es un archivo del directorio\n", my_file->name);

 
    my_file=readdir(my_dir); //leemos los otros nodos del directorio

}while(my_file!=NULL)//cuando no hay mas nodos que leer

 rewinddir(my_dir); // rebobinamos el directorio

 closedir(my_dir); //no es necesario, pero es buena practica

return 0;}

hay que tener en cuenta que struct dirent puede variar de distro a distro asi que siempre es recomendable fijarse en el manual.



pd: den +1
pd2: si lo van a compilar cambien el directorio que van a abrir

signal y sigaction, "that won't kill me"

Hay momentos en que a nuestros programas les caen señales, estas en general matan al proceso, para evitar este comportamiento existen las funciones signal y sigaction aunque si bien ambas sirven es recomendable utilizar la segunda.

nota: SIGKILL (9) no puede recivirse, simplemente mata al procesos sin mas.

Ahora a ver signal, la sintaxis es la siguiente:

*handler signal(int signal, *handler)

Signal es el identificador de la signal y handler es el nombre de la funcion que se ejecuta en la llegada de la signal, sin parametros ni parentesis, recibe el numero de señal. 

completar mas tarde.
ayuda #man signal; #man sigaction ;#kill -l 

Iron man III ...why?

No soy un fan de iron man ni mucho menos, pero puedo decir que la pelicula deja mucho que desear.

 Primero los efectos especiales gritan "standard hollywood", sobretodo si uno vio Avengers o Trnasformers III. Si bien parecen tener 10% mas de calidad, la escena final (spoiler) cuando explotan las armaduras se convierten en fuegos artificiales y true-mandarin parece salido de un videojuego barato.

 Si bien todo eso era mas que esperado la historia es tremendamente pobre y mal narrada, empezamos en 1999 en una especie de fiesta politica para (sin mucha explicacion de por medio) pasar a la actualida donde encontramos a un nuevo Tony con ataques de panico. Como si ya no estubiera bastante feo el panorama aquellos que lean el comic les recomiendo un lavado de cerebro antes de ver la pelicula, pues el mandarin es un actor (un actor haciendo de actor que hace a mandarin para ser precisos).

Bueno, espero que disfruten la pelicula, la banda sonora es muy buena. (aunque no tanto como en las anteriores).

Argumentos, volvieron en forma de tazos

Ahora vamos a empezar con un poco del viejo y querido C, para los que hayan usado linux seguramente vieron como la mayoria de los comandos tienen parametros, anteriormente vimos un modo rudimentrario de obtenerlos "a lo bestia" en bash (por si no recuerdan).

Bueno, como veran no es muy facil pasar muchos argumentos, y mucho menos si los pasamos en desorden !

Para solucionar este problema existe la función getopt en c. Las opciones que reconoce son ademas las standard de linux con "-" al principio.

sintaxis:
 int getopt( int argc, char* argv[], const char* optstring )  

"int argc" y "char* argv[]" son los parametros de main, que para los que aun no estan enterados la funcion main puede escribirse tanto como:

int main()

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

la segunda forma toma en consideracion que se le pueden pasar lineas de parametros. 

const char* opstring, es una cadena que contiene las opciones validas que se le pueden pasar a nuestro programa, por ejemplo si ponemos "ns" las opciones validas son -s -n -sn -ns cualquiera de esas combinaciones.Si ponemos "a:" significa que a recive un parametro obligatorio, si ponemos "a::" el parametro es opcional.

Pero para entender nada mejor que un ejemplo (que les puede servir de plantilla):

#include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[]){
                                 
int opt;                         
char *opciones="apl::b:";                       
                                               
while((opt=getopt(argc,argv, opciones)) != -1){
switch(opt){                                   
                                                case 'a': printf("\n\nopcion A\n\n");break;    case 'b': printf("\n\nopcion B con argumento %s\n\n", optarg);break;    case 'l': printf("\n\nopcion B con argumento opcional %s\n\n", optarg);break;   
    }
}    
return 0;
}        


pd: a nadie le importa la ortografia, solo a los homos.

GCC, compilando en linux

Una de las razones por las que siempre se escucha que linux es un SO para desrrolladores es el hecho de que en todas las distribuciones viene incluido por default gcc un compilador de C/C++ bastante potente y facil de usar. 

Para empezar a compilar tenemos que movernos a la carpeta en la que estan los sources

# cd /home/Documents/mis-sources

Para una compilacion simplemente ejecutamos

# gcc -o nombre_salida nombre.c

el parametro -o le da un nombre al archivo de salida que sino se llamaria "a.out" por default.

Aveces tambien es necesario incorporar librerias externas, como cuando usamos los threads de linux. No solo basta con incluir el archivo de cabezera sino que tambien hay que linkear el codigo fuente. Para eso solo agregamos al final el nombre de la libreria a agregar. Para estar mas seguros de que escribir nunca esta de mas buscar en el manual de la funcion (man pthread_create)

# gcc -o t_prog prog.c -pthread

Tambien es posible decirle a gcc que no haga linking es decir genera un archivo objeto(usualmente con extencion .o) que no es un ejecutable y que luego puede añadirse a otros programas como una libreria con la opcion -C.

# gcc -C -o cosas.o cosas.c
# gcc -o programa prog.c cosas.o 

Con esto el archivo "programa" va a contener el codigo compilado de prog.c y el de cosas.c, esta funcionalidad es muy util si queremos re utilizar o compartir codigo sin tener que compilar lo mismo una y otra vez.