class BasicSocket

Ruft das globale Flag do_not_reverse_lookup ab.

BasicSocket.do_not_reverse_lookup  #=> false

Setzt das globale Flag do_not_reverse_lookup.

Das Flag wird für den anfänglichen Wert von do_not_reverse_lookup für jeden Socket verwendet.

s1 = TCPSocket.new("localhost", 80)
p s1.do_not_reverse_lookup                 #=> true
BasicSocket.do_not_reverse_lookup = false
s2 = TCPSocket.new("localhost", 80)
p s2.do_not_reverse_lookup                 #=> false
p s1.do_not_reverse_lookup                 #=> true

Gibt ein Socket-Objekt zurück, das den Dateideskriptor fd enthält.

# If invoked by inetd, STDIN/STDOUT/STDERR is a socket.
STDIN_SOCK = Socket.for_fd(STDIN.fileno)
p STDIN_SOCK.remote_address

Verhindert weitere Lesevorgänge über den shutdown-Systemaufruf.

s1, s2 = UNIXSocket.pair
s1.close_read
s2.puts #=> Broken pipe (Errno::EPIPE)

Verhindert weitere Schreibvorgänge über den shutdown-Systemaufruf.

UNIXSocket.pair {|s1, s2|
  s1.print "ping"
  s1.close_write
  p s2.read        #=> "ping"
  s2.print "pong"
  s2.close
  p s1.read        #=> "pong"
}

Gibt eine Adresse des Sockets zurück, die für die Verbindung auf dem lokalen Rechner geeignet ist.

Diese Methode gibt self.local_address zurück, mit folgenden Ausnahmen.

• IPv4-unspezifizierte Adresse (0.0.0.0) wird durch IPv4-Loopback-Adresse (127.0.0.1) ersetzt.

• IPv6-unspezifizierte Adresse (::) wird durch IPv6-Loopback-Adresse (::1) ersetzt.

Wenn die lokale Adresse nicht für eine Verbindung geeignet ist, wird SocketError ausgelöst. IPv4- und IPv6-Adressen mit Port 0 sind nicht für Verbindungen geeignet. Unix-Domain-Sockets ohne Pfad sind nicht für Verbindungen geeignet.

Addrinfo.tcp("0.0.0.0", 0).listen {|serv|
  p serv.connect_address #=> #<Addrinfo: 127.0.0.1:53660 TCP>
  serv.connect_address.connect {|c|
    s, _ = serv.accept
    p [c, s] #=> [#<Socket:fd 4>, #<Socket:fd 6>]
  }
}

Ruft das Flag do_not_reverse_lookup des basicsocket ab.

require 'socket'

BasicSocket.do_not_reverse_lookup = false
TCPSocket.open("www.ruby-lang.org", 80) {|sock|
  p sock.do_not_reverse_lookup      #=> false
}
BasicSocket.do_not_reverse_lookup = true
TCPSocket.open("www.ruby-lang.org", 80) {|sock|
  p sock.do_not_reverse_lookup      #=> true
}

Setzt das Flag do_not_reverse_lookup des basicsocket.

TCPSocket.open("www.ruby-lang.org", 80) {|sock|
  p sock.do_not_reverse_lookup       #=> true
  p sock.peeraddr                    #=> ["AF_INET", 80, "221.186.184.68", "221.186.184.68"]
  sock.do_not_reverse_lookup = false
  p sock.peeraddr                    #=> ["AF_INET", 80, "carbon.ruby-lang.org", "54.163.249.195"]
}

Gibt den Benutzer und die Gruppe des Peers des UNIX-Sockets zurück. Das Ergebnis ist ein zweielementiges Array, das die effektive UID und die effektive GID enthält.

Socket.unix_server_loop("/tmp/sock") {|s|
  begin
    euid, egid = s.getpeereid

    # Check the connected client is myself or not.
    next if euid != Process.uid

    # do something about my resource.

  ensure
    s.close
  end
}

Gibt die Remote-Adresse des Sockets als sockaddr-String zurück.

