Current File : //proc/self/root/kunden/proc/self/root/usr/share/emacs/27.2/lisp/auth-source-pass.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\305\306\307\310\311\312\313\303\314\315&	\210\316\317\320\321\322DD\323\324\325\314\315&\210\316\326\320\321\327DD\330\324\331\314\315&\207" [require seq cl-lib auth-source url-parse custom-declare-group auth-source-pass nil "password-store integration within auth-source." :prefix "auth-source-pass-" :group :version "27.1" custom-declare-variable auth-source-pass-filename funcall function #[0 "\300\301!\206\302\207" [getenv "PASSWORD_STORE_DIR" "~/.password-store"] 2] "Filename of the password-store folder." :type directory auth-source-pass-port-separator #[0 "\300\207" [#1=":"] 1 #1#] "Separator string between host and port in entry filename." string] 10)
#@184 Given a property list SPEC, return search matches from the :backend.
See `auth-source-search' for details on SPEC.

(fn &rest SPEC &key BACKEND TYPE HOST USER PORT &allow-other-keys)
(defalias 'auth-source-pass-search #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\203>\306\307\"=\204>\310\311\312?\306\n\307\"=D\313$\210:\203M\314\315!\210\316\317\"\262\320=\203[\314\321!\210\313\202p\204c\313\202p\322#\211\205n\211C\262
\207" [plist-member :backend :type :host :user :port eieio-oref type cl--assertion-failed (or (null type) (eq type (oref backend type))) "Invalid password-store search: %s %s" nil warn "auth-source-pass ignores all but first host in spec." seq-find identity t "auth-source-pass does not handle host wildcards." auth-source-pass--build-result] 14 (#$ . 1143)])
#@81 Build auth-source-pass entry matching HOST, PORT and USER.

(fn HOST PORT USER)
(defalias 'auth-source-pass--build-result #[771 "\300#\211\205:\301\302\303\304\"\206\305\303\306\"\206\307\310\311\312\313\314\f!\315\"\316$\257\317\320\321\311\322#\"\210\211\262
\207" [auth-source-pass--find-match :host :port auth-source-pass--get-attr "port" :user "user" :secret make-byte-code 0 "\301\302\300\"\207" vconcat vector [auth-source-pass--get-attr secret] 3 auth-source-pass--do-debug "return %s as final result (plus hidden password)" seq-subseq -2] 17 (#$ . 1984)])
#@36 Enable auth-source-password-store.
(defalias 'auth-source-pass-enable #[0 "\300\301\302\"\210\303 \207" [add-to-list auth-sources password-store auth-source-forget-all-cached] 3 (#$ . 2573)])
#@41 Auth-source backend for password-store.
(defvar auth-source-pass-backend (byte-code "\301\302X\205\303\304\305\306\307\310\311&\207" [emacs-major-version auth-source-backend 25 "password-store" :source "." :type password-store :search-function auth-source-pass-search] 8) (#$ . 2771))
#@69 Create a password-store auth-source backend from ENTRY.

(fn ENTRY)
(defalias 'auth-source-pass-backend-parse #[257 "\211\301=\205\n\302
\"\207" [auth-source-pass-backend password-store auth-source-backend-parse-parameters] 4 (#$ . 3066)])
(byte-code "\300\301!\203\302\301\303\"\210\202\304\305\306\303#\210\300\207" [boundp auth-source-backend-parser-functions add-hook auth-source-pass-backend-parse advice-add auth-source-backend-parse :before-until] 4)
#@357 Return the value associated to KEY in the password-store entry ENTRY.

ENTRY is the name of a password-store entry.
The key used to retrieve the password is the symbol `secret'.

