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

PowerDNS / pdns / 18688711478

21 Oct 2025 03:15PM UTC coverage: 73.0% (-0.008%) from 73.008%
18688711478

push

github

web-flow
Merge pull request #16307 from omoerbeek/print-features

rec: explicit disabling/enabling of tls-gnutls for full and least configs and packages

38258 of 63140 branches covered (60.59%)

Branch coverage included in aggregate %.

8 of 8 new or added lines in 1 file covered. (100.0%)

37 existing lines in 11 files now uncovered.

127438 of 163840 relevant lines covered (77.78%)

5645617.26 hits per line

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

65.55
/modules/gpgsqlbackend/spgsql.cc
1
/*
2
 * This file is part of PowerDNS or dnsdist.
3
 * Copyright -- PowerDNS.COM B.V. and its contributors
4
 *
5
 * This program is free software; you can redistribute it and/or modify
6
 * it under the terms of version 2 of the GNU General Public License as
7
 * published by the Free Software Foundation.
8
 *
9
 * In addition, for the avoidance of any doubt, permission is granted to
10
 * link this program with OpenSSL and to (re)distribute the binaries
11
 * produced as the result of such linking.
12
 *
13
 * This program is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 * GNU General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU General Public License
19
 * along with this program; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21
 */
22

23
#ifdef HAVE_CONFIG_H
24
#include "config.h"
25
#endif
26
#include <string>
27
#include "spgsql.hh"
28
#include <sys/time.h>
29
#include <iostream>
30
#include "pdns/logger.hh"
31
#include "pdns/dns.hh"
32
#include "pdns/namespaces.hh"
33
#include <algorithm>
34

35
class SPgSQLStatement : public SSqlStatement
36
{
37
public:
38
  SPgSQLStatement(const string& query, bool dolog, int nparams, SPgSQL* db, unsigned int nstatement)
39
  {
32,436✔
40
    d_query = query;
32,436✔
41
    d_dolog = dolog;
32,436✔
42
    d_parent = db;
32,436✔
43
    d_nparams = nparams;
32,436✔
44
    d_nstatement = nstatement;
32,436✔
45
  }
32,436✔
46

47
  SSqlStatement* bind(const string& name, bool value) override { return bind(name, string(value ? "t" : "f")); }
41,850✔
48
  SSqlStatement* bind(const string& name, int value) override { return bind(name, std::to_string(value)); }
43,561✔
49
  SSqlStatement* bind(const string& name, uint32_t value) override { return bind(name, std::to_string(value)); }
20,853✔
50
  SSqlStatement* bind(const string& name, long value) override { return bind(name, std::to_string(value)); }
9✔
51
  SSqlStatement* bind(const string& name, unsigned long value) override { return bind(name, std::to_string(value)); }
11✔
52
  SSqlStatement* bind(const string& name, long long value) override { return bind(name, std::to_string(value)); }
×
53
  SSqlStatement* bind(const string& name, unsigned long long value) override { return bind(name, std::to_string(value)); }
×
54
  SSqlStatement* bind(const string& /* name */, const std::string& value) override
55
  {
178,918✔
56
    prepareStatement();
178,918✔
57
    allocate();
178,918✔
58
    if (d_paridx >= d_nparams) {
178,918!
59
      releaseStatement();
×
60
      throw SSqlException("Attempt to bind more parameters than query has: " + d_query);
×
61
    }
×
62
    paramValues[d_paridx] = new char[value.size() + 1];
178,918✔
63
    memset(paramValues[d_paridx], 0, sizeof(char) * (value.size() + 1));
178,918✔
64
    value.copy(paramValues[d_paridx], value.size());
178,918✔
65
    paramLengths[d_paridx] = value.size();
178,918✔
66
    d_paridx++;
178,918✔
67
    return this;
178,918✔
68
  }
178,918✔
69
  SSqlStatement* bindNull(const string& /* name */) override
70
  {
20,789✔
71
    prepareStatement();
20,789✔
72
    d_paridx++;
20,789✔
73
    return this;
20,789✔
74
  } // these are set null in allocate()
20,789✔
75
  SSqlStatement* execute() override
76
  {
27,057✔
77
    prepareStatement();
27,057✔
78
    if (d_dolog) {
27,057!
79
      g_log << Logger::Warning << "Query " << ((long)(void*)this) << ": Statement: " << d_query << endl;
×
80
      if (d_paridx) {
×
81
        // Log message is similar, but not exactly the same as the postgres server log.
82
        std::stringstream log_message;
×
83
        log_message << "Query " << ((long)(void*)this) << ": Parameters: ";
×
84
        for (int i = 0; i < d_paridx; i++) {
×
85
          if (i != 0) {
×
86
            log_message << ", ";
×
87
          }
×
88
          log_message << "$" << (i + 1) << " = ";
×
89
          if (paramValues[i] == nullptr) {
×
90
            log_message << "NULL";
×
91
          }
×
92
          else {
×
93
            log_message << "'" << paramValues[i] << "'";
×
94
          }
×
95
        }
×
96
        g_log << Logger::Warning << log_message.str() << endl;
×
97
      }
×
98
      d_dtime.set();
×
99
    }
×
100
    if (!d_stmt.empty()) {
27,057!
101
      d_res_set = PQexecPrepared(d_db(), d_stmt.c_str(), d_nparams, paramValues, paramLengths, nullptr, 0);
27,057✔
102
    }
27,057✔
103
    else {
×
104
      d_res_set = PQexecParams(d_db(), d_query.c_str(), d_nparams, nullptr, paramValues, paramLengths, nullptr, 0);
×
105
    }
×
106
    ExecStatusType status = PQresultStatus(d_res_set);
27,057✔
107
    if (status != PGRES_COMMAND_OK && status != PGRES_TUPLES_OK && status != PGRES_NONFATAL_ERROR) {
27,057!
108
      string errmsg(PQresultErrorMessage(d_res_set));
×
109
      releaseStatement();
×
110
      throw SSqlException("Fatal error during query: " + d_query + string(": ") + errmsg);
×
111
    }
×
112
    d_cur_set = 0;
27,057✔
113
    if (d_dolog) {
27,057!
114
      auto diff = d_dtime.udiffNoReset();
×
115
      g_log << Logger::Warning << "Query " << ((long)(void*)this) << ": " << diff << " us to execute" << endl;
×
116
    }
×
117

118
    nextResult();
27,057✔
119
    return this;
27,057✔
120
  }
27,057✔
121

122
  void nextResult()
123
  {
29,350✔
124
    if (d_res_set == nullptr)
29,350✔
125
      return;
2,293✔
126
    if (d_cur_set >= PQntuples(d_res_set)) {
27,057✔
127
      PQclear(d_res_set);
24,764✔
128
      d_res_set = nullptr;
24,764✔
129
      return;
24,764✔
130
    }
24,764✔
131
    if (PQftype(d_res_set, 0) == 1790) { // REFCURSOR
2,293!
132
      g_log << Logger::Error << "Postgres query returned a REFCURSOR and we do not support those - see https://github.com/PowerDNS/pdns/pull/10259" << endl;
×
133
      PQclear(d_res_set);
×
134
      d_res_set = nullptr;
×
135
    }
×
136
    else {
2,293✔
137
      d_res = d_res_set;
2,293✔
138
      d_res_set = nullptr;
2,293✔
139
      d_resnum = PQntuples(d_res);
2,293✔
140
    }
2,293✔
141
  }
2,293✔
142

143
  bool hasNextRow() override
144
  {
48,962✔
145
    if (d_dolog && d_residx == d_resnum) {
48,962!
146
      g_log << Logger::Warning << "Query " << ((long)(void*)this) << ": " << d_dtime.udiff() << " us total to last row" << endl;
×
147
    }
×
148

149
    return d_residx < d_resnum;
48,962✔
150
  }
48,962✔
151

152
  SSqlStatement* nextRow(row_t& row) override
153
  {
44,212✔
154
    int i;
44,212✔
155
    row.clear();
44,212✔
156
    if (d_residx >= d_resnum || !d_res)
44,212!
157
      return this;
×
158
    row.reserve(PQnfields(d_res));
44,212✔
159
    for (i = 0; i < PQnfields(d_res); i++) {
435,550✔
160
      if (PQgetisnull(d_res, d_residx, i)) {
391,338✔
161
        row.emplace_back("");
45,748✔
162
      }
45,748✔
163
      else if (PQftype(d_res, i) == 16) { // BOOLEAN
345,590!
UNCOV
164
        char* val = PQgetvalue(d_res, d_residx, i);
×
UNCOV
165
        row.emplace_back(val[0] == 't' ? "1" : "0");
×
UNCOV
166
      }
×
167
      else {
345,590✔
168
        row.emplace_back(PQgetvalue(d_res, d_residx, i));
345,590✔
169
      }
345,590✔
170
    }
391,338✔
171
    d_residx++;
44,212✔
172
    if (d_residx >= d_resnum) {
44,212✔
173
      PQclear(d_res);
2,293✔
174
      d_res = nullptr;
2,293✔
175
      nextResult();
2,293✔
176
    }
2,293✔
177
    return this;
44,212✔
178
  }
44,212✔
179

180
  SSqlStatement* getResult(result_t& result) override
181
  {
668✔
182
    result.clear();
668✔
183
    if (d_res == nullptr)
668✔
184
      return this;
147✔
185
    result.reserve(d_resnum);
521✔
186
    row_t row;
521✔
187
    while (hasNextRow()) {
1,043✔
188
      nextRow(row);
522✔
189
      result.push_back(std::move(row));
522✔
190
    }
522✔
191
    return this;
521✔
192
  }
668✔
193

194
  SSqlStatement* reset() override
195
  {
59,221✔
196
    int i;
59,221✔
197
    if (d_res) {
59,221!
198
      PQclear(d_res);
×
199
    }
×
200
    if (d_res_set) {
59,221!
201
      PQclear(d_res_set);
×
202
    }
×
203
    d_res_set = nullptr;
59,221✔
204
    d_res = nullptr;
59,221✔
205
    d_paridx = d_residx = d_resnum = 0;
59,221✔
206
    if (paramValues) {
59,221✔
207
      for (i = 0; i < d_nparams; i++) {
226,759✔
208
        if (paramValues[i]) {
199,707✔
209
          delete[] paramValues[i];
178,918✔
210
        }
178,918✔
211
      }
199,707✔
212
    }
27,052✔
213
    delete[] paramValues;
59,221✔
214
    paramValues = nullptr;
59,221✔
215
    delete[] paramLengths;
59,221✔
216
    paramLengths = nullptr;
59,221✔
217
    return this;
59,221✔
218
  }
59,221✔
219

220
  const std::string& getQuery() override { return d_query; }
×
221

222
  ~SPgSQLStatement() override
223
  {
32,164✔
224
    releaseStatement();
32,164✔
225
  }
32,164✔
226

227
private:
228
  PGconn* d_db()
229
  {
33,740✔
230
    return d_parent->db();
33,740✔
231
  }
33,740✔
232

233
  void releaseStatement()
234
  {
32,164✔
235
    d_prepared = false;
32,164✔
236
    reset();
32,164✔
237
    if (!d_stmt.empty()) {
32,164✔
238
      string cmd = string("DEALLOCATE " + d_stmt);
3,340✔
239
      PGresult* res = PQexec(d_db(), cmd.c_str());
3,340✔
240
      PQclear(res);
3,340✔
241
      d_stmt.clear();
3,340✔
242
    }
3,340✔
243
  }
32,164✔
244

245
  void prepareStatement()
246
  {
226,764✔
247
    if (d_prepared)
226,764✔
248
      return;
223,421✔
249
    if (d_parent->usePrepared()) {
3,343!
250
      // prepare a statement; name must be unique per session (using d_nstatement to ensure this).
251
      this->d_stmt = string("stmt") + std::to_string(d_nstatement);
3,343✔
252
      PGresult* res = PQprepare(d_db(), d_stmt.c_str(), d_query.c_str(), d_nparams, nullptr);
3,343✔
253
      ExecStatusType status = PQresultStatus(res);
3,343✔
254
      string errmsg(PQresultErrorMessage(res));
3,343✔
255
      PQclear(res);
3,343✔
256
      if (status != PGRES_COMMAND_OK && status != PGRES_TUPLES_OK && status != PGRES_NONFATAL_ERROR) {
3,343!
257
        releaseStatement();
×
258
        throw SSqlException("Fatal error during prePQpreparepare: " + d_query + string(": ") + errmsg);
×
259
      }
×
260
    }
3,343✔
261
    paramValues = nullptr;
3,343✔
262
    paramLengths = nullptr;
3,343✔
263
    d_cur_set = d_paridx = d_residx = d_resnum = 0;
3,343✔
264
    d_res = nullptr;
3,343✔
265
    d_res_set = nullptr;
3,343✔
266
    d_prepared = true;
3,343✔
267
  }
3,343✔
268

269
  void allocate()
270
  {
178,918✔
271
    if (paramValues != nullptr)
178,918✔
272
      return;
151,866✔
273
    paramValues = new char*[d_nparams];
27,052✔
274
    paramLengths = new int[d_nparams];
27,052✔
275
    memset(paramValues, 0, sizeof(char*) * d_nparams);
27,052✔
276
    memset(paramLengths, 0, sizeof(int) * d_nparams);
27,052✔
277
  }
27,052✔
278

279
  string d_query;
280
  string d_stmt;
281
  SPgSQL* d_parent;
282
  PGresult* d_res_set{nullptr};
283
  PGresult* d_res{nullptr};
284
  bool d_dolog;
285
  DTime d_dtime; // only used if d_dolog is set
286
  bool d_prepared{false};
287
  int d_nparams;
288
  int d_paridx{0};
289
  char** paramValues{nullptr};
290
  int* paramLengths{nullptr};
291
  int d_residx{0};
292
  int d_resnum{0};
293
  int d_cur_set{0};
294
  unsigned int d_nstatement;
295
};
296

