Provided by: manpages-pt_20040726-4_all bug

NOME

       socket - interface para socket Linux

SINOPSE

       #include <sys/socket.h>
       mysocket = socket(int socket_family, int socket_type, int protocol);

DESCRIÇÃO

       Esta  página do manual descreve a interface de usuário para a camada de
       socket de rede Linux. Os sockets compatíveis com BSD são uma  interface
       uniforme  entre  o processo do usuário e as pilhas de protocolo de rede
       no kernel.  Os módulos de protocolo  estão  agrupados  em  famlias  de
       protocolos  como  PF_INET,  PF_IPX,  PF_PACKET  e  tipos de socket como
       SOCK_STREAM ou SOCK_DGRAM.  Veja socket(2) para mais informações  sobre
       famílias e tipos.

FUNÇÕES DA CAMADA DE SOCKET

       Estas  funções  são  usadas  pelo  processo  do  usuário para enviar ou
       receber pacotes, e realizar  outras  operações  de  socket.  Para  mais
       informações, veja as respectivas páginas de manual.

       socket(2) cria um socket, connect(2) conecta um socket a um endereço de
       socket remoto, a função bind(2) liga um socket a um endereço de  socket
       local,  listen(2)  diz  ao  socket  que novas conexões serão aceitas, e
       accept(2) é usado para obter um novo socket com  uma  nova  conexão  de
       entrada.    socketpair(2)  retorna  dois  sockets  anônimos  conectados
       (somente implementados para algumas famílias locais, como PF_UNIX)

       send(2), sendto(2), e sendmsg(2) enviam dados através de um  socket,  e
       recv(2), recvfrom(2), recvmsg(2) recebem dados de um socket.  poll(2) e
       select(2) aguardam por dados que chegam ou um estado de prontidão  para
       enviar  dados.   Além  disso, as operações padrão de I/O como write(2),
       writev(2), sendfile(2), read(2), e readv(2) podem ser usados para ler e
       escrever dados.

       getsockname(2)  retorna  o  endereço  local  do socket e getpeername(2)
       retorna o endereço remoto do socket.  getsockopt(2) e setsockopt(2) são
       usados  para setar ou obter opções da camada de socket ou do protocolo.
       ioctl(2) pode ser usado para setar ou ler algumas outras opções.

       close(2) é usado para encerrar um socket.  shutdown(2)  encerra  partes
       de uma conexão de socket "full duplex".

       A busca ou a chamada de pread(2) ou pwrite(2) com uma posição diferente
       de zero não são suportados em sockets.

       É possível fazer IO não-bloqueável em sockets  configurando-se  o  flag
       O_NONBLOCK  em  um  descritor  de  arquivo  de socket, usando fcntl(2).
       O_NONBLOCK é herdado através de um accept.  Então  todas  as  operações
       que   normalmente   bloqueariam  (geralmente)  retornarão  com  EAGAIN;
       connect(2) retorna um erro do tipo EINPROGRESS neste caso.   O  usuário
       pode então esperar por vários eventos, via poll(2) ou select(2).

       +---------------------------------------------------------------+
       |                          I/O events                           |
       +-----------+-----------+---------------------------------------+
       |Evento     | Poll flag | Ocorrência                            |
       +-----------+-----------+---------------------------------------+
       |Read       | POLLIN    | Novo dado chegou.                     |
       +-----------+-----------+---------------------------------------+
       |Read       | POLLIN    | Uma   configuração   de  conexão  foi |
       |           |           | completada (para sockets orientados à |
       |           |           | conexão)                              |
       +-----------+-----------+---------------------------------------+
       |Read       | POLLHUP   | Um  pedido de desconexão foi iniciado |
       |           |           | pelo outro extremo.                   |
       +-----------+-----------+---------------------------------------+
       |Read       | POLLHUP   | Uma  conexão  foi  quebrada  (somente |
       |           |           | para    protocolos    orientados    à |
       |           |           | conexão).  Quando o socket é escrito, |
       |           |           | SIGPIPE é enviado também.             |
       +-----------+-----------+---------------------------------------+
       |Write      | POLLOUT   | O   socket   tem   espaço  de  buffer |
       |           |           | suficiente para escrever novos dados. |
       +-----------+-----------+---------------------------------------+
       |Read/Write | POLLIN|   | Um connect(2) externo terminou.       |
       |           | POLLOUT   |                                       |
       +-----------+-----------+---------------------------------------+
       |Read/Write | POLLERR   | Ocorreu um erro assíncrono.           |
       +-----------+-----------+---------------------------------------+
       |Read/Write | POLLHUP   | O outro extremo desligou uma direção. |
       +-----------+-----------+---------------------------------------+
       |Exception  | POLLPRI   | Dado   urgente   chegou.    SIGURG  é |
       |           |           | enviado, então.                       |
       +-----------+-----------+---------------------------------------+

       Uma  alternativa  para  poll/select  é  deixar  o  kernel  informar   o
       aplicativo  sobre  eventos  através  do  sinal  SIGIO  FASYNC  deve ser
       configurado em um descritor de arquivo de socket através fcntl(2)  ,  e
       um  manipulador  de  sinal  válido  para  SIGIO  deve ser instalado via
       sigaction(2).  Veja a discussão de SINAIS abaixo.

OPÇÕES DE SOCKET

       Estas opções de socket podem ser configuradas pelo uso de setsockopt(2)
       ,  e  lidas  com  getsockopt(2)  ,  com  o  nível  de  socket setado em
       SOL_SOCKET para todos os sockets:

       SO_KEEPALIVE
              Habilita o envio de mensagens "keep-alive" em sockets orientados
              à conexão. Espera por um integer boolean flag.

       SO_OOBINLINE
              Se  esta  opção  é  habilitada,  dados out-of-band são colocados
              diretamente no fluxo de dados de recepção. Caso contrário, dados
              out-of-band  são  passados apenas quando o flag MSG_OOB é setado
              durante a recepção.

       SO_RCVLOWAT e SO_SNDLOWAT
              Especifica o número mínimo de bytes no buffer até que  a  camada
              de  socket  passe  os  dados para o protocolo (SO_SNDLOWAT) , ou
              para o usuário, ao receber um (SO_RCVLOWAT).  Estes dois valores
              não  são alteráveis em Linux, e o tamanho de seus argumentos são
              sempre fixados  em  1  byte.   getsockopt  é  capaz  de  lê-los;
              setsockopt sempre retornará ENOPROTOOPT.

       SO_RCVTIMEO and SO_SNDTIMEO
              Especifica  os  timeouts  de  envio ou recepção, até reportar um
              erro.  Eles são fixados em  uma  configuração  Linux  específica
              para  cada  protocolo,  e  não pode ser lidos nem escritos. Suas
              funcionalidades  podem  ser  emuladas  usando-se   alarm(2)   ou
              setitimer(2).

       SO_BSDCOMPAT
              Habilita a compatibilidade BSD bug-a-bug. Isto é usado apenas no
              módulo do protocolo UDP e agendado para ser removido no  futuro.
              Se habilitado erros de ICMP recebidos de um socket UDP não serão
              passados para o programa do usuário. O Linux 2.0 também habilita
              opções  de  compatibilidade  BSD bug-a-bug (mudança aleatória de
              cabeçalhos, salto do sinalizador de broadcast) para sockets  raw
              com  estas  opções, mas isso foi removido no Linux 2.2. É melhor
              corrigir  os  programas  do  usuário  do  que   habilitar   este
              sinalizador.

       SO_PASSCRED
              Habilita  ou  desabilita  a  recepção  de  mensagem  de controle
              SCM_CREDENTIALS unix(7).

       SO_PEERCRED
              Retorna as credenciais do processo estrangeiro conectado a  este
              socket.   É útil somente para sockets PF_UNIX ; veja unix(7).  O
              argumento é uma estrutura ucred getsockopt.

       SO_BINDTODEVICE
              Liga este socket a um dispositivo particular, como “eth0”,  como
              especificado  no  nome  de  interface  passado.  Se o nome é uma
              string vazia, ou se o comprimento da opção é zero, a ligação  do
              dispositivo  do socket é removido.  A opção passada é uma string
              de nome de interface com comprimento  variável  e  terminada  em
              caractere  nulo,  com  comprimento  máximo  de  IFNAMSIZ.  Se um
              socket é ligado a uma interface, somente  os  pacotes  recebidos
              daquela interface particular serão processados pelo socket.

       SO_DEBUG
              Habilita o debugging do socket. Somente permitido para processos
              com a capabilidade CAP_NET_ADMIN ou com id  efetivo  de  usuário
              igual a 0.

       SO_REUSEADDR
              Indica   que   as  regras  usadas  nos  endereços  de  validação
              fornecidos em uma  chamada  de  bind(2)  permitiriam  reusar  os
              endereços  locais.  Para  sockets  PF_INET isso significa que um
              socket pode ser ligado, exceto quando há  um  socket  em  escuta
              ativo  ligado  ao endereço. Quando o socket em escuta é ligado a
              INADDR_ANY com  uma  porta  específica,  então  não  é  possível
              ligá-lo a esta porta para qualquer endereço local.

       SO_TYPE
              Obtém  o  tipo de socket como um inteiro (como SOCK_STREAM).  Só
              pode ser lido com getsockopt.

       SO_DONTROUTE
              Não  envia  através  de  um  gateway,  somente  envia  a   hosts
              conectados  diretamente.  O  mesmo efeito pode ser atingido pela
              configuração do flag MSG_DONTROUTE sobre uma operação de  socket
              send(2).  Espera um flag booleano inteiro.

       SO_BROADCAST
              Seta ou obtém o flag de broadcast. Quando habilitado, os sockets
              de datagrama  recebem  pacotes  enviados  para  um  endereço  de
              broadcast,  e  eles  têm  permissão  para  enviar  pacotes  a um
              endereço de broadcast.  Esta opção não  faz  efeito  em  sockets
              orientados a streams.

       SO_SNDBUF
              Seta  ou  obtém  o  buffer máximo de envio de socket em bytes. O
              valor padrão é selecionado pelo sysctl wmem_default e  o  máximo
              valor permitido é selecionado pelo sysctl wmem_max

       SO_RCVBUF
              Seta  ou obtém o máximo buffer de recepção de socket em bytes. O
              valor default é setado pelo sysctl rmem_default e o máximo valor
              permitido é setado pelo sysctl rmem_max

       SO_LINGER
              Seleciona  ou  obtém  a  opção  SO_LINGER.   O  argumento  é uma
              estrutura linger

              struct linger {
                  int   l_onoff;    /* linger ativo */
                  int   l_linger;   /* quantos segundos para realizar linger */
              };

              Quando habilitado, um close(2) ou um shutdown(2) não  retornarão
              até   que  todas  as  mensagens  para  o  socket  que  estiverem
              enfileiradas tenham sido enviadas com sucesso, ou o  timeout  do
              linger  tenha  sido  atingido. Caso contrário, a chamada retorna
              imediatamente e o fechamento  ocorre  em  background.  Quando  o
              socket  é encerrado como parte de exit(2) , ele sempre realiza o
              linger em background.

       SO_PRIORITY
              Seta a prioridade definida por protocolo para todos os pacotes a
              serem  enviados  sobre  este  socket.  Os usuários de Linux usam
              este valor para ordenar  as  filas  de  rede:  pacotes  com  uma
              prioridade  maior  podem ser processados primeiro, dependendo da
              disciplina de fila do dispositivo selecionado. Para ip(7) , isto
              também configura o campo IP "tipo-de-serviço (TOS)" para pacotes
              de saída.

       SO_ERROR
              Obtém e limpa erros de socket pendentes. Somente válido como  um
              getsockopt.  Espera um inteiro.

SINAIS

       Quando  se escreve para um socket orientado a conexão que foi derrubado
       (pela extremidade local ou pela  remota),  SIGPIPE  é  enviado  para  o
       processo  de escrita e EPIPE é retornado.  O sinal não é enviado quando
       a chamada de escrita especificou o sinalizador MSG_NOSIGNAL

       Quando pedido com o fcntl FIOCSETOWN ou com o ioctl SIOCSPGRP , SIGIO é
       enviado  quando  ocorre  um  evento  de I/O. É possível usar poll(2) ou
       select(2) em um manipulador de sinal para descobrir sobre qual socket o
       evento  ocorreu.   Uma alternativa (em Linux 2.2) é configurar um sinal
       de realtime usando o fnctl F_SETSIG ; o manipulador do sinal  de  tempo
       real  será  chamado  com  o  descritor de arquivo no campo si_fd do seu
       siginfo_t.  Veja fcntl(2) para mais informações.

       Sob certas circunstâncias (por exemplo, múltiplos  processos  acessando
       um   único  socket),  a  condição  que  causou  o  SIGIO  pode  já  ter
       desaparecido quando o processo reagir ao sinal. Se  isso  acontecer,  o
       processo  deveria  esperar  novamente  porque o Linux reenviará o sinal
       mais tarde.

SYSCTLS

       Os sysctls de núcleo para rede de sockets podem ser acessados usando-se
       os arquivos /proc/sys/net/core/* , ou com a interface sysctl(2)

       rmem_default
              contém a configuração padrão, em bytes, do buffer de recepção de
              sockets.

       rmem_max
              contém o tamanho máximo do buffer de  recepção  de  sockets,  em
              bytes,  que  um  usuário  pode  selecionar  pelo uso da opção de
              socket SO_RCVBUF

       wmem_default
              contém a configuração padrão, em bytes, do buffer  de  envio  de
              sockets.

       wmem_max
              contém  o  tamanho  máximo  do buffer de recepção de sockets, em
              bytes, que um usuário pode setar pelo uso  da  opção  de  socket
              SO_SNDBUF

       message_cost and message_burst
              configuram o filtro bucket de token usado para carregar o limite
              de mensagens de atenção causadas por eventos externos à rede.

       netdev_max_backlog
              Número máximo de pacotes na fila global de entrada.

       optmem_max
              Comprimento máximo dos dados ancilares e dos dados  de  controle
              do usuário, como os iovecs por socket.

IOCTLS

       Estes ioctls podem ser acessados usando-se ioctl(2):

              error = ioctl(ip_socket, ioctl_type, &value_result);

       SIOCGSTAMP
              Retorna  um struct timeval com o timestamp de recepção do último
              pacote passado ao usuário. Isto é útil para medidas precisas  do
              tempo  de  "round trip". Veja setitimer(2) para uma descrição de
              struct timeval.

       SIOCSPGRP
              Seta o processo ou grupo de processos para os  quais  se  enviam
              sinais  SIGIO  ou  SIGURG  quando uma operação de I/O assíncrona
              terminou,  ou  quando  dados  urgentes  estão  disponíveis.    O
              argumento  é um ponteiro para pid_t.  Se o argumento é positivo,
              envia os sinais para aquele processo. Se o argumento é negativo,
              envia os sinais ao grupo de processos com o id de valor absoluto
              do argumento.  O processo só pode escolher a si mesmo ou  a  seu
              próprio  grupo de processos para receber sinais, a menos que ele
              tenha a capabilidade CAP_KILL ou um UID efetivo igual a 0.

       FIOASYNC
              Altera o flag O_ASYNC para habilitar ou desabilitar o modo de IO
              assíncrono  do  socket.  Modo  de  IO assíncrono significa que o
              sinal SIGIO , ou os sinais setados com F_SETSIG é raised  quando
              ocorre um novo evento de I/O.

              O argumento é um sinalizador booleano inteiro.

       SIOCGPGRP
              Obtém  o  processo  corrente  ou  grupo de processos que recebem
              sinais SIGIO ou SIGURG , ou 0 quando nenhum foi configurado.

       fcntls válidos:

       FIOCGETOWN
              O mesmo que o ioctl SIOCGPGRP

       FIOCSETOWN
              O mesmo que o ioctl SIOCSPGRP

NOTAS

       O Linux assume que metade do buffer  de  envio/recepção  é  usado  para
       estruturas  internas do kernel; portanto, os sysctls são o dobro do que
       podem ser observados no wire.

PROBLEMAS

       As opções de socket CONFIG_FILTER , SO_ATTACH_FILTER e SO_DETACH_FILTER
       não   são  documentadas.  A  interface  sugerida  para  usá-las  é  via
       biblioteca libpcap.

VERSÕES

       SO_BINDTODEVICE foi introduzido no Linux 2.0.30.  SO_PASSCRED é novo no
       Linux 2.2.  Os sysctls são novos no Linux 2.2.

AUTORES

       Esta página de manual foi escrita por Andi Kleen.

VEJA TAMBÉM

       socket(2), ip(7), setsockopt(2), getsockopt(2), packet(7), ddp(7)

TRADUZIDO POR LDP-BR em 21/08/2000.

       Rubens  de  Jesus  Nogueira  <darkseid99@usa.net>  (tradução)  André L.
       Fassone Canova <lonelywolf@blv.com.br> (revisão)