}

        @Override
        public void write(final byte[] b) throws IOException {
            this.stream.write(b);
            this.collector.write(b);
        }

        @Override
        public void write(final byte[] b, final int off, final int len) throws IOException {
            this.stream.write(b, off, len);
            this.collector.write(b, off, len);
        }

        @Override

     * @return The number of bytes written.
     */
    public static int write(final FileChannel channel, final ByteBuffer buffer) {
        assertArgumentNotNull("channel", channel);
        assertArgumentNotNull("buffer", buffer);

        try {
            return channel.write(buffer);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link
   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *
   * <p>We sometimes also use {@code sneakyThrow} for testing how our code responds to
   * sneaky checked exception.
   *
   * @return never; this method declares a return type of {@link Error} only so that callers can

   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link
   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *
   * <p>We sometimes also use {@code sneakyThrow} for testing how our code responds to
   * sneaky checked exception.
   *
   * @return never; this method declares a return type of {@link Error} only so that callers can

        SMBUtil.writeInt4(STRUCTURE_SIZE, dst, dstIndex); // DataLength
        dstIndex += 4;

        // Write context name
        System.arraycopy(CONTEXT_NAME_BYTES, 0, dst, dstIndex, 4);
        dstIndex += 4;

        // Padding to align data to 8-byte boundary
        dstIndex += 4;

        // Write file ID (16 bytes)
        System.arraycopy(fileId, 0, dst, dstIndex, 16);
        dstIndex += 16;

        // Should return true when write caching is enabled
        assertTrue(DirectoryLeaseState.canCacheModifications(Smb2LeaseState.SMB2_LEASE_WRITE_CACHING));
        assertTrue(DirectoryLeaseState.canCacheModifications(Smb2LeaseState.SMB2_LEASE_READ_WRITE));
        assertTrue(DirectoryLeaseState.canCacheModifications(DirectoryLeaseState.DIRECTORY_FULL));

        // Should return false when write caching is not enabled

        SMBUtil.writeInt4(32, buffer, 12); // DataLength (standard lease only)

        // Write name
        System.arraycopy("DLse".getBytes(), 0, buffer, 16, 4);

        // Write lease key
        Smb2LeaseKey key = new Smb2LeaseKey();
        key.encode(buffer, 24);

        // Write lease state
        SMBUtil.writeInt4(DirectoryLeaseState.DIRECTORY_READ_HANDLE, buffer, 40);

 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.io;

import jcifs.CIFSContext;
import jcifs.Configuration;

 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.internal.smb1.trans;

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;

import jcifs.smb1.Config;
import jcifs.smb1.util.LogStream;

/**
Do not use this class. Writing to the OutputStream of this type of socket
requires leaving a 4 byte prefix for the NBT header. IOW you must call
write( buf, 4, len ). Calling write( buf, 0, len ) will generate an error.
 */

public class NbtSocket extends Socket {

    private static final int SSN_SRVC_PORT = 139;
    private static final int BUFFER_SIZE = 512;