;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013, 2014, 2015, 2016, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu system accounts)
  #:use-module (guix records)
  #:use-module (ice-9 match)
  #:export (user-account
            user-account?
            user-account-name
            user-account-password
            user-account-uid
            user-account-group
            user-account-supplementary-groups
            user-account-comment
            user-account-home-directory
            user-account-create-home-directory?
            user-account-shell
            user-account-system?

            user-group
            user-group?
            user-group-name
            user-group-password
            user-group-id
            user-group-system?

            sexp->user-account
            sexp->user-group

            default-shell))


;;; Commentary:
;;;
;;; Data structures representing user accounts and user groups.  This is meant
;;; to be used both on the host side and at run time--e.g., in activation
;;; snippets.
;;;
;;; Code:

(define default-shell
  ;; Default shell for user accounts (a string or string-valued gexp).
  (make-parameter "/bin/sh"))

(define-record-type* <user-account>
  user-acco<pre>
#include &quot;derivations.hh&quot;
#include &quot;store-api.hh&quot;
#include &quot;globals.hh&quot;
#include &quot;util.hh&quot;
#include &quot;misc.hh&quot;


namespace nix {


void DerivationOutput::parseHashInfo(bool &amp; recursive, HashType &amp; hashType, Hash &amp; hash) const
{
    recursive = false;
    string algo = hashAlgo;

    if (string(algo, 0, 2) == &quot;r:&quot;) {
        recursive = true;
        algo = string(algo, 2);
    }

    hashType = parseHashType(algo);
    if (hashType == htUnknown)
        throw Error(format(&quot;unknown hash algorithm `%1%&apos;&quot;) % algo);

    hash = parseHash(hashType, this-&gt;hash);
}


Path writeDerivation(StoreAPI &amp; store,
    const Derivation &amp; drv, const string &amp; name, bool repair)
{
    PathSet references;
    references.insert(drv.inputSrcs.begin(), drv.inputSrcs.end());
    foreach (DerivationInputs::const_iterator, i, drv.inputDrvs)
        references.insert(i-&gt;first);
    /* Note that the outputs of a derivation are *not* references
       (that can be missing (of course) and should not necessarily be
       held during a garbage collection). */
    string suffix = name + drvExtension;
    string contents = unparseDerivation(drv);
    return settings.readOnlyMode
        ? computeStorePathForText(suffix, contents, references)
        : store.addTextToStore(suffix, contents, references, repair);
}


static Path parsePath(std::istream &amp; str)
{
    string s = parseString(str);
    if (s.size() == 0 || s[0] != &apos;/&apos;)
        throw FormatError(format(&quot;bad path `%1%&apos; in derivation&quot;) % s);
    return s;
}


static StringSet parseStrings(std::istream &amp; str, bool arePaths)
{
    StringSet res;
    while (!endOfList(str))
        res.insert(arePaths ? parsePath(str) : parseString(str));
    return res;
}


static Derivation parseDerivation(const string &amp; s)
{
    Derivation drv;
    std::istringstream str(s);
    expect(str, &quot;Derive([&quot;);

    /* Parse the list of outputs. */
    while (!endOfList(str)) {
        DerivationOutput out;
        expect(str, &quot;(&quot;); string id = parseString(str);
        expect(str, &quot;,&quot;); out.path = parsePath(str);
        expect(str, &quot;