return SmbConstants.DEFAULT_PORT;
    }
    public URLConnection openConnection( URL u ) throws IOException {
        return new SmbFile( u );
    }
    protected void parseURL( URL u, String spec, int start, int limit ) {
        String host = u.getHost();
        String path, ref;
        int port;

        if( spec.equals( "smb1://" )) {
            spec = "smb1:////";
            limit += 2;

     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */
    @Override
    protected int readBytesWireFormat ( byte[] buffer, int bufferIndex ) throws SMBProtocolDecodingException {
        int start = bufferIndex;
        int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if ( structureSize != 17 ) {
            throw new SMBProtocolDecodingException("Expected structureSize = 17");
        }

}

// UnmarshalXML - decodes XML data.
func (l *ObjectLegalHold) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
	switch start.Name.Local {
	case "LegalHold", "ObjectLockLegalHold":
	default:
		return xml.UnmarshalError(fmt.Sprintf("expected element type <LegalHold>/<ObjectLockLegalHold> but have <%s>",
			start.Name.Local))
	}
	for {
		// Read tokens from the XML document in a stream.
		t, err := d.Token()

     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {
        int start = bufferIndex;

        // Read total allocation units.
        this.alloc = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // read caller available allocation units

        int start = dstIndex;

        dst[ dstIndex++ ] = (byte) 0x04;
        dstIndex += writeString(this.oldFileName, dst, dstIndex);
        dst[ dstIndex++ ] = (byte) 0x04;
        if ( this.isUseUnicode() ) {
            dst[ dstIndex++ ] = (byte) '\0';
        }
        dstIndex += writeString(this.newFileName, dst, dstIndex);

        return dstIndex - start;
    }


    @Override

    protected SmbComNtTransactionResponse ( Configuration config ) {
        super(config);
    }


    @Override
    protected int readParameterWordsWireFormat ( byte[] buffer, int bufferIndex ) {
        int start = bufferIndex;

        buffer[ bufferIndex++ ] = (byte) 0x00; // Reserved
        buffer[ bufferIndex++ ] = (byte) 0x00; // Reserved
        buffer[ bufferIndex++ ] = (byte) 0x00; // Reserved

        return 0;
    }


    @Override
    protected int readDataWireFormat ( byte[] buffer, int bufferIndex, int len ) {
        int start = bufferIndex;
        bufferIndex += this.dfsResponse.decode(buffer, bufferIndex, len);
        return bufferIndex - start;
    }


    @Override
    public String toString () {

        dst[dstIndex++] = subCommand;
        dst[dstIndex++] = (byte)0x00;
        return 2;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        writeInt2( informationLevel, dst, dstIndex );
        dstIndex += 2;

        /* windows98 has what appears to be another 4 0's followed by the share

                  .ok());
  ASSERT_TRUE(worker_server1->Start().ok());

  server_def.set_task_index(2);
  std::unique_ptr<tensorflow::GrpcServer> worker_server2;
  ASSERT_TRUE(tensorflow::GrpcServer::Create(
                  server_def, tensorflow::Env::Default(), &worker_server2)
                  .ok());
  ASSERT_TRUE(worker_server2->Start().ok());

  TF_Status* status = TF_NewStatus();

	const testPayload = "Hello Grid World!"

	gotResp := make(chan struct{})
	go func() {
		start := time.Now()
		t.Log("Roundtrip: sending request")
		resp, err := remoteConn.Request(context.Background(), handlerTest, []byte(testPayload))
		t.Log("Roundtrip:", time.Since(start), resp, err)
		gotResp <- struct{}{}
	}()
	<-gotCall
	remote.debugMsg(debugKillInbound)
	local.debugMsg(debugKillInbound)