org.freedesktop.dbus.Transport.SASL クラス

org.freedesktop.dbus.Transport.SASL 連携図

クラス
class	Command

公開メンバ関数
Command	receive (InputStream s) throws IOException
void	send (OutputStream out, int command, String... data) throws IOException
int	do_challenge (int auth, Command c) throws IOException
int	do_response (int auth, String Uid, String kernelUid, Command c)
String []	getTypes (int types)
boolean	auth (int mode, int types, String guid, OutputStream out, InputStream in, UnixSocket us) throws IOException

公開変数類
String	challenge = ""
String	cookie = ""

静的公開変数類
static final int	LOCK_TIMEOUT = 1000
static final int	NEW_KEY_TIMEOUT_SECONDS = 60 * 5
static final int	EXPIRE_KEYS_TIMEOUT_SECONDS = NEW_KEY_TIMEOUT_SECONDS + (60 * 2)
static final int	MAX_TIME_TRAVEL_SECONDS = 60 * 5
static final int	COOKIE_TIMEOUT = 240
static final String	COOKIE_CONTEXT = "org_freedesktop_java"
static final int	MODE_SERVER = 1
static final int	MODE_CLIENT = 2
static final int	AUTH_NONE = 0
static final int	AUTH_EXTERNAL = 1
static final int	AUTH_SHA = 2
static final int	AUTH_ANON = 4
static final int	COMMAND_AUTH = 1
static final int	COMMAND_DATA = 2
static final int	COMMAND_REJECTED = 3
static final int	COMMAND_OK = 4
static final int	COMMAND_BEGIN = 5
static final int	COMMAND_CANCEL = 6
static final int	COMMAND_ERROR = 7
static final int	INITIAL_STATE = 0
static final int	WAIT_DATA = 1
static final int	WAIT_OK = 2
static final int	WAIT_REJECT = 3
static final int	WAIT_AUTH = 4
static final int	WAIT_BEGIN = 5
static final int	AUTHENTICATED = 6
static final int	FAILED = 7
static final int	OK = 1
static final int	CONTINUE = 2
static final int	ERROR = 3
static final int	REJECT = 4

静的関数
	[static initializer]

非公開メンバ関数
String	findCookie (String context, String ID) throws IOException
void	addCookie (String context, String ID, long timestamp, String cookie) throws IOException
String	stupidlyEncode (String data)
String	stupidlyEncode (byte[] data)
byte	getNibble (char c)
String	stupidlyDecode (String data)

静的非公開変数類
static Collator	col = Collator.getInstance()

詳解

関数詳解

[static initializer]()

org.freedesktop.dbus.Transport.SASL.[static initializer] ( )

inlinestaticpackage

addCookie()

void org.freedesktop.dbus.Transport.SASL.addCookie ( String  context, String  ID, long  timestamp, String  cookie  ) throws IOException

inlineprivate

                                                                                                            {
            String homedir = System.getProperty("user.home");
            File keydir = new File(homedir + "/.dbus-keyrings/");
            File cookiefile = new File(homedir + "/.dbus-keyrings/" + context);
            File lock = new File(homedir + "/.dbus-keyrings/" + context + ".lock");
            File temp = new File(homedir + "/.dbus-keyrings/" + context + ".temp");

            // ensure directory exists
            if (!keydir.exists()) keydir.mkdirs();

            // acquire lock
            long start = System.currentTimeMillis();
            while (!lock.createNewFile() && LOCK_TIMEOUT > (System.currentTimeMillis() - start)) ;

            // read old file
            Vector<String> lines = new Vector<String>();
            if (cookiefile.exists()) {
                BufferedReader r = new BufferedReader(new InputStreamReader(new FileInputStream(cookiefile)));
                String s = null;
                while (null != (s = r.readLine())) {
                    String[] line = s.split(" ");
                    long time = Long.parseLong(line[1]);
                    // expire stale cookies
                    if ((timestamp - time) < COOKIE_TIMEOUT)
                        lines.add(s);
                }
                r.close();
            }

            // add cookie
            lines.add(ID + " " + timestamp + " " + cookie);

            // write temp file
            PrintWriter w = new PrintWriter(new FileOutputStream(temp));
            for (String l : lines)
                w.println(l);
            w.close();

            // atomically move to old file
            if (!temp.renameTo(cookiefile)) {
                cookiefile.delete();
                temp.renameTo(cookiefile);
            }

            // remove lock
            lock.delete();
        }

