Interesante

Cómo compartir archivos en Linux mediante NFS
El NFS o Network File System es un sistema de archivos virtual que permite que una máquina UNIX conectada a una red pueda montar un sistema de archivos de otra máquina e interactuar sobre él como si fuera propio. De esta manera, constituye un medio de compartición de archivos totalmente transparente para el usuario de la máquina cliente.

NFS no es en realidad un sistema de archivos físico, sino una capa de abstracción del sistema de archivos real (ext2, UFS, FFS, etc...) que permite el montaje de éste remotamente.
Cómo configurar Squid Cómo configurar Squid: Parámetros básicos para servidor Proxy.

Introducción.
Squid es el software para servidor Proxy más popular y extendido entre los sistemas operativos basados sobre UNIX®. Es muy confiable, robusto y versátil. Al ser software libre, además de estar disponible el código fuente, está libre del pago de costosas licencias por uso o con restricción a un uso con determinado número de usuarios.
Cómo instalar Linux
Introducción
Uno de los puntos más importantes para instalar Linux es tener listo nuestro disco duro. Parece un tanto raro el comentario pero ciertamente es donde más de un usuario se pierde, especialmente cuando tienen que particionar y cosas así, por lo que lo explicaremos brevemente.
Dado que actualmente la mayoría de las PC llegan con Windows preinstalado (¿dije la mayoría?, más bien todas), los usuarios no se preocupan por mucho más que sólo prenderla y cuando llega el caso, reinstalar con un CD, pero cuando tiene que hacer que el disco duro contenga otro sistema operativo (incluso otra versión de Windows), necesitar partir (particionar) el disco duro. Y aquí empezamos con los problemas.
Aquellos afortunados que tengan la posibilidad de adquirir otro disco duro para instalar Linux, pues adelante y se ahorrarán todo lo relativo a particionamiento de este tutorial, pero en caso contrario, pues continuamos.
Un disco duro se divide, físicamente, en cilindros y cada uno de estos se divide en sectores, regularmente de 512 bytes y es en este espacio donde la información es grabada. En el momento que indicamos que un disco se divida en varias unidades, realizamos el proceso llamado particionamiento, en el que se le asigna un espacio especifico a cada partición.
Verifiquemos nuestro hardware
Un elemento que regularmente los usuarios novatos pasan por alto es el relativo a verificar la compatibilidad/estado de su hardware, lo que puede traer como consecuencia que el sistema no quede bien instalado, sea inestable o de plano nos mande por un tubo el instalador, por lo que debemos verificar los siguientes puntos:
- Revisar que nuestro hardware esté soportado por la distribución que vamos a utilizar.
- Revisar que funcionen correctamente las tarjetas (red, sonido, módem).
- Revisar que el disco duro no tenga sectores dañados (debe ejecutarse el scandisk).
- Si se manifiestan problemas con Windows (lo que no es raro), como que se congele la máquina o no termine de encender, recomendamos enviarla antes a un servicio técnico para que se le revise la tarjeta madre o el estado del RAM.
Las revisiones de compatibilidad de hardware las pueden buscar en:
- Red Hat: http://hardware.redhat.com/hcl/
- Mandrake: http://www.linux-mandrake.com/en/hardware.php3
- SuSE: http://hardwaredb.suse.de/index.php
- Debian: http://www.debian.org/
- Slackware: http://www.slackware.com
Para otras distribuciones deberán revisar la página Web del proveedor.
En los casos de hardware desconocido o no compatible (caso clásico son los winmodem y softmodem) o que tengamos dañada alguna tarjeta, lo más recomendable es adquirir uno nuevo. Para el caso concreto de los módem, casi cualquiera externo por hardware funciona.
Para los que no sepan el porque, Linux no soporta ciertos dispositivos y tarjetas debido a que los controladores los hacen los mismos miembros de la comunidad GNU/Linux y esto es posible sólo cuando el fabricante libera las especificaciones de sus componentes, por eso siempre hay un un cierto período entre que un nuevo dispositivo es lanzado y que lo soporte este SO; caso contrario con Windows/Macintosh, ya que los fabricantes mismos son quienes desarrollan y prueban los controladores. El caso de los módem por software (winmodem/softmodem) es especial, ya que diversas funciones que debería manejar el hardware se le relega a que las maneje Windows directamente, lo que es una ventaja para los fabricantes al ser muy baratos de producir, peor que imposibilita su uso fuera del SO de las ventanas.
Una revisión previa es importante, ya que es frecuente que un usuario incauto simplemente no pueda configurar su módem, tarjeta de red o de sonido y le eche la culpa al sistema operativo, o peor aún cuando un hardware dañado truene la instalación, lo que los lleva a decir "Linux no sirve". El caso es sencillo, son los componentes, no el software. Si aparentemente todo está bien, pues continuamos.
Antes que nada, respaldamos
A menos a que seamos masoquistas, hayamos enloquecido o nos caiga mal el propietario de la información, es kamikaze (viento divino o irse de cabeza al barranco, como lo quieran traducir) no respaldar la información del disco duro; por lo que pueden utilizar un quemador de CD's, una unidad de Zip o Jaz o una unidad de red, también pueden utilizar alguna herramienta para generar una imagen de su disco, como:
- Partition Image for Linux (http://www.partimage.org)
- Norton Ghost (http://www.symantec.com/sabu/ghost/ghost_personal)
- PowerQuest Drive Image (http://www.powerquest.com/driveimage)
¿Para que particionamos?
Los motivos para particionar son varios e incluso es aconsejable aún cuando no se vaya a instalar otro sistema operativo, porque:
- Especifica partes donde se guarda la información y donde se guardan los programas, de manera que si se corrompe una unidad, no se pierde todo. Útil también con muchos virus que atacan la unidad C de una PC.
- Mejora el desempeño del disco duro, al tener que leer sectores más pequeños de disco duro y no toda la unidad.
- Limita el tamaño al que pueden crecer los directorios de diversos usuarios (en ambientes de redes), para evitar que saturen el disco duro y el sistema operativo ya no pueda operar.
¿Con que particionamos?
Desde DOS podemos utilizar una muy confiable pero limitada herramienta llamada >fdisk, la cual puede eliminar y crear nuevas particiones, sin embargo el contenido del disco duro se pierde y no hay manera de recuperarlo. Para activarlo simplemente es necesario, desde el prompt de DOS, teclear fdisk, eliminar todas las particiones existentes y luego crear las nuevas, después de salir de fdisk debemos dar formato las unidades ya que se pierde absolutamente todo. Nota: esta herramienta no puede funcionar desde Windows, es necesario iniciar una sesión de DOS para ello.
Para particionar mediante fdisk pueden apoyarse en el conocido manual disponible en el sitio del proyecto Linuxdoc: http://www.linuxdoc.org/HOWTO/mini/Partition/partition-5.html.
Se pueden recuperar particiones creadas con fdisk, pero será mejor ser cuidadoso y leer antes el siguiente manual para soporte: http://www.linuxdoc.org/HOWTO/mini/Partition/recovering.html.
Otras opciones para crear particiones son:
- FIPS. Legendaria herramienta libre que se distribuye con Red Hat y otras distribuciones de Linux desde hace tiempo, pero que tiene varias limitaciones, es software libre (http://www.igd.fhg.de/~aschaefe/fips).
- parted: Particionador del proyecto GNU, es software libre (http://www.gnu.org/software/parted/parted.html).
- Partition Magic: Permite crear, eliminar, mover y modificar las particiones desde un entorno gráfico, es software comercial - $70 USD - (http://www.powerquest.com/partitionmagic/index.html)
- Disk Drake: Script en Perl/Gtk para crear, modificar y eliminar particiones que se distribuye principalmente con Mandrake, es software libre (http://www.linux-mandrake.com/diskdrake)
- Disk Druid: Es el particionador por defecto de la instalación de Red Hat™, software libre.
- Ranish Partition Manager: tiene un sistema de arranque compatible con Windows 9x/NT/2000 y Linux, es software libre (http://www.ranish.com/part/)
- The Partition Resizer v. 1.3.4: permite mover y modificar particiones existentes, Freeware (http://www.utilitygeek.com/cgi-bin/download.pl?http://members.nbci.com/Zeleps/Files/PRESZ134.ZIP)
¿Cómo divido mi disco duro?
El tamaño de las particiones dependen del tamaño del disco es lógico que mientras más grande es éste, más espacio puedes dejar a Windows por un lado y Linux por el otro, pero...
Cuidado. Un aspecto muy importante es el hecho que muchos BIOS, incluyendo los de algunas computadoras nuevas (contra lo que dicen los fabricantes), no pueden iniciar un sistema operativo que se encuentre después del cilindro 1024 (aproximadamente 7,168 MB), por lo que al determinar el tamaño debemos cuidar donde colocaremos la partición de Linux.
En principio, a cada sistema operativo hay que dejarle el espacio suficiente para que trabajo, lo cual es variable, por ejemplo, Windows 95 ó 98 pueden funcionar dentro de particiones de 3 GB, con espacio para nuestras aplicaciones y archivos, pero Windows 2000 necesita de al menos 8 GB para trabajar bien como estación de trabajo (como servidor es mucho más); Red Hat necesita al menos de 600 MB para una instalación mínima, pero yo en lo personal dejo entre 2 y 3 GB sólo para el sistema operativo, aparte va el espacio para usuarios, archivos de bitácora y demás; es cosa de como se acomoden y lo que vayan a cargar para determinar cuanto espacio necesitan.
Otro comentario es que, regularmente, Windows debe ir en la primera partición y que este sistema operativo es el "propietario" del Master Boot Record (MBR), que se ubica en el sector 0 del disco y que tiene la información para el arranque de (los) SO(s).
Hace mucho tiempo cuando se utilizaba Lilo como arrancador para GNU/Linux, existía la limitación de tener que instalar éste y la partición que contuviese a /boot antes del cilindro 1024 del disco duro. Siendo que actualmente casi todas las distribuciones de GNU/Linux utilizan Grub, esta limitación ya no la hay.
Pueden obtener más información en:
- http://www.linuxdoc.org/HOWTO/mini/Linux+Win95/
¿Cómo identifico la unidad donde voy a instalar Linux?
Cuando vemos un disco duro o unidades dentro de Windows, se nos presentan como letras del abecedario (C, D, E, etc.) pero dentro de Linux, es bastante diferente, ya que su estructura semeja un árbol donde cada partición y dispositivo de lectura/escritura se representa como un directorio, los nombres de las unidades de disco duro son:
- hda: disco duro principal
- hdb: disco duro secundario
- hda1: primera partición del disco duro principal.
- hdb2: segunda partición del disco secundario
Ahora, para ejemplificar todo este proceso, supongamos que tienen un disco duro de 20 GB y generan dos particiones, uno de 5 GB para Windows y el resto para Linux, entonces es hda1 (Windows) y hda2 (Linux), siendo en este último donde crearíamos las particiones del sistema.
¿Qué particiones necesito para Linux?
NOTA: Estas particiones se crean al momento de instalar, no de dividir el disco duro para varios sistemas operativos, pero es importante que las conozcan de antemano.
En principio sólo se pueden montar tres y es suficiente para que funcione:
/boot
Es la partición donde se leen los parámetros para iniciar el sistema.
Requiere al menos 75 MB en Red Hat™ Enterprise Linux 3.0 y White Box Enterprise Linux 3.0. Asignar más espacio puede considerarse desperdicio.
/ o raíz
Es donde se instalarán los componentes del sistema operativo.
Requiere de 350 a 512 MB.
swap
Espacio físico para la memoria virtual del sistema.
Debe asignarse el doble del tamaño del RAM físico.
Esta será siempre la última partición del disco duro.
No se asigna punto de montaje.
Otras particiones son:
/usr
Se trata del segundo directorio en cuanto a jerarquía en el sistema. Contiene la mayoría de los binarios (ejecutables), bibliotecas compartidas, manuales, datos de aplicaciones e imágenes que utiliza el sistema, cabeceras de desarrollo, el árbol del kernel y documentación.
Requiere al menos 1.5 GB en instalaciones básicas. Debe considerarse el software a utilizar a futuro. Para uso general, se recomiendan no menos de 5 GB y, de ser posible, considere un tamaño óptimo de hasta 8 GB en instalaciones promedio.
/tmp
En éste se almacenan todos los ficheros temporales que generan los distintos programas.
Requiere al menos 350 MB y puede asignarse hasta 2 GB o más dependiendo de la carga de trabajo y tipo de aplicaciones. Si por ejemplo el sistema cuenta con un grabador de DVD, será necesario asignar a /tmp el espacio suficiente para almacenar una imagen de disco DVD, es decir, al menos 4.2 GB.
/var
Corresponde a la partición de datos de servicios.
Requiere al menos 512 MB en estaciones de trabajo sin servicios. En servidores regularmente se le asigna al menos la mitad del disco duro.
/home
Corresponde a la partición de datos de usuarios. Es donde se colocan los directorios para cada usuario con los perfiles de cada cuenta.
En estaciones de trabajo se asigna al menos la mitad del disco duro a esta partición.
Por costumbre (y experiencia) recomiendo crear particiones independientes para /boot, / (raíz), /home, /var y swap. También es aconsejable una para /usr y /tmp.

Por Hugo Madrid Luna
crowley arroba mexicoextremo.com.mx
http://www.mexicoextremo.com.mx
Guía de referencia de comandos Unix y Linux Guía de referencia de comandos Unix y Linux

Este guía no es para leer de forma seguida, este guía pretende ser una referencia de comandos Unix/Linux que se pueda consultar en cualquier momento. No pretende ser una guía exhaustiva, sino una referencia que sirva como recordatorio de los comandos más utilizados.
El shell:
Existen distintos interpretes de comandos en el mundo Unix: csh, bash, tsh, ksh,.. pero salvo pequeñas diferencias todos son parecidos. En este documento partimos sobretodo de bash, ya que esta muy extendido a través de Linux.
Cómo configurar Apache como servidor WebDAV
Configuración de Apache, como servidor WebDAV
En este artículo, explicaré como convertir en Linux, nuestro servidor web Apache (que previamente habremos instalado), en un servidor WebDAV. El fin de este dossier, será el de poder publicar los calendarios que desarrollemos con la aplicación iCal de Apple, de una forma muy similar a como lo haríamos con una cuenta .mac.
Una vez publicados nuestros calendarios, podrá la gente suscribirse a ellos o consultarlos vía web.
Cómo administrar Linux Administracion

¿Puedo trabajar normalmente como root?

Un consejo, solo utilizar la cuenta de root (administrador) para tareas de administracion. Para trabajar normalmente con el sistema NO hacerlo como root, ya que se tiene acceso completo a todo el sistema y es facil de estropear cosas si no se sabe lo que se hace. Aqui teneis un ejemplo que le ocurrio al autor de esta seccion trabajando como root:

Sep

Cómo utilizar los sockets en Linux

Escrito por J. Llorente

En este artículo explicaré el funcionamiento básico de los sockets en Linux y veremos dos ejemplos prácticos de su uso. No me meteré en temas de eficiencia o temas demasiado técnicos en la explicación del protocolo IP y de TCP ni UDP. El usuario debe tener unos conocimientos básicos en la programación en Linux así como de redes.

Para poder probar estos ejemplos necesitas un sistema Linux o Unix. Un compilador de C, yo los he probado tanto con cc como con gcc.

Seguro que más de una vez habrás querido hacer un programita que se pueda comunicar con otros programitas a través de la red o internet, pues bien, este artículo te explica cómo hacer eso utilizando los sockets y el protocolo UPD/IP y TCP/IP.

Conceptos básicos
Socket: es el componente básico para la intercomunicación de procesos a través de la red. La interfaz del socket proporciona acceso a los protocolos de transporte.
Hay varios tipos de sockets, estos tipos definen las propiedades de la comunicación visibles por el usuario. La comunicación entre procesos sólo se puede realizar con sockets del mismo tipo. Tipos de sockets:

STREAM SOCKET: proporciona comunicación bidireccional, alcanzable, secuencial y no duplica el flujo de datos. Este tipo de comunicación es similar a una conversación telefónica. Bajo Internet (AF_INET), el tipo del socket es SOCK_STREAM, y TCP.
DATAGRAM SOCKET: soporta flujo bidireccional de mensajes. Un proceso utilizando un datagram socket puede recibir mensajes en un orden diferente al de la secuencia de envío e incluso pueden llegarle duplicados. Es similar a enviar una carta. Bajo Internet (AF_INET), el tipo de socket es SOCK_DGRAM, y usa UDP.
RAW SOCKET: proporciona acceso a protocolos de capas inferiores. Estos protocolos normalmente son orientados a datagramas, pero sus características dependen de la interfaz proporcionada por el protocolo. Los protocolos RAW no se utilizan en la mayoría de las aplicaciones. Estos proporcionan soporte para la investigación y desarrollo de nuevos protocolos o para el acceso a ciertas facilidades de los protocolos existentes.

Para crear un socket se utiliza la función socket(),

s = socket(dominio, tipo, protocolo);

Si no se especifica el protocolo ( valor = 0) el sistema selecciona el protocolo que soporte el tipo del socket origen.
El dominio está especificado en una de las constantes definidas en <sys/socket.h>. Para el dominio UNIX la constente es AF_UNIX, para el dominio INTERNET la constente es AF_INET. Estas constantes indican el formato de la dirección para interpretar los nombres.

Los tipos de los sockets están definidos en <sys/socket.h>. SOCK_STREAM, SOCK_DGRAM y SOCK_INET son soportados por AF_INET y AF_UNIX.

s= socket(AF_INET, SOCK_STREAM, 0);

Una vez creado el socket debemos darle un nombre para que las otras aplicaciones puedan conectarse al mismo. Este nombre debe ser único.

La función bind(s, nombre, longitud_nombre) dará un nombre a nuestro socket s creado anteriormente.

... struct sockaddr_in bs, des; bind(s,(struct sockaddr*)&bs, sizeof(bs)) des.sin_family = AF_INET; des.sin_addr.s_addr = inet_addr(argv[1]); des.sin_port = htons(atoi(argv[2])); ...

Creo que es mejor pasar directamente a los ejemplos porque se entienden muy bien y los podrás probar y ver como funcionan.

Los ejemplos
En el primer ejemplo utilizamos UDP (User Datagram Protocol) que es un protocolo orientado a datagramas y simple (cada operación de salida generada por un proceso produce exactamente un datagrama UDP). Es un protocolo no orientado a conexión y no se garantiza que alcance su destino.

Cliente ECO con UDP

#include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> /**********************************************************/ /* función MAIN */ /* Orden Parametros: IP destino, puerto , mensaje */ /* */ /**********************************************************/ main(int argc, char *argv[]) { int s; struct sockaddr_in bs,des; char resp[255]; int *sd; if (argc == 4) { // Creamos el socket s = socket(AF_INET,SOCK_DGRAM,0); if (s != -1) { bs.sin_family = AF_INET; bs.sin_port = htons(0); //Coge cualquier puerto disponible en la máquina bs.sin_addr.s_addr = htonl(INADDR_ANY); //Coge cualquier IP de la máquina //Asigna un nombre local al socket if( bind(s,(struct sockaddr*)&bs, sizeof(bs)) != -1) { des.sin_family = AF_INET; des.sin_addr.s_addr = inet_addr(argv[1]); des.sin_port = htons(atoi(argv[2])); //Envia el string sendto(s,argv[3],strlen(argv[3])+1,0,(struct sockaddr*)&des,sizeof(des)); printf("\n\n->Enviando: %s, a: %s en el puerto: %s \n",argv[3], argv[1], argv[2]); //Recibe el string del servidor recvfrom(s,resp, sizeof(resp) ,0,(struct sockaddr*)&des, sd); printf("<-Recibido: %s\n",resp); //Cierra el socket close(s); } else { printf("ERROR al nombrar el socket\n"); } } else { printf("ERROR: El socket no se ha creado correctamente!\n"); } } else { printf("\n\n\aEl número de parámetros es incorrecto\n\n"); } }

Servidor de ECO UDP

#include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> /**********************************************************/ /* función MAIN */ /* Orden Parametros: Puerto */ /* */ /**********************************************************/ main(int argc, char *argv[]) { int s; struct sockaddr_in bs, in; char entrada[255]; int sd; if (argc == 2) { // Creamos el socket s = socket(AF_INET,SOCK_DGRAM,0); if (s != -1) { bs.sin_family = AF_INET; bs.sin_port = htons(atoi(argv[1])); //Asigna el puerto especificado por la línea de comandos bs.sin_addr.s_addr = htonl(INADDR_ANY); //IP cualquiera de la máquina //Asigna un nombre local al socket if( bind(s,(struct sockaddr*)&bs, sizeof(bs)) != -1) { printf("\n\aServidor ACTIVO escuchando en el puerto: %s\n",argv[1]); //El while permite atender a múltiples clientes while (1) { //Recibe la cadena del cliente if ( recvfrom(s,entrada, sizeof(entrada) ,0,(struct sockaddr*) &in, &sd)== -1) perror("Error en recvfrom"); //Devuelve la cadena al cliente if (sendto(s,strcat(entrada,"\0"),strlen(entrada)+1,0,(struct sockaddr*) &in, sizeof(in)) == -1) perror("Error en sendto"); } //Se cierra el socket close(s); } else { printf("ERROR al nombrar el socket\n"); } } else { printf("ERROR: El socket no se ha creado correctamente!\n"); } } else { printf("\n\n\aEl número de parámetros es incorrecto\n\n"); } }

Cliente de ECO TCP

#include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> /**********************************************************/ /* función MAIN */ /* Orden Parametros: IP destino, puerto , mensaje */ /* */ /**********************************************************/ main(int argc, char *argv[]) { int s; struct sockaddr_in bs,des; char resp[255]; int *sd; if (argc == 4) { // Creamos el socket s = socket(AF_INET,SOCK_STREAM,0); if (s != -1) { bs.sin_family = AF_INET; bs.sin_port = htons(0); //Asigna un puerto disponible dela máquina bs.sin_addr.s_addr = htonl(INADDR_ANY); //Asigna una IP de la máquina //Asigna un nombre local al socket if( bind(s,(struct sockaddr*)&bs, sizeof(bs)) != -1) { //Se prepara el nombre de la máquina remota des.sin_family = AF_INET; des.sin_addr.s_addr = inet_addr(argv[1]); des.sin_port = htons(atoi(argv[2])); //Establece la conexión con la máquina remota connect(s,(struct sockaddr*)&des,sizeof(des)); //Envía el mensaje send(s,argv[3],strlen(argv[3])+1,0); printf("\n\n->Enviando: %s, a: %s en el puerto: %s \n",argv[3], argv[1], argv[2]); //Recibe la respuesta recv(s,resp, sizeof(resp) ,0); printf("<-Recibido: %s\n",resp); //Se cierra la conexión (socket) close(s); } else { printf("ERROR al nombrar el socket\n"); } } else { printf("ERROR: El socket no se ha creado correctamente!\n"); } } else { printf("\n\n\aEl número de parámetros es incorrecto\n\n"); } }

Servidor de ECO TCP

#include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #define MAX_CONN 10 //Nº máximo de conexiones en espera /**********************************************************/ /* función MAIN */ /* Orden Parametros: Puerto */ /* */ /**********************************************************/ main(int argc, char *argv[]) { int s,s_aux; struct sockaddr_in bs,in, out_s; char entrada[255]; int sd; if (argc == 2) { // Creamos el socket s = socket(AF_INET, SOCK_STREAM,0); if (s != -1) { bs.sin_family = AF_INET; bs.sin_port = htons(atoi(argv[1])); bs.sin_addr.s_addr = htonl(INADDR_ANY); //Asigna un nombre local al socket if( bind(s,(struct sockaddr*)&bs, sizeof(bs)) != -1) { printf("\n\aServidor ACTIVO escuchando en el puerto: %s\n",argv[1]); //Espera al establecimiento de alguna conexión listen(s, MAX_CONN); //Permite atender a múltiples usuarios while (1) { //Establece una conexión s_aux = accept (s,(struct sockaddr*) &in, &sd); //Recibe el mensaje del cliente if ( recv(s_aux,entrada, sizeof(entrada) ,0)== -1) perror("Error en recvfrom"); //Envia el mensaje al cliente if (send(s_aux,strcat(entrada,"\0"),strlen(entrada)+1,0) == -1) perror("Error en sendto"); //Cierra la conexión con el cliente actual close(s_aux); } //Cierra el servidor close(s); } else { printf("ERROR al nombrar el socket\n"); } } else { printf("ERROR: El socket no se ha creado correctamente!\n"); } } else { printf("\n\n\aEl número de parámetros es incorrecto\n\n"); } }

Tienes que crear 4 ficheros (clienteUDP.c, servidorUDP.c clienteTCP.c, servidorTCP.c) y copiar el código anterior en su respectivo fichero. Los compilas y ya puedes probarlos.

Los clientes también los puedes probar con cualquier servidor de eco de internet de que tengas instalado.

Nota de compilación:
En algunas máquinas Unix es necesario indicarle al compilador con qué librerias debe linkar para resolver las referencias externas producidas por la utilización de funciones de manejo de sockets.
Ejemplo: $gcc clienteUDP.c -o clienteUDP -lsocket -lnsl
En Linux no suele ser necesario la utilización de -lsocket –lnsl

Ficheros del artículo
- Código fuente de los ejemplos descritos en el artículo. [3,54KB]

Es un artículo de:

Manuel Lagos Torres