doSkip();
                    } else {
                        doRecv( response );
                        response.isReceived = true;
                        notifyAll();
                    }
                }
            } catch( Exception ex ) {
                String msg = ex.getMessage();
                boolean timeout = msg != null && msg.equals( "Read timed out" );

      events.add(requestHeaders)
      notifyAll()
      return false
    }

    @Synchronized override fun onHeaders(
      streamId: Int,
      responseHeaders: List<Header>,
      last: Boolean,
    ): Boolean {
      assertThat(streamId).isEqualTo(2)
      assertThat(last).isTrue()
      events.add(responseHeaders)
      notifyAll()
      return false
    }

                }
            }
        }
        inDfs = false;
        inDomainDfs = false;

        connectionState = 0;

        session.transport.notifyAll();
}
    }

    public String toString() {
        return "SmbTree[share=" + share +
            ",service=" + service +
            ",tid=" + tid +
            ",inDfs=" + inDfs +

        synchronized ( this ) {
            notifyAll();
        }
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#exception(java.lang.Exception)
     */
    @Override
    public void exception ( Exception e ) {
        this.exception = e;
        synchronized ( this ) {
            notifyAll();
        }
    }


    /**

                        // responses
                        logoff(true, true);
                    }
                    throw se;
                }
                finally {
                    trans.notifyAll();
                }
            }
        }
    }


    /**
     * @param trans
     * @param chain
     * @param andxResponse
     * @throws SmbException
     */

        return obj;
    }


    private void updateLookupTable ( Name name ) {
        synchronized ( this.inFlightLookups ) {
            this.inFlightLookups.remove(name);
            this.inFlightLookups.notifyAll();
        }
    }


    void cacheAddress ( Name hostName, NbtAddress addr ) {
        if ( this.transportContext.getConfig().getNetbiosCachePolicy() == 0 ) {
            return;
        }

                            for ( Response response : this.response_map.values() ) {
                                synchronized ( response ) {
                                    response.notifyAll();
                                }
                            }
                            continue;
                        }

                        if ( log.isDebugEnabled() ) {

        }

        return obj;
    }
    private static void updateLookupTable( Name name ) {
        synchronized( LOOKUP_TABLE ) {
            LOOKUP_TABLE.remove( name );
            LOOKUP_TABLE.notifyAll();
        }
    }

/** 
 * Retrieves the local host address.
 *
 * @throws UnknownHostException This is not likely as the IP returned
 *                    by <code>InetAddress</code> should be available

        catch ( Exception e ) {
            log.warn("Failure decoding message, disconnecting transport", e);
            response.exception(e);
            synchronized ( response ) {
                response.notifyAll();
            }
            throw e;
        }

    }


    /**
     * @param response
     * @throws IOException
     * @throws SMBProtocolDecodingException
     */