297
bool SPgSQL::s_dolog;
298

299
static string escapeForPQparam(const string& v)
300
{
477✔
301
  string ret = v;
477✔
302
  boost::replace_all(ret, "\\", "\\\\");
477✔
303
  boost::replace_all(ret, "'", "\\'");
477✔
304

305
  return string("'") + ret + string("'");
477✔
306
}
477✔
307

308
SPgSQL::SPgSQL(const string& database, const string& host, const string& port, const string& user,
309
               const string& password, const string& extra_connection_parameters, const bool use_prepared)
310
{
477✔
311
  d_db = nullptr;
477✔
312
  d_in_trx = false;
477✔
313
  d_connectstr = "";
477✔
314
  d_nstatements = 0;
477✔
315

316
  if (!database.empty())
477!
317
    d_connectstr += "dbname=" + escapeForPQparam(database);
477✔
318

319
  if (!user.empty())
477!
UNCOV
320
    d_connectstr += " user=" + escapeForPQparam(user);
×
321

322
  if (!host.empty())
477!
323
    d_connectstr += " host=" + escapeForPQparam(host);
×
324

325
  if (!port.empty())
477!
326
    d_connectstr += " port=" + escapeForPQparam(port);
×
327

328
  if (!extra_connection_parameters.empty())
477!
329
    d_connectstr += " " + extra_connection_parameters;
×
330

331
  d_connectlogstr = d_connectstr;
477✔
332

333
  if (!password.empty()) {
477!
334
    d_connectlogstr += " password=<HIDDEN>";
×
335
    d_connectstr += " password=" + escapeForPQparam(password);
×
336
  }
×
337

338
  d_use_prepared = use_prepared;
477✔
339

340
  d_db = PQconnectdb(d_connectstr.c_str());
477✔
341

342
  if (!d_db || PQstatus(d_db) == CONNECTION_BAD) {
477!
343
    try {
×
344
      throw sPerrorException("Unable to connect to database, connect string: " + d_connectlogstr);
×
345
    }
×
346
    catch (...) {
×
347
      if (d_db)
×
348
        PQfinish(d_db);
×
349
      d_db = 0;
×
350
      throw;
×
351
    }
×
352
  }
×
353
}
477✔
354

