} else {
            ret.append(Hexdump.toHexString(serverChallenge, 0, serverChallenge.length * 2));
        }
        ret.append(",signingKey=");
        if (signingKey == null) {
            ret.append("null");
        } else {
            ret.append(Hexdump.toHexString(signingKey, 0, signingKey.length * 2));
        }
        ret.append("]");
        return ret.toString();
    }

    /**

     * @param offset
     *            The starting offset at which the SMB header begins.
     * @param length
     *            The length of the SMB data starting at offset.
     * @param request
     *            request message
     * @param response
     *            response message
     */
    void sign(byte[] data, int offset, int length, CommonServerMessageBlock request, CommonServerMessageBlock response);

    /**

                    hdrStart + securityBufferOffset + securityBufferLength > buffer.length) {
                throw new SMBProtocolDecodingException("Security buffer extends beyond available data (offset: " + securityBufferOffset
                        + ", length: " + securityBufferLength + ", buffer size: " + buffer.length + ")");
            }

            this.securityBuffer = new byte[securityBufferLength];

     *
     * @param rus wrapped string
     * @param zterm whether the string should be zero terminated
     */
    public UnicodeString(final rpc.unicode_string rus, final boolean zterm) {
        this.length = rus.length;
        this.maximum_length = rus.maximum_length;
        this.buffer = rus.buffer;
        this.zterm = zterm;
    }

    /**
     * Constructs a UnicodeString from a Java String.
     *

)

// getDataBlockLen - get length of data blocks from encoded blocks.
func getDataBlockLen(enBlocks [][]byte, dataBlocks int) int {
	size := 0
	// Figure out the data block length.
	for _, block := range enBlocks[:dataBlocks] {
		size += len(block)
	}
	return size
}

// Writes all the data blocks from encoded blocks until requested
// outSize length. Provides a way to skip bytes until the offset.

    // contain non-decimal characters.
    int length = end - start;
    if (length <= 0 || length > 3) {
      throw new NumberFormatException();
    }
    // Disallow leading zeroes, because no clear standard exists on
    // whether these should be interpreted as decimal or octal.
    if (length > 1 && ipString.charAt(start) == '0') {
      throw new NumberFormatException();
    }

      return delegate.order(insertionOrder);
    }

    @Override
    public K[] createKeyArray(int length) {
      return delegate.createKeyArray(length);
    }

    @Override
    public V[] createValueArray(int length) {
      return delegate.createValueArray(length);
    }

    @Override
    public SampleElements<Entry<K, V>> samples() {
      return delegate.samples();
    }

        for (int i = 0; i < this.unlocks.length; i++) {
            this.unlocks[i] = createLockRange();
            bufferIndex += this.unlocks[i].decode(buffer, bufferIndex, buffer.length);
        }

        for (int i = 0; i < this.locks.length; i++) {
            this.locks[i] = createLockRange();
            bufferIndex += this.locks[i].decode(buffer, bufferIndex, buffer.length);
        }

    for (int i = 0; i < reps; i++) {
      for (int n = 0; n < chars.length; n++) {
        dummy ^= Ascii.isUpperCase(chars[n]);
      }
    }
    return dummy;
  }

  static String charSequenceToUpperCase(CharSequence chars) {
    char[] newChars = new char[chars.length()];
    for (int i = 0; i < newChars.length; i++) {
      newChars[i] = Ascii.toUpperCase(chars.charAt(i));
    }

        final byte[] nameBytes = this.fileName.getBytes(StandardCharsets.UTF_16LE);

        SMBUtil.writeInt4(nameBytes.length, dst, dstIndex);
        dstIndex += 4;

        System.arraycopy(nameBytes, 0, dst, dstIndex, nameBytes.length);
        dstIndex += nameBytes.length;

        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */