#include "serialise.hh"
#include "util.hh"

#include <cstring>
#include <cerrno>


namespace nix {


BufferedSink::~BufferedSink()
{
    /* We can't call flush() here, because C++ for some insane reason
       doesn't allow you to call virtual methods from a destructor. */
    assert(!bufPos);
    delete[] buffer;
}

    
void BufferedSink::operator () (const unsigned char * data, size_t len)
{
    if (!buffer) buffer = new unsigned char[bufSize];
    
    while (len) {
        /* Optimisation: bypass the buffer if the data exceeds the
           buffer size. */
        if (bufPos + len >= bufSize) {
            flush();
            write(data, len);
            break;
        }
        /* Otherwise, copy the bytes to the buffer.  Flush the buffer
           when it's full. */
        size_t n = bufPos + len > bufSize ? bufSize - bufPos : len;
        memcpy(buffer + bufPos, data, n);
        data += n; bufPos += n; len -= n;
        if (bufPos == bufSize) flush();
    }
}


void BufferedSink::flush()
{
    if (bufPos == 0) return;
    size_t n = bufPos;
    bufPos = 0; // don't trigger the assert() in ~BufferedSink()
    write(buffer, n);
}


FdSink::~FdSink()
{
    try { flush(); } catch (...) { ignoreException(); }
}


size_t threshold = 256 * 1024 * 1024;

static void warnLargeDump()
{
    printMsg(lvlError, "warning: dumping very large path (> 256 MiB); this may run out of memory");
}


void FdSink::write(const unsigned char * data, size_t len)
{
    static bool warned = false;
    if (warn && !warned) {
        written += len;
        if (written > threshold) {
            warnLargeDump();
            warned = true;
        }
    }
    writeFull(fd, data, len);
}


void Source::operator () (unsigned char * data, size_t len)
{
    while (len) {
        size_t n = read(data, len);
        data += n; len -= n;
    }
}


BufferedSource::~BufferedSource()
{
    delete[] buffer;
}


size_t BufferedSource::read(unsigned char * data,<pre>
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2021 Oleg Pykhalov &lt;go.wigust@gmail.com&gt;
;;; Copyright © 2023 Justin Veilleux &lt;terramorpha@cock.li&gt;
;;;
;;; 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 &lt;http://www.gnu.org/licenses/&gt;.

(define-module (gnu services syncthing)
  #:use-module (gnu packages syncthing)
  #:use-module (gnu services)
  #:use-module (gnu services shepherd)
  #:use-module (guix gexp)
  #:use-module (guix records)
  #:use-module (ice-9 match)
  #:use-module (srfi srfi-1)
  #:export (syncthing-configuration
            syncthing-configuration?
            syncthing-service-type))

;;; Commentary:
;;;
;;; This module provides a service definition for the syncthing service.
;;;
;;; Code:

(define-record-type* &lt;syncthing-configuration&gt;
  syncthing-configuration make-syncthing-configuration
  syncthing-configuration?
  (syncthing syncthing-configuration-syncthing ;file-like
             (default syncthing))
  (arguments syncthing-configuration-arguments ;list of strings
             (default &apos;()))
  (logflags  syncthing-configuration-logflags  ;number
             (default 0))
  (user      syncthing-configuration-user      ;string
             (default #f))
  (group     syncthing-configuration-group     ;string
             (default &quot;users&quot;))
  (home      syncthing-configuration-home      ;string
             (default #f))
  (home-service? syncthing-configuration-home-service?
                 (default for-home?) (innate)))

(define syncthing-shepherd-service
  (match-record-lambda &lt;syncthing-configuration&gt;
      (syncthing arguments logflags user group home home-service?)
    (list
     (shepherd-service
      (provision (if home-service?
                     &apos;(syncthing)
                     (list (string-&gt;symbol
                            (string-append &quot;syncthing-&quot; user)))))
      (documentation &quot;Run syncthing.&quot;)
      (requirement (if home-service? &apos;() &apos;(loopback user-processes)))
      (start #~(make-forkexec-constructor
                (append (list (string-append #$syncthing &quot;/bin/syncthing&quot;)
                              &quot;--no-browser&quot;
                              &quot;--no-restart&quot;
                              (string-append &quot;--logflags=&quot; (number-&gt;string #$logflags)))
                        &apos;#$arguments)
                #:user #$(and (not home-service?) user)
                #:group #$(and (not home-service?) group)
                #:environment-variables
                (append
                 (list
                  (string-append &quot;HOME=&quot;
                                 (or #$home
                                     (passwd:dir
                                      (getpw (if (and #$home-service?
                                                      (not #$user))
                                                 (getuid)
                                                 #$user)))))
                              &quot;SSL_CERT_DIR=/etc/ssl/certs&quot;
                              &quot;SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt&quot;)
                        (filter (negate       ;XXX: &apos;remove&apos; is not in (guile)
                                 (lambda (str)
                                   (or (string-prefix? &quot;HOME=&quot; str)
                                       (string-prefix? &quot;SSL_CERT_DIR=&quot; str)
                                       (string-prefix? &quot;SSL_CERT_FILE=&quot; str))))
                                (environ)))))
      (respawn? #f)
      (stop #~(make-kill-destructor))))))

(define syncthing-service-type
  (service-type (name &apos;syncthing)
                (extensions (list (service-extension shepherd-root-service-type