• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

IJHack / QtPass / 43948445342

16 Nov 2026 08:18PM UTC coverage: 96.411% (-0.002%) from 96.413%
43948445342

push

github

web-flow
OTP: say why a configuration gives no code (#2233)

A refused OTP configuration showed "No OTP code found in this password
entry" in the panel and when copying, and "Invalid OTP secret" in the
edit dialog, leaving the user to guess whether the kind (HOTP), the
algorithm, the link or the secret was wrong. Totp::parse() now reports a
Refusal through an optional out-parameter, and Totp::describe() gives
one sentence for each: counter-based (HOTP), an unsupported algorithm,
an otpauth:// link it cannot read (or for another host), not a TOTP
secret or link (an otpauth-migration:// export), or a missing or
invalid secret, or too long. The panel's OTP row, the dialog's warning
tooltip and the copy message use it; the old texts stay for an entry
without any configuration. Six new strings await the next lupdate batch.

Signed-off-by: Anne Jan Brouwer <brouwer@annejan.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

36 of 36 new or added lines in 4 files covered. (100.0%)

1 existing line in 1 file now uncovered.

8918 of 9250 relevant lines covered (96.41%)

732.99 hits per line

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

92.37
/src/nativegrep.cpp
1
// SPDX-FileCopyrightText: 2026 Anne Jan Brouwer
2
// SPDX-License-Identifier: GPL-3.0-or-later
3
/**
4
 * @file
5
 * @brief Implements NativeGrep: the store walk, the per-file gpg runs and the
6
 * hand-over of results from the worker thread.
7
 */
8
#include "nativegrep.h"
9
#include "executor.h"
10
#include "pass.h"
11
#include "util.h"
12
#include <QDir>
13
#include <QElapsedTimer>
14
#include <QPointer>
15
#include <QProcess>
16
#include <QRegularExpression>
17
#include <QStringTokenizer>
18
#include <QThread>
19
#include <utility>
20

21
NativeGrep::NativeGrep(QObject *parent) : QObject(parent) {}
241 ✔
22

23
NativeGrep::~NativeGrep() {
241 ✔
24
  static constexpr int kThreadTimeoutMs = 5000;
25
  cancel();
241 ✔
26
  QElapsedTimer elapsed;
241 ✔
27
  elapsed.start();
241 ✔
28
  for (const Worker &w : std::as_const(m_workers)) {
241 ✔
UNCOV
29
    if (w.thread && w.thread->isRunning()) {
×
30
      const int remaining =
31
          kThreadTimeoutMs - static_cast<int>(elapsed.elapsed());
×
32
      if (remaining > 0)
×
33
        w.thread->wait(remaining);
×
34
    }
35
  }
36
}
241 ✔
37

38
/**
39
 * @brief Decrypt one .gpg file and return lines matching rx.
40
 */
41
auto NativeGrep::matchFile(const QProcessEnvironment &env,
426 ✔
42
                           const QString &gpgExe, const QString &filePath,
43
                           const QRegularExpression &rx,
44
                           const std::atomic_bool *cancel) -> QStringList {
45
  const QString translatedPath =
46
      Executor::translatePathForWsl(filePath, gpgExe);
426 ✔
47
  QString plaintext;
426 ✔
48
  // The QProcess overload is the one that takes the cancel flag; it polls
49
  // the flag while waiting and terminates (then kills) gpg from this thread,
50
  // the one that owns the process.
51
  QProcess gpg;
426 ✔
52
  gpg.setProcessEnvironment(env);
426 ✔
53
  const int rc = Executor::executeBlocking(
426 ✔
54
      gpg, gpgExe,
55
      QStringList{"-d", "--quiet", "--yes", "--no-encrypt-to", "--batch",
426 ✔
56
                  "--use-agent"} +
5,964 ✔
57
          Pass::maxOutputArgs() + QStringList{translatedPath},
2,130 ✔
58
      QString(), &plaintext, nullptr, cancel);
426 ✔
59
  if (rc != 0 || plaintext.isEmpty())
426 ✔
60
    return {};
44 ✔
61
  // Line by line over the text, never a list of every line (a compressed
62
  // entry can expand into tens of millions), and a bounded number taken.
63
  QStringList matches;
382 ✔
64
  for (QStringView line : QStringView(plaintext).tokenize(u'\n')) {
60,904 ✔
65
    if (line.endsWith(u'\r'))
66
      line.chop(1);
67
    const QStringView t = line.trimmed();
68
    if (t.isEmpty())
60,623 ✔
69
      continue;
60,519 ✔
70
    const QRegularExpressionMatch m = rx.matchView(line);
30,255 ✔
71
    if (!m.hasMatch())
30,255 ✔
72
      continue;
6 ✔
73
    if (matches.size() == kMaxMatchesPerEntry) {
30,249 ✔
74
      matches << QString(); // isMoreMarker(): not a match, not counted
101 ✔
75
      break;
76
    }
77
    if (t.size() <= kMaxPreviewLength) {
30,148 ✔
78
      matches << t.toString();
30,145 ✔
79
      continue;
30,145 ✔
80
    }
81
    // A window of the line that holds the match, a little context before
82
    // it; "…" marks what was left out on either side.
83
    const qsizetype at =
84
        qMax<qsizetype>(0, m.capturedStart() - (t.data() - line.data()));
3 ✔
85
    qsizetype start = qBound<qsizetype>(0, at - kMaxPreviewLength / 4,
3 ✔
86
                                        t.size() - kMaxPreviewLength);
3 ✔
87
    qsizetype end = start + kMaxPreviewLength;
3 ✔
88
    // Never half a surrogate pair (an emoji, CJK Extension B) at either
89
    // edge: the window takes the whole character.
90
    if (start > 0 && t[start].isLowSurrogate())
3 ✔
91
      --start;
1 ✔
92
    if (end < t.size() && t[end - 1].isHighSurrogate())
3 ✔
93
      ++end;
1 ✔
94
    QString preview = t.sliced(start, end - start).toString();
3 ✔
95
    if (start > 0)
3 ✔
96
      preview.prepend(QChar(0x2026));
2 ✔
97
    if (end < t.size())
3 ✔
98
      preview.append(QChar(0x2026));
3 ✔
99
    matches << preview;
100
  }
30,255 ✔
101
  return matches;
102
}
426 ✔
103

104
/**
105
 * @brief Walk the store, decrypt every .gpg file, collect matches.
106
 */
107
auto NativeGrep::scanStore(const QProcessEnvironment &env,
19 ✔
108
                           const QString &gpgExe, const QString &storeDir,
109
                           const QRegularExpression &rx,
110
                           const std::atomic_bool *cancel)
111
    -> QList<QPair<QString, QStringList>> {
112
  QList<QPair<QString, QStringList>> results;
19 ✔
113
  int total = 0; // matching lines, the markers not counted
114
  // Regular files only: a link or junction is not an entry, and searching
115
  // through one would decrypt files outside the store.
116
  const QStringList files =
117
      Util::regularFilesUnder(storeDir, QStringList() << "*.gpg");
57 ✔
118
  for (const QString &filePath : files) {
440 ✔
119
    if (QThread::currentThread()->isInterruptionRequested() ||
430 ✔
120
        (cancel != nullptr && cancel->load()))
78 ✔
121
      return {};
7 ✔
122
    if (total == kMaxMatches) {
423 ✔
123
      // The budget is spent and entries remain: the search stopped here.
124
      results.append({QString(), {}});
4 ✔
125
      break;
2 ✔
126
    }
127
    QStringList matches = matchFile(env, gpgExe, filePath, rx, cancel);
421 ✔
128
    if (matches.isEmpty())
421 ✔
129
      continue;
130
    const bool more = isMoreMarker(matches.constLast());
131
    if (more)
378 ✔
132
      matches.removeLast();
100 ✔
133
    // The store-wide budget: what still fits, and a marker when that cut
134
    // the entry short.
135
    const int room = kMaxMatches - total;
378 ✔
136
    if (matches.size() > room) {
378 ✔
137
      matches = matches.mid(0, room);
1 ✔
138
      matches << QString();
2 ✔
139
    } else if (more) {
377 ✔
140
      matches << QString();
200 ✔
141
    }
142
    total += static_cast<int>(matches.size()) -
378 ✔
143
             (isMoreMarker(matches.constLast()) ? 1 : 0);
378 ✔
144
    QString entry = QDir(storeDir).relativeFilePath(filePath);
378 ✔
145
    if (entry.endsWith(QLatin1String(".gpg")))
378 ✔
146
      entry.chop(4);
378 ✔
147
    results.append({entry, matches});
378 ✔
148
  }
149
  return results;
150
}
151

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

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

169
  // Use trimmed() rather than isEmpty(): a whitespace-only string is a valid
170
  // regex that matches every non-empty line, which is almost never intentional
171
  // and would decrypt the entire store.
172
  //
173
  // Both early returns post finished() via Qt::QueuedConnection so that the
174
  // signal is always delivered asynchronously after search() returns, matching
175
  // the contract of the threaded path.
176
  if (pattern.trimmed().isEmpty()) {
16 ✔
177
    QMetaObject::invokeMethod(
×
178
        this,
179
        [this, seq]() {
×
180
          if (m_seq == seq)
×
181
            emit finished({});
×
182
        },
×
183
        Qt::QueuedConnection);
184
    return;
1 ✔
185
  }
186

187
  const QRegularExpression rx(
188
      pattern, caseInsensitive ? QRegularExpression::CaseInsensitiveOption
189
                               : QRegularExpression::PatternOptions{});
16 ✔
190
  if (!rx.isValid()) {
16 ✔
191
    QMetaObject::invokeMethod(
1 ✔
192
        this,
193
        [this, seq]() {
1 ✔
194
          if (m_seq == seq)
1 ✔
195
            emit finished({});
2 ✔
196
        },
1 ✔
197
        Qt::QueuedConnection);
198
    return;
199
  }
200
  QPointer<NativeGrep> self(this);
201

202
  auto emitResults = [self, seq](QList<QPair<QString, QStringList>> results) {
30 ✔
203
    if (!self)
15 ✔
204
      return;
205
    QMetaObject::invokeMethod(
15 ✔
206
        self,
207
        [self, seq, results = std::move(results)]() {
45 ✔
208
          if (self && self->m_seq == seq)
30 ✔
209
            emit self->finished(results);
15 ✔
210
        },
15 ✔
211
        Qt::QueuedConnection);
212
  };
15 ✔
213

214
  auto cancelFlag = std::make_shared<std::atomic_bool>(false);
15 ✔
215
  QThread *thread = QThread::create([gpgExe, storeDir, env, rx, cancelFlag,
30 ✔
216
                                     emitResults = std::move(emitResults)]() {
217
    std::move(emitResults)(
15 ✔
218
        scanStore(env, gpgExe, storeDir, rx, cancelFlag.get()));
15 ✔
219
  });
15 ✔
220

221
  m_workers.append({thread, cancelFlag});
30 ✔
222
  connect(thread, &QThread::finished, thread, &QObject::deleteLater);
15 ✔
223
  connect(thread, &QThread::finished, this, [this, thread]() {
15 ✔
224
    m_workers.removeIf(
15 ✔
225
        [thread](const Worker &w) { return w.thread == thread; });
16 ✔
226
  });
227
  thread->start();
15 ✔
228
}
31 ✔
229

230
void NativeGrep::cancel() {
546 ✔
231
  for (const Worker &w : std::as_const(m_workers)) {
555 ✔
232
    w.cancel->store(true);
233
    if (w.thread && w.thread->isRunning())
9 ✔
234
      w.thread->requestInterruption();
8 ✔
235
  }
236
}
546 ✔
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc