Unix servers offer a rich set of features that make them a popular choice for critical computing tasks. Some of the key features include:

• Multiuser and Multitasking: Unix servers support multiple users and allow concurrent execution of various processes, enabling efficient resource utilization.
• Command-Line Interface (CLI): Unix servers provide a powerful command-line interface, allowing administrators to perform complex tasks efficiently.
• Modularity and Extensibility: Unix servers are built with a modular design, making it easy to add or modify functionalities without disrupting the core system.
• Networking Capabilities: Unix servers have robust networking capabilities, allowing seamless communication between different systems, making them ideal for distributed computing environments.
• Support for Scripting: Unix servers provide a wide range of scripting languages (e.g., Shell, Perl, Python) that enable automation and customization of system tasks.
• Compatibility: Unix servers are designed to be highly portable and compatible across different hardware architectures, ensuring software can run on various Unix-based systems.

Unix servers offer numerous advantages over other operating systems, making them a preferred choice for many organizations:

• Stability and Reliability: Unix servers are renowned for their stability and reliability, with uptime measured in months or even years, ensuring uninterrupted operation for critical applications.
• Security: Unix servers have a robust security model, incorporating permissions, access controls, and encryption mechanisms, making them highly resistant to unauthorized access and attacks.
• Performance and Efficiency: Unix servers are optimized for performance and resource efficiency, delivering fast and responsive systems even under heavy workloads.
• Community and Support: Unix has a vibrant community of developers and users who contribute to its development, provide support, and share knowledge, ensuring a wealth of resources and expertise.
• Cost-Effectiveness: Unix servers offer cost-effective solutions due to their ability to run on a wide range of hardware, scalability options, and long-term stability, reducing overall ownership costs.

Unix servers find application in various domains, including:

• Web Hosting: Unix servers are widely used as web servers due to their stability, security features, and compatibility with popular web technologies.
• Database Management: Many database management systems, such as Oracle and MySQL, run on Unix servers, leveraging their robustness and performance.
• Scientific Computing: Unix servers are extensively used in scientific research, simulations, and data analysis, thanks to their powerful computing capabilities.
• Network Infrastructure: Unix servers serve as core components in network infrastructure, providing routing, security, and network services.
• **Enterprise

Unix Operating System: A Foundation for Powerful Computing

Welcome to our website's page dedicated to the Unix operating system. In this section, we will provide an overview of Unix, its history, key features, and its significance in the world of computing. Whether you're a seasoned Unix user or new to this robust operating system, this page aims to provide you with valuable insights and information.

Table of Contents:

1. Introduction to Unix
2. History of Unix
3. Key Features of Unix
4. Unix Variants
5. Applications and Uses
6. Unix Philosophy
7. Conclusion

Unix is a powerful and versatile operating system developed in the late 1960s at Bell Labs by Ken Thompson, Dennis Ritchie, and their colleagues. It was designed to provide a flexible and efficient computing environment for both developers and users. Unix is characterized by its modular design, robustness, and support for multitasking and multiuser capabilities.

Unix's origins can be traced back to the early days of computing. It was initially developed as an internal project at Bell Labs and later released to external users, universities, and research institutions. Over the years, Unix has gone through various iterations, with different versions and variants emerging, such as BSD Unix, System V, and more recently, Linux.

Unix offers a plethora of features that have contributed to its enduring popularity and success. Some of the key features include:

• Multitasking and Multiuser: Unix allows multiple users to simultaneously run processes and perform tasks, providing efficient resource management and user isolation.
• Shell and Command-Line Interface (CLI): Unix pioneered the use of a command-line interface, offering a powerful shell that enables users to interact with the system and execute commands efficiently.
• Modularity and Portability: Unix's modular design allows for easy extensibility and customization. Moreover, it has been ported to various hardware architectures, making it highly portable across different systems.
• File System Hierarchy: Unix organizes files and directories in a hierarchical structure, with a root directory as the starting point. This design simplifies file management and navigation.
• Networking and Interoperability: Unix has built-in support for networking protocols, enabling seamless communication between Unix-based systems and interoperability with other platforms.
• Security and Permissions: Unix provides a robust security model with file permissions, access controls, and user management, ensuring data integrity and protection against unauthorized access.

Throughout its history, Unix has spawned various variants and distributions, each with its unique characteristics and focus. Some notable Unix variants include:

• BSD Unix: BSD (Berkeley Software Distribution) Unix emerged from the University of California, Berkeley, and introduced many enhancements, such as the TCP/IP networking stack and the virtual file system.
• System V: AT&T's System V Unix, released in the early 1980s, became one of the most widely used versions of Unix, incorporating new features and standardizing the Unix ecosystem.
• Linux: Linux, although not a direct descendant of the original Unix codebase, is a Unix-like operating system that shares many design principles and features. It has gained immense popularity and is used in various domains, from personal computers to large-scale servers.

Unix has found applications in numerous domains and industries, thanks to its stability, scalability, and versatility. Some common uses include:

• Server Operating System: Unix serves as the foundation for many server environments, powering web servers, database servers, file servers, and network infrastructure.
• Scientific Computing and Research: Unix is widely used in scientific research, simulations, data analysis, and modeling, providing a powerful and efficient computing environment for researchers and scientists.
• Software Development: Unix offers a rich ecosystem of development tools, compilers, and libraries, making it a preferred choice for software development and programming tasks.
• Embedded Systems: Unix-based operating systems are used in various embedded systems, such as routers, switches, telecommunications equipment, and IoT devices, due to their stability and flexibility.
• Education: Unix is often taught in computer science and engineering programs to introduce students to fundamental operating system concepts and provide hands-on experience.

Unix is guided by a set of principles known as the "Unix philosophy," which emphasizes simplicity, modularity, and the concept of "do one thing and do it well." This philosophy has influenced the development of many Unix tools and software, promoting efficient and focused solutions.

Unix stands as a foundational pillar in the world of operating systems, providing a robust, scalable, and versatile environment for a wide range of computing needs. Its rich history, key features, and extensive ecosystem have made it an enduring choice for both professionals and enthusiasts alike. Whether you're exploring Unix for the first time or continuing your Unix journey, we hope this page has provided you with valuable insights into the power and significance of Unix in the computing landscape.

UNIXServer represents a UNIX domain stream server socket.

new(path) => unixserver

Creates a new UNIX server socket bound to path.

require 'socket'



serv = UNIXServer.new("/tmp/sock")

s = serv.accept

p s.read

accept => unixsocket

Accepts an incoming connection. It returns a new UNIXSocket object.

UNIXServer.open("/tmp/sock") {|serv|

  UNIXSocket.open("/tmp/sock") {|c|

    s = serv.accept

    s.puts "hi"

    s.close

    p c.read #=> "hi\n"

  }

}

accept_nonblock([options]) => unixsocket

Accepts an incoming connection using accept(2) after O_NONBLOCK is set for the underlying file descriptor. It returns an accepted UNIXSocket for the incoming connection.

require 'socket'

serv = UNIXServer.new("/tmp/sock")

begin # emulate blocking accept

  sock = serv.accept_nonblock

rescue IO::WaitReadable, Errno::EINTR

  IO.select([serv])

  retry

end

# sock is an accepted socket.

Refer to Socket#accept for the exceptions that may be thrown if the call to #accept_nonblock fails.

#accept_nonblock may raise any error corresponding to accept(2) failure, including Errno::EWOULDBLOCK.

If the exception is Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::ECONNABORTED or Errno::EPROTO, it is extended by IO::WaitReadable. So IO::WaitReadable can be used to rescue the exceptions for retrying accept_nonblock.

By specifying a keyword argument exception to false, you can indicate that #accept_nonblock should not raise an IO::WaitReadable exception, but return the symbol :wait_readable instead.

• #accept
• Socket#accept

listen( int ) => 0

Listens for connections, using the specified int as the backlog. A call to listen only applies if the socket is of type SOCK_STREAM or SOCK_SEQPACKET.

• backlog - the maximum length of the queue for pending connections.

require 'socket'

include Socket::Constants

socket = Socket.new( AF_INET, SOCK_STREAM, 0 )

sockaddr = Socket.pack_sockaddr_in( 2200, 'localhost' )

socket.bind( sockaddr )

socket.listen( 5 )

require 'socket'

include Socket::Constants

socket = Socket.new( AF_INET, SOCK_STREAM, 0 )

socket.listen( 1 )

On unix based systems the above will work because a new sockaddr struct is created on the address ADDR_ANY, for an arbitrary port number as handed off by the kernel. It will not work on Windows, because Windows requires that the socket is bound by calling bind before it can listen.

If the backlog amount exceeds the implementation-dependent maximum queue length, the implementation's maximum queue length will be used.

On unix-based based systems the following system exceptions may be raised if the call to listen fails:

• Errno::EBADF - the socket argument is not a valid file descriptor
• Errno::EDESTADDRREQ - the socket is not bound to a local address, and the protocol does not support listening on an unbound socket
• Errno::EINVAL - the socket is already connected
• Errno::ENOTSOCK - the socket argument does not refer to a socket
• Errno::EOPNOTSUPP - the socket protocol does not support listen
• Errno::EACCES - the calling process does not have appropriate privileges
• Errno::EINVAL - the socket has been shut down
• Errno::ENOBUFS - insufficient resources are available in the system to complete the call

On Windows systems the following system exceptions may be raised if the call to listen fails:

• Errno::ENETDOWN - the network is down
• Errno::EADDRINUSE - the socket's local address is already in use. This usually occurs during the execution of bind but could be delayed if the call to bind was to a partially wildcard address (involving ADDR_ANY) and if a specific address needs to be committed at the time of the call to listen
• Errno::EINPROGRESS - a Windows Sockets 1.1 call is in progress or the service provider is still processing a callback function
• Errno::EINVAL - the socket has not been bound with a call to bind.
• Errno::EISCONN - the socket is already connected
• Errno::EMFILE - no more socket descriptors are available
• Errno::ENOBUFS - no buffer space is available
• Errno::ENOTSOC - socket is not a socket
• Errno::EOPNOTSUPP - the referenced socket is not a type that supports the listen method

• listen manual pages on unix-based systems
• listen function in Microsoft's Winsock functions reference

sysaccept => file_descriptor

Accepts a new connection. It returns the new file descriptor which is an integer.

UNIXServer.open("/tmp/sock") {|serv|

  UNIXSocket.open("/tmp/sock") {|c|

    fd = serv.sysaccept

    s = IO.new(fd)

    s.puts "hi"

    s.close

    p c.read #=> "hi\n"

  }

}

This page was generated for Ruby 2.4.0

Ruby-doc.org is a service of James Britt and Neurogami, an erratic source of art, music, and technology.

Generated with Ruby-doc Rdoc Generator 0.44.2.

• 2.4.0
• Downloads

• socket/lib/socket.rb
• socket/udpsocket.c

IPSocket

• ::new
• #bind
• #connect
• #recvfrom_nonblock
• #send

• Addrinfo
• BasicSocket
• IPSocket
• Object
• SOCKSSocket
• Socket
• Socket::AncillaryData
• Socket::Ifaddr
• Socket::Option
• Socket::UDPSource
• SocketError
• TCPServer
• TCPSocket
• UDPSocket
• UNIXServer
• UNIXSocket

UDPSocket represents a UDP/IP socket.

new([address_family]) => socketclick to toggle source

Creates a new UDPSocket object.

address_family should be an integer, a string or a symbol: Socket::AF_INET, "AF_INET", :INET, etc.

require 'socket'



UDPSocket.new                   #=> #<UDPSocket:fd 3>

UDPSocket.new(Socket::AF_INET6) #=> #<UDPSocket:fd 4>

bind(host, port) #=> 0

Binds udpsocket to host:port.

u1 = UDPSocket.new

u1.bind("127.0.0.1", 4913)

u1.send "message-to-self", 0, "127.0.0.1", 4913

p u1.recvfrom(10) #=> ["message-to", ["AF_INET", 4913, "localhost", "127.0.0.1"]]

connect(host, port) => 0

Connects udpsocket to host:port.

This makes possible to send without destination address.

u1 = UDPSocket.new

u1.bind("127.0.0.1", 4913)

u2 = UDPSocket.new

u2.connect("127.0.0.1", 4913)

u2.send "uuuu", 0

p u1.recvfrom(10) #=> ["uuuu", ["AF_INET", 33230, "localhost", "127.0.0.1"]]

recvfrom_nonblock(maxlen [, flags[, outbuf [, options]]]) => [mesg, sender_inet_addr]

Receives up to maxlen bytes from udpsocket using recvfrom(2) after O_NONBLOCK is set for the underlying file descriptor. flags is zero or more of the MSG_ options. The first element of the results, mesg, is the data received. The second element, sender_inet_addr, is an array to represent the sender address.

When recvfrom(2) returns 0, Socket#recvfrom_nonblock returns an empty string as data. It means an empty packet.

• maxlen - the number of bytes to receive from the socket
• flags - zero or more of the MSG_ options
• outbuf - destination String buffer
• options - keyword hash, supporting `exception: false`

require 'socket'

s1 = UDPSocket.new

s1.bind("127.0.0.1", 0)

s2 = UDPSocket.new

s2.bind("127.0.0.1", 0)

s2.connect(*s1.addr.values_at(3,1))

s1.connect(*s2.addr.values_at(3,1))

s1.send "aaa", 0

begin # emulate blocking recvfrom

  p s2.recvfrom_nonblock(10)  #=> ["aaa", ["AF_INET", 33302, "localhost.localdomain", "127.0.0.1"]]

rescue IO::WaitReadable

  IO.select([s2])

  retry

end

Refer to Socket#recvfrom for the exceptions that may be thrown if the call to recvfrom_nonblock fails.

#recvfrom_nonblock may raise any error corresponding to recvfrom(2) failure, including Errno::EWOULDBLOCK.

If the exception is Errno::EWOULDBLOCK or Errno::EAGAIN, it is extended by IO::WaitReadable. So IO::WaitReadable can be used to rescue the exceptions for retrying recvfrom_nonblock.

By specifying a keyword argument exception to false, you can indicate that #recvfrom_nonblock should not raise an IO::WaitReadable exception, but return the symbol :wait_readable instead.

• Socket#recvfrom

send(mesg, flags, host, port) => numbytes_sentsend(mesg, flags, sockaddr_to) => numbytes_sentsend(mesg, flags) => numbytes_sent

Sends mesg via udpsocket.

flags should be a bitwise OR of Socket::MSG_* constants.

u1 = UDPSocket.new

u1.bind("127.0.0.1", 4913)



u2 = UDPSocket.new

u2.send "hi", 0, "127.0.0.1", 4913



mesg, addr = u1.recvfrom(10)

u1.send mesg, 0, addr[3], addr[1]



p u2.recv(100) #=> "hi"

This page was generated for Ruby 2.4.0