40416601267

// SPDX-FileCopyrightText: 2026 Anne Jan Brouwer
// SPDX-License-Identifier: GPL-3.0-or-later
#include "nativegrep.h"
#include "executor.h"
#include "pass.h"
#include "util.h"
#include <QDir>
#include <QElapsedTimer>
#include <QPointer>
#include <QProcess>
#include <QRegularExpression>
#include <QThread>
#include <utility>

NativeGrep::NativeGrep(QObject *parent) : QObject(parent) {}

NativeGrep::~NativeGrep() {
  static constexpr int kThreadTimeoutMs = 5000;
  cancel();
  QElapsedTimer elapsed;
  elapsed.start();
  for (const Worker &w : std::as_const(m_workers)) {
    if (w.thread && w.thread->isRunning()) {
      const int remaining =
          kThreadTimeoutMs - static_cast<int>(elapsed.elapsed());
      if (remaining > 0)
        w.thread->wait(remaining);
    }
  }
}

/**
 * @brief Decrypt one .gpg file and return lines matching rx.
 */
auto NativeGrep::matchFile(const QProcessEnvironment &env,
                           const QString &gpgExe, const QString &filePath,
                           const QRegularExpression &rx,
                           const std::atomic_bool *cancel) -> QStringList {
  const QString translatedPath =
      Executor::translatePathForWsl(filePath, gpgExe);
  QString plaintext;
  // The QProcess overload is the one that takes the cancel flag; it polls
  // the flag while waiting and terminates (then kills) gpg from this thread,
  // the one that owns the process.
  QProcess gpg;
  gpg.setProcessEnvironment(env);
  const int rc = Executor::executeBlocking(
      gpg, gpgExe,
      QStringList{"-d", "--quiet", "--yes", "--no-encrypt-to", "--batch",
                  "--use-agent"} +
          Pass::maxOutputArgs() + QStringList{translatedPath},
      QString(), &plaintext, nullptr, cancel);
  if (rc != 0 || plaintext.isEmpty())
    return {};
  QStringList matches;
  for (const QString &line : plaintext.split('\n')) {
    QString candidate = line;
    if (candidate.endsWith('\r'))
      candidate.chop(1);
    const QString t = candidate.trimmed();
    if (!t.isEmpty() && candidate.contains(rx))
      matches << t;
  }
  return matches;
}

/**
 * @brief Walk the store, decrypt every .gpg file, collect matches.
 */
auto NativeGrep::scanStore(const QProcessEnvironment &env,
                           const QString &gpgExe, const QString &storeDir,
                           const QRegularExpression &rx,
                           const std::atomic_bool *cancel)
    -> QList<QPair<QString, QStringList>> {
  QList<QPair<QString, QStringList>> results;
  // Regular files only: a link or junction is not an entry, and searching
  // through one would decrypt files outside the store.
  const QStringList files =
      Util::regularFilesUnder(storeDir, QStringList() << "*.gpg");
  for (const QString &filePath : files) {
    if (QThread::currentThread()->isInterruptionRequested() ||
        (cancel != nullptr && cancel->load()))
      return {};
    const QStringList matches = matchFile(env, gpgExe, filePath, rx, cancel);
    if (!matches.isEmpty()) {
      QString entry = QDir(storeDir).relativeFilePath(filePath);
      if (entry.endsWith(QLatin1String(".gpg")))
        entry.chop(4);
      results.append({entry, matches});
    }
  }
  return results;
}

/**
 * @brief Start a search on a worker thread.
 *
 * Results are emitted on the owner's thread via QMetaObject::invokeMethod. A
 * sequence counter discards results from superseded searches; the previous
 * search is asked to stop but not waited for, since blocking the UI thread
 * while gpg decrypts would freeze the interface.
 */
void NativeGrep::search(const QString &pattern, bool caseInsensitive,
                        const QString &gpgExe, const QString &storeDir,
                        const QProcessEnvironment &env) {
  cancel();

  // Advance the sequence before any early return so in-flight workers from the
  // previous query fail the seq check and cannot publish stale results.
  const int seq = ++m_seq;

  // Use trimmed() rather than isEmpty(): a whitespace-only string is a valid
  // regex that matches every non-empty line, which is almost never intentional
  // and would decrypt the entire store.
  //
  // Both early returns post finished() via Qt::QueuedConnection so that the
  // signal is always delivered asynchronously after search() returns, matching
  // the contract of the threaded path.
  if (pattern.trimmed().isEmpty()) {
    QMetaObject::invokeMethod(
        this,
        [this, seq]() {
          if (m_seq == seq)
            emit finished({});
        },
        Qt::QueuedConnection);
    return;
  }

  const QRegularExpression rx(
      pattern, caseInsensitive ? QRegularExpression::CaseInsensitiveOption
                               : QRegularExpression::PatternOptions{});
  if (!rx.isValid()) {
    QMetaObject::invokeMethod(
        this,
        [this, seq]() {
          if (m_seq == seq)
            emit finished({});
        },
        Qt::QueuedConnection);
    return;
  }
  QPointer<NativeGrep> self(this);

  auto emitResults = [self, seq](QList<QPair<QString, QStringList>> results) {
    if (!self)
      return;
    QMetaObject::invokeMethod(
        self,
        [self, seq, results = std::move(results)]() {
          if (self && self->m_seq == seq)
            emit self->finished(results);
        },
        Qt::QueuedConnection);
  };

  auto cancelFlag = std::make_shared<std::atomic_bool>(false);
  QThread *thread = QThread::create([gpgExe, storeDir, env, rx, cancelFlag,
                                     emitResults = std::move(emitResults)]() {
    std::move(emitResults)(
        scanStore(env, gpgExe, storeDir, rx, cancelFlag.get()));
  });

  m_workers.append({thread, cancelFlag});
  connect(thread, &QThread::finished, thread, &QObject::deleteLater);
  connect(thread, &QThread::finished, this, [this, thread]() {
    m_workers.removeIf(
        [thread](const Worker &w) { return w.thread == thread; });
  });
  thread->start();
}

void NativeGrep::cancel() {
  for (const Worker &w : std::as_const(m_workers)) {
    w.cancel->store(true);
    if (w.thread && w.thread->isRunning())
      w.thread->requestInterruption();
  }
}

1	// SPDX-FileCopyrightText: 2026 Anne Jan Brouwer
2	// SPDX-License-Identifier: GPL-3.0-or-later
3	#include "nativegrep.h"
4	#include "executor.h"
5	#include "pass.h"
6	#include "util.h"
7	#include <QDir>
8	#include <QElapsedTimer>
9	#include <QPointer>
10	#include <QProcess>
11	#include <QRegularExpression>
12	#include <QThread>
13	#include <utility>
14
15	NativeGrep::NativeGrep(QObject *parent) : QObject(parent) {}	191 ✔
16
17	NativeGrep::~NativeGrep() {	191 ✔
18	static constexpr int kThreadTimeoutMs = 5000;
19	cancel();	191 ✔
20	QElapsedTimer elapsed;	191 ✔
21	elapsed.start();	191 ✔
22	for (const Worker &w : std::as_const(m_workers)) {	191 ✔
UNCOV 23	if (w.thread && w.thread->isRunning()) {	×
24	const int remaining =
25	kThreadTimeoutMs - static_cast<int>(elapsed.elapsed());	×
26	if (remaining > 0)	×
27	w.thread->wait(remaining);	×
28	}
29	}
30	}	191 ✔
31
32	/**
33	* @brief Decrypt one .gpg file and return lines matching rx.
34	*/
35	auto NativeGrep::matchFile(const QProcessEnvironment &env,	65 ✔
36	const QString &gpgExe, const QString &filePath,
37	const QRegularExpression &rx,
38	const std::atomic_bool *cancel) -> QStringList {
39	const QString translatedPath =
40	Executor::translatePathForWsl(filePath, gpgExe);	65 ✔
41	QString plaintext;	65 ✔
42	// The QProcess overload is the one that takes the cancel flag; it polls
43	// the flag while waiting and terminates (then kills) gpg from this thread,
44	// the one that owns the process.
45	QProcess gpg;	65 ✔
46	gpg.setProcessEnvironment(env);	65 ✔
47	const int rc = Executor::executeBlocking(	65 ✔
48	gpg, gpgExe,
49	QStringList{"-d", "--quiet", "--yes", "--no-encrypt-to", "--batch",	520 ✔
50	"--use-agent"} +	390 ✔
51	Pass::maxOutputArgs() + QStringList{translatedPath},	260 ✔
52	QString(), &plaintext, nullptr, cancel);	65 ✔
53	if (rc != 0 \|\| plaintext.isEmpty())	65 ✔
54	return {};	4 ✔
55	QStringList matches;	61 ✔
56	for (const QString &line : plaintext.split('\n')) {	196 ✔
57	QString candidate = line;
58	if (candidate.endsWith('\r'))	74 ✔
59	candidate.chop(1);	×
60	const QString t = candidate.trimmed();
61	if (!t.isEmpty() && candidate.contains(rx))	74 ✔
62	matches << t;
63	}
64	return matches;
65	}	130 ✔
66
67	/**
68	* @brief Walk the store, decrypt every .gpg file, collect matches.
69	*/
70	auto NativeGrep::scanStore(const QProcessEnvironment &env,	10 ✔
71	const QString &gpgExe, const QString &storeDir,
72	const QRegularExpression &rx,
73	const std::atomic_bool *cancel)
74	-> QList<QPair<QString, QStringList>> {
75	QList<QPair<QString, QStringList>> results;	10 ✔
76	// Regular files only: a link or junction is not an entry, and searching
77	// through one would decrypt files outside the store.
78	const QStringList files =
79	Util::regularFilesUnder(storeDir, QStringList() << "*.gpg");	30 ✔
80	for (const QString &filePath : files) {	74 ✔
81	if (QThread::currentThread()->isInterruptionRequested() \|\|	64 ✔
82	(cancel != nullptr && cancel->load()))	64 ✔
83	return {};	×
84	const QStringList matches = matchFile(env, gpgExe, filePath, rx, cancel);	64 ✔
85	if (!matches.isEmpty()) {	64 ✔
86	QString entry = QDir(storeDir).relativeFilePath(filePath);	61 ✔
87	if (entry.endsWith(QLatin1String(".gpg")))	61 ✔
88	entry.chop(4);	61 ✔
89	results.append({entry, matches});	61 ✔
90	}
91	}
92	return results;
93	}
94
95	/**
96	* @brief Start a search on a worker thread.
97	*
98	* Results are emitted on the owner's thread via QMetaObject::invokeMethod. A
99	* sequence counter discards results from superseded searches; the previous
100	* search is asked to stop but not waited for, since blocking the UI thread
101	* while gpg decrypts would freeze the interface.
102	*/
103	void NativeGrep::search(const QString &pattern, bool caseInsensitive,	10 ✔
104	const QString &gpgExe, const QString &storeDir,
105	const QProcessEnvironment &env) {
106	cancel();	10 ✔
107
108	// Advance the sequence before any early return so in-flight workers from the
109	// previous query fail the seq check and cannot publish stale results.
110	const int seq = ++m_seq;	10 ✔
111
112	// Use trimmed() rather than isEmpty(): a whitespace-only string is a valid
113	// regex that matches every non-empty line, which is almost never intentional
114	// and would decrypt the entire store.
115	//
116	// Both early returns post finished() via Qt::QueuedConnection so that the
117	// signal is always delivered asynchronously after search() returns, matching
118	// the contract of the threaded path.
119	if (pattern.trimmed().isEmpty()) {	10 ✔
120	QMetaObject::invokeMethod(	×
121	this,
122	[this, seq]() {	×
123	if (m_seq == seq)	×
124	emit finished({});	×
125	},	×
126	Qt::QueuedConnection);
127	return;	1 ✔
128	}
129
130	const QRegularExpression rx(
131	pattern, caseInsensitive ? QRegularExpression::CaseInsensitiveOption
132	: QRegularExpression::PatternOptions{});	20 ✔
133	if (!rx.isValid()) {	10 ✔
134	QMetaObject::invokeMethod(	1 ✔
135	this,
136	[this, seq]() {	1 ✔
137	if (m_seq == seq)	1 ✔
138	emit finished({});	2 ✔
139	},	1 ✔
140	Qt::QueuedConnection);
141	return;
142	}
143	QPointer<NativeGrep> self(this);
144
145	auto emitResults = [self, seq](QList<QPair<QString, QStringList>> results) {	18 ✔
146	if (!self)	9 ✔
147	return;
148	QMetaObject::invokeMethod(	9 ✔
149	self,
150	[self, seq, results = std::move(results)]() {	27 ✔
151	if (self && self->m_seq == seq)	18 ✔
152	emit self->finished(results);	9 ✔
153	},	9 ✔
154	Qt::QueuedConnection);
155	};	9 ✔
156
157	auto cancelFlag = std::make_shared<std::atomic_bool>(false);	9 ✔
158	QThread *thread = QThread::create([gpgExe, storeDir, env, rx, cancelFlag,	18 ✔
159	emitResults = std::move(emitResults)]() {
160	std::move(emitResults)(	9 ✔
161	scanStore(env, gpgExe, storeDir, rx, cancelFlag.get()));	9 ✔
162	});	9 ✔
163
164	m_workers.append({thread, cancelFlag});	18 ✔
165	connect(thread, &QThread::finished, thread, &QObject::deleteLater);	9 ✔
166	connect(thread, &QThread::finished, this, [this, thread]() {	9 ✔
167	m_workers.removeIf(	9 ✔
168	[thread](const Worker &w) { return w.thread == thread; });	9 ✔
169	});
170	thread->start();	9 ✔
171	}	19 ✔
172
173	void NativeGrep::cancel() {	392 ✔
174	for (const Worker &w : std::as_const(m_workers)) {	393 ✔
175	w.cancel->store(true);
176	if (w.thread && w.thread->isRunning())	1 ✔
177	w.thread->requestInterruption();	1 ✔
178	}
179	}	392 ✔

IJHack / QtPass / 40416601267

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous