123456789_123456789_123456789_123456789_123456789_

Module: WEBrick::Utils

Relationships & Source Files
Namespace Children
Classes:
Defined in: lib/webrick/ssl.rb,
lib/webrick/utils.rb

Constant Summary

Class Method Summary

Class Method Details

.create_listeners(address, port, logger = nil) (mod_func)

Creates TCP server sockets bound to address:port and returns them.

It will create IPV4 and IPV6 sockets on all interfaces.

[ GitHub ]

  
# File 'lib/webrick/utils.rb', line 66

def create_listeners(address, port, logger=nil)
  unless port
    raise ArgumentError, "must specify port"
  end
  sockets = Socket.tcp_server_sockets(address, port)
  sockets = sockets.map {|s|
    s.autoclose = false
    ts = TCPServer.for_fd(s.fileno)
    s.close
    ts
  }
  return sockets
end

.create_self_signed_cert(bits, cn, comment) (mod_func)

Creates a self-signed certificate with the given number of bits, the issuer cn and a comment to be stored in the certificate.

[ GitHub ]

  
# File 'lib/webrick/ssl.rb', line 91

def create_self_signed_cert(bits, cn, comment)
  rsa = OpenSSL::PKey::RSA.new(bits){|p, n|
    case p
    when 0; $stderr.putc "."  # BN_generate_prime
    when 1; $stderr.putc "+"  # BN_generate_prime
    when 2; $stderr.putc "*"  # searching good prime,
                              # n = #of try,
                              # but also data from BN_generate_prime
    when 3; $stderr.putc "\n" # found good prime, n==0 - p, n==1 - q,
                              # but also data from BN_generate_prime
    else;   $stderr.putc "*"  # BN_generate_prime
    end
  }
  cert = OpenSSL::X509::Certificate.new
  cert.version = 2
  cert.serial = 1
  name = OpenSSL::X509::Name.new(cn)
  cert.subject = name
  cert.issuer = name
  cert.not_before = Time.now
  cert.not_after = Time.now + (365*24*60*60)
  cert.public_key = rsa.public_key

  ef = OpenSSL::X509::ExtensionFactory.new(nil,cert)
  ef.issuer_certificate = cert
  cert.extensions = [
    ef.create_extension("basicConstraints","CA:FALSE"),
    ef.create_extension("keyUsage", "keyEncipherment"),
    ef.create_extension("subjectKeyIdentifier", "hash"),
    ef.create_extension("extendedKeyUsage", "serverAuth"),
    ef.create_extension("nsComment", comment),
  ]
  aki = ef.create_extension("authorityKeyIdentifier",
                            "keyid:always,issuer:always")
  cert.add_extension(aki)
  cert.sign(rsa, OpenSSL::Digest::SHA1.new)

  return [ cert, rsa ]
end

.getservername (mod_func)

The server hostname

[ GitHub ]

  
# File 'lib/webrick/utils.rb', line 52

def getservername
  host = Socket::gethostname
  begin
    Socket::gethostbyname(host)[0]
  rescue
    host
  end
end

.random_string(len) (mod_func)

Generates a random string of length len

[ GitHub ]

  
# File 'lib/webrick/utils.rb', line 89

def random_string(len)
  rand_max = RAND_CHARS.bytesize
  ret = ""
  len.times{ ret << RAND_CHARS[rand(rand_max)] }
  ret
end

.set_close_on_exec(io) (mod_func)

Sets the close on exec flag for io

[ GitHub ]

  
# File 'lib/webrick/utils.rb', line 30

def set_close_on_exec(io)
  if defined?(Fcntl::FD_CLOEXEC)
    io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
  end
end

.set_non_blocking(io) (mod_func)

Sets IO operations on io to be non-blocking

[ GitHub ]

  
# File 'lib/webrick/utils.rb', line 19

def set_non_blocking(io)
  flag = File::NONBLOCK
  if defined?(Fcntl::F_GETFL)
    flag |= io.fcntl(Fcntl::F_GETFL)
  end
  io.fcntl(Fcntl::F_SETFL, flag)
end

.su(user) (mod_func)

Changes the process's uid and gid to the ones of user

[ GitHub ]

  
# File 'lib/webrick/utils.rb', line 39

def su(user)
  if pw = Etc.getpwnam(user)
    Process::initgroups(user, pw.gid)
    Process::Sys::setgid(pw.gid)
    Process::Sys::setuid(pw.uid)
  else
    warn("WEBrick::Utils::su doesn't work on this platform")
  end
end

.timeout(seconds, exception = Timeout::Error) (mod_func)

Executes the passed block and raises exception if execution takes more than seconds.

If seconds is zero or nil, simply executes the block

[ GitHub ]

  
# File 'lib/webrick/utils.rb', line 218

def timeout(seconds, exception=Timeout::Error)
  return yield if seconds.nil? or seconds.zero?
  # raise ThreadError, "timeout within critical session" if Thread.critical
  id = TimeoutHandler.register(seconds, exception)
  begin
    yield(seconds)
  ensure
    TimeoutHandler.cancel(id)
  end
end