auth()

boolean org.freedesktop.dbus.Transport.SASL.auth ( int  mode, int  types, String  guid, OutputStream  out, InputStream  in, UnixSocket  us  ) throws IOException

inline

performs SASL auth on the given streams. Mode selects whether to run as a SASL server or client. Types is a bitmask of the available auth types. Returns true if the auth was successful and false if it failed.

                                                                                                                                  {
            String username = System.getProperty("user.name");
            String Uid = null;
            String kernelUid = null;
            try {
                Class c = Class.forName("com.sun.security.auth.module.UnixSystem");
                Method m = c.getMethod("getUid");
                Object o = c.newInstance();
                long uid = (Long) m.invoke(o);
                Uid = stupidlyEncode("" + uid);
            } catch (Exception e) {
                Uid = stupidlyEncode(username);
            }
            Command c;
            int failed = 0;
            int current = 0;
            int state = INITIAL_STATE;

            while (state != AUTHENTICATED && state != FAILED) {
                if (Debug.debug) Debug.print(Debug.VERBOSE, "AUTH state: " + state);
                switch (mode) {
                    case MODE_CLIENT:
                        switch (state) {
                            case INITIAL_STATE:
                                if (null == us)
                                    out.write(new byte[]{0});
                                else
                                    us.sendCredentialByte((byte) 0);
                                send(out, COMMAND_AUTH);
                                state = WAIT_DATA;
                                break;
                            case WAIT_DATA:
                                c = receive(in);
                                switch (c.getCommand()) {
                                    case COMMAND_DATA:
                                        switch (do_challenge(current, c)) {
                                            case CONTINUE:
                                                send(out, COMMAND_DATA, c.getResponse());
                                                break;
                                            case OK:
                                                send(out, COMMAND_DATA, c.getResponse());
                                                state = WAIT_OK;
                                                break;
                                            case ERROR:
                                                send(out, COMMAND_ERROR, c.getResponse());
                                                break;
                                        }
                                        break;
                                    case COMMAND_REJECTED:
                                        failed |= current;
                                        int available = c.getMechs() & (~failed);
                                        if (0 != (available & AUTH_EXTERNAL)) {
                                            send(out, COMMAND_AUTH, "EXTERNAL", Uid);
                                            current = AUTH_EXTERNAL;
                                        } else if (0 != (available & AUTH_SHA)) {
                                            send(out, COMMAND_AUTH, "DBUS_COOKIE_SHA1", Uid);
                                            current = AUTH_SHA;
                                        } else if (0 != (available & AUTH_ANON)) {
                                            send(out, COMMAND_AUTH, "ANONYMOUS");
                                            current = AUTH_ANON;
                                        } else state = FAILED;
                                        break;
                                    case COMMAND_ERROR:
                                        send(out, COMMAND_CANCEL);
                                        state = WAIT_REJECT;
                                        break;
                                    case COMMAND_OK:
                                        send(out, COMMAND_BEGIN);
                                        state = AUTHENTICATED;
                                        break;
                                    default:
                                        send(out, COMMAND_ERROR, "Got invalid command");
                                        break;
                                }
                                break;
                            case WAIT_OK:
                                c = receive(in);
                                switch (c.getCommand()) {
                                    case COMMAND_OK:
                                        send(out, COMMAND_BEGIN);
                                        state = AUTHENTICATED;
                                        break;
                                    case COMMAND_ERROR:
                                    case COMMAND_DATA:
                                        send(out, COMMAND_CANCEL);
                                        state = WAIT_REJECT;
                                        break;
                                    case COMMAND_REJECTED:
                                        failed |= current;
                                        int available = c.getMechs() & (~failed);
                                        state = WAIT_DATA;
                                        if (0 != (available & AUTH_EXTERNAL)) {
                                            send(out, COMMAND_AUTH, "EXTERNAL", Uid);
                                            current = AUTH_EXTERNAL;
                                        } else if (0 != (available & AUTH_SHA)) {
                                            send(out, COMMAND_AUTH, "DBUS_COOKIE_SHA1", Uid);
                                            current = AUTH_SHA;
                                        } else if (0 != (available & AUTH_ANON)) {
                                            send(out, COMMAND_AUTH, "ANONYMOUS");
                                            current = AUTH_ANON;
                                        } else state = FAILED;
                                        break;
                                    default:
                                        send(out, COMMAND_ERROR, "Got invalid command");
                                        break;
                                }
                                break;
                            case WAIT_REJECT:
                                c = receive(in);
                                switch (c.getCommand()) {
                                    case COMMAND_REJECTED:
                                        failed |= current;
                                        int available = c.getMechs() & (~failed);
                                        if (0 != (available & AUTH_EXTERNAL)) {
                                            send(out, COMMAND_AUTH, "EXTERNAL", Uid);
                                            current = AUTH_EXTERNAL;
                                        } else if (0 != (available & AUTH_SHA)) {
                                            send(out, COMMAND_AUTH, "DBUS_COOKIE_SHA1", Uid);
                                            current = AUTH_SHA;
                                        } else if (0 != (available & AUTH_ANON)) {
                                            send(out, COMMAND_AUTH, "ANONYMOUS");
                                            current = AUTH_ANON;
                                        } else state = FAILED;
                                        break;
                                    default:
                                        state = FAILED;
                                        break;
                                }
                                break;
                            default:
                                state = FAILED;
                        }
                        break;
                    case MODE_SERVER:
                        switch (state) {
                            case INITIAL_STATE:
                                byte[] buf = new byte[1];
                                if (null == us) {
                                    in.read(buf);
                                } else {
                                    buf[0] = us.recvCredentialByte();
                                    int kuid = us.getPeerUID();
                                    if (kuid >= 0)
                                        kernelUid = stupidlyEncode("" + kuid);
                                }
                                if (0 != buf[0]) state = FAILED;
                                else state = WAIT_AUTH;
                                break;
                            case WAIT_AUTH:
                                c = receive(in);
                                switch (c.getCommand()) {
                                    case COMMAND_AUTH:
                                        if (null == c.getData()) {
                                            send(out, COMMAND_REJECTED, getTypes(types));
                                        } else {
                                            switch (do_response(current, Uid, kernelUid, c)) {
                                                case CONTINUE:
                                                    send(out, COMMAND_DATA, c.getResponse());
                                                    current = c.getMechs();
                                                    state = WAIT_DATA;
                                                    break;
                                                case OK:
                                                    send(out, COMMAND_OK, guid);
                                                    state = WAIT_BEGIN;
                                                    current = 0;
                                                    break;
                                                case REJECT:
                                                    send(out, COMMAND_REJECTED, getTypes(types));
                                                    current = 0;
                                                    break;
                                            }
                                        }
                                        break;
                                    case COMMAND_ERROR:
                                        send(out, COMMAND_REJECTED, getTypes(types));
                                        break;
                                    case COMMAND_BEGIN:
                                        state = FAILED;
                                        break;
                                    default:
                                        send(out, COMMAND_ERROR, "Got invalid command");
                                        break;
                                }
                                break;
                            case WAIT_DATA:
                                c = receive(in);
                                switch (c.getCommand()) {
                                    case COMMAND_DATA:
                                        switch (do_response(current, Uid, kernelUid, c)) {
                                            case CONTINUE:
                                                send(out, COMMAND_DATA, c.getResponse());
                                                state = WAIT_DATA;
                                                break;
                                            case OK:
                                                send(out, COMMAND_OK, guid);
                                                state = WAIT_BEGIN;
                                                current = 0;
                                                break;
                                            case REJECT:
                                                send(out, COMMAND_REJECTED, getTypes(types));
                                                current = 0;
                                                break;
                                        }
                                        break;
                                    case COMMAND_ERROR:
                                    case COMMAND_CANCEL:
                                        send(out, COMMAND_REJECTED, getTypes(types));
                                        state = WAIT_AUTH;
                                        break;
                                    case COMMAND_BEGIN:
                                        state = FAILED;
                                        break;
                                    default:
                                        send(out, COMMAND_ERROR, "Got invalid command");
                                        break;
                                }
                                break;
                            case WAIT_BEGIN:
                                c = receive(in);
                                switch (c.getCommand()) {
                                    case COMMAND_ERROR:
                                    case COMMAND_CANCEL:
                                        send(out, COMMAND_REJECTED, getTypes(types));
                                        state = WAIT_AUTH;
                                        break;
                                    case COMMAND_BEGIN:
                                        state = AUTHENTICATED;
                                        break;
                                    default:
                                        send(out, COMMAND_ERROR, "Got invalid command");
                                        break;
                                }
                                break;
                            default:
                                state = FAILED;
                        }
                        break;
                    default:
                        return false;
                }
            }

            return state == AUTHENTICATED;
        }

do_challenge()

int org.freedesktop.dbus.Transport.SASL.do_challenge ( int  auth, Command  c  ) throws IOException

inline

                                                                        {
            switch (auth) {
                case AUTH_SHA:
                    String[] reply = stupidlyDecode(c.getData()).split(" ");
                    if (Debug.debug) Debug.print(Debug.VERBOSE, Arrays.toString(reply));
                    if (3 != reply.length) {
                        if (Debug.debug) Debug.print(Debug.DEBUG, "Reply is not length 3");
                        return ERROR;
                    }
                    String context = reply[0];
                    String ID = reply[1];
                    String serverchallenge = reply[2];
                    MessageDigest md = null;
                    try {
                        md = MessageDigest.getInstance("SHA");
                    } catch (NoSuchAlgorithmException NSAe) {
                        if (Debug.debug && AbstractConnection.EXCEPTION_DEBUG) Debug.print(Debug.ERR, NSAe);
                        return ERROR;
                    }
                    byte[] buf = new byte[8];
                    Message.marshallintBig(System.currentTimeMillis(), buf, 0, 8);
                    String clientchallenge = stupidlyEncode(md.digest(buf));
                    md.reset();
                    long start = System.currentTimeMillis();
                    String cookie = null;
                    while (null == cookie && (System.currentTimeMillis() - start) < LOCK_TIMEOUT)
                        cookie = findCookie(context, ID);
                    if (null == cookie) {
                        if (Debug.debug)
                            Debug.print(Debug.DEBUG, "Did not find a cookie in context " + context + " with ID " + ID);
                        return ERROR;
                    }
                    String response = serverchallenge + ":" + clientchallenge + ":" + cookie;
                    buf = md.digest(response.getBytes());
                    if (Debug.debug)
                        Debug.print(Debug.VERBOSE, "Response: " + response + " hash: " + Hexdump.format(buf));
                    response = stupidlyEncode(buf);
                    c.setResponse(stupidlyEncode(clientchallenge + " " + response));
                    return OK;
                default:
                    if (Debug.debug) Debug.print(Debug.DEBUG, "Not DBUS_COOKIE_SHA1 authtype.");
                    return ERROR;
            }
        }

do_response()

int org.freedesktop.dbus.Transport.SASL.do_response ( int  auth, String  Uid, String  kernelUid, Command  c  )

inline

                                                                                  {
            MessageDigest md = null;
            try {
                md = MessageDigest.getInstance("SHA");
            } catch (NoSuchAlgorithmException NSAe) {
                if (Debug.debug && AbstractConnection.EXCEPTION_DEBUG) Debug.print(Debug.ERR, NSAe);
                return ERROR;
            }
            switch (auth) {
                case AUTH_NONE:
                    switch (c.getMechs()) {
                        case AUTH_ANON:
                            return OK;
                        case AUTH_EXTERNAL:
                            if (0 == col.compare(Uid, c.getData()) &&
                                    (null == kernelUid || 0 == col.compare(Uid, kernelUid)))
                                return OK;
                            else
                                return ERROR;
                        case AUTH_SHA:
                            String context = COOKIE_CONTEXT;
                            long id = System.currentTimeMillis();
                            byte[] buf = new byte[8];
                            Message.marshallintBig(id, buf, 0, 8);
                            challenge = stupidlyEncode(md.digest(buf));
                            Random r = new Random();
                            r.nextBytes(buf);
                            cookie = stupidlyEncode(md.digest(buf));
                            try {
                                addCookie(context, "" + id, id / 1000, cookie);
                            } catch (IOException IOe) {
                                if (Debug.debug && AbstractConnection.EXCEPTION_DEBUG) Debug.print(Debug.ERR, IOe);
                            }
                            if (Debug.debug)
                                Debug.print(Debug.DEBUG, "Sending challenge: " + context + ' ' + id + ' ' + challenge);
                            c.setResponse(stupidlyEncode(context + ' ' + id + ' ' + challenge));
                            return CONTINUE;
                        default:
                            return ERROR;
                    }
                case AUTH_SHA:
                    String[] response = stupidlyDecode(c.getData()).split(" ");
                    if (response.length < 2) return ERROR;
                    String cchal = response[0];
                    String hash = response[1];
                    String prehash = challenge + ":" + cchal + ":" + cookie;
                    byte[] buf = md.digest(prehash.getBytes());
                    String posthash = stupidlyEncode(buf);
                    if (Debug.debug)
                        Debug.print(Debug.DEBUG, "Authenticating Hash; data=" + prehash + " remote hash=" + hash + " local hash=" + posthash);
                    if (0 == col.compare(posthash, hash))
                        return OK;
                    else
                        return ERROR;
                default:
                    return ERROR;
            }
        }

findCookie()

String org.freedesktop.dbus.Transport.SASL.findCookie ( String  context, String  ID  ) throws IOException

inlineprivate

                                                                                {
            String homedir = System.getProperty("user.home");
            File f = new File(homedir + "/.dbus-keyrings/" + context);
            BufferedReader r = new BufferedReader(new InputStreamReader(new FileInputStream(f)));
            String s = null;
            String cookie = null;
            long now = System.currentTimeMillis() / 1000;
            while (null != (s = r.readLine())) {
                String[] line = s.split(" ");
                long timestamp = Long.parseLong(line[1]);
                if (line[0].equals(ID) && (!(timestamp < 0 ||
                        (now + MAX_TIME_TRAVEL_SECONDS) < timestamp ||
                        (now - EXPIRE_KEYS_TIMEOUT_SECONDS) > timestamp))) {
                    cookie = line[2];
                    break;
                }
            }
            r.close();
            return cookie;
        }

getNibble()

byte org.freedesktop.dbus.Transport.SASL.getNibble ( char  c )

inlineprivate

                                       {
            switch (c) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    return (byte) (c - '0');
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                    return (byte) (c - 'A' + 10);
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                    return (byte) (c - 'a' + 10);
                default:
                    return 0;
            }
        }

getTypes()

String [] org.freedesktop.dbus.Transport.SASL.getTypes ( int  types )

inline

                                            {
            switch (types) {
                case AUTH_EXTERNAL:
                    return new String[]{"EXTERNAL"};
                case AUTH_SHA:
                    return new String[]{"DBUS_COOKIE_SHA1"};
                case AUTH_ANON:
                    return new String[]{"ANONYMOUS"};
                case AUTH_SHA + AUTH_EXTERNAL:
                    return new String[]{"EXTERNAL", "DBUS_COOKIE_SHA1"};
                case AUTH_SHA + AUTH_ANON:
                    return new String[]{"ANONYMOUS", "DBUS_COOKIE_SHA1"};
                case AUTH_EXTERNAL + AUTH_ANON:
                    return new String[]{"ANONYMOUS", "EXTERNAL"};
                case AUTH_EXTERNAL + AUTH_ANON + AUTH_SHA:
                    return new String[]{"ANONYMOUS", "EXTERNAL", "DBUS_COOKIE_SHA1"};
                default:
                    return new String[]{};
            }
        }

receive()

Command org.freedesktop.dbus.Transport.SASL.receive ( InputStream  s ) throws IOException

inline

                                                                 {
            StringBuffer sb = new StringBuffer();
            top:
            while (true) {
                int c = s.read();
                switch (c) {
                    case -1:
                        throw new IOException("Stream unexpectedly short (broken pipe)");
                    case 0:
                    case '\r':
                        continue;
                    case '\n':
                        break top;
                    default:
                        sb.append((char) c);
                }
            }
            if (Debug.debug) Debug.print(Debug.VERBOSE, "received: " + sb);
            try {
                return new Command(sb.toString());
            } catch (Exception e) {
                if (Debug.debug && AbstractConnection.EXCEPTION_DEBUG) Debug.print(Debug.ERR, e);
                return new Command();
            }
        }

send()

void org.freedesktop.dbus.Transport.SASL.send ( OutputStream  out, int  command, String...  data  ) throws IOException

inline

                                                                                           {
            StringBuffer sb = new StringBuffer();
            switch (command) {
                case COMMAND_AUTH:
                    sb.append("AUTH");
                    break;
                case COMMAND_DATA:
                    sb.append("DATA");
                    break;
                case COMMAND_REJECTED:
                    sb.append("REJECTED");
                    break;
                case COMMAND_OK:
                    sb.append("OK");
                    break;
                case COMMAND_BEGIN:
                    sb.append("BEGIN");
                    break;
                case COMMAND_CANCEL:
                    sb.append("CANCEL");
                    break;
                case COMMAND_ERROR:
                    sb.append("ERROR");
                    break;
                default:
                    return;
            }
            for (String s : data) {
                sb.append(' ');
                sb.append(s);
            }
            sb.append('\r');
            sb.append('\n');
            if (Debug.debug) Debug.print(Debug.VERBOSE, "sending: " + sb);
            out.write(sb.toString().getBytes());
        }

stupidlyDecode()

String org.freedesktop.dbus.Transport.SASL.stupidlyDecode ( String  data )

inlineprivate

                                                   {
            char[] cs = new char[data.length()];
            char[] res = new char[cs.length / 2];
            data.getChars(0, data.length(), cs, 0);
            for (int i = 0, j = 0; j < res.length; i += 2, j++) {
                int b = 0;
                b |= getNibble(cs[i]) << 4;
                b |= getNibble(cs[i + 1]);
                res[j] = (char) b;
            }
            return new String(res);
        }

stupidlyEncode() [1/2]

String org.freedesktop.dbus.Transport.SASL.stupidlyEncode ( String  data )

inlineprivate

Takes the string, encodes it as hex and then turns it into a string again. No, I don't know why either.

                                                   {
            return Hexdump.toHex(data.getBytes()).replaceAll(" ", "");
        }

stupidlyEncode() [2/2]

String org.freedesktop.dbus.Transport.SASL.stupidlyEncode ( byte []  data )

inlineprivate

                                                   {
            return Hexdump.toHex(data).replaceAll(" ", "");
        }

メンバ詳解

AUTH_ANON

final int org.freedesktop.dbus.Transport.SASL.AUTH_ANON = 4

static

AUTH_EXTERNAL

final int org.freedesktop.dbus.Transport.SASL.AUTH_EXTERNAL = 1

static

AUTH_NONE

final int org.freedesktop.dbus.Transport.SASL.AUTH_NONE = 0

static

AUTH_SHA

final int org.freedesktop.dbus.Transport.SASL.AUTH_SHA = 2

static

AUTHENTICATED

final int org.freedesktop.dbus.Transport.SASL.AUTHENTICATED = 6

static

challenge

String org.freedesktop.dbus.Transport.SASL.challenge = ""

col

Collator org.freedesktop.dbus.Transport.SASL.col = Collator.getInstance()

staticprivate

COMMAND_AUTH

final int org.freedesktop.dbus.Transport.SASL.COMMAND_AUTH = 1

static

COMMAND_BEGIN

final int org.freedesktop.dbus.Transport.SASL.COMMAND_BEGIN = 5

static

COMMAND_CANCEL

final int org.freedesktop.dbus.Transport.SASL.COMMAND_CANCEL = 6

static

COMMAND_DATA

final int org.freedesktop.dbus.Transport.SASL.COMMAND_DATA = 2

static

COMMAND_ERROR

final int org.freedesktop.dbus.Transport.SASL.COMMAND_ERROR = 7

static

COMMAND_OK

final int org.freedesktop.dbus.Transport.SASL.COMMAND_OK = 4

static

COMMAND_REJECTED

final int org.freedesktop.dbus.Transport.SASL.COMMAND_REJECTED = 3

static

CONTINUE

final int org.freedesktop.dbus.Transport.SASL.CONTINUE = 2

static

cookie

String org.freedesktop.dbus.Transport.SASL.cookie = ""

COOKIE_CONTEXT

final String org.freedesktop.dbus.Transport.SASL.COOKIE_CONTEXT = "org_freedesktop_java"

static

COOKIE_TIMEOUT

final int org.freedesktop.dbus.Transport.SASL.COOKIE_TIMEOUT = 240

static

ERROR

final int org.freedesktop.dbus.Transport.SASL.ERROR = 3

static

EXPIRE_KEYS_TIMEOUT_SECONDS

final int org.freedesktop.dbus.Transport.SASL.EXPIRE_KEYS_TIMEOUT_SECONDS = NEW_KEY_TIMEOUT_SECONDS + (60 * 2)

static

FAILED

final int org.freedesktop.dbus.Transport.SASL.FAILED = 7

static

INITIAL_STATE

final int org.freedesktop.dbus.Transport.SASL.INITIAL_STATE = 0

static

LOCK_TIMEOUT

final int org.freedesktop.dbus.Transport.SASL.LOCK_TIMEOUT = 1000

static

MAX_TIME_TRAVEL_SECONDS

final int org.freedesktop.dbus.Transport.SASL.MAX_TIME_TRAVEL_SECONDS = 60 * 5

static

MODE_CLIENT

final int org.freedesktop.dbus.Transport.SASL.MODE_CLIENT = 2

static

MODE_SERVER

final int org.freedesktop.dbus.Transport.SASL.MODE_SERVER = 1

static

NEW_KEY_TIMEOUT_SECONDS

final int org.freedesktop.dbus.Transport.SASL.NEW_KEY_TIMEOUT_SECONDS = 60 * 5

static

OK

final int org.freedesktop.dbus.Transport.SASL.OK = 1

static

REJECT

final int org.freedesktop.dbus.Transport.SASL.REJECT = 4

static

WAIT_AUTH

final int org.freedesktop.dbus.Transport.SASL.WAIT_AUTH = 4

static

WAIT_BEGIN

final int org.freedesktop.dbus.Transport.SASL.WAIT_BEGIN = 5

static

WAIT_DATA

final int org.freedesktop.dbus.Transport.SASL.WAIT_DATA = 1

static

WAIT_OK

final int org.freedesktop.dbus.Transport.SASL.WAIT_OK = 2

static

WAIT_REJECT

final int org.freedesktop.dbus.Transport.SASL.WAIT_REJECT = 3

static

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/federation/src/federation/sssd/src/main/java/org/freedesktop/dbus/Transport.java