TCPServer.open("127.0.0.1", 1440) {|serv|
  c = TCPSocket.new("127.0.0.1", 1440)
  s = serv.accept
  p s.getpeername #=> "\x02\x00\x82u\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
}

Wenn ein Addrinfo-Objekt einem Binärstring vorgezogen wird, verwenden Sie BasicSocket#remote_address.

Gibt die lokale Adresse des Sockets als sockaddr-String zurück.

TCPServer.open("127.0.0.1", 15120) {|serv|
  p serv.getsockname #=> "\x02\x00;\x10\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
}

Wenn ein Addrinfo-Objekt einem Binärstring vorgezogen wird, verwenden Sie BasicSocket#local_address.

Ruft eine Socket-Option ab. Diese sind protokoll- und systemspezifisch. Informationen finden Sie in der Dokumentation Ihres lokalen Systems. Die Option wird als Socket::Option-Objekt zurückgegeben.

Parameter

• level ist eine Ganzzahl, normalerweise eine der SOL_-Konstanten wie Socket::SOL_SOCKET oder eine Protokollebene. Ein String oder Symbol des Namens, möglicherweise ohne Präfix, wird ebenfalls akzeptiert.

• optname ist eine Ganzzahl, normalerweise eine der SO_-Konstanten wie Socket::SO_REUSEADDR. Ein String oder Symbol des Namens, möglicherweise ohne Präfix, wird ebenfalls akzeptiert.

Beispiele

Einige Socket-Optionen sind Ganzzahlen mit booleschen Werten. In diesem Fall kann getsockopt wie folgt aufgerufen werden

reuseaddr = sock.getsockopt(:SOCKET, :REUSEADDR).bool

optval = sock.getsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR)
optval = optval.unpack "i"
reuseaddr = optval[0] == 0 ? false : true

Einige Socket-Optionen sind Ganzzahlen mit numerischen Werten. In diesem Fall kann getsockopt wie folgt aufgerufen werden

ipttl = sock.getsockopt(:IP, :TTL).int

optval = sock.getsockopt(Socket::IPPROTO_IP, Socket::IP_TTL)
ipttl = optval.unpack1("i")

Optionswerte können Strukturen sein. Deren Dekodierung kann komplex sein, da sie die Untersuchung Ihrer System-Header erfordert, um die korrekte Definition zu ermitteln. Ein Beispiel ist eine +struct linger+, die in Ihren System-Headern wie folgt definiert sein kann:

struct linger {
  int l_onoff;
  int l_linger;
};

In diesem Fall kann getsockopt wie folgt aufgerufen werden

# Socket::Option knows linger structure.
onoff, linger = sock.getsockopt(:SOCKET, :LINGER).linger

optval =  sock.getsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER)
onoff, linger = optval.unpack "ii"
onoff = onoff == 0 ? false : true

Gibt ein Addrinfo-Objekt für die lokale Adresse zurück, die mit getsockname abgerufen wurde.

Beachten Sie, dass addrinfo.protocol mit 0 gefüllt ist.

TCPSocket.open("www.ruby-lang.org", 80) {|s|
  p s.local_address #=> #<Addrinfo: 192.168.0.129:36873 TCP>
}

TCPServer.open("127.0.0.1", 1512) {|serv|
  p serv.local_address #=> #<Addrinfo: 127.0.0.1:1512 TCP>
}

Empfängt eine Nachricht.

maxlen ist die maximale Anzahl der zu empfangenden Bytes.

flags sollte eine bitweise OR-Verknüpfung der Socket::MSG_* Konstanten sein.

outbuf enthält nach dem Methodenaufruf nur die empfangenen Daten, auch wenn es am Anfang nicht leer ist.

UNIXSocket.pair {|s1, s2|
  s1.puts "Hello World"
  p s2.recv(4)                     #=> "Hell"
  p s2.recv(4, Socket::MSG_PEEK)   #=> "o Wo"
  p s2.recv(4)                     #=> "o Wo"
  p s2.recv(10)                    #=> "rld\n"
}

Empfängt bis zu maxlen Bytes vom socket mit recvfrom(2), nachdem für den zugrundeliegenden Dateideskriptor O_NONBLOCK gesetzt wurde. flags ist Null oder mehr der MSG_-Optionen. Das Ergebnis, mesg, sind die empfangenen Daten.

Wenn recvfrom(2) 0 zurückgibt, gibt Socket#recv_nonblock nil zurück. In den meisten Fällen bedeutet dies, dass die Verbindung geschlossen wurde, aber bei UDP-Verbindungen kann dies bedeuten, dass ein leeres Paket empfangen wurde, da die zugrundeliegende API es unmöglich macht, diese beiden Fälle zu unterscheiden.

Parameter

• maxlen - die Anzahl der Bytes, die vom Socket empfangen werden sollen

• flags - null oder mehr der MSG_-Optionen.

• buf - Ziel-String-Puffer

• options - Keyword-Hash, unterstützt 'exception: false`

Beispiel

serv = TCPServer.new("127.0.0.1", 0)
af, port, host, addr = serv.addr
c = TCPSocket.new(addr, port)
s = serv.accept
c.send "aaa", 0
begin # emulate blocking recv.
  p s.recv_nonblock(10) #=> "aaa"
rescue IO::WaitReadable
  IO.select([s])
  retry
end

Beziehen Sie sich auf Socket#recvfrom für die Ausnahmen, die ausgelöst werden können, wenn der Aufruf von recv_nonblock fehlschlägt.

BasicSocket#recv_nonblock kann jede Ausnahme auslösen, die einem recvfrom(2)-Fehler entspricht, einschließlich Errno::EWOULDBLOCK.

Wenn die Ausnahme Errno::EWOULDBLOCK oder Errno::EAGAIN ist, wird sie von IO::WaitReadable erweitert. Daher kann IO::WaitReadable zum Abfangen der Ausnahmen für das Wiederholen von recv_nonblock verwendet werden.

Durch die Angabe eines Keyword-Arguments exception auf false können Sie angeben, dass recv_nonblock keine IO::WaitReadable-Ausnahme auslösen, sondern das Symbol :wait_readable zurückgeben soll.

Siehe

• Socket#recvfrom

recvmsg empfängt eine Nachricht über den recvmsg(2)-Systemaufruf blockierend.

maxmesglen ist die maximale Länge von mesg, die empfangen werden soll.

flags ist die bitweise OR von MSG_* Konstanten wie Socket::MSG_PEEK.

maxcontrollen ist die maximale Länge von Controls (Ancillary Data), die empfangen werden sollen.

opts ist ein Options-Hash. Derzeit ist :scm_rights=>bool die einzige Option.

:scm_rights Option gibt an, dass die Anwendung eine SCM_RIGHTS Control-Nachricht erwartet. Wenn der Wert nil oder false ist, erwartet die Anwendung keine SCM_RIGHTS Control-Nachricht. In diesem Fall schließt recvmsg die übergebenen Dateideskriptoren sofort. Dies ist das Standardverhalten.

Wenn der Wert :scm_rights weder nil noch false ist, erwartet die Anwendung eine SCM_RIGHTS Control-Nachricht. In diesem Fall erstellt recvmsg IO-Objekte für jeden Dateideskriptor für die Methode Socket::AncillaryData#unix_rights.

Der Rückgabewert ist ein 4-elementiges Array.

mesg ist ein String der empfangenen Nachricht.

sender_addrinfo ist die Sender-Socket-Adresse für verbindungslose Sockets. Es ist ein Addrinfo-Objekt. Für verbindungsorientierte Sockets wie TCP ist sender_addrinfo plattformabhängig.

rflags sind Flags der empfangenen Nachricht, die die bitweise OR von MSG_* Konstanten wie Socket::MSG_TRUNC darstellen. Sie ist nil, wenn das System einen alten recvmsg-Systemaufruf nach dem Stil 4.3BSD verwendet.

controls sind Ancillary Data, ein Array von Socket::AncillaryData-Objekten wie z. B.

#<Socket::AncillaryData: AF_UNIX SOCKET RIGHTS 7>

maxmesglen und maxcontrollen können nil sein. In diesem Fall wird der Puffer vergrößert, bis die Nachricht nicht mehr abgeschnitten ist. Intern wird MSG_PEEK verwendet. Puffer voll und MSG_CTRUNC werden auf Abschneiden geprüft.

recvmsg kann zur Implementierung von recv_io wie folgt verwendet werden

mesg, sender_sockaddr, rflags, *controls = sock.recvmsg(:scm_rights=>true)
controls.each {|ancdata|
  if ancdata.cmsg_is?(:SOCKET, :RIGHTS)
    return ancdata.unix_rights[0]
  end
}

recvmsg empfängt eine Nachricht über den recvmsg(2)-Systemaufruf nicht-blockierend.

Es ist ähnlich wie BasicSocket#recvmsg, aber das Nicht-Blockierungsflag wird vor dem Systemaufruf gesetzt und der Systemaufruf wird nicht wiederholt.

Durch die Angabe eines Keyword-Arguments exception auf false können Sie angeben, dass recvmsg_nonblock keine IO::WaitReadable-Ausnahme auslösen, sondern das Symbol :wait_readable zurückgeben soll.

Gibt ein Addrinfo-Objekt für die Remote-Adresse zurück, die mit getpeername abgerufen wurde.

Beachten Sie, dass addrinfo.protocol mit 0 gefüllt ist.

TCPSocket.open("www.ruby-lang.org", 80) {|s|
  p s.remote_address #=> #<Addrinfo: 221.186.184.68:80 TCP>
}

TCPServer.open("127.0.0.1", 1728) {|serv|
  c = TCPSocket.new("127.0.0.1", 1728)
  s = serv.accept
  p s.remote_address #=> #<Addrinfo: 127.0.0.1:36504 TCP>
}

sendet mesg über basicsocket.

mesg sollte ein String sein.

flags sollte eine bitweise OR-Verknüpfung der Socket::MSG_* Konstanten sein.

dest_sockaddr sollte ein gepackter sockaddr-String oder ein addrinfo sein.

TCPSocket.open("localhost", 80) {|s|
  s.send "GET / HTTP/1.0\r\n\r\n", 0
  p s.read
}

sendmsg sendet eine Nachricht über den sendmsg(2)-Systemaufruf blockierend.

mesg ist der zu sendende String.

flags ist die bitweise OR von MSG_* Konstanten wie Socket::MSG_OOB.

dest_sockaddr ist die Ziel-Socket-Adresse für verbindungslose Sockets. Es sollte ein sockaddr sein, z. B. das Ergebnis von Socket.sockaddr_in. Ein Addrinfo-Objekt kann ebenfalls verwendet werden.

controls ist eine Liste von Ancillary Data. Das Element von controls sollte ein Socket::AncillaryData oder ein 3-elementiges Array sein. Das 3-elementige Array sollte cmsg_level, cmsg_type und data enthalten.

Der Rückgabewert, numbytes_sent, ist eine Ganzzahl, die die Anzahl der gesendeten Bytes angibt.

sendmsg kann zur Implementierung von send_io wie folgt verwendet werden

# use Socket::AncillaryData.
ancdata = Socket::AncillaryData.int(:UNIX, :SOCKET, :RIGHTS, io.fileno)
sock.sendmsg("a", 0, nil, ancdata)

# use 3-element array.
ancdata = [:SOCKET, :RIGHTS, [io.fileno].pack("i!")]
sock.sendmsg("\0", 0, nil, ancdata)

sendmsg_nonblock sendet eine Nachricht über den sendmsg(2)-Systemaufruf nicht-blockierend.

Es ist ähnlich wie BasicSocket#sendmsg, aber das Nicht-Blockierungsflag wird vor dem Systemaufruf gesetzt und der Systemaufruf wird nicht wiederholt.

