Вы находитесь на странице: 1из 20

LENGUAJE C PARA UNIX

Instructores: Cinthia Lvaro Arroyo Jazmn Ivette Snchez Reyes Julio Csar Saynez Fabin

Curso de C para Unix Temario


1. Compilador gcc (GNU)
1.1. 1.2. 1.3. 1.4. 1.5. Introduccin Preprocesador Compilador Ensamblador Vinculador (Linker)

2. Control del proceso de compilacin: Utilizacin de make


2.1. Creacin de makefiles 2.2. Invocacin de make

3. Cmo funcionan las contraseas en UNIX


3.1. /etc/passwd 3.2. Algoritmos de cifrado 3.2.1. Algoritmos DES 3.2.2. Algoritmos MD5

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

6. Comunicacin entre procesos


6.1. Pipes 6.1.1. 6.1.2. 6.2. FIFOs 6.2.1. 6.2.2. 6.2.3. Apertura y cierre de pipes Lectura y escritura de pipes Creacin de un FIFO Apertura y cierre de pipes Lectura y escritura de pipes

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

Objetivo del curso:


Este curso esta aprenders a utilizar funciones del lenguaje C diseadas para manejar las ventajas del sistema operativo Unix, recuerda que gran parte de su ncleo fue desarrollado en este lenguaje, y actualmente hay cientos de programas y utileras desarrolladas en C, aprenders como utilizar parte de la herramientas de desarrollo en ambiente Unix para este lenguaje como son make, y otras opciones incluidas dentro de GCC y como crear programas que utilizan las conexiones de red para comunicarse con otros equipos en Internet a travs de sockets tipo TCP/IP.

Requisitos:
Conocimientos bsicos del Lenguaje C. Manejo de Sistema Operativo Unix. Manejo de vi.

Agenda del Curso

Lunes

Martes
2.MAKE

Mircoles

Jueves

Viernes
5.Seales

Semana 1

1.GCC 3.Contraseas

4.Procesos

Semana 2

6.Comunicacin entre procesos

7.Programaron TCP/IP

Entorno de programacin en sistemas UNIX


Utilizacin del compilador de cdigo de GNU (gcc) El gcc le da al programador un amplio control sobre el proceso de compilacin. Este ltimo comprende cuatro etapas: preprocesador, compilacin, ensamblaje y vinculacin. Uno puede detener el proceso despus de cualquiera de dichas etapas para examinar el rendimiento del compilador. El gcc incluye ms de 30 advertencias individuales y 3 niveles de advertencia tipo captura todo. El gcc es tambin un compilador cruzado, de modo que se puede desarrollar el cdigo en una arquitectura de procesador y correrlo en otro equipo de arquitectura diferente tales como el x86s de Intel, la PowerPC, las SCN Sparcs.

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.

Extensin .c .C , .cc .i .ii .S , .s .o .a , .so

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

Invocacin de gcc paso a paso

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);

# 4 "hola.c" 2 1 2 3 4 5 int main(void) { puts("Hola Mundo de programadores en UNIX!"); return 0; }

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

Utilizacin de mltiples archivos de cdigo fuente


La mayora de los programas de C consisten en mltiples archivos de cdigo fuente, de modo que cada archivo fuente debe ser compilado a cdigo objeto antes del paso final de linkeo. Este requerimiento se satisface con facilidad, Slo se requiere proveer a gcc del nombre de cada archivo de cdigo fuente que se deba compilar. gcc se hace cargo del resto del proceso. La invocacin de gcc seria similar a la siguiente: #gcc archivo1.c archivo2.c archivo3.c o nombre_programa

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.

-Dfoo=bar -Iruta dir

-Lruta_dir

-static -lfoo -g -ggdb -O -On -ansi -pedantic -pedantic-errors -traditional

-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.

Qu uso tiene make?


Para todos los proyectos de software excepto los ms simples, make resulta esencial En primer lugar, los proyectos compuestos por mltiples archivos de cdigo fuente requieren invocaciones del compilador que son largas y complejas. make simplifica esto mediante la invocacin de estas difciles lneas de comandos en un makefile, un archivo de texto que contiene todos los comandos requeridos para desarrollar proyectos de software. make resulta conveniente para todo aquel que quiera desarrollar un programa. A medida que se van haciendo modificaciones al programa, ya sea que se le agreguen nuevas prestaciones o se incorporen correcciones a errores (bugs) detectados, make le permite a uno reconstruir el programa con un nico y breve comando, reconstruir slo un nico mdulo, tal como un archivo de biblioteca, o personalizar el tipo de desarrollo que se desee, segn las circunstancias. make resulta tambin conveniente para otra gente que podra desarrollar el programa. En lugar de crear documentacin que explique en penoso detalle cmo desarrollarlo, uno simplemente les debe indicar que escriban make. El programador original apreciar las ventajas de tener que escribir menor cantidad de documentacin, y los dems colaboradores apreciarn la conveniencia de comandos de desarrollo que sean simples.

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.

Opciones comunes de lnea de comandos de make. Opcin


-f archivo -n -Inombre_dir -s -w -Wfile -r -d -i -k -jN

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.

Creacin de reglas (Targets ficticios)


Adems de los archivos target normales, make permite especificar targets ficticios. Los targets ficticios se denominan as porque no corresponden con archivos reales y, al igual que los targets normales, tienen reglas que listan comandos que make deber ejecutar. El ltimo target del makefile del ejemplo anterior, clean, era un target ficticio. Sin embargo, como clean no exhiba ninguna dependencia, sus correspondientes comandos no fueron ejecutados automticamente.

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:
-

***Recursive variable CC references itself (eventually). Stop.

El problema presente con la expansin recursiva de va

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

Variable $@ $* $< $^ $? $(@D) $(@F)

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

Valor predeterminado ar as cc cpp


rm -f

ARFLAGS ASFLAGS CFLAGS CPPFLAGS LDFLAGS Reglas implcitas

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

rv No hay No hay No hay No hay

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 $@

Cmo funcionan las contraseas en UNIX


Las contraseas en un sistema Unix se almacenan cifradas. El cifrado supone convertir una cadena de texto, mediante un algoritmo repetible, en otra cadena que sea muy diferente a la cadena original. El algoritmo debe ser repetible para que en el momento de establecer la misma cadena origina, el sistema atrapar la cadena y obtener la misma cadena cifrada que tiene almacenada: Unix utiliza un algoritmo de cifrado de sentido nico. Es decir, podrs cifrar una contrasea, pero no es posible generar la contrasea original partiendo de su forma cifrada. Lo nico que puedes intentar es adivinar la contrasea mediante un ataque de diccionario o de fuerza bruta. /etc/passwd Las primeras versiones de Unix guardaban las contraseas cifradas en el fichero /etc/passwd. Durante el proceso de conexin, se solicita al usuario su nombre y su contrasea. El sistema operativo lee ese nombre y busca su entrada en el fichero /etc/passwd, y lea su contrasea cifrada. Luego, el nombre de usuario y la contrasea se pasaba a una funcin de cifrado llamada crypt(), la cual generaba la contrasea cifrada. Si el resultado coincida con el almacenado en el fichero /etc/passwd, se permita el acceso al usuario. Algoritmos de cifrado En Unix y Linux se utilizan , principalmente, dos algoritmos para cifrar las contraseas: DES y MD5. Se trata, en ambos casos, de algoritmos efectivos, porque son repetibles y virtualmente imposibles de descifrar en un intervalo razonable de tiempo. Algoritmo DES El algoritmo Data Encryption Standard (DES) es uno de los utilizados para cifrar las contraseas de Unix. Fue desarrollado por el gobierno de los estados Unidos junto con IBM. Se implementa con la funcin crypt(3) , y es el estndar en el mundo UNIX. La funcin crypt(3) requiere dos argumentos: la clave y la sal. La clave es la contrasea del usuario, y la sal es una cadena de dos caracteres escogidos del conjunto [a-x A-Z 0-9 ./]. La clave del usuario no puede ser mayor de ocho caracteres. Los 7 bits menos significativos de cada uno de los bytes que forman la clave del usuario se unen para formar una clave de 56 bits. Esta clave se utiliza para cifrar una cadena constante (normalmente una cadena formada por ceros), generndose una cadena de 13 caracteres que es la que devuelve la funcin crypt(3). NOTA Como la clave del alagoritmo de cifrado es la contrasea del usuario (el valor es una cadena de ceros) es necesario conocer esa clave para realizar el descifrado.como la clave no debe conocerse (puesto que es una contrasea de un usuario de Unix), el resultado es indescifrable por cualquier funcin conocida. Por eso decimos que crypt(3) implementa un algoritmo de cifrado de sentido nico. El resultado de la funcin crypt(3) es una cadena en la que los dos primeros caracteres son la propia sal, y presenta el siguiente formato: Es una cadena formada por 13 caracteres. Los caracteres podrn ser letras, nmeros, guiones bajos, puntos o guiones: a-z A-A 0-9_.-

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.

Вам также может понравиться