11721722785

Committed 07 Nov 2024 11:04AM UTC coverage: 63.873% (-0.8%) from 64.692%

Build # 11721722785

Build Type

Pull #14823

github

Committed by

web-flow

Commit Message

Merge f7c93f01b into 98ff55085

Pull Request Pull Request #14823: SVCB parser: allow quotes around port=

Run Details

36861 of 88708 branches covered (41.55%)

Branch coverage included in aggregate %.

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

1521 existing lines in 53 files now uncovered.

124282 of 163577 relevant lines covered (75.98%)

4510452.56 hits per line

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

32.8

/pdns/cdb.cc

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include "cdb.hh"

CDB::CDB(const string &cdbfile)
{
  d_fd = open(cdbfile.c_str(), O_RDONLY);
  if (d_fd < 0)
  {
    throw std::runtime_error("Failed to open cdb database file '"+cdbfile+"': " + stringerror());
  }

  memset(&d_cdbf,0,sizeof(struct cdb_find));
  int cdbinit = cdb_init(&d_cdb, d_fd);
  if (cdbinit < 0)
  {
    close(d_fd);
    d_fd = -1;
    throw std::runtime_error("Failed to initialize cdb structure for database '+cdbfile+': '" + std::to_string(cdbinit) + "'");
  }
}

CDB::~CDB() {
  cdb_free(&d_cdb);
  close(d_fd);
}

int CDB::searchKey(const string &key) {
  d_searchType = SearchKey;

  // A 'bug' in tinycdb (the lib used for reading the CDB files) means we have to copy the key because the cdb_find struct
  // keeps a pointer to it.
  d_key = key;
  return cdb_findinit(&d_cdbf, &d_cdb, d_key.c_str(), d_key.size());
}

bool CDB::searchSuffix(const string &key) {
  d_searchType = SearchSuffix;

  //See CDB::searchKey()
  d_key = key;

  // We are ok with a search on things, but we do want to know if a record with that key exists.........
  bool hasDomain = (cdb_find(&d_cdb, d_key.c_str(), d_key.size()) == 1);
  if (hasDomain) {
    cdb_seqinit(&d_seqPtr, &d_cdb);
  }

  return hasDomain;
}

void CDB::searchAll() {
  d_searchType = SearchAll;
  cdb_seqinit(&d_seqPtr, &d_cdb);
}

bool CDB::moveToNext() {
  int hasNext = 0;
  if (d_searchType == SearchKey) {
    hasNext = cdb_findnext(&d_cdbf);
  } else {
    hasNext = cdb_seqnext(&d_seqPtr, &d_cdb);
  }
  return (hasNext > 0);
}

bool CDB::readNext(pair<string, string> &value) {
  while (moveToNext()) {
    unsigned int pos;
    unsigned int len;

    pos = cdb_keypos(&d_cdb);
    len = cdb_keylen(&d_cdb);

    std::string key;
    key.resize(len);
    int ret = cdb_read(&d_cdb, &key[0], len, pos);
    if (ret < 0) {
      throw std::runtime_error("Error while reading key for key '" + key + "' from CDB database: " + std::to_string(ret));
    }

    if (d_searchType == SearchSuffix) {
      char *p = strstr(const_cast<char*>(key.c_str()), d_key.c_str());
      if (p == nullptr) {
        continue;
      }
    }

    pos = cdb_datapos(&d_cdb);
    len = cdb_datalen(&d_cdb);
    std::string val;
    val.resize(len);
    ret = cdb_read(&d_cdb, &val[0], len, pos);
    if (ret < 0) {
      throw std::runtime_error("Error while reading value for key '" + key + "' from CDB database: " + std::to_string(ret));
    }

    value = {std::move(key), std::move(val)};
    return true;
  }

  // We're done searching, so we can clean up d_key
  if (d_searchType != SearchAll) {
    d_key.clear();
  }

  return false;
}

vector<string> CDB::findall(string &key)
{
  vector<string> ret;
  struct cdb_find cdbf;

  int res = cdb_findinit(&cdbf, &d_cdb, key.c_str(), key.size());
  if (res < 0) {
    throw std::runtime_error("Error looking up key '" + key + "' from CDB database: " + std::to_string(res));
  }

  while(cdb_findnext(&cdbf) > 0) {
    unsigned int vpos = cdb_datapos(&d_cdb);
    unsigned int vlen = cdb_datalen(&d_cdb);
    std::string val;
    val.resize(vlen);
    res = cdb_read(&d_cdb, &val[0], vlen, vpos);
    if (res < 0) {
      throw std::runtime_error("Error while reading value for key '" + key + "' from CDB database: " + std::to_string(res));
    }
    ret.push_back(std::move(val));
  }

  return ret;
}

bool CDB::keyExists(const string& key)
{
  int ret = cdb_find(&d_cdb, key.c_str(), key.size());
  if (ret < 0) {
    throw std::runtime_error("Error while looking up key '" + key + "' from CDB database: " + std::to_string(ret));
  }
  if (ret == 0) {
    /* no such key */
    return false;
  }

  return true;
}

