* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.util.transport;


/**
 *
 */
public interface Response extends Message {

    /**
     * 
     * @return whether the response is received
     */
    boolean isReceived ();


    /**
     * Set received status
     */
    void received ();


    /**
     * Unset received status

package jcifs.smb1.util.transport;

public abstract class Response {
    public long expiration;
    public boolean isReceived;

                    Response response,
                    long timeout ) throws IOException {
            makeKey( request );
            response.isReceived = false;
            try {
                response_map.put( request, response );
                doSend( request );
                response.expiration = System.currentTimeMillis() + timeout;
                while (!response.isReceived) {

                            for ( Response response : this.response_map.values() ) {
                                response.error();
                            }
                        }
                        throw new IOException("end of stream");
                    }

                    Response response = this.response_map.get(key);
                    if ( response == null ) {

                    th.getConfig().getListSize() - FIND_OVERHEAD),
                this.response);

            this.nextRequest = new Trans2FindNext2(
                th.getConfig(),
                this.response.getSid(),
                this.response.getResumeKey(),
                this.response.getLastName(),
                th.getConfig().getListCount(),

    }

    private int parseResponseCode() throws IOException {
        try {
            String response = connection.getHeaderField(0);
            int index = response.indexOf(' ');
            while (response.charAt(index) == ' ') index++;
            return Integer.parseInt(response.substring(index, index + 3));
        } catch (Exception ex) {
            throw new IOException(ex.getMessage());
        }

 * @author mbechler
 * @param <T>
 *            response type
 *
 */
public interface Request <T extends CommonServerMessageBlockResponse> extends CommonServerMessageBlockRequest {

    /**
     * 
     * @param tc
     * @return the initialized response
     * @internal
     */
    public T initResponse ( CIFSContext tc );


    /**
     * 
     * @return the response message
     */
    @Override

     */
    boolean isCancel ();


    /**
     * @return chained request
     */
    Request getNext ();


    /**
     * @return the response for this request
     */
    Response getResponse ();

    static final int SESSION_REQUEST = 0x81;

    /**
     * 
     */
    public static final int POSITIVE_SESSION_RESPONSE = 0x82;

    /**
     * 
     */
    public static final int NEGATIVE_SESSION_RESPONSE = 0x83;
    static final int SESSION_RETARGET_RESPONSE = 0x84;
    static final int SESSION_KEEP_ALIVE = 0x85;

    static final int MAX_MESSAGE_SIZE = 0x0001FFFF;

                byte[] lmResponse = type3.getLMResponse();
                if (lmResponse == null) lmResponse = new byte[0];
                byte[] ntResponse = type3.getNTResponse();
                if (ntResponse == null) ntResponse = new byte[0];
                return new NtlmPasswordAuthentication(type3.getDomain(),
                        type3.getUser(), challenge, lmResponse, ntResponse);
            }
        } else {