"socket" --- interfaz de red de bajo nivel
******************************************

**Código fuente:** Lib/socket.py

======================================================================

Este módulo proporciona acceso a la interfaz BSD *socket*. Está
disponible en todos los sistemas Unix modernos, Windows, MacOS y
probablemente plataformas adicionales.

Nota:

  Algunos comportamientos pueden depender de la plataforma, ya que las
  llamadas se realizan a las API de socket del sistema operativo.

La interfaz de Python es una transcripción sencilla de la llamada al
sistema Unix y la interfaz de la biblioteca para sockets al estilo
orientado a objetos de Python: la función "socket()" devuelve a
*socket object* cuyos métodos implementan las diversas llamadas al
sistema de socket. Los tipos de parámetros tienen un nivel algo más
alto que en la interfaz C: como con "read()" y "write()" en las
operaciones en los archivos Python, la asignación del buffer en las
operaciones de recepción es automática y la longitud del buffer está
implícita en las operaciones de envío.

Ver también:

  Módulo "socketserver"
     Clases que simplifican la escritura de servidores de red.

  Módulo "ssl"
     Un contenedor TLS/SSL para objetos de socket.


Familias Socket
===============

Dependiendo del sistema y de las opciones de compilación, este módulo
admite varias familias de sockets.

El formato de dirección requerido por un objeto de socket determinado
se selecciona automáticamente en función de la familia de direcciones
especificada cuando se creó el objeto de socket.  Las direcciones de
socket se representan de la siguiente manera:

* La dirección de un socket "AF_UNIX" enlazado a un nodo del sistema
  de archivos es representado como una cadena de caracteres,
  utilizando la codificación del sistema de archivos y el controlador
  de errores "'surrogateescape'" (Observar **PEP 383**). Una dirección
  en el espacio de nombre abstracto de Linux es devuelvo como un
  *bytes-like object* con un byte inicial nulo; tenga en cuenta que
  los sockets en este nombre de espacio puede comunicarse con sockets
  normales del sistema de archivos, así que los programas destinados a
  correr en Linux podrían necesitar tratar con ambos tipos de
  direcciones. Se puede pasar un objeto similar a una cadena de
  caracteres o bytes para cualquier tipo de dirección al pasarlo como
  argumento.

  Distinto en la versión 3.3: Anteriormente, se suponía que las rutas
  de socket "AF_UNIX" utilizaban codificación UTF-8.

  Distinto en la versión 3.5: Ahora se acepta la grabación *bytes-like
  object*.

* Un par "(host, puerto)" se utiliza para la familia de direcciones
  "AF_INET", donde *host* es una cadena que representa un nombre de
  host en notación de dominio de Internet como "'daring.cwi.nl'" o una
  dirección IPv4 como "'100.50.200.5'" y *puerto* es un entero.

  * Para direcciones IPv4, se aceptan dos formas especiales en lugar
    de una dirección de host: "’’" representa "INADDR_ANY", que se
    utiliza para enlazar a todas las interfaces, y la cadena de
    caracteres "'<broadcast>'" representa "INADDR_BROADCAST". Este
    comportamiento no es compatible con IPv6, por lo tanto, es posible
    que desee evitarlos sí tiene la intención de admitir IPv6 con sus
    programas Python.

* Para la familia de direcciones "AF_INET6", se utiliza una "(host,
  port, flowinfo, scope_id)" de cuatro tuplas, donde *flowinfo* y
  *scope_id* representan los miembros "sin6_flowinfo" y
  "sin6_scope_id" en "struct sockaddr_in6" en C. Para los métodos de
  los módulos "socket", *flowinfo* y *scope_id* pueden ser omitidos
  solo por compatibilidad con versiones anteriores. Sin embargo la
  omisión de *scope_id* puede causar problemas en la manipulación de
  direcciones IPv6 con ámbito.

  Distinto en la versión 3.7: Para direcciones de multidifusión (con
  *scopeid* significativo) *address* puede no contener la parte
  "%scope" (o "zone id"). Esta información es superflua y puede
  omitirse de forma segura (recomendado).

* "AF_NETLINK" sockets se representan como pares "(pid, groups)".

* La compatibilidad con LINUX solo para TIPC está disponible mediante
  la familia de direcciones "AF_TIPC".  TIPC es un protocolo en red
  abierto y no basado en IP diseñado para su uso en entornos
  informáticos agrupados.  Las direcciones se representan mediante una
  tupla y los campos dependen del tipo de dirección. El formulario de
  tupla general es "(addr_type, v1, v2, v3 [, scope])", donde:

  * *addr_type* es uno de "TIPC_ADDR_NAMESEQ", "TIPC_ADDR_NAME", o
    "TIPC_ADDR_ID".

  * *scope* es una de "TIPC_ZONE_SCOPE", "TIPC_CLUSTER_SCOPE", y
    "TIPC_NODE_SCOPE".

  * Si *addr_type* es "TIPC_ADDR_NAME", entonces *v1* es el tipo de
    servidor, *v2* es el identificador de puerto, y *v3* debe ser 0.

    Si *addr_type* es "TIPC_ADDR_NAMESEQ", entonces  *v1* es el tipo
    de servidor, *v2* es el numero de puerto inferior, y *v3* es el
    numero de puerto superior.

    Si *addr_type* es "TIPC_ADDR_ID", *v1* es el nodo, *v2* es la
    referencia y *v3* debe establecerse en 0.

* Una tupla "(interface, )" es usada para la dirección de familia
  "AF_CAN", donde *interface* es una cadena de caracteres
  representando a un nombre de interfaz de red como "’can0’". La
  interfaz de red llamada "''" puede ser usada para recibir paquetes
  de todas las interfaces de red de esta familia.

  * Protocolo "CAN_ISOTP" requiere una tupla "(interface, rx_addr,
    tx_addr)" donde ambos tiene parámetros adicionales son enteres
    largos sin símbolos que representan una identificador CAN
    (estándar o extendido).

  * Protocolo "CAN_J1939" requiere una tupla "(interface, name, pgn,
    addr)" donde los parámetros adicionales son números enteros sin
    signo de 64 bits representando el nombre ECU, los enteros sin
    signo de 32-bits representan el numero de grupo de
    parámetros(PGN), y los enteros de 8-bit representan la dirección.

* Se utiliza una cadena o una tupla "(id, unit)" para el protocolo
  "SYSPROTO_CONTROL" de la familia "PF_SYSTEM". La cadena es el nombre
  de un control de kernel mediante un IDENTIFICADOR asignado
  dinámicamente. La tupla se puede utilizar si se conoce el ID y el
  número de unidad del control del kernel o si se utiliza un ID
  registrado.

  Nuevo en la versión 3.3.

* "AF_BLUETOOTH" admite los siguientes protocolos y formatos de
  dirección:

  * "BTPROTO_L2CAP" acepta "(bdaddr, psm)" donde "bdaddr" es la
    dirección Bluetooth como una cadena de caracteres y "psm" es un
    entero.

  * "BTPROTO_RFCOMM" acepta "(bdaddr, channel)" donde "bdaddr" es la
    dirección Bluetooth como una cadena de caracteres y "channel" es
    un entero.

  * "BTPROTO_HCI" acepta "(device_id,)" donde "device_id" es un numero
    entero o una cadena de caracteres con la dirección Bluetooth de la
    interfaz. (Esto depende de tu OS; NetBSD y DragonFlyBSD supone una
    dirección Bluetooth mientras todo lo demás espera un entero.)

    Distinto en la versión 3.2: Se ha añadido compatibilidad con
    NetBSD y DragonFlyBSD.

  * "BTPROTO_SCO" acepta "bdaddr" donde "bdaddr" es un objeto "bytes"
    que contiene la dirección Bluetooth en un formato cadena. (ex.
    "b’12:23:34:45:56:67’") este protocolo no es admitido bajo
    FreeBSD.

* "AF_ALG" es una interfaz basada en socket sólo Linux para la
  criptografía del núcleo. Un socket de algoritmo se configura con una
  tupla de dos a cuatro elementos "(type, name [, feat [, mask]])",
  donde:

  * *type* es el tipo de algoritmos como cadenas de caracteres, e.g.
    "aead", "hash", "skcipher" o "rng".

  * *name* es el nombre del algoritmo y el modo de operación como
    cadena de caracteres, e.g. "sha256", "hmac(sha256)", "cbc(aes)" o
    "drbg_nopr_ctr_aes256".

  * *feat* y *mask* son enteros de 32 bits sin signo.

  Availability: Linux 2.6.38, some algorithm types require more recent
  Kernels.

  Nuevo en la versión 3.6.

* "AF_VSOCK" permite comunicación entre maquinas virtuales y sus
  hosts. Los sockets están representando como una tupla "(CID, port)"
  donde el contexto del ID o CID y el puerto son enteros.

  Availability: Linux >= 4.8 QEMU >= 2.8 ESX >= 4.0 ESX Workstation >=
  6.5.

  Nuevo en la versión 3.7.

* "AF_PACKET" es una interfaz de bajo nivel directa con los
  dispositivos de red. Los paquetes están representados por la tupla
  "(ifname, proto[, pkttype[, hatype[, addr]]])" donde:

  * *ifname* - Cadena que especifica el nombre del dispositivo.

  * *proto* - Un entero en orden de byte de red que especifica el
    número de protocolo Ethernet.

  * *pkttype* - Entero opcional especificando el tipo de paquete:

    * "PACKET_HOST" (por defecto) - Paquetes diseccionado al local
      host.

    * "PACKET_BROADCAST" - Paquete de transmisión de la capa física.

    * "PACKET_MULTIHOST" - Paquete enviado a una dirección de
      multidifusión de capa física.

    * "PACKET_OTHERHOST" - Paquete a otro host que haya sido capturado
      por un controlador de dispositivo en modo promiscuo.

    * "PACKET_OUTGOING" - Paquete originalmente desde el local host
      que se enlaza de nuevo a un conector de paquetes.

  * *hatype* - Entero opcional que especifica el tipo de dirección de
    hardware ARP.

  * *addr* - Objeto opcional en forma de bytes que especifica la
    dirección física del hardware, cuya interpretación depende del
    dispositivo.

     Availability: Linux >= 2.2.

* "AF_QIPCRTR" es una interfaz basada en sockets solo para Linux para
  comunicarse con servicios que se ejecutan en co-procesadores en
  plataformas Qualcomm. La familia de direcciones se representa como
  una tupla "(node, port)" donde el *node* y *port* son enteros no
  negativos.

     Availability: Linux >= 4.7.

  Nuevo en la versión 3.8.

* "IPPROTO_UDPLITE" es una variante de UDO que te permite especificar
  que porción del paquete es cubierta con la suma de comprobación.
  Esto agrega dos opciones al socket que pueden cambiar.
  "self.setsockopt(IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV, length)"
  cambiara que parte de los paquetes salientes están cubierta por la
  suma de comprobación y "self.setsockopt(IPPROTO_UDPLITE,
  UDPLITE_RECV_CSCOV, length)" filtrara los paquetes que permitirá
  cubrir una pequeña parte de tu datos. En ambos casos "length" deben
  estar en "range(8, 2**16, 8)".

  Tal socket debe construirse como "socket(AF_INET, SOCK_DGRAM,
  IPPROTO_UDPLITE)" para IPV4 o *socket(AF_INET6, SOCK_DGRAM,
  IPPROTO_UDPLITE)`* para IPV6.

  Availability: Linux >= 2.6.20, FreeBSD >= 10.1-RELEASE

  Nuevo en la versión 3.9.

Si utiliza un nombre de host en la parte *host* de la dirección de
socket IPv4/v6, el programa puede mostrar un comportamiento no
determinista, ya que Python utiliza la primera dirección devuelta por
la resolución DNS.  La dirección del socket se resolverá de manera
diferente en una dirección IPv4/v6 real, dependiendo de los resultados
de la resolución DNS y/o la configuración del host.  Para un
comportamiento determinista, utilice una dirección numérica en la
parte *host*.

Todos los errores generan excepciones.  Se pueden generar las
excepciones normales para los tipos de argumento no válidos y las
condiciones de memoria insuficiente; a partir de Python 3.3, los
errores relacionados con la semántica de socket o direcciones generan
"OSError" o una de sus subclases (solían generar "socket.error").

El modo de no bloqueo es compatible a través de "setblocking()".  Se
admite una generalización de esto basada en los tiempos de espera a
través de "settimeout()".


Contenido del módulo
====================

El módulo "socket" exporta los siguientes elementos.


Excepciones
-----------

exception socket.error

   Un alias en desuso de "OSError".

   Distinto en la versión 3.3: Siguiendo **PEP 3151**, es clase fue
   creada como un alias de "OSError".

exception socket.herror

   Una subclase de "OSError", esta excepción se produce para los
   errores relacionados con la dirección, es decir, para las funciones
   que utilizan *h_errno* en la API de POSIX C, incluidas
   "gethostbyname_ex()" y "gethostbyaddr()". El valor adjunto es un
   par "(h_errno, string)" que representa un error devuelto por una
   llamada a la biblioteca.  *h_errno* es un valor numérico, mientras
   que *string* representa la descripción de *h_errno*, devuelta por
   la función "hstrerror()" C.

   Distinto en la versión 3.3: Esta clase fue creada como una subclase
   de "OSError".

exception socket.gaierror

   Una subclase de "OSError", esta excepción se genera por errores
   relacionados a la dirección por "getaddrinfo()" y "getnameinfo()".
   El valor de acompañamiento es un par "(error, string)" representado
   un error retornado por una llamada de librería. *string* representa
   la descripción del *error*, tal como es retornado por la función C
   "gai_strerror()". El valor numérico *error* coincide con una de las
   constantes "EAI_*" definidas en este modulo.

   Distinto en la versión 3.3: Esta clase fue creada como una subclase
   de "OSError".

exception socket.timeout

   Una subclase de "OSError", esta excepción se genera cuando ocurre
   un *timeout* en un socket que ha tenido tiempos de espera
   habilitados a través de una llamada previa a "settimeout()" ( o
   implícitamente mediante "setdefaulttimeout()"). El valor del
   acompañamiento es una cadena de caracteres cuyo valor es
   actualmente siempre “tiempo de espera”.

   Distinto en la versión 3.3: Esta clase fue creada como una subclase
   de "OSError".


Constantes
----------

   Las constantes AF_* y SOCK_* ahora son colecciones: "AddressFamily"
   y "SocketKind" "IntEnum".

   Nuevo en la versión 3.4.

socket.AF_UNIX
socket.AF_INET
socket.AF_INET6

   Estas constantes representan la familias de direcciones (y
   protocolos), usados para el primer argumento para "socket()". Si la
   constante "AF_UNIX" no esta definida entonces este protocolo no es
   compatible. Mas constantes podrían estar disponibles dependiendo
   del sistema.

socket.SOCK_STREAM
socket.SOCK_DGRAM
socket.SOCK_RAW
socket.SOCK_RDM
socket.SOCK_SEQPACKET

   Estas constantes representan los tipos de socket, usadas por el
   segundo argumento para "socket()". Mas constante podrían estar
   disponibles dependiendo del sistema. ( Solamente "SOCK_STREAM" y
   "SOCK_DGRAM" parecen ser útiles en general.)

socket.SOCK_CLOEXEC
socket.SOCK_NONBLOCK

   Estas dos constantes, si se definen, se pueden combinar con los
   tipos de socket y le permiten establecer algunas banderas
   atómicamente (evitando así posibles condiciones de carrera y la
   necesidad de llamadas separadas).

   Ver también:

     Secure File Descriptor Handling para una explicación más
     completa.

   Availability: Linux >= 2.6.27.

   Nuevo en la versión 3.2.

SO_*
socket.SOMAXCONN
MSG_*
SOL_*
SCM_*
IPPROTO_*
IPPORT_*
INADDR_*
IP_*
IPV6_*
EAI_*
AI_*
NI_*
TCP_*

   Muchas constantes de estos formularios, documentadas en la
   documentación de Unix en sockets y/o el protocolo IP, también se
   definen en el módulo de socket. Generalmente se utilizan en
   argumentos de los métodos "setsockopt()" y "getsockopt()" de
   objetos socket.  En la mayoría de los casos, solo se definen los
   símbolos definidos en los archivos de encabezado Unix; para algunos
   símbolos, se proporcionan valores predeterminados.

   Distinto en la versión 3.6: "SO_DOMAIN", "SO_PROTOCOL",
   "SO_PEERSEC", "SO_PASSSEC", "TCP_USER_TIMEOUT", "TCP_CONGESTION"
   han sido agregados.

   Distinto en la versión 3.6.5: En Windows, "TCP_FASTOPEN",
   "TCP_KEEPCNT" aparecen si el tiempo de ejecución de Windows lo
   admite.

   Distinto en la versión 3.7: "TCP_NOTSENT_LOWAT" ha sido agregada.En
   Windows, "TCP_KEEPIDLE", "TCP_KEEPINTVL" aparecen si el tiempo de
   ejecución de Windows lo admite.

socket.AF_CAN
socket.PF_CAN
SOL_CAN_*
CAN_*

   Muchas constantes de estos formularios, documentadas en la
   documentación de Linux, también se definen en el módulo de socket.

   Availability: Linux >= 2.6.25.

   Nuevo en la versión 3.3.

socket.CAN_BCM
CAN_BCM_*

   CAN_BCM, en la familia de protocolo CAN, es el protocolo del
   administrador de difusión (BCM. Las constantes del administrador de
   difusión, documentada en la documentación de Linux, también esta
   definidos en el modulo socket.

   Availability: Linux >= 2.6.25.

   Nota:

     El indicador "CAN_BCM_CAN_FD_FRAME" esta solamente disponible en
     Linux >= 4.8.

   Nuevo en la versión 3.4.

socket.CAN_RAW_FD_FRAMES

   Habilita la compatibilidad con CAN FD en un socket CAN_RAW. Esta
   opción está deshabilitada de forma predeterminada. Esto permite que
   la aplicación envíe tramas CAN y CAN FD; sin embargo, debe aceptar
   las tramas CAN y CAN FD al leer desde el socket.

   Esta constante se documenta en la documentación de Linux.

   Availability: Linux >= 3.6.

   Nuevo en la versión 3.5.

socket.CAN_RAW_JOIN_FILTERS

   Se une a los filtros CAN aplicados de modo que solo las tramas CAN
   que coinciden con todos los filtros CAN dados se pasan al espacio
   del usuario.

   Esta constante se documenta en la documentación de Linux.

   Availability: Linux >= 4.1.

   Nuevo en la versión 3.9.

socket.CAN_ISOTP

   CAN_ISOTP, en el protocolo de familia CAN, es el protocolo  ISO-TP
   (ISO 15765-2). Constantes ISO-TP, documentadas en la documentación
   Linux.

   Availability: Linux >= 2.6.25.

   Nuevo en la versión 3.7.

socket.CAN_J1939

   CAN_J1939, en el protocolo de familias CAN, es el protocolo SAE
   J1939. Constantes J1939, documentadas en el documentación Linux.

   Availability: Linux >= 5.4.

   Nuevo en la versión 3.9.

socket.AF_PACKET
socket.PF_PACKET
PACKET_*

   Muchas constantes de estos formularios, documentadas en la
   documentación de Linux, también se definen en el módulo de socket.

   Availability: Linux >= 2.2.

socket.AF_RDS
socket.PF_RDS
socket.SOL_RDS
RDS_*

   Muchas constantes de estos formularios, documentadas en la
   documentación de Linux, también se definen en el módulo de socket.

   Availability: Linux >= 2.6.30.

   Nuevo en la versión 3.3.

socket.SIO_RCVALL
socket.SIO_KEEPALIVE_VALS
socket.SIO_LOOPBACK_FAST_PATH
RCVALL_*

   Constantes para Windows’ WSAIoctl(). Las constantes se utiliza como
   argumentos al método "ioctl()" de objetos de sockets.

   Distinto en la versión 3.6: "SIO_LOOPBACK_FAST_PATH" ha sido
   agregado.

TIPC_*

   LAS constantes relacionadas con TIPC, que coinciden con las
   exportadas por la API de socket de C. Consulte la documentación de
   TIPC para obtener más información.

socket.AF_ALG
socket.SOL_ALG
ALG_*

   Constantes para la criptográfica del Kernel de Linux.

   Availability: Linux >= 2.6.38.

   Nuevo en la versión 3.6.

socket.AF_VSOCK
socket.IOCTL_VM_SOCKETS_GET_LOCAL_CID
VMADDR*
SO_VM*

   Constantes para la comunicación host/invitado de Linux.

   Availability: Linux >= 4.8.

   Nuevo en la versión 3.7.

socket.AF_LINK

   Availability: BSD, macOS.

   Nuevo en la versión 3.4.

socket.has_ipv6

   Esta constante contiene un valor booleano que indica si IPv6 se
   admite en esta plataforma.

socket.BDADDR_ANY
socket.BDADDR_LOCAL

   Estas son constantes de cadenas que contienen direcciones Bluetooth
   con significados especiales. Por ejemplo "BDADDR_ANY" son usados
   para indicar cualquier dirección al especificar el socket
   vinculante con "BTPROTO_RFCOMM".

socket.HCI_FILTER
socket.HCI_TIME_STAMP
socket.HCI_DATA_DIR

   Para usar con "BTPROTO_HCI". "HCI_FILTER" no esta disponible para
   NetBSD o DragonFlyBSD. "HCI_TIME_STAMP" y "HCI_DATA_DIR" no esta
   disponible para FreeBSD, NetBSD, o DragonFlyBSD.

socket.AF_QIPCRTR

   Constante para el protocolo de router IPC de Qualcomm, que se
   utiliza para comunicarse con procesadores remotos que brindan
   servicios.

   Availability: Linux >= 4.7.


Funciones
---------


Creación de sockets
~~~~~~~~~~~~~~~~~~~

Todas las siguientes funciones crean socket objects.

class socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)

   Crear un nuevo socket usando la dirección de familia dada, tipo de
   socket y el numero de protocolo. La dirección de familia debería
   ser "AF_INET" (por defecto), "AF_INET6", "AF_UNIX", "AF_CAN",
   "AF_PACKET", o "AF_RDS". El tipo de socket debería ser
   "SOCK_STREAM" (por defecto), "SOCK_DGRAM", "SOCK_RAW" o quizás una
   de las otras constantes "SOCK_". El numero de protocolo es
   usualmente cero u omitirse o en el caso donde la familia de
   dirección es "AF_CAN" el protocolo debería ser uno de "CAN_RAW",
   "CAN_BCM", "CAN_ISOTP" o "CAN_J1939".

   Si *fileno* esta especificado, el valor de *family*, *type*, y
   *proto* son detectados automáticamente por el descriptor
   especificado de archivo. La detección automática se puede anular
   llamado la función con los argumentos explícitos *family*, *type*,
   o *proto*. Esto solamente afecta como Python representa e.g. el
   valor de retorno de  "socket.getpeername()" pero no del recurso
   actual del OS. Diferente a  "socket.fromfd()", *fileno* retornara
   el mismo socket y no un duplicado. Esto puede ayudar a cerrar un
   socket desconectado usando "socket.close()".

   El socket recién creado es non-inheritable.

   Genera un auditing event "socket.__new__" con los argumentos
   "self", "family", "type", "protocol".

   Distinto en la versión 3.3: Se añadió la familia AF_CAN. Se añadió
   la familia AF_RDS.

   Distinto en la versión 3.4: El protocolo CAN_BCM ha sido agregado.

   Distinto en la versión 3.4: Los sockets devueltos ahora no son
   heredables.

   Distinto en la versión 3.7: El protocolo CAN_ISOTP ha sido
   agregado.

   Distinto en la versión 3.7: Cuando las banderas bit "SOCK_NONBLOCK"
   or "SOCK_CLOEXEC" esta aplicados a *type* se borran, y
   "socket.type" no reflejan eso. Todavía se pasan a la llamada
   *socket ()* del sistema subyacente. Por lo tanto,

      sock = socket.socket(
          socket.AF_INET,
          socket.SOCK_STREAM | socket.SOCK_NONBLOCK)

   seguirá creando un socket sin bloqueo en los sistemas operativos
   que admiten "SOCK_NONBLOCK", pero "sock.type" se establecerá en
   "socket.SOCK_STREAM".

   Distinto en la versión 3.9: El protocolo CAN_J1939 ha sido
   agregado.

socket.socketpair([family[, type[, proto]]])

   Cree un par de objetos de socket conectados utilizando la familia
   de direcciones, el tipo de socket y el número de protocolo
   especificados.  La familia de direcciones, el tipo de socket y el
   número de protocolo son los siguientes para la función "socket()"
   anterior. La familia predeterminada es "AF_UNIX" si se define en la
   plataforma; de lo contrario, el valor predeterminado es "AF_INET".

   Los sockets creados recientemente son non-inheritable.

   Distinto en la versión 3.2: Los objetos de socket devueltos ahora
   admiten toda la API de socket, en lugar de un subconjunto.

   Distinto en la versión 3.4: Los sockets devueltos ahora no son
   heredables.

   Distinto en la versión 3.5: Se ha agregado compatibilidad con
   Windows.

socket.create_connection(address[, timeout[, source_address]])

   Conecta con un servicio TCP escuchando una *address* Internet (una
   tupla de 2 "(host, port)"), y retorna el objeto socket. Este es una
   función de nivel superior que "socket.connect()": si *host* es un
   nombre de host no numérico, intentara resolverlo para ambos
   "AF_INET" y "AF_INET6", y luego intenta conectarte a todas las
   direcciones posibles a la vez para lograr una conexión exitosa.
   Esto facilita la escritura de clientes que sean compatibles con
   IPv4 e IPv6.

   Pasando el parámetro opcional *timeout* establece el tiempo de
   espera dentro de la instancia del socket. Si no es proporcionado
   *timeout*, la configuración global de tiempo de espera
   predeterminada retornada por "getdefaulttimeout()" es usada.

   Si se suministra, *source_address* debe ser una ''(host, puerto)''
   de 2 tuplas para que el socket se enlace como su dirección de
   origen antes de conectarse.  Si el host o el puerto son '' o 0
   respectivamente, se utilizará el comportamiento predeterminado del
   sistema operativo.

   Distinto en la versión 3.2: *source_address* ha sido agregado.

socket.create_server(address, *, family=AF_INET, backlog=None, reuse_port=False, dualstack_ipv6=False)

   Función de conveniencia que crea un socket TCP enlazado a *address*
   (una tupla de 2 "(host, puerto)") y devuelve el objeto de socket.

   *family* debe ser "AF_INET" o "AF_INET6". *backlog* es el tamaño de
   la cola pasado a "socket.listen()"; cuando "0" se elige un valor
   predeterminado razonable. *reuse_port* dicta si se debe establecer
   la opción de socket "SO_REUSEPORT".

   Si *dualstack_ipv6* es true y la plataforma lo admite el socket
   podrá aceptar conexiones IPv4 e IPv6, de lo contrario generará
   "ValueError". Se supone que la mayoría de las plataformas POSIX y
   Windows admiten esta funcionalidad. Cuando esta funcionalidad está
   habilitada, la dirección devuelta por "socket.getpeername()" cuando
   se produce una conexión IPv4 será una dirección IPv6 representada
   como una dirección IPv4 asignada6. Si *dualstack_ipv6* es false,
   deshabilitará explícitamente esta funcionalidad en las plataformas
   que la habilitan de forma predeterminada (por ejemplo, Linux). Este
   parámetro se puede utilizar junto con "has_dualstack_ipv6()":

      import socket

      addr = ("", 8080)  # all interfaces, port 8080
      if socket.has_dualstack_ipv6():
          s = socket.create_server(addr, family=socket.AF_INET6, dualstack_ipv6=True)
      else:
          s = socket.create_server(addr)

   Nota:

     En plataformas POSIX la opción del socket "SO_REUSEADDR" está
     configurado para inmediatamente rehusar los sockets previos que
     estaban vinculados la misma *address* y permanecer en estado
     TIME_WAIT.

   Nuevo en la versión 3.8.

socket.has_dualstack_ipv6()

   Devuelve "True" si la plataforma admite la creación de un socket
   TCP que pueda manejar conexiones IPv4 e IPv6.

   Nuevo en la versión 3.8.

socket.fromfd(fd, family, type, proto=0)

   Duplica el descriptor de archivo *fd* (un entero retornado por el
   método "fileno()" de un objeto archivo) y crea un objeto socket a
   partir del resultado.  La familia de direcciones, el tipo de socket
   y el número de protocolo son como para la función "socket()"
   anterior. El descriptor de archivo debe hacer referencia a un
   socket, pero esto no se comprueba --- las operaciones posteriores
   en el objeto pueden fallar si el descriptor de archivo no es
   válido. Esta función rara vez se necesita, pero se puede usar para
   obtener o establecer opciones de socket en un socket pasado a un
   programa como entrada o salida estándar (como un servidor iniciado
   por el demonio inet de Unix).  Se supone que el socket está en modo
   de bloqueo.

   El socket recién creado es non-inheritable.

   Distinto en la versión 3.4: Los sockets devueltos ahora no son
   heredables.

socket.fromshare(data)

   Cree una instancia de un socket a partir de los datos obtenidos del
   método "socket.share()".  Se supone que el socket está en modo de
   bloqueo.

   Availability: Windows.

   Nuevo en la versión 3.3.

socket.SocketType

   Este es un tipo de objeto Python que representa el tipo de objeto
   del socket. Es lo mismo que decir "type(socket(…))".


Otras funciones
~~~~~~~~~~~~~~~

El modulo "socket" también ofrece varios servicios de red
relacionados:

socket.close(fd)

   Cierre un descriptor de archivo de socket. Esto es como
   "os.close()", pero para sockets. En algunas plataformas (la mayoría
   notable de Windows) "os.close()" no funciona para descriptores de
   archivos de socket.

   Nuevo en la versión 3.7.

socket.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0)

   Traduce el argumento *host*/*port* dentro de una secuencia de 5
   tuplas que contiene todo los argumentos necesarios para crear un
   socket conectado a ese servicio. *host* es un nombre de dominio,
   una cadena en representación de una dirección IPV4/IPV6 o "None".
   *port* es una nombre de una cadena de servicio como "'http'", un
   numero de puerto numérico o "None". Pasando "None" como el valor
   del  *host* y *port*, pasando "NULL" a la API C subyacente.

   Los argumentos *family*, *type* y *proto* se puede especificar
   opcionalmente para reducir la lista de direcciones retornadas.
   Pasando cero como un valor para cada uno de estos argumentos se
   selecciona la gama completa de resultados. El argumento *flags*
   puede ser uno o varios de los argumentos "AI_*", y pueden
   influenciar como los resultados son computados y devueltos. Por
   ejemplo, "AI_NUMERICHOST" desactivará la resolución de nombres de
   dominio y generará un error sí * host * es un nombre de dominio.

   La función devuelve una lista de 5 tuplas con la siguiente
   estructura:

   "(family, type, proto, canonname, sockaddr)"

   En estas tuplas, *family*, *type*, *proto* son todos enteros y
   están destinados a ser pasados por la función "socket()".
   *canonname* debe ser una cadena que representa el nombre canónico
   del *host* si "AI_CANONNAME" es parte de el argumento *flags*; de
   lo contrario *canonname* estará vacía.  *sockaddr* es un tupla
   describiendo una dirección de socket, cuyo formato depende del
   devuelto *family* (una "(address, port)" tupla de 2 para "AF_INET",
   una "(address, port, flowinfo, scope_id)" una tupla de 4 para una
   "AF_INET6"), y está destinado a ser pasado a el método
   "socket.connect()".

   Genera un auditing event "socket.getaddrinfo" con los argumentos
   "host", "port", "family", "type", "protocol".

   En el ejemplo siguiente se obtiene información de dirección para
   una conexión TCP hipotética a "example.org" en el puerto 80 (los
   resultados pueden diferir en el sistema si IPv6 no está
   habilitado):

      >>> socket.getaddrinfo("example.org", 80, proto=socket.IPPROTO_TCP)
      [(<AddressFamily.AF_INET6: 10>, <SocketType.SOCK_STREAM: 1>,
       6, '', ('2606:2800:220:1:248:1893:25c8:1946', 80, 0, 0)),
       (<AddressFamily.AF_INET: 2>, <SocketType.SOCK_STREAM: 1>,
       6, '', ('93.184.216.34', 80))]

   Distinto en la versión 3.2: los parámetros ahora se pueden pasar
   mediante argumentos de palabra clave.

   Distinto en la versión 3.7: para direcciones de multidifusión IPv6,
   la cadena que representa una dirección no contendrá partes
   "%scope_id".

socket.getfqdn([name])

   Return a fully qualified domain name for *name*. If *name* is
   omitted or empty, it is interpreted as the local host.  To find the
   fully qualified name, the hostname returned by "gethostbyaddr()" is
   checked, followed by aliases for the host, if available.  The first
   name which includes a period is selected.  In case no fully
   qualified domain name is available and *name* was provided, it is
   returned unchanged.  If *name* was empty or equal to "'0.0.0.0'",
   the hostname from "gethostname()" is returned.

socket.gethostbyname(hostname)

   Traduce un nombre de host a un formato de dirección IPV4. La
   dirección IPV4 es retornada como una cadena, como "’100.50.200.5’".
   Si el nombre de host es una dirección IPV4 en sí, se devuelve sin
   cambios. Observa "gethostbyname_ex()" para una interfaz mas
   completa. "gethostbyname()" no soporta la resolución de nombres
   IPV6, y "getaddrinfo()" debe utilizarse en su lugar para
   compatibilidad con doble pila IPv4/v6.

   Genera un evento auditing "socket.gethostbyname" con el argumento
   "hostname".

socket.gethostbyname_ex(hostname)

   Translate a host name to IPv4 address format, extended interface.
   Return a triple "(hostname, aliaslist, ipaddrlist)" where
   *hostname* is the host's primary host name, *aliaslist* is a
   (possibly empty) list of alternative host names for the same
   address, and *ipaddrlist* is a list of IPv4 addresses for the same
   interface on the same host (often but not always a single address).
   "gethostbyname_ex()" does not support IPv6 name resolution, and
   "getaddrinfo()" should be used instead for IPv4/v6 dual stack
   support.

   Genera un evento auditing "socket.gethostbyname" con el argumento
   "hostname".

socket.gethostname()

   Devuelve una cadena que contenga el nombre de host de la máquina
   donde se está ejecutando actualmente el intérprete de Python.

   Genera un auditing event "socket.gethostname" sin argumentos.

   Nota: "gethostname()" no siempre retorna el nombre de dominio
   completo, usa "getfqdn()" para eso.

socket.gethostbyaddr(ip_address)

   Retorna un triple "(hostname, aliaslist, ipaddrlist)" donde
   *hostname* es el nombre del host primario respondiendo de la misma
   *ip_address*, *aliaslist* es una (posiblemente vacía) lista de
   nombres de hosts alternativa, y *ipaddrlist* es una lista de
   direcciones IPV4/IPV6 para la misma interfaz y en el mismo host (
   lo más probable es que contenga solo una dirección ). Para
   encontrar el nombre de dominio completo, use la función
   "getfqdn()". "gethostbyaddr()" admite tanto IPv4 como IPv6.

   Generar un auditing event "socket.gethostbyaddr" con los argumentos
   "ip_address".

socket.getnameinfo(sockaddr, flags)

   Traduce una dirección de socket  *sockaddr* dentro de una tupla de
   2  "(host, port)". Dependiendo de la configuraciones de *flags*, el
   resultado puede contener un nombre de dominio completo o una
   representación numérica de la dirección en *host*. Similar, *port*
   puede contener un nombre de puerto de cadena o un numero de puerto
   numérico.

   Para las direcciones IPv6, "%scope" se anexa a la parte del host si
   *sockaddr* contiene *scopeid* significativo. Generalmente esto
   sucede para las direcciones de multidifusión.

   Para mas información sobre *flags* pueden consultar
   *getnameinfo(3)*.

   Plantea un auditing event "socket.getnameinfo" con el argumento
   "sockaddr".

socket.getprotobyname(protocolname)

   Traduzca un nombre de protocolo de Internet (por ejemplo, "'icmp'")
   a una constante adecuada para pasar como el tercer argumento
   (opcional) a la función "socket()".  Por lo general, esto sólo es
   necesario para los sockets abiertos en modo "crudo" ("SOCK_RAW");
   para los modos de socket normales, el protocolo correcto se elige
   automáticamente si se omite el protocolo o cero.

socket.getservbyname(servicename[, protocolname])

   Traduce un nombre de servicio de Internet y el nombre del protocolo
   para un numero de puerto para ese servicio. El nombre del protocolo
   opcional, si se da, podría ser *’tcp’`* o "’udp’", de lo contrario,
   cualquier protocolo coincidirá.

   Genera un auditing event "socket.getservbyname" con los argumentos
   "servicename", "protocolname".

socket.getservbyport(port[, protocolname])

   Traduzca un número de puerto de Internet y un nombre de protocolo a
   un nombre de servicio para ese servicio.  El nombre del protocolo
   opcional, si se da, debe ser "'tcp'" o "'udp'", de lo contrario
   cualquier protocolo coincidirá.

   Genera un auditing event "socket.getservbyport" con los argumentos
   "port", "protocolname".

socket.ntohl(x)

   Convierta enteros positivos de 32 bits de red a orden de bytes de
   host.  En equipos donde el orden de bytes de host es el mismo que
   el orden de bytes de red, se trata de un no-op; de lo contrario,
   realiza una operación de intercambio de 4 bytes.

socket.ntohs(x)

   Convierta enteros positivos de 16 bits de red a orden de bytes de
   host.  En equipos donde el orden de bytes de host es el mismo que
   el orden de bytes de red, se trata de un no-op; de lo contrario,
   realiza una operación de intercambio de 2 bytes.

   Obsoleto desde la versión 3.7: En el caso que *x* no encaje en un
   entero sin signo de 16 bits, pero encaja en un entero positivo C,
   esto es silenciosamente truncado en un entero sin signo de 16 bits.
   Esta característica de truncamiento silenciosa esta obsoleta, y
   generará una excepción en versiones futuras de Python.

socket.htonl(x)

   Convierta enteros positivos de 32 bits del host al orden de bytes
   de red.  En equipos donde el orden de bytes de host es el mismo que
   el orden de bytes de red, se trata de un no-op; de lo contrario,
   realiza una operación de intercambio de 4 bytes.

socket.htons(x)

   Convierta enteros positivos de 16 bits del host al orden de bytes
   de red.  En equipos donde el orden de bytes de host es el mismo que
   el orden de bytes de red, se trata de un no-op; de lo contrario,
   realiza una operación de intercambio de 2 bytes.

   Obsoleto desde la versión 3.7: En el caso que *x* no encaje en un
   entero sin signo de 16 bits, pero encaja en un entero positivo C,
   esto es silenciosamente truncado en un entero sin signo de 16 bits.
   Esta característica de truncamiento silenciosa esta obsoleta, y
   generará una excepción en versiones futuras de Python.

socket.inet_aton(ip_string)

   Convierte una dirección IPV4 desde el formato de cadena de cuatro
   puntos (por ejemplo, ‘123.45.67.89’) a formato binario empaquetado
   de 32 bits, como un objeto de bytes de cuatro caracteres de
   longitud. Esto es usado cuando al convertir un programa que usa la
   librería estándar C y necesita objetos de tipo  "struct in_addr",
   que es el tipo C para el binario empaquetado de 32 bits que
   devuelve esta función.

   Ademas "inet_aton`acepta cadena de caracteres con menos de tres
   puntos, observar la pagina del manual Unix :manpage:`inet(3)()"
   para mas detalles.

   Si la cadena de dirección IPv4 es pasada a esta función es
   invalido, "OSError" se generará. Tenga en cuenta que exactamente lo
   que es valido depende de la implementación C de "inet_aton()".

   "inet_aton()" no admite IPV6, y "inet_pton()" deberían utilizarse
   en su lugar para compatibilidad con doble pilas IPV4/v6.

socket.inet_ntoa(packed_ip)

   Convierte una dirección IPV4 empaquetada de 32 bits (un *bytes-like
   object* cuatro bytes de longitud) a su representación estándar de
   cadena de cuatro puntos ( por ejemplo ‘123.45.67.89’). Esto es útil
   cuando convertimos con un programa que usa la librería estándar C y
   necesita objetos de tipo "struct in_addr", que es el tipo C para
   los datos binarios empaquetados de 32 bits que esta función toma
   como argumento.

   Si la secuencia de byte pasada a esta función no es exactamente 4
   bytes de longitud  "OSError" podría generarse "inet_ntoa()" no
   soporta IPV6, y "inet_ntop()" debe utilizarse en su lugar para
   compatibilidad con doble pila IPv4 / v6.

   Distinto en la versión 3.5: Ahora se acepta la grabación *bytes-
   like object*.

socket.inet_pton(address_family, ip_string)

   Convierte una dirección IP desde su formato de cadena especifico de
   la familia a un empaquetado, formato binario "inet_pton()" es útil
   cuando una librería o protocolo de red llama desde un objeto de
   tipo "struct in_addr" (similar a "inet_aton()") o "struct
   in6_addr".

   Los Valores soportados para *address_family* son actualmente
   "AF_INET" y "AF_INET6". Si la cadena de dirección IP *ip_string* no
   es válida, "OSError" se genera. Tenga en cuenta que exactamente lo
   que es válido depende tanto del valor de *address_family* como de
   la implementación subyacente de "inet_pton()".

   Disponibilidad: Unix(Tal vez no todas las plataformas), Windows.

   Distinto en la versión 3.4: Se ha añadido compatibilidad con
   Windows

socket.inet_ntop(address_family, packed_ip)

   Convierte una dirección IP empaquetada ( un *bytes-like object* de
   algún numero de bytes) a su representación de cadena estándar,
   específica de la familia (por ejemplo "’7.10.0.5’" o
   "’5aef:2b::8’"). "inet_ntop()" es usado cuando una librería o
   protocolo de red retorna un objeto de tipo "struct in_addr"
   (similar para "inet_ntoa()") o "struct in6_addr".

   Los valores soportados para *address_family* actualmente son
   "AF_INET" y "AF_INET6". Si los objetos de bytes *packed_ip* no
   tienen la longitud correcta para la familia de direcciones
   especificas, "ValueError" podría generarse. "OSError" se genera
   para errores desde la llamada a "inet_ntop()".

   Disponibilidad: Unix(Tal vez no todas las plataformas), Windows.

   Distinto en la versión 3.4: Se ha añadido compatibilidad con
   Windows

   Distinto en la versión 3.5: Ahora se acepta la grabación *bytes-
   like object*.

socket.CMSG_LEN(length)

   Retorna la longitud total, sin relleno de arrastre, de un elemento
   de datos auxiliares con datos asociados del *length*. Este valor se
   puede utilizar a menudo como tamaño de búfer para "recvmsg()" para
   recibir un solo valor de datos auxiliares, pero **RFC 3542**
   requiere aplicaciones portables para usar "CMSG_SPACE()" y así
   incluir espacio para el relleno, incluso cuando el elemento será el
   último en el búfer. Genera  "OverflowError" si *length* está fuera
   del rango de valores permitido.

   Availability: la mayoría de plataformas Unix, posiblemente otras.

   Nuevo en la versión 3.3.

socket.CMSG_SPACE(length)

   Retorna el tamaño del buffer necesario por "recvmsg()" para recibir
   un elemento de datos auxiliares con datos asociados del *length*
   dado, junto con cualquier relleno final. El espacio de buffer
   necesario para recibir múltiples elementos es la suma de los
   valores de "CMSG_SPACE()" para los datos asociados con la
   longitudes. Genera "OverflowError" si *length* está fuera del rango
   de valores permitido.

   Tenga en cuenta que algunos sistemas pueden admitir datos
   auxiliares sin proporcionar esta función.  Tenga en cuenta también
   que establecer el tamaño del búfer utilizando los resultados de
   esta función puede no limitar con precisión la cantidad de datos
   auxiliares que se pueden recibir, ya que los datos adicionales
   pueden caber en el área de relleno.

   Availability: la mayoría de plataformas Unix, posiblemente otras.

   Nuevo en la versión 3.3.

socket.getdefaulttimeout()

   Retorna el tiempo de espera por defecto en segundos (flotante) para
   los objetos de un nuevo socket. Un valor de "None" indicada que los
   objetos del nuevo socket no tiene un tiempo de espera. Cuando el
   modulo socket es importado primero, por defecto es "None".

socket.setdefaulttimeout(timeout)

   Selecciona el tiempo de espera por defecto en segundos (flotante )
   para los objetos nuevos del socket. Cuando el modulo socket es
   importado primero, el valor por defecto es "None". Observar
   "settimeout()" para posible valores y sus respectivos significados.

socket.sethostname(name)

   Establece el nombre de host de la maquina en *name*. Esto genera un
   "OSError" si no tiene suficientes derechos.

   Plantea un auditing event "socket.sethostname" con el argumento
   "name".

   Availability: Unix.

   Nuevo en la versión 3.3.

socket.if_nameindex()

   Devuelve una lista de tuplas de información de interfaz de red
   (índice int, cadena de nombre). "OSError" si se produce un error en
   la llamada del sistema.

   Availability: Unix, Windows.

   Nuevo en la versión 3.3.

   Distinto en la versión 3.8: Se ha agregado compatibilidad con
   Windows.

   Nota:

     En Windows las interfaces de redes tienen diferentes nombres en
     diferentes contextos (todos los nombres son ejemplos):

     * UUID: "{FB605B73-AAC2-49A6-9A2F-25416AEA0573}"

     * nombre: "ethernet_32770"

     * nombre amigable: "vEthernet (nat)"

     * descripción: "Hyper-V Virtual Ethernet Adapter"

     Esta función retorna los nombres del segundo formulario de la
     lista, en este caso de ejemplo "ethernet_32770".

socket.if_nametoindex(if_name)

   Devuelve un número de índice de interfaz de red correspondiente a
   un nombre de interfaz. "OSError" si no existe ninguna interfaz con
   el nombre especificado.

   Availability: Unix, Windows.

   Nuevo en la versión 3.3.

   Distinto en la versión 3.8: Se ha agregado compatibilidad con
   Windows.

   Ver también:

     “”Interface name” es un nombre como se documenta en
     "if_nameindex()".

socket.if_indextoname(if_index)

   Devuelve un nombre de interfaz de red correspondiente a un número
   de índice de interfaz. "OSError" si no existe ninguna interfaz con
   el índice dado.

   Availability: Unix, Windows.

   Nuevo en la versión 3.3.

   Distinto en la versión 3.8: Se ha agregado compatibilidad con
   Windows.

   Ver también:

     “”Interface name” es un nombre como se documenta en
     "if_nameindex()".

socket.send_fds(sock, buffers, fds[, flags[, address]])

   Send the list of file descriptors *fds* over an "AF_UNIX" socket
   *sock*. The *fds* parameter is a sequence of file descriptors.
   Consult "sendmsg()" for the documentation of these parameters.

   Availability: Soporte para Unix "sendmsg()" con el mecanismo
   "SCM_RIGHTS".

   Nuevo en la versión 3.9.

socket.recv_fds(sock, bufsize, maxfds[, flags])

   Receive up to *maxfds* file descriptors from an "AF_UNIX" socket
   *sock*. Return "(msg, list(fds), flags, addr)". Consult "recvmsg()"
   for the documentation of these parameters.

   Availability: Soporte para Unix "recvmsg()" y el mecanismo
   "SCM_RIGHTS".

   Nuevo en la versión 3.9.

   Nota:

     Cualquier número entero truncado al final de la lista de
     descriptores de archivo.


Objetos Socket
==============

Los objetos socket tienen los siguientes métodos. Excepto para
"makefile()", esto corresponde al sistema de llamadas Unix para
sockets.

Distinto en la versión 3.2: El soporte para el protocolo *context
manager* ha sido agregado. Salir del gestor de contexto es equivalente
para el llamado "close()".

socket.accept()

   Acepta una conexión. El socket debe estar vinculado a una dirección
   y estar escuchando las conexiones. El valor de retorno es el par
   "(conn, address)" cuando *conn* es un *new* objeto socket usado
   para enviar y recibir información en la conexión, y *address* es la
   dirección vinculada al socket en el extremo de la conexión.

   El socket recién creado es non-inheritable.

   Distinto en la versión 3.4: El socket ahora no es heredable.

   Distinto en la versión 3.5: Si se interrumpe la llamada del sistema
   y el controlador de señal no genera una excepción, el método ahora
   vuelve a intentar la llamada del sistema en lugar de generar una
   excepción "InterruptedError" (consulte **PEP 475** para la lógica).

socket.bind(address)

   Enlaza el socket a *address*. El socket no debe estar ya unido. (El
   formato de *address* depende de la familia de direcciones, consulte
   más arriba).

   Genera un auditing event "socket.getaddrinfo" con los argumentos
   "host", "port", "family", "type", "protocol".

socket.close()

   Marca el socket cerrado. El recurso del sistema subyacente (ej. un
   descriptor de archivo) también se cierra cuando todos los objetos
   de archivo de "makefile()" están cerrados. Una vez que eso suceda,
   todas las operaciones futuras en el objeto socket fallarán. El
   extremo remoto no recibirá más datos (después de que se vacíen los
   datos en cola).

   Los sockets se cierran automáticamente cuando se recogen basura,
   pero se recomienda "cerrarlos()" explícitamente, o usar una
   instrucción "with" alrededor de ellos.

   Distinto en la versión 3.6: "OSError" is now raised if an error
   occurs when the underlying "close()" call is made.

   Nota:

     "close()" libera el recurso asociado a una conexión, pero no
     necesariamente cierra la conexión inmediatamente.  Si desea
     cerrar la conexión a tiempo, llame a "shutdown()" antes de
     "close()".

socket.connect(address)

   Conectar a un socket remoto en *address*. (El formato de *address*
   depende de la familia de direcciones --- ver arriba.)

   Si una señal interrumpe la conexión, el método espera hasta que se
   complete la conexión o genere un "socket.timeout" en el tiempo de
   espera, si el controlador de señal no genera una excepción y el
   socket está bloqueando o tiene un tiempo de espera. Para los
   sockets sin bloqueo, el método genera una excepción
   "InterruptedError" si la conexión se interrumpe por una señal (o la
   excepción provocada por el controlador de señal).

   Genera un auditing event "socket.connect" con los argumentos
   "self", "address".

   Distinto en la versión 3.5: El método ahora espera hasta que se
   completa la conexión en lugar de generar una excepción
   "InterruptedError" si la conexión se interrumpe por una señal, el
   controlador de señal no genera una excepción y el socket está
   bloqueando o tiene un tiempo de espera (consulte el **PEP 475**
   para la razón de ser).

socket.connect_ex(address)

   Similar a *connect(address)`*, pero retorna un indicador de error
   en lugar de generar una excepción para los errores retornados por
   la llamada de nivel C "connect()" (otros problemas, como “host no
   encontrado”, aún pueden generar excepciones). El indicador de error
   es "0" si la operación tuvo éxito, caso contrario es el valor de la
   variable "errno". Esto es útil para admitir, por ejemplo,
   conexiones asincrónicas.

   Genera un auditing event "socket.connect" con los argumentos
   "self", "address".

socket.detach()

   Coloque el objeto de socket en estado cerrado sin cerrar realmente
   el descriptor de archivo subyacente.  Se devuelve el descriptor de
   archivo y se puede reutilizar para otros fines.

   Nuevo en la versión 3.2.

socket.dup()

   Duplica el socket.

   El socket recién creado es non-inheritable.

   Distinto en la versión 3.4: El socket ahora no es heredable.

socket.fileno()

   Retorna un archivo descriptor del socket (un entero pequeño), o -1
   si falla. Esto es útil con "select.select()".

   En Windows el pequeño entero retornado por este método no puede ser
   usado donde un descriptor de un archivo pueda ser usado (como una
   "os.fdopen()"). Unix no tiene esta limitación.

socket.get_inheritable()

   Obtiene el inheritable flag del descriptor del archivo del socket o
   el controlador del socket: "True" si el socket puede ser heredada
   en procesos secundarios, "False" si falla.

   Nuevo en la versión 3.4.

socket.getpeername()

   Retorna la dirección remota a la que esta conectado el socket. Esto
   es útil para averiguar el número de puerto de un socket IPv4/v6
   remoto, por ejemplo. (El formato de la dirección devuelta depende
   de la familia de direcciones, consulte más arriba). En algunos
   sistemas, esta función no es compatible.

socket.getsockname()

   Retorna la dirección del propio socket. Esto es útil para descubrir
   el numero de puerto de un socket IPv4/IPv6, por ejemplo. (El
   formato de la dirección devuelta depende de la familia de
   direcciones, consulte más arriba).

socket.getsockopt(level, optname[, buflen])

   Devuelve el valor de la opción de socket dada (consulte la página
   de comando man de Unix *getsockopt(2)*).  Las constantes simbólicas
   necesarias ("SO_*" etc.) se definen en este módulo.  Si *buflen*
   está ausente, se asume una opción de entero y la función devuelve
   su valor entero.  Si *buflen* está presente, especifica la longitud
   máxima del búfer utilizado para recibir la opción y este búfer se
   devuelve como un objeto bytes.  Depende del autor de la llamada
   descodificar el contenido del búfer (consulte el módulo integrado
   opcional "struct" para obtener una manera de decodificar las
   estructuras C codificadas como cadenas de bytes).

socket.getblocking()

   Devuelve "True" si el socket está en modo de bloqueo, "False" si
   está en sin bloqueo.

   Esto es equivalente a comprobar "socket.gettimeout() == 0".

   Nuevo en la versión 3.7.

socket.gettimeout()

   Retorna el tiempo de espera en segundos (flotante) asociado con las
   operaciones del socket, o "None" si el tiempo de espera no es
   seleccionado. Esto refleja la ultima llamada al "setblocking()" o
   "settimeout()".

socket.ioctl(control, option)

   plataforma:
      Windows

   El método "ioctl()" es una interfaz limitada para el sistema de
   interfaces WSAIoctl. Por favor refiérase a Win32 documentation para
   mas información.

   En otras plataformas, las funciones genéricas "fcntl.fcntl()" y
   "fcntl.ioctl()" podrían ser usadas; ellas aceptan un objeto socket
   como su primer argumento.

   Actualmente solo el siguiente control de códigos está soportados:
   "SIO_RCVALL", "SIO_KEEPALIVE_VALS", y "SIO_LOOPBACK_FAST_PATH".

   Distinto en la versión 3.6: "SIO_LOOPBACK_FAST_PATH" ha sido
   agregado.

socket.listen([backlog])

   Habilita un servidor para aceptar conexiones. Si *backlog* es
   especifico, debe ser al menos 0 (si es menor, se establece en 0);
   especifica el número de conexiones no aceptadas que permitirá el
   sistema antes de rechazar nuevas conexiones. Si no se especifica,
   se elige un valor razonable predeterminado.

   Distinto en la versión 3.5: El parámetro *backlog* ahora es
   opcional.

socket.makefile(mode='r', buffering=None, *, encoding=None, errors=None, newline=None)

   Retorna un *file object* asociado con el socket. El tipo exacto
   retornado depende de los argumentos dados a "makefile()". Estos
   argumentos se interpretan de la misma forma que la función
   "open()", excepto que los únicos valores de *mode* admitidos son
   "’r’" (default), "’w’" and "’b’".

   El socket debe estar en modo de bloqueo; puede tener un tiempo de
   espera, pero el búfer interno del objeto de archivo puede terminar
   en un estado incoherente si se produce un tiempo de espera.

   Cerrar el objeto de archivo devuelto por "makefile()" no cerrará el
   socket original a menos que se hayan cerrado todos los demás
   objetos de archivo y "socket.close()" se haya llamado al objeto
   socket.

   Nota:

     En Windows, el objeto similar a un archivo creado por
     "makefile()" no se puede utilizar cuando se espera un objeto de
     archivo con un descriptor de archivo, como los argumentos de
     secuencia de "subprocess.Popen()".

socket.recv(bufsize[, flags])

   Recibir datos del socket.  El valor devuelto es un objeto bytes que
   representa los datos recibidos.  *bufsize* especifica la cantidad
   máxima de datos que se recibirán a la vez.  Consulte la página del
   manual de Unix *recv(2)* para conocer el significado del argumento
   opcional *flags*; por defecto es cero.

   Nota:

     Para una mejor coincidencia con las realidades de hardware y red,
     el valor de *bufsize* debe ser una potencia relativamente pequeña
     de 2, por ejemplo, 4096.

   Distinto en la versión 3.5: Si se interrumpe la llamada del sistema
   y el controlador de señal no genera una excepción, el método ahora
   vuelve a intentar la llamada del sistema en lugar de generar una
   excepción "InterruptedError" (consulte **PEP 475** para la lógica).

socket.recvfrom(bufsize[, flags])

   Recibe datos desde el socket. El valor de retorno es un par
   "(bytes, address)" donde *bytes* es un objeto de bytes que
   representa los datos recibidos y *address* es la dirección de el
   socket enviando los datos. Observar la pagina del manual Unix
   *recv(2)* para el significado del argumento opcional *flags*; por
   defecto es cero. (El formato de *address* depende de la familia de
   direcciones, consulte más arriba).

   Distinto en la versión 3.5: Si se interrumpe la llamada del sistema
   y el controlador de señal no genera una excepción, el método ahora
   vuelve a intentar la llamada del sistema en lugar de generar una
   excepción "InterruptedError" (consulte **PEP 475** para la lógica).

   Distinto en la versión 3.7: Para direcciones IPv6 de multidifusión,
   el primer elemento de *address* ya no contiene la parte
   "%scope_id". Para obtener la dirección IPV6 completa, use
   "getnameinfo()".

socket.recvmsg(bufsize[, ancbufsize[, flags]])

   Reciba datos normales (hasta *bufsize* bytes) y datos auxiliares
   del socket.  El argumento *ancbufsize* establece el tamaño en bytes
   del búfer interno utilizado para recibir los datos auxiliares; el
   valor predeterminado es 0, lo que significa que no se recibirán
   datos auxiliares.  Los tamaños de búfer adecuados para los datos
   auxiliares se pueden calcular mediante "CMSG_SPACE()" o
   "CMSG_LEN()", y los elementos que no caben en el búfer pueden
   truncarse o descartarse.  El valor predeterminado del argumento
   *flags* es 0 y tiene el mismo significado que para "recv()".

   El valor de retorno es una tupla de 4: "(data, ancdata, msg_flags,
   address)". El valor *data* es un objeto "bytes" que contiene los
   datos no auxiliares recibidos. El valor *ancdata* es una lista de
   cero o mas tuplas "(cmsg_level, cmsg_type, cmsg_data)" representado
   los datos auxiliares (control de mensajes) recibidos: *cmsg_level*
   y *cmsg_type* son enteros especificando el nivel de protocolo y
   tipo específico de protocolo respectivamente, y *cmsg_data* es un
   objeto "bytes" sosteniendo los datos asociados. El valor
   *msg_flags* es el OR bit a bit de varios indicadores que indican
   condiciones en el mensaje recibido; consulte la documentación de su
   sistema para obtener más detalles. Si la toma de recepción no está
   conectada, *address* es la dirección de el socket enviado, si está
   disponible; de lo contrario, su valor no se especifica.

   En algunos sistemas, "sendmsg()" y "recvmsg()" se puede utilizar
   para pasar descriptores de archivos entre procesos a través de un
   socket "AF_UNIX" Cuando se utiliza esta función (a menudo se limita
   a sockets "SOCK_STREAM"), "recvmsg`devolverá, en sus datos
   auxiliares, elementos del formulario ``(socket.SOL_SOCKET,
   socket.SCM_RIGHTS, fds)`()", donde *fds* es un objeto "bytes"
   representado el nuevo descriptor de archivos como una matriz
   binaria del tipo C nativa :"int". Si "recvmsg()" genera un
   excepción después del retorno de la llamada del sistema, primero
   intentará cerrar cualquier descriptor de archivo recibido a través
   de este mecanismo.

   Algunos sistemas no indican la longitud truncada de los elementos
   de datos auxiliares que solo se han recibido parcialmente.  Si un
   elemento parece extenderse más allá del final del búfer,
   "recvmsg()" emitirá un "RuntimeWarning", y devolverá la parte de él
   que está dentro del búfer siempre que no se haya truncado antes del
   inicio de sus datos asociados.

   En sistemas donde soporta el mecanismo "SCM_RIGHTS", la siguiente
   función recibirá un descriptor de archivos *maxfds*, devolviendo el
   mensaje de datos y un lista que contiene los descriptores (mientras
   se ignoran las condiciones inesperadas, como la recepción de
   mensajes de control no relacionados). Ver también "sendmsg()".

      import socket, array

      def recv_fds(sock, msglen, maxfds):
          fds = array.array("i")   # Array of ints
          msg, ancdata, flags, addr = sock.recvmsg(msglen, socket.CMSG_LEN(maxfds * fds.itemsize))
          for cmsg_level, cmsg_type, cmsg_data in ancdata:
              if cmsg_level == socket.SOL_SOCKET and cmsg_type == socket.SCM_RIGHTS:
                  # Append data, ignoring any truncated integers at the end.
                  fds.frombytes(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
          return msg, list(fds)

   Availability: la mayoría de plataformas Unix, posiblemente otras.

   Nuevo en la versión 3.3.

   Distinto en la versión 3.5: Si se interrumpe la llamada del sistema
   y el controlador de señal no genera una excepción, el método ahora
   vuelve a intentar la llamada del sistema en lugar de generar una
   excepción "InterruptedError" (consulte **PEP 475** para la lógica).

socket.recvmsg_into(buffers[, ancbufsize[, flags]])

   Recibir datos normales y datos auxiliares desde el socket,
   comportándose como "recvmsg()" lo haría, pero dispersar los datos
   no auxiliares en una serie de buffers en lugar de devolver un nuevo
   objeto bytes.  El argumento *buffers* debe ser un iterable de
   objetos que exportan buffers de escritura (por ejemplo, objetos
   "bytearray"); estos se llenarán con fragmentos sucesivos de los
   datos no auxiliares hasta que se hayan escrito todos o no haya más
   buffers.  El sistema operativo puede establecer un límite
   ("sysconf()" valor "SC_IOV_MAX") en el número de buffers que se
   pueden utilizar.  Los argumentos *ancbufsize* y *flags* tienen el
   mismo significado que para "recvmsg()".

   El valor de retorno es tupla de 4: "(nbytes, ancdata, msg_flags,
   address)", donde *nbytes* es el numero total de bytes de datos no
   auxiliares escrito dentro de los bufetes, y *ancdata*, *msg_flags*
   y *address* son lo mismo que para "recvmsg()".

   Ejemplo:

      >>> import socket
      >>> s1, s2 = socket.socketpair()
      >>> b1 = bytearray(b'----')
      >>> b2 = bytearray(b'0123456789')
      >>> b3 = bytearray(b'--------------')
      >>> s1.send(b'Mary had a little lamb')
      22
      >>> s2.recvmsg_into([b1, memoryview(b2)[2:9], b3])
      (22, [], 0, None)
      >>> [b1, b2, b3]
      [bytearray(b'Mary'), bytearray(b'01 had a 9'), bytearray(b'little lamb---')]

   Availability: la mayoría de plataformas Unix, posiblemente otras.

   Nuevo en la versión 3.3.

socket.recvfrom_into(buffer[, nbytes[, flags]])

   Reciba datos del socket, escribiéndolo en *buffer* en lugar de
   crear una nueva cadena de bytes.  El valor devuelto es un par
   "(nbytes, address)" donde *nbytes* es el número de bytes recibidos
   y *address* es la dirección del socket que envía los datos.
   Consulte la página del manual de Unix *recv(2)* para conocer el
   significado del argumento opcional *flags*; por defecto es cero.
   (El formato de *address* depende de la familia de direcciones ---
   ver arriba.)

socket.recv_into(buffer[, nbytes[, flags]])

   Recibe hasta *nbytes* bytes desde el socket, almacenado los datos
   en un búfer en lugar de crear una nueva cadena de bytes. Si
   *nbytes* no esta especificado (o 0), recibir hasta el tamaño
   disponible en el búfer dado. Devuelve el número de bytes recibidos.
   Ver la página del manual de Unix *recv(2)* para el significado del
   argumento opcional *flags*; por defecto es cero.

socket.send(bytes[, flags])

   Enviar datos al socket.  El socket debe estar conectado a un socket
   remoto.  El argumento opcional *flags* tiene el mismo significado
   que para "recv()" arriba. Devuelve el número de bytes enviados. Las
   aplicaciones son responsables de comprobar que se han enviado todos
   los datos; si sólo se transmitieron algunos de los datos, la
   aplicación debe intentar la entrega de los datos restantes. Para
   obtener más información sobre este tema, consulte HOW TO -
   Programación con sockets.

   Distinto en la versión 3.5: Si se interrumpe la llamada del sistema
   y el controlador de señal no genera una excepción, el método ahora
   vuelve a intentar la llamada del sistema en lugar de generar una
   excepción "InterruptedError" (consulte **PEP 475** para la lógica).

socket.sendall(bytes[, flags])

   Enviar datos al socket.  El socket debe estar conectado a un socket
   remoto.  El argumento opcional *flags* tiene el mismo significado
   que para "recv()" arriba. A diferencia de "send()", este método
   continúa enviando datos desde *bytes* hasta que se han enviado
   todos los datos o se produce un error.  "Ninguno" se devuelve en
   caso de éxito.  Por error, se genera una excepción y no hay forma
   de determinar cuántos datos, si los hay, se enviaron correctamente.

   Distinto en la versión 3.5: El tiempo de espera del socket no se
   restablece más cada vez que los datos se envían correctamente. El
   tiempo de espera del socket es ahora la duración total máxima para
   enviar todos los datos.

   Distinto en la versión 3.5: Si se interrumpe la llamada del sistema
   y el controlador de señal no genera una excepción, el método ahora
   vuelve a intentar la llamada del sistema en lugar de generar una
   excepción "InterruptedError" (consulte **PEP 475** para la lógica).

socket.sendto(bytes, address)
socket.sendto(bytes, flags, address)

   Enviar datos al socket.  El socket no debe estar conectado a un
   socket remoto, ya que el socket de destino se especifica mediante
   *address*.  El argumento opcional *flags* tiene el mismo
   significado que para "recv()" arriba.  Devolver el número de bytes
   enviados. (El formato de *address* depende de la familia de
   direcciones --- ver arriba.)

   Genera un auditing event "socket.sendto" con los argumentos "self",
   "address".

   Distinto en la versión 3.5: Si se interrumpe la llamada del sistema
   y el controlador de señal no genera una excepción, el método ahora
   vuelve a intentar la llamada del sistema en lugar de generar una
   excepción "InterruptedError" (consulte **PEP 475** para la lógica).

socket.sendmsg(buffers[, ancdata[, flags[, address]]])

   Enviar datos normales y auxiliares al socket, recopilar los datos
   no auxiliares de una serie de buffers y concatenando en un único
   mensaje.  El argumento *buffers* especifica los datos no auxiliares
   como un iterable de *bytes-como objetos* (por ejemplo: objetos
   "bytes"); el sistema operativo puede establecer un límite
   ("os.sysconf()" valor "SC_IOV_MAX") en el número de buffers que se
   pueden utilizar.  El argumento *ancdata* especifica los datos
   auxiliares (mensajes de control) como un iterable de cero o más
   tuplas "(cmsg_level, cmsg_type, cmsg_data)", donde *cmsg_level* y
   *cmsg_type* son enteros que especifican el nivel de protocolo y el
   tipo específico del protocolo respectivamente, y *cmsg_data* es un
   objeto similar a bytes que contiene los datos asociados.  Tenga en
   cuenta que algunos sistemas (en particular, sistemas sin
   "CMSG_SPACE()") pueden admitir el envío de solo un mensaje de
   control por llamada.  El valor predeterminado del argumento *flags*
   es 0 y tiene el mismo significado que para "send()".  Si se
   proporciona *address* y no "None", establece una dirección de
   destino para el mensaje.  El valor devuelto es el número de bytes
   de datos no auxiliares enviados.

   La siguiente función envía la lista de descriptores de archivos
   *fds* sobre un socket "AF_UNIX", estos sistemas pueden soportar la
   mecánica "SCM_RIGHTS". Observar también "recvmsg()".

      import socket, array

      def send_fds(sock, msg, fds):
          return sock.sendmsg([msg], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.array("i", fds))])

   Availability: la mayoría de plataformas Unix, posiblemente otras.

   Genera un auditing event "socket.sendmsg" con los argumentos
   "self", "address".

   Nuevo en la versión 3.3.

   Distinto en la versión 3.5: Si se interrumpe la llamada del sistema
   y el controlador de señal no genera una excepción, el método ahora
   vuelve a intentar la llamada del sistema en lugar de generar una
   excepción "InterruptedError" (consulte **PEP 475** para la lógica).

socket.sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags]]])

   Versión especializada de "sendmsg()" para el socket "AF_ALG". Modo
   de ajuste, IV, longitud de datos asociados a AEAD y banderas para
   el socket "AF_ALG".

   Availability: Linux >= 2.6.38.

   Nuevo en la versión 3.6.

socket.sendfile(file, offset=0, count=None)

   Enviar un archivo hasta que se alcance EOF mediante el uso de alto
   rendimiento "os.sendfile" y devolver el número total de bytes que
   se enviaron. *file* debe ser un objeto de archivo normal abierto en
   modo binario. Si "os.sendfile" no está disponible (por ejemplo,
   Windows) o *file* no es un archivo normal "send()" se utilizará en
   su lugar. *offset* indica desde dónde empezar a leer el archivo. Si
   se especifica, *count* es el número total de bytes para transmitir
   en lugar de enviar el archivo hasta que se alcance EOF. La posición
   del archivo se actualiza a la vuelta o también en caso de error en
   cuyo caso "file.tell()" se puede utilizar para averiguar el número
   de bytes que se enviaron. El socket debe ser de tipo "SOCK_STREAM"
   No se admiten sockets sin bloqueo.

   Nuevo en la versión 3.5.

socket.set_inheritable(inheritable)

   Selecciona el inheritable flag descriptor del archivo del socket o
   el controlador del socket.

   Nuevo en la versión 3.4.

socket.setblocking(flag)

   Establecer el modo de bloqueo o no bloqueo del socket: si *flag* es
   false, el socket se establece en modo sin bloqueo, de lo contrario
   en modo de bloqueo.

   El método es una abreviatura para ciertas llamadas "settimeout()":

   * "sock.setblocking(True)" es equivalente a "sock.settimeout(None)"

   * "sock.setblocking(False)" es equivalente a "sock.settimeout(0.0)"

   Distinto en la versión 3.7: El método ya no aplica la bandera
   "SOCK_NONBLOCK" en "socket.type".

socket.settimeout(value)

   Establece un tiempo de espera para bloquear las operaciones de
   socket. El argumento *value* puede ser un número de punto flotante
   no negativo que exprese segundos, o "None". Si se da un valor
   distinto de cero, las operaciones subsiguientes de socket generarán
   una excepción "timeout" si el período de tiempo de espera *value*
   ha transcurrido antes de que se complete la operación. Si se da
   cero, el socket se pone en modo sin bloqueo. Si se da "None", el
   enchufe se pone en modo de bloqueo.

   Para obtener más información, consulte las notas notas sobre los
   tiempos de espera del socket.

   Distinto en la versión 3.7: El método ya no cambia la bandera
   "SOCK_NONBLOCK" en  "socket.type".

socket.setsockopt(level, optname, value: int)

socket.setsockopt(level, optname, value: buffer)

socket.setsockopt(level, optname, None, optlen: int)

   Establece el valor de la opción de socket dada (consulte la página
   de manual de Unix *setsockopt(2)*). Las constantes simbólicas
   necesarias se definen en el modulo "socket" ("SO_*" etc.). El valor
   puede ser un entero, "None" o un *bytes-like object* representan un
   buffer. En el último caso, depende de la persona que llama
   asegurarse de que la cadena de bytes contenga los bits adecuados
   (consulte el módulo integrado opcional "struct" para una forma de
   codificar estructuras C como cadenas de bytes). Cuando *value* se
   establece en "None", el argumento *optlen* es requerido. Esto es
   equivalente a llamar a una función C "setsockopt()" con
   "optval=NULL" y "optlen=optlen".

   Distinto en la versión 3.5: Ahora se acepta la grabación *bytes-
   like object*.

   Distinto en la versión 3.6: setsockopt(level, optname, None,
   optlen: int) form added.

socket.shutdown(how)

   Apague una o ambas mitades de la conexión. Si *how* es "SHUT_RD",
   más recibe no se permiten. Si *how* es  "SHUT_WR", mas recibe no se
   permiten. Si *how* es "SHUT_RDWR", más recibe no se permiten.

socket.share(process_id)

   Duplica un socket y lo prepara para compartirlo con el proceso de
   destino. El proceso de destino debe estar provisto de *process_id*.
   el objeto de bytes resultante luego se puede pasar al proceso de
   destino usando alguna forma de comunicación entre procesos y el
   socket se puede recrear allí usando  "fromshare()". Una vez que se
   ha llamado a este método, es seguro cerrar el socket ya que el
   sistema operativo ya lo ha duplicado para el proceso de destino.

   Availability: Windows.

   Nuevo en la versión 3.3.

Tenga en cuenta que no hay métodos "read()" o "write()"; use "recv()"
y "send()" sin el argumento *flags* en su lugar.

Los objetos de socket también tienen estos atributos (de solo lectura)
que corresponden a los valores dados al constructor "socket".

socket.family

   La familia Socket.

socket.type

   El tipo de socket.

socket.proto

   The socket protocol.


Notas sobre los tiempos de espera del socket
============================================

Un objeto de socket puede estar en uno de los tres modos: bloqueo, no
bloqueo o tiempo de espera.  Los sockets se crean de forma
predeterminada siempre en modo de bloqueo, pero esto se puede cambiar
llamando a "setdefaulttimeout()".

* En el modo *bloqueo*, las operaciones se bloquean hasta que se
  completan o el sistema devuelve un error (como tiempo de espera de
  conexión agotado).

* En el modo *sin bloqueo*, las operaciones fallan (con un error que,
  por desgracia, depende del sistema) si no se pueden completar
  inmediatamente: las funciones de "select" se pueden utilizar para
  saber cuándo y si un socket está disponible para leer o escribir.

* En *timeout mode*, las operaciones fallan si no se puede completan
  el tiempo de espera especifico para el socket ( ellos levanta una
  excepción "timeout") o si el sistema devuelve un error.

Nota:

  En el nivel del sistema operativo, los sockets en el *timeout mode*
  se establecen internamente en modo sin bloqueo.  Además, los modos
  de bloqueo y tiempo de espera se comparten entre descriptores de
  archivo y objetos de socket que hacen referencia al mismo punto de
  conexión de red. Este detalle de implementación puede tener
  consecuencias visibles si, por ejemplo, decide utilizar el
  "fileno()" de un socket.


Tiempos de espera y el método "connect"
---------------------------------------

La operación "connect()" también está sujeta a la configuración de
tiempo de espera, y en general se recomienda llamar a "settimeout()"
antes de llamar a "connect()" o pasar un parámetro de tiempo de espera
a "create_connection()".  Sin embargo, la pila de red del sistema
también puede devolver un error de tiempo de espera de conexión propio
independientemente de cualquier configuración de tiempo de espera del
socket de Python.


Tiempos de espera y el método "accept"
--------------------------------------

Si "getdefaulttimeout()" no es una "None", los sockets devuelto por el
método "accept()" heredan ese tiempo de espera. De lo contrario, el
comportamiento depende de la configuración de la toma de escucha:

* si los sockets están escuchando en *blocking mode* o en el *timeout
  mode*, el socket devuelve el "accept()" en un *blocking mode*;

* si los sockets están escuchando en *non-blocking mode*, ya sea el
  socket devuelto por "accept()" es un modo de bloqueo o no bloque
  depende del sistema operativo. Si desea garantizar un comportamiento
  multiplataforma, se recomienda que se anule manualmente esta
  configuración.


Ejemplo
=======

Aquí están cuatro programas mínimos usando el protocolo TCP/IP: un
servidor que hace eco de todos los datos que reciban de vuelta (
Servicio a un solo cliente), y un cliente usando esto. Recuerde que un
servidor debe llevar a cabo la secuencia "socket()", "bind()",
"listen()", "accept()" (posiblemente repitiendo la "accept()" para un
servicio mas que un cliente), mientras un cliente solamente necesita
la secuencia "socket()", "connect()". También recuerde que el servidor
no "sendall()"/"recv()" en el socket esta escuchando pero en el nuevo
socket devuelto por "accept()".

Los dos primeros ejemplos solo admiten IPv4.

   # Echo server program
   import socket

   HOST = ''                 # Symbolic name meaning all available interfaces
   PORT = 50007              # Arbitrary non-privileged port
   with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
       s.bind((HOST, PORT))
       s.listen(1)
       conn, addr = s.accept()
       with conn:
           print('Connected by', addr)
           while True:
               data = conn.recv(1024)
               if not data: break
               conn.sendall(data)

   # Echo client program
   import socket

   HOST = 'daring.cwi.nl'    # The remote host
   PORT = 50007              # The same port as used by the server
   with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
       s.connect((HOST, PORT))
       s.sendall(b'Hello, world')
       data = s.recv(1024)
   print('Received', repr(data))

Los dos ejemplos siguientes son idénticos a los dos anteriores, pero
admiten IPv4 e IPv6. El lado del servidor escuchará la primera familia
de direcciones disponible (debe escuchar ambas en su lugar). En la
mayoría de los sistemas listos para IPv6, IPv6 tendrá prioridad y es
posible que el servidor no acepte tráfico IPv4. El lado del cliente
intentará conectarse a todas las direcciones devueltas como resultado
de la resolución de nombres y enviará el tráfico al primero conectado
correctamente.

   # Echo server program
   import socket
   import sys

   HOST = None               # Symbolic name meaning all available interfaces
   PORT = 50007              # Arbitrary non-privileged port
   s = None
   for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,
                                 socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
       af, socktype, proto, canonname, sa = res
       try:
           s = socket.socket(af, socktype, proto)
       except OSError as msg:
           s = None
           continue
       try:
           s.bind(sa)
           s.listen(1)
       except OSError as msg:
           s.close()
           s = None
           continue
       break
   if s is None:
       print('could not open socket')
       sys.exit(1)
   conn, addr = s.accept()
   with conn:
       print('Connected by', addr)
       while True:
           data = conn.recv(1024)
           if not data: break
           conn.send(data)

   # Echo client program
   import socket
   import sys

   HOST = 'daring.cwi.nl'    # The remote host
   PORT = 50007              # The same port as used by the server
   s = None
   for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
       af, socktype, proto, canonname, sa = res
       try:
           s = socket.socket(af, socktype, proto)
       except OSError as msg:
           s = None
           continue
       try:
           s.connect(sa)
       except OSError as msg:
           s.close()
           s = None
           continue
       break
   if s is None:
       print('could not open socket')
       sys.exit(1)
   with s:
       s.sendall(b'Hello, world')
       data = s.recv(1024)
   print('Received', repr(data))

El siguiente ejemplo muestra cómo escribir un rastreador de red muy
simple con sockets sin procesar en Windows. El ejemplo requiere
privilegios de administrador para modificar la interfaz:

   import socket

   # the public network interface
   HOST = socket.gethostbyname(socket.gethostname())

   # create a raw socket and bind it to the public interface
   s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
   s.bind((HOST, 0))

   # Include IP headers
   s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

   # receive all packages
   s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)

   # receive a package
   print(s.recvfrom(65565))

   # disabled promiscuous mode
   s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

En el ejemplo siguiente se muestra cómo utilizar la interfaz de socket
para comunicarse con una red CAN mediante el protocolo de socket sin
procesar. Para utilizar CAN con el protocolo de gestor de difusión en
su lugar, abra un socket con:

   socket.socket(socket.AF_CAN, socket.SOCK_DGRAM, socket.CAN_BCM)

Después de enlazar ("CAN_RAW") o conectar ("CAN_BCM") el socket, puede
usar las operaciones "socket.send()" y "socket.recv()" (y sus
contrapartes) en el objeto de socket como de costumbre.

Este último ejemplo puede requerir privilegios especiales:

   import socket
   import struct


   # CAN frame packing/unpacking (see 'struct can_frame' in <linux/can.h>)

   can_frame_fmt = "=IB3x8s"
   can_frame_size = struct.calcsize(can_frame_fmt)

   def build_can_frame(can_id, data):
       can_dlc = len(data)
       data = data.ljust(8, b'\x00')
       return struct.pack(can_frame_fmt, can_id, can_dlc, data)

   def dissect_can_frame(frame):
       can_id, can_dlc, data = struct.unpack(can_frame_fmt, frame)
       return (can_id, can_dlc, data[:can_dlc])


   # create a raw socket and bind it to the 'vcan0' interface
   s = socket.socket(socket.AF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
   s.bind(('vcan0',))

   while True:
       cf, addr = s.recvfrom(can_frame_size)

       print('Received: can_id=%x, can_dlc=%x, data=%s' % dissect_can_frame(cf))

       try:
           s.send(cf)
       except OSError:
           print('Error sending CAN frame')

       try:
           s.send(build_can_frame(0x01, b'\x01\x02\x03'))
       except OSError:
           print('Error sending CAN frame')

Ejecutar un ejemplo varias veces con un retraso demasiado pequeño
entre ejecuciones, podría dar lugar a este error:

   OSError: [Errno 98] Address already in use

Esto se debe a que la ejecución anterior ha dejado el socket en un
estado "TIME_WAIT" y no se puede reutilizar inmediatamente.

Este es una bandera "socket" para establecer, en orden para prevenir
esto, "socket.SO_REUSEADDR":

   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   s.bind((HOST, PORT))

el indicador "SO_REUSEADDR" indica al kernel que reutilice un socket
local en estado "TIME_WAIT", sin esperar a que expire su tiempo de
espera natural.

Ver también:

  Para obtener una introducción a la programación de sockets (en C),
  consulte los siguientes documentos:

  * *An Introductory 4.3BSD Interprocess Communication Tutorial*, por
    Stuart Sechrest

  * *An Advanced 4.3BSD Interprocess Communication Tutorial*, por
    Samuel J.  Leffler et al,

  ambos en el manual del programador de Unix, documentos
  suplementarios 1 ( secciones  PS1:7 y PS1:8). La plataforma
  especifica material de referencia para las diversas llamadas al
  sistema también son una valiosa fuente de información en los
  detalles de la semántica del socket. Para Unix, referencia a las
  paginas del manual, para Windows, observa la especificación WinSock
  (o WinSock 2). Para APIS listas IPV6, los lectores pueden querer
  referirse al titulado Extensiones básicas de interfaz de socket para
  IPv6 **RFC 3493** .
