streamMediaTypes = append(streamMediaTypes, info.MediaType+";stream=watch")
		}
	}
	return mediaTypes, streamMediaTypes
}

// NegotiateOutputMediaType negotiates the output structured media type and a serializer, or
// returns an error.

 * to a remote host. Newer TLS options are quite useful:
 *
 *  * Server Name Indication (SNI) enables one IP address to negotiate secure connections for
 *    multiple domain names.
 *
 *  * Application Layer Protocol Negotiation (ALPN) enables the HTTPS port (443) to be used to
 *    negotiate HTTP/2.
 *
 * Unfortunately, older HTTPS servers refuse to connect when such options are presented. Rather than

David Eads <******@****.***> 1603998691 -0400

// RoundTripper. The primary use of this method is to support proxying upgradable connections.
// For this reason this method will prefer to negotiate http/1.1 if the URL scheme is https.
// If you wish to ensure ALPN negotiates http2 then set NextProto=[]string{"http2"} in the
// TLSConfig of the http.Transport
func DialURL(ctx context.Context, url *url.URL, transport http.RoundTripper) (net.Conn, error) {

        super(tc.getConfig(), SMB_COM_SESSION_SETUP_ANDX, andx);
        this.negotiated = negotiated;
        this.capabilities = negotiated.getNegotiatedCapabilities();
        ServerData server = negotiated.getServerData();
        if ( server.security == SmbConstants.SECURITY_USER ) {
            if ( cred instanceof NtlmPasswordAuthenticator ) {
                NtlmPasswordAuthenticator a = (NtlmPasswordAuthenticator) cred;

    /**
     * @param resp
     */
    void setupResponse ( Response resp );


    /**
     * @return whether signing has been negotiated
     */
    boolean isSigningNegotiated ();


    /**
     * @param cap
     * @return whether capability is negotiated
     */
    boolean haveCapabilitiy ( int cap );


    /**
     * @return the send buffer size
     */
    int getSendBufferSize ();

		}

		for _, p := range test.clientProtocols {
			req.Header.Add(HeaderProtocolVersion, p)
		}

		w := newResponseWriter()
		negotiated, err := Handshake(req, w, test.serverProtocols)

		// verify negotiated protocol
		if e, a := test.expectedProtocol, negotiated; e != a {
			t.Errorf("%s: protocol: expected %q, got %q", name, e, a)
		}

		if test.expectError {
			if err == nil {

  internal const val B0_FLAG_FIN = 128

  /** Byte 0 reserved flag 1. Must be 0 unless negotiated otherwise. */
  internal const val B0_FLAG_RSV1 = 64

  /** Byte 0 reserved flag 2. Must be 0 unless negotiated otherwise. */
  internal const val B0_FLAG_RSV2 = 32

  /** Byte 0 reserved flag 3. Must be 0 unless negotiated otherwise. */
  internal const val B0_FLAG_RSV3 = 16

  /** Byte 0 mask for the frame opcode. */

     */
    private static final long serialVersionUID = -5576981906065713710L;


    /**
     * 
     */
    public SmbUnsupportedOperationException () {
        super("Operation is not supported with the negotiated capabilities");
    }


    /**
     * 
     * @param msg
     */
    public SmbUnsupportedOperationException ( String msg ) {
        super(msg);
    }

See the License for the specific language governing permissions and
limitations under the License.
*/

package serializer

import (
	"k8s.io/apimachinery/pkg/runtime"
)

// TODO: We should split negotiated serializers that we can change versions on from those we can change
// serialization formats on
type negotiatedSerializerWrapper struct {
	info runtime.SerializerInfo
}