The convention used as the format for a password-store file is
the following (see http://www.passwordstore.org/#organization):

secret
key1: value1
key2: value2

(fn KEY ENTRY)
(defalias 'auth-source-pass-get #[514 "\300
!\301\"\207" [auth-source-pass-parse-entry auth-source-pass--get-attr] 6 (#$ . 3537)])
#@224 Return value associated with KEY in an ENTRY-DATA.

ENTRY-DATA is the data from a parsed password-store entry.
The key used to retrieve the password is the symbol `secret'.

See `auth-source-pass-get'.

(fn KEY ENTRY-DATA)
(defalias 'auth-source-pass--get-attr #[514 "\300\"A\206
\301\230\205\300\302\"A\207" [assoc "user" "username"] 5 (#$ . 4033)])
#@61 Return a string with the file content of ENTRY.

(fn ENTRY)
(defalias 'auth-source-pass--read-entry #[257 "\301\302!r\211q\210\303\304\305\306\307!\310\"\311$\216\312\313\314\315\"\"!\210\316ed\"*\207" [auth-source-pass-filename generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 insert-file-contents expand-file-name format "%s.gpg" buffer-substring-no-properties] 8 (#$ . 4397)])
#@110 Return an alist of the data associated with ENTRY.

ENTRY is the name of a password-store entry.

(fn ENTRY)
(defalias 'auth-source-pass-parse-entry #[257 "\3001\301
!0\202
\210\302\211\205\303\304!B\305!B\207" [(error) auth-source-pass--read-entry nil secret auth-source-pass--parse-secret auth-source-pass--parse-data] 5 (#$ . 4859)])
#@134 Parse the password-store data in the string CONTENTS and return its secret.
The secret is the first line of CONTENTS.

(fn CONTENTS)
(defalias 'auth-source-pass--parse-secret #[257 "\300
\301\302#@\207" [split-string "\n" t] 5 (#$ . 5210)])
#@151 Parse the password-store data in the string CONTENTS and return an alist.
CONTENTS is the contents of a password-store formatted file.

(fn CONTENTS)
(defalias 'auth-source-pass--parse-data #[257 "\300
\301\302\303$\304\305\306\307A\"\"\207" [split-string "\n" t "[ 	]+" seq-remove null mapcar #[257 "\300\301\302\303\"\"\211G\304V\205\211@\305\306A\303#B\207" [mapcar #[257 "\211\301\211
\302
\206\303\304Q\301\305\306#)\266\203\211\203%\307\310#\202&\262
\266\202\306\311\2062\303\312Q\"\203A\307\310\225\"\202B
\266\202\207" [inhibit-changing-match-data nil "\\(?:" "[ 	\n
]+" "\\)\\'" t string-match substring 0 "\\`\\(?:" "\\)"] 13 "\n\n(fn S)"] split-string ":" 1 mapconcat identity] 7 "\n\n(fn LINE)"]] 7 (#$ . 5458)])
#@68 Call `auth-source-do-debug` with MSG and a prefix.

(fn &rest MSG)
(defalias 'auth-source-pass--do-debug #[128 "\300\301\302@PAB\"\207" [apply auth-source-do-debug "auth-source-pass: "] 5 (#$ . 6215)])
#@46 Return a list of all password store entries.
(defalias 'auth-source-pass-entries #[0 "\301!\302\303\304\305\306\307!\310\"\311\312%\313\314\"\"\207" [auth-source-pass-filename expand-file-name mapcar make-byte-code 257 "\301\302\300\"!\207" vconcat vector [file-name-sans-extension file-relative-name] 5 "\n\n(fn FILE)" directory-files-recursively "\\.gpg\\'"] 8 (#$ . 6425)])
#@217 Return password-store entry data matching HOST, USER and PORT.

Disambiguate between user provided inside HOST (e.g., user@server.com) and
inside USER by giving priority to USER.  Same for PORT.

(fn HOST USER PORT)
(defalias 'auth-source-pass--find-match #[771 "\300\301\302#\"\207" [apply auth-source-pass--find-match-unambiguous auth-source-pass--disambiguate] 9 (#$ . 6814)])
#@215 Return (HOST USER PORT) after disambiguation.
Disambiguate between having user provided inside HOST (e.g.,
user@server.com) and inside USER by giving priority to USER.
Same for PORT.

(fn HOST &optional USER PORT)
(defalias 'auth-source-pass--disambiguate #[769 "\302\303\304\305\306#)\266\203\203\202\307\310\"!\311
!	>\204)\312\313\314D\"\210\211\315H\2060\206F\311!	>\204C\312\313\314D\"\210
\316H\206\216\317\311
!	>\204[\312\313\314D\"\210\211\320H\206\213\311
!	>\204p\312\313\314D\"\210\211\321H\205\213\322\311!	>\204\206\312\313\314D\"\210
\321H\323\"\262
!E\207" [inhibit-changing-match-data cl-struct-url-tags url-generic-parse-url ".*://" nil t string-match format "https://%s" type-of signal wrong-type-argument url 4 2 number-to-string 5 1 url-scheme-get-property default-port] 13 (#$ . 7204)])
#@235 Return password-store entry data matching HOSTNAME, USER and PORT.
If many matches are found, return the first one.  If no match is found,
return nil.

HOSTNAME should not contain any username or port number.

(fn HOSTNAME USER PORT)
(defalias 'auth-source-pass--find-match-unambiguous #[771 "\300 \301#\302\303\206\304\206\304$\210\302\305\"\210\3062l\211\211\205i\211@\307
\"\310
\"
G\211\311\267\202L\302\312\"\210\202V\302\313@#\210\202V\302\314G$\210\210\211\203`\315\306\"\210\266
A\266\202\202#\262
0\207" [auth-source-pass-entries auth-source-pass--generate-entry-suffixes auth-source-pass--do-debug "searching for entries matching hostname=%S, user=%S, port=%S" "" "corresponding suffixes to search for: %S" auth-source-pass-break auth-source-pass--entries-matching-suffix auth-source-pass--select-from-entries #s(hash-table size 2 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (0 58 1 66)) "found no entries matching %S" "found 1 entry matching %S: %S" "found %s entries matching %S: %S" throw] 15 (#$ . 8052)])
#@168 Return best matching password-store entry data from ENTRIES.

If USER is non-nil, give precedence to entries containing a user field
matching USER.

(fn ENTRIES USER)
(defalias 'auth-source-pass--select-from-entries #[514 "\300\30128\211\2034\211@\302
!\211\203,\204,\211\262\203'\303\304\"\232\203,\305\301\"\210\210
A\266\202\202
\262
0\207" [nil auth-source-pass-break auth-source-pass-parse-entry auth-source-pass--get-attr "user" throw] 9 (#$ . 9134)])
#@135 Return entries matching SUFFIX.
If ENTRIES is nil, use the result of calling `auth-source-pass-entries' instead.

(fn SUFFIX ENTRIES)
(defalias 'auth-source-pass--entries-matching-suffix #[514 "\300\301\302\303\304\305!\306\"\307\310%\206\311 \"\207" [cl-remove-if-not make-byte-code 257 "\302\303\304\300!\"
\305\306\307#)\207" vconcat vector [inhibit-changing-match-data format "\\(^\\|/\\)%s$" regexp-quote nil t string-match] 8 "\n\n(fn ENTRY)" auth-source-pass-entries] 9 (#$ . 9614)])
#@274 Return a list of possible entry path suffixes in the password-store.

Based on the supported pathname patterns for HOSTNAME, USER, &
PORT, return a list of possible suffixes for matching entries in
the password-store.

PORT may be a list of ports.

(fn HOSTNAME USER PORT)
(defalias 'auth-source-pass--generate-entry-suffixes #[771 "\300\301\302\"!\303\304\305\306\307\310\"\311\"\312\313%\"\207" [auth-source-pass--domains split-string "\\." seq-mapcat make-byte-code 257 "\302\303\304\305\306\307\300\"\310\"\311\312%\301:\203\301\202\301C\"\207" vconcat vector [seq-mapcat make-byte-code 257 "\302\301\300#\207" vconcat vector [auth-source-pass--name-port-user-suffixes] 5 "\n\n(fn P)"] 9 "\n\n(fn DOMAIN)"] 12 (#$ . 10121)])
#@304 Return a list of possible domain names matching the hostname.

This function takes a list of NAME-COMPONENTS, the strings
separated by periods in the hostname, and returns a list of full
domain names containing the trailing sequences of those
components, from longest to shortest.

(fn NAME-COMPONENTS)
(defalias 'auth-source-pass--domains #[257 "\300\301\"\207" [cl-maplist #[257 "\300\301\302#\207" [mapconcat identity "."] 5 "\n\n(fn COMPONENTS)"]] 4 (#$ . 10870)])
#@260 Return a list of possible path suffixes for NAME, USER, & PORT.

The resulting list is ordered from most specific to least
specific, with paths matching all of NAME, USER, & PORT first,
then NAME & USER, then NAME & PORT, then just NAME.

(fn NAME USER PORT)
(defalias 'auth-source-pass--name-port-user-suffixes #[771 "\301\302\205\205\303\304%\303\305	%D\2051\303\306#\303\307#D\205>\303\310$C\303\311	\"CF\"\207" [auth-source-pass-port-separator seq-mapcat identity format "%s@%s%s%s" "%s%s%s/%s" "%s@%s" "%s/%s" "%s%s%s" "%s"] 12 (#$ . 11348)])
(provide 'auth-source-pass)