¡Recomienda este blog!

lunes, 18 de abril de 2011

Problemática de las fotocopias de libros: 1996 - Actualidad.

1. Introducción y contexto social.

El problema a analizar surge tras el uso abusivo de las copias de libros por parte de los usuarios y las perdidas económicas que esto supone a escritores y editoriales. Si bien, es cierto que anteriormente a Abril de 1996, fecha en que se crea el Real Decreto que establece una gestión y protección de derechos de reproducción, era completamente legal, y aquí es donde comenzará el estudio, para finalizar en la actualidad.

Debido a esto, el impacto social que tiene este cambio es de gran magnitud, ya que a partir de este momento quedaba prohibido y era considerado como delito algo que siempre ha estado bien visto por gran parte de la sociedad.

De forma general, como se observa en las encuesta realizadas a universitarios de la época, 1996, la gran mayoría estaban desacuerdo con este tipo de prácticas e incluso opinaban que les parecía bien que se copiaran libros, debido al ahorro económico que esto les suponía. De hecho entre los seis comentarios que se recogen en el estudio realizado, solo uno de los encuestados opinó que es algo que no estaba bien, lo que demuestra que un gran porcentaje de la población estaba de acuerdo con este tipo de prácticas.

Por otro lado, supone un cambio brutal en la industria del libro, ya que desde este momento se ejercerá una mayor protección sobre los derechos de reproducción reprográfica, hasta el punto que conocemos en la actualidad.

Es acertado, a mi parecer, la carta enviada a las universidades de aquel entonces, por el presidente de CEDRO, ya que con esto se hace conocer a estas la situación en la que se encuentra tanto la ley como la situación en el sector de las editoriales y los autores.

Si observamos con detenimiento la noticia del 7 de noviembre de 1996 donde se multaba a un empleado de una papelería por realizar copias de libros, se pueden sacar algunas conclusiones sobre como todo esto influye en la sociedad. Por ejemplo al regente de la papelería se le impone una multa de las denominadas “ejemplares”, ya que la sanción que se le establece es de 190.000 euros, es decir, 31.613.340 millones de pesetas, una cifra Problemática de las fotocopias de libros.

Aunque 1996, queda bastante lejos de la actualidad, esta situación es semejante a la vivida actualmente en el sector de la música, el cine, etc. Si nos fijamos, ambas situaciones se producen por la misma situación, es decir, debido a los precios elevados impuestos a estos productos “intelectuales”. Pero no ambas situaciones pueden resolverse de la misma forma.

En el problema de los libros, la situación se reguló, desde mi punto de vista de una forma bastante acertada, ya que las copias se redujeron de forma considerable. Si bien es cierto que hoy en día, son las propias copisterías las que no permiten realizar copias de libros.

Pero si nos paramos a pensar, ya incluso no es necesario ir a coger un libro de forma física y fotocopiarlo porque con internet y las nuevas tecnologías se puede buscar cualquier libro y tenerlo directamente en tu ordenador de una forma rápida, aunque no legal. En este no es necesario ni siquiera imprimir el libro, ya que se puede leer directamente en la pantalla de un ordenador o reproducir en cualquier lector de libros electrónicos (ebook).

2. Análisis del problema en el marco de la Ley de Propiedad intelectual.

Centrándonos en el contexto social descrito en el punto anterior y dentro de la Ley de propiedad intelectual, se procede a analizar de forma clara los diversos Artículos que regulan todo lo relacionado con la copia de libros.

En el artículo 10 de esta ley, se establecen las obras literarias como objeto de la propiedad intelectual así como obras de la misma naturaleza, con lo que desde un primer momento se muestra explícitamente la protección de estos por la ley.

Posteriormente se establecen las normas de distribución en el artículo 19, y se define perfectamente que se entiende como préstamo. En esta definición ya se especifica que dicho préstamo se realizará por tiempo limitado y sin beneficio económico o comercial directo ni indirecto. En este punto, se observa cómo el regente de la papelería que aparece en nuestro estudio estaba incumpliendo este artículo, ya que obtenía beneficio económico de la copia de los libros de medicina y farmacia. Pero no solo esto, sino que también la ley era incumplida por los alumnos que obtenían los libros de la biblioteca para fotocopiarlos, y así obtener beneficio, no de forma directa, pero si indirectamente.
Centrándonos en este aspecto, toma especial sentido la carta circular que el presidente de CEDRO envía a las universidades en 1996, ya que son entornos más propensos a la realización de estas copias.

En el artículo 37 se establece que los museos, archivos, bibliotecas, hemerotecas, fonotecas o filmotecas de titularidad pública o que pertenezcan a entidades de interés general de carácter cultural, científico o educativo sin ánimo de lucro, o a instituciones docentes integradas en el sistema educativo español, no precisarán autorización de los titulares de derechos por los préstamos que realicen. Aunque si se remunerará a los autores por los prestamos que se realicen.

