text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

    <title>kadmin — MIT Kerberos Documentation</title>

    <link rel="stylesheet" href="../../_static/agogo.css" type="text/css" />
    <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
    <link rel="stylesheet" href="../../_static/kerb.css" type="text/css" />

    <link rel="author" title="About these documents" href="../../about.html" />
    <link rel="copyright" title="Copyright" href="../../copyright.html" />
    <link rel="top" title="MIT Kerberos Documentation" href="../../index.html" />
    <link rel="up" title="Administration programs" href="index.html" />
    <link rel="next" title="kadmind" href="kadmind.html" />
    <link rel="prev" title="Administration programs" href="index.html" />

MIT Kerberos Documentation

        Contents |
        previous |
        next |
        index |
        Search |
    feedback

kadmin¶

SYNOPSIS¶

kadmin
[-O|-N]
[-r realm]
[-p principal]
[-q query]
[[-c cache_name]|[-k [-t keytab]]|-n]
[-w password]
[-s admin_server[:port]]
[command args...]

kadmin.local
[-r realm]
[-p principal]
[-q query]
[-d dbname]
[-e enc:salt ...]
[-m]
[-x db_args]
[command args...]

DESCRIPTION¶

kadmin and kadmin.local are command-line interfaces to the Kerberos V5
administration system.  They provide nearly identical functionalities;
the difference is that kadmin.local directly accesses the KDC
database, while kadmin performs operations using kadmind.
Except as explicitly noted otherwise, this man page will use “kadmin”
to refer to both versions.  kadmin provides for the maintenance of
Kerberos principals, password policies, and service key tables
(keytabs).

The remote kadmin client uses Kerberos to authenticate to kadmind
using the service principal <tt class="docutils literal">kadmin/ADMINHOST</tt> (where ADMINHOST is
the fully-qualified hostname of the admin server) or <tt class="docutils literal">kadmin/admin</tt>.
If the credentials cache contains a ticket for one of these
principals, and the -c credentials_cache option is specified, that
ticket is used to authenticate to kadmind.  Otherwise, the -p and
-k options are used to specify the client Kerberos principal name
used to authenticate.  Once kadmin has determined the principal name,
it requests a service ticket from the KDC, and uses that service
ticket to authenticate to kadmind.

Since kadmin.local directly accesses the KDC database, it usually must
be run directly on the master KDC with sufficient permissions to read
the KDC database.  If the KDC database uses the LDAP database module,
kadmin.local can be run on any host which can access the LDAP server.

OPTIONS¶

-r realm

Use realm as the default database realm.

-p principal

Use principal to authenticate.  Otherwise, kadmin will append
<tt class="docutils literal">/admin</tt> to the primary principal name of the default ccache,
the value of the USER environment variable, or the username as
obtained with getpwuid, in order of preference.

-k

Use a keytab to decrypt the KDC response instead of prompting for
a password.  In this case, the default principal will be
<tt class="docutils literal">host/hostname</tt>.  If there is no keytab specified with the
-t option, then the default keytab will be used.

-t keytab

Use keytab to decrypt the KDC response.  This can only be used
with the -k option.

-n

Requests anonymous processing.  Two types of anonymous principals
are supported.  For fully anonymous Kerberos, configure PKINIT on
the KDC and configure pkinit_anchors in the client’s
krb5.conf.  Then use the -n option with a principal
of the form <tt class="docutils literal">@REALM</tt> (an empty principal name followed by the
at-sign and a realm name).  If permitted by the KDC, an anonymous
ticket will be returned.  A second form of anonymous tickets is
supported; these realm-exposed tickets hide the identity of the
client but not the client’s realm.  For this mode, use <tt class="docutils literal">kinit
-n</tt> with a normal principal name.  If supported by the KDC, the
principal (but not realm) will be replaced by the anonymous
principal.  As of release 1.8, the MIT Kerberos KDC only supports
fully anonymous operation.

-c credentials_cache

Use credentials_cache as the credentials cache.  The
cache should contain a service ticket for the <tt class="docutils literal">kadmin/ADMINHOST</tt>
(where ADMINHOST is the fully-qualified hostname of the admin
server) or <tt class="docutils literal">kadmin/admin</tt> service; it can be acquired with the
kinit program.  If this option is not specified, kadmin
requests a new service ticket from the KDC, and stores it in its
own temporary ccache.

-w password

Use password instead of prompting for one.  Use this option with
care, as it may expose the password to other users on the system
via the process list.

-q query

Perform the specified query and then exit.

-d dbname

Specifies the name of the KDC database.  This option does not
apply to the LDAP database module.

-s admin_server[:port]

Specifies the admin server which kadmin should contact.

-m

If using kadmin.local, prompt for the database master password
instead of reading it from a stash file.

-e “enc:salt ...”

Sets the keysalt list to be used for any new keys created.  See
Keysalt lists in kdc.conf for a list of possible
values.

-O

Force use of old AUTH_GSSAPI authentication flavor.

-N

Prevent fallback to AUTH_GSSAPI authentication flavor.

-x db_args

Specifies the database specific arguments.  See the next section
for supported options.

Starting with release 1.14, if any command-line arguments remain after
the options, they will be treated as a single query to be executed.
This mode of operation is intended for scripts and behaves differently
from the interactive mode in several respects:

Query arguments are split by the shell, not by kadmin.

Informational and warning messages are suppressed.  Error messages
and query output (e.g. for get_principal) will still be
displayed.

Confirmation prompts are disabled (as if -force was given).
Password prompts will still be issued as required.

The exit status will be non-zero if the query fails.

The -q option does not carry these behavior differences; the query
will be processed as if it was entered interactively.  The -q
option cannot be used in combination with a query in the remaining
arguments.

DATABASE OPTIONS¶

Database options can be used to override database-specific defaults.
Supported options for the DB2 module are:

-x dbname=*filename*

Specifies the base filename of the DB2 database.

-x lockiter

Make iteration operations hold the lock for the duration of
the entire operation, rather than temporarily releasing the
lock while handling each principal.  This is the default
behavior, but this option exists to allow command line
override of a [dbmodules] setting.  First introduced in
release 1.13.

-x unlockiter

Make iteration operations unlock the database for each
principal, instead of holding the lock for the duration of the
entire operation.  First introduced in release 1.13.

Supported options for the LDAP module are:

-x host=ldapuri

Specifies the LDAP server to connect to by a LDAP URI.

-x binddn=bind_dn

Specifies the DN used to bind to the LDAP server.

-x bindpwd=password

Specifies the password or SASL secret used to bind to the LDAP
server.  Using this option may expose the password to other
users on the system via the process list; to avoid this,
instead stash the password using the stashsrvpw command of
kdb5_ldap_util.

-x sasl_mech=mechanism

Specifies the SASL mechanism used to bind to the LDAP server.
The bind DN is ignored if a SASL mechanism is used.  New in
release 1.13.

-x sasl_authcid=name

Specifies the authentication name used when binding to the
LDAP server with a SASL mechanism, if the mechanism requires
one.  New in release 1.13.

-x sasl_authzid=name

Specifies the authorization name used when binding to the LDAP
server with a SASL mechanism.  New in release 1.13.

-x sasl_realm=realm

Specifies the realm used when binding to the LDAP server with
a SASL mechanism, if the mechanism uses one.  New in release
1.13.

-x debug=level

sets the OpenLDAP client library debug level.  level is an
integer to be interpreted by the library.  Debugging messages
are printed to standard error.  New in release 1.12.

COMMANDS¶

When using the remote client, available commands may be restricted
according to the privileges specified in the kadm5.acl file
on the admin server.

add_principal¶

add_principal [options] newprinc

Creates the principal newprinc, prompting twice for a password.  If
no password policy is specified with the -policy option, and the
policy named <tt class="docutils literal">default</tt> is assigned to the principal if it exists.
However, creating a policy named <tt class="docutils literal">default</tt> will not automatically
assign this policy to previously existing principals.  This policy
assignment can be suppressed with the -clearpolicy option.

This command requires the add privilege.

Aliases: addprinc, ank

Options:

-expire expdate

(getdate time string) The expiration date of the principal.

-pwexpire pwexpdate

(getdate time string) The password expiration date.

-maxlife maxlife

(Time duration or getdate time string) The maximum ticket life
for the principal.

-maxrenewlife maxrenewlife

(Time duration or getdate time string) The maximum renewable
life of tickets for the principal.

-kvno kvno

The initial key version number.

-policy policy

The password policy used by this principal.  If not specified, the
policy <tt class="docutils literal">default</tt> is used if it exists (unless -clearpolicy
is specified).

-clearpolicy

Prevents any policy from being assigned when -policy is not
specified.

{-|+}allow_postdated

-allow_postdated prohibits this principal from obtaining
postdated tickets.  +allow_postdated clears this flag.

{-|+}allow_forwardable

-allow_forwardable prohibits this principal from obtaining
forwardable tickets.  +allow_forwardable clears this flag.

{-|+}allow_renewable

-allow_renewable prohibits this principal from obtaining
renewable tickets.  +allow_renewable clears this flag.

{-|+}allow_proxiable

-allow_proxiable prohibits this principal from obtaining
proxiable tickets.  +allow_proxiable clears this flag.

{-|+}allow_dup_skey

-allow_dup_skey disables user-to-user authentication for this
principal by prohibiting this principal from obtaining a session
key for another user.  +allow_dup_skey clears this flag.

{-|+}requires_preauth

+requires_preauth requires this principal to preauthenticate
before being allowed to kinit.  -requires_preauth clears this
flag.  When +requires_preauth is set on a service principal,
the KDC will only issue service tickets for that service principal
if the client’s initial authentication was performed using
preauthentication.

{-|+}requires_hwauth

+requires_hwauth requires this principal to preauthenticate
using a hardware device before being allowed to kinit.
-requires_hwauth clears this flag.  When +requires_hwauth is
set on a service principal, the KDC will only issue service tickets
for that service principal if the client’s initial authentication was
performed using a hardware device to preauthenticate.

{-|+}ok_as_delegate

+ok_as_delegate sets the okay as delegate flag on tickets
issued with this principal as the service.  Clients may use this
flag as a hint that credentials should be delegated when
authenticating to the service.  -ok_as_delegate clears this
flag.

{-|+}allow_svr

-allow_svr prohibits the issuance of service tickets for this
principal.  +allow_svr clears this flag.

{-|+}allow_tgs_req

-allow_tgs_req specifies that a Ticket-Granting Service (TGS)
request for a service ticket for this principal is not permitted.
+allow_tgs_req clears this flag.

{-|+}allow_tix

-allow_tix forbids the issuance of any tickets for this
principal.  +allow_tix clears this flag.

{-|+}needchange

+needchange forces a password change on the next initial
authentication to this principal.  -needchange clears this
flag.

{-|+}password_changing_service

+password_changing_service marks this principal as a password
change service principal.

{-|+}ok_to_auth_as_delegate

+ok_to_auth_as_delegate allows this principal to acquire
forwardable tickets to itself from arbitrary users, for use with
constrained delegation.

{-|+}no_auth_data_required

+no_auth_data_required prevents PAC or AD-SIGNEDPATH data from
being added to service tickets for the principal.

{-|+}lockdown_keys

+lockdown_keys prevents keys for this principal from leaving
the KDC via kadmind.  The chpass and extract operations are denied
for a principal with this attribute.  The chrand operation is
allowed, but will not return the new keys.  The delete and rename
operations are also denied if this attribute is set, in order to
prevent a malicious administrator from replacing principals like
krbtgt/* or kadmin/* with new principals without the attribute.
This attribute can be set via the network protocol, but can only
be removed using kadmin.local.

-randkey

Sets the key of the principal to a random value.

-nokey

Causes the principal to be created with no key.  New in release
1.12.

-pw password

Sets the password of the principal to the specified string and
does not prompt for a password.  Note: using this option in a
shell script may expose the password to other users on the system
via the process list.

-e enc:salt,...

Uses the specified keysalt list for setting the keys of the
principal.  See Keysalt lists in kdc.conf for a
list of possible values.

-x db_princ_args

Indicates database-specific options.  The options for the LDAP
database module are:

-x dn=dn

Specifies the LDAP object that will contain the Kerberos
principal being created.

-x linkdn=dn

Specifies the LDAP object to which the newly created Kerberos
principal object will point.

-x containerdn=container_dn

Specifies the container object under which the Kerberos
principal is to be created.

-x tktpolicy=policy

Associates a ticket policy to the Kerberos principal.

Note

The containerdn and linkdn options cannot be
specified with the dn option.

If the dn or containerdn options are not specified while
adding the principal, the principals are created under the
principal container configured in the realm or the realm
container.

dn and containerdn should be within the subtrees or
principal container configured in the realm.

Example:

kadmin: addprinc jennifer
WARNING: no policy specified for "jennifer@ATHENA.MIT.EDU";
defaulting to no policy.
Enter password for principal jennifer@ATHENA.MIT.EDU:
Re-enter password for principal jennifer@ATHENA.MIT.EDU:
Principal "jennifer@ATHENA.MIT.EDU" created.
kadmin:

modify_principal¶

modify_principal [options] principal

Modifies the specified principal, changing the fields as specified.
The options to add_principal also apply to this command, except
for the -randkey, -pw, and -e options.  In addition, the
option -clearpolicy will clear the current policy of a principal.

This command requires the modify privilege.

Alias: modprinc

Options (in addition to the addprinc options):

-unlock

Unlocks a locked principal (one which has received too many failed
authentication attempts without enough time between them according
to its password policy) so that it can successfully authenticate.

rename_principal¶

rename_principal [-force] old_principal new_principal

Renames the specified old_principal to new_principal.  This
command prompts for confirmation, unless the -force option is
given.

This command requires the add and delete privileges.

Alias: renprinc

delete_principal¶

delete_principal [-force] principal

Deletes the specified principal from the database.  This command
prompts for deletion, unless the -force option is given.

This command requires the delete privilege.

Alias: delprinc

change_password¶

change_password [options] principal

Changes the password of principal.  Prompts for a new password if
neither -randkey or -pw is specified.

This command requires the changepw privilege, or that the
principal running the program is the same as the principal being
changed.

Alias: cpw

The following options are available:

-randkey

Sets the key of the principal to a random value.

-pw password

Set the password to the specified string.  Using this option in a
script may expose the password to other users on the system via
the process list.

-e enc:salt,...

Uses the specified keysalt list for setting the keys of the
principal.  See Keysalt lists in kdc.conf for a
list of possible values.

-keepold

Keeps the existing keys in the database.  This flag is usually not
necessary except perhaps for <tt class="docutils literal">krbtgt</tt> principals.

Example:

kadmin: cpw systest
Enter password for principal systest@BLEEP.COM:
Re-enter password for principal systest@BLEEP.COM:
Password for systest@BLEEP.COM changed.
kadmin:

purgekeys¶

purgekeys [-all|-keepkvno oldest_kvno_to_keep] principal

Purges previously retained old keys (e.g., from change_password
-keepold) from principal.  If -keepkvno is specified, then
only purges keys with kvnos lower than oldest_kvno_to_keep.  If
-all is specified, then all keys are purged.  The -all option
is new in release 1.12.

This command requires the modify privilege.

get_principal¶

get_principal [-terse] principal

Gets the attributes of principal.  With the -terse option, outputs
fields as quoted tab-separated strings.

This command requires the inquire privilege, or that the principal
running the the program to be the same as the one being listed.

Alias: getprinc

Examples:

kadmin: getprinc tlyu/admin
Principal: tlyu/admin@BLEEP.COM
Expiration date: [never]
Last password change: Mon Aug 12 14:16:47 EDT 1996
Password expiration date: [none]
Maximum ticket life: 0 days 10:00:00
Maximum renewable life: 7 days 00:00:00
Last modified: Mon Aug 12 14:16:47 EDT 1996 (bjaspan/admin@BLEEP.COM)
Last successful authentication: [never]
Last failed authentication: [never]
Failed password attempts: 0
Number of keys: 2
Key: vno 1, des-cbc-crc
Key: vno 1, des-cbc-crc:v4
Attributes:
Policy: [none]

kadmin: getprinc -terse systest
systest@BLEEP.COM   3    86400     604800    1
785926535 753241234 785900000
tlyu/admin@BLEEP.COM     786100034 0    0
kadmin:

list_principals¶

list_principals [expression]

Retrieves all or some principal names.  expression is a shell-style
glob expression that can contain the wild-card characters <tt class="docutils literal">?</tt>,
<tt class="docutils literal">*</tt>, and <tt class="docutils literal">[]</tt>.  All principal names matching the expression are
printed.  If no expression is provided, all principal names are
printed.  If the expression does not contain an <tt class="docutils literal">@</tt> character, an
<tt class="docutils literal">@</tt> character followed by the local realm is appended to the
expression.

This command requires the list privilege.

Alias: listprincs, get_principals, get_princs

Example:

kadmin:  listprincs test*
test3@SECURE-TEST.OV.COM
test2@SECURE-TEST.OV.COM
test1@SECURE-TEST.OV.COM
testuser@SECURE-TEST.OV.COM
kadmin:

get_strings¶

get_strings principal

Displays string attributes on principal.

This command requires the inquire privilege.

Alias: getstr

set_string¶

set_string principal name value

Sets a string attribute on principal.  String attributes are used to
supply per-principal configuration to the KDC and some KDC plugin
modules.  The following string attribute names are recognized by the
KDC:

require_auth

Specifies an authentication indicator which is required to
authenticate to the principal as a service.  Multiple indicators
can be specified, separated by spaces; in this case any of the
specified indicators will be accepted.  (New in release 1.14.)

session_enctypes

Specifies the encryption types supported for session keys when the
principal is authenticated to as a server.  See
Encryption types in kdc.conf for a list of the
accepted values.

otp

Enables One Time Passwords (OTP) preauthentication for a client
principal.  The value is a JSON string representing an array
of objects, each having optional <tt class="docutils literal">type</tt> and <tt class="docutils literal">username</tt> fields.

pkinit_cert_match

Specifies a matching expression that defines the certificate
attributes required for the client certificate used by the
principal during PKINIT authentication.  The matching expression
is in the same format as those used by the pkinit_cert_match
option in krb5.conf.  (New in release 1.16.)

This command requires the modify privilege.

Alias: setstr

Example:

set_string host/foo.mit.edu session_enctypes aes128-cts
set_string user@FOO.COM otp "[{""type"":""hotp"",""username"":""al""}]"

del_string¶

del_string principal key

Deletes a string attribute from principal.

This command requires the delete privilege.

Alias: delstr

add_policy¶

add_policy [options] policy

Adds a password policy named policy to the database.

This command requires the add privilege.

Alias: addpol

The following options are available:

-maxlife time

(Time duration or getdate time string) Sets the maximum
lifetime of a password.

-minlife time

(Time duration or getdate time string) Sets the minimum
lifetime of a password.

-minlength length

Sets the minimum length of a password.

-minclasses number

Sets the minimum number of character classes required in a
password.  The five character classes are lower case, upper case,
numbers, punctuation, and whitespace/unprintable characters.

-history number

Sets the number of past keys kept for a principal.  This option is
not supported with the LDAP KDC database module.

-maxfailure maxnumber

Sets the number of authentication failures before the principal is
locked.  Authentication failures are only tracked for principals
which require preauthentication.  The counter of failed attempts
resets to 0 after a successful attempt to authenticate.  A
maxnumber value of 0 (the default) disables lockout.

-failurecountinterval failuretime

(Time duration or getdate time string) Sets the allowable time
between authentication failures.  If an authentication failure
happens after failuretime has elapsed since the previous
failure, the number of authentication failures is reset to 1.  A
failuretime value of 0 (the default) means forever.

-lockoutduration lockouttime

(Time duration or getdate time string) Sets the duration for
which the principal is locked from authenticating if too many
authentication failures occur without the specified failure count
interval elapsing.  A duration of 0 (the default) means the
principal remains locked out until it is administratively unlocked
with <tt class="docutils literal">modprinc -unlock</tt>.

-allowedkeysalts

Specifies the key/salt tuples supported for long-term keys when
setting or changing a principal’s password/keys.  See
Keysalt lists in kdc.conf for a list of the
accepted values, but note that key/salt tuples must be separated
with commas (‘,’) only.  To clear the allowed key/salt policy use
a value of ‘-‘.

Example:

kadmin: add_policy -maxlife "2 days" -minlength 5 guests
kadmin:

modify_policy¶

modify_policy [options] policy

Modifies the password policy named policy.  Options are as described
for add_policy.

This command requires the modify privilege.

Alias: modpol

delete_policy¶

delete_policy [-force] policy

Deletes the password policy named policy.  Prompts for confirmation
before deletion.  The command will fail if the policy is in use by any
principals.

This command requires the delete privilege.

Alias: delpol

Example:

kadmin: del_policy guests
Are you sure you want to delete the policy "guests"?
(yes/no): yes
kadmin:

get_policy¶

get_policy [ -terse ] policy

Displays the values of the password policy named policy.  With the
-terse flag, outputs the fields as quoted strings separated by
tabs.

This command requires the inquire privilege.

Alias: getpol

Examples:

kadmin: get_policy admin
Policy: admin
Maximum password life: 180 days 00:00:00
Minimum password life: 00:00:00
Minimum password length: 6
Minimum number of password character classes: 2
Number of old keys kept: 5
Reference count: 17

kadmin: get_policy -terse admin
admin     15552000  0    6    2    5    17
kadmin:

The “Reference count” is the number of principals using that policy.
With the LDAP KDC database module, the reference count field is not
meaningful.

list_policies¶

list_policies [expression]

Retrieves all or some policy names.  expression is a shell-style
glob expression that can contain the wild-card characters <tt class="docutils literal">?</tt>,
<tt class="docutils literal">*</tt>, and <tt class="docutils literal">[]</tt>.  All policy names matching the expression are
printed.  If no expression is provided, all existing policy names are
printed.

This command requires the list privilege.

Aliases: listpols, get_policies, getpols.

Examples:

kadmin:  listpols
test-pol
dict-only
once-a-min
test-pol-nopw

kadmin:  listpols t*
test-pol
test-pol-nopw
kadmin:

ktadd¶

ktadd [options] principal

ktadd [options] -glob princ-exp

Adds a principal, or all principals matching princ-exp, to a
keytab file.  Each principal’s keys are randomized in the process.
The rules for princ-exp are described in the list_principals
command.

This command requires the inquire and changepw privileges.
With the -glob form, it also requires the list privilege.

The options are:

-k[eytab] keytab

Use keytab as the keytab file.  Otherwise, the default keytab is
used.

-e enc:salt,...

Uses the specified keysalt list for setting the new keys of the
principal.  See Keysalt lists in kdc.conf for a
list of possible values.

-q

Display less verbose information.

-norandkey

Do not randomize the keys. The keys and their version numbers stay
unchanged.  This option cannot be specified in combination with the
-e option.

An entry for each of the principal’s unique encryption types is added,
ignoring multiple keys with the same encryption type but different
salt types.

Example:

kadmin: ktadd -k /tmp/foo-new-keytab host/foo.mit.edu
Entry for principal host/foo.mit.edu@ATHENA.MIT.EDU with kvno 3,
     encryption type aes256-cts-hmac-sha1-96 added to keytab
     FILE:/tmp/foo-new-keytab
kadmin:

ktremove¶

ktremove [options] principal [kvno | all | old]

Removes entries for the specified principal from a keytab.  Requires
no permissions, since this does not require database access.

If the string “all” is specified, all entries for that principal are
removed; if the string “old” is specified, all entries for that
principal except those with the highest kvno are removed.  Otherwise,
the value specified is parsed as an integer, and all entries whose
kvno match that integer are removed.

The options are:

-k[eytab] keytab

Use keytab as the keytab file.  Otherwise, the default keytab is
used.

-q

Display less verbose information.

Example:

kadmin: ktremove kadmin/admin all
Entry for principal kadmin/admin with kvno 3 removed from keytab
     FILE:/etc/krb5.keytab
kadmin:

lock¶

Lock database exclusively.  Use with extreme caution!  This command
only works with the DB2 KDC database module.

unlock¶

Release the exclusive database lock.

list_requests¶

Lists available for kadmin requests.

Aliases: lr, ?

quit¶

Exit program.  If the database was locked, the lock is released.

Aliases: exit, q

HISTORY¶

The kadmin program was originally written by Tom Yu at MIT, as an
interface to the OpenVision Kerberos administration program.

SEE ALSO¶

kpasswd, kadmind

On this page

kadmin

SYNOPSIS

DESCRIPTION

OPTIONS

DATABASE OPTIONS

COMMANDS

add_principal

modify_principal

rename_principal

delete_principal

change_password

purgekeys

get_principal

list_principals

get_strings

set_string

del_string

add_policy

modify_policy

delete_policy

get_policy

list_policies

ktadd

ktremove

lock

unlock

list_requests

quit

HISTORY

SEE ALSO

Table of contents

For users

For administrators

Installation guide

Configuration Files

Realm configuration decisions

Database administration

Account lockout

Configuring Kerberos with OpenLDAP back-end

Application servers

Host configuration

Backups of secure hosts

PKINIT configuration

OTP Preauthentication

Principal names and DNS

Encryption types

HTTPS proxy configuration

Authentication indicators

Administration  programs

kadmin

kadmind

kdb5_util

kdb5_ldap_util

krb5kdc

kprop

kpropd

kproplog

ktutil

k5srvutil

sserver

MIT Kerberos defaults

Environment variables

Troubleshooting

Advanced topics

Various links

For application developers

For plugin module developers

Building Kerberos V5

Kerberos V5 concepts

Protocols and file formats

MIT Kerberos features

How to build this documentation from the source

Contributing to the MIT Kerberos Documentation

Resources

Full Table of Contents

Search

    <form class="search" action="../../search.html" method="get">
      <input type="text" name="q" size="18" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>

Release: 1.16

                © Copyright 1985-2017, MIT.

        Contents |
        previous |
        next |
        index |
        Search |
    feedback


text:
""" Different file parsers for TACA
"""
import os
import xml.etree.ElementTree as ET

#######################################
# Raw data status/stats files parsers #
#######################################

def get_read_configuration(run_path):
    """Parse the RunInfo.xml to read configuration and return a list of dicts

    :param str run_path: Path to the run directory
    :returns: List of dicts corresponding to sections in RunInfo.xml
    :rtype: list
    :raises RunTimeError: If no RunInfo.xml file is found
    """
    reads = []
    run_info_file = os.path.join(run_path, "RunInfo.xml")
    try:
        tree = ET.ElementTree()
        tree.parse(run_info_file)
        read_elem = tree.find("Run/Reads")
        for read in read_elem:
            reads.append(dict(zip(read.keys(), [read.get(k) for k in read.keys()])))
        return reads
    except IOError:
        raise RuntimeError('No RunInfo.xml file found in {}. Please check.'.format(run_path))

def last_index_read(run):
    """Parse the number of the highest index read from the RunInfo.xml file

    :param str run: Run directory
    :returns: Highest index read
    :rtype: int
    """
    read_numbers = [int(read.get("Number", 0)) for read in get_read_configuration(run) if read.get("IsIndexedRead", "") == "Y"]
    return 0 if len(read_numbers) == 0 else max(read_numbers)

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="UTF-8"?>

getmaintainers_test


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
avrora.stack
</TITLE>

<META NAME="keywords" CONTENT="avrora.stack package">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../stylesheet.css" TITLE="Style">

avrora.stack

Interfaces

AnalyzerPolicy

IORegisterConstants

Classes

AbstractArithmetic

AbstractInterpreter

AbstractState

Analyzer

MutableState

StateCache

StatePrinter

StateTransitionGraph

StateTransitionGraph.Edge

StateTransitionGraph.EdgeList

StateTransitionGraph.StateInfo

StateTransitionGraph.StateList


text:
package com.intellij.compiler.actions;

import com.intellij.ide.nls.NlsMessages;
import com.intellij.openapi.actionSystem.*;
import com.intellij.openapi.compiler.JavaCompilerBundle;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
import com.intellij.task.ProjectTaskManager;
import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NotNull;

import java.util.stream.Stream;

public class MakeModuleAction extends CompileActionBase {
  private static final Logger LOG = Logger.getInstance(MakeModuleAction.class);

  @Override
  protected void doAction(@NotNull AnActionEvent event, Project project) {
    try {
      final DataContext dataContext = event.getDataContext();
      final Module[] modules = dataContext.getData(LangDataKeys.MODULE_CONTEXT_ARRAY);
      if (modules != null) {
        ProjectTaskManager.getInstance(project).build(modules);
      }
      else {
        final Module module = dataContext.getData(PlatformCoreDataKeys.MODULE);
        if (module != null) {
          ProjectTaskManager.getInstance(project).build(module);
        }
      }
    }
    catch (Exception e) {
      LOG.error(e);
    }
  }

  @Override
  public void update(@NotNull AnActionEvent event){
    super.update(event);
    Presentation presentation = event.getPresentation();
    if (!presentation.isEnabled()) {
      return;
    }
    boolean isEnabled = false;
    String presentationText;
    final Module[] modules = event.getData(LangDataKeys.MODULE_CONTEXT_ARRAY);
    if (modules != null) {
      isEnabled = true;
      if (ArrayUtil.contains(null, modules)) {
        final DataContext dataContext = event.getDataContext();
        LOG.error("Unexpected null module slipped through validator; dataContext = " + dataContext + "; class = "+dataContext.getClass().getName());
      }
      if (modules.length == 1) {
        presentationText = JavaCompilerBundle.message("action.make.single.module.text", modules[0].getName());
      }
      else {
        String moduleNames = Stream.of(modules).map(m -> "'"+m.getName()+"'").collect(NlsMessages.joiningNarrowAnd());
        presentationText = moduleNames.length() > 20 ?
                           JavaCompilerBundle.message("action.make.selected.modules.text") :
                           JavaCompilerBundle.message("action.make.few.modules.text", moduleNames);
      }
    }
    else {
      final Module module = event.getData(PlatformCoreDataKeys.MODULE);
      if (module != null) {
        isEnabled = true;
        presentationText = JavaCompilerBundle.message("action.make.single.module.text", module.getName());
      }
      else {
        presentationText = getTemplatePresentation().getTextWithMnemonic();
      }
    }
    presentation.setText(presentationText);
    presentation.setEnabled(isEnabled);
    presentation.setVisible(isEnabled || !ActionPlaces.PROJECT_VIEW_POPUP.equals(event.getPlace()));
  }
}


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <artifactId>bcds-parent</artifactId>
        <groupId>gov.va.vba</groupId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../bcds</relativePath>
    </parent>

    <artifactId>cdm-schema</artifactId>
    <name>BCDS - Generated CDM schema JAXB classes</name>

    <dependencies>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.jvnet.jaxb2.maven2</groupId>
                <artifactId>maven-jaxb2-plugin</artifactId>
                <executions>
                    <execution>
                        <id>Common Schema</id>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                        <configuration>
                            <schemaDirectory>src/main/resources/schemas</schemaDirectory>
                            <schemaIncludes>
                                <include>**/*.xsd</include>
                            </schemaIncludes>
                            <strict>false</strict>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>


