/**
     * Reads up to b.length bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException if a network error occurs
     */

    @Override
    public int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     *

            byte[] buffer = createValidCopyChunkResponse(5, 65536, 327680);

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

            assertEquals(12, bytesDecoded); // 3 x 4 bytes = 12 bytes
            assertEquals(5, response.getChunksWritten());
            assertEquals(65536, response.getChunkBytesWritten());
            assertEquals(327680, response.getTotalBytesWritten());
        }

   *
   * @throws IllegalArgumentException if {@code bytes} has fewer than 4 elements
   */
  public static int fromByteArray(byte[] bytes) {
    checkArgument(bytes.length >= BYTES, "array too small: %s < %s", bytes.length, BYTES);
    return fromBytes(bytes[0], bytes[1], bytes[2], bytes[3]);
  }

  /**
   * Returns the {@code int} value whose byte representation is the given 4 bytes, in big-endian

		Avg:  a.Avg,
		Max:  a.Max,
	}
	return w
}

// QStat holds queue stats for replication
type QStat struct {
	Count float64 `json:"count"`
	Bytes float64 `json:"bytes"`
}

func (q *QStat) add(o QStat) QStat {
	return QStat{Bytes: q.Bytes + o.Bytes, Count: q.Count + o.Count}
}

// InQueueMetric holds queue stats for replication
type InQueueMetric struct {
	Curr QStat `json:"curr" msg:"cq"`

	var buf bytes.Buffer
	buf.WriteString(xxml.Header)
	if err := xxml.NewEncoder(&buf).Encode(response); err != nil {
		bugLogIf(GlobalContext, err)
		return nil
	}
	return buf.Bytes()
}

// Encodes the response headers into JSON format.
func encodeResponseJSON(response any) []byte {
	var bytesBuffer bytes.Buffer
	e := json.NewEncoder(&bytesBuffer)
	e.Encode(response)
	return bytesBuffer.Bytes()
}

        idx += 4;
        SMBUtil.writeInt4(maxFragmentedSize, data, idx);
        idx += 4;

        // Reserved fields (8 bytes)
        // Already zero-initialized

        return data;
    }

    /**
     * Get size of this message
     *
     * @return size in bytes (32)
     */
    public static int size() {
        return 32;
    }

    // Getters and setters

    /**

    /**
     * Creates the NTLM2 response for the supplied information.
     *
     * @param nTOWFv1 the NTOWFv1 hash
     * @param serverChallenge the server challenge bytes
     * @param clientChallenge the client challenge bytes
     * @return the NTLM2 response bytes
     */
    public static byte[] getNTLM2Response(final byte[] nTOWFv1, final byte[] serverChallenge, final byte[] clientChallenge) {

      if (type == TYPE_A || type == TYPE_AAAA) {
        val bytes = ByteArray(length)
        buf.read(bytes)
        result.add(InetAddress.getByAddress(bytes))
      } else {
        buf.skip(length.toLong())
      }
    }

    return result
  }

  @Throws(EOFException::class)
  private fun skipName(source: Buffer) {
    // 0 - 63 bytes
    var length = source.readByte().toInt()

  // performed while the lock is held.

  /** The bytes consumed and acknowledged by the stream. */
  val readBytes: WindowCounter = WindowCounter(id)

  /** The total number of bytes produced by the application. */
  var writeBytesTotal = 0L
    internal set

  /** The total number of bytes permitted to be produced by incoming `WINDOW_UPDATE` frame. */

        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes from the file into the specified byte array.
     *
     * @param b the byte array to read data into
     * @param off the offset in the array at which to start storing bytes
     * @param len the maximum number of bytes to read
     * @return the number of bytes read, or -1 if end of file is reached
     * @throws SmbException if an I/O error occurs