Durch die Angabe eines Keyword-Arguments exception auf false können Sie angeben, dass sendmsg_nonblock keine IO::WaitWritable-Ausnahme auslösen, sondern das Symbol :wait_writable zurückgeben soll.

Setzt eine Socket-Option. Diese sind protokoll- und systemspezifisch. Informationen finden Sie in der Dokumentation Ihres lokalen Systems.

Parameter

• level ist eine Ganzzahl, normalerweise eine der SOL_-Konstanten wie Socket::SOL_SOCKET oder eine Protokollebene. Ein String oder Symbol des Namens, möglicherweise ohne Präfix, wird ebenfalls akzeptiert.

• optname ist eine Ganzzahl, normalerweise eine der SO_-Konstanten wie Socket::SO_REUSEADDR. Ein String oder Symbol des Namens, möglicherweise ohne Präfix, wird ebenfalls akzeptiert.

• optval ist der Wert der Option. Er wird an das zugrundeliegende setsockopt() als Zeiger auf eine bestimmte Anzahl von Bytes übergeben. Wie dies geschieht, hängt vom Typ ab.

  • Integer: Der Wert wird einer Ganzzahl zugewiesen, und ein Zeiger auf die Ganzzahl wird mit der Länge sizeof(int) übergeben.

  • true oder false: 1 oder 0 (jeweils) wird einer Ganzzahl zugewiesen, und die Ganzzahl wird wie für einen Integer übergeben. Beachten Sie, dass false, nicht nil, übergeben werden muss.

  • String: Die Daten und die Länge des Strings werden an den Socket übergeben.

• socketoption ist eine Instanz von Socket::Option

Beispiele

Einige Socket-Optionen sind Ganzzahlen mit booleschen Werten. In diesem Fall kann setsockopt wie folgt aufgerufen werden

sock.setsockopt(:SOCKET, :REUSEADDR, true)
sock.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
sock.setsockopt(Socket::Option.bool(:INET, :SOCKET, :REUSEADDR, true))

Einige Socket-Optionen sind Ganzzahlen mit numerischen Werten. In diesem Fall kann setsockopt wie folgt aufgerufen werden

sock.setsockopt(:IP, :TTL, 255)
sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, 255)
sock.setsockopt(Socket::Option.int(:INET, :IP, :TTL, 255))

Optionswerte können Strukturen sein. Deren Übergabe kann komplex sein, da sie die Untersuchung Ihrer System-Header erfordert, um die korrekte Definition zu ermitteln. Ein Beispiel ist ein ip_mreq, das in Ihren System-Headern wie folgt definiert sein kann:

struct ip_mreq {
  struct  in_addr imr_multiaddr;
  struct  in_addr imr_interface;
};

In diesem Fall kann setsockopt wie folgt aufgerufen werden

optval = IPAddr.new("224.0.0.251").hton +
         IPAddr.new(Socket::INADDR_ANY, Socket::AF_INET).hton
sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, optval)

Ruft den shutdown(2)-Systemaufruf auf.

s.shutdown(Socket::SHUT_RD) verhindert weitere Lesevorgänge.

s.shutdown(Socket::SHUT_WR) verhindert weitere Schreibvorgänge.

s.shutdown(Socket::SHUT_RDWR) verhindert weitere Lese- und Schreibvorgänge.

how kann ein Symbol oder ein String sein

• :RD, :SHUT_RD, “RD” und “SHUT_RD” werden als Socket::SHUT_RD akzeptiert.

• :WR, :SHUT_WR, “WR” und “SHUT_WR” werden als Socket::SHUT_WR akzeptiert.

• :RDWR, :SHUT_RDWR, “RDWR” und “SHUT_RDWR” werden als Socket::SHUT_RDWR akzeptiert.

  UNIXSocket.pair {|s1, s2|

  s1.puts "ping"
  s1.shutdown(:WR)
  p s2.read          #=> "ping\n"
  s2.puts "pong"
  s2.close
  p s1.read          #=> "pong\n"
  

  }