module WEBrick::Utils

Constants

RAND_CHARS: Characters used to generate random strings

Public Class Methods

create_listeners(address, port, logger=nil) click to toggle source

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

It will create IPV4 and IPV6 sockets on all interfaces.

# File lib/webrick/utils.rb, line 71
def create_listeners(address, port, logger=nil)
  unless port
    raise ArgumentError, "must specify port"
  end
  res = Socket::getaddrinfo(address, port,
                            Socket::AF_UNSPEC,   # address family
                            Socket::SOCK_STREAM, # socket type
                            0,                   # protocol
                            Socket::AI_PASSIVE)  # flag
  last_error = nil
  sockets = []
  res.each{|ai|
    begin
      logger.debug("TCPServer.new(#{ai[3]}, #{port})") if logger
      sock = TCPServer.new(ai[3], port)
      port = sock.addr[1] if port == 0
      Utils::set_close_on_exec(sock)
      sockets << sock
    rescue => ex
      logger.warn("TCPServer Error: #{ex}") if logger
      last_error  = ex
    end
  }
  raise last_error if sockets.empty?
  return sockets
end

create_self_signed_cert(bits, cn, comment) click to toggle source

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

# 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() click to toggle source

The server hostname

# File lib/webrick/utils.rb, line 57
def getservername
  host = Socket::gethostname
  begin
    Socket::gethostbyname(host)[0]
  rescue
    host
  end
end

random_string(len) click to toggle source

Generates a random string of length len

# File lib/webrick/utils.rb, line 107
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) click to toggle source

Sets the close on exec flag for io

# File lib/webrick/utils.rb, line 34
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) click to toggle source

Sets IO operations on io to be non-blocking

# File lib/webrick/utils.rb, line 23
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) click to toggle source

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

# File lib/webrick/utils.rb, line 43
def su(user)
  if defined?(Etc)
    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) { || ... } click to toggle source

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

If seconds is zero or nil, simply executes the block

# File lib/webrick/utils.rb, line 234
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

Private Instance Methods