355
void SPgSQL::setLog(bool state)
356
{
477✔
357
  s_dolog = state;
477✔
358
}
477✔
359

360
SPgSQL::~SPgSQL()
361
{
473✔
362
  PQfinish(d_db);
473✔
363
}
473✔
364

365
SSqlException SPgSQL::sPerrorException(const string& reason)
366
{
×
367
  return SSqlException(reason + string(": ") + (d_db ? PQerrorMessage(d_db) : "no connection"));
×
368
}
×
369

370
void SPgSQL::execute(const string& query)
371
{
432✔
372
  PGresult* res = PQexec(d_db, query.c_str());
432✔
373
  ExecStatusType status = PQresultStatus(res);
432✔
374
  string errmsg(PQresultErrorMessage(res));
432✔
375
  PQclear(res);
432✔
376
  if (status != PGRES_COMMAND_OK && status != PGRES_TUPLES_OK && status != PGRES_NONFATAL_ERROR) {
432!
377
    throw sPerrorException("Fatal error during query: " + errmsg);
×
378
  }
×
379
}
432✔
380

381
std::unique_ptr<SSqlStatement> SPgSQL::prepare(const string& query, int nparams)
382
{
32,436✔
383
  d_nstatements++;
32,436✔
384
  return std::make_unique<SPgSQLStatement>(query, s_dolog, nparams, this, d_nstatements);
32,436✔
385
}
32,436✔
386

