Академический Документы
Профессиональный Документы
Культура Документы
Instructores: Cinthia Lvaro Arroyo Jazmn Ivette Snchez Reyes Julio Csar Saynez Fabin
4. Procesos
4.1. Que es un proceso 4.2. Atributos de un proceso 4.3. Manipulacin de procesos 4.3.1. Creacin de procesos 4.3.2. Esperas en procesos 4.3.3. Eliminacin
5. Seales
5.1. 5.2. 5.3. 5.4. Qu es una seal? Seales disponible Envi de seales Intercepcin de seales
7. Programacin TCP/IP
7.1. Manejo de Conectores 7.1.1. Bind 7.1.2. Listen 7.1.3. Connect 7.1.4. Accept 7.2. Lectura y escritura de sockets TCP/IP
Requisitos:
Conocimientos bsicos del Lenguaje C. Manejo de Sistema Operativo Unix. Manejo de vi.
Lunes
Martes
2.MAKE
Mircoles
Jueves
Viernes
5.Seales
Semana 1
1.GCC 3.Contraseas
4.Procesos
Semana 2
7.Programaron TCP/IP
Invocacin de gcc
Para utilizar gcc, escriba el nombre del archivo fuente de C y utilice la opcin o para especificar el nombre del archivo de salida. gcc preprocesar, compilar, ensamblara y vinculara (link) el programa, generando un archivo ejecutable, a menudo denominado binario. La sintaxis ms simple se ilustra aqu: # gcc archivo_entrada.c [-o archivo_salida] archivo_entrada.c es un archivo de cdigo fuente en C y o establece que el nombre del archivo de salida ser archivo_salida. Los corchetes ([]) indican que los argumentos son opcionales. Si el nombre del archivo de salida no se especifica , gcc lo denominara a.out como opcin predeterminada. EJEMPLO
1 2 3 4 5 6 7 8 9 10
/* * hola.c "Hola Mundo!" */ #include <stdio.h> int main(void) { puts("Hola Mundo de programadores en UNIX!"); return 0; }
para compilar y correr este programa, escriba: #gcc hola.c -o hola #./hola El comando que ejecut el programa hola inclua especficamente el directorio corriente, representado con un punto(.).
Cmo sabe gcc cmo procesar los archivos? Se basa en las extensiones de los mismos para determinar cmo procesar correctamente cada archivo. Las extensiones ms comunes y sus interpretaciones se lista a continuacin.
Tipo de archivo Cdigo fuente de lenguaje C Cdigo fuente de lenguaje C++ Cdigo fuente de C preprocesado Cdigo fuente de C++ preprocesado Cdigo fuente de lenguaje ensamblador Cdigo objeto compilado Cdigo de biblioteca compilado
Figura 1 La compilacin de un programa consiste de varias etapas Uno puede recrear estas etapas manualmente , avanzando por el proceso de compilacin un paso ala vez. Para indicarle al gcc que detenga la compilacin luego del preprocesado, utilice la opcin E de gcc, como se indica a continuacin: #gcc -E archivo_entrada.c -o archivo_salida.cpp El paso siguiente consiste en compilar el archivo preprocesado para convertirlo en cdigo objeto utilizndola opcin c de gcc. La opcin x se utiliza para indicar a gcc que comience la compilacin a partir de cierta etapa. La sintaxis correcta para esta etapa es: #gcc -x cpp-output -c archivo_entrada.cpp -o archivo_salida.o Linkeando el archivo objeto, finalmente, se obtiene su imagen binaria. El comando que llevara a cabo la etapa de vinculacin sera algo as como la siguiente lnea: #gcc archivo_entrada.o -o archivo_sailda EJEMPLO Volviendo al ejemplo anterior, primero el preprocesador #gcc E hola.c o hola.cpp
Si examina hola.cpp con editor de texto como vi ver el contenido del archivo de encabezamiento stdio.h ha sido efectivamente insertado en el cdigo fuente, junto a otros smbolos del preprocesador. Lo siguiente es un extracto de hola.cpp: int fileno(FILE *_stream); FILE * fdopen(int _fildes, const char *_type); int pclose(FILE *_pf); FILE * popen(const char *_command, const char *_mode); extern FILE __dj_stdprn, __dj_stdaux; void int int int int _djstat_describe_lossage(FILE *_to_where); _doprnt(const char *_fmt, va_list _args, FILE *_f); _doscan(FILE *_f, const char *_fmt, void **_argp); vscanf(const char *_format, va_list _ap); vsscanf(const char *_s, const char *_format, va_list _ap);
El paso siguiente es compilar hola.cpp para convertirlo en cdigo objeto: #gcc x cpp-out -c hola.cpp -o hola.o Se debe utilizar la opcin x para indicarle a gcc que comience la compilacin a cierta altura, en este caso, a partir del cdigo fuente preprocesado. Cuando se efecta el linkeo del cdigo objeto, finalmente, se crea un archivo binario. #gcc hola.o o hola
EJEMPLO 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1 2 3 4 5 6 7 8 9 10 /* * mostrar.c Controlador de pantalla */ #include <stdio.h> #include "msg.h" int main(void) { char msg_hi[] = {"Hola, Programador!"}; char msg_bye[] = {"Adios, programados!"}; printf("%s\n", msg_hi); prmsg(msg_bye); return 0; } /* * msg.c - Funcion definida en msg.h */ #include <stdio.h> #include "msg.h" void prmsg(char *msg) { printf("%s\n", msg); }
1 2 3 4 5 6 7 8 9 10
/* * msg.h - Encabezado de msg.c */ #ifndef MSG_H_ #define MSG_H_ void prmsg(char *msg); #endif /* MSG_H_ */
El comando para compilar estos programas, por lo tanto para crear hola2 es: #gcc msg.c mostrar.c -o hola2
Opciones y argumentos
La lista de opciones de lnea do comando que acepta gcc ocupara varias paginas, de modo que la tabla presenta solo las ms comunes. Opciones de lnea de comando de gcc
Opcin -o non_archivo
Propsito
Designa el archivo de salida nom_archivo (no necesariamente cuando se compila cdigo objeto). Si no se especifica el nombre de este archivo, la opcin predeterminada es a.out. Compilar sin linkear. Define un macro de preprocesador too con un valor bar en la lnea de comandos. Sita la rota de acceso al directorio especificado en ruta_dir al comienzo de la lista de directorios en que gcc busca los archivos a incluir por la presencia de directivas #include. Sita la ruta de acceso al directorio especificado en ruta_dir al comienzo dc la lista de directorios en que gcc busca archivos de biblioteca. Como opcin predeterminada, gcc linkea bibliotecas compartidas. Linkea bibliotecas estticas Linkea la biblioteca foo. Incluye en el archivo binario informacin estndar de depuracin. Incluye en el archivo binario muchsima informacin de depuracin que slo puede interpretar el depurador del GNU, gdb. Optimiza el cdigo compilado. Esto es equivalente a especificar -01. Especifica un nivel de optimizacin n, 0<=n<=3. Coloca et compilador en modo ANSI/ISO C, no permitiendo extensiones GNU que generen conflictos con dichos estndares. Muestra todas las advertencias que requiere el ANSI/ISO C estndar. Muestra todos los errores que requiere el ANSI/ISO C estndar. Habilita el apoyo pare a sintaxis del C de Kernighan y Ritchie (si el lector no comprende lo que significa esto, no se preocupe por ello; baste con saber que Kernighan y Ritchie fueron los diseadores del C original). Suprime todos los mensajes de advertencia. Exhibe todas las advertencias generalmente aplicables que puede proveer gcc. Para ver advertencias especificas, utilice Wwarning. En lugar de generar advertencias, gcc convertir las advertencias en errores, deteniendo la compilacin. Emitir una lista de dependencias compatible con make. til depara crear una makefile en un proyecto complicado. Muestra los comandos utilizados en cada etapa de compilacin.
-Lruta_dir
-w -Wall
-werror -MM -v
Archivos de Biblioteca y de Inclusin Si se dispone de archivos de biblioteca o de inclusin situados en ubicaciones no estandar, las opciones Lrura_dir y Iruta_dir permiten especificar dichas ubicaciones y asegurar que se busquen los respectivos archivos en esas ubicaciones antes de hacerlo en las estndar(las asignadas por el compilador como predeterminadas).
La opcin l le indica al linker que tome cdigo objeto desde la biblioteca especificada.
Nota Una convencin en UNIX requiere que las bibliotecas se denominen lib{algn nombre}, y gcc, al igual que la mayora de los compiladores de UNIX y de Linux, se basa en dicha convencin. Si no utiliza la opcin l cuando vincula bibliotecas o no provee una ruta de acceso a la biblioteca a ser vinculada, la etapa de linkeo no tendr xito y gcc emitir un mensaje de error debido a la referencia sin definir a nombre_de_funcin.
Creacin de makefiles
As que, cmo logra realizar make sus mgicas proezas? Utilizando un makefile que es una base de datos en formato texto que contiene reglas que le indican a make qu construir y cmo construirlo. Cada regla consiste de lo siguiente: Un target, la cosa que en definitiva make trata de crear. Una lista de una o ms dependencias, generalmente archivos, requeridas para construir el target. Una lista de comandos a ser ejecutados con el fin de crear el target a partir de las dependencias entre archivos especificadas.
Cuando se lo invoca, el make busca un archivo denominado GNUmakefile, makefile, o Makefile, en ese orden. Por alguna razn, la mayora de los programadores de Linux utiliza esta ltima forma, Makefile. Las reglas de un makefile tienen la siguiente forma general: objetivo : dependencia [dependencia] [] comando [comando] PRECAUCIN El primer carcter de un comando debe ser el carcter de tabulacin; ocho espacios no son la misma cosa. Esto a menudo toma a la gente desprevenida, y puede resultar un problema si su editor preferido convierte servicialmente cada tabulador en ocho espacios. Si uno trata de emplear espacios en lugar de tabuladores, make exhibir el mensaje Missing separator y se detendr.
Target es habitualmente el archivo binario o el archivo objeto que uno quiere crear. Dependencia es una lista de uno o ms archivos requeridos como fuente con el fin de crear target. Los comandos son los diversos pasos, tales como la invocacin del compilador o los comandos de interfaz, necesarias para crear el target. A menos que se lo especifique de forma expresa, make realiza todo su trabajo en el directorio corriente de trabajo. Como logra saber make cundo(re)construir un archivo? La respuesta es simple: si un target especificado no se encuentra presente en algn lugar donde make pueda hallarlo, make lo (re)construye. Si el target no existe, make compara la fecha y hora del objetivo (target) con la fecha y hora de los archivos de los cuales ste depende. Si al menos una de dichos archivos es ms nueva que el target, make
reconstruye el target, interpretando que el hecho de que ese archivo sea ms nuevo es seal de que debe incorporarse al mismo algn cambio de cdigo. Este makefile de muestra permitir que la explicacin sea ms concreta. Seria el makefile necesario para desarrollar un editor de textos. Los signos de numeral (#) inician las lneas de comentarios, rm es una variable predefinida que activa un programa de eliminacin de archivos. # Makefile de muestra editor : editor.o pantalla.o teclado.o gcc -o editor editor.o pantalla.o teclado.o editor.o : editor.c editor.h teclado.h pantalla.h gcc -c editor.c pantal1a.o : pantalla.c pantalla.h gcc -c pantalla.c teclado.o : teclado.c teclado.h gcc -c teclado.c clean: rm editor *.o Para compilar editor, se debera teclear sencillamente make en el directorio donde se encuentre el makefile. As de simple. Este makefile tiene cinco reglas. El primer target, editor, se denomina target predeterminado; este es el archivo que make en definitiva trata de crear, editor tiene tres archivos de los cuales depende: editor.o, pantalla.o y teclado.o; estos tres archivos deben existir para que se pueda construir editor. La lnea siguiente consiste en el comando que debe ejecutar make para crear editor. Como se recordar del captulo 1, Compilacin de programas, esta invocacin del compilador construye un archivo ejecutable denominado editor a partir de los tres mdulos objeto, editor.o, pantalla.o y teclado.o las tres reglas que vienen despus le indican a make cmo construir cada uno de los mdulos objeto. La ltima regla le indica a make que haga limpieza, eliminando todos los archivos objeto que contribuyen a formar editor. Aqu es donde el valor de make se hace evidente: normalmente, si uno trata de construir editor utilizando el comando de compilador de la lnea 2, si los archivos de los cuales ste dependiera no existiesen gcc producira un tajante mensaje de error y terminara, make, en cambio, despus de haber determinado que editor requiere esos archivos para ser compilado, primero verificara que existiesen y, si no fuera as, ejecutara los comandos necesarios para crearlos. Luego retornara a la primera regla y creara del archivo ejecutable de editor. Por supuesto, si a su vez las respectivas dependencias para los componentes, teclado.c o pantalla.h, no existiesen, make renunciara tambin, porque no dispondra de los targets denominados, en este caso, teclado.c y pantalla.h.
make
Invocar a make slo requiere teclear make en el directorio donde se encuentre el makefile. Por supuesto, igual que la mayora de los programas de GNU, make acepta una considerable cantidad de opciones de lnea de comandos. Las opciones ms comunes se listan en la tabla siguiente.
Propsito
Utiliza el makefile denominado archivo en lugar de uno de los de nombre estndar (GNUmakefile, makefile o Makefile). Exhibe los comandos que ejecutarla make sin en realidad ejecutarlos. til para comprobar un makefile. Aade nombre_dir a la lista de directorios donde buscar make los makefiles incluidos. Ejecucin silenciosa, sin imprimir los comandos que va ejecutando make. Imprime nombres de directorios cuando make cambia de directorios. Ejecuta make como si archivo hubiese sido modificado. Igual que -n, muy til para comprobar makefiles. Deshabilita todas las reglas integradas en make. Imprime gran cantidad de informacin para depuracin. Normalmente, make se detiene si un comando retorna un cdigo de error distinto de cero. Esta opcin deshabilita este comportamiento. Seguir ejecutndose aun si uno de los targets no se lograra construir. Normalmente, si uno de los targets no se lograra construir, make terminara. Correr N comandos en paralelo, donde N es un valor entero pequeo distinto de cero.
Este comportamiento de make se desprende de la explicacin sobre su funcionamiento convencional: cuando encuentra el target clean, make determina si existen o no dependencias y, como clean no tiene dependencias, make interpreta que ese target se encuentra actualizado. Para construir dicho target, uno tiene que teclear make clean. Si efectivamente existiera, sin embargo, un archivo denominado clean, make lo detectara. Pero, como carecera de dependencias, make supondra que el mismo se encuentra ya actualizado y no ejecutara los comandos asociados con el target clean. Para administrar adecuadamente esta situacin, utilice el target especial de make .PHONY. Todas las dependencias del objetivo (target) .PHONY sern evaluadas como habitualmente, pero make no tomar en cuenta la presencia de un archivo cuyo nombre coincide con el de una de las dependencias de .PHONY y ejecutar de todos modos los comandos correspondientes.
Variables
Con el fin de simplificar la edicin y mantenimiento del makefile, make le permite a uno crear y utilizar variables. Una variable de make es simplemente un nombre definido en un makefile y que representa una cadena de texto; este texto se denomina valor de la respectiva variable. make puede distinguir entre cuatro tipos de variables: variables definidas por usuario, variables de entorno, variables automticas y variables predefinidas. Su empleo es idntico.
VARIABLES DEFINIDAS POR USUARIO Las variables de un makefile se definen empleando la forma general: NOMBRE_DE_VARIABLE = valor [] Por convencin, las variables de un makefile se escriben todas en maysculas, pero esa no es una condicin necesaria. Para obtener el valor de NOMBRE_DE_VARIABLE, encierre el nombre entre parntesis precedido con un signo $: $(NOMBRE_DE_VARIABLE) NOMBRE_DE_VARIABLE se expande de modo de hacer disponible el texto almacenado en valor, el valor colocado del lado derecho de la sentencia de asignacin. Generalmente las variables se definen al comienzo de un makefile. La utilizacin de variables en un makefile es antes que nada una conveniencia. Si el valor cambia, uno debe efectuar slo un cambio en lugar de muchos, simplificndose as el mantenimiento del makefile. Este makefile muestra cmo funcionan las variables definidas por el usuario. Utiliza el comando echo de la interfaz a fin de demostrar cmo se expanden las variables EJEMPLO. PROGRAMAS = progl prog2 prog3 prog4 .PHONY : volcar volcar : echo $(PROGRAMAS) $ make -s volcar progl prog2 prog3 prog4 EXPANSIN RECURSIVA CONTRA EXPANSIN SIMPLE DE VARIABLES make en realidad emplea dos tipos de variables, recursivamente expandidas y simplemente expandidas. Las variables recursivamente expandidas son expandidas tal cual cuando son referenciadas, o sea, si la expansin contuviese otra referencia a una variable, esta ltima ser asimismo expandida. La expansin contina hasta que no queden ms variables por expandir, a lo que se debe el nombre de esta modalidad, expansin recursiva. Por ejemplo, consideremos las variables DIR_SUPERIOR y DIR_FUENTE, definidas como sigue: DIR_SUPERIOR = /home/carlos/miproyecto DIR_FUENTE = $(DIR_SUPERIOR)/fuente As, DIR_FUENTE tendr el valor /home/carlos/miproyecto/fuente. Esto funciona como se lo esperaba y deseaba. Sin embargo, uno no puede agregar texto al final de una variable definida con anterioridad. Consideremos la definicin de la siguiente variable: CC = gcc
CC = $(CC) -g
Claramente, lo que en definitiva se desea es obtener CC = gcc g. Esto no es lo que se obtendr, sin embargo. Cada vez que se la referencia $(CC) es expandida recursivamente, de modo que uno termina con un lazo infinito: $(CC) insistir en expandirse a $(CC), y nunca se llegar a la opcin g. Afortunadamente, make detecta esto e informa un error:
-
EJEMPLO Este makefile utiliza variables de expansin simple en lugar de las variables de expansin recursiva del primer ejemplo. CC := gcc CC += -g hola: hola.c $(CC) hola.c -o hola $make hola gcc -c hola.c -o hola VARIABLES DE ENTORNO Las variables de entorno son las versiones de make de todas las variables de entorno de la interfaz. Cuando se inicia, make lee todas las variables definidas en el entorno de la interfaz y crea variables con los mismos nombres y valores. Sin embargo, las variables del mismo nombre presentes en el make file invalidan las variables de entorno, de modo que tenga cuidado.
-
EJEMPLO Este makefile utiliza la variable $HOME que hereda de la interfaz como parte de una regla para construir el target hola. hola : $(HOME)/hola.c gcc $(HOME)/hola.c -o $(HOME)/hola $ make all make: *** No hola. Stop.
rule
to
make
target
/home/carlos/hola.c,
needed
by
El mensaje de error exhibido es un tanto engaoso. Cuando make no pudo encontrar /home/carlos/hola.c, listado como dependencia del target hola, interpret que deba de alguna manera construir primero hola.c. Sin embargo, no pudo encontrar una regla para ello, de modo que exhibi el mensaje de error y termin. Lo que se pretenda, sin embargo, era demostrar que make hered la variable $HOME del entorno de la interfaz (/home/carlos, en este caso). VARIABLES AUTOMTICAS Las variables automticas son variables cuyos valores son evaluados cada vez que se ejecuta una regla, basndose en el target y en las dependencias de esa regla. Las variables automticas se emplean para crear reglas patrn. Las reglas patrn son instrucciones genricas, tales como una regla que indique cmo compilar un archivo .c arbitrario a su correspondiente archivo .o. Las variables automticas tienen un aspecto bastante crptico. La tabla contiene una lista parcial de variables automticas. Variables automticas Descripcin
Representa el nombre de un archivo target presente en una regla
Representa la porcin bsica (o raz) de un nombre de archivo. Representa el nombre de archivo de la primera dependencia de una regla Se expande para dar lugar a una lista delimitada por espacios de todas las dependencias de una regla Se expande para dar lugar a una lista delimitada por espacios de todas las dependencias de una regla que sean ms nuevas que el target Si el target designado se encuentra en un subdirectorio, esta variable representa la parte correspondiente a los directorios de la ruta de acceso al mismo Si el target designado se encuentra en un subdirectorio, esta variable representa la parte correspondiente al nombre del archivo de la ruta de acceso al mismo
EJEMPLO CFLAGS := -g CC := gcc .c.o: $(CC) $(CFLAGS) -c $*.c hola: hola.o $(CC) $(CFLAGS) $< -o $@
$make hola gcc g c hola.c gcc -g hola.c -o hola El primer target es una regla implcita o predefinida. Establece que, para cada nombre de archivo que tenga la extensin .c, se crear un archivo objeto de extensin .o, utilizando el comando $(CC) $(CFLAGS) -c. El trmino $*.c representa cualquier archivo del directorio corriente que tenga la extensin .c ; en este caso, hola.c. VARIABLES PREDEFINIDAS El make predefine otras variables que son utilizadas ya sea como nombres de programas o para transferir indicadores y argumentos a esos programas. La tabla siguiente lista las variables predefinidas de make de empleo ms frecuente. Variables predefinidas para nombres de programa e indicadores Variable AR AS CC CPP
RM
Descripcin Nombre de archivo del programa de mantenimiento de archivos compactados Nombre de archivo del ensamblador Nombre de archivo del compilador de C Nombre de archivo del preprocesador de C
Programa para eliminar archivos
Indicadores para el programa de mantenimiento de archivos compactados Especificadotes de opciones para el ensamblador Especificadotes de opciones para el compilador de C Especificadotes de opciones para el preprocesador de C Especificadotes de opciones para el linker
Las reglas implcitas simplifican el mantenimiento de los makefiles. Supongamos que un makefile tuviese estas dos reglas prog : prog.o
prog.o : prog.c las dos reglas listan dependencias, pero no reglas para construir sus targets. En lugar de terminar su ejecucin, sin embargo, make intentar encontrar y utilizar reglas implcitas que le permitan construir los targets ( se puede verificar que make busca reglas implcitas observando la salida generada por el depurador cuando se utiliza la opcin -d).
Reglas patrn La reglas patrn proveen una manera de que uno defina sus propias reglas implcita. Las reglas patrn tienen el aspecto de reglas normales, excepto que el target contiene exactamente en carcter % que representa cualquier cadena no vaca. Las dependencias de una regla de este tipo tambin emplean % con el fin de coincidir con el target, por ejemplo: %.o: %.c Esto le indica a meke que constuya cualquier archivo objeto archivo.o a partir de un archivo fuente correspondiente denominado archivo.c. Esta regla patrn tambin resulta ser una de las reglas patrn predefinidas de make pero, igual que lo que sucede con las variables predefinidas, uno puede redefinirlas para acomodar sus propias necesidades. %.o : %.c $(CC) c $(CFLAGS) $(CPPFLAGS) $< -o $@
EJEMPLO 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 /* * * * */ mipasswd.c Este programa muestra el uso de la funcin crypt para compilar gcc mipasswd.c -o mipasswd -lcrypt
#include<stdio.h> #include<crypt.h> int main(int argc,char *argv[]) { if(argc!=3) printf("Uso: mipasswd clave sal\n"); else printf("clave: %s \n",crypt(argv[1],argv[2])); }
Si la sal es la cadena A1, y La contrasea del usuario es MiClave la funcion crypt(3) devolver: A1VAvbm85K.wY El algoritmo MD5 MD5 es un algoritmo hash, supone una mejora sobre DES en varios aspectos: Contraseas de longitud infinita. No existe la limitacin de ocho caracteres. Resultado mucho ms largo. Lo siguiente es un ejemplo de un resultado obtenido con MD5: $1$rVh4/3C$.xtBPA85bzw/2qBTOYY/R
Exportable. No ha sido desarrollado por el gobierno de lo Estados Unidos, por lo que puede exportarse sin problema alguno fuera de ese pas.
Bibliografa:
Kart Wall, Programacin en Linux con ejemplos, Editorial Prentice Hall. Fco. Manuel Mrquez, UNIX, Programacin avanzada, Editorial Alfaomega.