this.userAuthorizations.addAll(KerberosAuthData.parse(authType.getValue().intValue(), authData.getOctets(), keys));
                }
                break;
            default:
                throw new PACDecodingException("Unknown field " + tagged.getTagNo());
            }
        }
    }

                catch ( GeneralSecurityException e ) {
                    throw new PACDecodingException("Decryption failed " + serverKey.getKeyType(), e);
                }
                break;
            default:
                throw new PACDecodingException("Unrecognized field " + tagged.getTagNo());
            }
        }

    }


    public String getUserPrincipalName () {

     * </table>
     * 
     * 
     * Property <tt>jcifs.smb.lmCompatibility</tt> (int, default 3)
     * 
     * @return lanman compatibility level, defaults to 3 i.e. NTLMv2 only
     */
    int getLanManCompatibility ();


    /**
     * 
     * Property <tt>jcifs.smb.allowNTLMFallback</tt> (boolean, default true)
     * 
     * @return whether to allow fallback from kerberos to NTLM
     */

    protected String oemEncoding = SmbConstants.DEFAULT_OEM_ENCODING;
    protected int flags2 = 0;
    protected int capabilities = 0;
    protected int sessionLimit = SmbConstants.DEFAULT_SSN_LIMIT;
    protected boolean smbTcpNoDelay = false;
    protected int smbResponseTimeout = SmbConstants.DEFAULT_RESPONSE_TIMEOUT;
    protected int smbSocketTimeout = SmbConstants.DEFAULT_SO_TIMEOUT;

                        ASN1OctetString mechanismListMIC = ASN1OctetString.getInstance(tagged, true);
                        setMechanismListMIC(mechanismListMIC.getOctets());
                        break;
                    default:
                        throw new IOException("Malformed token field.");
                    }
                }
        }
    }

        this.smbSendBufferSize = Config.getInt(p, "jcifs.smb.client.snd_buf_size", SmbConstants.DEFAULT_SND_BUF_SIZE);
        this.smbRecvBufferSize = Config.getInt(p, "jcifs.smb.client.rcv_buf_size", SmbConstants.DEFAULT_RCV_BUF_SIZE);
        this.smbNotifyBufferSize = Config.getInt(p, "jcifs.smb.client.notify_buf_size", SmbConstants.DEFAULT_NOTIFY_BUF_SIZE);

    {
        Properties props = new Properties();
        props.put("jcifs.smb.client.domain", "my-domain");
        props.put("jcifs.smb.client.username", "my-default-user-id");
        props.put("jcifs.smb.client.password", "my-default-password");

        CIFSContext auth = new BaseContext(new PropertyConfiguration(props));
        assertTrue(auth.hasDefaultCredentials());

                    break;
                default:
                    disconnect(true);
                    throw new NbtException(NbtException.ERR_SSN_SRVC, errorCode);
                }
                break;
            case -1:
                disconnect(true);
                throw new NbtException(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED);
            default:
                disconnect(true);

                case SmbComTransaction.TRANS2_GET_DFS_REFERRAL:
                    break;
                default:
                    throw new SmbException("Invalid operation for " + svc + " service: " + request);
                }
                break;
            default:
                throw new SmbException("Invalid operation for " + svc + " service" + request);
            }
        }
    }

public class SmbFile extends URLConnection implements SmbResource, SmbConstants {
    protected static final int ATTR_GET_MASK = 0x7FFF;
    protected static final int ATTR_SET_MASK = 0x30A7;
    protected static final int DEFAULT_ATTR_EXPIRATION_PERIOD = 5000;

    protected static final int HASH_DOT = ".".hashCode();
    protected static final int HASH_DOT_DOT = "..".hashCode();