try {
            try ( ASN1InputStream stream = new ASN1InputStream(new ByteArrayInputStream(token)) ) {
                sequence = ASN1Util.as(ASN1Sequence.class, stream);
            }
        }
        catch ( IOException e ) {
            throw new PACDecodingException("Malformed Kerberos Ticket", e);
        }
        return sequence;
    }

            der.writeObject(derApplicationSpecific);
            return collector.toByteArray();
        }
        catch ( IOException ex ) {
            throw new IllegalStateException(ex.getMessage());
        }
    }


    @Override
    protected void parse ( byte[] token ) throws IOException {

        this.openFlags = openFlags;
        this.access = (openFlags >>> 16) & 0xFFFF;
        if( append ) {
            try {
                fp = file.length();
            } catch( SmbAuthException sae ) {
                throw sae;
            } catch( SmbException se ) {
                fp = 0L;
            }
        }
        if( file instanceof SmbNamedPipe && file.unc.startsWith( "\\pipe\\" )) {

                break;
            } else if (id == id0) {
                try {
                    return new String(type2token, ri, len, SmbConstants.UNI_ENCODING);
                } catch (java.io.UnsupportedEncodingException uee) {
                    break;
                }
            }
            ri += len;
        }

        return null;
    }

                return calculateMacHMACAES(usage, key, data);
            }
            else {
                throw new PACDecodingException("Invalid MAC algorithm");
            }
        }
        catch ( GeneralSecurityException e ) {
            throw new PACDecodingException("Failed to calculate MAC", e);
        }
    }

        int result = -1;

        synchronized( lock ) {
            try {
                while( used == 0 ) {
                    lock.wait();
                }
            } catch( InterruptedException ie ) {
                throw new IOException( ie.getMessage() );
            }
            result = pipe_buf[beg_idx] & 0xFF;
            beg_idx = ( beg_idx + 1 ) % pipe_buf.length;
        }

     * 4 = SMB_COM_DELETE_DIRECTORY
     * 5 = SMB_COM_OPEN_ANDX
     * 6 = SMB_COM_RENAME
     * 7 = SMB_COM_TRANSACTION
     * 8 = SMB_COM_QUERY_INFORMATION
     */

    /* All batch limits are single batch only until further notice
     */

    private static byte[] batchLimits = {
        1, 1, 1, 1, 1, 1, 1, 1, 0
    };

    static {
        String s;

            out.write( buffer, 0, ssp0.writeWireFormat( buffer, 0 ));

            setSoTimeout( soTimeout );
            type = ssp0.readPacketType( in, buffer, 0 );
        } catch( IOException ioe ) {
            close();
            throw ioe;
        }

        switch( type ) {
            case SessionServicePacket.POSITIVE_SESSION_RESPONSE:
                if( log.level > 2 )

        Encdec.enc_uint32le(0, buf, i); i += 4;
        Encdec.enc_uint32le(len + 1, buf, i); i += 4;
        try {
            System.arraycopy(s.getBytes("UTF-16LE"), 0, buf, i, len * 2);
        } catch( UnsupportedEncodingException uee ) {
        }
        i += len * 2;
        buf[i++] = (byte)'\0';
        buf[i++] = (byte)'\0';
        advance(i - index);
    }

                        populate(r, tc);
                    }
                }
                result = this.table.get(name);
            }
        }
        catch ( IOException fnfe ) {
            log.error("Could not read lmhosts " + tc.getConfig().getLmHostsFileName(), fnfe); //$NON-NLS-1$
        }
        return result;
    }