Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.8k

[ "func", "(", "b", "*", "Boxer", ")", "boxV1", "(", "messagePlaintext", "chat1", ".", "MessagePlaintext", ",", "key", "types", ".", "CryptKey", ",", "signingKeyPair", "libkb", ".", "NaclSigningKeyPair", ")", "(", "res", "chat1", ".", "MessageBoxed", ",", "err", "error", ")", "{", "body", ":=", "chat1", ".", "BodyPlaintextV1", "{", "MessageBody", ":", "messagePlaintext", ".", "MessageBody", ",", "}", "\n", "plaintextBody", ":=", "chat1", ".", "NewBodyPlaintextWithV1", "(", "body", ")", "\n", "encryptedBody", ",", "err", ":=", "b", ".", "seal", "(", "plaintextBody", ",", "libkb", ".", "NaclSecretBoxKey", "(", "key", ".", "Material", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// create the v1 header, adding hash", "bodyHash", ":=", "b", ".", "hashV1", "(", "encryptedBody", ".", "E", ")", "\n", "if", "messagePlaintext", ".", "ClientHeader", ".", "MerkleRoot", "!=", "nil", "{", "return", "res", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "header", ":=", "chat1", ".", "HeaderPlaintextV1", "{", "Conv", ":", "messagePlaintext", ".", "ClientHeader", ".", "Conv", ",", "TlfName", ":", "messagePlaintext", ".", "ClientHeader", ".", "TlfName", ",", "TlfPublic", ":", "messagePlaintext", ".", "ClientHeader", ".", "TlfPublic", ",", "MessageType", ":", "messagePlaintext", ".", "ClientHeader", ".", "MessageType", ",", "Prev", ":", "messagePlaintext", ".", "ClientHeader", ".", "Prev", ",", "Sender", ":", "messagePlaintext", ".", "ClientHeader", ".", "Sender", ",", "SenderDevice", ":", "messagePlaintext", ".", "ClientHeader", ".", "SenderDevice", ",", "MerkleRoot", ":", "nil", ",", "// MerkleRoot cannot be sent in MBv1 messages", "BodyHash", ":", "bodyHash", "[", ":", "]", ",", "OutboxInfo", ":", "messagePlaintext", ".", "ClientHeader", ".", "OutboxInfo", ",", "OutboxID", ":", "messagePlaintext", ".", "ClientHeader", ".", "OutboxID", ",", "KbfsCryptKeysUsed", ":", "messagePlaintext", ".", "ClientHeader", ".", "KbfsCryptKeysUsed", ",", "}", "\n\n", "// sign the header and insert the signature", "sig", ",", "err", ":=", "b", ".", "signMarshal", "(", "header", ",", "signingKeyPair", ",", "kbcrypto", ".", "SignaturePrefixChatMBv1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "header", ".", "HeaderSignature", "=", "&", "sig", "\n\n", "// create a plaintext header", "plaintextHeader", ":=", "chat1", ".", "NewHeaderPlaintextWithV1", "(", "header", ")", "\n", "encryptedHeader", ",", "err", ":=", "b", ".", "seal", "(", "plaintextHeader", ",", "libkb", ".", "NaclSecretBoxKey", "(", "key", ".", "Material", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "return", "chat1", ".", "MessageBoxed", "{", "Version", ":", "chat1", ".", "MessageBoxedVersion_V1", ",", "ClientHeader", ":", "messagePlaintext", ".", "ClientHeader", ",", "BodyCiphertext", ":", "*", "encryptedBody", ",", "HeaderCiphertext", ":", "encryptedHeader", ".", "AsSealed", "(", ")", ",", "KeyGeneration", ":", "key", ".", "Generation", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "boxMessageWithKeys", "encrypts", "and", "signs", "a", "keybase1", ".", "MessagePlaintext", "into", "a", "chat1", ".", "MessageBoxed", "given", "a", "keybase1", ".", "CryptKey", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "boxV2orV3orV4", "(", "ctx", "context", ".", "Context", ",", "messagePlaintext", "chat1", ".", "MessagePlaintext", ",", "baseEncryptionKey", "types", ".", "CryptKey", ",", "ephemeralSeed", "*", "keybase1", ".", "TeamEk", ",", "signingKeyPair", "libkb", ".", "NaclSigningKeyPair", ",", "version", "chat1", ".", "MessageBoxedVersion", ",", "pairwiseMACRecipients", "[", "]", "keybase1", ".", "KID", ")", "(", "res", "chat1", ".", "MessageBoxed", ",", "err", "error", ")", "{", "if", "messagePlaintext", ".", "ClientHeader", ".", "MerkleRoot", "==", "nil", "{", "return", "res", ",", "NewBoxingError", "(", "\"", "\"", ",", "false", ")", "\n", "}", "\n", "headerEncryptionKey", ",", "err", ":=", "libkb", ".", "DeriveSymmetricKey", "(", "libkb", ".", "NaclSecretBoxKey", "(", "baseEncryptionKey", ".", "Material", "(", ")", ")", ",", "libkb", ".", "EncryptionReasonChatMessage", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// Regular messages use the same encryption key for the header and for the", "// body. Exploding messages use a derived ephemeral key for the body.", "bodyEncryptionKey", ":=", "headerEncryptionKey", "\n", "if", "messagePlaintext", ".", "IsEphemeral", "(", ")", "{", "bodyEncryptionKey", ",", "err", "=", "libkb", ".", "DeriveFromSecret", "(", "ephemeralSeed", ".", "Seed", ",", "libkb", ".", "DeriveReasonTeamEKExplodingChat", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "// The MessagePlaintext supplied by the caller has a Lifetime, but we", "// expect the Generation is left uninitialized, and we set it here.", "messagePlaintext", ".", "ClientHeader", ".", "EphemeralMetadata", ".", "Generation", "=", "ephemeralSeed", ".", "Metadata", ".", "Generation", "\n", "}", "\n\n", "bodyVersioned", ":=", "chat1", ".", "NewBodyPlaintextWithV1", "(", "chat1", ".", "BodyPlaintextV1", "{", "MessageBody", ":", "messagePlaintext", ".", "MessageBody", ",", "}", ")", "\n", "bodyEncrypted", ",", "err", ":=", "b", ".", "seal", "(", "bodyVersioned", ",", "bodyEncryptionKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "bodyHash", ",", "err", ":=", "b", ".", "makeBodyHash", "(", "*", "bodyEncrypted", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// create the v1 header, adding hash", "headerVersioned", ":=", "chat1", ".", "NewHeaderPlaintextWithV1", "(", "chat1", ".", "HeaderPlaintextV1", "{", "Conv", ":", "messagePlaintext", ".", "ClientHeader", ".", "Conv", ",", "TlfName", ":", "messagePlaintext", ".", "ClientHeader", ".", "TlfName", ",", "TlfPublic", ":", "messagePlaintext", ".", "ClientHeader", ".", "TlfPublic", ",", "MessageType", ":", "messagePlaintext", ".", "ClientHeader", ".", "MessageType", ",", "Prev", ":", "messagePlaintext", ".", "ClientHeader", ".", "Prev", ",", "Sender", ":", "messagePlaintext", ".", "ClientHeader", ".", "Sender", ",", "SenderDevice", ":", "messagePlaintext", ".", "ClientHeader", ".", "SenderDevice", ",", "BodyHash", ":", "bodyHash", ",", "MerkleRoot", ":", "messagePlaintext", ".", "ClientHeader", ".", "MerkleRoot", ",", "OutboxInfo", ":", "messagePlaintext", ".", "ClientHeader", ".", "OutboxInfo", ",", "OutboxID", ":", "messagePlaintext", ".", "ClientHeader", ".", "OutboxID", ",", "KbfsCryptKeysUsed", ":", "messagePlaintext", ".", "ClientHeader", ".", "KbfsCryptKeysUsed", ",", "EphemeralMetadata", ":", "messagePlaintext", ".", "ClientHeader", ".", "EphemeralMetadata", ",", "// In MessageBoxed.V2 HeaderSignature is nil.", "HeaderSignature", ":", "nil", ",", "}", ")", "\n\n", "// signencrypt the header", "headerSealed", ",", "err", ":=", "b", ".", "signEncryptMarshal", "(", "headerVersioned", ",", "headerEncryptionKey", ",", "signingKeyPair", ",", "kbcrypto", ".", "SignaturePrefixChatMBv2", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n\n", "// Make pairwise MACs if there are any pairwise recipients supplied. Note", "// that we still sign+encrypt with a signing key above. If we want", "// repudiability, it's the caller's responsibility to provide a zero", "// signing key or similar. Signing with a real key and also MAC'ing is", "// redundant, but it will let us test the MAC code in prod in a backwards", "// compatible way.", "if", "len", "(", "pairwiseMACRecipients", ")", ">", "0", "{", "pairwiseMACs", ",", "err", ":=", "b", ".", "makeAllPairwiseMACs", "(", "ctx", ",", "headerSealed", ",", "pairwiseMACRecipients", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "messagePlaintext", ".", "ClientHeader", ".", "PairwiseMacs", "=", "pairwiseMACs", "\n", "}", "\n\n", "// verify", "verifyKey", ":=", "signingKeyPair", ".", "GetBinaryKID", "(", ")", "\n\n", "return", "chat1", ".", "MessageBoxed", "{", "Version", ":", "version", ",", "ServerHeader", ":", "nil", ",", "ClientHeader", ":", "messagePlaintext", ".", "ClientHeader", ",", "HeaderCiphertext", ":", "headerSealed", ".", "AsSealed", "(", ")", ",", "BodyCiphertext", ":", "*", "bodyEncrypted", ",", "VerifyKey", ":", "verifyKey", ",", "KeyGeneration", ":", "baseEncryptionKey", ".", "Generation", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "V3", "is", "just", "V2", "but", "with", "exploding", "messages", "support", ".", "V4", "is", "just", "V3", "but", "it", "signs", "with", "the", "zero", "key", "when", "pairwise", "MACs", "are", "included", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "seal", "(", "data", "interface", "{", "}", ",", "key", "libkb", ".", "NaclSecretBoxKey", ")", "(", "*", "chat1", ".", "EncryptedData", ",", "error", ")", "{", "s", ",", "err", ":=", "b", ".", "marshal", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "nonce", "[", "libkb", ".", "NaclDHNonceSize", "]", "byte", "\n", "if", "_", ",", "err", ":=", "rand", ".", "Read", "(", "nonce", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "encKey", "[", "libkb", ".", "NaclSecretBoxKeySize", "]", "byte", "=", "key", "\n\n", "sealed", ":=", "secretbox", ".", "Seal", "(", "nil", ",", "[", "]", "byte", "(", "s", ")", ",", "&", "nonce", ",", "&", "encKey", ")", "\n", "enc", ":=", "&", "chat1", ".", "EncryptedData", "{", "V", ":", "1", ",", "E", ":", "sealed", ",", "N", ":", "nonce", "[", ":", "]", ",", "}", "\n\n", "return", "enc", ",", "nil", "\n", "}" ]

[ "seal", "encrypts", "data", "into", "chat1", ".", "EncryptedData", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "open", "(", "data", "chat1", ".", "EncryptedData", ",", "key", "libkb", ".", "NaclSecretBoxKey", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "len", "(", "data", ".", "N", ")", "!=", "libkb", ".", "NaclDHNonceSize", "{", "return", "nil", ",", "libkb", ".", "DecryptBadNonceError", "{", "}", "\n", "}", "\n", "var", "nonce", "[", "libkb", ".", "NaclDHNonceSize", "]", "byte", "\n", "copy", "(", "nonce", "[", ":", "]", ",", "data", ".", "N", ")", "\n\n", "plain", ",", "ok", ":=", "secretbox", ".", "Open", "(", "nil", ",", "data", ".", "E", ",", "&", "nonce", ",", "(", "*", "[", "32", "]", "byte", ")", "(", "&", "key", ")", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "libkb", ".", "DecryptOpenError", "{", "}", "\n", "}", "\n", "return", "plain", ",", "nil", "\n", "}" ]

[ "open", "decrypts", "chat1", ".", "EncryptedData", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "signMarshal", "(", "data", "interface", "{", "}", ",", "kp", "libkb", ".", "NaclSigningKeyPair", ",", "prefix", "kbcrypto", ".", "SignaturePrefix", ")", "(", "chat1", ".", "SignatureInfo", ",", "error", ")", "{", "encoded", ",", "err", ":=", "b", ".", "marshal", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "chat1", ".", "SignatureInfo", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "b", ".", "sign", "(", "encoded", ",", "kp", ",", "prefix", ")", "\n", "}" ]

[ "signMarshal", "signs", "data", "with", "a", "NaclSigningKeyPair", "returning", "a", "chat1", ".", "SignatureInfo", ".", "It", "marshals", "data", "before", "signing", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "signEncryptMarshal", "(", "data", "interface", "{", "}", ",", "encryptionKey", "libkb", ".", "NaclSecretBoxKey", ",", "signingKeyPair", "libkb", ".", "NaclSigningKeyPair", ",", "prefix", "kbcrypto", ".", "SignaturePrefix", ")", "(", "chat1", ".", "SignEncryptedData", ",", "error", ")", "{", "encoded", ",", "err", ":=", "b", ".", "marshal", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "chat1", ".", "SignEncryptedData", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "b", ".", "signEncrypt", "(", "encoded", ",", "encryptionKey", ",", "signingKeyPair", ",", "prefix", ")", "\n", "}" ]

[ "signEncryptMarshal", "signencrypts", "data", "given", "an", "encryption", "and", "signing", "key", "returning", "a", "chat1", ".", "SignEncryptedData", ".", "It", "marshals", "data", "before", "signing", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "sign", "(", "msg", "[", "]", "byte", ",", "kp", "libkb", ".", "NaclSigningKeyPair", ",", "prefix", "kbcrypto", ".", "SignaturePrefix", ")", "(", "chat1", ".", "SignatureInfo", ",", "error", ")", "{", "sig", ",", "err", ":=", "kp", ".", "SignV2", "(", "msg", ",", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "chat1", ".", "SignatureInfo", "{", "}", ",", "err", "\n", "}", "\n", "sigInfo", ":=", "chat1", ".", "SignatureInfo", "{", "V", ":", "sig", ".", "Version", ",", "S", ":", "sig", ".", "Sig", "[", ":", "]", ",", "K", ":", "sig", ".", "Kid", ",", "}", "\n\n", "if", "b", ".", "testingSignatureMangle", "!=", "nil", "{", "b", ".", "assertInTest", "(", ")", "\n", "sigInfo", ".", "S", "=", "b", ".", "testingSignatureMangle", "(", "sigInfo", ".", "S", ")", "\n", "}", "\n\n", "return", "sigInfo", ",", "nil", "\n", "}" ]

[ "sign", "signs", "msg", "with", "a", "NaclSigningKeyPair", "returning", "a", "chat1", ".", "SignatureInfo", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "signEncrypt", "(", "msg", "[", "]", "byte", ",", "encryptionKey", "libkb", ".", "NaclSecretBoxKey", ",", "signingKeyPair", "libkb", ".", "NaclSigningKeyPair", ",", "prefix", "kbcrypto", ".", "SignaturePrefix", ")", "(", "chat1", ".", "SignEncryptedData", ",", "error", ")", "{", "if", "signingKeyPair", ".", "Private", "==", "nil", "{", "return", "chat1", ".", "SignEncryptedData", "{", "}", ",", "libkb", ".", "NoSecretKeyError", "{", "}", "\n", "}", "\n\n", "var", "nonce", "[", "signencrypt", ".", "NonceSize", "]", "byte", "\n", "if", "_", ",", "err", ":=", "rand", ".", "Read", "(", "nonce", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "chat1", ".", "SignEncryptedData", "{", "}", ",", "err", "\n", "}", "\n\n", "var", "encKey", "[", "signencrypt", ".", "SecretboxKeySize", "]", "byte", "=", "encryptionKey", "\n", "var", "signKey", "[", "ed25519", ".", "PrivateKeySize", "]", "byte", "=", "*", "signingKeyPair", ".", "Private", "\n\n", "signEncryptedBytes", ":=", "signencrypt", ".", "SealWhole", "(", "msg", ",", "&", "encKey", ",", "&", "signKey", ",", "prefix", ",", "&", "nonce", ")", "\n", "signEncryptedInfo", ":=", "chat1", ".", "SignEncryptedData", "{", "V", ":", "1", ",", "E", ":", "signEncryptedBytes", ",", "N", ":", "nonce", "[", ":", "]", ",", "}", "\n\n", "if", "b", ".", "testingSignatureMangle", "!=", "nil", "{", "b", ".", "assertInTest", "(", ")", "\n", "signEncryptedInfo", ".", "E", "=", "b", ".", "testingSignatureMangle", "(", "signEncryptedInfo", ".", "E", ")", "\n", "}", "\n\n", "return", "signEncryptedInfo", ",", "nil", "\n", "}" ]

[ "signEncrypt", "signencrypts", "msg", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "signEncryptOpen", "(", "data", "chat1", ".", "SignEncryptedData", ",", "encryptionKey", "libkb", ".", "NaclSecretBoxKey", ",", "verifyKID", "[", "]", "byte", ",", "prefix", "kbcrypto", ".", "SignaturePrefix", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "var", "encKey", "[", "signencrypt", ".", "SecretboxKeySize", "]", "byte", "=", "encryptionKey", "\n\n", "verifyKey", ":=", "kbcrypto", ".", "KIDToNaclSigningKeyPublic", "(", "verifyKID", ")", "\n", "if", "verifyKey", "==", "nil", "{", "return", "nil", ",", "kbcrypto", ".", "BadKeyError", "{", "}", "\n", "}", "\n", "var", "verKey", "[", "ed25519", ".", "PublicKeySize", "]", "byte", "=", "*", "verifyKey", "\n\n", "var", "nonce", "[", "signencrypt", ".", "NonceSize", "]", "byte", "\n", "if", "copy", "(", "nonce", "[", ":", "]", ",", "data", ".", "N", ")", "!=", "signencrypt", ".", "NonceSize", "{", "return", "nil", ",", "libkb", ".", "DecryptBadNonceError", "{", "}", "\n", "}", "\n\n", "plain", ",", "err", ":=", "signencrypt", ".", "OpenWhole", "(", "data", ".", "E", ",", "&", "encKey", ",", "&", "verKey", ",", "prefix", ",", "&", "nonce", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "plain", ",", "nil", "\n", "}" ]

[ "signEncryptOpen", "opens", "and", "verifies", "chat1", ".", "SignEncryptedData", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "verifyMessageV1", "(", "ctx", "context", ".", "Context", ",", "header", "chat1", ".", "HeaderPlaintext", ",", "msg", "chat1", ".", "MessageBoxed", ",", "skipBodyVerification", "bool", ")", "(", "verifyMessageRes", ",", "types", ".", "UnboxingError", ")", "{", "headerVersion", ",", "err", ":=", "header", ".", "Version", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "verifyMessageRes", "{", "}", ",", "NewPermanentUnboxingError", "(", "err", ")", "\n", "}", "\n\n", "switch", "headerVersion", "{", "case", "chat1", ".", "HeaderPlaintextVersion_V1", ":", "return", "b", ".", "verifyMessageHeaderV1", "(", "ctx", ",", "header", ".", "V1", "(", ")", ",", "msg", ",", "skipBodyVerification", ")", "\n", "// NOTE: When adding new versions here, you must also update", "// chat1/extras.go so MessageUnboxedError.ParseableVersion understands the", "// new max version", "default", ":", "return", "verifyMessageRes", "{", "}", ",", "NewPermanentUnboxingError", "(", "NewHeaderVersionError", "(", "headerVersion", ",", "b", ".", "headerUnsupported", "(", "ctx", ",", "headerVersion", ",", "header", ")", ")", ")", "\n", "}", "\n", "}" ]

[ "verifyMessage", "checks", "that", "a", "message", "is", "valid", ".", "Only", "works", "on", "MessageBoxedVersion_V1" ]

[ "func", "(", "b", "*", "Boxer", ")", "verifyMessageHeaderV1", "(", "ctx", "context", ".", "Context", ",", "header", "chat1", ".", "HeaderPlaintextV1", ",", "msg", "chat1", ".", "MessageBoxed", ",", "skipBodyVerification", "bool", ")", "(", "verifyMessageRes", ",", "types", ".", "UnboxingError", ")", "{", "if", "!", "skipBodyVerification", "{", "// check body hash", "bh", ":=", "b", ".", "hashV1", "(", "msg", ".", "BodyCiphertext", ".", "E", ")", "\n", "if", "!", "libkb", ".", "SecureByteArrayEq", "(", "bh", "[", ":", "]", ",", "header", ".", "BodyHash", ")", "{", "return", "verifyMessageRes", "{", "}", ",", "NewPermanentUnboxingError", "(", "BodyHashInvalid", "{", "}", ")", "\n", "}", "\n", "}", "\n\n", "// check key validity", "// ValidSenderKey uses the server-given ctime, but emits senderDeviceRevokedAt as a workaround.", "// See ValidSenderKey for details.", "found", ",", "validAtCtime", ",", "revoked", ",", "ierr", ":=", "b", ".", "ValidSenderKey", "(", "ctx", ",", "header", ".", "Sender", ",", "header", ".", "HeaderSignature", ".", "K", ",", "msg", ".", "ServerHeader", ".", "Ctime", ")", "\n", "if", "ierr", "!=", "nil", "{", "return", "verifyMessageRes", "{", "}", ",", "ierr", "\n", "}", "\n", "if", "!", "found", "{", "return", "verifyMessageRes", "{", "}", ",", "NewPermanentUnboxingError", "(", "libkb", ".", "NoKeyError", "{", "Msg", ":", "\"", "\"", "}", ")", "\n", "}", "\n", "if", "!", "validAtCtime", "{", "return", "verifyMessageRes", "{", "}", ",", "NewPermanentUnboxingError", "(", "libkb", ".", "NoKeyError", "{", "Msg", ":", "\"", "\"", "}", ")", "\n", "}", "\n\n", "// check signature", "hcopy", ":=", "header", "\n", "hcopy", ".", "HeaderSignature", "=", "nil", "\n", "hpack", ",", "err", ":=", "b", ".", "marshal", "(", "hcopy", ")", "\n", "if", "err", "!=", "nil", "{", "return", "verifyMessageRes", "{", "}", ",", "NewPermanentUnboxingError", "(", "err", ")", "\n", "}", "\n", "if", "!", "b", ".", "verify", "(", "hpack", ",", "*", "header", ".", "HeaderSignature", ",", "kbcrypto", ".", "SignaturePrefixChatMBv1", ")", "{", "return", "verifyMessageRes", "{", "}", ",", "NewPermanentUnboxingError", "(", "libkb", ".", "BadSigError", "{", "E", ":", "\"", "\"", "}", ")", "\n", "}", "\n\n", "return", "verifyMessageRes", "{", "senderDeviceRevokedAt", ":", "revoked", ",", "}", ",", "nil", "\n", "}" ]

[ "verifyMessageHeaderV1", "checks", "the", "body", "hash", "header", "signature", "and", "signing", "key", "validity", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "verify", "(", "data", "[", "]", "byte", ",", "si", "chat1", ".", "SignatureInfo", ",", "prefix", "kbcrypto", ".", "SignaturePrefix", ")", "bool", "{", "sigInfo", ":=", "kbcrypto", ".", "NaclSigInfo", "{", "Version", ":", "si", ".", "V", ",", "Prefix", ":", "prefix", ",", "Kid", ":", "si", ".", "K", ",", "Payload", ":", "data", ",", "}", "\n", "copy", "(", "sigInfo", ".", "Sig", "[", ":", "]", ",", "si", ".", "S", ")", "\n", "_", ",", "err", ":=", "sigInfo", ".", "Verify", "(", ")", "\n", "return", "(", "err", "==", "nil", ")", "\n", "}" ]

[ "verify", "verifies", "the", "signature", "of", "data", "using", "SignatureInfo", "." ]

[ "func", "(", "b", "*", "Boxer", ")", "compareHeadersMBV1", "(", "ctx", "context", ".", "Context", ",", "hServer", "chat1", ".", "MessageClientHeader", ",", "hSigned", "chat1", ".", "MessageClientHeaderVerified", ")", "types", ".", "UnboxingError", "{", "// Conv", "if", "!", "hServer", ".", "Conv", ".", "Eq", "(", "hSigned", ".", "Conv", ")", "{", "return", "NewPermanentUnboxingError", "(", "NewHeaderMismatchError", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// TlfName", "if", "hServer", ".", "TlfName", "!=", "hSigned", ".", "TlfName", "{", "return", "NewPermanentUnboxingError", "(", "NewHeaderMismatchError", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// TlfPublic", "if", "hServer", ".", "TlfPublic", "!=", "hSigned", ".", "TlfPublic", "{", "return", "NewPermanentUnboxingError", "(", "NewHeaderMismatchError", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// MessageType", "if", "hServer", ".", "MessageType", "!=", "hSigned", ".", "MessageType", "{", "return", "NewPermanentUnboxingError", "(", "NewHeaderMismatchError", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// Note: Supersedes, Deletes, and some other fields are not checked because they are not", "// part of MessageClientHeaderVerified.", "// Prev", "if", "len", "(", "hServer", ".", "Prev", ")", "!=", "len", "(", "hSigned", ".", "Prev", ")", "{", "return", "NewPermanentUnboxingError", "(", "NewHeaderMismatchError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "for", "i", ",", "a", ":=", "range", "hServer", ".", "Prev", "{", "b", ":=", "hSigned", ".", "Prev", "[", "i", "]", "\n", "if", "!", "a", ".", "Eq", "(", "b", ")", "{", "return", "NewPermanentUnboxingError", "(", "NewHeaderMismatchError", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "}", "\n\n", "// Sender", "// This prevents someone from re-using a header for another sender", "if", "!", "hServer", ".", "Sender", ".", "Eq", "(", "hSigned", ".", "Sender", ")", "{", "return", "NewPermanentUnboxingError", "(", "NewHeaderMismatchError", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// SenderDevice", "if", "!", "bytes", ".", "Equal", "(", "hServer", ".", "SenderDevice", ".", "Bytes", "(", ")", ",", "hSigned", ".", "SenderDevice", ".", "Bytes", "(", ")", ")", "{", "return", "NewPermanentUnboxingError", "(", "NewHeaderMismatchError", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// _Don't_ check that the MerkleRoot's match.", "// The signed MerkleRoot should be nil as it was not part of the protocol", "// when clients were writing MBV1. But we just allow anything here.", "// There are V1 messages in the wild with hServer.MerkleRoot set but nothing signed.", "// OutboxID, OutboxInfo: Left unchecked as I'm not sure whether these hold in V1 messages.", "return", "nil", "\n", "}" ]

[ "See", "note", "on", "compareHeadersMBV2orV3", "." ]

[ "func", "SaltpackEncrypt", "(", "m", "MetaContext", ",", "arg", "*", "SaltpackEncryptArg", ")", "error", "{", "var", "receiverBoxKeys", "[", "]", "saltpack", ".", "BoxPublicKey", "\n", "for", "_", ",", "k", ":=", "range", "arg", ".", "Receivers", "{", "// Since signcryption became the default, we never use visible", "// recipients in encryption mode, except in tests.", "if", "arg", ".", "VisibleRecipientsForTesting", "{", "receiverBoxKeys", "=", "append", "(", "receiverBoxKeys", ",", "naclBoxPublicKey", "(", "k", ")", ")", "\n", "}", "else", "{", "receiverBoxKeys", "=", "append", "(", "receiverBoxKeys", ",", "hiddenNaclBoxPublicKey", "(", "k", ")", ")", "\n", "}", "\n", "}", "\n\n", "var", "bsk", "saltpack", ".", "BoxSecretKey", "\n", "if", "!", "arg", ".", "Sender", ".", "IsNil", "(", ")", "{", "bsk", "=", "naclBoxSecretKey", "(", "arg", ".", "Sender", ")", "\n", "}", "\n\n", "// If the version is unspecified, default to the current version.", "saltpackVersion", ":=", "arg", ".", "SaltpackVersion", "\n", "if", "saltpackVersion", "==", "(", "saltpack", ".", "Version", "{", "}", ")", "{", "saltpackVersion", "=", "saltpack", ".", "CurrentVersion", "(", ")", "\n", "}", "\n\n", "var", "plainsink", "io", ".", "WriteCloser", "\n", "var", "err", "error", "\n", "if", "!", "arg", ".", "EncryptionOnlyMode", "{", "if", "arg", ".", "SaltpackVersion", ".", "Major", "==", "1", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "signer", "saltpack", ".", "SigningSecretKey", "\n", "if", "!", "arg", ".", "SenderSigning", ".", "IsNil", "(", ")", "{", "signer", "=", "saltSigner", "{", "arg", ".", "SenderSigning", "}", "\n", "}", "\n", "if", "arg", ".", "Binary", "{", "plainsink", ",", "err", "=", "saltpack", ".", "NewSigncryptSealStream", "(", "arg", ".", "Sink", ",", "emptyKeyring", "{", "}", ",", "signer", ",", "receiverBoxKeys", ",", "arg", ".", "SymmetricReceivers", ")", "\n", "}", "else", "{", "plainsink", ",", "err", "=", "saltpack", ".", "NewSigncryptArmor62SealStream", "(", "arg", ".", "Sink", ",", "emptyKeyring", "{", "}", ",", "signer", ",", "receiverBoxKeys", ",", "arg", ".", "SymmetricReceivers", ",", "KeybaseSaltpackBrand", ")", "\n", "}", "\n", "}", "else", "{", "if", "arg", ".", "Binary", "{", "plainsink", ",", "err", "=", "saltpack", ".", "NewEncryptStream", "(", "saltpackVersion", ",", "arg", ".", "Sink", ",", "bsk", ",", "receiverBoxKeys", ")", "\n", "}", "else", "{", "plainsink", ",", "err", "=", "saltpack", ".", "NewEncryptArmor62Stream", "(", "saltpackVersion", ",", "arg", ".", "Sink", ",", "bsk", ",", "receiverBoxKeys", ",", "KeybaseSaltpackBrand", ")", "\n", "}", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "n", ",", "err", ":=", "io", ".", "Copy", "(", "plainsink", ",", "arg", ".", "Source", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "m", ".", "Debug", "(", "\"", "\"", ",", "n", ")", "\n\n", "if", "err", ":=", "plainsink", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "arg", ".", "Sink", ".", "Close", "(", ")", "\n", "}" ]

[ "SaltpackEncrypt", "reads", "from", "the", "given", "source", "encrypts", "it", "for", "the", "given", "receivers", "from", "the", "given", "sender", "and", "writes", "it", "to", "sink", ".", "If", "Binary", "is", "false", "the", "data", "written", "to", "sink", "will", "be", "armored", "." ]

[ "func", "(", "mc", "*", "MerkleClient", ")", "FetchRootFromServer", "(", "m", "MetaContext", ",", "freshness", "time", ".", "Duration", ")", "(", "mr", "*", "MerkleRoot", ",", "err", "error", ")", "{", "defer", "m", ".", "VTrace", "(", "VLog0", ",", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// on startup, many threads might try to mash this call at once (via the Auditor or", "// other pathways). So protect this with a lock.", "mc", ".", "freshLock", ".", "Lock", "(", ")", "\n", "defer", "mc", ".", "freshLock", ".", "Unlock", "(", ")", "\n\n", "root", ":=", "mc", ".", "LastRoot", "(", ")", "\n", "now", ":=", "m", ".", "G", "(", ")", ".", "Clock", "(", ")", ".", "Now", "(", ")", "\n", "if", "root", "!=", "nil", "&&", "freshness", ">", "0", "&&", "now", ".", "Sub", "(", "root", ".", "fetched", ")", "<", "freshness", "{", "m", ".", "VLogf", "(", "VLog0", ",", "\"", "\"", ",", "freshness", ")", "\n", "return", "root", ",", "nil", "\n", "}", "\n", "return", "mc", ".", "fetchRootFromServer", "(", "m", ",", "root", ")", "\n", "}" ]

[ "FetchRootFromServer", "fetches", "a", "root", "from", "the", "server", ".", "If", "the", "last", "-", "fetched", "root", "was", "fetched", "within", "freshness", "ago", "then", "OK", "to", "return", "the", "last", "-", "fetched", "root", ".", "Otherwise", "refetch", ".", "Similarly", "if", "the", "freshness", "passed", "is", "0", "then", "always", "refresh", "." ]

[ "func", "(", "mc", "*", "MerkleClient", ")", "lookupPathAndSkipSequenceHelper", "(", "m", "MetaContext", ",", "q", "HTTPArgs", ",", "sigHints", "*", "SigHints", ",", "lastRoot", "*", "MerkleRoot", ",", "isUser", "bool", ")", "(", "apiRes", "*", "APIRes", ",", "err", "error", ")", "{", "defer", "m", ".", "VTrace", "(", "VLog1", ",", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "// Poll for 10s and ask for a race-free state.", "w", ":=", "10", "*", "int", "(", "CITimeMultiplier", "(", "mc", ".", "G", "(", ")", ")", ")", "\n\n", "q", ".", "Add", "(", "\"", "\"", ",", "I", "{", "w", "}", ")", "\n", "q", ".", "Add", "(", "\"", "\"", ",", "B", "{", "true", "}", ")", "\n", "if", "isUser", "{", "q", ".", "Add", "(", "\"", "\"", ",", "B", "{", "true", "}", ")", "\n", "q", ".", "Add", "(", "\"", "\"", ",", "B", "{", "true", "}", ")", "\n", "}", "\n\n", "// Add the local db sigHints version", "if", "sigHints", "!=", "nil", "{", "q", ".", "Add", "(", "\"", "\"", ",", "I", "{", "sigHints", ".", "version", "}", ")", "\n", "}", "\n\n", "// Get back a series of skips from the last merkle root we had to the new", "// one we're getting back, and hold the server to it.", "lastSeqno", ":=", "lastRoot", ".", "Seqno", "(", ")", "\n", "if", "lastSeqno", "!=", "nil", "{", "q", ".", "Add", "(", "\"", "\"", ",", "I", "{", "int", "(", "*", "lastSeqno", ")", "}", ")", "\n", "}", "\n\n", "apiRes", ",", "err", "=", "m", ".", "G", "(", ")", ".", "API", ".", "Get", "(", "m", ",", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "APISessionTypeNONE", ",", "Args", ":", "q", ",", "AppStatusCodes", ":", "[", "]", "int", "{", "SCOk", ",", "SCNotFound", ",", "SCDeleted", "}", ",", "RetryCount", ":", "3", ",", "InitialTimeout", ":", "4", "*", "time", ".", "Second", ",", "RetryMultiplier", ":", "1.1", ",", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "switch", "apiRes", ".", "AppStatus", ".", "Code", "{", "case", "SCNotFound", ":", "err", "=", "NotFoundError", "{", "}", "\n", "return", "nil", ",", "err", "\n", "case", "SCDeleted", ":", "err", "=", "UserDeletedError", "{", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "apiRes", ",", "err", "\n", "}" ]

[ "isUser", "is", "true", "for", "loading", "a", "user", "and", "false", "for", "loading", "a", "team", "." ]

[ "func", "(", "mc", "*", "MerkleClient", ")", "readSkipSequenceFromAPIRes", "(", "m", "MetaContext", ",", "res", "*", "APIRes", ",", "thisRoot", "*", "MerkleRoot", ",", "lastRoot", "*", "MerkleRoot", ")", "(", "ret", "SkipSequence", ",", "err", "error", ")", "{", "defer", "m", ".", "VTrace", "(", "VLog1", ",", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n", "if", "lastRoot", "==", "nil", "{", "m", ".", "VLogf", "(", "VLog0", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "!", "thisRoot", ".", "HasSkips", "(", ")", "{", "m", ".", "VLogf", "(", "VLog0", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "skips", ":=", "res", ".", "Body", ".", "AtKey", "(", "\"", "\"", ")", "\n\n", "if", "skips", ".", "IsNil", "(", ")", "{", "m", ".", "VLogf", "(", "VLog1", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n\n", "var", "v", "[", "]", "string", "\n", "if", "err", "=", "skips", ".", "UnmarshalAgain", "(", "&", "v", ")", ";", "err", "!=", "nil", "{", "m", ".", "VLogf", "(", "VLog0", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "ret", ",", "err", "=", "readSkipSequenceFromStringList", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Create the skip sequence by bookending the list the server replies with", "// with: (1) the most recent root, sent back in this reply; and (2) our last", "// root, which we read out of cache (in memory or on disk). HOWEVER, in the", "// case of lookup up historical roots, the ordering might be reversed. So", "// we swap in that case.", "left", ",", "right", ":=", "thisRoot", ".", "payload", ",", "lastRoot", ".", "payload", "\n", "if", "left", ".", "seqno", "(", ")", "<", "right", ".", "seqno", "(", ")", "{", "left", ",", "right", "=", "right", ",", "left", "\n", "}", "\n\n", "ret", "=", "append", "(", "SkipSequence", "{", "left", "}", ",", "ret", "...", ")", "\n", "ret", "=", "append", "(", "ret", ",", "right", ")", "\n\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "readSkipSequenceFromAPIRes", "returns", "a", "SkipSequence", ".", "We", "construct", "the", "sequence", "by", "starting", "with", "the", "most", "recent", "merkle", "root", "adding", "the", "skip", "pointers", "returned", "by", "the", "server", "and", "finally", "bookending", "with", "the", "merkle", "root", "we", "last", "fetched", "from", "the", "DB", ".", "In", "verifySkipSequence", "we", "walk", "over", "this", "Sequence", "to", "make", "sure", "that", "it", "obeys", "proper", "construction", "." ]

[ "func", "(", "mc", "*", "MerkleClient", ")", "storeRoot", "(", "m", "MetaContext", ",", "root", "*", "MerkleRoot", ")", "{", "m", ".", "VLogf", "(", "VLog0", ",", "\"", "\"", ",", "*", "root", ".", "Seqno", "(", ")", ")", "\n", "err", ":=", "mc", ".", "G", "(", ")", ".", "LocalDb", ".", "Put", "(", "merkleHeadKey", "(", ")", ",", "nil", ",", "root", ".", "ToJSON", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "Error", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "mc", ".", "lastRoot", "=", "root", "\n", "}", "\n", "}" ]

[ "storeRoot", "stores", "the", "root", "in", "the", "db", "and", "mem", ".", "Must", "be", "called", "from", "under", "a", "lock", "." ]

[ "func", "newChatLocalHandler", "(", "xp", "rpc", ".", "Transporter", ",", "g", "*", "globals", ".", "Context", ",", "gh", "*", "gregorHandler", ")", "*", "chatLocalHandler", "{", "h", ":=", "&", "chatLocalHandler", "{", "BaseHandler", ":", "NewBaseHandler", "(", "g", ".", "ExternalG", "(", ")", ",", "xp", ")", ",", "}", "\n", "h", ".", "Server", "=", "chat", ".", "NewServer", "(", "g", ",", "gh", ",", "h", ")", "\n", "return", "h", "\n", "}" ]

[ "newChatLocalHandler", "creates", "a", "chatLocalHandler", "." ]

[ "func", "NewNonTLFStatusFile", "(", "fs", "*", "FS", ",", "entryValid", "*", "time", ".", "Duration", ")", "*", "SpecialReadFile", "{", "*", "entryValid", "=", "0", "\n", "return", "&", "SpecialReadFile", "{", "read", ":", "func", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "return", "libfs", ".", "GetEncodedStatus", "(", "ctx", ",", "fs", ".", "config", ")", "\n", "}", ",", "}", "\n", "}" ]

[ "NewNonTLFStatusFile", "returns", "a", "special", "read", "file", "that", "contains", "a", "text", "representation", "of", "the", "global", "KBFS", "status", "." ]

[ "func", "IsSocialAssertion", "(", "ctx", "AssertionContext", ",", "s", "string", ")", "bool", "{", "_", ",", "ok", ":=", "NormalizeSocialAssertion", "(", "ctx", ",", "s", ")", "\n", "return", "ok", "\n", "}" ]

[ "IsSocialAssertion", "returns", "true", "for", "strings", "that", "are", "valid", "social", "assertions", ".", "They", "do", "not", "need", "to", "be", "normalized", "so", "user" ]

[ "func", "teamEKRetryWrapper", "(", "mctx", "libkb", ".", "MetaContext", ",", "retryFn", "func", "(", ")", "error", ")", "(", "err", "error", ")", "{", "knownRaceConditions", ":=", "[", "]", "keybase1", ".", "StatusCode", "{", "keybase1", ".", "StatusCode_SCSigWrongKey", ",", "keybase1", ".", "StatusCode_SCSigOldSeqno", ",", "keybase1", ".", "StatusCode_SCEphemeralKeyBadGeneration", ",", "keybase1", ".", "StatusCode_SCEphemeralKeyUnexpectedBox", ",", "keybase1", ".", "StatusCode_SCEphemeralKeyMissingBox", ",", "keybase1", ".", "StatusCode_SCEphemeralKeyWrongNumberOfKeys", ",", "}", "\n", "for", "tries", ":=", "0", ";", "tries", "<", "maxRetries", ";", "tries", "++", "{", "if", "err", "=", "retryFn", "(", ")", ";", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "retryableError", ":=", "false", "\n", "for", "_", ",", "code", ":=", "range", "knownRaceConditions", "{", "if", "libkb", ".", "IsAppStatusCode", "(", "err", ",", "code", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "tries", ",", "err", ")", "\n", "retryableError", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "retryableError", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "There", "are", "plenty", "of", "race", "conditions", "where", "the", "PTK", "or", "teamEK", "or", "membership", "list", "can", "change", "out", "from", "under", "us", "while", "we", "re", "in", "the", "middle", "of", "posting", "a", "new", "key", "causing", "the", "post", "to", "fail", ".", "Detect", "these", "conditions", "and", "retry", "." ]

[ "func", "fetchTeamEKStatement", "(", "mctx", "libkb", ".", "MetaContext", ",", "teamID", "keybase1", ".", "TeamID", ")", "(", "statement", "*", "keybase1", ".", "TeamEkStatement", ",", "latestGeneration", "keybase1", ".", "EkGeneration", ",", "wrongKID", "bool", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "apiArg", ":=", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "Args", ":", "libkb", ".", "HTTPArgs", "{", "\"", "\"", ":", "libkb", ".", "S", "{", "Val", ":", "string", "(", "teamID", ")", "}", ",", "}", ",", "}", "\n", "res", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetAPI", "(", ")", ".", "Get", "(", "mctx", ",", "apiArg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "err", "\n", "}", "\n\n", "parsedResponse", ":=", "teamEKStatementResponse", "{", "}", "\n", "err", "=", "res", ".", "Body", ".", "UnmarshalAgain", "(", "&", "parsedResponse", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "err", "\n", "}", "\n\n", "// If the result field in the response is null, the server is saying that", "// the team has never published a teamEKStatement, stale or otherwise.", "if", "parsedResponse", ".", "Sig", "==", "nil", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "latestGeneration", ",", "false", ",", "nil", "\n", "}", "\n\n", "statement", ",", "latestGeneration", ",", "wrongKID", ",", "err", "=", "verifySigWithLatestPTK", "(", "mctx", ",", "teamID", ",", "*", "parsedResponse", ".", "Sig", ")", "\n", "// Check the wrongKID condition before checking the error, since an error", "// is still returned in this case. TODO: Turn this warning into an error", "// after EK support is sufficiently widespread.", "if", "wrongKID", "{", "mctx", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "latestGeneration", ",", "true", ",", "nil", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "latestGeneration", ",", "false", ",", "err", "\n", "}", "\n\n", "return", "statement", ",", "latestGeneration", ",", "false", ",", "nil", "\n", "}" ]

[ "Returns", "nil", "if", "the", "team", "has", "never", "published", "a", "teamEK", ".", "If", "the", "team", "has", "published", "a", "teamEK", "but", "has", "since", "rolled", "their", "PTK", "without", "publishing", "a", "new", "one", "this", "function", "will", "also", "return", "nil", "and", "log", "a", "warning", ".", "This", "is", "a", "transitional", "thing", "and", "eventually", "when", "all", "reasonably", "up", "to", "date", "clients", "in", "the", "wild", "have", "EK", "support", "we", "will", "make", "that", "case", "an", "error", "." ]

[ "func", "fetchTeamMemberStatements", "(", "mctx", "libkb", ".", "MetaContext", ",", "teamID", "keybase1", ".", "TeamID", ")", "(", "statementMap", "map", "[", "keybase1", ".", "UID", "]", "*", "keybase1", ".", "UserEkStatement", ",", "err", "error", ")", "{", "defer", "mctx", ".", "TraceTimed", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "err", "}", ")", "(", ")", "\n\n", "apiArg", ":=", "libkb", ".", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "SessionType", ":", "libkb", ".", "APISessionTypeREQUIRED", ",", "Args", ":", "libkb", ".", "HTTPArgs", "{", "\"", "\"", ":", "libkb", ".", "S", "{", "Val", ":", "string", "(", "teamID", ")", "}", ",", "}", ",", "}", "\n", "res", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetAPI", "(", ")", ".", "Get", "(", "mctx", ",", "apiArg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "parsedResponse", ":=", "teamMemberEKStatementResponse", "{", "}", "\n", "err", "=", "res", ".", "Body", ".", "UnmarshalAgain", "(", "&", "parsedResponse", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "team", ",", "err", ":=", "teams", ".", "Load", "(", "mctx", ".", "Ctx", "(", ")", ",", "mctx", ".", "G", "(", ")", ",", "keybase1", ".", "LoadTeamArg", "{", "ID", ":", "teamID", ",", "ForceRepoll", ":", "true", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "statementMap", "=", "make", "(", "map", "[", "keybase1", ".", "UID", "]", "*", "keybase1", ".", "UserEkStatement", ")", "\n", "for", "uid", ",", "sig", ":=", "range", "parsedResponse", ".", "Sigs", "{", "// Verify the server only returns actual members of our team.", "upak", ",", "_", ",", "err", ":=", "mctx", ".", "G", "(", ")", ".", "GetUPAKLoader", "(", ")", ".", "LoadV2", "(", "libkb", ".", "NewLoadUserArgWithMetaContext", "(", "mctx", ")", ".", "WithUID", "(", "uid", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "uv", ":=", "upak", ".", "Current", ".", "ToUserVersion", "(", ")", "\n", "isMember", ":=", "team", ".", "IsMember", "(", "mctx", ".", "Ctx", "(", ")", ",", "uv", ")", "\n", "if", "!", "isMember", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uv", ",", "teamID", ")", "\n", "}", "\n", "memberStatement", ",", "_", ",", "wrongKID", ",", "err", ":=", "verifySigWithLatestPUK", "(", "mctx", ",", "uid", ",", "sig", ")", "\n", "// Check the wrongKID condition before checking the error, since an error", "// is still returned in this case. TODO: Turn this warning into an error", "// after EK support is sufficiently widespread.", "if", "wrongKID", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "uid", ")", "\n", "// Don't box for this member since they have no valid userEK", "continue", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "statementMap", "[", "uid", "]", "=", "memberStatement", "\n", "}", "\n", "return", "statementMap", ",", "nil", "\n", "}" ]

[ "Returns", "nil", "if", "all", "team", "members", "have", "never", "published", "a", "teamEK", ".", "Verifies", "that", "the", "map", "of", "users", "the", "server", "returns", "are", "indeed", "valid", "team", "members", "of", "the", "team", "and", "all", "signatures", "verify", "correctly", "for", "the", "users", "." ]

[ "func", "(", "fl", "*", "FolderList", ")", "userChanged", "(", "ctx", "context", ".", "Context", ",", "_", ",", "newUser", "kbname", ".", "NormalizedUsername", ")", "{", "var", "fs", "[", "]", "*", "Folder", "\n", "func", "(", ")", "{", "fl", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "fl", ".", "mu", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "tlf", ":=", "range", "fl", ".", "folders", "{", "if", "tlf", ",", "ok", ":=", "tlf", ".", "(", "*", "TLF", ")", ";", "ok", "{", "fs", "=", "append", "(", "fs", ",", "tlf", ".", "folder", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "for", "_", ",", "f", ":=", "range", "fs", "{", "f", ".", "TlfHandleChange", "(", "ctx", ",", "nil", ")", "\n", "}", "\n", "if", "newUser", "!=", "kbname", ".", "NormalizedUsername", "(", "\"", "\"", ")", "{", "fl", ".", "fs", ".", "config", ".", "KBFSOps", "(", ")", ".", "ForceFastForward", "(", "ctx", ")", "\n", "}", "\n", "}" ]

[ "update", "things", "after", "user", "changed", "." ]

[ "func", "(", "l", "*", "LoaderContextG", ")", "getNewLinksFromServer", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "lows", "getLinksLows", ",", "readSubteamID", "*", "keybase1", ".", "TeamID", ")", "(", "*", "rawTeam", ",", "error", ")", "{", "return", "l", ".", "getLinksFromServerCommon", "(", "ctx", ",", "teamID", ",", "&", "lows", ",", "nil", ",", "readSubteamID", ")", "\n", "}" ]

[ "Get", "new", "links", "from", "the", "server", "." ]

[ "func", "(", "l", "*", "LoaderContextG", ")", "getLinksFromServer", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "requestSeqnos", "[", "]", "keybase1", ".", "Seqno", ",", "readSubteamID", "*", "keybase1", ".", "TeamID", ")", "(", "*", "rawTeam", ",", "error", ")", "{", "return", "l", ".", "getLinksFromServerCommon", "(", "ctx", ",", "teamID", ",", "nil", ",", "requestSeqnos", ",", "readSubteamID", ")", "\n", "}" ]

[ "Get", "full", "links", "from", "the", "server", ".", "Does", "not", "guarantee", "that", "the", "server", "returned", "the", "correct", "links", "nor", "that", "they", "are", "unstubbed", "." ]

[ "func", "NewCoalescingContext", "(", "parent", "context", ".", "Context", ")", "(", "*", "CoalescingContext", ",", "context", ".", "CancelFunc", ")", "{", "ctx", ":=", "&", "CoalescingContext", "{", "// Make the parent's `Value()` method available to consumers of this", "// context. For example, this maintains the parent's log debug tags.", "// TODO: Make _all_ parents' values available.", "Context", ":", "parent", ",", "doneCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "mutateCh", ":", "make", "(", "chan", "context", ".", "Context", ")", ",", "}", "\n", "closeCh", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "ctx", ".", "selects", "=", "[", "]", "reflect", ".", "SelectCase", "{", "{", "Dir", ":", "reflect", ".", "SelectRecv", ",", "Chan", ":", "reflect", ".", "ValueOf", "(", "ctx", ".", "mutateCh", ")", ",", "}", ",", "{", "Dir", ":", "reflect", ".", "SelectRecv", ",", "Chan", ":", "reflect", ".", "ValueOf", "(", "closeCh", ")", ",", "}", ",", "}", "\n", "ctx", ".", "appendContext", "(", "parent", ")", "\n", "go", "ctx", ".", "loop", "(", ")", "\n", "cancelFunc", ":=", "func", "(", ")", "{", "select", "{", "case", "<-", "closeCh", ":", "default", ":", "close", "(", "closeCh", ")", "\n", "}", "\n", "}", "\n", "return", "ctx", ",", "cancelFunc", "\n", "}" ]

[ "NewCoalescingContext", "creates", "a", "new", "CoalescingContext", ".", "The", "context", "_must_", "be", "canceled", "to", "avoid", "a", "goroutine", "leak", "." ]

[ "func", "(", "ctx", "*", "CoalescingContext", ")", "AddContext", "(", "other", "context", ".", "Context", ")", "error", "{", "select", "{", "case", "ctx", ".", "mutateCh", "<-", "other", ":", "return", "nil", "\n", "case", "<-", "ctx", ".", "doneCh", ":", "return", "context", ".", "Canceled", "\n", "}", "\n", "}" ]

[ "AddContext", "adds", "a", "context", "to", "the", "set", "of", "contexts", "that", "we", "re", "waiting", "on", "." ]

[ "func", "(", "k", "*", "KexRouter", ")", "Post", "(", "sessID", "kex2", ".", "SessionID", ",", "sender", "kex2", ".", "DeviceID", ",", "seqno", "kex2", ".", "Seqno", ",", "msg", "[", "]", "byte", ")", "(", "err", "error", ")", "{", "mctx", ":=", "k", ".", "M", "(", ")", ".", "WithLogTag", "(", "\"", "\"", ")", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "sessID", ",", "sender", ",", "seqno", ")", "\n", "defer", "func", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "sessID", ",", "sender", ",", "seqno", ",", "ErrToOk", "(", "err", ")", ")", "\n", "}", "(", ")", "\n\n", "arg", ":=", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "Args", ":", "HTTPArgs", "{", "\"", "\"", ":", "HexArg", "(", "sessID", "[", ":", "]", ")", ",", "\"", "\"", ":", "HexArg", "(", "sender", "[", ":", "]", ")", ",", "\"", "\"", ":", "I", "{", "Val", ":", "int", "(", "seqno", ")", "}", ",", "\"", "\"", ":", "B64Arg", "(", "msg", ")", ",", "}", ",", "}", "\n", "mctx", "=", "mctx", ".", "BackgroundWithLogTags", "(", ")", "\n", "kexAPITimeout", "(", "&", "arg", ",", "time", ".", "Second", "*", "5", ")", "\n", "_", ",", "err", "=", "mctx", ".", "G", "(", ")", ".", "API", ".", "Post", "(", "mctx", ",", "arg", ")", "\n\n", "return", "err", "\n", "}" ]

[ "Post", "implements", "Post", "in", "the", "kex2", ".", "MessageRouter", "interface", "." ]

[ "func", "(", "k", "*", "KexRouter", ")", "Get", "(", "sessID", "kex2", ".", "SessionID", ",", "receiver", "kex2", ".", "DeviceID", ",", "low", "kex2", ".", "Seqno", ",", "poll", "time", ".", "Duration", ")", "(", "msgs", "[", "]", "[", "]", "byte", ",", "err", "error", ")", "{", "mctx", ":=", "k", ".", "M", "(", ")", ".", "WithLogTag", "(", "\"", "\"", ")", "\n", "mctx", ".", "Debug", "(", "\"", "\"", ",", "sessID", ",", "receiver", ",", "low", ",", "poll", ")", "\n", "defer", "func", "(", ")", "{", "mctx", ".", "Debug", "(", "\"", "\"", ",", "sessID", ",", "receiver", ",", "low", ",", "poll", ",", "ErrToOk", "(", "err", ")", ",", "len", "(", "msgs", ")", ")", "\n", "}", "(", ")", "\n\n", "if", "poll", ">", "HTTPPollMaximum", "{", "poll", "=", "HTTPPollMaximum", "\n", "}", "\n\n", "arg", ":=", "APIArg", "{", "Endpoint", ":", "\"", "\"", ",", "Args", ":", "HTTPArgs", "{", "\"", "\"", ":", "HexArg", "(", "sessID", "[", ":", "]", ")", ",", "\"", "\"", ":", "HexArg", "(", "receiver", "[", ":", "]", ")", ",", "\"", "\"", ":", "I", "{", "Val", ":", "int", "(", "low", ")", "}", ",", "\"", "\"", ":", "I", "{", "Val", ":", "int", "(", "poll", "/", "time", ".", "Millisecond", ")", "}", ",", "}", ",", "}", "\n", "kexAPITimeout", "(", "&", "arg", ",", "2", "*", "poll", ")", "\n", "var", "j", "kexResp", "\n\n", "if", "err", "=", "mctx", ".", "G", "(", ")", ".", "API", ".", "GetDecode", "(", "mctx", ".", "BackgroundWithLogTags", "(", ")", ",", "arg", ",", "&", "j", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "j", ".", "Status", ".", "Code", "!=", "SCOk", "{", "return", "nil", ",", "AppStatusError", "{", "Code", ":", "j", ".", "Status", ".", "Code", ",", "Name", ":", "j", ".", "Status", ".", "Name", ",", "Desc", ":", "j", ".", "Status", ".", "Desc", "}", "\n", "}", "\n\n", "for", "_", ",", "m", ":=", "range", "j", ".", "Msgs", "{", "dec", ",", "err", ":=", "base64", ".", "StdEncoding", ".", "DecodeString", "(", "m", ".", "Msg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "msgs", "=", "append", "(", "msgs", ",", "dec", ")", "\n", "}", "\n\n", "return", "msgs", ",", "nil", "\n", "}" ]

[ "Get", "implements", "Get", "in", "the", "kex2", ".", "MessageRouter", "interface", "." ]

[ "func", "NewCmdSimpleFSRead", "(", "cl", "*", "libcmdline", ".", "CommandLine", ",", "g", "*", "libkb", ".", "GlobalContext", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "ArgumentHelp", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "Action", ":", "func", "(", "c", "*", "cli", ".", "Context", ")", "{", "cl", ".", "ChooseCommand", "(", "&", "CmdSimpleFSRead", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", "}", ",", "\"", "\"", ",", "c", ")", "\n", "cl", ".", "SetNoStandalone", "(", ")", "\n", "}", ",", "Flags", ":", "[", "]", "cli", ".", "Flag", "{", "cli", ".", "IntFlag", "{", "Name", ":", "\"", "\"", ",", "Value", ":", "readBufSizeDefault", ",", "Usage", ":", "\"", "\"", ",", "}", ",", "cli", ".", "IntFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "}", ",", "cli", ".", "StringFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\\\"", "\\\"", "\"", ",", "}", ",", "cli", ".", "StringFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\\\"", "\\\"", "\"", ",", "}", ",", "}", ",", "}", "\n", "}" ]

[ "NewCmdSimpleFSRead", "creates", "a", "new", "cli", ".", "Command", "." ]

[ "func", "NewAutoFlushingBufferedWriter", "(", "baseWriter", "io", ".", "Writer", ",", "flushFrequency", "time", ".", "Duration", ")", "(", "w", "io", ".", "Writer", ",", "shutdown", "chan", "struct", "{", "}", ",", "done", "chan", "struct", "{", "}", ")", "{", "result", ":=", "&", "autoFlushingBufferedWriter", "{", "bufferedWriter", ":", "bufio", ".", "NewWriter", "(", "baseWriter", ")", ",", "backupWriter", ":", "bufio", ".", "NewWriter", "(", "baseWriter", ")", ",", "frequency", ":", "flushFrequency", ",", "timer", ":", "newTriggerableTimer", "(", "flushFrequency", ")", ",", "shutdown", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "doneShutdown", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "go", "result", ".", "backgroundFlush", "(", ")", "\n", "return", "result", ",", "result", ".", "shutdown", ",", "result", ".", "doneShutdown", "\n", "}" ]

[ "NewAutoFlushingBufferedWriter", "returns", "an", "io", ".", "Writer", "that", "buffers", "its", "output", "and", "flushes", "automatically", "after", "flushFrequency", "." ]

[ "func", "EnableBufferedLogging", "(", ")", "{", "writer", ",", "shutdown", ",", "done", ":=", "NewAutoFlushingBufferedWriter", "(", "ErrorWriter", "(", ")", ",", "loggingFrequency", ")", "\n", "stdErrLoggingShutdown", "=", "shutdown", "\n", "stdErrLoggingShutdownDone", "=", "done", "\n", "logBackend", ":=", "logging", ".", "NewLogBackend", "(", "writer", ",", "\"", "\"", ",", "0", ")", "\n", "logging", ".", "SetBackend", "(", "logBackend", ")", "\n", "}" ]

[ "EnableBufferedLogging", "turns", "on", "buffered", "logging", "-", "this", "is", "a", "performance", "boost", "at", "the", "expense", "of", "not", "getting", "all", "the", "logs", "in", "a", "crash", "." ]

[ "func", "loadLibrary", "(", "epc", "*", "errorPrinter", ",", "path", "string", ")", "(", "windows", ".", "Handle", ",", "error", ")", "{", "hdl", ",", "err", ":=", "windows", ".", "LoadLibrary", "(", "path", ")", "\n", "epc", ".", "Printf", "(", "\"", "\\n", "\"", ",", "path", ",", "hdl", ",", "err", ")", "\n", "return", "hdl", ",", "err", "\n", "}" ]

[ "loadLibrary", "calls", "win32", "LoadLibrary", "and", "logs", "the", "result", "." ]

[ "func", "doLoadDLL", "(", "epc", "*", "errorPrinter", ",", "path", "string", ")", "(", "windows", ".", "Handle", ",", "error", ")", "{", "var", "guessPath", "bool", "\n", "epc", ".", "Printf", "(", "\"", "\\n", "\"", ",", "path", ")", "\n", "if", "path", "==", "\"", "\"", "{", "path", "=", "shortPath", "\n", "guessPath", "=", "true", "\n", "}", "else", "{", "path", "=", "filepath", ".", "FromSlash", "(", "path", ")", "\n", "}", "\n", "const", "loadLibrarySearchSystem32", "=", "0x800", "\n", "const", "flags", "=", "loadLibrarySearchSystem32", "\n", "hdl", ",", "err", ":=", "windows", ".", "LoadLibraryEx", "(", "path", ",", "0", ",", "flags", ")", "\n", "epc", ".", "Printf", "(", "\"", "\\n", "\"", ",", "path", ",", "flags", ",", "hdl", ",", "err", ")", "\n", "if", "err", "==", "nil", "||", "!", "guessPath", "{", "return", "hdl", ",", "err", "\n", "}", "\n", "// User probably has not installed KB2533623 which is a security update", "// from 2011. Without this Windows security update loading libraries", "// is unsafe on Windows.", "// Continue to try to load the DLL regardless.", "if", "runtime", ".", "GOARCH", "==", "`386`", "{", "hdl", ",", "err", "=", "loadLibrary", "(", "epc", ",", "syswow64", "+", "shortPath", ")", "\n", "if", "err", "==", "nil", "{", "return", "hdl", ",", "nil", "\n", "}", "\n", "}", "\n", "hdl", ",", "err", "=", "loadLibrary", "(", "epc", ",", "system32", "+", "shortPath", ")", "\n", "if", "err", "==", "nil", "{", "return", "hdl", ",", "nil", "\n", "}", "\n", "hdl", ",", "err", "=", "loadLibrary", "(", "epc", ",", "shortPath", ")", "\n", "if", "err", "==", "nil", "{", "return", "hdl", ",", "nil", "\n", "}", "\n", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "epc", ".", "Printf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "0", ",", "err", "\n", "}" ]

[ "doLoadDLL", "tries", "to", "load", "the", "dokan", "DLL", "from", "various", "locations", "." ]

[ "func", "loadDokanDLL", "(", "cfg", "*", "Config", ")", "error", "{", "var", "epc", "errorPrinter", "\n", "err", ":=", "doLoadDokanAndGetSymbols", "(", "&", "epc", ",", "cfg", ".", "DllPath", ")", "\n", "cfg", ".", "FileSystem", ".", "Printf", "(", "\"", "\"", ",", "epc", ".", "buf", ".", "Bytes", "(", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "loadDokanDLL", "tries", "to", "load", "the", "dokan", "DLL", "from", "the", "given", "path", ".", "Empty", "path", "is", "allowed", "and", "will", "result", "in", "the", "location", "being", "guessed", "." ]

[ "func", "transformPaymentStellar", "(", "mctx", "libkb", ".", "MetaContext", ",", "acctID", "stellar1", ".", "AccountID", ",", "p", "stellar1", ".", "PaymentSummaryStellar", ",", "oc", "OwnAccountLookupCache", ")", "(", "*", "stellar1", ".", "PaymentLocal", ",", "error", ")", "{", "loc", ",", "err", ":=", "newPaymentLocal", "(", "mctx", ",", "p", ".", "TxID", ",", "p", ".", "Ctime", ",", "p", ".", "Amount", ",", "p", ".", "Asset", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "isSender", ":=", "p", ".", "From", ".", "Eq", "(", "acctID", ")", "\n", "isRecipient", ":=", "p", ".", "To", ".", "Eq", "(", "acctID", ")", "\n", "switch", "{", "case", "isSender", "&&", "isRecipient", ":", "loc", ".", "Delta", "=", "stellar1", ".", "BalanceDelta_NONE", "\n", "case", "isSender", ":", "loc", ".", "Delta", "=", "stellar1", ".", "BalanceDelta_DECREASE", "\n", "case", "isRecipient", ":", "loc", ".", "Delta", "=", "stellar1", ".", "BalanceDelta_INCREASE", "\n", "}", "\n\n", "loc", ".", "FromAccountID", "=", "p", ".", "From", "\n", "loc", ".", "FromType", "=", "stellar1", ".", "ParticipantType_STELLAR", "\n", "loc", ".", "ToAccountID", "=", "&", "p", ".", "To", "\n", "loc", ".", "ToType", "=", "stellar1", ".", "ParticipantType_STELLAR", "\n", "fillOwnAccounts", "(", "mctx", ",", "loc", ",", "oc", ")", "\n\n", "loc", ".", "StatusSimplified", "=", "stellar1", ".", "PaymentStatus_COMPLETED", "\n", "loc", ".", "StatusDescription", "=", "strings", ".", "ToLower", "(", "loc", ".", "StatusSimplified", ".", "String", "(", ")", ")", "\n", "loc", ".", "Unread", "=", "p", ".", "Unread", "\n", "loc", ".", "IsInflation", "=", "p", ".", "IsInflation", "\n", "loc", ".", "InflationSource", "=", "p", ".", "InflationSource", "\n\n", "return", "loc", ",", "nil", "\n", "}" ]

[ "transformPaymentStellar", "converts", "a", "stellar1", ".", "PaymentSummaryStellar", "into", "a", "stellar1", ".", "PaymentLocal", "." ]

[ "func", "transformPaymentDirect", "(", "mctx", "libkb", ".", "MetaContext", ",", "acctID", "stellar1", ".", "AccountID", ",", "p", "stellar1", ".", "PaymentSummaryDirect", ",", "oc", "OwnAccountLookupCache", ")", "(", "*", "stellar1", ".", "PaymentLocal", ",", "error", ")", "{", "loc", ",", "err", ":=", "newPaymentLocal", "(", "mctx", ",", "p", ".", "TxID", ",", "p", ".", "Ctime", ",", "p", ".", "Amount", ",", "p", ".", "Asset", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "isSender", ":=", "p", ".", "FromStellar", ".", "Eq", "(", "acctID", ")", "\n", "isRecipient", ":=", "p", ".", "ToStellar", ".", "Eq", "(", "acctID", ")", "\n", "switch", "{", "case", "isSender", "&&", "isRecipient", ":", "loc", ".", "Delta", "=", "stellar1", ".", "BalanceDelta_NONE", "\n", "case", "isSender", ":", "loc", ".", "Delta", "=", "stellar1", ".", "BalanceDelta_DECREASE", "\n", "case", "isRecipient", ":", "loc", ".", "Delta", "=", "stellar1", ".", "BalanceDelta_INCREASE", "\n", "}", "\n\n", "loc", ".", "Worth", ",", "_", ",", "err", "=", "formatWorth", "(", "mctx", ",", "p", ".", "DisplayAmount", ",", "p", ".", "DisplayCurrency", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "loc", ".", "FromAccountID", "=", "p", ".", "FromStellar", "\n", "loc", ".", "FromType", "=", "stellar1", ".", "ParticipantType_STELLAR", "\n", "if", "username", ",", "err", ":=", "lookupUsername", "(", "mctx", ",", "p", ".", "From", ".", "Uid", ")", ";", "err", "==", "nil", "{", "loc", ".", "FromUsername", "=", "username", "\n", "loc", ".", "FromType", "=", "stellar1", ".", "ParticipantType_KEYBASE", "\n", "}", "\n\n", "loc", ".", "ToAccountID", "=", "&", "p", ".", "ToStellar", "\n", "loc", ".", "ToType", "=", "stellar1", ".", "ParticipantType_STELLAR", "\n", "if", "p", ".", "To", "!=", "nil", "{", "if", "username", ",", "err", ":=", "lookupUsername", "(", "mctx", ",", "p", ".", "To", ".", "Uid", ")", ";", "err", "==", "nil", "{", "loc", ".", "ToUsername", "=", "username", "\n", "loc", ".", "ToType", "=", "stellar1", ".", "ParticipantType_KEYBASE", "\n", "}", "\n", "}", "\n\n", "fillOwnAccounts", "(", "mctx", ",", "loc", ",", "oc", ")", "\n", "switch", "{", "case", "loc", ".", "FromAccountName", "!=", "\"", "\"", ":", "// we are sender", "loc", ".", "WorthAtSendTime", ",", "_", ",", "err", "=", "formatWorthAtSendTime", "(", "mctx", ",", "p", ",", "true", ")", "\n", "case", "loc", ".", "ToAccountName", "!=", "\"", "\"", ":", "// we are recipient", "loc", ".", "WorthAtSendTime", ",", "_", ",", "err", "=", "formatWorthAtSendTime", "(", "mctx", ",", "p", ",", "false", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "loc", ".", "StatusSimplified", "=", "p", ".", "TxStatus", ".", "ToPaymentStatus", "(", ")", "\n", "loc", ".", "StatusDescription", "=", "strings", ".", "ToLower", "(", "loc", ".", "StatusSimplified", ".", "String", "(", ")", ")", "\n", "loc", ".", "StatusDetail", "=", "p", ".", "TxErrMsg", "\n\n", "loc", ".", "Note", ",", "loc", ".", "NoteErr", "=", "decryptNote", "(", "mctx", ",", "p", ".", "TxID", ",", "p", ".", "NoteB64", ")", "\n\n", "loc", ".", "SourceAmountMax", "=", "p", ".", "SourceAmountMax", "\n", "loc", ".", "SourceAmountActual", "=", "p", ".", "SourceAmountActual", "\n", "loc", ".", "SourceAsset", "=", "p", ".", "SourceAsset", "\n\n", "return", "loc", ",", "nil", "\n", "}" ]

[ "transformPaymentDirect", "converts", "a", "stellar1", ".", "PaymentSummaryDirect", "into", "a", "stellar1", ".", "PaymentLocal", "." ]

[ "func", "TransformToAirdropStatus", "(", "status", "remote", ".", "AirdropStatusAPI", ")", "stellar1", ".", "AirdropStatus", "{", "var", "out", "stellar1", ".", "AirdropStatus", "\n", "switch", "{", "case", "status", ".", "AlreadyRegistered", ":", "out", ".", "State", "=", "stellar1", ".", "AirdropAccepted", "\n", "case", "status", ".", "Qualifications", ".", "QualifiesOverall", ":", "out", ".", "State", "=", "stellar1", ".", "AirdropQualified", "\n", "default", ":", "out", ".", "State", "=", "stellar1", ".", "AirdropUnqualified", "\n", "}", "\n\n", "dq", ":=", "stellar1", ".", "AirdropQualification", "{", "Title", ":", "status", ".", "AirdropConfig", ".", "MinActiveDevicesTitle", ",", "Valid", ":", "status", ".", "Qualifications", ".", "HasEnoughDevices", ",", "}", "\n", "out", ".", "Rows", "=", "append", "(", "out", ".", "Rows", ",", "dq", ")", "\n\n", "aq", ":=", "stellar1", ".", "AirdropQualification", "{", "Title", ":", "status", ".", "AirdropConfig", ".", "AccountCreationTitle", ",", "}", "\n\n", "var", "used", "[", "]", "string", "\n", "for", "k", ",", "q", ":=", "range", "status", ".", "Qualifications", ".", "ServiceChecks", "{", "if", "q", ".", "Qualifies", "{", "aq", ".", "Valid", "=", "true", "\n", "break", "\n", "}", "\n", "if", "q", ".", "Username", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "!", "q", ".", "IsOldEnough", "{", "continue", "\n", "}", "\n", "if", "q", ".", "IsUsedAlready", "{", "used", "=", "append", "(", "used", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "q", ".", "Username", ",", "k", ")", ")", "\n", "}", "\n", "}", "\n", "if", "!", "aq", ".", "Valid", "{", "aq", ".", "Subtitle", "=", "status", ".", "AirdropConfig", ".", "AccountCreationSubtitle", "\n", "if", "len", "(", "used", ")", ">", "0", "{", "usedDisplay", ":=", "strings", ".", "Join", "(", "used", ",", "\"", "\"", ")", "\n", "aq", ".", "Subtitle", "+=", "\"", "\"", "+", "fmt", ".", "Sprintf", "(", "status", ".", "AirdropConfig", ".", "AccountUsed", ",", "usedDisplay", ")", "\n", "}", "\n", "}", "\n", "out", ".", "Rows", "=", "append", "(", "out", ".", "Rows", ",", "aq", ")", "\n\n", "return", "out", "\n", "}" ]

[ "TransformToAirdropStatus", "takes", "the", "result", "from", "api", "server", "status_check", "and", "transforms", "it", "into", "stellar1", ".", "AirdropStatus", "." ]

[ "func", "(", "c", "*", "ConversationLockTab", ")", "deadlockDetect", "(", "ctx", "context", ".", "Context", ",", "trace", "string", ",", "waiters", "map", "[", "string", "]", "bool", ")", "bool", "{", "// See if this trace is waiting on any other trace", "waitingOnTrace", ",", "ok", ":=", "c", ".", "waits", "[", "trace", "]", "\n", "if", "!", "ok", "{", "// If not, no deadlock", "return", "false", "\n", "}", "\n", "// If we are waiting on a trace we have already encountered, then we have hit a deadlock", "if", "waiters", "[", "waitingOnTrace", "]", "{", "c", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "trace", ",", "waitingOnTrace", ",", "waiters", ")", "\n", "return", "true", "\n", "}", "\n", "// Set the current trace as waiting, and then continue down the chain", "waiters", "[", "trace", "]", "=", "true", "\n", "return", "c", ".", "deadlockDetect", "(", "ctx", ",", "waitingOnTrace", ",", "waiters", ")", "\n", "}" ]

[ "deadlockDetect", "tries", "to", "find", "a", "deadlock", "condition", "in", "the", "current", "set", "of", "waiting", "acquirers", "." ]

[ "func", "(", "c", "*", "ConversationLockTab", ")", "Acquire", "(", "ctx", "context", ".", "Context", ",", "uid", "gregor1", ".", "UID", ",", "convID", "chat1", ".", "ConversationID", ")", "(", "blocked", "bool", ",", "err", "error", ")", "{", "sleep", ":=", "200", "*", "time", ".", "Millisecond", "\n", "for", "i", ":=", "0", ";", "i", "<", "c", ".", "maxAcquireRetries", ";", "i", "++", "{", "blocked", ",", "err", "=", "c", ".", "doAcquire", "(", "ctx", ",", "uid", ",", "convID", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "!=", "ErrConvLockTabDeadlock", "{", "return", "true", ",", "err", "\n", "}", "\n", "c", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "i", ")", "\n", "time", ".", "Sleep", "(", "sleep", ")", "\n", "continue", "\n", "}", "\n", "return", "blocked", ",", "nil", "\n", "}", "\n", "c", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "true", ",", "ErrConvLockTabDeadlock", "\n", "}" ]

[ "Acquire", "obtains", "a", "per", "user", "per", "conversation", "lock", "on", "a", "per", "trace", "basis", ".", "That", "is", "the", "lock", "is", "a", "shared", "lock", "for", "the", "current", "chat", "trace", "and", "serves", "to", "synchronize", "large", "chat", "operations", ".", "If", "there", "is", "no", "chat", "trace", "this", "is", "a", "no", "-", "op", "." ]

[ "func", "(", "s", "*", "Storage", ")", "EphemeralPurge", "(", "ctx", "context", ".", "Context", ",", "convID", "chat1", ".", "ConversationID", ",", "uid", "gregor1", ".", "UID", ",", "purgeInfo", "*", "chat1", ".", "EphemeralPurgeInfo", ")", "(", "newPurgeInfo", "*", "chat1", ".", "EphemeralPurgeInfo", ",", "explodedMsgs", "[", "]", "chat1", ".", "MessageUnboxed", ",", "err", "Error", ")", "{", "defer", "s", ".", "Trace", "(", "ctx", ",", "func", "(", ")", "error", "{", "return", "err", "}", ",", "\"", "\"", ")", "(", ")", "\n", "lock", ":=", "locks", ".", "StorageLockTab", ".", "AcquireOnName", "(", "ctx", ",", "s", ".", "G", "(", ")", ",", "convID", ".", "String", "(", ")", ")", "\n", "defer", "lock", ".", "Release", "(", "ctx", ")", "\n\n", "if", "purgeInfo", "==", "nil", "{", "return", "nil", ",", "nil", ",", "nil", "\n", "}", "\n\n", "// Fetch secret key", "key", ",", "ierr", ":=", "GetSecretBoxKey", "(", "ctx", ",", "s", ".", "G", "(", ")", ".", "ExternalG", "(", ")", ",", "DefaultSecretUI", ")", "\n", "if", "ierr", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "MiscError", "{", "Msg", ":", "\"", "\"", "+", "ierr", ".", "Error", "(", ")", "}", "\n", "}", "\n\n", "ctx", ",", "err", "=", "s", ".", "engine", ".", "Init", "(", "ctx", ",", "key", ",", "convID", ",", "uid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "maxMsgID", ",", "err", ":=", "s", ".", "idtracker", ".", "getMaxMessageID", "(", "ctx", ",", "convID", ",", "uid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "// We don't care about holes.", "maxHoles", ":=", "int", "(", "maxMsgID", "-", "purgeInfo", ".", "MinUnexplodedID", ")", "+", "1", "\n", "var", "target", "int", "\n", "if", "purgeInfo", ".", "MinUnexplodedID", "==", "0", "{", "target", "=", "0", "// we need to traverse the whole conversation", "\n", "}", "else", "{", "target", "=", "maxHoles", "\n", "}", "\n", "rc", ":=", "NewHoleyResultCollector", "(", "maxHoles", ",", "NewSimpleResultCollector", "(", "target", ")", ")", "\n", "err", "=", "s", ".", "engine", ".", "ReadMessages", "(", "ctx", ",", "rc", ",", "convID", ",", "uid", ",", "maxMsgID", ",", "0", ")", "\n", "switch", "err", ".", "(", "type", ")", "{", "case", "nil", ":", "// ok", "if", "len", "(", "rc", ".", "Result", "(", ")", ")", "==", "0", "{", "err", ":=", "s", ".", "ephemeralTracker", ".", "inactivatePurgeInfo", "(", "ctx", ",", "convID", ",", "uid", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "case", "MissError", ":", "s", ".", "Debug", "(", "ctx", ",", "\"", "\"", ")", "\n", "// We don't have these messages in cache, so don't retry this", "// conversation until further notice.", "err", ":=", "s", ".", "ephemeralTracker", ".", "inactivatePurgeInfo", "(", "ctx", ",", "convID", ",", "uid", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "default", ":", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "newPurgeInfo", ",", "explodedMsgs", ",", "err", "=", "s", ".", "ephemeralPurgeHelper", "(", "ctx", ",", "convID", ",", "uid", ",", "rc", ".", "Result", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "err", "=", "s", ".", "ephemeralTracker", ".", "setPurgeInfo", "(", "ctx", ",", "convID", ",", "uid", ",", "newPurgeInfo", ")", "\n", "return", "newPurgeInfo", ",", "explodedMsgs", ",", "err", "\n", "}" ]

[ "For", "a", "given", "conversation", "purge", "all", "ephemeral", "messages", "from", "purgeInfo", ".", "MinUnexplodedID", "to", "the", "present", "updating", "bookkeeping", "for", "the", "next", "time", "we", "need", "to", "purge", "this", "conv", "." ]

[ "func", "UIDListMerge", "(", "list1", "[", "]", "UID", ",", "list2", "[", "]", "UID", ")", "[", "]", "UID", "{", "m", ":=", "make", "(", "map", "[", "string", "]", "UID", ")", "\n", "for", "_", ",", "uid", ":=", "range", "list1", "{", "m", "[", "uid", ".", "String", "(", ")", "]", "=", "uid", "\n", "}", "\n", "for", "_", ",", "uid", ":=", "range", "list2", "{", "m", "[", "uid", ".", "String", "(", ")", "]", "=", "uid", "\n", "}", "\n", "res", ":=", "make", "(", "[", "]", "UID", ",", "0", ")", "\n", "for", "_", ",", "uid", ":=", "range", "m", "{", "res", "=", "append", "(", "res", ",", "uid", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "Merge", "two", "lists", "of", "UIDs", ".", "Duplicates", "will", "be", "dropped", ".", "Not", "stably", "ordered", "." ]

[ "func", "(", "h", "*", "Handle", ")", "ResolveAgain", "(", "ctx", "context", ".", "Context", ",", "resolver", "idutil", ".", "Resolver", ",", "idGetter", "IDGetter", ",", "osg", "idutil", ".", "OfflineStatusGetter", ")", "(", "*", "Handle", ",", "error", ")", "{", "if", "h", ".", "IsFinal", "(", ")", "{", "// Don't attempt to further resolve final handles.", "return", "h", ",", "nil", "\n", "}", "\n", "return", "h", ".", "ResolveAgainForUser", "(", "ctx", ",", "resolver", ",", "idGetter", ",", "osg", ",", "keybase1", ".", "UID", "(", "\"", "\"", ")", ")", "\n", "}" ]

[ "ResolveAgain", "tries", "to", "resolve", "any", "unresolved", "assertions", "in", "the", "given", "handle", "and", "returns", "a", "new", "handle", "with", "the", "results", ".", "As", "an", "optimization", "if", "h", "contains", "no", "unresolved", "assertions", "it", "just", "returns", "itself", "." ]

[ "func", "(", "h", "Handle", ")", "ResolvesTo", "(", "ctx", "context", ".", "Context", ",", "codec", "kbfscodec", ".", "Codec", ",", "resolver", "idutil", ".", "Resolver", ",", "idGetter", "IDGetter", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "other", "Handle", ")", "(", "resolvesTo", "bool", ",", "partialResolvedH", "*", "Handle", ",", "err", "error", ")", "{", "// Check the conflict extension.", "var", "conflictAdded", ",", "finalizedAdded", "bool", "\n", "if", "!", "h", ".", "IsConflict", "(", ")", "&&", "other", ".", "IsConflict", "(", ")", "{", "conflictAdded", "=", "true", "\n", "// Ignore the added extension for resolution comparison purposes.", "other", ".", "conflictInfo", "=", "nil", "\n", "}", "\n\n", "// Check the finalized extension.", "if", "h", ".", "IsFinal", "(", ")", "{", "if", "conflictAdded", "{", "// Can't add conflict info to a finalized handle.", "return", "false", ",", "nil", ",", "HandleFinalizedError", "{", "}", "\n", "}", "\n", "}", "else", "if", "other", ".", "IsFinal", "(", ")", "{", "finalizedAdded", "=", "true", "\n", "// Ignore the added extension for resolution comparison purposes.", "other", ".", "finalizedInfo", "=", "nil", "\n", "}", "\n\n", "if", "h", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "// Nothing to resolve for team-based TLFs, just use `other` by", "// itself.", "partialResolvedH", "=", "other", ".", "DeepCopy", "(", ")", "\n", "}", "else", "{", "unresolvedAssertions", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "for", "_", ",", "uw", ":=", "range", "other", ".", "unresolvedWriters", "{", "unresolvedAssertions", "[", "uw", ".", "String", "(", ")", "]", "=", "true", "\n", "}", "\n", "for", "_", ",", "ur", ":=", "range", "other", ".", "unresolvedReaders", "{", "unresolvedAssertions", "[", "ur", ".", "String", "(", ")", "]", "=", "true", "\n", "}", "\n\n", "// TODO: Once we keep track of the original assertions in", "// Handle, restrict the resolver to use other's assertions", "// only, so that we don't hit the network at all.", "partialResolvedH", ",", "err", "=", "h", ".", "ResolveAgain", "(", "ctx", ",", "partialResolver", "{", "resolver", ",", "unresolvedAssertions", "}", ",", "idGetter", ",", "osg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "nil", ",", "err", "\n", "}", "\n\n", "// If we're migrating, use the partially-resolved handle's", "// list of writers, readers, and conflict info, rather than", "// explicitly checking team membership. This is assuming that", "// we've already validated the migrating folder's name against", "// the user list in the current MD head (done via", "// `MDOps.GetIDForHandle()`).", "if", "other", ".", "TypeForKeying", "(", ")", "==", "tlf", ".", "TeamKeying", "{", "if", "h", ".", "IsFinal", "(", ")", "{", "return", "false", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "other", ".", "resolvedWriters", "=", "partialResolvedH", ".", "resolvedWriters", "\n", "other", ".", "resolvedReaders", "=", "partialResolvedH", ".", "resolvedReaders", "\n", "other", ".", "unresolvedWriters", "=", "partialResolvedH", ".", "unresolvedWriters", "\n", "other", ".", "unresolvedReaders", "=", "partialResolvedH", ".", "unresolvedReaders", "\n", "other", ".", "conflictInfo", "=", "partialResolvedH", ".", "conflictInfo", "\n", "}", "\n", "}", "\n\n", "if", "conflictAdded", "||", "finalizedAdded", "{", "resolvesTo", ",", "err", "=", "partialResolvedH", ".", "EqualsIgnoreName", "(", "codec", ",", "other", ")", "\n", "}", "else", "{", "resolvesTo", ",", "err", "=", "partialResolvedH", ".", "Equals", "(", "codec", ",", "other", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "nil", ",", "err", "\n", "}", "\n\n", "return", "resolvesTo", ",", "partialResolvedH", ",", "nil", "\n", "}" ]

[ "ResolvesTo", "returns", "whether", "this", "handle", "resolves", "to", "the", "given", "one", ".", "It", "also", "returns", "the", "partially", "-", "resolved", "version", "of", "h", "i", ".", "e", ".", "h", "resolved", "except", "for", "unresolved", "assertions", "in", "other", ";", "this", "should", "equal", "other", "if", "and", "only", "if", "true", "is", "returned", "." ]

[ "func", "(", "h", "Handle", ")", "MutuallyResolvesTo", "(", "ctx", "context", ".", "Context", ",", "codec", "kbfscodec", ".", "Codec", ",", "resolver", "idutil", ".", "Resolver", ",", "idGetter", "IDGetter", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "other", "Handle", ",", "rev", "kbfsmd", ".", "Revision", ",", "tlfID", "tlf", ".", "ID", ",", "log", "logger", ".", "Logger", ")", "error", "{", "handleResolvesToOther", ",", "partialResolvedHandle", ",", "err", ":=", "h", ".", "ResolvesTo", "(", "ctx", ",", "codec", ",", "resolver", ",", "idGetter", ",", "osg", ",", "other", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// TODO: If h has conflict info, other should, too.", "otherResolvesToHandle", ",", "partialResolvedOther", ",", "err", ":=", "other", ".", "ResolvesTo", "(", "ctx", ",", "codec", ",", "resolver", ",", "idGetter", ",", "osg", ",", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "handlePath", ":=", "h", ".", "GetCanonicalPath", "(", ")", "\n", "otherPath", ":=", "other", ".", "GetCanonicalPath", "(", ")", "\n", "if", "!", "handleResolvesToOther", "&&", "!", "otherResolvesToHandle", "{", "return", "HandleMismatchError", "{", "rev", ",", "h", ".", "GetCanonicalPath", "(", ")", ",", "tlfID", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "otherPath", ",", "h", ".", "GetCanonicalPath", "(", ")", ",", "partialResolvedHandle", ".", "GetCanonicalPath", "(", ")", ",", "other", ".", "GetCanonicalPath", "(", ")", ",", "partialResolvedOther", ".", "GetCanonicalPath", "(", ")", ")", ",", "}", "\n", "}", "\n\n", "if", "handlePath", "!=", "otherPath", "{", "log", ".", "CDebugf", "(", "ctx", ",", "\"", "\"", ",", "handlePath", ",", "otherPath", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "MutuallyResolvesTo", "checks", "that", "the", "target", "handle", "and", "the", "provided", "other", "handle", "resolve", "to", "each", "other", "." ]

[ "func", "(", "nitk", "noImplicitTeamKBPKI", ")", "ResolveImplicitTeam", "(", "_", "context", ".", "Context", ",", "_", ",", "_", "string", ",", "_", "tlf", ".", "Type", ",", "_", "keybase1", ".", "OfflineAvailability", ")", "(", "idutil", ".", "ImplicitTeamInfo", ",", "error", ")", "{", "return", "idutil", ".", "ImplicitTeamInfo", "{", "}", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "ResolveImplicitTeam", "implements", "the", "KBPKI", "interface", "for", "noImplicitTeamKBPKI", "." ]

[ "func", "ParseHandlePreferredQuick", "(", "ctx", "context", ".", "Context", ",", "kbpki", "idutil", ".", "KBPKI", ",", "osg", "idutil", ".", "OfflineStatusGetter", ",", "name", "string", ",", "ty", "tlf", ".", "Type", ")", "(", "handle", "*", "Handle", ",", "err", "error", ")", "{", "// Override the KBPKI with one that doesn't try to resolve", "// implicit teams.", "kbpki", "=", "noImplicitTeamKBPKI", "{", "kbpki", "}", "\n", "return", "ParseHandlePreferred", "(", "ctx", ",", "kbpki", ",", "nil", ",", "osg", ",", "name", ",", "ty", ")", "\n", "}" ]

[ "ParseHandlePreferredQuick", "parses", "a", "handle", "from", "a", "name", "without", "doing", "this", "time", "consuming", "checks", "needed", "for", "implicit", "-", "team", "checking", "or", "TLF", "-", "ID", "-", "fetching", "." ]

[ "func", "newLoginLoadUser", "(", "g", "*", "libkb", ".", "GlobalContext", ",", "username", "string", ")", "*", "loginLoadUser", "{", "return", "&", "loginLoadUser", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "g", ")", ",", "username", ":", "strings", ".", "TrimSpace", "(", "username", ")", ",", "}", "\n", "}" ]

[ "newLoginLoadUser", "creates", "a", "loginLoadUser", "engine", ".", "username", "argument", "is", "optional", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSListRecursive", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSListRecursiveArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Begin", "recursive", "list", "of", "items", "in", "directory", "at", "path", ".", "If", "refreshSubscription", "is", "true", "and", "the", "path", "is", "a", "KBFS", "path", "simpleFS", "will", "begin", "sending", "FSPathUpdated", "notifications", "for", "the", "for", "the", "corresponding", "TLF", "until", "another", "call", "refreshes", "the", "subscription", "on", "a", "different", "TLF", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSListRecursiveToDepth", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSListRecursiveToDepthArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Begin", "recursive", "list", "of", "items", "in", "directory", "at", "path", "up", "to", "a", "given", "depth" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSReadList", "(", "ctx", "context", ".", "Context", ",", "opID", "OpID", ")", "(", "res", "SimpleFSListResult", ",", "err", "error", ")", "{", "__arg", ":=", "SimpleFSReadListArg", "{", "OpID", ":", "opID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Get", "list", "of", "Paths", "in", "progress", ".", "Can", "indicate", "status", "of", "pending", "to", "get", "more", "entries", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSCopy", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSCopyArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Begin", "copy", "of", "file", "or", "directory" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSSymlink", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSSymlinkArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Make", "a", "symlink", "of", "file", "or", "directory" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSCopyRecursive", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSCopyRecursiveArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Begin", "recursive", "copy", "of", "directory" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSRename", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSRenameArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Rename", "file", "or", "directory", "KBFS", "side", "only" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSWrite", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSWriteArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Append", "content", "to", "opened", "file", ".", "May", "be", "repeated", "until", "OpID", "is", "closed", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSRemove", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSRemoveArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Remove", "file", "or", "directory", "from", "filesystem" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSStat", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSStatArg", ")", "(", "res", "Dirent", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Get", "info", "about", "file" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSGetRevisions", "(", "ctx", "context", ".", "Context", ",", "__arg", "SimpleFSGetRevisionsArg", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Get", "revision", "info", "for", "a", "directory", "entry" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSReadRevisions", "(", "ctx", "context", ".", "Context", ",", "opID", "OpID", ")", "(", "res", "GetRevisionsResult", ",", "err", "error", ")", "{", "__arg", ":=", "SimpleFSReadRevisionsArg", "{", "OpID", ":", "opID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Get", "list", "of", "revisions", "in", "progress", ".", "Can", "indicate", "status", "of", "pending", "to", "get", "more", "revisions", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSMakeOpid", "(", "ctx", "context", ".", "Context", ")", "(", "res", "OpID", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "SimpleFSMakeOpidArg", "{", "}", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Convenience", "helper", "for", "generating", "new", "random", "value" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSCancel", "(", "ctx", "context", ".", "Context", ",", "opID", "OpID", ")", "(", "err", "error", ")", "{", "__arg", ":=", "SimpleFSCancelArg", "{", "OpID", ":", "opID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Cancels", "a", "running", "operation", "like", "copy", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSCheck", "(", "ctx", "context", ".", "Context", ",", "opID", "OpID", ")", "(", "res", "OpProgress", ",", "err", "error", ")", "{", "__arg", ":=", "SimpleFSCheckArg", "{", "OpID", ":", "opID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Check", "progress", "of", "pending", "operation" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSGetOps", "(", "ctx", "context", ".", "Context", ")", "(", "res", "[", "]", "OpDescription", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "SimpleFSGetOpsArg", "{", "}", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Get", "all", "the", "outstanding", "operations" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSWait", "(", "ctx", "context", ".", "Context", ",", "opID", "OpID", ")", "(", "err", "error", ")", "{", "__arg", ":=", "SimpleFSWaitArg", "{", "OpID", ":", "opID", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Blocking", "wait", "for", "the", "pending", "operation", "to", "finish" ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSDumpDebuggingInfo", "(", "ctx", "context", ".", "Context", ")", "(", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "SimpleFSDumpDebuggingInfoArg", "{", "}", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Instructs", "KBFS", "to", "dump", "debugging", "info", "into", "its", "logs", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSClearConflictState", "(", "ctx", "context", ".", "Context", ",", "path", "Path", ")", "(", "err", "error", ")", "{", "__arg", ":=", "SimpleFSClearConflictStateArg", "{", "Path", ":", "path", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "Clear", "the", "conflict", "state", "of", "a", "TLF", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSSyncStatus", "(", "ctx", "context", ".", "Context", ",", "filter", "ListFilter", ")", "(", "res", "FSSyncStatus", ",", "err", "error", ")", "{", "__arg", ":=", "SimpleFSSyncStatusArg", "{", "Filter", ":", "filter", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "Get", "sync", "status", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSListFavorites", "(", "ctx", "context", ".", "Context", ")", "(", "res", "FavoritesResult", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "SimpleFSListFavoritesArg", "{", "}", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "simpleFSListFavorites", "gets", "the", "current", "favorites", "ignored", "folders", "and", "new", "folders", "from", "the", "KBFS", "cache", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSGetUserQuotaUsage", "(", "ctx", "context", ".", "Context", ")", "(", "res", "SimpleFSQuotaUsage", ",", "err", "error", ")", "{", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "SimpleFSGetUserQuotaUsageArg", "{", "}", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "simpleFSGetUserQuotaUsage", "returns", "the", "quota", "usage", "for", "the", "logged", "-", "in", "user", ".", "Any", "usage", "includes", "local", "journal", "usage", "as", "well", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSGetTeamQuotaUsage", "(", "ctx", "context", ".", "Context", ",", "teamName", "TeamName", ")", "(", "res", "SimpleFSQuotaUsage", ",", "err", "error", ")", "{", "__arg", ":=", "SimpleFSGetTeamQuotaUsageArg", "{", "TeamName", ":", "teamName", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "&", "res", ")", "\n", "return", "\n", "}" ]

[ "simpleFSGetTeamQuotaUsage", "returns", "the", "quota", "usage", "for", "the", "given", "team", "if", "the", "logged", "-", "in", "user", "has", "access", "to", "that", "team", ".", "Any", "usage", "includes", "local", "journal", "usage", "as", "well", "." ]

[ "func", "(", "c", "SimpleFSClient", ")", "SimpleFSReset", "(", "ctx", "context", ".", "Context", ",", "path", "Path", ")", "(", "err", "error", ")", "{", "__arg", ":=", "SimpleFSResetArg", "{", "Path", ":", "path", "}", "\n", "err", "=", "c", ".", "Cli", ".", "Call", "(", "ctx", ",", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "__arg", "}", ",", "nil", ")", "\n", "return", "\n", "}" ]

[ "simpleFSReset", "completely", "resets", "the", "KBFS", "folder", "referenced", "in", "path", ".", "It", "should", "only", "be", "called", "after", "explicit", "user", "confirmation", "." ]

[ "func", "isWriterOrValidRekey", "(", "ctx", "context", ".", "Context", ",", "teamMemChecker", "kbfsmd", ".", "TeamMembershipChecker", ",", "codec", "kbfscodec", ".", "Codec", ",", "currentUID", "keybase1", ".", "UID", ",", "verifyingKey", "kbfscrypto", ".", "VerifyingKey", ",", "mergedMasterHead", ",", "newMd", "kbfsmd", ".", "RootMetadata", ",", "prevExtra", ",", "extra", "kbfsmd", ".", "ExtraMetadata", ")", "(", "bool", ",", "error", ")", "{", "h", ",", "err", ":=", "mergedMasterHead", ".", "MakeBareTlfHandle", "(", "prevExtra", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "if", "h", ".", "Type", "(", ")", "==", "tlf", ".", "SingleTeam", "{", "isWriter", ",", "err", ":=", "teamMemChecker", ".", "IsTeamWriter", "(", "ctx", ",", "h", ".", "Writers", "[", "0", "]", ".", "AsTeamOrBust", "(", ")", ",", "currentUID", ",", "verifyingKey", ",", "keybase1", ".", "OfflineAvailability_NONE", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "kbfsmd", ".", "ServerError", "{", "Err", ":", "err", "}", "\n", "}", "\n", "// Team TLFs can't be rekeyed, so readers aren't ever valid.", "return", "isWriter", ",", "nil", "\n", "}", "\n\n", "if", "h", ".", "IsWriter", "(", "currentUID", ".", "AsUserOrTeam", "(", ")", ")", "{", "return", "true", ",", "nil", "\n", "}", "\n\n", "if", "h", ".", "IsReader", "(", "currentUID", ".", "AsUserOrTeam", "(", ")", ")", "{", "// if this is a reader, are they acting within their", "// restrictions?", "return", "newMd", ".", "IsValidRekeyRequest", "(", "codec", ",", "mergedMasterHead", ",", "currentUID", ",", "prevExtra", ",", "extra", ")", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "Helper", "to", "aid", "in", "enforcement", "that", "only", "specified", "public", "keys", "can", "access", "TLF", "metadata", ".", "mergedMasterHead", "can", "be", "nil", "in", "which", "case", "true", "is", "returned", "." ]

[ "func", "Init", "(", "homeDir", ",", "mobileSharedHome", ",", "logFile", ",", "runModeStr", "string", ",", "accessGroupOverride", "bool", ",", "externalDNSNSFetcher", "ExternalDNSNSFetcher", ",", "nvh", "NativeVideoHelper", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "flattenError", "(", "err", ")", "\n", "if", "err", "==", "nil", "{", "setInited", "(", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "homeDir", ",", "mobileSharedHome", ")", "\n", "var", "ekLogFile", "string", "\n", "if", "logFile", "!=", "\"", "\"", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "logFile", ")", "\n", "ekLogFile", "=", "logFile", "+", "\"", "\"", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "ekLogFile", ")", "\n", "}", "\n\n", "// Reduce OS threads on mobile so we don't have too much contention with JS thread", "oldProcs", ":=", "runtime", ".", "GOMAXPROCS", "(", "0", ")", "\n", "newProcs", ":=", "oldProcs", "/", "2", "\n", "runtime", ".", "GOMAXPROCS", "(", "newProcs", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "newProcs", ",", "oldProcs", ")", "\n\n", "startTrace", "(", "logFile", ")", "\n\n", "dnsNSFetcher", ":=", "newDNSNSFetcher", "(", "externalDNSNSFetcher", ")", "\n", "dnsServers", ":=", "dnsNSFetcher", ".", "GetServers", "(", ")", "\n", "for", "_", ",", "srv", ":=", "range", "dnsServers", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "srv", ")", "\n", "}", "\n\n", "kbCtx", "=", "libkb", ".", "NewGlobalContext", "(", ")", "\n", "kbCtx", ".", "Init", "(", ")", "\n", "kbCtx", ".", "SetProofServices", "(", "externals", ".", "NewProofServices", "(", "kbCtx", ")", ")", "\n\n", "// 10k uid -> FullName cache entries allowed", "kbCtx", ".", "SetUIDMapper", "(", "uidmap", ".", "NewUIDMap", "(", "10000", ")", ")", "\n", "usage", ":=", "libkb", ".", "Usage", "{", "Config", ":", "true", ",", "API", ":", "true", ",", "KbKeyring", ":", "true", ",", "}", "\n", "runMode", ",", "err", ":=", "libkb", ".", "StringToRunMode", "(", "runModeStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "config", ":=", "libkb", ".", "AppConfig", "{", "HomeDir", ":", "homeDir", ",", "MobileSharedHomeDir", ":", "mobileSharedHome", ",", "LogFile", ":", "logFile", ",", "EKLogFile", ":", "ekLogFile", ",", "RunMode", ":", "runMode", ",", "Debug", ":", "true", ",", "LocalRPCDebug", ":", "\"", "\"", ",", "VDebugSetting", ":", "\"", "\"", ",", "// use empty string for same logging as desktop default", "SecurityAccessGroupOverride", ":", "accessGroupOverride", ",", "ChatInboxSourceLocalizeThreads", ":", "5", ",", "LinkCacheSize", ":", "1000", ",", "}", "\n", "err", "=", "kbCtx", ".", "Configure", "(", "config", ",", "usage", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "svc", ":=", "service", ".", "NewService", "(", "kbCtx", ",", "false", ")", "\n", "err", "=", "svc", ".", "StartLoopbackServer", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "kbCtx", ".", "SetService", "(", ")", "\n", "uir", ":=", "service", ".", "NewUIRouter", "(", "kbCtx", ")", "\n", "kbCtx", ".", "SetUIRouter", "(", "uir", ")", "\n", "kbCtx", ".", "SetDNSNameServerFetcher", "(", "dnsNSFetcher", ")", "\n", "svc", ".", "SetupCriticalSubServices", "(", ")", "\n", "svc", ".", "SetupChatModules", "(", "nil", ")", "\n", "svc", ".", "RunBackgroundOperations", "(", "uir", ")", "\n", "kbChatCtx", "=", "svc", ".", "ChatContextified", ".", "ChatG", "(", ")", "\n", "kbChatCtx", ".", "NativeVideoHelper", "=", "newVideoHelper", "(", "nvh", ")", "\n\n", "logs", ":=", "libkb", ".", "Logs", "{", "Service", ":", "config", ".", "GetLogFile", "(", ")", ",", "EK", ":", "config", ".", "GetEKLogFile", "(", ")", ",", "}", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "kbCtx", ".", "Env", ".", "GetLogFileConfig", "(", "config", ".", "GetLogFile", "(", ")", ")", ")", "\n\n", "logSendContext", "=", "libkb", ".", "LogSendContext", "{", "Contextified", ":", "libkb", ".", "NewContextified", "(", "kbCtx", ")", ",", "Logs", ":", "logs", ",", "}", "\n\n", "// open the connection", "if", "err", "=", "Reset", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "go", "func", "(", ")", "{", "kbfsCtx", ":=", "env", ".", "NewContextFromGlobalContext", "(", "kbCtx", ")", "\n", "kbfsParams", ":=", "libkbfs", ".", "DefaultInitParams", "(", "kbfsCtx", ")", "\n", "// Setting this flag will enable KBFS debug logging to always", "// be true in a mobile setting. Change these back to the", "// commented-out values if we need to make a mobile release", "// before KBFS-on-mobile is ready.", "kbfsParams", ".", "Debug", "=", "true", "// false", "\n", "kbfsParams", ".", "Mode", "=", "libkbfs", ".", "InitConstrainedString", "// libkbfs.InitMinimalString", "\n", "kbfsConfig", ",", "_", "=", "libkbfs", ".", "Init", "(", "context", ".", "Background", "(", ")", ",", "kbfsCtx", ",", "kbfsParams", ",", "serviceCn", "{", "}", ",", "func", "(", ")", "error", "{", "return", "nil", "}", ",", "kbCtx", ".", "Log", ")", "\n", "}", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "runs", "the", "Keybase", "services" ]

[ "func", "LogSend", "(", "status", "string", ",", "feedback", "string", ",", "sendLogs", "bool", ",", "uiLogPath", ",", "traceDir", ",", "cpuProfileDir", "string", ")", "(", "res", "string", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "flattenError", "(", "err", ")", "}", "(", ")", "\n", "logSendContext", ".", "Logs", ".", "Desktop", "=", "uiLogPath", "\n", "logSendContext", ".", "Logs", ".", "Trace", "=", "traceDir", "\n", "logSendContext", ".", "Logs", ".", "CPUProfile", "=", "cpuProfileDir", "\n", "env", ":=", "kbCtx", ".", "Env", "\n", "sendLogMaxSizeBytes", ":=", "10", "*", "1024", "*", "1024", "// NOTE: If you increase this, check go/libkb/env.go:Env.GetLogFileConfig to make sure we store at least that much.", "\n", "return", "logSendContext", ".", "LogSend", "(", "status", ",", "feedback", ",", "sendLogs", ",", "sendLogMaxSizeBytes", ",", "env", ".", "GetUID", "(", ")", ",", "env", ".", "GetInstallID", "(", ")", ",", "true", "/* mergeExtendedStatus */", ")", "\n", "}" ]

[ "LogSend", "sends", "a", "log", "to", "Keybase" ]

[ "func", "WriteB64", "(", "str", "string", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "flattenError", "(", "err", ")", "}", "(", ")", "\n", "if", "conn", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "data", ",", "err", ":=", "base64", ".", "StdEncoding", ".", "DecodeString", "(", "str", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "str", ")", "\n", "}", "\n", "n", ",", "err", ":=", "conn", ".", "Write", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "n", "!=", "len", "(", "data", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "WriteB64", "sends", "a", "base64", "encoded", "msgpack", "rpc", "payload" ]

[ "func", "ReadB64", "(", ")", "(", "res", "string", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "err", "=", "flattenError", "(", "err", ")", "}", "(", ")", "\n", "if", "conn", "==", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "n", ",", "err", ":=", "conn", ".", "Read", "(", "buffer", ")", "\n", "if", "n", ">", "0", "&&", "err", "==", "nil", "{", "str", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "buffer", "[", "0", ":", "n", "]", ")", "\n", "return", "str", ",", "nil", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "// Attempt to fix the connection", "Reset", "(", ")", "\n", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "\"", "\"", ",", "nil", "\n", "}" ]

[ "ReadB64", "is", "a", "blocking", "read", "for", "base64", "encoded", "msgpack", "rpc", "data", ".", "It", "is", "called", "serially", "by", "the", "mobile", "run", "loops", "." ]

[ "func", "Reset", "(", ")", "error", "{", "if", "conn", "!=", "nil", "{", "conn", ".", "Close", "(", ")", "\n", "}", "\n\n", "var", "err", "error", "\n", "conn", ",", "err", "=", "kbCtx", ".", "LoopbackListener", ".", "Dial", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Reset", "resets", "the", "socket", "connection" ]

[ "func", "ForceGC", "(", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "kbCtx", ".", "FlushCaches", "(", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "debug", ".", "FreeOSMemory", "(", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "}" ]

[ "ForceGC", "Forces", "a", "gc" ]

[ "func", "pushPendingMessageFailure", "(", "obrs", "[", "]", "chat1", ".", "OutboxRecord", ",", "pusher", "PushNotifier", ")", "{", "for", "_", ",", "obr", ":=", "range", "obrs", "{", "if", "!", "obr", ".", "IsUnfurl", "(", ")", "{", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "obr", ".", "ConvID", ")", "\n", "pusher", ".", "LocalNotification", "(", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ",", "\"", "\"", ",", "obr", ".", "ConvID", ".", "String", "(", ")", ",", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "len", "(", "obrs", ")", ")", "\n", "}" ]

[ "pushPendingMessageFailure", "sends", "at", "most", "one", "notification", "that", "a", "message", "failed", "to", "send", ".", "We", "don", "t", "notify", "the", "user", "about", "background", "failures", "like", "unfurling", "." ]

[ "func", "AppWillExit", "(", "pusher", "PushNotifier", ")", "{", "if", "!", "isInited", "(", ")", "{", "return", "\n", "}", "\n", "defer", "kbCtx", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "nil", "}", ")", "(", ")", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n", "obrs", ",", "err", ":=", "kbChatCtx", ".", "MessageDeliverer", ".", "ActiveDeliveries", "(", "ctx", ")", "\n", "if", "err", "==", "nil", "{", "// We are about to get killed with messages still to send, let the user", "// know they will get stuck", "pushPendingMessageFailure", "(", "obrs", ",", "pusher", ")", "\n", "}", "\n", "kbCtx", ".", "MobileAppState", ".", "Update", "(", "keybase1", ".", "MobileAppState_BACKGROUND", ")", "\n", "}" ]

[ "AppWillExit", "is", "called", "reliably", "on", "iOS", "when", "the", "app", "is", "about", "to", "terminate", "not", "as", "reliably", "on", "android" ]

[ "func", "AppBeginBackgroundTask", "(", "pusher", "PushNotifier", ")", "{", "if", "!", "isInited", "(", ")", "{", "return", "\n", "}", "\n", "defer", "kbCtx", ".", "Trace", "(", "\"", "\"", ",", "func", "(", ")", "error", "{", "return", "nil", "}", ")", "(", ")", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n", "// Poll active deliveries in case we can shutdown early", "beginTime", ":=", "libkb", ".", "ForceWallClock", "(", "time", ".", "Now", "(", ")", ")", "\n", "ticker", ":=", "time", ".", "NewTicker", "(", "5", "*", "time", ".", "Second", ")", "\n", "appState", ":=", "kbCtx", ".", "MobileAppState", ".", "State", "(", ")", "\n", "if", "appState", "!=", "keybase1", ".", "MobileAppState_BACKGROUNDACTIVE", "{", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "var", "g", "*", "errgroup", ".", "Group", "\n", "g", ",", "ctx", "=", "errgroup", ".", "WithContext", "(", "ctx", ")", "\n", "g", ".", "Go", "(", "func", "(", ")", "error", "{", "select", "{", "case", "appState", "=", "<-", "kbCtx", ".", "MobileAppState", ".", "NextUpdate", "(", "&", "appState", ")", ":", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "appState", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}", ")", "\n", "g", ".", "Go", "(", "func", "(", ")", "error", "{", "ch", ",", "cancel", ":=", "kbChatCtx", ".", "MessageDeliverer", ".", "NextFailure", "(", ")", "\n", "defer", "cancel", "(", ")", "\n", "select", "{", "case", "obrs", ":=", "<-", "ch", ":", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "len", "(", "obrs", ")", ")", "\n", "pushPendingMessageFailure", "(", "obrs", ",", "pusher", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}", ")", "\n", "g", ".", "Go", "(", "func", "(", ")", "error", "{", "successCount", ":=", "0", "\n", "for", "{", "select", "{", "case", "<-", "ticker", ".", "C", ":", "obrs", ",", "err", ":=", "kbChatCtx", ".", "MessageDeliverer", ".", "ActiveDeliveries", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "len", "(", "obrs", ")", "==", "0", "{", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "successCount", ")", "\n", "// We can race the failure case here, so lets go a couple passes of no pending", "// convs before we abort due to ths condition.", "if", "successCount", ">", "1", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "successCount", "++", "\n", "}", "\n", "curTime", ":=", "libkb", ".", "ForceWallClock", "(", "time", ".", "Now", "(", ")", ")", "\n", "if", "curTime", ".", "Sub", "(", "beginTime", ")", ">=", "10", "*", "time", ".", "Minute", "{", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ")", "\n", "pushPendingMessageFailure", "(", "obrs", ",", "pusher", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "}", "\n", "}", ")", "\n", "if", "err", ":=", "g", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "kbCtx", ".", "Log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "AppBeginBackgroundTask", "notifies", "us", "that", "an", "app", "background", "task", "has", "been", "started", "on", "our", "behalf", ".", "This", "function", "will", "return", "once", "we", "no", "longer", "need", "any", "time", "in", "the", "background", "." ]

[ "func", "NewCryptoLocal", "(", "codec", "kbfscodec", ".", "Codec", ",", "signingKey", "kbfscrypto", ".", "SigningKey", ",", "cryptPrivateKey", "kbfscrypto", ".", "CryptPrivateKey", ",", "blockCryptVersioner", "blockCryptVersioner", ")", "*", "CryptoLocal", "{", "return", "&", "CryptoLocal", "{", "MakeCryptoCommon", "(", "codec", ",", "blockCryptVersioner", ")", ",", "kbfscrypto", ".", "SigningKeySigner", "{", "Key", ":", "signingKey", "}", ",", "cryptPrivateKey", ",", "make", "(", "map", "[", "keybase1", ".", "TeamID", "]", "perTeamKeyPairs", ")", ",", "}", "\n", "}" ]

[ "NewCryptoLocal", "constructs", "a", "new", "CryptoLocal", "instance", "with", "the", "given", "signing", "key", "." ]

[ "func", "(", "c", "*", "CryptoLocal", ")", "DecryptTLFCryptKeyClientHalf", "(", "ctx", "context", ".", "Context", ",", "publicKey", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "encryptedClientHalf", "kbfscrypto", ".", "EncryptedTLFCryptKeyClientHalf", ")", "(", "kbfscrypto", ".", "TLFCryptKeyClientHalf", ",", "error", ")", "{", "return", "kbfscrypto", ".", "DecryptTLFCryptKeyClientHalf", "(", "c", ".", "cryptPrivateKey", ",", "publicKey", ",", "encryptedClientHalf", ")", "\n", "}" ]

[ "DecryptTLFCryptKeyClientHalf", "implements", "the", "Crypto", "interface", "for", "CryptoLocal", "." ]

[ "func", "(", "c", "*", "CryptoLocal", ")", "DecryptTLFCryptKeyClientHalfAny", "(", "ctx", "context", ".", "Context", ",", "keys", "[", "]", "EncryptedTLFCryptKeyClientAndEphemeral", ",", "_", "bool", ")", "(", "clientHalf", "kbfscrypto", ".", "TLFCryptKeyClientHalf", ",", "index", "int", ",", "err", "error", ")", "{", "if", "len", "(", "keys", ")", "==", "0", "{", "return", "kbfscrypto", ".", "TLFCryptKeyClientHalf", "{", "}", ",", "-", "1", ",", "errors", ".", "WithStack", "(", "NoKeysError", "{", "}", ")", "\n", "}", "\n", "var", "firstNonDecryptionErr", "error", "\n", "for", "i", ",", "k", ":=", "range", "keys", "{", "clientHalf", ",", "err", ":=", "c", ".", "DecryptTLFCryptKeyClientHalf", "(", "ctx", ",", "k", ".", "EPubKey", ",", "k", ".", "ClientHalf", ")", "\n", "if", "err", "!=", "nil", "{", "_", ",", "isDecryptionError", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "libkb", ".", "DecryptionError", ")", "\n", "if", "firstNonDecryptionErr", "==", "nil", "&&", "!", "isDecryptionError", "{", "firstNonDecryptionErr", "=", "err", "\n", "}", "\n", "continue", "\n", "}", "\n", "return", "clientHalf", ",", "i", ",", "nil", "\n", "}", "\n", "// This is to mimic the behavior in", "// CryptoClient.DecryptTLFCryptKeyClientHalfAny, which is to,", "// if all calls to prepareTLFCryptKeyClientHalf failed, return", "// the first prep error, and otherwise to return the error", "// from the service, which is usually libkb.DecryptionError.", "if", "firstNonDecryptionErr", "!=", "nil", "{", "return", "kbfscrypto", ".", "TLFCryptKeyClientHalf", "{", "}", ",", "-", "1", ",", "firstNonDecryptionErr", "\n", "}", "\n", "return", "kbfscrypto", ".", "TLFCryptKeyClientHalf", "{", "}", ",", "-", "1", ",", "errors", ".", "WithStack", "(", "libkb", ".", "DecryptionError", "{", "}", ")", "\n", "}" ]

[ "DecryptTLFCryptKeyClientHalfAny", "implements", "the", "Crypto", "interface", "for", "CryptoLocal", "." ]

[ "func", "(", "c", "*", "CryptoLocal", ")", "DecryptTeamMerkleLeaf", "(", "ctx", "context", ".", "Context", ",", "teamID", "keybase1", ".", "TeamID", ",", "publicKey", "kbfscrypto", ".", "TLFEphemeralPublicKey", ",", "encryptedMerkleLeaf", "kbfscrypto", ".", "EncryptedMerkleLeaf", ",", "minKeyGen", "keybase1", ".", "PerTeamKeyGeneration", ")", "(", "decryptedData", "[", "]", "byte", ",", "err", "error", ")", "{", "perTeamKeys", ":=", "c", ".", "teamPrivateKeys", "[", "teamID", "]", "\n", "maxKeyGen", ":=", "keybase1", ".", "PerTeamKeyGeneration", "(", "len", "(", "perTeamKeys", ")", ")", "\n", "for", "i", ":=", "minKeyGen", ";", "i", "<=", "maxKeyGen", ";", "i", "++", "{", "decryptedData", ",", "err", ":=", "kbfscrypto", ".", "DecryptMerkleLeaf", "(", "perTeamKeys", "[", "i", "]", ".", "privKey", ",", "publicKey", ",", "encryptedMerkleLeaf", ")", "\n", "if", "err", "==", "nil", "{", "return", "decryptedData", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "errors", ".", "WithStack", "(", "libkb", ".", "DecryptionError", "{", "}", ")", "\n", "}" ]

[ "DecryptTeamMerkleLeaf", "implements", "the", "Crypto", "interface", "for", "CryptoLocal", "." ]

[ "func", "GetEncodedUpdateHistory", "(", "ctx", "context", ".", "Context", ",", "config", "libkbfs", ".", "Config", ",", "folderBranch", "data", ".", "FolderBranch", ")", "(", "data", "[", "]", "byte", ",", "t", "time", ".", "Time", ",", "err", "error", ")", "{", "history", ",", "err", ":=", "config", ".", "KBFSOps", "(", ")", ".", "GetUpdateHistory", "(", "ctx", ",", "folderBranch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n\n", "data", ",", "err", "=", "json", ".", "Marshal", "(", "history", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "time", ".", "Time", "{", "}", ",", "err", "\n", "}", "\n\n", "data", "=", "append", "(", "data", ",", "'\\n'", ")", "\n", "return", "data", ",", "time", ".", "Time", "{", "}", ",", "nil", "\n", "}" ]

[ "GetEncodedUpdateHistory", "returns", "a", "JSON", "-", "encoded", "version", "of", "a", "TLF", "s", "complete", "update", "history", "." ]

[ "func", "NewKeyCacheStandard", "(", "capacity", "int", ")", "*", "KeyCacheStandard", "{", "head", ",", "err", ":=", "lru", ".", "New", "(", "capacity", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "&", "KeyCacheStandard", "{", "head", "}", "\n", "}" ]

[ "NewKeyCacheStandard", "constructs", "a", "new", "KeyCacheStandard", "with", "the", "given", "cache", "capacity", "." ]

[ "func", "(", "k", "*", "KeyCacheStandard", ")", "GetTLFCryptKey", "(", "tlf", "tlf", ".", "ID", ",", "keyGen", "kbfsmd", ".", "KeyGen", ")", "(", "kbfscrypto", ".", "TLFCryptKey", ",", "error", ")", "{", "cacheKey", ":=", "keyCacheKey", "{", "tlf", ",", "keyGen", "}", "\n", "if", "entry", ",", "ok", ":=", "k", ".", "lru", ".", "Get", "(", "cacheKey", ")", ";", "ok", "{", "if", "key", ",", "ok", ":=", "entry", ".", "(", "kbfscrypto", ".", "TLFCryptKey", ")", ";", "ok", "{", "return", "key", ",", "nil", "\n", "}", "\n", "// shouldn't really be possible", "return", "kbfscrypto", ".", "TLFCryptKey", "{", "}", ",", "KeyCacheHitError", "{", "tlf", ",", "keyGen", "}", "\n", "}", "\n", "return", "kbfscrypto", ".", "TLFCryptKey", "{", "}", ",", "KeyCacheMissError", "{", "tlf", ",", "keyGen", "}", "\n", "}" ]

[ "GetTLFCryptKey", "implements", "the", "KeyCache", "interface", "for", "KeyCacheStandard", "." ]

[ "func", "(", "k", "*", "KeyCacheStandard", ")", "PutTLFCryptKey", "(", "tlf", "tlf", ".", "ID", ",", "keyGen", "kbfsmd", ".", "KeyGen", ",", "key", "kbfscrypto", ".", "TLFCryptKey", ")", "error", "{", "cacheKey", ":=", "keyCacheKey", "{", "tlf", ",", "keyGen", "}", "\n", "k", ".", "lru", ".", "Add", "(", "cacheKey", ",", "key", ")", "\n", "return", "nil", "\n", "}" ]

[ "PutTLFCryptKey", "implements", "the", "KeyCache", "interface", "for", "KeyCacheStandard", "." ]

[ "func", "PrettyJSON", "(", "value", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "data", ",", "err", ":=", "json", ".", "MarshalIndent", "(", "value", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "data", "=", "append", "(", "data", ",", "'\\n'", ")", "\n", "return", "data", ",", "nil", "\n", "}" ]

[ "PrettyJSON", "marshals", "a", "value", "to", "human", "-", "readable", "JSON", "." ]

[ "func", "(", "s", "*", "Semaphore", ")", "Count", "(", ")", "int64", "{", "s", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "s", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "s", ".", "count", "\n", "}" ]

[ "Count", "returns", "the", "current", "resource", "count", "." ]

[ "func", "(", "s", "*", "Semaphore", ")", "tryAcquire", "(", "n", "int64", ")", "(", "<-", "chan", "struct", "{", "}", ",", "int64", ")", "{", "s", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "n", "<=", "s", ".", "count", "{", "s", ".", "count", "-=", "n", "\n", "return", "nil", ",", "s", ".", "count", "\n", "}", "\n\n", "return", "s", ".", "onRelease", ",", "s", ".", "count", "\n", "}" ]

[ "tryAcquire", "tries", "to", "acquire", "n", "resources", ".", "If", "successful", "nil", "is", "returned", ".", "Otherwise", "a", "channel", "which", "will", "be", "closed", "when", "new", "resources", "are", "available", "is", "returned", ".", "In", "either", "case", "the", "possibly", "-", "updated", "resource", "count", "is", "returned", "." ]

[ "func", "LsofMount", "(", "mountDir", "string", ",", "log", "Log", ")", "(", "[", "]", "CommonLsofResult", ",", "error", ")", "{", "log", ".", "Debug", "(", "\"", "\"", ",", "mountDir", ")", "\n", "if", "mountDir", "==", "\"", "\"", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "_", ",", "serr", ":=", "os", ".", "Stat", "(", "mountDir", ")", ";", "os", ".", "IsNotExist", "(", "serr", ")", "{", "log", ".", "Debug", "(", "\"", "\"", ",", "mountDir", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n\n", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "processes", ",", "err", ":=", "lsof", ".", "MountPoint", "(", "mountDir", ")", "\n", "if", "err", "!=", "nil", "{", "// If there is an error in lsof it's ok to continue", "// An exit status of 1 means that the mount is not in use, and is", "// not really an error.", "log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n", "var", "ret", "[", "]", "CommonLsofResult", "\n", "for", "_", ",", "process", ":=", "range", "processes", "{", "ret", "=", "append", "(", "ret", ",", "CommonLsofResult", "{", "process", ".", "PID", ",", "process", ".", "Command", "}", ")", "\n", "}", "\n", "return", "ret", ",", "nil", "\n", "}" ]

[ "LsofMount", "does", "not", "return", "an", "error", "if", "it", "was", "unable", "to", "lsof", "the", "mountpoint", "or", "the", "mountpoint", "does", "not", "exist", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "Open", "(", "filename", "string", ")", "(", "f", "billy", ".", "File", ",", "err", "error", ")", "{", "if", "!", "rootWrappedNodeNames", "[", "filename", "]", "{", "// In particular, this FS doesn't let you open the folderlist", "// directories or anything in them.", "return", "nil", ",", "os", ".", "ErrNotExist", "\n", "}", "\n\n", "switch", "filename", "{", "case", "StatusFileName", ":", "return", "&", "wrappedReadFile", "{", "name", ":", "StatusFileName", ",", "reader", ":", "func", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "return", "GetEncodedStatus", "(", "ctx", ",", "rfs", ".", "config", ")", "\n", "}", ",", "log", ":", "rfs", ".", "log", ",", "}", ",", "nil", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "filename", ")", ")", "\n", "}", "\n", "}" ]

[ "Open", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "OpenFile", "(", "filename", "string", ",", "flag", "int", ",", "_", "os", ".", "FileMode", ")", "(", "f", "billy", ".", "File", ",", "err", "error", ")", "{", "if", "flag", "&", "os", ".", "O_CREATE", "!=", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "rfs", ".", "Open", "(", "filename", ")", "\n", "}" ]

[ "OpenFile", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "Lstat", "(", "filename", "string", ")", "(", "fi", "os", ".", "FileInfo", ",", "err", "error", ")", "{", "if", "filename", "==", "\"", "\"", "{", "filename", "=", "\"", "\"", "\n", "}", "\n", "if", "filename", "==", "\"", "\"", "{", "return", "&", "wrappedReadFileInfo", "{", "\"", "\"", ",", "0", ",", "rfs", ".", "config", ".", "Clock", "(", ")", ".", "Now", "(", ")", ",", "true", "}", ",", "nil", "\n", "}", "\n", "if", "!", "rootWrappedNodeNames", "[", "filename", "]", "{", "return", "nil", ",", "os", ".", "ErrNotExist", "\n", "}", "\n\n", "switch", "filename", "{", "case", "StatusFileName", ":", "wrf", ":=", "&", "wrappedReadFile", "{", "name", ":", "StatusFileName", ",", "reader", ":", "func", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "byte", ",", "time", ".", "Time", ",", "error", ")", "{", "return", "GetEncodedStatus", "(", "ctx", ",", "rfs", ".", "config", ")", "\n", "}", ",", "log", ":", "rfs", ".", "log", ",", "}", "\n", "return", "wrf", ".", "GetInfo", "(", ")", ",", "nil", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "filename", ")", ")", "\n", "}", "\n", "}" ]

[ "Lstat", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]

[ "func", "(", "rfs", "*", "RootFS", ")", "Stat", "(", "filename", "string", ")", "(", "fi", "os", ".", "FileInfo", ",", "err", "error", ")", "{", "return", "rfs", ".", "Lstat", "(", "filename", ")", "\n", "}" ]

[ "Stat", "implements", "the", "billy", ".", "Filesystem", "interface", "for", "RootFS", "." ]