Este documento trata sobre la programación en cliente-servidor de bajo nivel utilizando sockets y canales. Explica conceptos como sockets, dominios y tipos de sockets, y la creación, implementación y supresión de sockets. También describe el desarrollo del lado del servidor y cliente con sockets, incluyendo constructores y métodos importantes. El objetivo es comprender la comunicación entre procesos a través de sockets para desarrollar aplicaciones cliente-servidor.

1. S.E.P. TECNOLÓGICO NACIONAL DE MÉXICO
INSTITUTO TECNOLÓGICO
de Tuxtepec
MATERIA:
PROGRAMACIÓN EN AMBIENTE C/S
INVESTIGACIÓN:
“PROGRAMACIÓN C / S DE BAJO NIVEL: SOCKETS Y
CANALES”.
CARRERA:
INGENIERA INFORMÁTICA
PRESENTA:
ANAYA MANZANO JUAN. 13350283
CATEDRÁTICO:
M.S.C VÍCTOR MANUEL EVARISTO SALINAS
San Juan Bautista Tuxtepec, Oax. Octubre de 2016.

2. Introducción.
En este documento se tratara la temática de la programación en ambiente cliente
servidor de bajo nivel, en específico de los sockets y canales.
Un socket no es más que un conector que uno dos o más programas que están en
la misma red, pero que se ejecutan en distintos nodos, ya sea en el servidor o en
un cliente, y es asi como los clientes de un servidor pueden hacer peticiones de
recursos de otras máquinas que están en la misma red, hacia otras máquinas, esto
con el fin de aprovechar las características que ofrecen los servidores.
También se mencionara sobre los dominios, se hablará de los tres tipos que se
implementa, se abordara el tema de desarrollo del lado tanto servidor como cliente
con sockets.

3. Contenido
Introducción........................................................................................................................................ 1
Socket.................................................................................................................................................. 3
Dominios y tipos de sockets................................................................................................................ 4
Creación, implementación y supresión de sockets............................................................................. 6
Supresión......................................................................................................................................... 7
Cerrar sockets.................................................................................................................................. 7
Desarrollo del lado del servidor con socket........................................................................................ 8
En la parte del servidor: ...................................................................................................................... 8
Constructores.................................................................................................................................. 8
Métodos:......................................................................................................................................... 8
En la parte del cliente:......................................................................................................................... 9
Constructores:................................................................................................................................. 9
Métodos:....................................................................................................................................... 10
Conclusión......................................................................................................................................... 12
Bibliografía ........................................................................................................................................ 13

4. Socket
Un socket es un punto de comunicación por el cual un proceso puede emitir o recibir
información. En el interior de un proceso, un socket se identifica por un descriptor
de la misma naturaleza que los que identifican los archivos, al igual que todos los
procesos del sistema UNIX de Berkeley.
La comunicación mediante sockets es una interfaz (o servicio) con la capa de
transporte (nivel 4) de la jerarquía OSI. La filosofía de la división por capas de un
sistema es encapsular, dentro de cada una de ellas, detalles que conciernen sólo a
cada capa, y presentársela al usuario de tal forma que este pueda trabajar con ella
sin necesidad de conocer sus detalles de implementación. La interfaz de acceso a
la capa de transporte del sistema UNIX de Berkeley no está totalmente aislada de
las capas inferiores, por lo que a la hora de trabajar con sockets, es necesario
conocer algunos detalles sobre esas capas. En concreto, a la hora de establecer
una conexión mediante sockets, es necesario conocer la familia o dominio de la
conexión, y el tipo de conexión.
La creación de un socket se realizará por la primitiva socket, la cual veremos con
más detenimiento más adelante, cuyo valor de vuelta es un descriptor sobre el cual
es posible realizar operaciones de escritura y lectura. Un socket permite la
comunicación en los dos sentidos (conexión full-dúplex).
En resumen los sockets:
 Son un mecanismo de comunicación entre procesos:
o Dentro de una misma máquina
o Distribuidos en diferentes máquinas
 Pueden ser identificados mediante un nombre
 Proporcionan un interfaz estándar para el acceso a diferentes protocolos de
comunicaciones

5.  Soportan, entre otros, la pila de protocolos TCP/IP
Dominios y tipos de sockets.
Una familia, o dominio de la conexión, agrupa todos aquellos sockets que comparten
características comunes. Especifica el formato de las direcciones que se podrán dar
al socket y los diferentes protocolos soportados por las comunicaciones vía los
sockets de este dominio.
Cada protocolo, a la hora de referirse a un nodo de la red, implementa un
mecanismo de direccionamiento. La dirección distingue de forma inequívoca a cada
nodo u ordenador, y es utilizada para encaminar los datos desde el nodo origen
hasta el nodo destino. Hay muchas llamadas al sistema que necesitan un puntero a
una estructura de dirección de socket para trabajar.
Cada tipo de socket va a definir una serie de propiedades en función de las
comunicaciones en las cuales está implicado:
1. La fiabilidad de la transmisión. Ningún dato transmitido se pierde.
2. La conservación del orden de los datos. Los datos llegan en el orden en el
que han sido emitidos.
3. La no duplicación de datos. Sólo llega a destino un ejemplar de cada dato
emitido.
4. La comunicación en modo conectado. Se establece una conexión entre dos
puntos antes del principio de la comunicación (es decir, se establece un
circuito virtual). A partir de entonces, una emisión desde un extremo está
implícitamente destinada al otro extremo conectado.
5. La conservación de los límites de los mensajes. Los límites de los mensajes
emitidos se pueden encontrar en el destino.

6. 6. El envío de mensajes (urgentes). Corresponde a la posibilidad de enviar
datos fuera del flujo normal, y por consecuencia accesibles inmediatamente
(datos fuera de flujo).
Cabe reseñar que un cauce de comunicación normal tiene las cuatro primeras
propiedades, pero no las dos últimas.
Existen tres dominios de comunicación para un socket
 El dominio de internet. (AF_INET). Se utiliza para la comunicación entre
procesos del sistema.
 El dominio NS. Se utilizaba sobre los procesos que se comunicaban sobre
el protocolo de comunicación de Xerox.
En cuanto a los tipos de sockets disponibles, se pueden considerar:
 SOCK_STREAM: Los sockets de este tipo permiten comunicaciones fiables
en modo conectado (propiedades a, b, c y d) y eventualmente autorizan,
según el protocolo aplicado los mensajes fuera de flujo (propiedad f). El
protocolo subyacente en el dominio Internet es TCP. Se establece un circuito
virtual realizando una búsqueda de enlaces libres que unan los dos
ordenadores a conectar (parecido a lo que hace la red telefónica conmutada
para establecer una conexión entre dos teléfonos). Una vez establecida la
conexión, se puede proceder al envío secuencial de los datos, ya que la
conexión es permanente. Son streams de bytes full-dúplex (similar a pipes).
Un socket stream debe estar en estado conectado antes de que se envíe o
reciba en él.
 SOCK_DGRAM: Corresponde a los sockets destinados a la comunicación
en modo no conectado para el envío de datagramas de tamaño limitado. Las

7. comunicaciones correspondientes tienen la propiedad e. En el dominio
Internet, el protocolo subyacente es el UDP. Los datagramas no trabajan con
conexiones permanentes. La transmisión por los datagramas es a nivel de
paquetes, donde cada paquete puede seguir una ruta distinta, no
garantizándose una recepción secuencial de la información.
 SOCK_RAW: Permite el acceso a los protocolos de más bajo nivel (por
ejemplo, el protocolo IP en el dominio Internet). Su uso está reservado al
supe usuario
 SOCK_SEQPACKET: Corresponde a las comunicaciones que poseen las
propiedades a, b, c, d y e. Estas comunicaciones se encuentran en el dominio
XNS.
Los dos tipos de sockets más utilizados son los dos primero.
Creación, implementación y supresión de sockets.
A la hora de la implementación de un servidor también necesitamos crear un objeto
socket desde el ServerSocket para que esté atento a las conexiones que le puedan
realizar clientes potenciales y poder aceptar esas conexiones.
Socket socketServicio = null;
try{
socketServicio = miServicio.accept ();
} catch (IOException e) {
System.out.println (e);
}