bool CDB::findOne(const string& key, string& value)
{
  if (!keyExists(key)) {
    return false;
  }

  unsigned int vpos = cdb_datapos(&d_cdb);
  unsigned int vlen = cdb_datalen(&d_cdb);
  value.resize(vlen);
  int ret = cdb_read(&d_cdb, &value[0], vlen, vpos);
  if (ret < 0) {
    throw std::runtime_error("Error while reading value for key '" + key + "' from CDB database: " + std::to_string(ret));
  }

  return true;
}

CDBWriter::CDBWriter(int fd): d_fd(fd)
{
  cdb_make_start(&d_cdbm, d_fd);
}

CDBWriter::~CDBWriter()
{
  close();
}

void CDBWriter::close()
{
  if (d_fd >= 0) {
    cdb_make_finish(&d_cdbm);
    ::close(d_fd);
    d_fd = -1;
  }
}

bool CDBWriter::addEntry(const std::string& key, const std::string& value)
{
  if (d_fd < 0) {
    throw std::runtime_error("Can't add an entry to a closed CDB database");
  }

  int ret = cdb_make_add(&d_cdbm, key.c_str(), key.size(), value.c_str(), value.size());
  if (ret != 0) {
    throw std::runtime_error("Error adding key '" + key + "' to CDB database: " + std::to_string(ret));
  }

  return true;
}

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	#ifdef HAVE_CONFIG_H
23	#include "config.h"
24	#endif
25
26	#include <sys/types.h>
27	#include <sys/stat.h>
28	#include <fcntl.h>
29	#include <unistd.h>
30
31	#include "cdb.hh"
32
33	CDB::CDB(const string &cdbfile)
34	{	6✔
35	d_fd = open(cdbfile.c_str(), O_RDONLY);	6✔
36	if (d_fd < 0)	6!
37	{	×
38	throw std::runtime_error("Failed to open cdb database file '"+cdbfile+"': " + stringerror());	×
39	}	×
40
41	memset(&d_cdbf,0,sizeof(struct cdb_find));	6✔
42	int cdbinit = cdb_init(&d_cdb, d_fd);	6✔
43	if (cdbinit < 0)	6!
44	{	×
45	close(d_fd);	×
46	d_fd = -1;	×
47	throw std::runtime_error("Failed to initialize cdb structure for database '+cdbfile+': '" + std::to_string(cdbinit) + "'");	×
48	}	×
49	}	6✔
50
51	CDB::~CDB() {	2✔
52	cdb_free(&d_cdb);	2✔
53	close(d_fd);	2✔
54	}	2✔
55
UNCOV 56	int CDB::searchKey(const string &key) {	×
UNCOV 57	d_searchType = SearchKey;	×
58
59	// A 'bug' in tinycdb (the lib used for reading the CDB files) means we have to copy the key because the cdb_find struct
60	// keeps a pointer to it.
UNCOV 61	d_key = key;	×
UNCOV 62	return cdb_findinit(&d_cdbf, &d_cdb, d_key.c_str(), d_key.size());	×
UNCOV 63	}	×
64
65	bool CDB::searchSuffix(const string &key) {	×
66	d_searchType = SearchSuffix;	×
67
68	//See CDB::searchKey()
69	d_key = key;	×
70
71	// We are ok with a search on things, but we do want to know if a record with that key exists.........
72	bool hasDomain = (cdb_find(&d_cdb, d_key.c_str(), d_key.size()) == 1);	×
73	if (hasDomain) {	×
74	cdb_seqinit(&d_seqPtr, &d_cdb);	×
75	}	×
76
77	return hasDomain;	×
78	}	×
79
UNCOV 80	void CDB::searchAll() {	×
UNCOV 81	d_searchType = SearchAll;	×
UNCOV 82	cdb_seqinit(&d_seqPtr, &d_cdb);	×
UNCOV 83	}	×
84
UNCOV 85	bool CDB::moveToNext() {	×
UNCOV 86	int hasNext = 0;	×
UNCOV 87	if (d_searchType == SearchKey) {	×
UNCOV 88	hasNext = cdb_findnext(&d_cdbf);	×
UNCOV 89	} else {	×
UNCOV 90	hasNext = cdb_seqnext(&d_seqPtr, &d_cdb);	×
UNCOV 91	}	×
UNCOV 92	return (hasNext > 0);	×
UNCOV 93	}	×
94
UNCOV 95	bool CDB::readNext(pair<string, string> &value) {	×
UNCOV 96	while (moveToNext()) {	×
UNCOV 97	unsigned int pos;	×
UNCOV 98	unsigned int len;	×
99
UNCOV 100	pos = cdb_keypos(&d_cdb);	×
UNCOV 101	len = cdb_keylen(&d_cdb);	×
102
UNCOV 103	std::string key;	×
UNCOV 104	key.resize(len);	×
UNCOV 105	int ret = cdb_read(&d_cdb, &key[0], len, pos);	×
UNCOV 106	if (ret < 0) {	×
107	throw std::runtime_error("Error while reading key for key '" + key + "' from CDB database: " + std::to_string(ret));	×
108	}	×
109
UNCOV 110	if (d_searchType == SearchSuffix) {	×
111	char p = strstr(const_cast<char>(key.c_str()), d_key.c_str());	×
112	if (p == nullptr) {	×
113	continue;	×
114	}	×
115	}	×
116
UNCOV 117	pos = cdb_datapos(&d_cdb);	×
UNCOV 118	len = cdb_datalen(&d_cdb);	×
UNCOV 119	std::string val;	×
UNCOV 120	val.resize(len);	×
UNCOV 121	ret = cdb_read(&d_cdb, &val[0], len, pos);	×
UNCOV 122	if (ret < 0) {	×
123	throw std::runtime_error("Error while reading value for key '" + key + "' from CDB database: " + std::to_string(ret));	×
124	}	×
125
UNCOV 126	value = {std::move(key), std::move(val)};	×
UNCOV 127	return true;	×
UNCOV 128	}	×
129
130	// We're done searching, so we can clean up d_key
UNCOV 131	if (d_searchType != SearchAll) {	×
UNCOV 132	d_key.clear();	×
UNCOV 133	}	×
134
UNCOV 135	return false;	×
UNCOV 136	}	×
137
138	vector<string> CDB::findall(string &key)
139	{	×
140	vector<string> ret;	×
141	struct cdb_find cdbf;	×
142
143	int res = cdb_findinit(&cdbf, &d_cdb, key.c_str(), key.size());	×
144	if (res < 0) {	×
145	throw std::runtime_error("Error looking up key '" + key + "' from CDB database: " + std::to_string(res));	×
146	}	×
147
148	while(cdb_findnext(&cdbf) > 0) {	×
149	unsigned int vpos = cdb_datapos(&d_cdb);	×
150	unsigned int vlen = cdb_datalen(&d_cdb);	×
151	std::string val;	×
152	val.resize(vlen);	×
153	res = cdb_read(&d_cdb, &val[0], vlen, vpos);	×
154	if (res < 0) {	×
155	throw std::runtime_error("Error while reading value for key '" + key + "' from CDB database: " + std::to_string(res));	×
156	}	×
157	ret.push_back(std::move(val));	×
158	}	×
159
160	return ret;	×
161	}	×
162
163	bool CDB::keyExists(const string& key)
164	{	105✔
165	int ret = cdb_find(&d_cdb, key.c_str(), key.size());	105✔
166	if (ret < 0) {	105!
167	throw std::runtime_error("Error while looking up key '" + key + "' from CDB database: " + std::to_string(ret));	×
168	}	×
169	if (ret == 0) {	105✔
170	/* no such key */
171	return false;	68✔
172	}	68✔
173
174	return true;	37✔
175	}	105✔
176
177	bool CDB::findOne(const string& key, string& value)
178	{	102✔
179	if (!keyExists(key)) {	102✔
180	return false;	67✔
181	}	67✔
182
183	unsigned int vpos = cdb_datapos(&d_cdb);	35✔
184	unsigned int vlen = cdb_datalen(&d_cdb);	35✔
185	value.resize(vlen);	35✔
186	int ret = cdb_read(&d_cdb, &value[0], vlen, vpos);	35✔
187	if (ret < 0) {	35!
188	throw std::runtime_error("Error while reading value for key '" + key + "' from CDB database: " + std::to_string(ret));	×
189	}	×
190
191	return true;	35✔
192	}	35✔
193
194	CDBWriter::CDBWriter(int fd): d_fd(fd)
195	{	1✔
196	cdb_make_start(&d_cdbm, d_fd);	1✔
197	}	1✔
198
199	CDBWriter::~CDBWriter()
200	{	1✔
201	close();	1✔
202	}	1✔
203
204	void CDBWriter::close()
205	{	2✔
206	if (d_fd >= 0) {	2✔
207	cdb_make_finish(&d_cdbm);	1✔
208	::close(d_fd);	1✔
209	d_fd = -1;	1✔
210	}	1✔
211	}	2✔
212
213	bool CDBWriter::addEntry(const std::string& key, const std::string& value)
214	{	6✔
215	if (d_fd < 0) {	6!
216	throw std::runtime_error("Can't add an entry to a closed CDB database");	×
217	}	×
218
219	int ret = cdb_make_add(&d_cdbm, key.c_str(), key.size(), value.c_str(), value.size());	6✔
220	if (ret != 0) {	6!
221	throw std::runtime_error("Error adding key '" + key + "' to CDB database: " + std::to_string(ret));	×
222	}	×
223
224	return true;	6✔
225	}	6✔

PowerDNS / pdns / 11721722785

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