# File lib/webrick/utils.rb, line 59
59:     def create_listeners(address, port, logger=nil)
60:       unless port
61:         raise ArgumentError, "must specify port"
62:       end
63:       res = Socket::getaddrinfo(address, port,
64:                                 Socket::AF_UNSPEC,   # address family
65:                                 Socket::SOCK_STREAM, # socket type
66:                                 0,                   # protocol
67:                                 Socket::AI_PASSIVE)  # flag
68:       last_error = nil
69:       sockets = []
70:       res.each{|ai|
71:         begin
72:           logger.debug("TCPServer.new(#{ai[3]}, #{port})") if logger
73:           sock = TCPServer.new(ai[3], port)
74:           port = sock.addr[1] if port == 0
75:           Utils::set_close_on_exec(sock)
76:           sockets << sock
77:         rescue => ex
78:           logger.warn("TCPServer Error: #{ex}") if logger
79:           last_error  = ex
80:         end
81:       }
82:       raise last_error if sockets.empty?
83:       return sockets
84:     end

    # File lib/webrick/ssl.rb, line 39
39:     def create_self_signed_cert(bits, cn, comment)
40:       rsa = OpenSSL::PKey::RSA.new(bits){|p, n|
41:         case p
42:         when 0; $stderr.putc "."  # BN_generate_prime
43:         when 1; $stderr.putc "+"  # BN_generate_prime
44:         when 2; $stderr.putc "*"  # searching good prime,  
45:                                   # n = #of try,
46:                                   # but also data from BN_generate_prime
47:         when 3; $stderr.putc "\n" # found good prime, n==0 - p, n==1 - q,
48:                                   # but also data from BN_generate_prime
49:         else;   $stderr.putc "*"  # BN_generate_prime
50:         end
51:       }
52:       cert = OpenSSL::X509::Certificate.new
53:       cert.version = 3
54:       cert.serial = 0
55:       name = OpenSSL::X509::Name.new(cn)
56:       cert.subject = name
57:       cert.issuer = name
58:       cert.not_before = Time.now
59:       cert.not_after = Time.now + (365*24*60*60)
60:       cert.public_key = rsa.public_key
61: 
62:       ef = OpenSSL::X509::ExtensionFactory.new(nil,cert)
63:       ef.issuer_certificate = cert
64:       cert.extensions = [
65:         ef.create_extension("basicConstraints","CA:FALSE"),
66:         ef.create_extension("keyUsage", "keyEncipherment"),
67:         ef.create_extension("subjectKeyIdentifier", "hash"),
68:         ef.create_extension("extendedKeyUsage", "serverAuth"),
69:         ef.create_extension("nsComment", comment),
70:       ]
71:       aki = ef.create_extension("authorityKeyIdentifier",
72:                                 "keyid:always,issuer:always")
73:       cert.add_extension(aki)
74:       cert.sign(rsa, OpenSSL::Digest::SHA1.new)
75: 
76:       return [ cert, rsa ]
77:     end

    # File lib/webrick/utils.rb, line 49
49:     def getservername
50:       host = Socket::gethostname
51:       begin
52:         Socket::gethostbyname(host)[0]
53:       rescue
54:         host
55:       end
56:     end

    # File lib/webrick/utils.rb, line 91
91:     def random_string(len)
92:       rand_max = RAND_CHARS.size
93:       ret = "" 
94:       len.times{ ret << RAND_CHARS[rand(rand_max)] }
95:       ret 
96:     end

    # File lib/webrick/utils.rb, line 30
30:     def set_close_on_exec(io)
31:       if defined?(Fcntl::FD_CLOEXEC)
32:         io.fcntl(Fcntl::FD_CLOEXEC, 1)
33:       end
34:     end

    # File lib/webrick/utils.rb, line 21
21:     def set_non_blocking(io)
22:       flag = File::NONBLOCK
23:       if defined?(Fcntl::F_GETFL)
24:         flag |= io.fcntl(Fcntl::F_GETFL)
25:       end
26:       io.fcntl(Fcntl::F_SETFL, flag)
27:     end

    # File lib/webrick/utils.rb, line 37
37:     def su(user)
38:       if defined?(Etc)
39:         pw = Etc.getpwnam(user)
40:         Process::initgroups(user, pw.gid)
41:         Process::Sys::setgid(pw.gid)
42:         Process::Sys::setuid(pw.uid)
43:       else
44:         warn("WEBrick::Utils::su doesn't work on this platform")
45:       end
46:     end