FPO Programador De Sistemas

En una red de ordenadores hay varios ordenadores que están conectados entre si por un cable. A través de dicho cable pueden transmitirse información. Es claro que deben estar de acuerdo en cómo transmitir esa información, de forma que cualquiera de ellos pueda entender lo que están transmitiendo los otros, de la misma forma que nosotros nos ponemos de acuerdo para hablar en inglés cuando uno es italiano, el otro francés, el otro español y el otro alemán.
Al "idioma" que utilizan los ordenadores para comunicarse cuando están en red se le denomina protocolo. Hay muchísimos protocolos de comunicación, entre los cuales el más extendido es el TCP/IP. El más extendido porque es el que se utiliza en Internet.
Aunque todo esto pueda parecer complicado y que no podemos hacer mucho con ello, lo cierto es que podemos aprovecharlo para comunicar dos programas nuestros que estén corriendo en ordenadores distintos. De hecho, con C en Linux/Unix tenemos una serie de funciones que nos permiten enviar y recibir datos de otros programas, en C o en otros lenguajes de programación, que estén corriendo en otros ordenadores de la misma red.
En este artículo no se pretende dar una descripción detallada y rigurosa del protocolo TCP/IP y lo que va alrededor de él. Simplemente se darán unas nociones básicas de manera informal, con la intención de que se pueda comprender un pequeño ejemplo de programación en C.
Está, por tanto, orientado a personas que tengan unos conocimientos básicos de C en Linux y deseen o necesiten comunicar dos programas en C que corren simultáneamente en dos ordenadores distintos conectados en red. El ejemplo propuesto puede servir como guía inicial que se pude complicar todo lo que se desee.

LOS SOCKETS

Una forma de conseguir que dos programas se transmitan datos, basada en el protocolo TCP/IP, es la programación de sockets. Un socket no es más que un "canal de comunicación" entre dos programas que corren sobre ordenadores distintos o incluso en el mismo ordenador.
Desde el punto de vista de programación, un socket no es más que un "fichero" que se abre de una manera especial. Una vez abierto se pueden escribir y leer datos de él con las habituales funciones de read() y write() del lenguaje C. Hablaremos de todo esto con detalle más adelante.
Existen básicamente dos tipos de "canales de comunicación" o sockets, los orientados a conexión y los no orientados a conexión.
En el primer caso ambos programas deben conectarse entre ellos con un socket y hasta que no esté establecida correctamente la conexión, ninguno de los dos puede transmitir datos. Esta es la parte TCP del protocolo TCP/IP, y garantiza que todos los datos van a llegar de un programa al otro correctamente. Se utiliza cuando la información a transmitir es importante, no se puede perder ningún dato y no importa que los programas se queden "bloqueados" esperando o transmitiendo datos. Si uno de los programas está atareado en otra cosa y no atiende la comunicación, el otro quedará bloqueado hasta que el primero lea o escriba los datos.
En el segundo caso, no es necesario que los programas se conecten. Cualquiera de ellos puede transmitir datos en cualquier momento, independientemente de que el otro programa esté "escuchando" o no. Es el llamado protocolo UDP, y garantiza que los datos que lleguen son correctos, pero no garantiza que lleguen todos. Se utiliza cuando es muy importante que el programa no se quede bloqueado y no importa que se pierdan datos. Imaginemos, por ejemplo, un programa que está controlando la temperatura de un horno y envía dicha temperatura a un ordenador en una sala de control para que éste presente unos gráficos de temperatura. Obviamente es más importante el control del horno que el perfecto refresco de los gráficos. El programa no se puede quedar bloqueado sin atender al horno simplemente porque el ordenador que muestra los gráficos esté ocupado en otra cosa.
En el ejemplo y a partir de este momento nos referimos únicamente a sockets TCP. Los UDP son básicamente iguales, aunque hay pequeñas diferencias en la forma de abrirlos y de enviar los mensajes. Puedes ver un ejemplo de programación de socket UDP.

ARQUITECTURA CLIENTE / SERVIDOR

A la hora de comunicar dos programas, existen varias posibilidades para establecer la conexión inicialmente. Una de ellas es la utilizada aquí. Uno de los programas debe estar arrancado y en espera de que otro quiera conectarse a él. Nunca da "el primer paso" en la conexión. Al programa que actúa de esta forma se le conoce como servidor. Su nombre se debe a que normalmente es el que tiene la información que sea disponible y la "sirve" al que se la pida. Por ejemplo, el servidor de páginas web tiene las páginas web y se las envía al navegador que se lo solcite.
El otro programa es el que da el primer paso. En el momento de arrancarlo o cuando lo necesite, intenta conectarse al servidor. Este programa se denomina cliente. Su nombre se debe a que es el que solicita información al servidor. El navegador de Internet pide la página web al servidor de Internet.
En este ejemplo, el servidor de páginas web se llama servidor porque está (o debería de estar) siempre encendido y pendiente de que alguien se conecte a él y le pida una página. El navegador de Internet es el cliente, puesto que se arranca cuando nosotros lo arrancamos y solicita conexión con el servidor cuando nosotros escribimos, por ejemplo, www.chuidiang.com
En el juego del Quake, debe haber un servidor que es el que tiene el escenario del juego y la situación de todos los jugadores en él. Cuando un nuevo jugador arranca el juego en su ordenador, se conecta al servidor y le pide el escenario del juego para presentarlo en la pantalla. Los movimientos que realiza el jugador se transmiten al servidor y este actualiza escenarios a todos los jugadores.
Resumiendo, servidor es el programa que permanece pasivo a la espera de que alguien solicite conexión con él, normalmente, para pedirle algún dato. Cliente es el programa que solicita la conexión para, normalmente, pedir datos al servidor.

LA CONEXIÓN

Para poder realizar la conexión entre ambos programas son necesarias varias cosas:

Dirección IP del servidor.

Cada ordenador de una red tiene asignado un número único, que sirve para identificarle y distinguirle de los demás, de forma que cuando un ordenador quiere hablar con otro, manda la información a dicho número. Es similar a nuestros números de teléfono. Si quiero hablar con mi amigo "Josechu", primero marco su número de teléfono y luego hablo con él.

El servidor no necesita la dirección de ninguno de los dos ordenadores, al igual que nosotros, para recibir una llamada por teléfono, no necesitamos saber el número de nadie, ni siquiera el nuestro. El cliente sí necesita saber el número del servidor, al igual que nosotros para llamar a alguien necesitamos saber su número de teléfono.

La dirección IP es un número del estilo 192.100.23.4. ¡Todos lo hemos visto en Internet!. En resumidas cuentas, el cliente debe conocer a qué ordenador desea conectarse. En nuestro navegador de Internet facilitamos la dirección IP del servidor al que queremos conectarnos a través de su nombre (www.chuidiang.com). Obviamente este nombre hay que traducirlo a una dirección IP, pero nuestro navegador e Internet se encargan de eso por nosotros.
Servicio que queremos crear / utilizar.

Si llamamos a una empresa, puede haber en ella muchas personas, cada una con su extensión de teléfono propia. Normalmente la persona en concreto con la que hablemos nos da igual, lo que queremos es alguien que nos atienda y nos de un determinado "servicio", como recoger una queja, darnos una información, tomarnos nota de un pedido, etc.

De la misma forma, en un mismo ordenador pueden estar corriendo varios programas servidores, cada uno de ellos dando un servicio distinto. Por ejemplo, un ordenador puede tener un servidor de Quake y un servidor de páginas web corriendo a la vez. Cuando un cliente desea conectarse, debe indicar qué servicio quiere, igual que al llamar a la empresa necesitamos decir la extensión de la persona con la que queremos hablar o, al menos, decir su nombre o el departamento al que pertenece para que la telefonista nos ponga con la persona adecuada.

Por ello, cada servicio dentro del ordenador debe tener un número único que lo identifique (como la extensión de teléfono). Estos números son enteros normales y van de 1 a 65535. Los número bajos, desde 1 a 1023 están reservados para servicios habituales de los sistemas operativos (www, ftp, mail, ping, etc). El resto están a disposición del programador y sirven para cosas como Quake.

Tanto el servidor como el cliente deben conocer el número del servicio al que atienden o se conectan. El servidor le indica al sistema operativo qué servicio quiere atender, al igual que en una empresa el empleado recién contratado (o alguien en su lugar) debe informar a la telefonista en qué extensión se encuentra.

El cliente, cuando llame a la empresa, debe dar el número de extensión (o nombre de empleado), de forma que la telefonista le ponga con la persona adecuada. En el caso del navegador de Internet, estamos indicando el servicio con la www en www.chuidiang.com, servicio de páginas web. También es posible, por ejemplo "ftp.chuidiang.com", si chuidiang.com admite clientes ftp. Nuestro ordenador es lo suficientemente listo como para saber a qué número corresponden esos servicios habituales.

EL SERVIDOR

A partir de este punto comenzamos con lo que es la programación en C de los sockets. Si no tienes unos mínimos conocimientos de C, es mejor que los adquieras antes de seguir.
Con C en Unix/Linux, los pasos que debe seguir un programa servidor son los siguientes:

Apertura de un socket, mediante la función socket(). Esta función devuelve un descriptor de fichero normal, como puede devolverlo open(). La función socket() no hace absolutamente nada, salvo devolvernos y preparar un descriptor de fichero que el sistema posteriormente asociará a una conexión en red.
Avisar al sistema operativo de que hemos abierto un socket y queremos que asocie nuestro programa a dicho socket. Se consigue mediante la función bind(). El sistema todavía no atenderá a las conexiones de clientes, simplemente anota que cuando empiece a hacerlo, tendrá que avisarnos a nosotros. Es en esta llamada cuando se debe indicar el número de servicio al que se quiere atender.
Avisar al sistema de que comience a atender dicha conexión de red. Se consigue mediante la función listen(). A partir de este momento el sistema operativo anotará la conexión de cualquier cliente para pasárnosla cuando se lo pidamos. Si llegan clientes más rápido de lo que somos capaces de atenderlos, el sistema operativo hace una "cola" con ellos y nos los irá pasando según vayamos pidiéndolo.
Pedir y aceptar las conexiones de clientes al sistema operativo. Para ello hacemos una llamada a la función accept(). Esta función le indica al sistema operativo que nos dé al siguiente cliente de la cola. Si no hay clientes se quedará bloqueada hasta que algún cliente se conecte.
Escribir y recibir datos del cliente, por medio de las funciones write() y read(), que son exactamente las mismas que usamos para escribir o leer de un fichero. Obviamente, tanto cliente como servidor deben saber qué datos esperan recibir, qué datos deben enviar y en qué formato. Puedes ver cómo se pueden poner de acuerdo en estos mensajes en el apartado de mensajes.
Cierre de la comunicación y del socket, por medio de la función close(), que es la misma que sirve para cerrar un fichero.

EL CLIENTE

Los pasos que debe seguir un programa cliente son los siguientes:

Apertura de un socket, como el servidor, por medio de la función socket()
Solicitar conexión con el servidor por medio de la función connect(). Dicha función quedará bloqueada hasta que el servidor acepte nuestra conexión o bien si no hay servidor en el sitio indicado, saldrá dando un error. En esta llamada se debe facilitar la dirección IP del servidor y el número de servicio que se desea.
Escribir y recibir datos del servidor por medio de las funciones write() y read().
Cerrar la comunicación por medio de close().

FICHEROS UNIX/LINUX IMPLICADOS

Para la programación de socket no es estrictamente necesario ningún fichero. Sabiendo la dirección IP y el número de servicio, se ponen directamente en código y todo resuelto. Sin embargo, esto no es lo más cómodo ni lo más portable de unos ordenadores a otros.
Hay dos ficheros en Unix/Linux que nos facilitan esta tarea, aunque hay que tener permisos de root para modificarlos. Estos ficheros serían el equivalente a una agenda de teléfonos, en uno tenemos apuntados el nombre de la empresa con su número de teléfono y en el otro fichero el nombre de la persona y su extensión (EmpresaGorda, tlfn 123.456.789; JoseGordo, extensión 2245; ...)
/etc/hosts : Esta es la agenda en la que tenemos las empresas y sus números de teléfono. En este fichero hay una lista de nombres de ordenadores conectados en red y dirección IP de cada uno. Habitualmente en el /etc/hosts del cliente se suele colocar el nombre del servidor y su dirección IP. Luego, desde programa, se hace una llamada a la función gethostbyname(), a la que pasándole el nombre del ordenador como una cadena de caracteres, devuelve una estructura de datos entre los que está la dirección IP.
Una línea de lo que puede aparecer en este fichero es la siguiente, en el que vemos la dirección IP y el nombre del ordenador que nos da el servicio de Quake.

192.30.10.1 Ordenador_Quake

En Windows, este fichero suele encontrarse en C:\WINNT\system32\drivers\etc\hosts.
/etc/services : Este fichero es el equivalente a la agenda donde tenemos apuntados los distintos departamentos/personas de la empresa y sus números de extensión telefónica. En este fichero hay una lista de servicios disponibles, indicando nombre de servicio, número de servicio y tipo (ftp/udp).
Tanto el servidor como el cliente deben tener en este fichero el servicio que están atendiendo / solicitando con el mismo número y tipo de servicio. El nombre puede ser distinto, igual que cada uno en su agenda pone el nombre que quiere, pero no es lo habitual.
Desde programa, tanto cliente como servidor, deben hacer una llamada a la función getservbyname(), a la que pasándole el nombre del servicio, devuelve una estructura de datos entre los que está el número de servicio y el tipo.
Un ejemplo de lo que puede aparecer en un fichero /etc/services es el siguiente, en el que vemos en cada línea nombre del servicio, número / tipo y un comentario opcional detrás del símbolo #. "Casualmente", se ve el servicio www, cuyo número de servicio conocido por todos los ordenadores de Internet, es el 80.

tftp 69/udp
gopher 70/tcp # Internet Gopher
gopher 70/udp
rje 77/tcp
finger 79/tcp
www 80/tcp http # Worldwide Web HTTP
www 80/udp # HyperText Transfer Protocol
link 87/tcp ttylink

En Windows, el ficherito de marras está en C:\WINNT\system32\drivers\etc\services

EJEMPLO

Sentadas las bases de los sockets, vamos a ver un pequeño fuente.zip de programa servidor y cliente, realizado con C en Linux. El servidor esperará la conexión del cliente. Una vez conectados, se enviarán una cadena de texto el uno al otro y ambos escribirán en pantalla la cadena recibida.
Para ejecutar el ejemplo no es necesario tener dos ordenadores. Se pude ejecutar el servidor desde una ventana y el cliente desde otra. En la ventana del servidor veremos la cadena que ha enviado el cliente y al revés.

DETALLES DEL SERVIDOR

En este apartado vamos a detallar las llamadas a las funciones del servidor que indicamos anteriormente. Explicaremos con cierto detalle qué parámetros se deben pasar y cual es el resultado de dichas llamadas.
En primer lugar el servidor debe obtener el número del servicio al que quiere atender, haciendo la llamada a getservbyname(). Esta función devuelve una estructura (en realidad puntero a la estructura) en el que uno de sus campos contiene el número de servicio solicitado.

struct servent Puerto; /* Estructura devuelta */

/* La llamada a la función */
Puerto = getservbyname ("Nombre_Servicio", "tcp");

Los parámetros de la función son dos cadenas de caracteres. La primera es el nombre del servicio, tal cual lo escribimos en el fichero /etc/services. El segundo es el tipo de protocolo que queremos usar. "tcp" o "udp", Dentro de lo que devuelve la función, el número de servicio que nos interesa está en un campo de Puerto:

Puerto->s_port

Ya tenemos todos los datos que necesita el servidor para abrir el socket, así que procedemos a hacerlo. El socket se abre mediante la llamada a la función socket() y devuelve un entero que es el descriptor de fichero o –1 si ha habido algún error.

int Descriptor;
Descriptor = socket (AF_INET, SOCK_STREAM, 0);
if (Descriptor == -1)
printf ("Error\n");

El primer parámetro es AF_INET o AF_UNIX para indicar si los clientes pueden estar en otros ordenadores distintos del servidor o van a correr en el mismo ordenador. AF_INET vale para los dos casos. AF_UNIX sólo para el caso de que el cliente corra en el mismo ordenador que el servidor, pero lo implementa de forma más eficiente. Si ponemos AF_UNIX, el resto de las funciones varía ligeramente.
El segundo parámetro indica si el socket es orientado a conexión (SOCK_STREAM) o no lo es (SOCK_DGRAM). De esta forma podremos hacer sockets de red o de Unix tanto orientados a conexión como no orientados a conexión.
El tercer parámetro indica el protocolo a emplear. Habitualmente se pone 0.
Si se ha obtenido un descriptor correcto, se puede indicar al sistema que ya lo tenemos abierto y que vamos a atender a ese servicio. Para ello utilizamos la función bind(). El problema de la función bind() es que lleva un parámetro bastante complejo que debemos rellenar.

struct sockaddr_in Direccion;
Direccion.sin_family = AF_INET;
Direccion.sin_port = Puerto->s_port;
Direccion.sin_addr.s_addr =INADDR_ANY;

if (bind (Descriptor, (struct sockaddr *)&Direccion, sizeof (Direccion)) == -1)
{
printf ("Error\n");
}

El parámetro que necesita es una estructura sockaddr. Lleva varios campos, entre los que es obligatorio rellenar los indicados en el código.
sin_family es el tipo de conexión (por red o interna), igual que el primer parámetro de socket().
sin_port es el número correspondiente al servicio que obtuvimos con getservbyname(). El valor está en el campo s_port de Puerto.
Finalmente sin_addr.s_addr es la dirección del cliente al que queremos atender. Colocando en ese campo el valor INADDR_ANY, atenderemos a cualquier cliente.
La llamada a bind() lleva tres parámetros:

Descriptor del socket que hemos abierto
Puntero a la estructura Direccion con los datos indicados anteriormente. La estructura admitida por este parámetro es general y valida para cualquier tipo de socket y es del tipo struct sockaddr. Cada socket concreto lleva su propia estructura. Los AF_INET como este caso llevan struct sockaddr_in, los AF_UNIX llevan la estructura struct sockaddr_un. Por eso, a la hora de pasar el parámetro, debemos hacer un "cast" al tipo struct sockaddr. La operación cast es un pequeño truco que admite C. Cuando tenemos un dato de un determinado tipo, por ejemplo, un entero int, es posible convertirlo a otro tipo que nos venga mejor poniendo el nuevo tipo deseado entre paréntesis y detrás la variable del tipo no deseado. Por ejemplo, para convertir de entero a flotante:

Variable_Flotante = (float)Variable_Entera;

Esto es válido siempre y cuando los dos tipos tengan algún tipo de relación y sea posible convertir uno en el otro. En nuestro ejemplo las estructuras sockaddr_in y sockaddr_un pueden convertirse sin problemas al tipo sockaddr.
Longitud de la estructura Direccion.

La función devuelve -1 en caso de error. Una vez hecho esto, podemos decir al sistema que empiece a atender las llamadas de los clientes por medio de la función listen()

if (listen (Descriptor, 1) == -1)
{
printf ("Error\n");
}

La función listen() admite dos parámetros, afortunadamente sencillos:

Descriptor del socket.
Número máximo de clientes encolados. Supongamos que recibimos la conexión de un primer cliente y le atendemos. Mientras lo estamos haciendo, se conecta un segundo cliente, al que no atendemos puesto que estamos ejecutando el código necesario para atender al primero. Mientras sucede todo esto, llega un tercer cliente que también se conecta. Estamos atendiendo al primero y tenemos dos en la "lista de espera". El segundo parámetro de listen() indica cuántos clientes máximo podemos tener en la lista de espera. Cuando un cliente entra en la lista de espera, su llamada a connect() queda bloqueada hasta que se le atiende. Si la lista de espera está llena, el nuevo cliente que llama a connect() recibirá un error de dicha función. Algo así como un "vuelva usted mañana".

La función listen() devuelve –1 en caso de error. Con todo esto ya sólo queda recoger los clientes de la lista de espera por medio de la función accept(). Si no hay ningún cliente, la llamada quedará bloqueada hasta que lo haya. Esta función devuelve un descriptor de fichero que es el que se tiene que usar para "hablar" con el cliente. El descriptor anterior corresponde al servicio y sólo sirve para encolar a los clientes. Digamos que el primer descriptor es el aparato de teléfono de la telefonista de la empresa y el segundo descriptor es el aparato de teléfono del que está atendiendo al cliente.

struct sockaddr Cliente;
int Descriptor_Cliente;
int Longitud_Cliente;

Descriptor_Cliente = accept (Descriptor, &Cliente, &Longitud_Cliente);
if (Descriptor_Cliente == -1)
{
printf ("Error\n");
}

La función accept() es otra que lleva un parámetro complejo, pero que no debemos rellenar. Los parámetros que admite son

Descriptor del socket abierto.
Puntero a estructura sockaddr. A la vuelta de la función, esta estructura contendrá la dirección y demás datos del ordenador cliente que se ha conectado a nosotros.
Puntero a un entero, en el que se nos devolverá la longitud útil del campo anterior.

La función devuelve un –1 en caso de error. Si todo ha sido correcto, ya podemos "hablar" con el cliente. Para ello se utilizan las funciones read() y write() de forma similar a como se haría con un fichero. Supongamos que sabemos que al conectarse un cliente, nos va a mandar una cadena de cinco caracteres. Para leerla sería

int Leido = 0;/* Número de caracteres leídos hasta el momento */
int Aux = 0; /* Guardaremos el valor devuelto por read() */
int Longitud = 5; /* Número de caracteres a leer */
char Datos[5]; /* Buffer donde guardaremos los caracteres */

/* Bucle hasta que hayamos leído todos los caracteres que
estamos esperando */
while (Leido < Longitud)
{
    /* Se leen los caracteres */
    Aux = read (Descriptor, Datos + Leido, Longitud - Leido);

    /* Si hemos conseguido leer algún carácter */
    if (Aux > 0)
    {
        /* Se incrementa el número de caracteres leídos */
        Leido = Leido + Aux;
    }
    else
    {
        /* Si no se ha leído ningún carácter, se comprueba
        la condición de socket cerrado */
        if (Aux == 0)
        {
            printf ("Socket cerrado\n");
        }
        else
        /* y la condición de error */
        if (Aux == -1)
        {
            printf ("Error\n");
        }
    }
}

Parece un poco complicado. A ver si somos capaces de aclararlo. La función read() admite como parámetros

Descriptor del fichero / socket del que se quiere leer
Puntero a char donde se almacenarán los datos leídos
Número de caracteres que se quieren leer.

La función devuelve –1 si ha habido error, 0 si el socket se ha cerrado o el fichero ha llegado a fin de fichero, o bien el número de caracteres si se ha conseguido leer alguno. En el caso de socket, si no hay errores y el socket sigue abierto y no hay caracteres para leer (no los han enviado desde el otro extremo), la llamada queda bloqueada. En el caso de leer de socket, tenemos un pequeño problema añadido y es que se leen los caracteres disponibles y se vuelve. Si pedimos 5 caracteres, entra dentro de lo posible que read() lea 3 caracteres y vuelva, sin dar error, pero sin leer todos los que hemos pedido. Por ese motivo, al leer de socket es casi obligatorio (totalmente obligatorio si queremos transmitir muchos caracteres de un solo golpe) el leer con un bucle, comprobando cada vez cuantos caracteres se han leído y cuantos faltan.
Por este motivo, read() va dentro de un while() en el que se mira si el total de caracteres leídos es menor que el número de caracteres que queremos leer. La lectura del read() debe además pasar como parámetro cada vez la posición dentro del buffer de lectura en la que queremos situar los caracteres (Datos + Leido ) y la longitud de caracteres a leer, (Longitud - Leido ) que también cambia según se va leyendo.
En cuanto a escribir caracteres, la función write() admite los mismos parámetros, con la excepción de que el buffer de datos debe estar previamente relleno con la información que queremos enviar. Tiene el mismo problema, que escribe lo que puede y vuelve, pudiendo no haber escrito toda la información, por lo que hay que hacer un trozo de código similar.

int Escrito = 0; /* Núm. de caracteres que ya se han escrito */
int Aux = 0; /* Número de caracteres escritos en cada pasada */
int Longitud = 5; /* Total de caracteres a escribir */
char Datos[] = "Hola"; /* El 5º carácter es el \0 del final */

/* Bucle mientras no se hayan escrito todos los caracteres
deseados */
while (Escrito < Longitud)
{
    /* Se escriben los caracteres */
    Aux = write (Descriptor, Datos + Escrito, Longitud - Escrito);

    /* Si hemos conseguido escribir algún carácter */
    if (Aux > 0)
    {
        /* Incrementamos el número de caracteres escritos */
        Escrito = Escrito + Aux;
    }
    else
    {
        /* Si no hemos podido escribir caracteres,
        comprobamos la condición de socket cerrado */
        if (Aux == 0)
        {
            printf ("Socket cerrado\n");
        }
        else
        /* y la condición de error */
        if (Aux == -1)
        {
            printf ("Error\n");
        }
    }
}

En un programa más serio, ni el cliente ni el servidor saben a priori qué es lo que tienen que leer. Normalmente hay una serie de mensajes que los dos conocen precedidos de una "cabecera", en la que suelen ir campos del estilo "Identificador de mensaje" y "Longitud del mensaje". De esta forma, primero se leen estos dos campos y sabiendo qué mensaje va a llegar y su longitud, se procede a leerlo. A la hora de escribir, primero se manda la cabecera diciendo qué mensaje se va a mandar y qué longitud tiene, y luego se manda el mensaje en sí.
Una vez que se han leído / enviado todos los datos necesarios, se procede a cerrar el socket. Para ello se llama a la función close(), que admite como parámetro el descriptor del socket que se quiere cerrar.

close (Descriptor_Cliente);

Normalmente el servidor cierra el descriptor del cliente (Descriptor_Cliente), no el del socket (Descriptor), ya que este se suele dejar abierto para volver a realizar una llamada a accept() y sacar al siguiente cliente de la cola. Es como si una vez que un amable señor de una empresa nos ha atendido le dice a la telefonista que no atienda más el teléfono. Esas cosas sólo las hacen los jefes.

DETALLES DEL CLIENTE

Puesto que la escritura / lectura y cierre de sockets es idéntica a la del servidor, únicamente contaremos la apertura del socket que, cómo no, es más compleja que la del servidor, puesto que además del número de servicio, debe obtener la dirección IP del servidor.
En primer lugar, como en el servidor, obtenemos el número del servicio.

struct servent *Puerto;
Puerto = getservbyname ("Nombre_Servicio", "tcp");

if (Puerto == NULL)
{
printf ("Error\n");
}

Después obtenemos la dirección IP del servidor. El parámetro que hay que pasar es una cadena de caracteres con el nombre del servidor, tal cual lo pusimos en el fichero /etc/hosts. Devuelve los datos del servidor en una estructura hostent.

struct hostent *Host;

Host = gethostbyname ("Nombre_Servidor");
if (Host == NULL)
{
printf ("Error\n");
}

Una vez que tenemos todos los datos necesarios, abrimos el socket igual que en el servidor.

Descriptor = socket (AF_INET, SOCK_STREAM, 0);

if (Descriptor == -1)
{
printf ("Error\n");
}

Ya tenemos todo lo necesario para solicitar conexión con el servidor. El parámetro de connect() ya es conocido y sólo tenemos que rellenarlo, igual que en bind() del servidor.

struct sockaddr_in Direccion;
Direccion.sin_family = AF_INET;
Direccion.sin_addr.s_addr = ((structin_addr*)(Host->h_addr))->s_addr;
Direccion.sin_port = Puerto->s_port;

if (connect (Descriptor, (struct sockaddr *)&Direccion,sizeof (Direccion)) == -1)
{
printf ("Error\n");
}

La única novedad es que la dirección del servidor se coloca en Direccion.sin_addr.s_addr y no como pusimos antes, INADDR_ANY. Dicha dirección la tenemos dentro de la estructura obtenida con gethostbyname(), en el campo ((structin_addr*)(Host->h_addr))->s_addr. ¡Vaya por Dios!, ¡Menudo campo!. Nos pasa como dijimos antes, los tipos no son exactamente los mismos y tenemos estructuras anidadas en estructuras, con lo que la sintaxis queda de esa forma tan horrible. La explicación es la siguiente:
La estructura Host tiene un campo h_addr, de ahí la parte Host->h_addr.
Este campo no es del tipo deseado, así que se convierte con un cast a struct in_addr, de ahí lo de (struct in_addr*)(Host->h_addr).
Bueno, pues todo esto es a su vez una estructura, de la que nos interesa el campo s_addr, así que metemos todo entre paréntesis, cogemos el campo y nos queda lo que tenemos puesto en el código ((structin_addr*)(Host->h_addr))->s_addr
El resto es exactamente igual que en el servidor.

ALGUNAS CONSIDERACIONES

Puede haber variaciones con otro tipo de sockets.

El ejemplo aquí expuesto funciona correctamente, pero si se quieren hacer otras cosas un poco más serias hay que tener en cuenta varios puntos que indicamos aquí por encima.
En primer lugar el ejemplo es con sockets orientados a conexión y de tipo AF_INET ( para que pueda funcionar con servidor en un ordenador y cliente en otro). Si cambiamos de tipo de socket o de conexión, la idea básica es la misma, pero la sintaxis del código cambia ligeramente. Antes de realizar dicho cambio, conviene saber qué cosas hay que cambiar en el código. Un ejemplo claro, si usamos sockets no orientados a conexión, sobra la llamada a connect() que hace el cliente y la de accept() que hace el servidor, pero en su lugar el cliente debe hacer una llamada a bind(). Puedes ver aquí un ejemplo de socket udp.
Si usamos sockets AF_UNIX, sobra pedir la dirección IP del servidor, ya que es el mismo ordenador en el que corren ambos programas.

Organización de los enteros.

En el mundo de los ordenadores, están los micros de intel (y los que los emulan) y los demás. La diferencia, entre otras muchas, es que organizan los enteros de forma distinta; uno pone antes el byte más significativo del entero y el otro lo pone al final. Si conectamos dos ordenadores con sockets, una de las informaciones que se transmiten en la conexión es un entero con el número de servicio. ¡Ya la hemos liado! hay micros que no se entienden entre sí. Para evitar este tipo de problemas están la funciones htons(), htonl() y similares. Esta función convierte los enteros a un formato "standard" de red, con lo que se garantiza que nos podemos entender con cualquier entero. Eso implica que algunos de los campos de las estructuras que hemos rellenado arriba, debemos aplicarles esta función antes de realizar la conexión. Si enviamos después enteros con write() o los leemos con read(), debemos convertirlos y desconvertirlos a formato red.
Puedes ver un ejemplo de todo esto al conectar un socket en Java con uno en C. Aunque ambos corran en el mismo ordenador, java tiene su propia máquina virtual, por lo que es como si corriera en su propio microprocesados, distinto de los pentium.

Atención al cliente

Una técnica habitual en el servidor es que cree nuevos procesos (o hilos) para cada cliente. Puedes echar un ojo a la función fork(). Si no se quieren crear procesos, se puede usar la función select(). A esta función se le dicen todos los sockets que estamos atendiendo y cuando la llamemos, nos quedamos bloqueados hasta que en alguno de ellos haya "actividad". Esto nos evita estar en un bucle mirando todos los sockets clientes uno por uno para ver si alguno quiere algo.
Se suelen crear procesos con fork() cuando el servidor no es capaz de atender todas las peticiones de los clientes a suficiente velocidad. Al tener un proceso dedicado a cada cliente, se puede atender a varios "simultaneamente". Se suele usar select() cuando podemos atender a los clientes lo suficientemente rápido como para hacerlo de uno en uno, sin hacer esperar demasiado a nadie.
Poniendo un ejemplo, si en una ventanilla de un banco "gotean" los clientes y se despacha rápido a cada uno, basta con una única ventanilla y una persona en ella que "duerma disimuladamente" mientras llega un cliente. Si los clientes llegan a mogollón y se tarda en atender a cada uno de ellos, es mejor que haya muchas ventanillas, lo ideal, una por cada cliente.

BIBLIOGRAFÍA

Un excelente libro para programación avanzada en C sobre entorno Unix es "UNIX, Programación avanzada" de Fco. Manuel Márquez García, editorial ra-ma.
Tienes una guia bastante simple, pero más detallada de sockets en http://www.arrakis.es/~dmrq/beej/index.html

Solución con Menus Graficos

2012-07-12T10:53:00.003-07:00

Os dejo aqui un enlace para la descarga de la solución usando menus graficos:

Nota:
He echo una pequeña mejora con el comando paste, para añadir y mezclar distinto tipo de información en un mismo menu ( permisos y nombre de archivos)

(fuente: http://html.rincondelvago.com/unix_9.html )

Nota Importante: term.h
Si al compilar conio.h, os da un error en la linea:
#include <term.h>

Tendreis que instalar desde synaptic la siguiente libreria:
libncurses5-dev

(fuente: http://www.ubuntu-es.org/node/25843 )

Programa Final

2012-07-12T10:53:00.001-07:00

Realizar un programa que desempeñe las funciones de un administrador de archivos.

Debe poder gestionar tanto ficheros como directorios y puntos de montaje

Directorios:
    crear
    borrar
    renombrar y mover
    enlazar
    mostrar contenido
    desplazarse por ellos
    gestion de permisos

Ficheros
    copiar
    borrar
    renombrar/mover
    ver contenido (Texto y Hexadecimal)
    Gestion Permisos

Puntos de montaje: manejar las descripciones conetenidas en el archivo /etc/fstab
    Montar sistema de archivos
    Desmontar sistemas de archivos

solucion 7: alumno antonio

2012-07-12T10:52:00.003-07:00

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
   char Npid[10];
   char hazlo[20];
   char proceso[20];
   char op = ' ';
   void menu();
   int pedirNum();

   while (op != 0) {                                                   //Mientras no se elija la opcion de salida,me muestra el menu y la función pedirNum.
       system("clear");
       menu();
       op=pedirNum();                                                    //Ejecutamos la función pedirNum y lo que devuelve se lo asignamos a op.

       switch (op) {                                                   //Tratamos los casos con %s para no tener problemas si el usuario uintroduce una letra en la selección en lugar de un número.
       case '1':
           system("ps -Ao user,pid,comm,stat |grep -i $USER | grep -v mata");   //Me muestra los apartados que quiero y filtramos nuestro usuario y evitamos que aparezca nuestro programa.
           printf("\nEscriba el PID del proceso que quiere matar: ");
           scanf("%s", Npid);
           sprintf(hazlo, "kill -9 %s", Npid);                           //Copiamos lo que leemos en Npid junto con el comando a ejecutar en la cadena (hazlo).
           system(hazlo);
           break;
       case '2':
           system("ps -Ao user,pid,comm,stat |grep -i $USER | grep -v mata");
           printf("\nEscriba el PID del proceso que quiere parar: ");
           scanf("%s", Npid);
           sprintf(hazlo, "kill -19 %s", Npid);
           system(hazlo);
           break;
       case '3':
           printf("\n");
           system("ps -Ao user,pid,comm,stat | grep T");               //Mostramos los apartados que nos interesa y filtramos los que esten parados y podamos continuar.
           printf("\nEscriba el PID del proceso que quiere continuar: ");
           scanf("%s", Npid);
           sprintf(hazlo, "kill -18 %s", Npid);
           system(hazlo);
           break;
       case '4':
           system("ps -Ao user,pid,comm,stat |grep -i $USER | grep -v mata");
           printf("\nEscriba el PID del proceso que quiere terminar: ");
           scanf("%s", Npid);
           sprintf(hazlo, "kill -9 %s", Npid);
           system(hazlo);
           break;
       case '5':
           system("ps -Ao user,pid,comm,stat |grep -i $USER | grep -v mata");
           printf("Escriba el nombre del proceso que quiere terminar: ");
           scanf("%s", proceso);
           sprintf(hazlo, "killall %s", proceso);
           system(hazlo);
           break;
       case '6':
           system("gnome-terminal -e top");                           //Abrimos otra terminal y le pasamos el comando top.
           break;
       case '0':
           system("clear");
           printf("Saliendo del programa...\n");
           exit(1);
           break;
       default:
           printf("--OPCION INCORRECTA--");                           //Si no es una opción correcta, nos muestra el mensaje.
       }
   }
   return 0;
}

// Procedimiento menu.

void menu() {
   printf("\n\n-------MENU-------\n\n");
   printf("1.Matar un proceso.\n");
   printf("2.Para un proceso.\n");
   printf("3.Continua un proceso.\n");
   printf("4.Termina un proceso.\n");
   printf("5.Matar procesos por su nombre.\n");
   printf("6.Ver procesos por consumo.\n");
   printf("0.Salir del programa.\n");
}

// Función Pedir Número.
int pedirNum() {
   char num = ' ';
   printf("\nElija operación(0-6)");
   scanf("%s", &num);
   return num;
}

Solucion 7: alumno

2012-07-12T10:52:00.001-07:00

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void rehacer_pantalla();
void presentar_menu();
void ejecutar_ps_completo();

int buscaespacio1(char *texto);
int buscaespacio2(int,char *texto);

typedef struct{
    int num;
    int proceso;
    char nombre[350];
}linea_datos;

linea_datos linea[500];// numero maximo de procesos a gestionar

int main(int argc, char **argv) {
    int op = 1000;
    char entrada_texto[10];
    char *comando[100];
    int pro;
    rehacer_pantalla();

    while (op != 0) {
        op = atoi(gets(entrada_texto));
        switch (op) {
        case 1:
             system("ps");
           printf("\n    Pulse Enter \n");
            break;
        case 2:
            system("ps a");
printf("\n    Pulse Enter \n");
            break;

        case 3:
system("ps u");
printf("\n    Pulse Enter \n");
            break;

case 4:
system("ps x");
printf("\n    Pulse Enter \n");
            break;

case 5:
system("ps f");
printf("\n    Pulse Enter \n");
            break;

case 6:
system("jobs");
printf("\n    Pulse Enter \n");
            break;

        case 7:
            ejecutar_ps_completo();
printf("\n    Pulse Enter \n");

        break;
        case 8:
            printf("\nNº del proceso (a parar) ");
            pro = atoi(gets(entrada_texto));
            sprintf(comando,"kill -19 %d",pro);
             system(comando);
printf("\n    Pulse Enter \n");
            break;

        case 9:
            printf("\nNº del proceso (a continuar): ");
            pro = atoi(gets(entrada_texto));
            sprintf(comando,"kill -18 %d",pro);
             system(comando);
printf("\n    Pulse Enter \n");
            break;
    case 10:
            printf("\nNº del proceso (a terminar): ");
            pro = atoi(gets(entrada_texto));
            sprintf(comando,"kill 15 %d",pro);
             system(comando);
    printf("\n    Pulse Enter \n");
            break;
    case 11:
            printf("\nNº del proceso (a matar): ");
            pro = atoi(gets(entrada_texto));
            sprintf(comando,"kill 9 %d",pro);
             system(comando) ;
   printf("\n    Pulse Enter \n");
    break;
    case -1:
    op=0;

            break;
            default:
            rehacer_pantalla();
            op=1020;
        }


        }



    return 0;
}

void rehacer_pantalla(muestra) {
    int resp;
    resp = system("clear");

    presentar_menu();
}

void presentar_menu() {

    printf("\033[47m\033[1;35m\033[2;0H    Menu: MATA     \033[0m\n");
    printf("\033[3;0H-1) Salir del programa\n");
    printf("\033[4;0H 1) Muestra los procesos del terminal\n ");
    printf("\033[5;0H 2) Muestra los procesos de todos los usuarios del terminal\n");
    printf("\033[6;0H 3) Identifica el usuario que ha puesto en marcha ese proceso y cuando se inicio ese proceso\n");
    printf("\033[7;0H 4) Muestra los procesos que no dependen de un terminal");
    printf("\033[8;0H 5) Rastrear que proceso es el padre de que proceso (forma arbol)");
    printf("\033[9;0H 6) Muestra trabajos en 2º plano");
    printf("\033[10;0H 7) Todos los procesos del ordenador, mostrando usuario y en forma de arbol");

    printf("\033[11;0H 8) Parar un proceso");
    printf("\033[12;0H 9) Continuar un proceso");
    printf("\033[13;0H10) Terminar un proceso");
    printf("\033[14;0H11) Matar un proceso");
    printf("\033[15;0HNúmero de la opción:           ");
    printf("\033[15;21H");        // para que se ponga en la misma linea del nº de opcion

}

void ejecutar_ps_completo(){
int c = 0;
    FILE *pf;
    char texto[5455];
    char *p;
    char proceso[100];
    char *lista_proceso[1000] ;
    int ac=0;//
    int pos_espacio1=0;
    int pos_espacio2=0;
    int b=0;
    p = texto;

// obtengo los datos de la linea de procesos
   pf = popen("ps a u x f", "r");

    fgets(texto,5450, pf);
    c++;

/* no me funciona !!!!!!
    while (!feof(pf)) {
     fgets(texto, 5450, pf);
        c++;
//printf("%s \n",texto);

    // analizo linea....
//sprintf(linea2,"%3d: %s", c, texto);
linea[c].num=c;

// buscar el primer " "
pos_espacio1=buscaespacio1(texto);
pos_espacio2=buscaespacio2(pos_espacio1,texto);

//printf("%3d , %3d \n %s \n",pos_espacio1,pos_espacio2,texto);

// asignar el trozo que hemos seleccionado
b=-1;
ac=pos_espacio1-1;
while (ac<pos_espacio2){
b++;
ac++;
proceso[b]=texto[ac];

}

proceso[b+1]='\0';

//printf("%3d , %3d, proceso: %s \n %s \n",pos_espacio1,pos_espacio2,proceso,texto);

strcpy(lista_proceso[linea[c].num],proceso);

//printf("%3d %s \n",linea[c].num,proceso);

    }
pclose(pf);

*/

// escribo en pantalla los procesos

    pf = popen("ps a u x f", "r");
c=-1;
    fgets(texto, 350, pf);
    c++;
printf("     %s", texto); // dibuja rotulo

    while (!feof(pf)) {
     fgets(texto, 350, pf);
        c++;
printf("%3d: %s",c, texto);
    }
pclose(pf);

}

int buscaespacio1(char *texto){
    int a=0;
    int paso1=0;
    int c=0;
    while (a!=1){
        if (texto[c]==' '){
            paso1=1;

        } else {
        if (paso1==1 && texto[c]!=' '){
            return c;
        }
       }
        c++;
    }
return 0;
}

int buscaespacio2(int inicio,char *texto){
    int a=0;
    int paso1=0;
    int c=inicio;
    while (a!=1){
        if (texto[c]==' '){
            paso1=1;
            return c;
        }
        c++;
    }
    return 0;
}

Examen 7: Crear el comando "mata"

2012-07-12T10:51:00.001-07:00

El programa debe permitir gestionar los procesos en ejecución del usuario, dando la posibilidad de finalizar alguno de ellos.

Opcional: Impedir que el programa se mate a si mismo.

solucion 6: alumno

2012-07-12T10:50:00.003-07:00

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

void presentar_calendario();
void relleno_tareas();
void relleno_tareas_diarias();
void presentar_menu();
void anadir();
void editar();
void rehacer_pantalla(int muestra);
void annadir_tarea_diaria();

int main(int argc, char **argv) {
    int op = 1;
    char entrada_texto[10];
    char cadena[20];
    int muestra = 1;            // tareas: periodo 1, dia 0
    char otrotexto[20]; //

    rehacer_pantalla(muestra);

    while (op != 0) {
        op = atoi(gets(entrada_texto));
        if (op == 1) {
            anadir();
            rehacer_pantalla(muestra);
        } else if (op == 2) {
            annadir_tarea_diaria();
            rehacer_pantalla(muestra);
        } else if (op == 4) {
            if (muestra == 1) {
                muestra = 0;

            } else
                muestra = 1;
            rehacer_pantalla(muestra);
        }

        //borrar tarea diaria
        if (op==3) {

            printf("Numero: ");
            strcpy(otrotexto, gets(cadena));
            //sprintf("atrm %s",otrotexto);
            //printf("lo que va a ejecutar es: atrm %s",otrotexto);
            sprintf(cadena,"atrm %s",otrotexto);
            printf("%s",cadena);
            system(cadena);
            rehacer_pantalla(0);
        }

        if (op == 9) {
            op = 0;
        } else {
            op = 10;
        }

    }
    system("clear");
    system("echo Fin del programa");
// printf("\033[40;0H");
    return 0;
}

void presentar_calendario() {
    int c = 0;
    FILE *pf;
    char texto[255];
    char *p;
    p = texto;
    pf = popen("cal", "r");
    printf("\033[47m\033[34m\033[0;550H");
    fgets(texto, 80, pf);
    c++;
    while (!feof(pf)) {
        printf("\033[47m\033[34m\033[0%d;55H", c);
        printf("%21s\033[0m", texto);
        fgets(texto, 80, pf);
        c++;
    }
    pclose(pf);

    pf = popen("date +\"%A %d %B %Y\" ", "r");
    fgets(texto, 80, pf);
    c++;
    while (!feof(pf)) {

        printf("\033[1;1HFecha: %s", texto);
        fgets(texto, 80, pf);
        c++;
    }
    pclose(pf);
}

void relleno_tareas() {

    printf("\033[11;1H\033[47m\033[32m                    Listas de Tareas Programas Periodicas                  \033[0m\n");
    int c = 0;
    FILE *pf;
    char texto[255];
    char *p;
    p = texto;
    pf = popen("crontab -l", "r");
    //printf("\033[47m\033[34m\033[0;550H" );
    fgets(texto, 80, pf);
    c++;
    while (!feof(pf)) {
        //printf("\033[47m\033[34m\033[0%d;55H",c );
        //printf("%s\033[0m",texto);
        printf("%2d:%s", c, texto);
        fgets(texto, 200, pf);
        c++;
    }
    pclose(pf);
}

void presentar_menu() {

    printf("\033[47m\033[1;35m\033[2;0H       Menu:      \033[0m\n");
    printf("\033[3;0H9)Salir del programa\n");
    printf("\033[4;0H1)Editar crontab.txt con nano para tareas periodicas\n ");
    printf("\033[5;0H2)Añadir tarea del dia\n");
    printf("\033[6;0H3)Borrar tarea del dia\n");
    printf("\033[7;0H4)Mostrar tareas Periodicas/Diarias");
    printf("\033[9;0HNúmero de la opción:           ");
    printf("\033[9;21H");

}

void anadir() {
    system("nano ~/.calendar/crontab.txt"); // edito crontab
    system("crontab ~/.calendar/crontab.txt"); //actualizo mi crom
}

void annadir_tarea_diaria() {
    char hora[40];
    char minutos[40];

    char entrada_texto[200];
    char cadena[500];
    char cadena_ejemplo[400];

    system("clear");
    printf("Introduce tarea del dia:\n");
    printf("Hora:");
    strcpy(hora, gets(entrada_texto));
    printf("\nMinutos:");
    strcpy(minutos, gets(entrada_texto));
    sprintf(cadena, "at %s:%s", hora, minutos);

    printf("\nEjemplo de notificación:\n");
    sprintf(cadena_ejemplo,"notify-send \"hola\" -i /usr/share/pixmaps/gnome-home.png ");
     printf("%s\n",cadena_ejemplo);
    printf("\n Para salir pulse Crtl+D \n");

    // ejecuto el comando at hora: minutos
    system(cadena);
    //salida ordenada
    printf("\n");
    printf("\n");
    printf("Pulse una tecla\n");
    gets(entrada_texto);

}

void rehacer_pantalla(muestra) {
    int resp;
    resp = system("clear");
    presentar_calendario();
    if (muestra == 1) {
        relleno_tareas();
    } else {
        relleno_tareas_diarias();
    }
    presentar_menu();
}

void relleno_tareas_diarias() {

    printf("\033[11;1H\033[47m\033[35m                    Listas de Tareas Diarias                                \033[0m\n");
    int c = 0;
    FILE *pf;
    char texto[255];
    char *p;
    p = texto;
    pf = popen("atq", "r");

    fgets(texto, 80, pf);
    c++;
    while (!feof(pf)) {
        printf("%2d:%s", c, texto);
        fgets(texto, 80, pf);
        c++;
    }
    pclose(pf);

}

Examen 6: Gestión de trareas y notificarlas

2012-07-12T10:50:00.001-07:00

Crear programa que permita gestionar tareas y que las notifique el usuario el día adecuado.

Nuestro programa debe mostrar el calendario del mes actual junto con las tareas del día; además, debe permitir añadir, modificar, y eliminar tareas para un dia concreto.

Las tareas, pueden ser periódicas, de forma que se repitan cada día, cada semana, cada mes, o cada año, o simplemente que no se repitan.

El programa puede tener interfaz de usuario basada en menu o en argumentos. A elección del programa.

Opcional: Las tareas se asignan a días, no a horas concretas, por lo que la gestión de horas es opcional.

examen 5 solucion compi. Antonio

2012-07-12T10:49:00.001-07:00

Antonio, es otro alumno del curso, que ha resuelto el problema de otra forma (aunque no resuelve el caso de que le demos un fichero). Pero como siempre es interesante ver las distintas formas resolver el problema, aqui os lo dejo:

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <pwd.h>
#include <grp.h>

#define FALSE 0
#define TRUE !0

void VerResultado(char *, struct stat *,int ,int);       //Función que te muestra los resultados de lsl dependiendo de los argumentos.
void permisos (char *, struct stat *);                   //Función que nos compara st_mode con sus banderas y nos escribe las letras en la cadena perm.

int main(int argc, char **argv) {
   DIR *pdir;                           // declaramos un puntero de tipo DIR que permite manejar directorios.
   char nomcomp[255];
   struct stat st;                       // variable st de tipo strut stat.
   struct dirent *dp;                   // puntero dp de tipo struct dirent.
   int c=1;
   int argumento_a=0;
   int argumento_c=0;

   while(c<argc) {                       // Mientras c sea menor que el número de palabras introducidas, sigue comprobando.
       if(strcmp(argv[c],"-a")==0) {
           argumento_a=TRUE;
       } else {
           if(strcmp(argv[c],"-c")==0) {
               argumento_c=TRUE;
           } else {
               if(strcmp(argv[c],"-ac")==0 || (strcmp(argv[c],"-ca")==0 )) {
                   argumento_c=TRUE;
                   argumento_a=TRUE;
               } else {
                   if(argumento_c==TRUE && argumento_a==TRUE) { //Si ya tiene los 2 argumentos, se sale del bucle.
                       c=argc;
                   } else {
                       pdir = opendir(argv[c]);           //si el argumento no es válido intentamos abrir (argv[c]) como directorio.
                       if (pdir == NULL) {                   // si no se puede abrir ese directorio nos dara error y se saldra del programa.
                           perror(argv[0]);               // nos devuelve el mensaje de error actual de tu programa (perror)
                           exit(-1);
                       }
                   }
               }
           }
       }
       c++;                                               //Aseguramos la salida sumando 1 a c.
   }

   pdir = opendir(argv[argc-1]);           // abrimos un directorio que lo recibimos en argv[argc-1] y lo pasamos al puntero pdir (opendir)
   if (pdir == NULL) {
       pdir = opendir(".");               //si no se puede abrir argv[argc-1](se supone que es el directorio),abriremos el actual(significará que se ha escrito solo lsl porque si nos falla por un argumento inválido ya lo tenemos controlado anteriormente)
       if (pdir == NULL) {                   // si no se puede abrir ese directorio nos dara error y se saldra del programa.
           perror(argv[0]);               // nos devuelve el mensaje de error actual de tu programa (perror)
           exit(-1);
       }
       strcpy(argv[argc-1],".");           // Si consigue abrir el directorio actual, le decimos que el actual es "." que si es el directorio válido.
   }

   dp = readdir(pdir);                   // si la linea 24 ha funcionado, leemos una entrada del directorio (readdir) y la pasamos a dp
   while (dp != NULL) {               // mientras haya directorios que leer.
       sprintf(nomcomp, "%s/%s", argv[argc-1], dp->d_name);       // como dp es un puntero ponemos dp->d_name(sino fuera puntero dp.d_name que seria igual que la que teniamos en otro programa donde poniamos tablaRecords.nombre)
       if (stat(nomcomp, &st) < 0) {   // stat te devuelve un valor numerico y obtiene informacion de un fichero y me la guarda en &st(que hace referencia a la direccion de memoria donde se almacena esa variable)
           perror(nomcomp);
       } else {
           VerResultado(dp->d_name, &st,argumento_a,argumento_c);   // si obtiene la informacion y la ha podido guardar en st le pasamos a la funcion VerResultado el nombre fichero y la direccion de memoria donde esta almacenada su información.
       }
       dp = readdir(pdir);               // leo el siguiente nombre de archivo que haya en el directorio hasta que devuelva un NULL al puntero dp
   }
   closedir(pdir);
   return 0;
}

// Funcion que muestra el nombre de fichero o directorio y la informacion detallada.

void VerResultado(char *nomfich, struct stat *st,int argumento_a,int argumento_c) {   // recifimos un puntero llamado nomfich y un puntero a la variable st de tipo struct stat
   struct tm *t;                                   // creamos una structura del tipo tm y la manejamos por medio del puntero t
   struct passwd *pwu;                               // creamos otras 2 estructuras para el id de grupo y se usuario.
   struct group *pwg;
   char perm[10];

   t = gmtime(&st->st_mtime);                       // a t le pasamos la funcion gmtime(coge el numero q te da st_mtime y lo desglosa en horas,minutos,segundos,etc) le indicamos el trozo de memoria de st ,mtime
   pwu = getpwuid(st->st_uid);                       // a pwu y pwg le pasamos los nombres de usuario y grupo respectivamente.
   pwg = getgrgid(st->st_gid);
   permisos(perm,st);                               // declaramos la función permisos, que nos devuelve la variable perm con los permisos en letras.

   if(argumento_a==TRUE && argumento_c==FALSE) {
       printf("%s %3d %s %s %8ld bytes %02d/%02d/%4d %02d:%02d:%02d %-20s\n",
           perm,
           st->st_nlink,
           pwu->pw_name,
           pwg->gr_name,
           st->st_size,
           t->tm_mday,
           t->tm_mon + 1,
           t->tm_year + 1900,
           t->tm_hour,
           t->tm_min,
           t->tm_sec,
           nomfich);
   } else {
       if(argumento_a==TRUE && argumento_c ==TRUE) {
           printf("%20s\n",nomfich);       //Nos muestra directorios y ficheros y además ocultos cada uno en una línea.
       } else {
           if(nomfich[0]!='.') {       //Si el argumento a es FALSE(no muestra los ocultos),imprime los directorios visibles.
               if(argumento_a==FALSE && argumento_c==TRUE) {
                   printf("%20s\n",nomfich);
               } else {
                   if(argumento_a==FALSE && argumento_c==FALSE) {   //Si no se especifica ningun argumento.
                       printf("%s %3d %s %s %8ld bytes %02d/%02d/%4d %02d:%02d:%02d %-20s\n",
                           perm,                   //variable que contiene una cadena de caracteres con los permisos.
                           st->st_nlink,
                           pwu->pw_name,
                           pwg->gr_name,
                           st->st_size,
                           t->tm_mday,
                           t->tm_mon + 1,
                           t->tm_year + 1900,
                           t->tm_hour,
                           t->tm_min,
                           t->tm_sec,
                           nomfich);
                   }
               }
           }
       }
   }
}

// Procedimiento que te escribe los permisos en letras.

void permisos (char *perm, struct stat *st) {       //comparamos st_mode con sus banderas para escribir los permisos en perm.

   if (S_ISDIR(st->st_mode)) {                       //es un directorio?
       perm[0] = 'd';
   } else if(S_ISLNK(st->st_mode)) {               //es un enlace?
       perm[0] = 'l';
   } else {                                       //es un fichero?
       perm[0]= '-';
   }
   if (st->st_mode & S_IRUSR) {                   //tiene permiso de lectura el usuario?
       perm[1] = 'r';
   } else {
       perm[1] = '-';
   }
   if (st->st_mode & S_IWUSR) {                   //tiene permiso de escritura el usuario?
       perm[2] = 'w';
   } else {
       perm[2] = '-';
   }
   if (st->st_mode & S_IXUSR) {
       perm[3] = 'x';
   } else {
       perm[3] = '-';
   }
   if (st->st_mode & S_IRGRP) {
       perm[4] = 'r';
   } else {
       perm[4] = '-';
   }
   if (st->st_mode & S_IWGRP) {
       perm[5] = 'w';
   } else {
       perm[5] = '-';
   }
   if (st->st_mode & S_IXGRP) {
       perm[6] = 'x';
   } else {
       perm[6] = '-';
   }
   if (st->st_mode & S_IROTH) {
       perm[7] = 'r';
   } else {
       perm[7] = '-';
   }
   if (st->st_mode & S_IWOTH) {
       perm[8] = 'w';
   } else {
       perm[8] = '-';
   }
   if (st->st_mode & S_IXOTH) {
       perm[9] = 'x';
   } else {
       perm[9] = '-';
   }
}

examen 5: solucion alumno (usando colores)

2012-07-12T10:48:00.003-07:00

// Paginas web de referencia:
// tomado del: https://sites.google.com/site/fpoprogramadorsistemas/analisis-de-argumentos-2
// https://sites.google.com/site/fpoprogramadorsistemas/soluciones-profe-del-cat
#include <stdio.h>
#include <limits.h>
#include <string.h>

// https://sites.google.com/site/fpoprogramadorsistemas/c-trabajar-con-directorios
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>

// para datos del usuario: man getpwuid
#include <pwd.h>

//http://www.fismat.umich.mx/mn1/manual/node19.html
#include <unistd.h> // leer la ruta actual donde este el programa

#include <grp.h> // datos del grupo

void VerResultadoA(char *, struct stat *); //lsl -a: ocultos y visibles mas datos.
void escribedatos(char *, struct stat *);
void VerResultadoAC(char *, struct stat *); //lsl -aca: ocultos y visibles sin datos
void VerResultadoC(char *, struct stat *); //lsl -c: solo nombre de visibles
void VerResultadoLSL(char *, struct stat *); //lsl: de visibles mas datos
int comprobar_Directorio_o_Fichero(char *); // lsl comprobar directorio o fichero

int procesarArgumentos(int, char **);

DIR *pdir;
char *nomfich;
char nomcomp[255];
struct stat st;
struct dirent *dp;
FILE *pf;

char cadena[125]; // aqui guarda el directorio actual si solo ejecuto LSL

// procesa todos los argumentos que reciba, y devuelve un numero
// positivo= la suma de los valores de los argumentos
// negativo =hay argumentos pero no son validos
// cero= no hay ningun argumento

int argumento(char *); // procesa   cada argumento de forma

int esArgumento(char *); // comprueba que es un argumento

int main(int argc, char **argv)
{
    int resul;
    int numero_de_argumentos=0; // contador de argumentos
    int uno=0;
    int dos=0;

    int archivo=0;
    int valor=0;

// caso de lsl solo
// comprobacion si: es un archivo o directorio, y si existen....
    if (argc==1) {
        printf("Se trata del comando lsl solo.\n");
        // se trata de solo la orden lsl
        pdir = opendir(".");
        dp = readdir(pdir);
        while (dp != NULL) {
            sprintf(nomcomp, "%s/%s", ".", dp->d_name);
            nomfich = dp->d_name;

            if (stat(nomcomp, &st) < 0) {
                perror(nomcomp);
            } else {
                VerResultadoLSL(nomfich, &st);
            }
            dp = readdir(pdir);
        }
        closedir(pdir);
        return 0; // termino el programa aqui

    }

// hay mas de 1 arguento......

// PROCESAR ARGUMENTOS......
    resul = procesarArgumentos(argc, argv);
    printf("Trabajo realizar: \n");
    if (resul > 0) { //
        if (resul & 1) { // Enmascaramiento Binario: pregunto por los numero &(=y logico a nivel de bits). (no es lo mismo que &&) posicion 1, vease final
            printf("Usado argumento \"a\"\n");
            numero_de_argumentos++;
            uno=1;
        }
        if (resul & 2) {
            printf("Usado argumento \"c\"\n");
            dos=1;
            if (uno!=1) {
                // para que no sume cuando la a esta tambien...
                numero_de_argumentos++;
            }
        }

    }

//***********************************************************************************
// dos= 1 ,numero de agumento =1
// uno=1, numero de agumento =1
// uno=1 y dos=1, numero de argumentos=2
//***********************************************************************************

// caso de lsl y directorio/fichero
    if (uno==0 && dos==0 && argc==2) {
// ver si es un archivo o un directorio y listar como si fuera lsl solo

        valor=comprobar_Directorio_o_Fichero(argv[1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
        if (valor==1) {
            pdir = opendir(argv[1]);
            dp = readdir(pdir);
            while (dp != NULL) {
                sprintf(nomcomp, "%s/%s", argv[1], dp->d_name);
                nomfich = dp->d_name;

                if (stat(nomcomp, &st) < 0) {
                    perror(nomcomp);
                } else {
                    VerResultadoLSL(nomfich, &st);
                }
                dp = readdir(pdir);
            }
            closedir(pdir);
            return 0; // termino el programa aqui

        }
        if (valor==2) {
            if((pf = fopen(argv[1], "r")) != NULL) {
                // es un archivo... lo que nos han pasado
                archivo=1;
                //Importante: cargo con la funcio stat los datos del fichero a st
                if (stat(argv[1], &st) < 0) {
                    perror(argv[1]);
                } else {

                    VerResultadoLSL(argv[1], &st);
                }
                fclose(pf);
            } else {
                printf("Error: no encuentro el fichero");
            }

            return 0;
        }
    }

// caso de lsl un argumento y sin nada: caso a al directorio actual
    if (uno==1 && dos==0 && argc==2) {
        // ver si es un archivo o un directorio y listar como si fuera lsl solo
        pdir = opendir(".");
        dp = readdir(pdir);
        while (dp != NULL) {
            sprintf(nomcomp, "%s/%s", ".", dp->d_name);
            nomfich = dp->d_name;

            if (stat(nomcomp, &st) < 0) {
                perror(nomcomp);
            } else {
                VerResultadoA(nomfich, &st);
            }
            dp = readdir(pdir);
        }
        closedir(pdir);
        return 0; // termino el programa aqui

    }

// caso de lsl un argumento y sin nada: caso c

    if (uno==0 && dos==1 && argc==2) {
        // ver si es un archivo o un directorio y listar como si fuera lsl solo

        pdir = opendir(".");
        dp = readdir(pdir);
        while (dp != NULL) {
            sprintf(nomcomp, "%s/%s", ".", dp->d_name);
            nomfich = dp->d_name;

            if (stat(nomcomp, &st) < 0) {
                perror(nomcomp);
            } else {
                VerResultadoC(nomfich, &st);
            }
            dp = readdir(pdir);
        }
        closedir(pdir);
        return 0; // termino el programa aqui

    }

// caso de lsl un argmento y con directorio/fichero: caso a
    if (uno==1 && dos==0 && argc==3) {

        valor=comprobar_Directorio_o_Fichero(argv[3-1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
        if (valor==1) {
            pdir = opendir(argv[3-1]);
            dp = readdir(pdir);
            while (dp != NULL) {
                sprintf(nomcomp, "%s/%s",argv[3-1] , dp->d_name);
                nomfich = dp->d_name;
                if (stat(nomcomp, &st) < 0) {
                    perror(nomcomp);
                } else {
                    VerResultadoA(nomfich, &st);
                }
                dp = readdir(pdir);
            }
            closedir(pdir);
            return 0; // termino el programa aqui

        }
        if (valor==2) {
            if((pf = fopen(argv[3-1], "r")) != NULL) {
                // es un archivo... lo que nos han pasado
                archivo=1;

                if (stat(argv[3-1], &st) < 0) {
                    perror(argv[3-1]);
                } else {

                    VerResultadoA(argv[3-1], &st);
                }
                fclose(pf);

            }
            return 0;
        }

    }

// caso de lsl un argmento y con directorio/fichero: caso c
    if (uno==0 && dos==1 && argc==3) {
        valor=comprobar_Directorio_o_Fichero(argv[3-1]);

// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
        if (valor==1) {
            pdir = opendir(argv[3-1]);
            dp = readdir(pdir);
            while (dp != NULL) {
                sprintf(nomcomp, "%s/%s",argv[3-1] , dp->d_name);
                nomfich = dp->d_name;
                if (stat(nomcomp, &st) < 0) {
                    perror(nomcomp);
                } else {
                    VerResultadoC(nomfich, &st);
                }
                dp = readdir(pdir);
            }
            closedir(pdir);
            return 0; // termino el programa aqui

        }
        if (valor==2) {
            if((pf = fopen(argv[3-1], "r")) != NULL) {
                // es un archivo... lo que nos han pasado
                archivo=1;

                if (stat(argv[3-1], &st) < 0) {
                    perror(argv[3-1]);
                } else {
                    VerResultadoC(argv[3-1], &st);
                    fclose(pf);
                }
                return 0;
            }

        }
    }

// caso de lsl dos argumentos y sin nada: lsl -a -c ó es -a-c
    if (uno==1 && dos==1 && argc==2) {
        pdir = opendir(".");
        dp = readdir(pdir);
        while (dp != NULL) {
            sprintf(nomcomp, "%s/%s","." , dp->d_name);
            nomfich = dp->d_name;

            if (stat(nomcomp, &st) < 0) {
                perror(nomcomp);
            } else {
                VerResultadoAC(nomfich, &st);
            }
            dp = readdir(pdir);
        }
        closedir(pdir);
        return 0; // termino el programa aqui

    }

// caso de lsl dos argumentos con fichero: lsl -a -c ó es -ac ó es -ca + fichero
    if (uno==1 && dos==1 && argc==3) {
        valor=comprobar_Directorio_o_Fichero(argv[3-1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
        if (valor==1) {
            pdir = opendir(argv[3-1]);
            dp = readdir(pdir);
            while (dp != NULL) {
                sprintf(nomcomp, "%s/%s",argv[3-1], dp->d_name);
                nomfich = dp->d_name;

                if (stat(nomcomp, &st) < 0) {
                    perror(nomcomp);
                } else {
                    VerResultadoAC(nomfich, &st);
                }
                dp = readdir(pdir);
            }
            closedir(pdir);
            return 0; // termino el programa aqui
        }

        if (valor==2) {
            if((pf = fopen(argv[3-1], "r")) != NULL) {
                // es un archivo... lo que nos han pasado
                archivo=1;

                if (stat(argv[3-1], &st) < 0) {
                    perror(argv[3-1]);
                } else {

                    VerResultadoC(argv[3-1], &st);
                    fclose(pf);
                }
                return 0;
            }
        }
    }

// caso de lsl dos argumentos y con directorio o fichero
    if (uno==1 && dos==1 && argc==4) {
        valor=comprobar_Directorio_o_Fichero(argv[4-1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
        if (valor==1) {
            pdir = opendir(argv[4-1]);
            dp = readdir(pdir);
            while (dp != NULL) {
                sprintf(nomcomp, "%s/%s",argv[4-1] , dp->d_name);
                nomfich = dp->d_name;
                if (stat(nomcomp, &st) < 0) {
                    perror(nomcomp);
                } else {
                    VerResultadoAC(nomfich, &st);
                }
                dp = readdir(pdir);
            }
            closedir(pdir);
            return 0; // termino el programa aqui

        }
        if (valor==2) {
            if((pf = fopen(argv[4-1], "r")) != NULL) {
                // es un archivo... lo que nos han pasado
                archivo=1;

                if (stat(argv[4-1], &st) < 0) {
                    perror(argv[4-1]);
                } else {
                    VerResultadoAC(argv[4-1], &st);
                    fclose(pf);
                }
                return 0;
            }

        }

    }
    return 0;

}

//-------------------------------------------------------------------------------
// FIN DEL MAIN
//-------------------------------------------------------------------------------

//-------------------------------------------------------------------------------
// OTRAS FUNCIONES
//-------------------------------------------------------------------------------

// Procesa la lista de argumentos.
// Devuelve un nº positivo indicando la suma de los argumentos empleados
// Negativo si alguna letra no es válida

int procesarArgumentos(int argc, char **argv)
{
    char usados[100] = "";
    int c = 0;
    int suma = 0;
    char *argu; // para procesar la lista de argumentos

    int valor;
    char *posUsados;
// para buscar en la tabla de usados
// el argumento 0 no lo proceso ya que es el nombre del programa, y empieza por el c=1
    for (c = 1; c < argc; c++) {
        argu = argv[c];

        if(esArgumento(argu)) {
            //sumo al puntero 1 posicion, me desplazo a la derecha una posicion
            //(salto al signo menos que no me interesa analizar ahora dentro de la cadena)

            argu++;

            //*argu=conenido a lo que apuntaba argu: la letra "a" en asci no vale cero,
            // por lo tanto cumple la condicion de que sea distinto de cero
            // cuando encuentre \0, el valor numerico es 0, con lo cual parará el while.
            while (*argu) {
                valor = argumento(argu);

                // 0 es cuando no tenga signo menos, y negativo cuendo no lo encuentra en la tabla
                if (valor > 0) {
                    posUsados = strchr(usados, *argu);
                    // si el usuario pone varias veces el mismo argumento, solo lo cuenta una vez

                    //si no lo he encontrado lo meto en la tabla
                    if (posUsados == NULL) {
                        usados[strlen(usados)] = *argu;
                    } else {
                        // si la he encontrado, es porque ha repetido el valor
                        valor = 0;
                    }
                }
                // calculo la suma de todos los arguemntos
                suma += valor;
                //me desplazo al siguiente argumento
                argu++;
            }
        }
    }
    return suma;
}

// Procesa un argumento de forma individual
// Devuelve INT_MIN si no es válido y positivo si lo es (2 ^ posicion)

int argumento(char *argu)
{

// los argumentos validos van a ser: a,c
// el comando -l ya lo doy visto

    char valen[] = { "ac" };

    // tabla sin tamaño definido([]), el compilador cuenta los elementos "abcdef",
    // y lo dimensiona automaticamente, tambien valdria: char valen[6]={ "abcdef" }

    char *pos;
    int dif; // es la diferencia....

    if ((pos = strchr(valen, argu[0]))) {
        // la asignación pos=strchr. La función strchr te busca un caracter en una cadena:
        // si lo encuentra lo que hace es que pos apunte al caracter,
        // y la expresion (pos=strchr(valen, *argu[0])) la evalua el if.
        // si strchr() devuelve una posicion, pos = esa posicion, con lo cual es correcto(verdadero)
        // si strchr() no devuelve nada (NULL), no lo ha encontrado, pos=NULL, con lo cual el falso

        dif = (pos - valen); // se pueden hacer operaciones aritmeticas con los puntero,
        // se estan restando las posiciones.
        // por ejemplo si pos marcaria 12034, y si valen marcaria 12035, dif=1

        return (1 << dif); // << operador binario que trabaja con bits, y hace desplazamiento a la izquierda
    } else {
        return INT_MIN; //
    }
}

int esArgumento(char *argu)
{
// en el puntero *argu, (guarda la posicion donde esta apuntando)
//...y nos puede mostrar el contenido a donde apunta:

    if (*argu == '-') {
        // si el primer carater es '-' es un argumento.
        return 1; // verdadero
    }
    return 0; // falso
}

//------------------------------------------------------------------------------------------
void VerResultadoA(char *nomfich, struct stat *st)
{
    escribedatos(nomfich,st); // todos, incluidos los ocultos
}

void VerResultadoAC(char *nomfich, struct stat *st)
{
    // voy a colorear segun sea fichero,directorio,o enlace

    struct tm *t;
    struct passwd *p;
    struct group *p2;
    struct stat atributos;
    char permiso[13];
    t = gmtime(&st->st_mtime);
    int ejecutable=0;
    int directorio=0;
    int enlace=0;
    int fichero=0;


    lstat(nomfich,&atributos); // leo todos los atributos de nomfich


    if((atributos.st_mode & S_IXUSR)!=0) {

        ejecutable=1;
    } else {

    }


    if( S_ISDIR(st->st_mode )) {

        directorio=1;
    } else {
        if(( S_ISREG(st->st_mode ))) {
            //ES UN FICHERO

            fichero=1;
        } else {
            if((S_ISLNK(st->st_mode ))) {
                // es un enlace Simbolico

                enlace=1;
            }
        }
    }


if (ejecutable==1 && fichero==1 ) {
        // lo pongo en verde
        printf("\033[0;32m %-20s \033[m\n", nomfich);
    }

    if (directorio==1) {
        // lo pongo en azul
        printf("\033[0;34m %-20s \033[m\n", nomfich);
    } else {
        if (fichero==1 && ejecutable==0) {
            // lo pongo en gris claro
            printf("\033[1;30m %-20s \033[m\n", nomfich);
        }
    }
}

void VerResultadoC(char *nomfich, struct stat *st)
{
    if (nomfich[0]!='.') {
        // se trata visible
        VerResultadoAC(nomfich,st);
    }

}

void VerResultadoLSL(char *nomfich, struct stat *st)
{

// muestro todos los archivos (incluido los ocultos)

    escribedatos(nomfich,st);

}

//-----------------------------------------------------------------------------------------------
// Funcion para saber si lo me pasan es un directorio o un fichero
//----------------------------------------------------------------------------------------------
// intento abrirlo con opendir(),
// si me da error no es un directorio en caso contrario es un directorio y devuelve 1
// si ha dado error en opendir(), intento abrirlo como un fichero fopen(), si no da error es un fichero y
// devuelve 2, en caso contrario devuelve 0

// devuelve 1 si es directorio.
// devuelve 2 si es fichero.

int comprobar_Directorio_o_Fichero(char *argumento)
{

    pdir = opendir(argumento);
    if (pdir != NULL) {
        // es un directorio.... lo que nos han dado
        //directorio=1;
        printf("directorio: %s\n",argumento);
        closedir(pdir);
        return 1;
    } else {
        if((pf = fopen(argumento, "r")) != NULL) {
            // es un archivo... lo que nos han pasado
            //    archivo=1;
            printf("Fichero: %s\n",argumento);
            fclose(pf);
            return 2;
        }
    }
    return 0;
}

void escribedatos(char *nomfich, struct stat *st)
{
    struct tm *t;
    struct passwd *p;
    struct group *p2;
    struct stat atributos;
    char permiso[13];
    t = gmtime(&st->st_mtime);
    p=getpwuid(st->st_uid);
    p2=getgrgid(st->st_gid);
    int ejecutable=0;
    int directorio=0;
    int fichero=0;
    int enlace=0;
    // http://www.juntadeandalucia.es/averroes/iesbajoguadalquivir/inf/dfsi/lstat.c
    lstat(nomfich,&atributos);
    //    printf("\nPermisos:\n");

// p=passwd(&);
    printf("%8ld bytes %02d/%02d/%4d %02d:%02d:%02d %-10s %-10s ",
           st->st_size,
           t->tm_mday,
           t->tm_mon + 1,
           t->tm_year + 1900,
           t->tm_hour,
           t->tm_min,
           t->tm_sec,

           // ------------------
           // t->tm_nlink ,

           p->pw_name,
           p2->gr_name);
    //-------------------

    // es un directorio
    if( S_ISDIR(st->st_mode )) {
        printf(" D ");
        directorio=1;
    } else {
        if(( S_ISREG(st->st_mode ))) {
            //ES UN FICHERO
            printf(" F ");
            fichero=1;
        } else {
            if((S_ISLNK(st->st_mode ))) {
                // es un enlace Simbolico
                printf(" E ");
                enlace=1;
            }
        }
    }

    if((atributos.st_mode & S_IRUSR)!=0) {
        printf("r");
    } else {
        printf("-");
    }
    if((atributos.st_mode & S_IWUSR)!=0) {
        printf("w");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_IXUSR)!=0) {
        printf("x");
        ejecutable=1;
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_IRGRP)!=0) {
        printf("r");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_IWGRP)!=0) {
        printf("w");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_IXGRP)!=0) {
        printf("x");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_IROTH)!=0) {
        printf("r");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_IWOTH)!=0) {
        printf("w");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_IXOTH)!=0) {
        printf("x");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_ISUID)!=0) {
        printf("1");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_ISGID)!=0) {
        printf("2");
    } else {
        printf("-");
    }

    if((atributos.st_mode & S_ISVTX)!=0) {
        printf("t");
    } else {
        printf("-");
    }

    if (ejecutable==1 && fichero==1 ) {
        // lo pongo en verde
        printf("\033[0;32m %-20s \033[m\n", nomfich);
    }

    if (directorio==1) {
        // lo pongo en azul
        printf("\033[0;34m %-20s \033[m\n", nomfich);
    } else {
        if (fichero==1 && ejecutable==0) {
            // lo pongo en gris claro
            printf("\033[1;30m %-20s \033[m\n", nomfich);
        }
    }

}

Examen 5: crear comando lsl

2012-07-12T10:48:00.001-07:00

Crear un programa llamado "lsl.c" que realice la misma tarea que el comando ls -l.

Formato:
lsl [opciones] [fichero...]

Nuestro programa debe admitir los argumentos -a y -c y toda combinación de ellos, es decir, puede admitirlo de forma individual, usando dos de ellos, usando los dos o sin usar ninguno.

Además, los argumentos deber pode unirse, es decir, se considerará un argumento válido -ac y debe interpretarse como los argumentos -a y -c

Descripción de los argumentos:
-a Muestra tambien los ficheros y directorios ocultos.
-c Muestra solo los nombres de ficheros y directorios, cada uno en una linea
Cualquier otro argumentos, debe de ser tratado como un nombre de fichero o directorio.

Fecha limite de entrega: Viernes 11 de marzo de 2011.

Nota:
Traducción del enunciado:

solucion 4 alumno

2012-07-12T10:47:00.001-07:00

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

float operacion(char *,float,float);// char es operacion, 1º float es resultado, 2º float en numero que carga

int main(int argc, char **argv)
{
    int c=0; // contador
    float resultado=0; // contiene el resulado
    char operador[10]; // contiene la operacion que estoy analizando
    float numero=0; // arguemento convertido en numero

//    while (c<argc) {
//        printf("Argumento nº %d, es el %s \n",c,argv[c]);
//        c++;
//    }

    c=1;
        strcpy(operador,"+");
    while (c<argc) {

        if (strcmp(argv[c],"-")==0) {
            strcpy(operador,"-");
        } else {
            if (strcmp(argv[c],"+")==0) {
                strcpy(operador,"+");
            } else {
                if (strcmp(argv[c],"x")==0) {
                    strcpy(operador,"x");
                } else {
                    if (strcmp(argv[c],"/")==0) {
                        strcpy(operador,"/");
                    } else {
                        // o es numero o un operador desconocido...

                        //convierto el argumento en un numero float
                        numero=atof(argv[c]);
                        resultado=operacion(operador,resultado,numero);
                        strcpy(operador," "); // reinicio el operador, lo siguiente tiene que ser un operador
                    }
                }

            }
        }
        c++;
    }

    printf("%f\n",resultado);
    return 0;

}

// funcion de realizacion de operacion
float operacion(char *ope,float resultado,float numero)
{
    if (strcmp(ope,"-")==0) {
        return resultado-numero    ;
    }

    if (strcmp(ope,"+")==0) {
        return resultado+numero    ;
    }

    if (strcmp(ope,"x")==0) {
        return resultado*numero    ;
    }

    if (strcmp(ope,"/")==0) {
        return resultado/numero    ;
    }

    printf("Error: operador no entindido %s",ope);

return 1;

}

nota:
El * me daba problemas con lo cual tuve que poner "x" , supongo que el sistema entiende que es un comodin.

Examen 4: calculadora no interactiva

2012-07-12T10:46:00.003-07:00

Programa: Calculadora no interactiva.

Hacer una calculadora que pueda multiplicar, dividir, sumar y restar, pero que no se interactiva. Osea que en la linea de comando se le diga la operación que tiene que resolver. Resolviendolo de izquiera a derecha sin preferencia de operadores. (y se le pueden poner varias operaciones)

examen 3: solución del profe

2012-07-12T10:46:00.001-07:00

Vease:

Ver tema:

Analisis de argumentos 2: << ( desplazamiento binario) y enmascaramiento binario

examen 3: solución del alumno (2º variante): Con uso de estructuras y switch case

2012-07-12T10:45:00.001-07:00

//examen 3: solución del alumno (2º variante): Con uso de estructuras y switch case (en pruebas)
//      wcjsbsan.c
//
//      Copyright 2011 julio
//
// Usando estructuras para los distintos casos de argumentos. y switch Case

#include <stdio.h>
#include <string.h> // manejamos cadenas (copiar, comparar)

// defino funciones....
void contar(int,int,int,char *);
// primer argumento es si cuento caracteres
// segundo argumento es si cuento palabras " ","\t","\n"
// tercero argumento es si cuento lineas "\n"
// cuarto argumento es el nombre del archivo

// crear estructura de opciones de argumentos y tareas a hacer....
typedef struct {
    char nombre[15]; //14 caracteres (+1 de /0): adminteria -adfk y -a (por ejemplo)
    int tarea; // un numero que especifique que tarea hara...
} tipoopciones;

int main(int argc, char **argv) {
    // vemos los argumentos que nos han introducido....

    int c=0; // contador
    int d=0; //contador 2
    int posicion_nombre_archivo=0;          // guarda donde esta el archivo en los argumentos

// estas variables hacen una funcion de "interruptores"
    int contarpalabra=0; // si vale 0 no las contará, si vale 1 contara palabras
    int contarlinea=0;// si vale 0 no las contará, si vale 1 contara lineas
    int contarcaracter=0; // si vale 0 no las contará, si vale 1 contara caracteres


    int errores=0;//contar errores (introduccion de parametros no validos

    while (c<argc) {
        printf("Argumento nº %d, es el %s \n",c,argv[c]);
        c++;
    }

    tipoopciones opcion[17]; //maximo numero de argumentos que nos va ha aceptar el programa

    // reviso cada argumento, si la primera letra es un - (guion),
    // se trata de un argumento a analizar, sino es el nombre del archivo a analizar...

// tabla de opciones posibles....

    strcpy(opcion[0].nombre,"-w");
    opcion[0].tarea=1; //contarpalabra=1

    strcpy(    opcion[1].nombre,"-l");
    opcion[1].tarea=2; //contarlinea=1

    strcpy(    opcion[2].nombre,"-c");
    opcion[2].tarea=3; //contarcaracter=1

    strcpy(opcion[3].nombre,"-wl");
    opcion[3].tarea=4;//contarpalabra=1 //contarlinea=1

    strcpy(    opcion[4].nombre,"-lw");
    opcion[4].tarea=4;//contarpalabra=1 //contarlinea=1

    strcpy(opcion[5].nombre,"--lines");
    opcion[5].tarea=2; //contarlinea=1

    strcpy(opcion[6].nombre,"--words");
    opcion[6].tarea=1; //contarpalabra=1

    strcpy(opcion[7].nombre,"-cw");
    opcion[7].tarea=8; //contarpalabra=1 //contarcaracter=1

    strcpy(opcion[8].nombre,"-wc");
    opcion[8].tarea=8; //contarpalabra=1 //contarcaracter=1

    strcpy(opcion[9].nombre,"-lc");
    opcion[9].tarea=9; //contarlinea=1 //contarcaracter=1

    strcpy(opcion[10].nombre,"-cl");
    opcion[10].tarea=9; //contarlinea=1 //contarcaracter=1

    strcpy(opcion[11].nombre,"-lwc");
    opcion[11].tarea=10; //contarlinea=1 //contarcaracter=1 //contarpalabra=1

    strcpy(opcion[12].nombre,"-wlc");
    opcion[12].tarea=10; //contarlinea=1 //contarcaracter=1 //contarpalabra=1

    strcpy(opcion[13].nombre,"-wcl");
    opcion[13].tarea=10; //contarlinea=1 //contarcaracter=1 //contarpalabra=1

    strcpy(opcion[14].nombre,"-cwl");
    opcion[14].tarea=10; //contarlinea=1 //contarcaracter=1 //contarpalabra=1

    strcpy(opcion[15].nombre,"-clw");
    opcion[15].tarea=10; //contarlinea=1 //contarcaracter=1 //contarpalabra=1

    strcpy(opcion [16].nombre,"-lcw");
    opcion[16].tarea=10; //contarlinea=1 //contarcaracter=1 //contarpalabra=1

    if (argc>20) {
        fprintf(stderr, "%s: %d: El numero de argumentos a superado los 20 elementos \n", argv[0], argc);
        errores++;
    }

    c=1;
    // caso
    while (c<argc) {
        if (argv[c][0]=='-') {
            // se trada de un argumento reviso la tabla....
            d=0;
            while (d<argc) {
                  //empiezo a comparar el argumento (c), con la lista de opciones que tengo
                if ( strcmp(argv[c],opcion[d].nombre)==0) {
                    switch(opcion[d].tarea) {
                    case 1:
                        contarpalabra=1;
                        break;
                    case 2:
                        contarlinea=1;
                        break;
                    case 3:
                        contarcaracter=1;
                        break;
                    case 4:
                        contarpalabra=1 ;
                        contarlinea=1;
                        break;
                    case 8:
                        contarpalabra=1 ;
                        contarcaracter=1;
                        break;
                    case 9:
                        contarlinea=1 ;
                        contarcaracter=1;
                        break;
                    case 10:
                        contarlinea=1 ;
                        contarcaracter=1;
                        contarcaracter=1;
                    default:
                        // en caso contrario las combinaciones de letras no valdrían...
                        fprintf(stderr, "%s: %s: Opcion no valia\n", argv[0], argv[c]);
                        errores++;
                    }
                }
            d++;
            }
        }    else {
            //sera el nombre del archivo
            if (argc>0) {
                posicion_nombre_archivo=c;
                break;
            } else {
                fprintf(stderr, "%s: %s: No se ha especificado nombre de archivo valido\n", argv[0], argv[0]);
            }
        }
        c++;
    }

    if (errores!=0) {
        return 1;
    }

    if (argc==2) {
        //significa que solo ha escrio el comando y el nombre de archivo
        //tenemos que ejecutar -w -l -c
        contarpalabra=1;
        contarlinea=1;
        contarcaracter=1;
    }

    fprintf(stdout, "wcjsb contara del archivo: %s\n",argv[posicion_nombre_archivo]);

    if (contarlinea==1) {
        fprintf( stdout, "contara lineas\n");
    }

    if (contarpalabra==1) {
        fprintf( stdout, "contara palabras\n");

    }
    if (contarcaracter==1) {
        fprintf( stdout, "contara caracteres\n");
    }

    contar(contarcaracter,contarpalabra,contarlinea,argv[posicion_nombre_archivo]);
    return 0;
}

void contar(int caracter,int palabra,int linea, char *archivo) {
    int numero_caracter=0;
    int numero_palabra=0;
    int numero_linea=0    ;
    FILE *pf;
    char letra;
    char letraAnterior;
    int errores=0;

    if((pf=fopen(archivo,"r"))==NULL) {
        fprintf(stderr, "%s: %s: No se puede abrir el fichero\n", archivo, archivo);
        errores++;

    } else {

        // Lee el primer caracter del archivo ¡porque es posible que el archivo este vacio!

        letra = fgetc(pf);
        letraAnterior = letra + 1; // asi nuestra letra anterior nos aseguramos que es distinta al anterior
        //numero_caracter++;

        // Mientras no sea fin de fichero
        while(!feof(pf)) {
            // tengo que analizar el caracter:
            if (palabra==1) {
                if ( ((letra==' ') || (letra=='\n') || (letra=='\t')) && (letra!=letraAnterior) ) {
                    // comprobramos que esta entre espacios y que no son espacios consecutivos (letra != letraAnterior)
                    numero_palabra++;
                }
            }

            if (linea==1) {
                if (letra=='\n') {
                    numero_linea++;
                }
            }
            numero_caracter++;
            letraAnterior = letra;
            letra = fgetc(pf);
        }
        // Cierra el archivo
        fclose(pf);

        // escribe resultado segun lo que nos hayan pedido....

        fprintf( stdout, "-------------Resultados-------------\n");

        if (linea==1) {
            fprintf( stdout, "Nº de lineas: %d\n",numero_linea);
        }

        if (palabra==1) {
            fprintf( stdout, "Nº de palabras: %d\n",numero_palabra);

        }

        if (caracter==1) {
            fprintf( stdout, "Nº de caracteres: %d\n",numero_caracter);
        }

        fprintf( stdout, "------------- fin -------------\n");

    }

}

examen 3: solución del alumno

2012-07-12T10:44:00.001-07:00

//      wcjsbsan.c
//
//      Copyright 2011 julio
//
#include <stdio.h>
#include <string.h> // manejamos cadenas (copiar, comparar)

// defino funciones....
void contar(int,int,int,char *);
// primer argumento es si cuento caracteres
// segundo argumento es si cuento palabras " ","\t","\n"
// tercero argumento es si cuento lineas "\n"
// cuarto argumento es el nombre del archivo

int main(int argc, char **argv)
{
    // vemos los argumentos que nos han introducido....

    int c=0; // contador
    char archivo[256]; // guarda el nombre del archivo: esto es una limitacion (ver comentario final)
                                 // posible mejora: int posicion_nombre_archivo=0
                                 // guarda donde esta el archivo en los argumentos

   // estas variables hacen una funcion de "interruptores"
    int contarpalabra=0; // si vale 0 no las contará, si vale 1 contara palabras
    int contarlinea=0;// si vale 0 no las contará, si vale 1 contara lineas
    int contarcaracter=0; // si vale 0 no las contará, si vale 1 contara caracteres


   int errores=0;//contar errores (introduccion de parametros no validos

    while (c<argc) {
        printf("Argumento nº %d, es el %s \n",c,argv[c]);
        c++;
    }

    // reviso cada argumento, si la primera letra es un - (guion),
    // se trata de un argumento a analizar, sino es el nombre del archivo a analizar...

    c=1;
    while (c<argc) {
        if (argv[c][0]=='-') {
            //se trata de un argumento a analizar
            if (strcmp(argv[c],"-w")==0) {
                contarpalabra=1;
            } else {

                if (strcmp(argv[c],"-l")==0) {
                    contarlinea=1;
                } else {
                    if (strcmp(argv[c],"-c")==0) {
                        contarcaracter=1;
                    } else {
                        if (strcmp(argv[c],"-wl")==0) {
                            contarpalabra=1;
                            contarlinea=1;
                        } else {
                            if (strcmp(argv[c],"-lw")==0) {
                                contarpalabra=1;
                                contarlinea=1;
                            } else {
                                if (strcmp(argv[c],"--lines")==0) {
                                    contarlinea=1;
                                } else {
                                    if (strcmp(argv[c],"--words")==0) {
                                        contarpalabra=1;
                                    } else {
                                        // en caso contrario las combinaciones de letras no valdrían...
                                        fprintf(stderr, "%s: %s: Opcion no valia\n", argv[0], argv[c]);
                                        errores++;
                                    }
                                }
                            }
                        }
                    }
                }
            }

        } else {
            //sera el nombre del archivo
            if (argc>0) {
                strcpy(archivo,argv[c]); // ver comentario final,
                                                     // mejora: posicion_nombre_archivo=c;
                break;
            } else {
                fprintf(stderr, "%s: %s: No se ha especificado nombre de archivo valido\n", argv[0], argv[0]);
            }
        }
        c++;
    }

    if (errores!=0) {
        return 1;
    }

    if (argc==2) {
        //significa que solo ha escrio el comando y el nombre de archivo
        //tenemos que ejecutar -w -l -c
        contarpalabra=1;
        contarlinea=1;
        contarcaracter=1;
    }

    fprintf(stdout, "wcjsb contara del archivo: %s\n",archivo);

    if (contarlinea==1) {
        fprintf( stdout, "contara lineas\n");
    }

    if (contarpalabra==1) {
        fprintf( stdout, "contara palabras\n");

    }
    if (contarcaracter==1) {
        fprintf( stdout, "contara caracteres\n");
    }
// podiamos llamar sin usar la variable archivo de esta manera:
//    contar(contarcaracter,contarpalabra,contarlinea,argv[posicion_nombre_archivo]);
    contar(contarcaracter,contarpalabra,contarlinea,archivo);
    return 0;
}

void contar(int caracter,int palabra,int linea, char *archivo)
{
    int numero_caracter=0;
    int numero_palabra=0;
    int numero_linea=0    ;
    FILE *pf;
    char letra;
    char letraAnterior;
    int errores=0;

    if((pf=fopen(archivo,"r"))==NULL) {
        fprintf(stderr, "%s: %s: No se puede abrir el fichero\n", archivo, archivo);
        errores++;

    } else {

        // Lee el primer caracter del archivo ¡porque es posible que el archivo este vacio!

        letra = fgetc(pf);
        letraAnterior = letra + 1; // asi nuestra letra anterior nos aseguramos que es distinta al anterior
        //numero_caracter++;

        // Mientras no sea fin de fichero
        while(!feof(pf)) {
            // tengo que analizar el caracter:
            if (palabra==1) {
                if ( ((letra==' ') || (letra=='\n') || (letra=='\t')) && (letra!=letraAnterior) ) {
                    // comprobramos que esta entre espacios y que no son espacios consecutivos (letra != letraAnterior)
                    numero_palabra++;
                }
            }

            if (linea==1) {
                if (letra=='\n') {
                    numero_linea++;
                }
            }
            numero_caracter++;
            letraAnterior = letra;
            letra = fgetc(pf);
        }
        // Cierra el archivo
        fclose(pf);

        // escribe resultado segun lo que nos hayan pedido....

        fprintf( stdout, "-------------Resultados-------------\n");

        if (linea==1) {
            fprintf( stdout, "Nº de lineas: %d\n",numero_linea);
        }

        if (palabra==1) {
            fprintf( stdout, "Nº de palabras: %d\n",numero_palabra);

        }

        if (caracter==1) {
            fprintf( stdout, "Nº de caracteres: %d\n",numero_caracter);
        }

        fprintf( stdout, "------------- fin -------------\n");

    }

}

Nota:
He corregido las condiciones que evaluaban la instruccion if que contaba las palabras, ahora va bien.

Mejora: limitación al definir char archivo[256] (Comentada por los campañeros Luismiguel , Enrique y Beatriz)
El hecho de definir esta variable, es una limitación ya que estamos "limitando" operar con archivos (+ longitud ruta) que no superen los 255 caracteres (el ultimo tiene que estar servado a '\0').
Se puede evitar esto, creando una variable numerica int (por ejemplo llamandola posicion_nombre_archivo), que guarde la posicion del nombre del archivo dentro de la tabla de argv[] (normalmente, este argumento es el ultimo...):

argv[pocicion_nombre_archivo]

Examen 3

2012-07-12T10:43:00.003-07:00

Crear un programa que realice las mismas tareas que el comando wc.
Nuestro programa debe admitir los argumentos -w -l -c, y toda la combinación de ellos, es decir, puede admitirlo de forma individual, usando dos de ellos, usando los tres o sin usar ninguno.

Ademas, los argumentos deben poder unirse, es decir se considerará un argumento válido -wl y debe interpretase como los argumento -w y -l

examen 2: solución del profe

2012-07-12T10:43:00.001-07:00

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <time.h>

// Tabla de records
// crear estructura
typedef struct {
    char nombre[20];
    int intentos;
} tipoRecord;

// Funciones
void leerArchivoRecords(tipoRecord *);
void asignarRecordsIniciales(tipoRecord *);
void guardarArchivoRecords(tipoRecord *);
void mostrarTablaRecords(tipoRecord *);
int pedirNum(char *);
int jugarPartida();
void comprobarTablaRecords(int, tipoRecord *);

int main(int argc, char **argv)
{
    // Variables
    tipoRecord tablaRecords[10];
    int c = 0;        // Contador para bucles
    int op = -1;    // Opción del usuario
    int inten = 0;    // Intentos usados en cada partida

    // Preparamos secuencia de nº aleatorios
    srand(time(NULL));
    // leer archivo de records y pasarlo a la tabla
    leerArchivoRecords(tablaRecords);
    // Mientras quiera seguir jugando
    while(op != 2) {
        // Mostrar records actuales
        mostrarTablaRecords(tablaRecords);
        // Mostrar menú
        printf("1 Jugar     2 Salir\n");
        // Pedir opción al usuario
        op = pedirNum("Introduzca la opción ");
        // Procesar opción de menú
        switch(op) {
        case 1:        // Jugar partida
            inten = jugarPartida();
            comprobarTablaRecords(inten, tablaRecords);
            break;
        case 2:        // Salir
            printf("Hasta luego\n");
            break;
        }
    } // Fin mientras
    // Guardar archivo con tabla de records
    guardarArchivoRecords(tablaRecords);
    return 0;
}

// pasa los 10 records del archivo a la tabla
void leerArchivoRecords(tipoRecord *tr)
{
    FILE *pf;
    // Abrir de lectura
    if((pf = fopen("records", "r")) == NULL) {
        // Ha fallado la apertura (No existe el archivo)
        asignarRecordsIniciales(tr);
        guardarArchivoRecords(tr);
        pf = fopen("records", "r");
    }
    // Leer contenido
    fread(tr, sizeof(tipoRecord), 10, pf);
    // Cerrar
    fclose(pf);
}

// Guarda la tabla de records en el archivo
void guardarArchivoRecords(tipoRecord *tr)
{
    FILE *pf;
    // Abrir de escritura
    if((pf = fopen("records", "w")) == NULL) {
        // Ha fallado la apertura (error irrecuperable)
        printf("Cascazo del 15\n");
        exit(1);
    }
    // Guardar contenido
    fwrite(tr, sizeof(tipoRecord), 10, pf);
    // Cerrar
    fclose(pf);
}

// Asigna valores iniciales a la tabla de records
void asignarRecordsIniciales(tipoRecord *tr)
{
    int c = 0;

    // Recorre los 10 records
    for(c = 0; c < 10; c++) {
        strcpy(tr[c].nombre, "Nadie");    // A cada record le asigna como nombre "nadie"
        tr[c].intentos = 999999;        // A cada record le asigna como intentos 999999
    }
}

// Muestra los 10 records actuales
void mostrarTablaRecords(tipoRecord *tr)
{
    int c = 0;

    printf("***** RECORDS ACTUALES *****\n");
    // Recorre los 10 records
    for(c = 0; c < 10; c++) {
        printf("%-20s %7d\n", tr[c].nombre, tr[c].intentos);
    }
}

// pide un número por teclado mostrando antes el mensaje indicado en texto
int pedirNum(char *texto)
{
    int resp = 0;

    printf("%s", texto);
    scanf("%d", &resp);

    return resp;
}

int jugarPartida()
{
    int ale = 0;
    int num = 0;
    int inten = 0;

    // Nº aleatorio
    ale = 1+(int) (100000.0*rand()/(RAND_MAX+1.0));
    printf(" %d ",ale);
    // Mientras aleatorio != usuario
    while(ale != num) {
        // Pedir nª al usuario
        num = pedirNum("Introduzca un número ");
        // comprobar nª usuario y aleatorio
        // mayor, menor, igual, contar intentos
        inten ++;
        if(num > ale) {
            printf("Te has pasado de largo\n");
        } else {
            if(num < ale) {
                printf("Te has quedado corto\n");
            } else {
                printf("CORRECTO\n");
            }
        }
    }
    return inten;
}

// Comprueba si entra en la tabla de records
void comprobarTablaRecords(int inten, tipoRecord *tr)
{
    int pos = 0;
    int c = 0;
    char nombre[20];

    // Buscar la posición en la que quedaría "inten" en la tabla de 10 records
    while(tr[pos].intentos < inten && pos < 10) {
        pos++;
    }
    // Si entra
    if(pos < 10) {
        // Pedir nombre
        printf("Ha entrado en la tabla de records\n");
        printf("Indique su nombre: ");
        scanf("%s", nombre);
        // Mover los records 1 hacia abajo
        c = 9;
        while(c > pos) {
            strcpy(tr[c].nombre, tr[c - 1].nombre);        // Pasa el nombre 8 a la posición 9
            tr[c].intentos = tr[c - 1].intentos;
            c--;
        }
        // Insertar el nuevo record
        strcpy(tr[pos].nombre, nombre);
        tr[pos].intentos = inten;
    }
}

examen 2: solución del alumno

2012-07-12T10:42:00.003-07:00

Utilizando estructuras definidas por el usuario.

main.h

typedef struct {
    char nombre[15];
    int intentos;
} puntuacion;

// declaracion de funciones
void reiniciarAleatorio();
void mostrarMenu();

void limpiarpantalla();

int pedirNum(char *);

void mostrarTablaDeRecord(puntuacion *);

void jugar(puntuacion *);

#define TAMANO 11

void AbrirFicheroOCrearlo(puntuacion *);
void SalvarFicheroDatos(puntuacion *);

void guardarTabla(int n,char *);

main.c

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>
#include <string.h>
#include "main.h"

//entrada del programa
int main(int argc, char **argv)
{
// definir variables
    puntuacion TablaRecords[TAMANO]; //el la posicion t[10] se guarda el numero ultimo de intentos...
    int op=0;

//reiniciar el rnd
    reiniciarAleatorio();

//reinicio tabla de record o la leo de un archivo....
    while (op<TAMANO) {
        TablaRecords[op].intentos=INT_MAX;
        op++;
    }

    op=1;// para el menu

//leer el archivo de resultados del juego, y si no existe crearlo
    AbrirFicheroOCrearlo(TablaRecords);

    printf("***********************************************\n");
    printf("******** JUEGOS DE ACEPTAR LOS NUMEROS ********\n");
    printf("***********************************************\n");

// mostrar menu:
    while (op!=3) {
// mostrar menu:
//             1.mostrar tabla de record
//             2.jugar
//             3.fin del programa
        mostrarMenu();
        op=pedirNum("Indique la opción deseada:");
        switch(op) {
        case 1:
            mostrarTablaDeRecord(TablaRecords);
            break;
        case 2:
            jugar(TablaRecords);
            break;
        case 3:
            break;
        default:
            printf("Opción no valida\n");
        }
    }
    // guardo los datos de los record:
    SalvarFicheroDatos(TablaRecords);
    printf("Fin del juego, Adios....\n");

//**************jugar***********

//el programa elige un numero aleatorio

// mientras no acierte
//            escribe un numero el usuario
// ver si es menor ponerle mensaje. Numero de intentos ++
// ver si es mayor ponerle mensaje Numero de intentos ++
// si es igual acerto, salida del bucle y guarda en la tabla el numero de intentos..
//

// guardar la tabla del numero de intentos
    /* Guardamos 10registros de record, + 1 PARA EL ULTIMO VALOR METIDO
    * comprobar que posicion esta (ordenar)
    * si esta fuera de la tabla no se guarda, si no se introduce numero
    * y si translada la posicion de los otros numeros.
    */

    return 0;
}

// ------------------------------------------------
// procedimientos y funciones
// ------------------------------------------------
void reiniciarAleatorio()
{
    srand(time(NULL));
}

// ------------------------------------------------
// menu
// ------------------------------------------------
//             1.mostrar tabla de record
//             2.jugar
//             3.fin del programa
void    mostrarMenu()
{
    limpiarpantalla();
    printf( "*********** Menu ****************\n");
    printf( " 1- Mostrar tabla de record\n");
    printf( " 2- Jugar\n");
    printf( " 3- Fin del programa\n");
    printf( "*********************************\n");

}

void limpiarpantalla()
{
    int c=0;
    for (c=0; c<5; c++) {
        printf("\n");
    }

}

// pedir numero para el menu..
// Pide un número entero por teclado. Muestra el texto indicado
int pedirNum(char *texto)
{
    char entrada_texto[10];
    char vaciabufferteclado[10];
    int num = 0;

    printf("%s", texto);
    num=atoi(gets(entrada_texto)); // convertimos cadena de texto en un numero int, con la funcion atoi
   // ver nota a pie de pagina del uso del gets.

    return num;
}

void mostrarTablaDeRecord(puntuacion *tabla)
{
    limpiarpantalla();
    char op2[5];
    int c=0;
    printf("***************** Tabla de Record ****************\n");
    printf("* Posicion                 Record      Jugador *\n");

    while (c<(TAMANO-1)) {
        //pongo TAMANO-1, porque solo quiero hacer que se muestren los 10 primeros.

        if (tabla[c].intentos!=2147483647) {
            printf("* %2dº ................. %7d          %5s      *\n",c+1,tabla[c].intentos,tabla[c].nombre);
            c++;
        } else {
            printf("* %2dº ................... no record      xxxxxx *\n",c+1);
            c++;
        }
    }
    printf("***************** Tabla de Record ****************\n");

//    printf("Pulse S para salir ");

}

// jugar devuelve el numero de repeticiones hechas por el jugador antes de resolver la solucion
void jugar(puntuacion *tabla)
{
    char cadena[20];
    int c;
    int pos;
    int op2;
    int indice;
    int solucion;
    int salir=1;
    int repeticiones=0;
    int numero=0;
    char nombre[15];
    char *texto;
    //pruebo con 10.... aunque deberia de ser 10000
    solucion=1+(int) (10.0*rand()/(RAND_MAX+1.0));

    printf("\n");
    printf("\n");
    printf("***********************************************\n");
    printf("*************** A JUGAR ***********************\n");
    printf("***********************************************\n");
    while (salir=1) {
        numero=pedirNum("Introduce un número:");
        if (numero==solucion) {
            break; // asi salgo del bucle...
        } else {
            if (numero>solucion) {
                printf("la solucion es MENOR... intentalo de nuevo\n");
                repeticiones++;
            } else {
                printf("la solucion es MAYOR... intentalo de nuevo\n");
                repeticiones++;
            }
        }

    }

    printf("\n Lo has hecho en %d intentos...\n",repeticiones);

    //     repeticiones;
    /* compruebo en la tabla de record, si las repeticiones las tengo que
    * introducir , si son nuevo record (o estar en la lista de 10 mejores), o no
    * */

    // determinar la posicion en la tabla....

    c=0;
    pos=0;
    while ((tabla[pos].intentos<repeticiones) && (pos<(TAMANO-1))) {
        pos++;

    }
    if (pos<TAMANO) {
        indice=TAMANO-1;
        while (indice>pos) {
            tabla[indice].intentos=tabla[indice-1].intentos;
            indice--;
        }
        tabla[pos].intentos=repeticiones;
        printf("Introduce el nombre del jugador (maximo 14 caracteres): ");
        texto=gets(nombre);

        strcpy(tabla[pos].nombre,texto);

        //guardarTabla(pos,texto); // pos es un int, y texto es un puntero
    }

}

// ---------------------- abrir o crear archivo de datos ----------------

void AbrirFicheroOCrearlo(puntuacion *tabla)
{
    int c=0;
    FILE *pf;
    if ((pf=fopen("/home/julio/records.txt","r"))==NULL) {
        // no puedo abrir el archivo, tengo que crearlo ...
        pf=fopen("/home/julio/records.txt","w");
        // me da problemas el ~/, me dice fallo de segmentacion...
        // tengo que poner /home/julio/records.txt

        fwrite(tabla,sizeof(puntuacion),TAMANO, pf);
        fclose(pf);

        // ya lo he creado
    } else {
        // leer datos de los puntos record

        fread(tabla,sizeof(puntuacion),TAMANO,pf);
        fclose(pf);
    }

}

void SalvarFicheroDatos(puntuacion *tabla)
{
    FILE *pf;
    int c=0;
    pf=fopen("/home/julio/records.txt","w");
    // me da problemas el ~/, me dice fallo de segmentacion...
    // tengo que poner /home/julio/records.txt

    fwrite(tabla,sizeof(puntuacion),TAMANO,pf);
    //}

    fclose(pf);
    // ya lo he creado
}

Nota al pe de pagina:
Cuando compilamos este ejercicio, nos da un aviso:
warning: the `gets' function is dangerous and should not be used.

Este aviso se debe a que gets, puede producir desbordamiento, ya que el usuario puede introducir mas caracteres que los que tengamos asignados a la variable de texto.

Para solucionar este problema lo suyo es utilizar la funcion fgets

examen 2: solución del alumno

2012-07-12T10:42:00.001-07:00

Examen 2

2012-07-12T10:41:00.003-07:00

Realizar un programa que seleciones un numero al azar entre 1 y 100.000, dicho numero no debe de ser mostrado al usuario, posteriormente debe ofrecerle al usuario la posibilidad de acertar el número y en caso de no hacerlo, debe indicar si el número tecleado por el usuario es mayor o menor que el numero aleatorio y volver a pedir número al usuario hasta que lo acierte.

El programa debe mantener una tabla con los records obtenidos por el usuario, (siendo el mejor record el menor número de intentos hasta acertar el número) y almacenarla en un fichero. Dicha tabla será cargada desde el fichero al inicio del programa y guardada cuando el usuario indique que no desea jugar otra partida.

Comentarios sobre la corrección del examen I

2012-07-12T10:41:00.001-07:00

Sobre los comentarios:

Poner siempre comentarios. Incluso antes de empezar a codificar en C, poner comentarios de lo que vamos a hacer en cada procedimiento/funcion y programa principal main.c

Sobre nombrar variables y funciones:

Las variables poner nombres claros, y para las funciones nombres descriptivos y facil de leer.

no vale: cargatabladenadaascendente

mejor (mas claro): cargaTablaOrdenadaAscendente

No usar nombres de variable por ejemplo “c”, para distintas cosas, no vale para contador y luego usarla como entrada de teclado, porque al final nos equivocaremos.

La solución del profe...

2012-07-12T10:40:00.001-07:00

El profe, Juan Andres, nos ha pasado su solucion, la cual la vamos a estudiar ya que explica mas cosas sobre C.

Nuevas cosas: Crea una nueva cabecera llamda "main.h"

main.h:// Creamos la contantante TAMANO con valor 10
#define TAMANO 10

// Declaración de funciones usadas a lo largo del programa
void mostrarTabla(int [TAMANO]);        // equivalente a void mostrarTabla(int *);
void mostrarMenu();

void cargarTabla(int *);
void cargarTablaOrdenada(int *);
void rotarIzquierda(int *);
void rotarDerecha(int *);
void ordenarAsc(int *);
void ordenarDesc(int *);
int compararAsc(const void *, const void *);
int compararDesc(const void *, const void *);
void cargarAleatorio(int *);

int pedirNum(char *);

Y en el main.c:
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>

#include "main.h"

// Entrada al programa
int main(int argc, char **argv) {
    int op = 1;
    int tabla[TAMANO];

    // Valores iniciales aleatorios
    cargarAleatorio(tabla);

    // 0 = Salir
    while(op != 0) {
        // Muestra el estado de la tabla, el menú y solicita la opción al usuario
        mostrarTabla(tabla);
        mostrarMenu();
        op = pedirNum("Indique la opción deseada ");
        // Procesa la opción seleccionada
        switch(op) {
            case 1:
                cargarTabla(tabla);
                break;
            case 2:
                cargarTablaOrdenada(tabla);
                break;
            case 3:
                rotarIzquierda(tabla);
                break;
            case 4:
                rotarDerecha(tabla);
                break;
            case 5:
                ordenarDesc(tabla);
                break;
            case 6:
                ordenarAsc(tabla);
                break;
            case 7:
                cargarAleatorio(tabla);
                break;
            case 0:        // No se hace nada
                break;
            default:
                printf("Opción no válida\n");
        }
    }
    return 0;
}

// Muestra la tabla
void mostrarTabla(int tabla[TAMANO]) {        // tambien se puede poner void mostrarTabla(int *tabla)
    int c;

    for(c = 0; c < TAMANO; c++) {
        printf("%7d",tabla[c]);            // %7d = %d que ocupa 7 posiciones, rellena con espacios
    }
    printf("\n");
}

// Carga la tabla desde teclado (Opción 1)
void cargarTabla(int *tabla) {
    int c;

    for(c = 0; c < TAMANO; c++) {
        tabla[c] = pedirNum("Introduzca un número ");
    }
}

// Carga la tabla con 10 números, insertando cada número en la posición adecuada (Opción 2)
void cargarTablaOrdenada(int *tabla) {
    int c;
    int c1;
    int pos = 0;
    int num = 0;

    // Pone INT_MAX en todos los elementos de la tabla para que el número introducido siempre sea menor
    for(c = 0; c < TAMANO; c++) {
        tabla[c] = INT_MAX;
    }

    for(c = 0; c < TAMANO; c++) {
        pos = 0;
        num = pedirNum("Introduzca un número ");
        // Busca la posición correcta para insertar el número en la tabla
        while(tabla[pos] < num && pos < (TAMANO-1)) {
            pos++;
        }
        // Corre posición de los elementos de la tabla si es necesario
        for(c1 = TAMANO - 1; c1 > pos; c1--) {
            tabla[c1] = tabla[c1 - 1];
        }
        // Guarda el numero en la posición correcta
        tabla[pos] = num;
    }
}

// Desplaza los elementos de la tabla 1 posición a la izquierda. (Opción 3)
void rotarIzquierda(int *tabla) {
    int c = 0;
    // Guardamos el primer elemento en el auxiliar
    int aux = tabla[0];
    // Movemos todos los demás
    for(c = 0; c < TAMANO - 1; c++) {
        tabla[c] = tabla[c + 1];
    }
    // Pasamos el auxiliar al último elemento
    tabla[TAMANO - 1] = aux;
}

// Desplaza los elementos de la tabla 1 posición a la derecha. (Opción 4)
void rotarDerecha(int *tabla) {
    int c = 0;
    // Guardamos el último elemento en el auxiliar
    int aux = tabla[TAMANO - 1];
    // Movemos los demás
    for(c = TAMANO ; c > 0; c--) {
        tabla[c] = tabla[c - 1];
    }
    // Pasamos el auxiliar a la primera posición
    tabla[0] = aux;
}

// Ordena la tabla de forma descendente usando qsort (Opción 5)
void ordenarDesc(int *tabla) {
    qsort(tabla, TAMANO, sizeof(int), &compararDesc);
}
int compararDesc(const void *n1, const void *n2) {
        return (*(int *)n2 - *(int *)n1);
}

// Ordena la tabla de forma ascendente usando qsort (Opción 6)
void ordenarAsc(int *tabla) {
    qsort(tabla, TAMANO, sizeof(int), &compararAsc);
}
int compararAsc(const void *n1, const void *n2) {
        return (*(int *)n1 - *(int *)n2);
}

// Carga la tabla con 10 números aleatorios entre 1 y 100 (Opción 7)
void cargarAleatorio(int *tabla) {
    int c = 0;

    // Inicializa secuencia de numeros aleatorios
    srand(time(NULL));

    for(c = 0; c < TAMANO; c++) {
        tabla[c] = 1+(int) (100.0*rand()/(RAND_MAX+1.0));
    }
}

// Muestra las opciones del menú
void mostrarMenu() {
    printf("1 - Cargar la tabla con 10 números\n");
    printf("2 - Cargar la tabla con 10 números ordenados de menos a mayor\n");
    printf("3 - Rotar la tabla una posición a la izquierda\n");
    printf("4 - Rotar la tabla una posición a la derecha\n");
    printf("5 - Ordenar la tabla descendente\n");
    printf("6 - Ordenar la tabla ascendente\n");
    printf("7 - Rellenar la tabla con números aleatorios\n");
    printf("0 - Salir\n");
}

// Pide un número entero por teclado. Muestra el texto indicado
int pedirNum(char *texto) {
    int num = 0;
    printf("%s", texto);
    scanf("%d", &num);
    return num;
}

examen1 solucion en c

2012-07-12T10:39:00.003-07:00

#include <stdio.h>
#include <time.h> // para el time() // esto es para el tema del numero aleatorio
#include <stdlib.h> // para el srand() // esto es para el tema del numero aleatorio
#include <limits.h> // esto es para usar INT_MAX

int pedirnumero(char *,int); // declarar la funcion de pedir numero con el texto que queramos

void escribe_menu(int *);
int leeropcionmenu();
void cargatabla10elementos(int *);
void cargartabla10elementosordenadosmenoramayor(int *);
void rotarlatablaunaposicionizquierda(int *);
void rotarlatablaunaposicionderecha(int *);
void ordenarlatabladescendentemente(int *);
void ordenarlatablaascendente(int *);
void rellenarlatablaconnumerosaleatorios(int *);

int main(int argc, char **argv)
{
    int opcion=1;
    int tabla[10];
    int contador=0;
    srand(time(NULL)); // reiniciar rand con la variable tiempo
    // Pongo todos los numeros de la tabla a cero
    while (contador<10) {
        tabla[contador]=0;
        contador++;
    }

    escribe_menu(tabla);

    while (opcion!=0) {
        //presentacion del menu
        opcion=leeropcionmenu();
        switch(opcion) {
        case 1:
            cargatabla10elementos(tabla);
            escribe_menu(tabla);
            break;
        case 2:
            cargartabla10elementosordenadosmenoramayor(tabla);
            escribe_menu(tabla);
            break;
        case 3:
            rotarlatablaunaposicionizquierda(tabla);
            escribe_menu(tabla);
            break;
        case 4:
            rotarlatablaunaposicionderecha(tabla);
            escribe_menu(tabla);
            break;
        case 5:
            ordenarlatabladescendentemente(tabla);
            escribe_menu(tabla);
            break;
        case 6:
            ordenarlatablaascendente(tabla);
            escribe_menu(tabla);
            break;
        case 7:
            rellenarlatablaconnumerosaleatorios(tabla);
            escribe_menu(tabla);
            break;
        case 0:
            opcion=0;
            break;
        }

        //escribetabla(tabla);

    }

    printf("Fin del programa");
    return 0;
}

//-------------------------------------
// Definicion de funciones
//-------------------------------------

int pedirnumero(char *texto,int contador)
{
    int resul=0;
    printf("%s (%dº):",texto,contador+1);
    scanf("%d",&resul);
    return resul;

}

//-----------------escribir menu ---------------

void escribe_menu(int *tabla)
{
    int c=0;
    while (c<30) {
        printf("\n");
        c++;
    }

    printf("*****************************************************************\n");
    printf("* Menu:                                                         *\n");
    printf("* 1-Cargar la tabla con 10 numeros                              *\n");
    printf("* 2-Cargar la tabla con 10 numeros ordenados de menor a mayor   *\n");
    printf("* 3-Rotar la tabla una posicion a la izquierda                  *\n");
    printf("* 4-Rotar la tabla un posición a la derecha                     *\n");
    printf("* 5-Ordenar la tabla descendientemente                          *\n");
    printf("* 6-Ordenar la tabla ascendentemente                            *\n");
    printf("* 7-Rellenar la tabla con numeros aleatorios                    *\n");
    printf("* 0-Salir                                                       *\n");
    printf("*                                                               *\n");
    printf("* Tabla actual                                                  *\n");
    c=0;
    while (c<10) {
        printf("%d ,",tabla[c]);
        c++;
    }
    printf("\n");
    printf("*                                                               *\n");
    printf("*****************************************************************\n");

}

//----------------------------------------------

int leeropcionmenu()
{
    int salir=0;
    int valor;
    valor=-1;
    while (salir==0) {

        printf("Escribe la opción:                                \r"); // borra los numeros si ha introducido algo
        printf("Escribe la opción:");
        scanf("%d",&valor);
        if ((valor>-1) && (valor<8)) {
            salir=1;
        }
    }

    return valor;

}

//-------------------------------------------------------------

void cargatabla10elementos(int *tabla)
{
    int elementos=0;
    while (elementos<10) {
        tabla[elementos]=pedirnumero("Escribe el numero",elementos);
        elementos++;
    }

}

//------------------------------------------------------
void cargartabla10elementosordenadosmenoramayor(int *tabla)
{
    int elementos=0;
    int valor=0;
    int pos=0;
    int indice=0;

    // tengo que poner cada valor de la
    //tabla al maximo, para que lo ordene correctamente
    while (elementos<10) {
        tabla[elementos]=INT_MAX;
        elementos++;
    }

    elementos=0;
    while (elementos<10) {
        // obtener el numero
        printf("Escribe el elmento %dº:",elementos+1);
        scanf("%d",&valor);

//determino la posicion
        pos=0;
        while ((tabla[pos]<valor) && (pos<9)) {
            pos++;
        }

// insertar el numero en la posicion obtenida
        indice=9;
        while (indice>pos) {
            tabla[indice]=tabla[indice-1];
            indice--;
        }
        tabla[pos]=valor;
        elementos++;
    }
}

//-------------------------------rotar la tabla una posicion izquierda
void rotarlatablaunaposicionizquierda(int *tabla)
{
    int pos=9;
    int valor=tabla[9];
    while (pos>0) {
        tabla[pos]=tabla[pos-1];
        pos--;
    }
    tabla[0]=valor;
}

//-------------------------------rotar la tabla una posicion derecha
void rotarlatablaunaposicionderecha(int *tabla)
{
    int pos=0;
    int valor=tabla[0];
    while (pos<9) {
        tabla[pos]=tabla[pos+1];
        pos++;
    }
    tabla[9]=valor;
}

//---------------------------------ordenarlatabladescendentemente(tabla
void ordenarlatabladescendentemente(int *tabla)
{
    int num=0;
    int aux=0;
    int c=0;
    while (num<10) {
        c=num+1;
        while (c<10) {
            if (tabla[num]>tabla[c]) {
            } else {
                aux=tabla[c];
                tabla[c]=tabla[num];
                tabla[num]=aux;
            }
            c++;
        }
        num++;
    }
}

//-------------------------------------------------------------
void ordenarlatablaascendente(int *tabla)
{
    int num=0;
    int aux=0;
    int c=0;
    while (num<10) {
        c=num+1;
        while (c<10) {
            if (tabla[num]<tabla[c]) {
            } else {
                aux=tabla[c];
                tabla[c]=tabla[num];
                tabla[num]=aux;
            }
            c++;
        }
        num++;
    }

}

//---------------------------------------------------------
void rellenarlatablaconnumerosaleatorios(int *tabla)
{
    int c=0;
    while (c<10) {
        tabla[c]=1+(int) ((100.0)*rand()/(RAND_MAX+1.0));
        c++;
    }
}