387
void SPgSQL::startTransaction()
388
{
221✔
389
  execute("begin");
221✔
390
  d_in_trx = true;
221✔
391
}
221✔
392

393
void SPgSQL::commit()
394
{
201✔
395
  execute("commit");
201✔
396
  d_in_trx = false;
201✔
397
}
201✔
398

399
void SPgSQL::rollback()
400
{
10✔
401
  execute("rollback");
10✔
402
  d_in_trx = false;
10✔
403
}
10✔
404

405
bool SPgSQL::isConnectionUsable()
406
{
3,722✔
407
  if (PQstatus(d_db) != CONNECTION_OK) {
3,722!
408
    return false;
×
409
  }
×
410

411
  bool usable = false;
3,722✔
412
  int sd = PQsocket(d_db);
3,722✔
413
  bool wasNonBlocking = isNonBlocking(sd);
3,722✔
414

415
  if (!wasNonBlocking) {
3,722!
416
    if (!setNonBlocking(sd)) {
×
417
      return usable;
×
418
    }
×
419
  }
×
420

421
  usable = isTCPSocketUsable(sd);
3,722✔
422

423
  if (!wasNonBlocking) {
3,722!
424
    if (!setBlocking(sd)) {
×
425
      usable = false;
×
426
    }
×
427
  }
×
428

429
  return usable;
3,722✔
430
}
3,722✔
431

432
void SPgSQL::reconnect()
433
{
×
434
  PQreset(d_db);
×
435
}
×
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc