return 2;
    }

    @Override
    int writeParametersWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        writeInt2(maxReferralLevel, dst, dstIndex);
        dstIndex += 2;
        dstIndex += writeString(path, dst, dstIndex);

        return dstIndex - start;
    }

    @Override
    int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

        final int start = dstIndex;
        SMBUtil.writeInt2(24, dst, dstIndex);
        dstIndex += 2;
        dstIndex += 2; // Reserved1
        dstIndex += 4; // Reserved2

        System.arraycopy(this.fileId, 0, dst, dstIndex, 16);
        dstIndex += 16;

        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *

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

                : loc.getUNCPath();
        String share = loc.getShare();

        final DfsReferralData start = referral != null ? referral : this.ctx.getDfs().resolve(this.ctx, hostName, loc.getShare(), path);
        DfsReferralData dr = start;
        IOException last = null;
        do {
            if (dr != null) {
                targetDomain = dr.getDomain();

  }

  /**
   * Starts the server on the loopback interface for the given port.
   *
   * @param port the port to listen to, or 0 for any available port. Automated tests should always
   * use port 0 to avoid flakiness when a specific port is unavailable.
   */
  @Throws(IOException::class)
  @JvmOverloads
  public fun start(port: Int = 0) {
    start(InetAddress.getByName("localhost"), port)
  }

            activeWatchers.put(directoryPath, handle);

            // Start async change notification
            startAsyncNotification(handle);

        } catch (Exception e) {
            log.error("Failed to start directory watching for: " + directoryPath, e);
        }
    }

    /**
     * Stop watching a directory
     *

			return err
		}
		if _, err := io.WriteString(w.cw, h.Comment); err != nil {
			return err
		}
	}
	end := w.cw.count

	records := uint64(len(w.dir))
	size := uint64(end - start)
	offset := uint64(start)

	if f := w.testHookCloseSizeOffset; f != nil {
		f(size, offset)
	}

	if records >= uint16max || size >= uint32max || offset >= uint32max {
		var buf [directory64EndLen + directory64LocLen]byte

      return matcher.replaceAll(replacement);
    }

    @Override
    public int end() {
      return matcher.end();
    }

    @Override
    public int start() {
      return matcher.start();
    }
  }

  @J2ktIncompatible private static final long serialVersionUID = 0;

        final int start = dstIndex;

        SMBUtil.writeInt2(this.fid, dst, dstIndex);
        dstIndex += 2;
        dst[dstIndex] = (byte) 0x00; // Reserved
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00; // Reserved
        SMBUtil.writeInt4(this.securityInformation, dst, dstIndex);
        dstIndex += 4;
        return dstIndex - start;
    }

    @Override

        return 0;
    }

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

    @Override
    public String toString() {