* @param type2 The Type-2 message.
     * @param password The password.
     * @return A <code>byte[]</code> containing the LanManager response.
     */
    public static byte[] getLMResponse(Type2Message type2, String password) {
        if (type2 == null || password == null) return null;
        return NtlmPasswordAuthentication.getPreNTLMResponse(password,
                type2.getChallenge());
    }

        byte[] type3 = new byte[size];
        int pos = 0;

        System.arraycopy(NTLMSSP_SIGNATURE, 0, type3, 0, 8);
        pos += 8;

        writeULong(type3, pos, NTLMSSP_TYPE3);
        pos += 4;

        int lmOff = writeSecurityBuffer(type3, 12, lmResponseBytes);
        pos += 8;
        int ntOff = writeSecurityBuffer(type3, 20, ntResponseBytes);
        pos += 8;

            size += 8;
        }

        byte[] type2 = new byte[size];
        int pos = 0;

        System.arraycopy(NTLMSSP_SIGNATURE, 0, type2, pos, NTLMSSP_SIGNATURE.length);
        pos += NTLMSSP_SIGNATURE.length;

        writeULong(type2, pos, NTLMSSP_TYPE2);
        pos += 4;

        // TargetNameFields
        int targetNameOff = writeSecurityBuffer(type2, pos, targetBytes);
        pos += 8;

        this(type1, null, null);
    }

    /**
     * Creates a Type-2 message in response to the given Type-1 message.
     *
     * @param type1 The Type-1 message which this represents a response to.
     * @param challenge The challenge from the domain controller/server.
     * @param target The authentication target.
     */

            }
            Type1Message type1 = (Type1Message) attemptNegotiation(response);
            if (type1 == null) return; // no NTLM
            int attempt = 0;
            while (attempt < MAX_REDIRECTS) {
                connection.setRequestProperty(authProperty, authMethod + ' ' +
                        Base64.encode(type1.toByteArray()));
                connection.connect(); // send type 1

                    return;
                }
                NtlmMessage type3 = attemptNegotiation(response);
                if ( type3 == null )
                    return;
                this.connection.setRequestProperty(this.authProperty, this.authMethod + ' ' + Base64.toBase64String(type3.toByteArray()));
                this.connection.connect(); // send type 3
                if ( this.cachedOutput != null && this.doOutput ) {

        assertArgumentNotNull("type", type);
        assertArgumentNotNull("clazz", clazz);

        if (type instanceof Class) {
            return clazz.isAssignableFrom((Class<?>) type);
        }
        if (type instanceof ParameterizedType) {
            final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
            return isTypeOf(parameterizedType.getRawType(), clazz);

    }


    @Override
    public NbtAddress getNbtByName ( String host, int type, String scope ) throws UnknownHostException {
        return getNbtByName(host, type, scope, null);
    }


    @Override
    public NbtAddress getNbtByName ( String host, int type, String scope, InetAddress svr ) throws UnknownHostException {

        if ( host == null || host.length() == 0 ) {

        /* For name queries resolved by different sources (e.g. WINS,
         * BCAST, Node Status) we need to augment the hashcode generated
         * for the addresses hostname or failed lookups for one type will
         * be cached and cause other types to fail even though they may
         * not be the authority for the name. For example, if a WINS lookup
         * for FOO fails and caches unknownAddress for FOO, a subsequent

						<!-- Add libs -->
						<data>
							<type>directory</type>
							<src>${project.build.directory}/tomcat-lib</src>
							<mapper>
								<type>perm</type>
								<prefix>${packaging.fess.lib.dir}/classes</prefix>
								<user>${packaging.fess.user}</user>
								<group>${packaging.fess.group}</group>
							</mapper>
						</data>
						<data>
							<type>files</type>
							<paths>