ByteBuffer bb2 = ByteBuffer.wrap(bytes, 8, 8).order(java.nio.ByteOrder.BIG_ENDIAN);
        long data4 = bb2.getLong();

        // Construct UUID from components - Java UUID expects big-endian representation
        long mostSig = ((long) data1 << 32) | ((long) (data2 & 0xFFFF) << 16) | (data3 & 0xFFFF);
        long leastSig = data4;

    /** The next DFS referral in the chain */
    DfsReferral next;
    /** Map containing DFS referral entries */
    Map map;
    /** The cache key for this referral */
    String key = null;

    /**
     * Constructs a new DfsReferral instance
     */
    public DfsReferral() {
        this.next = this;
    }

    void append(final DfsReferral dr) {
        dr.next = next;
        next = dr;
    }

    @Override

 * position after a seek request in SMB1 protocol file operations.
 *
 * @author mbechler
 */
public class SmbComSeekResponse extends ServerMessageBlock {

    private long offset;

    /**
     * Constructs a seek response.
     *
     * @param config the configuration
     */
    public SmbComSeekResponse(final Configuration config) {
        super(config);
    }

    /**

 * to become available when the pipe server is busy or temporarily unavailable.
 *
 * @author mbechler
 */
public class TransWaitNamedPipe extends SmbComTransaction {

    /**
     * Constructs a wait request for a named pipe.
     *
     * @param config the configuration to use
     * @param pipeName the name of the pipe to wait for
     */

 *
 * @author mbechler
 */
public class Smb2FlushRequest extends ServerMessageBlock2Request<Smb2FlushResponse> implements RequestWithFileId {

    private byte[] fileId;

    /**
     * Constructs an SMB2 flush request
     * @param config the client configuration
     * @param fileId the file identifier to flush
     */
    public Smb2FlushRequest(final Configuration config, final byte[] fileId) {

    /** The thread being monitored. */
    protected Thread runningThread;

    /** Flag indicating if the thread is still running. */
    protected AtomicBoolean running = new AtomicBoolean();

    /**
     * Constructs an AccessTimeoutTarget with the specified thread.
     * @param thread The thread to monitor.
     */
    public AccessTimeoutTarget(final Thread thread) {
        runningThread = thread;
        running.set(true);

    private int dataRemaining;
    private int dataLength;
    private final byte[] outputBuffer;
    private final int outputBufferOffset;

    /**
     * Constructs a SMB2 read response with the specified configuration and output buffer
     *
     * @param config
     *            the configuration to use for this response
     * @param outputBuffer

 * </p>
 *
 */
public abstract class AbstractExtractor implements Extractor {

    /** The crawler container. */
    @Resource
    protected CrawlerContainer crawlerContainer;

    /**
     * Constructs a new AbstractExtractor.
     */
    public AbstractExtractor() {
        // NOP
    }

    /**
     * Registers this extractor with the ExtractorFactory.

  }

  @Override
  protected void tearDown() throws Exception {

    // Make sure we have no waiting threads.
    latch.countDown();
  }

  /** Constructs a listenable future with a value available after the latch has counted down. */
  protected abstract <V> ListenableFuture<V> createListenableFuture(
      V value, @Nullable Exception except, CountDownLatch waitOn);

    }

    SmbException(final String msg, final Throwable rootCause) {
        super(msg);
        this.rootCause = rootCause;
        status = NT_STATUS_UNSUCCESSFUL;
    }

    /**
     * Constructs an SmbException with an error code.
     *
     * @param errcode the error code
     * @param winerr true if this is a Windows error code, false for DOS error code
     */