ssn.treeConnectLogon();
                }
            }
            return new NtlmChallenge(trans.getServerEncryptionKey(), dc);
        }
        catch ( SmbException e ) {
            throw e;
        }
        catch ( IOException e ) {
            throw new SmbException("Connection failed", e);
        }
    }


    /**
     * @return
     */

                    }
                }
            }
        }
        catch ( SmbException e ) {
            throw e;
        }
        catch ( IOException e1 ) {
            log.debug("Ignoring invalid initial token", e1);
        }

            } catch (IOException ex) { }
        }
        int domainLength = domain.length;
        byte[] server = new byte[0];
        try {
            String host = NbtAddress.getLocalHost().getHostName();
            if (host != null) {
                try {
                    server = host.getBytes(UNI_ENCODING);
                } catch (IOException ex) { }
            }

            stream.close();
        }
        catch ( IOException e ) {
            throw new PACDecodingException("Malformed kerberos ticket", e);
        }

        ASN1Sequence sequence;
        try {
            sequence = ASN1Util.as(ASN1Sequence.class, derToken.getBaseObject());
        }
        catch ( IOException e ) {
            throw new PACDecodingException("Malformed kerberos ticket", e);

                            this.type = SmbConstants.TYPE_WORKGROUP;
                            return this.type;
                        }
                    }
                }
                catch ( CIFSException e ) {
                    if ( ! ( e.getCause() instanceof UnknownHostException ) ) {
                        throw e;
                    }
                    log.debug("Unknown host", e);

                if ( dirents[ i ].getType() == SmbConstants.TYPE_NAMED_PIPE ) {
                    continue;
                }
            }
            catch ( SmbAuthException sae ) {
                log.warn("Auth failed", sae);
            }
            catch ( SmbException se ) {
                log.warn("Connection failed", se);
                if ( se.getNtStatus() != NtStatus.NT_STATUS_UNSUCCESSFUL ) {

                }
            }
        }
        catch ( SmbException e ) {
            throw e;
        }
        catch ( IOException e1 ) {
            log.debug("Ignoring invalid initial token", e1);
        }

        try {
            return createContext(tc, targetDomain, host);
        }
        catch ( GSSException e ) {
            throw new SmbException("Context setup failed", e);

                        request.auth = auth;
    
                        try {
                            transport.send( request, response );
                        } catch (SmbAuthException sae) {
                            throw sae;
                        } catch (SmbException se) {
                            ex = se;
                        }
    
                        if( response.isLoggedInAsGuest &&

            LogStream.setLevel( level );
        }
        if( log.level > 2 ) {
            try {
                Config.store( log, "JCIFS PROPERTIES" );
            } catch( IOException ioe ) {
            }
        }
    }

    public void destroy() {
    }

    /**
     * This method simply calls <tt>negotiate( req, resp, false )</tt>

        int size = readUnsignedShort();
        byte[] b = new byte[size];
        read( b, 0, size );
        try {
            return Encdec.dec_utf8( b, 0, size );
        } catch( IOException ioe ) {
            throw new SmbException( "", ioe );
        }
    }
    public final void writeBoolean( boolean v ) throws SmbException {
        tmp[0] = (byte)(v ? 1 : 0);