Module: Rack::Request::Helpers

Included in:
Rack::Request
Defined in:
lib/rack/request.rb

Constant Summary collapse

FORM_DATA_MEDIA_TYPES =

The set of form-data media-types. Requests that do not indicate one of the media types present in this list will not be eligible for form-data / param parsing.

[ 'application/x-www-form-urlencoded', 'multipart/form-data' ]
PARSEABLE_DATA_MEDIA_TYPES =

The set of media-types. Requests that do not indicate one of the media types present in this list will not be eligible for param parsing like soap attachments or generic multiparts

[ 'multipart/related', 'multipart/mixed' ]
DEFAULT_PORTS =

Default ports depending on scheme. Used to decide whether or not to include the port in a generated URI.

{ 'http' => 80, 'https' => 443, 'coffee' => 80 }
HTTP_X_FORWARDED_FOR =

The address of the client which connected to the proxy.

'HTTP_X_FORWARDED_FOR'
HTTP_X_FORWARDED_HOST =

The contents of the host/:authority header sent to the proxy.

'HTTP_X_FORWARDED_HOST'
HTTP_FORWARDED = 
'HTTP_FORWARDED'
HTTP_X_FORWARDED_SCHEME =

The value of the scheme sent to the proxy.

'HTTP_X_FORWARDED_SCHEME'
HTTP_X_FORWARDED_PROTO =

The protocol used to connect to the proxy.

'HTTP_X_FORWARDED_PROTO'
HTTP_X_FORWARDED_PORT =

The port used to connect to the proxy.

'HTTP_X_FORWARDED_PORT'
HTTP_X_FORWARDED_SSL =

Another way for specifying https scheme was used.

'HTTP_X_FORWARDED_SSL'

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#query_parser=(value) ⇒ Object

Allow overriding the query parser that the receiver will use. By default Rack::Utils.default_query_parser is used.

 562 563 564
 
# File 'lib/rack/request.rb', line 562 def query_parser=(value) @query_parser = value end

Instance Method Details

#accept_encoding ⇒ Object 

 611 612 613
 
# File 'lib/rack/request.rb', line 611 def accept_encoding parse_http_accept_header(get_header("HTTP_ACCEPT_ENCODING")) end

#accept_language ⇒ Object 

 615 616 617
 
# File 'lib/rack/request.rb', line 615 def accept_language parse_http_accept_header(get_header("HTTP_ACCEPT_LANGUAGE")) end

#authority ⇒ Object

The authority of the incoming request as defined by RFC3976. tools.ietf.org/html/rfc3986#section-3.2

In HTTP/1, this is the ‘host` header. In HTTP/2, this is the `:authority` pseudo-header.

 271 272 273
 
# File 'lib/rack/request.rb', line 271 def authority forwarded_authority || host_authority || server_authority end

#base_url ⇒ Object 

 594 595 596
 
# File 'lib/rack/request.rb', line 594 def base_url "#{scheme}://#{host_with_port}" end

#body ⇒ Object 

 195
 
# File 'lib/rack/request.rb', line 195 def body; get_header(RACK_INPUT) end

#content_charset ⇒ Object

The character set of the request body if a “charset” media type parameter was given, or nil if no “charset” was specified. Note that, per RFC2616, text/* media types that specify no explicit charset are to be considered ISO-8859-1.

 465 466 467
 
# File 'lib/rack/request.rb', line 465 def content_charset media_type_params['charset'] end

#content_length ⇒ Object 

 204
 
# File 'lib/rack/request.rb', line 204 def content_length; get_header('CONTENT_LENGTH') end

#content_type ⇒ Object 

 313 314 315 316
 
# File 'lib/rack/request.rb', line 313 def content_type content_type = get_header('CONTENT_TYPE') content_type.nil? || content_type.empty? ? nil : content_type end

#cookies ⇒ Object 

 298 299 300 301 302 303 304 305 306 307 308 309 310 311
 
# File 'lib/rack/request.rb', line 298 def cookies hash = fetch_header(RACK_REQUEST_COOKIE_HASH) do |key| set_header(key, {}) end string = get_header(HTTP_COOKIE) unless string == get_header(RACK_REQUEST_COOKIE_STRING) hash.replace Utils.parse_cookies_header(string) set_header(RACK_REQUEST_COOKIE_STRING, string) end hash end

#delete? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type DELETE

Returns:

  • (Boolean) 
 225
 
# File 'lib/rack/request.rb', line 225 def delete?; request_method == DELETE end

#delete_param(k) ⇒ Object

Destructively delete a parameter, whether it’s in GET or POST. Returns the value of the deleted parameter.

If the parameter is in both GET and POST, the POST value takes precedence since that’s how #params works.

env['rack.input'] is not touched.

 589 590 591 592
 
# File 'lib/rack/request.rb', line 589 def delete_param(k) post_value, get_value = self.POST.delete(k), self.GET.delete(k) post_value || get_value end

#form_data? ⇒ Boolean

Determine whether the request body contains form-data by checking the request content-type for one of the media-types: “application/x-www-form-urlencoded” or “multipart/form-data”. The list of form-data media types can be modified through the FORM_DATA_MEDIA_TYPES array.

A request body is also assumed to contain form-data when no content-type header is provided and the request_method is POST.

Returns:

  • (Boolean) 
 477 478 479 480 481 482
 
# File 'lib/rack/request.rb', line 477 def form_data? type = media_type meth = get_header(RACK_METHODOVERRIDE_ORIGINAL_METHOD) || get_header(REQUEST_METHOD) (meth == POST && type.nil?) || FORM_DATA_MEDIA_TYPES.include?(type) end

#form_pairs ⇒ Object

Returns the form data pairs received in the request body.

This method support both application/x-www-form-urlencoded and multipart/form-data.

 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
 
# File 'lib/rack/request.rb', line 499 def form_pairs if pairs = get_header(RACK_REQUEST_FORM_PAIRS) return pairs elsif error = get_header(RACK_REQUEST_FORM_ERROR) raise error.class, error.message, cause: error.cause end begin rack_input = get_header(RACK_INPUT) # Otherwise, figure out how to parse the input: if rack_input.nil? set_header(RACK_REQUEST_FORM_PAIRS, []) elsif form_data? || parseable_data? if pairs = Rack::Multipart.parse_multipart(env, Rack::Multipart::ParamList) set_header RACK_REQUEST_FORM_PAIRS, pairs else # Add 2 bytes. One to check whether it is over the limit, and a second # in case the slice! call below removes the last byte # If read returns nil, use the empty string form_vars = get_header(RACK_INPUT).read(query_parser.bytesize_limit + 2) || '' # Fix for Safari Ajax postings that always append \0 # form_vars.sub!(/\0\z/, '') # performance replacement: form_vars.slice!(-1) if form_vars.end_with?("\0") set_header RACK_REQUEST_FORM_VARS, form_vars pairs = query_parser.parse_query_pairs(form_vars, '&') set_header(RACK_REQUEST_FORM_PAIRS, pairs) end else set_header(RACK_REQUEST_FORM_PAIRS, []) end rescue => error set_header(RACK_REQUEST_FORM_ERROR, error) raise end end

#forwarded_authority ⇒ Object 

 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
 
# File 'lib/rack/request.rb', line 398 def forwarded_authority forwarded_priority.each do |type| case type when :forwarded if forwarded = get_http_forwarded(:host) return forwarded.last end when :x_forwarded if (value = get_header(HTTP_X_FORWARDED_HOST)) && (x_forwarded_host = split_header(value).last) return wrap_ipv6(x_forwarded_host) end end end nil end

#forwarded_for ⇒ Object 

 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
 
# File 'lib/rack/request.rb', line 358 def forwarded_for forwarded_priority.each do |type| case type when :forwarded if forwarded_for = get_http_forwarded(:for) return(forwarded_for.map! do |authority| split_authority(authority)[1] end) end when :x_forwarded if value = get_header(HTTP_X_FORWARDED_FOR) return(split_header(value).map do |authority| split_authority(wrap_ipv6(authority))[1] end) end end end nil end

#forwarded_port ⇒ Object 

 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
 
# File 'lib/rack/request.rb', line 379 def forwarded_port forwarded_priority.each do |type| case type when :forwarded if forwarded = get_http_forwarded(:for) return(forwarded.map do |authority| split_authority(authority)[2] end.compact) end when :x_forwarded if value = get_header(HTTP_X_FORWARDED_PORT) return split_header(value).map(&:to_i) end end end nil end

#fullpath ⇒ Object 

 607 608 609
 
# File 'lib/rack/request.rb', line 607 def fullpath query_string.empty? ? path : "#{path}?#{query_string}" end

#GET ⇒ Object

Returns the data received in the query string.

 491 492 493
 
# File 'lib/rack/request.rb', line 491 def GET get_header(RACK_REQUEST_QUERY_HASH) || set_header(RACK_REQUEST_QUERY_HASH, parse_query(query_string, '&')) end

#get? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type GET

Returns:

  • (Boolean) 
 228
 
# File 'lib/rack/request.rb', line 228 def get?; request_method == GET end

#head? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type HEAD

Returns:

  • (Boolean) 
 231
 
# File 'lib/rack/request.rb', line 231 def head?; request_method == HEAD end

#host ⇒ Object

Returns a formatted host, suitable for being used in a URI.

 338 339 340
 
# File 'lib/rack/request.rb', line 338 def host split_authority(self.authority)[0] end

#host_authority ⇒ Object

The ‘HTTP_HOST` header.

 323 324 325
 
# File 'lib/rack/request.rb', line 323 def host_authority get_header(HTTP_HOST) end

#host_with_port(authority = self.authority) ⇒ Object 

 327 328 329 330 331 332 333 334 335
 
# File 'lib/rack/request.rb', line 327 def host_with_port(authority = self.authority) host, _, port = split_authority(authority) if port == DEFAULT_PORTS[self.scheme] host else authority end end

#hostname ⇒ Object

Returns an address suitable for being to resolve to an address. In the case of a domain name or IPv4 address, the result is the same as host. In the case of IPv6 or future address formats, the square brackets are removed.

 346 347 348
 
# File 'lib/rack/request.rb', line 346 def hostname split_authority(self.authority)[1] end

#ip ⇒ Object 

 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
 
# File 'lib/rack/request.rb', line 419 def ip remote_addresses = split_header(get_header('REMOTE_ADDR')) remote_addresses.reverse_each do |ip| return ip unless trusted_proxy?(ip) end if (forwarded_for = self.forwarded_for) && !forwarded_for.empty? # The forwarded for addresses are ordered: client, proxy1, proxy2. # So we reject all the trusted addresses (proxy*) and return the # last client. Or if we trust everyone, we just return the first # address. forwarded_for.reverse_each do |ip| return ip unless trusted_proxy?(ip) end return forwarded_for.first end # If all the addresses are trusted, and we aren't forwarded, just return # the first remote address, which represents the source of the request. remote_addresses.first end

#link? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type LINK

Returns:

  • (Boolean) 
 237
 
# File 'lib/rack/request.rb', line 237 def link?; request_method == LINK end

#logger ⇒ Object 

 205
 
# File 'lib/rack/request.rb', line 205 def logger; get_header(RACK_LOGGER) end

#media_type ⇒ Object

The media type (type/subtype) portion of the CONTENT_TYPE header without any media type parameters. e.g., when CONTENT_TYPE is “text/plain;charset=utf-8”, the media-type is “text/plain”.

For more information on the use of media types in HTTP, see: www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7

 448 449 450
 
# File 'lib/rack/request.rb', line 448 def media_type MediaType.type(content_type) end

#media_type_params ⇒ Object

The media type parameters provided in CONTENT_TYPE as a Hash, or an empty Hash if no CONTENT_TYPE or media-type parameters were provided. e.g., when the CONTENT_TYPE is “text/plain;charset=utf-8”, this method responds with the following Hash:

{ 'charset' => 'utf-8' } 
 457 458 459
 
# File 'lib/rack/request.rb', line 457 def media_type_params MediaType.params(content_type) end

#options? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type OPTIONS

Returns:

  • (Boolean) 
 234
 
# File 'lib/rack/request.rb', line 234 def options?; request_method == OPTIONS end

#params ⇒ Object

The union of GET and POST data.

Note that modifications will not be persisted in the env. Use update_param or delete_param if you want to destructively modify params.

 556 557 558
 
# File 'lib/rack/request.rb', line 556 def params self.GET.merge(self.POST) end

#parseable_data? ⇒ Boolean

Determine whether the request body contains data by checking the request media_type against registered parse-data media-types

Returns:

  • (Boolean) 
 486 487 488
 
# File 'lib/rack/request.rb', line 486 def parseable_data? PARSEABLE_DATA_MEDIA_TYPES.include?(media_type) end

#patch? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type PATCH

Returns:

  • (Boolean) 
 240
 
# File 'lib/rack/request.rb', line 240 def patch?; request_method == PATCH end

#path ⇒ Object 

 603 604 605
 
# File 'lib/rack/request.rb', line 603 def path script_name + path_info end

#path_info ⇒ Object 

 199
 
# File 'lib/rack/request.rb', line 199 def path_info; get_header(PATH_INFO).to_s end

#path_info=(s) ⇒ Object 

 200
 
# File 'lib/rack/request.rb', line 200 def path_info=(s); set_header(PATH_INFO, s.to_s) end

#port ⇒ Object 

 350 351 352 353 354 355 356
 
# File 'lib/rack/request.rb', line 350 def port if authority = self.authority _, _, port = split_authority(authority) end port || forwarded_port&.last || DEFAULT_PORTS[scheme] || server_port end

#POST ⇒ Object

Returns the data received in the request body.

This method support both application/x-www-form-urlencoded and multipart/form-data.

 542 543 544 545 546 547 548 549 550 551
 
# File 'lib/rack/request.rb', line 542 def POST if form_hash = get_header(RACK_REQUEST_FORM_HASH) return form_hash elsif error = get_header(RACK_REQUEST_FORM_ERROR) raise error.class, error.message, cause: error.cause end pairs = form_pairs set_header RACK_REQUEST_FORM_HASH, expand_param_pairs(pairs) end

#post? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type POST

Returns:

  • (Boolean) 
 243
 
# File 'lib/rack/request.rb', line 243 def post?; request_method == POST end

#put? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type PUT

Returns:

  • (Boolean) 
 246
 
# File 'lib/rack/request.rb', line 246 def put?; request_method == PUT end

#query_string ⇒ Object 

 203
 
# File 'lib/rack/request.rb', line 203 def query_string; get_header(QUERY_STRING).to_s end

#referer ⇒ Object Also known as: referrer

the referer of the client

 209
 
# File 'lib/rack/request.rb', line 209 def referer; get_header('HTTP_REFERER') end

#request_method ⇒ Object 

 202
 
# File 'lib/rack/request.rb', line 202 def request_method; get_header(REQUEST_METHOD) end

#scheme ⇒ Object 

 254 255 256 257 258 259 260 261 262 263 264
 
# File 'lib/rack/request.rb', line 254 def scheme if get_header(HTTPS) == 'on' 'https' elsif get_header(HTTP_X_FORWARDED_SSL) == 'on' 'https' elsif forwarded_scheme forwarded_scheme else get_header(RACK_URL_SCHEME) end end

#script_name ⇒ Object 

 196
 
# File 'lib/rack/request.rb', line 196 def script_name; get_header(SCRIPT_NAME).to_s end

#script_name=(s) ⇒ Object 

 197
 
# File 'lib/rack/request.rb', line 197 def script_name=(s); set_header(SCRIPT_NAME, s.to_s) end

#server_authority ⇒ Object

The authority as defined by the ‘SERVER_NAME` and `SERVER_PORT` variables.

 277 278 279 280 281 282 283 284 285 286 287 288
 
# File 'lib/rack/request.rb', line 277 def server_authority host = self.server_name port = self.server_port if host if port "#{host}:#{port}" else host end end end

#server_name ⇒ Object 

 290 291 292
 
# File 'lib/rack/request.rb', line 290 def server_name get_header(SERVER_NAME) end

#server_port ⇒ Object 

 294 295 296
 
# File 'lib/rack/request.rb', line 294 def server_port get_header(SERVER_PORT) end

#session ⇒ Object 

 212 213 214 215 216
 
# File 'lib/rack/request.rb', line 212 def session fetch_header(RACK_SESSION) do |k| set_header RACK_SESSION, default_session end end

#session_options ⇒ Object 

 218 219 220 221 222
 
# File 'lib/rack/request.rb', line 218 def session_options fetch_header(RACK_SESSION_OPTIONS) do |k| set_header RACK_SESSION_OPTIONS, {} end end

#ssl? ⇒ Boolean

Returns:

  • (Boolean) 
 415 416 417
 
# File 'lib/rack/request.rb', line 415 def ssl? scheme == 'https' || scheme == 'wss' end

#trace? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type TRACE

Returns:

  • (Boolean) 
 249
 
# File 'lib/rack/request.rb', line 249 def trace?; request_method == TRACE end

#trusted_proxy?(ip) ⇒ Boolean

Returns:

  • (Boolean) 
 619 620 621
 
# File 'lib/rack/request.rb', line 619 def trusted_proxy?(ip) Rack::Request.ip_filter.call(ip) end

#unlink? ⇒ Boolean

Checks the HTTP request method (or verb) to see if it was of type UNLINK

Returns:

  • (Boolean) 
 252
 
# File 'lib/rack/request.rb', line 252 def unlink?; request_method == UNLINK end

#update_param(k, v) ⇒ Object

Destructively update a parameter, whether it’s in GET and/or POST. Returns nil.

The parameter is updated wherever it was previous defined, so GET, POST, or both. If it wasn’t previously defined, it’s inserted into GET.

env['rack.input'] is not touched.

 569 570 571 572 573 574 575 576 577 578 579 580 581 582
 
# File 'lib/rack/request.rb', line 569 def update_param(k, v) found = false if self.GET.has_key?(k) found = true self.GET[k] = v end if self.POST.has_key?(k) found = true self.POST[k] = v end unless found self.GET[k] = v end end

#url ⇒ Object

Tries to return a remake of the original request URL as a string.

 599 600 601
 
# File 'lib/rack/request.rb', line 599 def url base_url + fullpath end

#user_agent ⇒ Object 

 206
 
# File 'lib/rack/request.rb', line 206 def user_agent; get_header('HTTP_USER_AGENT') end

#xhr? ⇒ Boolean

Returns:

  • (Boolean) 
 318 319 320
 
# File 'lib/rack/request.rb', line 318 def xhr? get_header("HTTP_X_REQUESTED_WITH") == "XMLHttpRequest" end