text:
var FilterOption = require('../../core/filter_option.js');

// <option name="STRING!" value="STRING!"/>
FilterOption.parseXML = function (xml) {
    var pF     = require('../../util/parsingFunctions.js'),
        option = new FilterOption();
    if (xml) {
        option.name(pF.getXMLAttr(xml,"name"));
        option.value(pF.getXMLAttr(xml,"value") === "" ? undefined : pF.getXMLAttr(xml,"value"));
    }
    return option;
};

module.exports = FilterOption;


text:
<component name="for">
	<arg name="items"/>
	<arg name="as"/>
	<arg name="index"/>
	<arg name="each" transclude="true"/>
	<script>
		self.render = function(){
			self.$el.empty();
			scope.items.forEach(function(item, i){
				var local = {};
				local[scope.as] = item;
				if(scope.index){
					local[scope.index] = i;
				}
				var newScope = _.extend(local, scope);
				self.$el.append(scope.each(newScope));
			});
    	};
	 </script>
</component>


text: Bedrock dockerized for quick WordPress development


text:
An easy Clojure app, easily deployable to Heroku, for accumulating SMS server notifications.

This application is based on [Getting Started with Clojure](https://devcenter.heroku.com/articles/getting-started-with-clojure) article - check it out.

## Running Locally

Make sure you have Clojure installed.  Also, install the [Heroku Toolbelt](https://toolbelt.heroku.com/).

```sh
$ git clone https://github.com/ivanhernandez/sms-receipts.git
$ cd sms-receipts
$ lein repl
```
```clojure
user=>(require 'sms-receipts.web)
user=>(def server (sms-receipts.web/-main))
```

Your app should now be running on [localhost:5000](http://localhost:5000/).

## Deploying to Heroku

```sh
$ heroku create
$ git push heroku master
$ heroku open
```

## Documentation

For more information about using Clojure on Heroku, see these Dev Center articles:

- [Clojure on Heroku](https://devcenter.heroku.com/categories/clojure)


text:
__author__ = 'mriegel'

import os

environment = os.environ.get("DJANGO_ENV", "staging")

if environment == "staging":
    from .staging import *

if environment == "development":
    from .development import *


text:
<!DOCTYPE html>

<html ng-app="miAppModule">

  <head>
      <meta charset="utf-8">
      <title>Angular JS</title>
      <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/angularjs/1.4.7/angular.min.js"></script>
      <script type="text/javascript" src="https://code.angularjs.org/1.4.7/angular-route.min.js"></script>
      <script type="text/javascript" src="http://code.jquery.com/jquery-latest.min.js"></script>
      <script type="text/javascript" src="js/autocomplete-jquery-ui.js"></script>
      <script type="text/javascript" src="js/app.js"></script>
      <script type="text/javascript" src="js/controllers.js"></script>
      <script type="text/javascript" src="js/directives.js"></script>

      <link rel="stylesheet" type="text/css" href="css/autocomplete-jquery-ui.structure.css" />
      <link rel="stylesheet" type="text/css" href="css/style.css" />

      <style type="text/css">
        .circular {
          border-radius: 50%;
          width: 100px;
          height: 100px;
          display: inline-block;
          }

        .no-list{
          list-style-type: none;
        }

        body,html{
          text-align: center;
          background-color: #eee;
          margin: 0px;
        }
      </style>
  </head>

  <body>
    <div ng-view></div>

  </body>

</html>


text:
<?xml version="1.0"?>
<package>
  <name>otl_pepper_apps</name>
  <version>0.0.0</version>
  <description>The otl_pepper_apps package</description>

  <maintainer email="t.ogura@gmail.com">Takashi Ogura</maintainer>

  <license>BSD</license>
  <url type="website">http://wiki.ros.org/otl_pepper_apps</url>
  <author email="t.ogura@gmail.com">Takashi Ogura</author>
  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>rospy</build_depend>
  <run_depend>ros_myo</run_depend>
  <run_depend>rospy</run_depend>
  <run_depend>geometry_msgs</run_depend>
  <run_depend>naoqi_msgs</run_depend>
  <run_depend>std_msgs</run_depend>
</package>


text:
import express from 'express';
import rewrite from 'express-urlrewrite';
import httpProxy from 'http-proxy';
import { sortBy } from 'lodash';
import marked from 'marked';
import { config, storage, commons, gengine } from 'structor-commons';
import * as gengineManager from '../commons/gengine';
import * as middlewareCompilerManager from './middlewareCompilerManager.js';
import * as extractManager from './extractManager.js';
import * as installManager from './installManager.js';

export const STRUCTOR_URLS = [
  '/structor',
  '/structor-invoke',
  '/structor-sandbox',
  '/structor-deskpage',
  '/structor-dev',
  '/structor-desk',
  '/structor-sandbox-preview',
  '/structor-sandbox-screenshot',
  '/structor-gengine-scaffolds'
];

let serverRef = undefined;
let proxy = undefined;

export function loopback (options) {
  return Promise.resolve('Response: ' + options.message);
}

export function error (options) {
  return Promise.reject('Response: ' + options.message);
}

export function setServer (server) {
  serverRef = server;
  if (config.status() === config.READY) {
    initServer();
    initProxyServer();
  }
}

function initServer () {
  if (serverRef) {
    serverRef.app.use(middlewareCompilerManager.getDevMiddleware());
    serverRef.app.use(middlewareCompilerManager.getHotMiddleware());
    serverRef.app.use(middlewareCompilerManager.getBuilderMiddleware({
      callback: stats => {
        if (serverRef.ioSocketClient) {
          serverRef.ioSocketClient.emit('compiler.message', stats);
        }
      }
    }));
    serverRef.app.use(rewrite('/structor-deskpage/*', '/structor-desk/index.html'));
    serverRef.app.use('/structor-desk', express.static(config.deskDirPath()));
    serverRef.app.use('/structor-gengine-scaffolds', express.static(config.scaffoldsDirPath()));
  }
}

function initProxyServer () {
  if (serverRef) {
    if (!proxy) {
      proxy = httpProxy.createProxyServer({});
      proxy.on('error', (err, req, res) => {
        const statusText = 'Proxy server error connecting to ' + config.projectProxyURL() + req.url + ' ' + (err.message ? err.message : err);
        res.writeHead(500, statusText);
        res.end(statusText);
        console.error(statusText);
      });
      proxy.on('proxyReq', () => {
        let projectProxyURL = config.projectProxyURL();
        if (projectProxyURL) {
          const proxyURL = projectProxyURL.replace('http://', '');
          return (proxyReq, req, res, options) => {
            proxyReq.setHeader('X-Forwarded-Host', proxyURL);
          };
        }
      });
      //
      serverRef.app.all('/*', (req, res, next) => {
        let url = req.url;
        if (checkDeniedProxyURL(url)) {
          next('route');
        } else {
          let proxyURL = config.projectProxyURL();
          if (proxyURL && proxyURL.length > 0 && url.indexOf(proxyURL) >= 0) {
            proxy.web(req, res, {target: proxyURL});
          } else {
            // all other requests redirect to deskpage
            res.redirect('/structor-deskpage' + url.replace('http://', ''));
          }
        }
      });
    }
  }
}

function checkDeniedProxyURL (textUrl) {
  let isDenied = false;
  if (textUrl) {
    for (let i = 0; i < STRUCTOR_URLS.length; i++) {
      if (textUrl.indexOf(STRUCTOR_URLS[i]) === 0) {
        isDenied = true;
        break;
      }
    }
  }
  return isDenied;
}

export function getModel () {
  return storage.readProjectJsonModel();
}

export function getConfig () {

  return Promise.resolve(config.asObject());
}

export function getProjectStatus () {
  return Promise.resolve(config.status());
}

export function setProxyURL (options) {
  return config.projectProxyURL(options.proxyURL)
    .then(() => {
      initProxyServer();
    });
}

export function getComponentTree () {
  return storage.getComponentTree();
}

export function writeComponentDefaults (options) {
  const {componentName, namespace, defaults} = options;
  return storage.writeComponentDefaults(componentName, namespace, defaults);
}

export function getComponentNotes (options) {
  const {componentName, namespace} = options;
  return storage.readComponentDocument(componentName, namespace)
    .then(readmeText => {
      let propNames = [];
      if (readmeText && readmeText.length > 0) {
        marked(readmeText, {
          highlight: function (code) {
            if (code && code.length > 0 && code.indexOf(`${componentName}.propTypes`) >= 0) {
              const ast = commons.parse(code);
              propNames = commons.getObjectAssignmentPropNames(ast);
            }
          }
        });
      }
      return {readmeText, propNames};
    });
}

export function getComponentSourceCode (options) {
  return storage.readComponentSourceCode(options.filePath);
}

export function writeComponentSourceCode (options) {
  return storage.writeComponentSourceCode(options.filePath, options.sourceCode);
}

export function saveProjectModel (options) {
  return storage.writeProjectJsonModel(options.model);
}

export function pregenerate (options) {
  const {generatorName, generatorDirPath, namespace, componentName, model} = options;
  let generatorData = {
    namespace,
    componentName,
    model,
    project: config.getProjectConfig(),
  };
  return storage.getComponentTree()
    .then(index => {
      generatorData.index = index;
      return gengineManager.preProcess(generatorDirPath, generatorData);
    });
}

export function generate (options) {
  const {generatorName, generatorDirPath, namespace, componentName, model, metadata} = options;
  let generatorData = {
    namespace,
    componentName,
    model,
    metadata,
    project: config.getProjectConfig(),
  };
  return storage.getComponentTree()
    .then(index => {
      generatorData.index = index;
      return gengineManager.process(generatorDirPath, generatorData);
    });
}

export function generateApplication (options) {
  const generatorDirPath = config.applicationGeneratorDirPath();
  const {pagesModel, hasApplicationFiles} = options;
  let generatorData = {
    pagesModel,
    hasApplicationFiles,
    project: config.getProjectConfig(),
  };
  return storage.getComponentTree()
    .then(index => {
      generatorData.index = index;
      return gengineManager.process(generatorDirPath, generatorData);
    })
    .then(generatedObject => {
      const {files, dependencies} = generatedObject;
      return storage.saveGenerated(dependencies, files);
    });
}

export function saveGenerated (options) {
  const {files, dependencies} = options;
  return storage.saveGenerated(dependencies, files);
}

export function preExtractNamespaces (options) {
  const {namespaces, pages} = options;
  return extractManager.getAllDependencies(namespaces, pages);
}

export function extractNamespaces (options) {
  const {namespaces, dependencies, pages, dirPath} = options;
  return extractManager.extractNamespaces(namespaces, dependencies, pages, dirPath);
}

export function getMarketList (options) {
  return installManager.getMarketList();
}

export function getGHRepoInfo (options) {
  const {gitHubRepo, gitHubOwner} = options;
  return installManager.getGHRepoInfo(gitHubRepo, gitHubOwner);
}

export function preInstall (options) {
  const {dirPath, url} = options;
  return installManager.preInstall(dirPath, url);
}

export function cancelInstall (options) {
  return installManager.cleanDistr();
}

export function installFromLocalDir (options) {
  const {dirPath} = options;
  return installManager.installFromDir(dirPath);
}

export function getScaffoldGenerators (options) {
  const scaffoldsUrlPrefix = '/structor-gengine-scaffolds';
  const rootDir = config.scaffoldsDirPath();
  return storage.getScaffoldGenerators()
    .then(generators => {
      if (generators && generators.length > 0) {
        generators.forEach(generator => {
          generator.screenshotFilePath = generator.screenshotFilePath.replace(rootDir, scaffoldsUrlPrefix);
        });
        generators = sortBy(generators, ['name']);
      }
      return generators;
    });
}


text:
@interface Demo6Cell : UITableViewCell

@property (weak, nonatomic) IBOutlet UILabel *endTimeLabel;

@property (weak, nonatomic) IBOutlet UILabel *countLabel;

@end


text:
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle" >

    <gradient
        android:angle="90"
        android:endColor="@color/light_purple"
        android:startColor="@color/dark_purple" />

    <corners android:radius="0dp" />

</shape>


text:
namespace jam
{

  Entity::Entity()
    : m_active(true)
  {

  }

  Entity::~Entity()
  {}

  void Entity::baseUpdate(const float dt)
  {
    if (isActive()) {
      update(dt);
    }
  }

  void Entity::baseDraw(sf::RenderTarget& target)
  {
    if (isActive()) {
      draw(target);
    }
  }

  void Entity::update(const float dt)
  {}

  void Entity::draw(sf::RenderTarget& target)
  {}

  void Entity::setActive(const bool active)
  {
    m_active = active;
  }

  bool Entity::isActive() const
  {
    return m_active;
  }
}


text:
@interface QYPersonAnnotion ()
@property (nonatomic, strong) CLLocation *location;

@end
@implementation QYPersonAnnotion

- (instancetype)init {

    self = [super init];
    return self;
}
- (CLLocation *)locationForAnnotion {

    if (!_location) {

        _location = [[CLLocation alloc] initWithLatitude:self.coordinate.latitude longitude:self.coordinate.longitude];
    }
    return _location;
}
@end


text:
package com.google.security.zynamics.binnavi.Gui.GraphWindows;

import com.google.common.base.Preconditions;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Menu.CGraphWindowMenuBar;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.NodeTaggingTree.CTagsTree;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Panels.Bottom.CCombinedBottomPanel;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Panels.CDebugPerspectiveModel;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Panels.CPerspectiveModel;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Panels.Center.CCombinedCenterPanel;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Panels.IFrontEndDebuggerProvider;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Panels.Left.CCombinedLeftPanel;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Panels.PerspectiveType;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Panels.Right.CCombinedRightPanel;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.Toolbar.CGraphToolBar;
import com.google.security.zynamics.binnavi.Gui.GraphWindows.helpers.CSizeSettingsNormalizer;
import com.google.security.zynamics.binnavi.ZyGraph.Painters.CDebuggerPainter;
import com.google.security.zynamics.binnavi.config.ConfigManager;
import com.google.security.zynamics.binnavi.config.GeneralSettingsConfigItem;
import com.google.security.zynamics.binnavi.debug.debugger.interfaces.IDebugger;
import com.google.security.zynamics.binnavi.debug.models.processmanager.TargetProcessThread;
import com.google.security.zynamics.binnavi.disassembly.RelocatedAddress;
import com.google.security.zynamics.binnavi.disassembly.views.INaviView;
import com.google.security.zynamics.binnavi.yfileswrap.Gui.GraphWindows.CGraphHotkeys;
import com.google.security.zynamics.binnavi.yfileswrap.Gui.GraphWindows.CGraphPanelSynchronizer;
import com.google.security.zynamics.binnavi.yfileswrap.zygraph.ZyGraph;

import com.jidesoft.swing.JideSplitPane;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;

import javax.swing.JMenuBar;
import javax.swing.JPanel;

/**
 * The CGraphPanel class is used to display a single graph and its associated components like the
 * node chooser panel or the debug panel.
 */
public final class CGraphPanel extends JPanel implements IGraphPanel {
  /**
   * Used for serialization.
   */
  private static final long serialVersionUID = 1468419960151528961L;

  /**
   * Information about the graph displayed in the panel.
   */
  private final CGraphModel m_model;

  /**
   * Synchronizes events in graph and view objects with the displayed graph.
   */
  private final CGraphPanelSynchronizer m_graphSynchronizer;

  /**
   * The menu bar that is shown in the parent window when the graph panel is active.
   */
  private CGraphWindowMenuBar m_menuBar;

  /**
   * Main toolbar of the graph panel.
   */
  private CGraphToolBar m_toolBar;

  /**
   * Panel shown at the bottom of the graph panel.
   */
  private final CCombinedBottomPanel m_bottomPanel;

  /**
   * Panel shown in the center of the graph panel.
   */
  private final CCombinedCenterPanel m_centerPanel;

  /**
   * Panel shown on the right of the graph panel.
   */
  private final CCombinedRightPanel m_rightPanel;

  /**
   * Panel shown on the left of the graph panel.
   */
  private final CCombinedLeftPanel m_leftPanel;

  /**
   * Splits the center panel and the bottom panel.
   */
  private JideSplitPane m_graphSplitter;

  /**
   * Splits left, center, and right panels.
   */
  private JideSplitPane m_graphTaggingSplitter;

  /**
   * Describes the active GUI perspective.
   */
  private final CPerspectiveModel m_viewModel;

  /**
   * Contains the dialogs that are specific for this panel.
   */
  private final CGraphPanelDialogs m_dialogs;

  /**
   * Creates a new graph panel object.
   *
   * @param model Model of the graph displayed in the panel.
   */
  public CGraphPanel(final CGraphModel model) {
    super(new BorderLayout());

    Preconditions.checkNotNull(model, "IE01617: Model argument can't be null");

    m_model = model;
    m_model.setPanel(this);

    m_viewModel = new CPerspectiveModel(model);

    final CGraphWindow parent = m_model.getParent();
    final ZyGraph graph = m_model.getGraph();

    final InternalViewSwitcher viewSwitcher = new InternalViewSwitcher();

    m_toolBar =
        new CGraphToolBar(parent, model.getGraphPanel(), graph, m_model.getViewContainer()
            .getModules());
    m_menuBar = new CGraphWindowMenuBar(m_model, viewSwitcher);

    m_graphSynchronizer = new CGraphPanelSynchronizer(m_model, m_menuBar);

    final CDebugPerspectiveModel debugPerspective =
        ((CDebugPerspectiveModel) m_viewModel.getModel(PerspectiveType.DebugPerspective));

    m_bottomPanel = new CCombinedBottomPanel(model, m_graphSynchronizer, m_viewModel);
    m_centerPanel = new CCombinedCenterPanel(model.getGraph(), debugPerspective);
    m_rightPanel = new CCombinedRightPanel(parent, model, m_viewModel);
    m_leftPanel =
        new CCombinedLeftPanel(model, m_viewModel, m_toolBar.getSearchPanel().getSearchField());

    createGui();

    m_dialogs = new CGraphPanelDialogs(model, m_menuBar);

    CGraphHotkeys.registerHotKeys(parent, this,
        (IFrontEndDebuggerProvider) m_viewModel.getModel(PerspectiveType.DebugPerspective),
        m_toolBar.getSearchPanel().getSearchField(), m_toolBar.getGotoAddressField());

    for (final IDebugger debugger : model.getDebuggerProvider().getDebuggers()) {
      if (debugger.isConnected()) {
        debugPerspective.setActiveDebugger(debugger);
        viewSwitcher.activateDebugView();
        break;
      }
    }

    final IDebugger debugger = debugPerspective.getCurrentSelectedDebugger();

    if ((debugger != null) && debugger.isConnected()) {
      for (final TargetProcessThread thread : debugger.getProcessManager().getThreads()) {
        final RelocatedAddress address = thread.getCurrentAddress();

        if (address != null) {
          CDebuggerPainter.updateDebuggerHighlighting(graph, debugger.memoryToFile(address),
              debugger.getModule(address));
        }
      }
    }
  }

  /**
   * Sets up all the splitters and other minor GUI elements of the graph panel.
   */
  private void createGui() {
    m_graphSplitter = new JideSplitPane() {
      private static final long serialVersionUID = -4363828908016863289L;

      // ESCA-JAVA0025: Workaround for Case 1168
      @Override
      public void updateUI() {
        // Workaround for Case 1168: The mere presence of a JIDE component
        // screws up the look and feel.
      }
    };

    m_graphSplitter.setOrientation(JideSplitPane.VERTICAL_SPLIT);

    m_graphSplitter.addPane(m_centerPanel);
    m_graphSplitter.addPane(m_bottomPanel);

    m_graphTaggingSplitter = new JideSplitPane() {
      private static final long serialVersionUID = -9037540212052390552L;

      // ESCA-JAVA0025: Workaround for Case 1168
      @Override
      public void updateUI() {
        // Workaround for Case 1168: The mere presence of a JIDE component
        // screws up the look and feel.
      }
    };

    m_graphTaggingSplitter.setOrientation(JideSplitPane.HORIZONTAL_SPLIT);
    m_graphTaggingSplitter.addPane(m_leftPanel);
    m_graphTaggingSplitter.addPane(m_graphSplitter);
    m_graphTaggingSplitter.addPane(m_rightPanel);

    m_graphTaggingSplitter.setDoubleBuffered(true);
    m_graphTaggingSplitter.setOneTouchExpandable(true);
    m_graphTaggingSplitter.setMinimumSize(new Dimension(0, 0));

    m_graphSplitter.setDoubleBuffered(true);
    m_graphSplitter.setOneTouchExpandable(true);
    m_graphSplitter.setMinimumSize(new Dimension(0, 0));

    add(m_graphTaggingSplitter);

    add(m_toolBar, BorderLayout.NORTH);
  }

  @Override
  public void close(final boolean askSave) {
    if (!askSave || CPanelCloser.closeTab(m_model.getParent(), this)) {
      m_model.getParent().close(this);
    }
  }

  /**
   * Frees allocated resources.
   */
  @Override
  public void dispose() {
    m_graphSynchronizer.dispose();

    m_bottomPanel.dispose();
    m_centerPanel.dispose();

    m_model.dispose();

    final INaviView view = m_model.getGraph().getRawView();

    view.close();

    m_menuBar.dipose();
    m_toolBar.dispose();

    // Note: The following line is necessary for garbage collection
    // because the menus keep references to the graph panel and
    // this leads to circular object references.
    m_menuBar.removeAll();
    m_toolBar.removeAll();

    m_menuBar = null;
    m_toolBar = null;

    m_rightPanel.dispose();
    m_leftPanel.dispose();

    m_dialogs.dispose();

    removeAll();
  }

  /**
   * Returns the graph panel specific dialogs.
   *
   * @return The graph panel specific dialogs.
   */
  public CGraphPanelDialogs getDialogs() {
    return m_dialogs;
  }

  @Override
  public JMenuBar getMenu() {
    return m_menuBar;
  }

  /**
   * Returns information about the graph displayed in the panel.
   *
   * @return Information about the graph displayed in the panel.
   */
  @Override
  public CGraphModel getModel() {
    return m_model;
  }

  @Override
  public JPanel getPanel() {
    return this;
  }

  /**
   * Returns the node tagging tree shown in this graph panel.
   *
   * @return The node tagging tree shown in this graph panel.
   */
  public CTagsTree getTagsTree() {
    return m_rightPanel.getTree();
  }

  /**
   * Returns the toolbar of the graph panel.
   *
   * @return The toolbar of the graph panel.
   */
  public CGraphToolBar getToolbar() {
    return m_toolBar;
  }

  /**
   * Returns the perspective model of the graph panel.
   *
   * @return The perspective model of the graph panel.
   */
  public CPerspectiveModel getViewModel() {
    return m_viewModel;
  }

  /**
   * Part of a workaround.
   */
  public void updateSplitters() {
    // Required because JSplitters suck.
    final GeneralSettingsConfigItem.GraphWindowConfigItem settings =
        ConfigManager.instance().getGeneralSettings().getGraphWindow();

    final Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

    final int leftPanelSize =
        CSizeSettingsNormalizer.getSize(settings.getSizeLeftPanel(), screenSize.width, 200);
    final int rightPanelSize =
        CSizeSettingsNormalizer.getSize(settings.getSizeRightPanel(), screenSize.width,
            screenSize.width - 200);
    final int bottomPanelSize =
        CSizeSettingsNormalizer.getSize(settings.getSizeBottomPanel(), screenSize.height,
            screenSize.height - 400);

    m_graphTaggingSplitter.setDividerLocation(0, leftPanelSize);
    m_graphTaggingSplitter.setDividerLocation(1, rightPanelSize);
    m_graphSplitter.setDividerLocation(0, bottomPanelSize);

    CGraphPanelSettingsSynchronizer.initializeSynchronizer(m_graphSplitter, m_graphTaggingSplitter);
  }

  /**
   * Toggles between the different graph window perspectives.
   */
  private class InternalViewSwitcher implements IViewSwitcher {
    @Override
    public void activateDebugView() {
      m_viewModel.setActiveView(PerspectiveType.DebugPerspective);
    }

    @Override
    public void activateStandardView() {
      m_viewModel.setActiveView(PerspectiveType.StandardPerspective);
    }
  }
}


text:
'use strict';

angular.module('mean')
    .config(['$stateProvider', function($stateProvider) {
        $stateProvider
            .state('dashboard', {
                url: '/dashboard',
                templateUrl: 'dashboard/views/index.html'
            })
            .state('dashboard.projects', {
                url: '/projects',
                templateUrl: 'dashboard/views/projects.html'
            })
            .state('dashboard.project', {
                url: '/project/:projectId',
                templateUrl: 'dashboard/views/project.html',
            })
            .state('dashboard.project.module', {
                url: '/module/:moduleId',
                views: {
                    moduleContent: {
                        templateUrl: 'dashboard/views/module.html'
                    }
                },
                resolve: {

                }
            })
            .state('dashboard.project.page', {
                url: '/page',
                views: {
                    moduleContent: {
                        templateUrl: 'dashboard/views/page.html'
                    }
                }
            })
            .state('dashboard.project.interface', {
                url: '/interface',
                views: {
                    moduleContent: {
                        templateUrl: 'dashboard/views/interface.html'
                    }
                }
            })
            .state('otherwise', {
                url: '*path',
                templateUrl: 'dashboard/views/404.html'
            });
    }
]);


text:
"use strict";
exports.__esModule = true;
exports.lib = void 0;
exports.lib = {
    one: 1,
    two: 2,
    three: 3
};
//# sourceMappingURL=index.js.map


text:
//
//  QMImageView.h
//  QMChatViewController
//
//  Created by Andrey Ivanov on 27.06.14.
//  Copyright (c) 2014 Quickblox. All rights reserved.
//

#import <UIKit/UIKit.h>
#import "QMImageLoader.h"

@protocol QMImageViewDelegate ;

typedef NS_ENUM(NSUInteger, QMImageViewType) {
    QMImageViewTypeNone,
    QMImageViewTypeCircle,
    QMImageViewTypeSquare
};

@interface QMImageView : UIImageView
/**
 Default QMUserImageViewType QMUserImageViewTypeNone
 */
@property (assign, nonatomic) QMImageViewType imageViewType;
@property (weak, nonatomic, readonly) UITapGestureRecognizer *tapGestureRecognizer;
@property (strong, nonatomic, readonly) NSURL *url;

@property (weak, nonatomic) id <QMImageViewDelegate> delegate;

- (void)setImageWithURL:(NSURL *)url;

- (void)setImageWithURL:(NSURL *)url
            placeholder:(UIImage *)placehoder
                options:(SDWebImageOptions)options
               progress:(SDWebImageDownloaderProgressBlock)progress
         completedBlock:(SDExternalCompletionBlock)completedBlock;

- (void)setImageWithURL:(NSURL *)url
                  title:(NSString *)title
         completedBlock:(SDExternalCompletionBlock)completedBlock;

- (UIImage *)originalImage;

@end

@protocol QMImageViewDelegate <NSObject>

- (void)imageViewDidTap:(QMImageView *)imageView;

@end


text:
#import <Foundation/Foundation.h>

#import <GoogleDataTransport/GDTCORStoredEvent.h>

#import "GDTCCTLibrary/Protogen/nanopb/cct.nanopb.h"

NS_ASSUME_NONNULL_BEGIN

#pragma mark - General purpose encoders

/** Converts an NSString* to a pb_bytes_array_t*.
 *
 * @note malloc is called in this method. Ensure that pb_release is called on this or the parent.
 *
 * @param string The string to convert.
 * @return A newly allocated array of bytes representing the UTF8 encoding of the string.
 */
pb_bytes_array_t *GDTCCTEncodeString(NSString *string);

/** Converts an NSData to a pb_bytes_array_t*.
 *
 * @note malloc is called in this method. Ensure that pb_release is called on this or the parent.
 *
 * @param data The data to convert.
 * @return A newly allocated array of bytes with [data bytes] copied into it.
 */
pb_bytes_array_t *GDTCCTEncodeData(NSData *data);

#pragma mark - CCT object constructors

/** Encodes a batched log request.
 *
 * @note Ensure that pb_release is called on the batchedLogRequest param.
 *
 * @param batchedLogRequest A pointer to the log batch to encode to bytes.
 * @return An NSData object representing the bytes of the log request batch.
 */
FOUNDATION_EXPORT
NSData *GDTCCTEncodeBatchedLogRequest(gdt_cct_BatchedLogRequest *batchedLogRequest);

/** Constructs a gdt_cct_BatchedLogRequest given sets of events segemented by mapping ID.
 *
 * @note malloc is called in this method. Ensure that pb_release is called on this or the parent.
 *
 * @param logMappingIDToLogSet A map of mapping IDs to sets of events to convert into a batch.
 * @return A newly created gdt_cct_BatchedLogRequest.
 */
FOUNDATION_EXPORT
gdt_cct_BatchedLogRequest GDTCCTConstructBatchedLogRequest(
    NSDictionary<NSString *, NSSet<GDTCORStoredEvent *> *> *logMappingIDToLogSet);

/** Constructs a log request given a log source and a set of events.
 *
 * @note malloc is called in this method. Ensure that pb_release is called on this or the parent.
 * @param logSource The CCT log source to put into the log request.
 * @param logSet The set of events to send in this log request.
 */
FOUNDATION_EXPORT
gdt_cct_LogRequest GDTCCTConstructLogRequest(int32_t logSource, NSSet<GDTCORStoredEvent *> *logSet);

/** Constructs a gdt_cct_LogEvent given a GDTCORStoredEvent*.
 *
 * @param event The GDTCORStoredEvent to convert.
 * @return The new gdt_cct_LogEvent object.
 */
FOUNDATION_EXPORT
gdt_cct_LogEvent GDTCCTConstructLogEvent(GDTCORStoredEvent *event);

/** Constructs a gdt_cct_ClientInfo representing the client device.
 *
 * @return The new gdt_cct_ClientInfo object.
 */
FOUNDATION_EXPORT
gdt_cct_ClientInfo GDTCCTConstructClientInfo(void);

/** Constructs a gdt_cct_IosClientInfo representing the client device.
 *
 * @return The new gdt_cct_IosClientInfo object.
 */
FOUNDATION_EXPORT
gdt_cct_IosClientInfo GDTCCTConstructiOSClientInfo(void);

#pragma mark - CCT object decoders

/** Decodes a gdt_cct_LogResponse given proto bytes.
 *
 * @note malloc is called in this method. Ensure that pb_release is called on the return value.
 *
 * @param data The proto bytes of the gdt_cct_LogResponse.
 * @param error An error that will be populated if something went wrong during decoding.
 * @return A newly allocated gdt_cct_LogResponse from the data, if the bytes decoded properly.
 */
FOUNDATION_EXPORT
gdt_cct_LogResponse GDTCCTDecodeLogResponse(NSData *data, NSError **error);

NS_ASSUME_NONNULL_END