En este artículo aparece una frase que me llama la atención y es que no será necesario esta remuneración a establecimientos públicos que se encuentren en municipios de menos de 5000 habitantes, ni tampoco instituciones docentes integradas en el sistema educativo español. En cuestiones docentes es algo lógico, pero si una población tiene menos habitantes ¿tendrán entonces más privilegios sobre la ley? Es una excepción que me parece de difícil comprensión.

La ley de propiedad intelectual establece además, las compensaciones equitativas por realizar una copia privada en su artículo 25, es decir, que se permite realizar copias de obras como libros, fonogramas, videogramas siempre que hayas pagado por ellos y sean adquiridos de forma legal, pero únicamente si estas copias se realizan para uso privado. Para ello es establece, que cuando se compre un equipo o aparato de reproducción de libros o publicaciones asimiladas reglamentariamente a libros se pague una determinada cantidad extra según la capacidad de copia. Pero, tras este análisis me surgen una duda, por ejemplo, ¿y si la compra de estos aparatos no se realiza para realizar ningún tipo de copia con propiedad intelectual y se adquiere para copias de nuestra propiedad? ¿Estaríamos pagando un canon aunque esto fuera así? La respuesta seguramente sea, Sí. Con lo que se está determinando a priori que se van a copiar “productos intelectuales”.

Con respecto a los derechos de reproducción, distribución y comunicación pública de pequeños fragmentos de obras en el entorno de la enseñanza, la ley determina en el artículo 32 que el profesorado necesitará autorización del autor para realizar estos actos, en lo referente a libros y manuales universitarios. Problemática de las fotocopias de libros.

Tras el estudio de la ley en mayor profundidad, me sorprende gratamente que se establezcan como serán los contratos de edición entre autores y editoriales, como se describe en el artículo 62. Debido a la gran importancia de los autores para estas creaciones y a los que desde mi punto de vista se les debe proteger con mayor mimo.

3. Conclusiones.

En la sociedad actual, aunque en menor cantidad que cuando se promulgó la ley de propiedad intelectual, se siguen realizando copias ilegales de libros, si bien, aunque no en copisterías, si para su posterior distribución en herramientas como Internet y medios como P2P.

Sobre este tema han surgido muchas discusiones sobre si esto está dentro de la legalidad o no.Según la ley de propiedad intelectual no se hace mención de que para que la copia sea legal debe ser hecha directamente de la original, aunque si obliga a que el usuario haya tenido acceso legitimo a la obra que copia. Esto se determinó así, para permitir la grabación de material emitido por medios de comunicación como la televisión o la radio, que retribuyen directamente a los propietarios del material por su comunicación pública, y lo que permite al usuario acceder legítimamente. Con lo que sería necesario, desde mi punto de vista realizar una modificación en la ley para que esto fuera ilegal, ya que en estas prácticas por lo general no existe ánimo de lucro.

Si actualmente se realizara una encuesta a universitarios sobre este tema, como la realizada en 1996, pero centrándose en la copia de libros a través de las nuevas tecnologías, probablemente el resultado sería parecido, ya que socialmente, aunque me cueste admitirlo, estamos muy acostumbrados y vemos como algo normal descargarse un libro por internet, un disco de música etc.

Si reflexionamos un poco sobre el tema, se deduce que estamos en la misma situación en la que se encontraba el sector autoral y editorial en 1996, solo que ahora los medios son electrónicos y no en papel. Con lo que para emendar la situación se necesita un cambio de la legislación vigente, pero un cambio de verdad, ya que no solo basta con prohibir los enlaces en las páginas web como determina la “ley Sinde”, sin pensar que estos son por diversas razones la esencia de internet, si no realizar un cambio más profundo.

También, desde mi punto de vista, el precio de los libros es algunas veces abusivo y esto en parte es también una razón para realizar copias, aunque sean ilegales.

Por último y para concluir, me gustaría mencionar algunas alternativas que se están llevando a cabo de forma satisfactoria, en mi opinión, sobre la venta de libros. Las nuevas tecnologías siguen avanzando a un ritmo casi incontrolable. Con toda esta evolución surgen los E-Book, libros electrónicos o como a mí me gusta llamarlo, ecolibro.

Son libros en formato digital que se pueden adquirir a un coste muy por debajo de los precios de libros “físicos”, y que pueden ser leídos se forma muy agradable mediante un lector de ebooks que simulan papel de verdad. Con todo esto no solo mejorarían las ventas de libros sino que también estaríamos protegiendo el medio ambiente.

lunes, 11 de abril de 2011

Aplicación Cliente-Servidor: Ahorcado remoto.

Contenido

1. INTRODUCCIÓN.

2. DESCRIPCIÓN DEL SERVICIO A IMPLEMENTAR.

3. DECISIONES DE DISEÑO.

3.1. Tipo de protocolo escogido.
3.2. Presentación e introducción de datos.
3.3. Comunicación cliente – servidor.

4. MANUAL DE USUARIO.

4.1. Compilación de la aplicación.
4.2. Ejecución del cliente y el servidor.

5. BIBLIOGRAFÍA EMPLEADA.

__________________________________________________________

1. INTRODUCCIÓN


En este proyecto se pretende abordar el diseño y la implementación de un programa cliente – servidor. Para concretar, este proyecto se centrará en la implementación del servicio de un Ahorcado Remoto.

El objetivo de este trabajo ya no es sólo la resolución del problema asignado, sino la adquisición de conocimientos por parte de los alumnos acerca del propio modelo cliente – servidor y todo lo que ello conlleva. Entre estos conocimientos merece hacer mención a la apertura y cierre de sockets entre cliente y servidor, así como el establecimiento y cierre de la comunicación y el envío de información entre ellos.

Se entiende este aspecto de la asignatura como un elemento imprescindible ya que los sockets proporcionan un elemento de comunicación entre dos procesos, además de ser elementos versátiles y componentes básicos de comunicación entre interprocesos e intersistemas.

Otro de los fines de este proyecto es prestar atención a la importancia de la capa de transporte dentro de la arquitectura OSI, así como de los protocolos UDP y TCP y la diferencia entre ellos. TCP y UDP son dos protocolos de puertos de comunicaciones que resultan imprescindibles, pero que sin embargo se comportan de manera diferente como se comprobará más adelante.

Como consecuencia de lo dicho anteriormente, este proyecto servirá para asentar a los alumnos los conceptos acerca de los diferentes tipos de clientes y servidores, así como su implementación de forma iterativa o concurrente.

Para poder alcanzar las metas propuestas anteriormente, ha sido necesaria la utilización de una serie de recursos, desde los apuntes proporcionados disponibles en la página de la asignatura, hasta la bibliografía complementaria recomendada por el profesor de la misma, que facilita la comprensión de los conceptos ya citados.

2. DESCRIPCIÓN DEL SERVICIO A IMPLEMENTAR.

El servicio a implementar asignado para este grupo corresponde al servicio de Ahorcado Remoto.

Este servicio consistirá en la implementación del juego del ahorcado mediante su diseño en la estructura Cliente – Servidor.

Para ello el servidor debe tener en su haber una serie de palabras almacenadas en un diccionario disponibles para iniciar el juego, de las cuales elegirá una aleatoriamente para comenzar. Estas palabras formarán parte de una cadena, y en el momento en el que una palabra es seleccionada, esta pasa a formar parte de otra cadena en la que aparecerá con todos sus caracteres ocultos.

Antes de que el servidor pueda enviar la palabra oculta correspondiente, debe esperar a que el cliente realice una petición de conexión al mismo, mostrando así su intención de iniciar una nueva partida del juego.

El cliente dispondrá de un número fijo de fallos, que en este caso será de ocho,tantos como letras tiene la palabra AHORCADO. Cada vez que el cliente cometa un fallo, se añadirá una letra a la palabra AHORCADO, almacenada en otra cadena auxiliar definido para tal fin.

En el transcurso del juego, el cliente irá introduciendo letras en la palabra que se le mostrará como oculta. En caso de que el cliente introduzca una letra que pertenezca a la palabra mostrada, esta será cambiada por su carácter oculto correspondiente. Si la letra introducida no es correcta y no pertenece a la palabra oculta, se mostrará el estado de la palabra oculta tal y como estaba hasta ese momento, es decir, se mostrarán tanto los caracteres ocultos como las letras descubiertas hasta entonces.

Si por alguna razón, el cliente introduce una letra que ya había introducido antes (tanto en caso de acierto como en caso de fallo en la primera vez en la que se introdujo la letra), esta se penalizará y se contará como un error más por parte del cliente, añadiéndose la letra correspondiente de la palabra AHORCADO.

Cabe hacer mención a que el servidor no distingue entre letras mayúsculas y letras minúsculas, y por consecuencia, reciba la letra que reciba, se tomará esta letra como si de una letra mayúscula se tratase.

Por parte del cliente, este no aceptará la introducción por parte del usuario de caracteres que no sean letras del abecedario. Tampoco son aceptadas la letra ‘ñ’ y todas las vocales acentuadas.

En caso de que el cliente acumule ocho fallos, la partida finalizará y el cliente habrá perdido la partida, por lo que se le mostrará un mensaje que se lo indicará. Si por el contrario, el cliente logra adivinar la palabra antes de que se le muestre la palabra AHORCADO, este habrá ganado la partida.

Se enviará por parte del servidor un mensaje que indique el fin de la partida al cliente, tanto si este ha ganado como si ha perdido. El cliente al recibir este mensaje, lo identificará y esperará a recibir otro mensaje más desde el servidor indicándole cuál era la palabra correcta.

Cuando el servidor envíe este mensaje con la palabra correcta, cerrará el socket. De igual manera hará el cliente cuando reciba este mensaje.

3. DECISIONES DE DISEÑO.

3.1. Tipo de protocolo escogido.

En el diseño de este proyecto se ha optado por la selección del protocolo TCP y un servidor con concurrencia real.

Se seleccionó un servicio de transporte orientado a conexión en el que los clientes deben de establecer una conexión con el servidor antes de lanzar sus peticiones. En este servicio se sobrepuso la fiabilidad del servicio, así como la entrega ordenada de los mensajes sobre la mayor simplicidad de un protocolo no orientado a conexión. Por estos motivos la opción por la que se optó fue la de implementar un servidor TCP.

El sistema requiere la necesidad de establecer una conexión entre cliente y servidor antes del comienzo del envío de mensajes entre ambos. Esto es debido a que en caso de no utilizar un servidor de este tipo, si se perdiese una letra enviada por el cliente al servidor, o un mensaje enviado por parte de este último, no se tendría constancia de
ello y por tanto no podría llevarse una cuenta ordenada del número de aciertos y fallos que el cliente se anota.

Por otro lado, pero no por eso menos importante, para la implementación de este servicio, se requiere de un orden en la comunicación, y se acusa la necesidad de que los mensajes no lleguen al destino fuera del orden establecido; puesto que este servicio basa su técnica en la colocación reiterada y ordenada de letras en una palabra desconocida. Si estos mensajes llegasen fuera de orden, o se perdiesen, por un lado el servidor no habría
recibido las letras solicitadas por el cliente, y por otro lado, el cliente no sabría si la letra seleccionada se ha perdido o es que aparecerá en pantalla en otro orden distinto al que este la había enviado.

Se debe hacer mención a la decisión tomada sobre la elección de un servidor concurrente. Se tomó esta decisión debido a la característica principal de este tipo de servidores; un servidor concurrente permite que varios clientes realicen peticiones simultáneas a un mismo servidor. Por tanto se determinó esta opción como la mejor
manera de poder atender a los clientes, y no retardar el servicio hacia los clientes, haciéndoles esperar hasta que el servidor procese todas las peticiones pendientes como ocurre en un servidor iterativo.

Dentro de las diferentes formas entre las que se puede implementar un servidor concurrente, se seleccionó la opción de crear un servidor con concurrencia real, basada en la técnica de creación de procesos hijos mediante en servicio fork (). Este servicio crea un nuevo hijo del proceso activo, y una vez creado deja a este último a cargo de la comunicación con cliente, lo que permite volver a colocar al proceso original a la espera de peticiones de nuevos clientes mediante un bucle infinito.

Por otro lado, en el sistema implementado se puede observar un gran flujo de peticiones y respuestas, lo que favorece aún más la selección de un servidor concurrente, caracterizado por utilizar respuestas que necesitan de múltiples operaciones de entrada – salida.

3.2. Presentación e introducción de datos.

Otro aspecto a tener en cuenta, como ya se mencionó en la introducción, es la transformación de cualquier letra que sea introducida por parte del cliente a una letra mayúscula. Esto es conseguido mediante la utilización de la función toupper que realiza la función ya mencionada del siguiente modo: cada carácter introducido por el cliente se corresponde con un carácter ASCII, por lo que esta función se encarga de restarle al número de carácter correspondiente 32 para asignarle así su homólogo en mayúsculas.

Para una mayor facilidad en el diseño y en la jugabilidad, se ha decidido que sólo se permite la introducción de caracteres que pertenecen al abecedario, excluyendo la letra ‘ñ’ y las vocales acentuadas.

Siguiendo con las decisiones tomadas propias del diseño, se ha querido implementar el cliente de forma que cuando este presione una tecla para enviar una letra al servidor, esta no sólo no aparezca en la terminal del cliente, sino que este no tenga que pulsar la tecla intro. El sistema no realiza esa especie de “eco” y no muestra en su pantalla el mensaje introducido por el cliente, lo que permite hacer el servicio más legible frente a si no se introduce esta mejora.

Todo esto se lleva a cabo gracias a una nueva librería incluida en el sistema. Linux no admite la inclusión de la librería conio.h y como consecuencia, tampoco la función getch(), que es la que permitiría al usuario realizar la operación descrita anteriormente. Por este motivo se ha creado una nueva libería (“miconio.h”), la cual implementa la función elegida que nos permita conseguir el objetivo buscado. Esta librería se importa en el cliente y la función getch() se usa como si se dispusiese de la auténtica librería conio.h.

3.3. Comunicación cliente – servidor.

El servidor permite elegir el puerto por el que se podrán conectar los clientes. Por defecto, este servicio utilizará el puerto 8041, el cual no está asignado según la IANA. Al cliente, por su parte, se le puede indicar el host de destino como parámetro. Si no se indicase nada como parámetro, al ejecutar el cliente se solicitará al usuario el nombre del host o su IP.

Como ya se mencionó en la introducción, el servidor le indicará al cliente (tanto en el caso de haber ganado como de haber perdido la partida) que la partida ha finalizado y cerrará la conexión con este cliente, mientras que sigue escuchando a la espera de recibir más peticiones de otros clientes o de este mismo.

Aparte de recibir la palabra oculta con la que se había jugado la partida, el cliente recibe una cadena que contiene en sus primeros tres caracteres la palabra FIN. El cliente se encargará de comprobar de si en las tres primeras letras de las cadenas que le envía el servidor está la palabra descrita anteriormente. Todo ello se hará mediante una función de comparación, que en caso de que devuelva un uno (las tres primeras letras serán FIN), este sabrá que la partida ha finalizado y procederá a cerrar el socket abierto con el servidor y posteriormente, cerrar la aplicación.

Hay que añadir que se ha decidido fijar el tamaño de los mensajes con el que se comunican cliente y servidor. De esta manera, se simplifica en gran medida la comunicación entre ambos. El tamaño de estos mensajes se ha fijado según el tamaño máximo de las palabras (que en nuestro caso, se ha decidido que sea de 32 caracteres
incluyendo el carácter nulo), añadiéndole 10 caracteres más. En definitiva, el tamaño de los mensajes será de 42 caracteres.

4. MANUAL DE USUARIO.

4.1. Compilación de la aplicación.

Para compilar el programa, se puede utilizar el MAKEFILE (no se adjunta ), utilizando el comando ‘make’ de la siguiente manera:

$ make all

También se puede utilizar el compilador GCC de Linux introduciendo los siguientes comandos según queramos para el cliente o el servidor:

Para el cliente:

gcc Ahorcado_cliente.c socket_utils.c error.c miconio.c -o Ahorcado_cliente

Para el servidor:

gcc Ahorcado_servidor.c socket_utils.c error.c -o Ahorcado_servidor

4.2. Ejecución del cliente y el servidor.

Como ya se ha mencionado varias veces hasta el momento, esta es una aplicación que implementa el servicio del Ahorcado remoto en la arquitectura Cliente – Servidor.

El servidor se arranca en modo superusuario en cualquier terminal del sistema operativo Linux, habiendo compilado este previamente. La razón de que se tenga que ejecutar en modo superusuario es que la ejecución de un servidor requiere del acceso a ciertos privilegios del sistema de los cuales no se dispone en modo usuario.

En otra terminal diferente o incluso en otra terminal de otro ordenador diferente, puede lanzarse la ejecución del cliente. Al igual que el servidor, este debe de ser previamente compilado para poder ser ejecutado, pero a diferencia con él, la ejecución de un cliente no necesita de privilegios para llevarse a cabo.

En el caso en que la ejecución del cliente se lance en un ordenador diferente al que se está ejecutando el servidor, debe indicarse como parámetro en el comando de la ejecución del cliente, la dirección IP propia del ordenador en el que está siendo ejecutado el servidor. O bien, no indicarlo como parámetro, pero será preguntado al usuario al ejecutar el cliente.

Para ejecutar el servidor se escribirá la siguiente línea de comandos (imagen 4.1):

$ sudo ./Ahorcado_servidor

Para ejecutar el cliente podría escribirse la siguiente línea de comandos (imagen 4.2), donde la dirección IP es una elegida para el ejemplo, pudiéndose cambiar según las necesidades del usuario:

$ ./Ahorcado_cliente 192.168.1.5

Una vez establecida la conexión, aparecerán en la terminal del cliente una cadena con una serie de asteriscos, tantos como letras contenga la palabra con la que se haya iniciado la partida.

La misión del cliente es ir introduciendo letras para intentar descubrir el contenido de la palabra oculta. Se mostrará el seguimiento de la palabra en la terminal del cliente, así como los fallos que lleva acumulados.

5. BIBLIOGRAFÍA EMPLEADA.

La bibliografía empleada en la realización de este trabajo ha sido la mostrada a continuación:

- Douglas E. Comer and David L. Estevens, "Internetworking with TCP/IP vol III: client-server programming and applications". Prentice Hall, 1996.

- Behrouz A. Forouzan "TCP/IP Protocol Suite" 4ª Edición, McGraw Hill, 2010.

- Apuntes proporcionados por el profesor de la asignatura Redes II acerca del modelo Cliente – Servidor, la interfaz de sockets y la API en función de los sockets.

- Página web con contenido relacionado con la programación de sockets en c para Linux. http://www.chuidiang.com/clinux/sockets/sockets_simp.php

- Página web donde se encontró el código fuente para poder crear la biblioteca “miconio.h” y poder adaptarla a las necesidades del servicio, así como la utilización de una simulación de la función original getch(). http://www.reloco.com.ar/linux/prog/tecla.html

Autores:
Gabriel Cebrián Márquez.
Estefanía Coronado Calero.
Iván Durango Blanco.

Código Fuente Cliente-Servidor: Ahorcado remoto.

Código fuente del Servidor:

/*************************************************************************
*
* Servidor del juego Ahorcado en TCP.
* Asignatura: Redes II.
* Autores:
* Gabriel Cebrián Márquez.
* Estefanía Coronado Calero.
* Iván Durango Blanco.
*
************************************************************************/

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 

#include 
/*extern int errno;*/

#include "error.h"
#include "socket_utils.h"

#define _USE_BSD
#define QLEN     32 /* Longitud máxima de la cola de conexiones */
#define BUFSIZE   4096
#define MAXDICT     32 /* Máximo tamaño de la palabra del ahorcado */
#define MAXLINEA MAXDICT + 10
#define NUM_PALABRAS     15

void reaper(int);
int escogeAleatorio();
int ahorcadoSrv(int desc);

/*************************************************************************
*
* main - Servidor concurrente para el servicio del ahorcado remoto.
*
*************************************************************************/

int main(int argc, char *argv[])
{
char *service = "8041"; /* Nombre del servicio o número de puerto */
struct sockaddr_in fsin; /* Dirección del cliente   */
unsigned int alen;  /* Tamaño de la dirección del cliente  */
int msock;   /* Socket del servidor maestro   */
int ssock;   /* Socket del servidor esclavo   */

switch (argc)
{
case 1:
break;
default:
errexit("Uso del programa: Ahorcado_servidor\n");
}

/* Se crea un socket pasivo */
msock = passiveTCP(service, QLEN);
(void) signal(SIGCHLD, reaper);

while (1)
{
alen = sizeof(fsin);

/* Cambiamos el identificador del socket */
ssock = accept(msock, (struct sockaddr *)&fsin, &alen);

if (ssock < 0)
{
if (errno == EINTR)
continue;
errexit("Error ACCEPT: %s\n", strerror(errno));
}

switch (fork())
{
case 0:  /* Hijo */
(void) close(msock);
exit(ahorcadoSrv(ssock));
default: /* Padre */
(void) close(ssock);
break;
case -1:
errexit("Error FORK: %s\n", strerror(errno));
}
}
}

/*************************************************************************
*
* ahorcadoSrv - Función que gestiona el juego en el servidor.
* 
*************************************************************************/

int ahorcadoSrv(int desc)
{
/* Diccionario de palabras para el juego */
char diccionario[NUM_PALABRAS][MAXDICT] = { 
"CARACOL",
"MOTOCICLETA",
"HORMIGA",
"GUACAMAYO",
"HECHICERO",
"JUGUETE",
"LICENCIA",
"INSECTICIDA",
"JINETE",
"LADRILLO",
"LEVADIZO",
"JEROGLIFICO",
"LEVITACION",
"IMPACIENCIA",
"IMPERMEABILIDAD"};

char auxiliar[MAXLINEA];
char solucion[MAXLINEA] = "Correcta: "; /* Array auxiliar para mostrar la palabra correcta al final. */
char ahorcado[] = "AHORCADO"; /* Array auxiliar para mostrar ahorcado*/
char buffer[BUFSIZ];
char solucionSrv[MAXDICT + 26] = "La palabra a adivinar es: "; /* Solución que se mostrará en el servidor. */

int cc;
int aleatorio = escogeAleatorio(); /* Indice aleatorio del array*/

int i;
int encontrados;
int NumCaracteresAEncontrar = 0;
int errores = 0;

/* Mostramos la palabra que se debe adivinar en la terminal del servidor. */
printf("%s\n", strcat(solucionSrv, diccionario[aleatorio]));

/* Inicializamos el vector auxiliar a espacios vacíos. */
for (i = 0; i < MAXLINEA; i++)
auxiliar[i] = ' ';

/* Colocamos los asteriscos de la palabra elegida. */
for (i = 10; diccionario[aleatorio][i-10] != '\0'; i++)
auxiliar[i] = '*'; 
auxiliar[i] = '\0';

/* Pongo el limite de caracteres que deben ser encontrados. */
NumCaracteresAEncontrar = i - 10;

/* Enviamos la primera pista al cliente, todavía sin haber realizado ningún intento. */
if (write(desc, auxiliar, MAXLINEA) < 0) 
errexit("Error WRITE (primera pista): %s\n", strerror(errno));

/* Mientras no superemos el número de errores, no hayamos ganado y leamos algo del cliente */
while ((NumCaracteresAEncontrar > 0) && (errores < 8) && (cc = read(desc, buffer, sizeof(buffer))) )
{
if (cc < 0)
errexit("No se ha leído la letra correctamente: %s\n", strerror(errno));

/* Inicializamos encontrados, que servirá para ver si se encuentra la letra recibida todavía sin descubrir. */
encontrados = 0;

/* Recorremos todas las letras de la palabra del diccionario */
for (i = 10; diccionario[aleatorio][i-10] != '\0'; i++)
{
/* Miramos que no la hayamos introducido anteriormente. */
if ((toupper(buffer[0]) == diccionario[aleatorio][i-10]) && (toupper(buffer[0]) != auxiliar[i]))
{
auxiliar[i] = toupper(buffer[0]);
encontrados++;
NumCaracteresAEncontrar--;
}
}

if (encontrados == 0) errores++;

/* Ponemos la palabra AHORCADO según el número de errores. */
for (i = 0; i < errores; i++)
auxiliar[i] = ahorcado[i];

if ( NumCaracteresAEncontrar != 0 && errores < 8)
{
if (write(desc, auxiliar, MAXLINEA) < 0) 
errexit("Error WRITE (envío pista): %s\n", strerror(errno));
}

}


if (errores >= 8)
{
if (write(desc, "FIN DE LA PARTIDA. ¡Has sido ahorcado!", MAXLINEA) < 0) 
errexit("Error WRITE (envío final de partida): %s\n", strerror(errno));
}
else
{
if (write(desc, "FIN DE LA PARTIDA. ¡Has ganado!", MAXLINEA) < 0)
errexit("Error WRITE (envío final de partida): %s\n", strerror(errno));
}

/* Enviamos la palabra correcta */
if (write(desc, strcat(solucion, diccionario[aleatorio]), MAXLINEA) < 0)
errexit("Error WRITE (envío solución): %s\n", strerror(errno));

/* Cerramos socket */
close(desc);
return 0;
}

/*************************************************************************
*
* escogeAleatorio - Función que gestiona el juego en el servidor.
* 
*************************************************************************/

int escogeAleatorio()
{
int i, n, aleatorio, P, U;

/* Indices, entre 0 y NUM_PALABRAS-1. Son NUM_PALABRAS palabras*/
P = 0;

U = NUM_PALABRAS-1;

srand(time(NULL));

aleatorio = P+(int)(((U-P+1.0)*rand())/(RAND_MAX+1.0));

return aleatorio;
}

/*************************************************************************
*
* reaper - Limpia los hijos en estado zombie.
* 
*************************************************************************/

void reaper(int sig)
{
int status;

while (wait3(&status, WNOHANG, (struct rusage *)0) >= 0)
/* empty */;
}

Código fuente del Cliente:

/*************************************************************************
*
* Cliente del juego Ahorcado en TCP.
* Asignatura: Redes II.
* Autores:
* Gabriel Cebrián Márquez.
* Estefanía Coronado Calero.
* Iván Durango Blanco.
*
************************************************************************/

#include 
#include 
#include 
#include 
#include 

#include 
/*extern int errno;*/

#include "error.h"
#include "socket_utils.h"

/* Librerías incluídas */
#include "miconio.h"

int ahorcadoCli(const char *host, const char *service);
int comparacion(char *c1);
void leerDeServidor(char *buf, int socket);

#define MAXLINEA  42 /* Máximo tamaño de la línea que recibiremos. */

/*************************************************************************
*
* Main - Cliente ahorcado TCP.
*
************************************************************************/

int main(int argc, char *argv[])
{
char *host = "localhost"; /* Host que se usa si no se indica ninguno */
char *service = "8041"; /* Nombre del servicio por defecto     */
char nombreServidor[256]; /* Almacenará el nombre del servidor, si fuera necesario. */

switch (argc)
{
case 1:
printf("Indica el nombre del host o IP al que conectar: ");
scanf("%s", nombreServidor);
fflush(stdin);
host = nombreServidor;
break;
case 2:
host = argv[1];
break;
default:
fprintf(stderr, "Uso del programa: Ahorcado_cliente [host]\n");
exit(1);
}
ahorcadoCli(host, service);
exit(0);
}

/*************************************************************************
*
* ahorcadoCli - Función que gestiona el juego para el cliente.
*
************************************************************************/

int ahorcadoCli(const char *host, const char *service)
{
char buf[MAXLINEA+1]; /* Buffer para intercambio de información */
int socket;   /* Descripción del socket    */
int outchars;  /* Número de caracteres enviados   */

socket = connectTCP(host, service);

printf("\n=======================================");
printf("\n          AHORCADO REMOTO");
printf("\n=======================================");
printf("");
printf("\nInstrucciones: El servidor elegirá aleatoriamente una palabra que usted tendrá");
printf("\n  que adivinar.");
printf("\nDispone de 8 intentos para acertarla. En cada intento podrá elegir una letra.");
printf("\nSi la palabra a adivinar la contiene, esta aparecerá en su lugar.");
printf("\nSi usted repite una letra se le añadirá un fallo a su lista. El juego finalizará");
printf("\n  si usted adivina la palabra o por el contrario se muestra la palabra AHORCADO.");
printf("\n\n\nErrores:  Palabra a adivinar:");
printf("\n\n");

/* Leemos la cadena del servidor donde se nos ofrece la primera pista. */
leerDeServidor(buf, socket);
printf("%s\n",buf);

while (buf[0] = getch())
{
if (((buf[0] >= 'A') && (buf[0] <= 'Z')) || ((buf[0] >= 'a') && (buf[0] <= 'z')))
{ 
buf[MAXLINEA] = '\0'; /* Fin de linea */
outchars = strlen(buf);
if (send(socket, buf, outchars) < 0)
errexit("Error SEND: %s\n", strerror(errno));;

/* Se lee del servidor */
leerDeServidor(buf, socket);

if(comparacion(buf) == 1)
{
printf("%s\n",buf); /* Hemos llegado al final, ganando o perdiendo, imprimimos dos líneas. */
leerDeServidor(buf, socket);
printf("%s\n",buf);

close(socket);
exit(0);
}

printf("%s\n",buf);
}
}
}

/*************************************************************************
*
* comparacion - Función que determina cuando finaliza el cliente, acabará
* cuando el servidor responde FIN.
* Si hemos llegado al final retorna 1. De lo contrario retorna 0.
*
************************************************************************/

int comparacion(char *c1)
{ 
char palabra[] = "FIN";
int i;

for (i = 0; i<3; i++)
{
if (c1[i]!=palabra[i])
return 0;
}

return 1;
}

/*************************************************************************
*
* leerDeServidor - Función que recoje lo que el servidor envía.
*
**************************************************************************/

void leerDeServidor(char *buf, int socket)
{
int inchars;
int n;

for (inchars = 0; inchars < MAXLINEA; inchars += n)
{
n = read(socket, &buf[inchars], MAXLINEA - inchars);

if (n < 0)
errexit("Error READ: %s\n", strerror(errno));
}
}

Link para descargar el código fuente:

Codigo_fuente_ahorcado

Para más información sobre como ejecutar, como a sido diseñado, etc visitar:

http://aprendiendo2veces.blogspot.com/2011/04/aplicacion-cliente-servidor-ahorcado.html

jueves, 7 de abril de 2011

La ley Sinde. ¿De verdad servirá para algo?

En este breve artículo, se intenta dar una opinión personal sobre el impacto social y cultural que la ley Sinde está originando tras su creación y posterior aprobación. Para esto, se intentaran dar razones sustancialmente razonadas, donde se explicará, desde un punto de vista objetivo el porqué de la oposición que genera esta ley.

Tras un análisis profundo, llego a la conclusión de que estoy desacuerdo con algunas de las ideas que se exponen actualmente sobre este tema, aunque también en desacuerdo con otras.
Está claro que la Ley Sinde, se hace exclusivamente para proteger la propiedad intelectual en internet, si bien es cierto, que es creada para proteger los intereses no de una forma general, si no de una forma muy privada.

Este razonamiento cobra sentido al pensar en el tanto porciento “irrisorio” que se llevan de beneficio los autores por sus obras y en ver como los intermediarios son los que realmente se llevan el mayor beneficio sin crear absolutamente nada. Aunque parezca algo sorprendente, esto no solo ocurre en el ámbito de la propiedad intelectual, que tanto está de moda, sino que también podemos observar como los agricultores que son realmente quienes realizan la producción de los productos agropecuarios (sus autores), reciben por estos cantidades completamente grotescas y como los intermediarios sacan beneficios totalmente desproporcionados.

Por este motivo, es completamente comprensible que muchos autores españoles estén en contra de esta ley, siendo realmente los intermediarios los interesados en su creación.

Desde mi punto de vista, es una buena idea crear una ley que regule los derechos de autor, pero no de esta forma tan restrictiva y prohibitoria, si no tomando medidas de verdad y llegando al fondo del asunto.

Si bien es cierto que la cultura vive hoy más esplendor que en el pasado debido a su facilidad de difusión y acceso con el uso de las nuevas tecnologías, pero el problema de la piratería no se centra en esta facilidad de acceso, si no en el coste tan elevado de productos con propiedad intelectual como CDs de música, películas, videojuegos etc.

En este aspecto, me parecen una buena idea servicios existentes en la actualidad como "spotify", en los cuales se tiene acceso a toda tu música favorita con costes muy reducidos e incluso gratis. Pero no solo eso, si no que, al disponer de todas las canciones sin necesidad de descargas, la piratería se reduce en gran proporción. ¿ Por que no se progresa en esa línea?

Desde otra perspectiva, es cierto, que la esencia de Internet son los enlaces, contra los que arremete la ley Sinde, y que esta herramienta es de gran importancia en el futuro, pero estoy en contra de lo que se expone en algunos artículos al decir que la realidad es que “La música en Internet ES GRATIS”, ya que esto es solo un pensamiento debido a la cultura pro-piratería que vivimos actualmente y creado por una sociedad que ve como normal realizar descargas de forma ilegal, y no se para a pensar que esto es un delito contra la propiedad intelectual y sobre todo contra los autores.