8. Supresión.
Siempre se debe de cerrar los canales de entrada y salida que se hayan abierto
durante la ejecución de la aplicación. Es importante destacar que el orden de cierre
es relevante, es decir se deben cerrar primero los streams relacionados con un
socket antes que el propio socket, ya que de esta forma evitamos posibles errores
de escrituras o lecturas sobre descriptores ya cerrados.
Cerrar sockets.
En la parte del cliente
try {
salida.close ();
miCliente.close ();
{ Catch (IOException e) {
System.out.println (e);
}
En la parte del servidor
try {
salida.close ();
entrada.close ();
socketServicio.close ();
miCliente.close ();
{Catch (IOException e) {
System.out.println (e);
}

9. Desarrollo del lado del servidor con socket.
En la parte del servidor:
public final class java.net.ServerSocket extends java.lang.Object
Constructores
public ServerSocket (int port) throws IOException
Se crea un socket local al que se enlaza el puerto especificado en el parámetro port,
si se especifica un 0 en dicho parámetro creará el socket en cualquier puerto
disponible. Puede aceptar hasta 50 peticiones en cola pendientes de conexión por
parte de los clientes.
public ServerSocket (int port , int count) throws IOException
Aquí, el parámetro count sirve para que puede especificarse, el número máximo de
peticiones de conexión que se pueden mantener en cola.
Hay que recordar, que es fundamental que el puerto escogido sea conocido por el
cliente, en caso contrario, no se podría establecer la conexión.
Métodos:
public Socket accept () throws IOException
Sobre un ServerSocket se puede realizar una espera de conexión por parte del
cliente mediante el método accept (). Hay que decir, que este método es de bloqueo,
el proceso espera a que se realice una conexión por parte del cliente para seguir su
ejecución. Una vez que se ha establecido una conexión por el cliente, este método
devolverá un objeto tipo Socket, a través del cual se establecerá la comunicación
con el cliente.

10. public void close () throws IOException
Se encarga de cerrar el socket.
public InetAddress getInetAddress ()
Retorna la dirección IP remota a la cual está conectado el socket. Si no lo está
retornará null.
public int getLocalPort ()
Retorna el puerto en el que está escuchando el socket.
public static void setSocketImplFactory (SocketImplFactory fac) throws
IOException
Este método establece la compañía de implementación del socket para la
aplicación. Debido a que cuando una aplicación crea un nuevo socket, se realiza
una llamada al método createSocketImpl () de la compañía que implementa al
socket. Es por tanto en el parámetro fac, donde se especificará la citada compañía.
public String toString( )
Retorna un string representando el socket.
En la parte del cliente:
public final class java.net.Socket extends java.lang.Object
Constructores:
public Socket (InetAddress address, int port) throws IOException
Crea un StreamSocket y lo conecta al puerto remoto y dirección IP remota
especificada.

11. public Socket (InetAddress address, int port , boolean stream) throws
IOException
Ídem a la anterior incluyendo el parámetro booleano stream que si es true creará un
StreamSocket y si es false un DatagramSocket (En desuso).
public Socket (String host, int port) throws UnKnownHostException,
IOException
Crea un StreamSocket y lo conecta al número de puerto y al nombre de host
especificados.
public Socket (String host , int port , boolean stream) throws IOException
Ídem al anterior incluyendo el parámetro booleano stream que si es true creará un
StreamSocket y si es false un DatagramSocket (En desuso).
Métodos:
public void close() throws IOException
Se encarga de cerrar el socket.
public InetAddress getInetAddress ()
Retorna la dirección IP remota a la que se conecta el socket.
public InputStream getInputStream () throws IOException
Retorna un input stream para la lectura de bytes desde el socket.
public int getLocalPort()
Retorna el puerto local al que está conectado el socket.
public OutputStream getOutputStream () throws IOException
Retorna un output stream para la escritura de bytes hacia el socket.

12. public int getPort ()
Retorna el puerto remoto al que está conectado el socket.
public static void setSocketImplFactory (SocketImplFactory fac) throws
IOException
Este método establece la compañía de implementación del socket para la
aplicación. Debido a que cuando una aplicación crea un nuevo socket, se realiza
una llamada al método createSocketImpl( ) de la compañía que implementa al
socket. Es por tanto en el parámetro fac , donde especificaremos la citada
compañía.

13. Conclusión.
Finalmente cuando se conoce el concepto adecuado de socket, se puede mencionar
la importancia en esta en el desarrollo de programas que hagan peticiones y reciban
las misma peticiones en el servidor, estén o no en la misma red, es decir que se
vuelven como un tipo de recursos compartidos, ya que cada nodo cliente haría una
petición especifica al servidor y este accedería a sus recursos y en caso de que no
lo tuviera al alcance mandaría una excepción.

14. Bibliografía
(s.f.). Obtenido de http://www.infor.uva.es/~fdiaz/sd/doc/java.net.pdf
Arquitectura cliente servidor. (s.f.). Obtenido de http://profesores.fi-
b.unam.mx/yasmine/expo/Sockets_Phyton.pdf
DOCPLAYER. (s.f.). Obtenido de Programación con sockets: http://docplayer.es/798743-
Programacion-con-sockets.html
ICC. (s.f.). Obtenido de http://www.lcc.uma.es/~eat/services/i_socket/i_socket.html
Sánchez, O. J. (s.f.). Obtenido de https://prezi.com/-7badyjcjunb/creacion-implementacion-y-
supresion-de-sockets/