1. Skip to Menu
  2. Skip to Content
  3. Skip to Footer>

Interesante

  • Instalacion de Ubuntu

    El presente documento tiene la misión de indicar los pasos a seguir para la instalación de la distribución Ubuntu (versión 5.04 "Hoary Hedgehog") en un portátil Toshiba Satellite A40-201.

    La instalación no resultó sencilla y, tras cerca de 10 intentos y una noche sin dormir, logré encontrar la combinación adecuada....... 
  • Cómo clonar discos duros con Linux
    Cualquiera que haya tenido que instalar un parque de 10 - 100 estaciones de trabajo con exactamente los mismos sistema operativo y programas se habrá preguntado si hay un modo mejor - y más rápido - de hacerlo que mover los CDs de caja en caja. Clonar consiste en  - una vez - una estación de trabajo modelo, y después copiarla en todas las demás.
    El propósito de este texto es explorar algunos de los muchos modos de clonar la configuración del disco duro de una estación de trabajo. En el proceso de clonación, utilizaremos las posibilidades nativas de Linux para producir más o menos el mismo efecto que el bien conocido Norton Ghost del mundo de Windows.
  • Cómo configurar BIND

    BIND es el servidor de nombres de dominio más popular en Internet, que trabaja en todas las plataformas informáticas principales y se caracteriza por su flexibilidad y seguridad. A continuación se puede encontrar tanto la teoría general de los servicios de DNS, como una explicación detallada de los campos y opciones de la configuración de BIND, ejemplos, opciones de seguridad, herramientas de verificación, ligas de información adicional y otras más.

     

  • Cómo instalar NIS + NFS

    Procedimientos

    En el Servidor para poner NIS

    1. domainname nombre-de-dominio
    2. cd /var/yp
    3. mkdir nombre-de-dominio
    4. service portmap restart
    5. service ypserv restart
    6. service ypbind restart
    7. make
    8. En el servidor deben de estar seleccionados los servicios para arrancar desde inicio                                                                                                                                             
      • ypserv
      • ypbind
      • portmap
                        
                                
                      

    En el cliente para escuchar NIS

    1. En gnome seleccionar Aplicaciones -> System settings -> Authentication
    2. Marcar la casilla "Enable NIS Support"
    3. Seleccionar "Configure NIS..."
    4. En NIS Domanin escribir el nombre del dominio NIS creado
    5. En NIS Servidor ponr la ip del Servidor NIS
    6. En el servidor deben de estar seleccionados los servicios para arrancar desde inicio                                                                           
      1. ypbind
      2. portmap                                                  


    Ahora la parte NFS del Servidor

    1. como root cd /home
    2. mkdir nfs (aqui van a quedar todos los homes de los usuarios creados)
    3. cd /etc
    4. vi exports
    5. Agregar la siguiente linea

      /home/nfs rango.de.ips.de.red(rw,sync,no_root_squash)
      En mi caso particular la linea se ve asi:
      /home/nfs/ 192.168.1.*(rw,sync,no_root_squash)
    6. Reiniciar el demonio nfs con service nfs restart
    7. Los servicios que deben inicarse en el arranque para NFS son                                                                                      
      • netfs
      • nfs
      • nfslock
      • portmap

                         

                             

    Ahora la parte NFS en el cliente

    1. como root cd /etc
    2. vi fstab
    3. agregar la siguiente linea
      192.168.1.1:/home/nfs   /home/nfs    nfs   defaults    0 0
    4. mount -a
    5. Los servicios que deben inicarse en el arranque para NFS son                                                                                                          
      • netfs
      • nfs
      • nfslock
      • portmap

                                            

                          

    Agregando usuarios en el Servidor NIS

    La parte importante de agregar los usuarios en el NIS Servidor, es que, su directorio home no debe de quedar dentro de /home, sino dentro de /home/nfs/usuario.

    Con la utileria "Users & Groups", al agregar al usuario ejemplo, le decimos que su direcotorio personal quede dentro de /home/nfs/ejemplo.

    En el Servidor, es importante loggearse como el usuario recien creado, para que despues sea disponible en cualquier equipo de la red.

    Despues de loggearse y salir de la session como el usuario recien creado, el siguiente paso es (como root)

    1. cd /var/yp
    2. make
    3. service portmap restart
    4. service ypserv restart
    5. service ypbind restart
    6. Ir a la maquina cliente y loggearse como el usuario recien creado en el NIS Servidor. Todo debe de funcionar.


    Fuente:

    Kwame
    daniel arroba informatux.net
    http://www.informatux.net/
    Original: LinuxParaTodos

    Copyright.

    © 2003 Kwame. Se permite la libre distribución y modificación de este documento por cualquier medio y formato mientras esta leyenda permanezca intacta junto con el documento y la distribución y modificación se hagan de de acuerdo con los términos de la Licencia Pública General GNU publicada por la Free Software Fundation; sea la versión 2 de la licencia o (a su elección) cualquier otra posterior. La información contenida en este documento y los derivados de éste se proporcionan tal cual son y los autores no asumirán responsabilidad alguna si el usuario o lector hace mal uso de éstos.

    Technorati Tags:
    >>

  • MSN Messenger en Linux
    La mensajería instantánea es una mezcla de correo electrónico y chat, por un lado nos permite enviar mensajes a amigos (conocidos como contactos) que estén en ese momento conectados a Internet y, ya en las últimas versiones de las distintas aplicaciones de mensajería, disponen de "salas" de chat en donde te encuentras con gente desconocida.
    La mensajería instantánea nace en Israel gracias a la idea de un padre y su hijo que crean el primer programa llamado ICQ en el año 1996. Más tarde, en el año 1998, America Online compra Mirabili (empresa propietaria de ICQ). Según AOL, ICQ tenía 20 millones de usuarios activos en el año 2000 pero esta cifra ha ido decreciendo constantemente debido a la aparición de nuevos programas de mensajería.

  • Cómo configurar Squid Proxy Caché PROXY-CACHE

    Squid es el servidor de proxy y cache por excelencia. Rechace imitaciones.

    Cuando navegamos a traves de un proxy, cada peticion que hace nuestro navegador se delega al servidor proxy y es este el que se descarga la pagina o el elemento web que se ha solicitado y se lo pasa a nuestro navegador. Por tanto es un intermediario entre los usuarios y la web. Al estar en medio de ese trafico puede realizar dos funciones muy importantes: controlar los accesos (permitir o denegar segun se disponga en sus normas); y ademas hacer cacheo de elementos (paginas web, imagenes, iconos que una vez se piden se guardan en la memoria del proxy), con lo que si se solicita un elemento que ya se ha pedido en lugar de volver a bajarselo de internet, lo sirve el propio proxy. Con esta tecnica de cache nos podemos ahorrar desde un 20 a un 40% de trafico de internet.

27
Sep

Cómo utilizar los sockets en Linux

Escrito por J. Llorente

PDFImprimir E-mail
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

Agregue su comentario

Tu Nombre:
Asunto:
Comentario:

Últimos contenidos

Facebook conecta

Total visitas

3641380
38.107.179.233
UNITED STATES
US

Quien está en linea

Tenemos 61 invitados conectado(s)

Conectan

Locations of visitors to this page

Nos visitan desde

Últimos comentarios

Vitales Servidor