com.hierynomus.protocol.commons.ByteArrayUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of smbj Show documentation
SMB2 protocol library for communication with Windows servers
There is a newer version: 0.13.0
/*
 * Copyright (C)2016 - SMBJ Contributors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.hierynomus.protocol.commons;

/**
 * Utility functions for byte arrays.
 */
public class ByteArrayUtils {

    final static char[] digits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    /**
     * Check whether some part or whole of two byte arrays is equal, for length bytes starting at some
     * offset.
     *
     * @param a1
     * @param a1Offset
     * @param a2
     * @param a2Offset
     * @param length
     * @return true or false
     */
    public static boolean equals(byte[] a1, final int a1Offset, byte[] a2, final int a2Offset, final int length) {
        if (a1.length < a1Offset + length || a2.length < a2Offset + length) {
            return false;
        }

        for (int l = 0; l < length; l++) {
            if (a1[a1Offset + l] != a2[a2Offset + l])
                return false;
        }
        return true;
    }

    /**
     * Get a hexadecimal representation of the full byte array, with each octet separated by a space.
     *
     * @param array
     * @return hex string, each octet delimited by a space
     */
    public static String printHex(byte[] array) {
        return printHex(array, 0, array.length);
    }

    /**
     * Get a hexadecimal representation of a byte array starting at offset index for len
     * bytes, with each octet separated by a space.
     *
     * @param array
     * @param offset
     * @param len
     * @return hex string, each octet delimited by a space
     */
    public static String printHex(byte[] array, int offset, int len) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < len; i++) {
            byte b = array[offset + i];
            if (sb.length() > 0)
                sb.append(' ');
            sb.append(digits[b >> 4 & 0x0F]);
            sb.append(digits[b & 0x0F]);
        }
        return sb.toString();
    }

    /**
     * Get the hexadecimal representation of a byte array.
     *
     * @param array
     * @return hex string
     */
    public static String toHex(byte[] array) {
        return toHex(array, 0, array.length);
    }

    /**
     * Get the hexadecimal representation of a byte array starting at offset index for len
     * bytes.
     *
     * @param array
     * @param offset
     * @param len
     * @return hex string
     */
    public static String toHex(byte[] array, int offset, int len) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < len; i++) {
            byte b = array[offset + i];
            sb.append(digits[b >> 4 & 0x0F]);
            sb.append(digits[b & 0x0F]);
        }
        return sb.toString();
    }

}