extraNetworkInterceptor =
      Interceptor { chain: Interceptor.Chain ->
        chain.proceed(
          chain.request()
            .newBuilder()
            .header("Content-Length", "2")
            .header("Content-Type", "text/plain-ish")
            .build(),
        )
      }
    server.enqueue(MockResponse())
    client.newCall(
      request()
        .post("Hi?".toRequestBody(PLAIN))

crawler.document.html.lang.xpath=//HTML/@lang
crawler.document.html.digest.xpath=//META[@name='description']/@content
crawler.document.html.canonical.xpath=//LINK[@rel='canonical'][1]/@href
crawler.document.html.pruned.tags=noscript,script,style,header,footer,aside,nav,a[rel=nofollow]
crawler.document.html.max.digest.length=120
crawler.document.html.default.lang=
crawler.document.html.default.include.index.patterns=

          nextRequest = route.address.proxyAuthenticator.authenticate(route, response)
            ?: throw IOException("Failed to authenticate with proxy")

          if ("close".equals(response.header("Connection"), ignoreCase = true)) {
            return nextRequest
          }
        }

        else -> throw IOException("Unexpected response code for CONNECT: ${response.code}")
      }
    }
  }

<img src="/img/tutorial/security/image10.png">

/// note

Notice the header `Authorization`, with a value that starts with `Bearer `.

///

## Advanced usage with `scopes`

OAuth2 has the notion of "scopes".

You can use them to add a specific set of permissions to a JWT token.

		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
	globalNotificationSys.SignalConfigReload(subSys)
	// Tell the client that dynamic config was applied.
	w.Header().Set(madmin.ConfigAppliedHeader, madmin.ConfigAppliedTrue)
}

type badConfigErr struct {
	Err error
}

// Error - return the error message
func (bce badConfigErr) Error() string {

    cookie_params = _get_flat_fields_from_params(flat_dependant.cookie_params)
    parameter_groups = [
        (ParamTypes.path, path_params),
        (ParamTypes.query, query_params),
        (ParamTypes.header, header_params),
        (ParamTypes.cookie, cookie_params),
    ]
    for param_type, param_group in parameter_groups:
        for param in param_group:
            field_info = param.field_info

 *        * body ([responseBodyStart], [responseBodyEnd])
 *
 * This nesting is typical but not strict. For example, when calls use "Expect: continue" the
 * request body start and end events occur within the response header events. Similarly,
 * [duplex calls][RequestBody.isDuplex] interleave the request and response bodies.
 *
 * Since connections may be reused, the proxy selection, DNS, and connect events may not be present

pkg syscall (freebsd-arm), type InterfaceAnnounceMessage struct
pkg syscall (freebsd-arm), type InterfaceAnnounceMessage struct, Header IfAnnounceMsghdr
pkg syscall (freebsd-arm), type InterfaceMessage struct
pkg syscall (freebsd-arm), type InterfaceMessage struct, Data []uint8
pkg syscall (freebsd-arm), type InterfaceMessage struct, Header IfMsghdr

type objectAPIHandlers struct {
	ObjectAPI func() ObjectLayer
}

// getHost tries its best to return the request host.
// According to section 14.23 of RFC 2616 the Host header
// can include the port number if the default value of 80 is not used.
func getHost(r *http.Request) string {
	if r.URL.IsAbs() {
		return r.URL.Host
	}
	return r.Host
}

                    }
                }
                // == 5*128 = 640

                // . and .. entries = 200 byte (includes alignment)

                // + 64 byte header
                // + 8 byte query response overhead
                // + 110 bytes entry
                // -> 1022 predicted message size <= 1023 maximum buffer size
                // 112 bytes to alignment