use make_unique instead of new

Signed-off-by: Rosen Penev <[email protected]>

modules/bindbackend/bindbackend2.cc

@@ -224,7 +224,7 @@ bool Bind2Backend::startTransaction(const DNSName& qname, int id)
       return false;
     }
 
-    d_of = std::unique_ptr<ofstream>(new ofstream(d_transaction_tmpname.c_str()));
+    d_of = std::make_unique<ofstream>(d_transaction_tmpname);
     if (!*d_of) {
       unlink(d_transaction_tmpname.c_str());
       close(fd);

modules/geoipbackend/geoipinterface-dat.cc

@@ -476,7 +476,7 @@ unique_ptr<GeoIPInterface> GeoIPInterface::makeDATInterface(const string& fname,
   const auto& opt = opts.find("mode");
   if (opt != opts.end())
     mode = opt->second;
-  return unique_ptr<GeoIPInterface>(new GeoIPInterfaceDAT(fname, mode));
+  return std::make_unique<GeoIPInterfaceDAT>(fname, mode);
 }
 
 #else

modules/geoipbackend/geoipinterface-mmdb.cc

@@ -283,7 +283,7 @@ unique_ptr<GeoIPInterface> GeoIPInterface::makeMMDBInterface(const string& fname
   const auto& opt_lang = opts.find("language");
   if (opt_lang != opts.end())
     language = opt_lang->second;
-  return unique_ptr<GeoIPInterface>(new GeoIPInterfaceMMDB(fname, mode, language));
+  return std::make_unique<GeoIPInterfaceMMDB>(fname, mode, language);
 }
 
 #else

modules/gmysqlbackend/smysql.cc

@@ -552,7 +552,7 @@ SSqlException SMySQL::sPerrorException(const string& reason)
 
 std::unique_ptr<SSqlStatement> SMySQL::prepare(const string& query, int nparams)
 {
-  return std::unique_ptr<SSqlStatement>(new SMySQLStatement(query, s_dolog, nparams, &d_db));
+  return std::make_unique<SMySQLStatement>(query, s_dolog, nparams, &d_db);
 }
 
 void SMySQL::execute(const string& query)

modules/godbcbackend/sodbc.cc

@@ -479,7 +479,7 @@ SSqlException SODBC::sPerrorException(const std::string& reason)
 
 std::unique_ptr<SSqlStatement> SODBC::prepare(const string& query, int nparams)
 {
-  return std::unique_ptr<SSqlStatement>(new SODBCStatement(query, m_log, nparams, m_connection));
+  return std::make_unique<SODBCStatement>(query, m_log, nparams, m_connection);
 }
 
 void SODBC::startTransaction()

modules/gpgsqlbackend/spgsql.cc

@@ -375,7 +375,7 @@ void SPgSQL::execute(const string& query)
 std::unique_ptr<SSqlStatement> SPgSQL::prepare(const string& query, int nparams)
 {
   d_nstatements++;
-  return std::unique_ptr<SSqlStatement>(new SPgSQLStatement(query, s_dolog, nparams, this, d_nstatements));
+  return std::make_unique<SPgSQLStatement>(query, s_dolog, nparams, this, d_nstatements);
 }
 
 void SPgSQL::startTransaction()

modules/pipebackend/pipebackend.cc

@@ -66,10 +66,10 @@ void CoWrapper::launch()
     throw ArgException("pipe-command is not specified");
 
   if (isUnixSocket(d_command)) {
-    d_cp = std::unique_ptr<CoRemote>(new UnixRemote(d_command, d_timeout));
+    d_cp = std::make_unique<UnixRemote>(d_command, d_timeout);
   }
   else {
-    auto coprocess = std::unique_ptr<CoProcess>(new CoProcess(d_command, d_timeout));
+    auto coprocess = std::make_unique<CoProcess>(d_command, d_timeout);
     coprocess->launch();
     d_cp = std::move(coprocess);
   }
@@ -130,11 +130,11 @@ void PipeBackend::launch()
 
   try {
     if (!getArg("regex").empty()) {
-      d_regex = std::unique_ptr<Regex>(new Regex(getArg("regex")));
+      d_regex = std::make_unique<Regex>(getArg("regex"));
     }
     d_regexstr = getArg("regex");
     d_abiVersion = getArgAsNum("abi-version");
-    d_coproc = unique_ptr<CoWrapper>(new CoWrapper(getArg("command"), getArgAsNum("timeout"), getArgAsNum("abi-version")));
+    d_coproc = std::make_unique<CoWrapper>(getArg("command"), getArgAsNum("timeout"), getArgAsNum("abi-version"));
   }
 
   catch (const ArgException& A) {

modules/remotebackend/httpconnector.cc

@@ -385,7 +385,7 @@ int HTTPConnector::send_message(const Json& input)
 
     while (gAddrPtr) {
       try {
-        d_socket = std::unique_ptr<Socket>(new Socket(gAddrPtr->ai_family, gAddrPtr->ai_socktype, gAddrPtr->ai_protocol));
+        d_socket = std::make_unique<Socket>(gAddrPtr->ai_family, gAddrPtr->ai_socktype, gAddrPtr->ai_protocol);
         d_addr.setSockaddr(gAddrPtr->ai_addr, gAddrPtr->ai_addrlen);
         d_socket->connect(d_addr);
         d_socket->setNonBlocking();

modules/remotebackend/remotebackend.cc

@@ -165,20 +165,20 @@ int RemoteBackend::build()
 
   // connectors know what they are doing
   if (type == "unix") {
-    this->connector = std::unique_ptr<Connector>(new UnixsocketConnector(options));
+    this->connector = std::make_unique<UnixsocketConnector>(options);
   }
   else if (type == "http") {
-    this->connector = std::unique_ptr<Connector>(new HTTPConnector(options));
+    this->connector = std::make_unique<HTTPConnector>(options);
   }
   else if (type == "zeromq") {
 #ifdef REMOTEBACKEND_ZEROMQ
-    this->connector = std::unique_ptr<Connector>(new ZeroMQConnector(options));
+    this->connector = std::make_unique<ZeroMQConnector>(options);
 #else
     throw PDNSException("Invalid connection string: zeromq connector support not enabled. Recompile with --enable-remotebackend-zeromq");
 #endif
   }
   else if (type == "pipe") {
-    this->connector = std::unique_ptr<Connector>(new PipeConnector(options));
+    this->connector = std::make_unique<PipeConnector>(options);
   }
   else {
     throw PDNSException("Invalid connection string: unknown connector");

modules/tinydnsbackend/tinydnsbackend.cc

@@ -58,7 +58,7 @@ vector<string> TinyDNSBackend::getLocations()
   for (int i = 4; i >= 0; i--) {
     string searchkey(key, i + 2);
     try {
-      auto reader = std::unique_ptr<CDB>(new CDB(getArg("dbfile")));
+      auto reader = std::make_unique<CDB>(getArg("dbfile"));
       ret = reader->findall(searchkey);
     }
     catch (const std::exception& e) {
@@ -158,7 +158,7 @@ void TinyDNSBackend::getAllDomains(vector<DomainInfo>* domains, bool getSerial,
   d_dnspacket = NULL;
 
   try {
-    d_cdbReader = std::unique_ptr<CDB>(new CDB(getArg("dbfile")));
+    d_cdbReader = std::make_unique<CDB>(getArg("dbfile"));
   }
   catch (const std::exception& e) {
     g_log << Logger::Error << e.what() << endl;
@@ -201,7 +201,7 @@ bool TinyDNSBackend::list(const DNSName& target, int domain_id, bool include_dis
   d_isGetDomains = false;
   string key = target.toDNSStringLC();
   try {
-    d_cdbReader = std::unique_ptr<CDB>(new CDB(getArg("dbfile")));
+    d_cdbReader = std::make_unique<CDB>(getArg("dbfile"));
   }
   catch (const std::exception& e) {
     g_log << Logger::Error << e.what() << endl;
@@ -231,7 +231,7 @@ void TinyDNSBackend::lookup(const QType& qtype, const DNSName& qdomain, int zone
   d_qtype = qtype;
 
   try {
-    d_cdbReader = std::unique_ptr<CDB>(new CDB(getArg("dbfile")));
+    d_cdbReader = std::make_unique<CDB>(getArg("dbfile"));
   }
   catch (const std::exception& e) {
     g_log << Logger::Error << e.what() << endl;

pdns/comfun.cc

@@ -429,7 +429,7 @@ try
   }
   else if(mode=="scan-ns") {
     ifstream ns(string(argv[2])+".nameservers");
-    g_powerdns = std::unique_ptr<ofstream>(new ofstream(string(argv[2])+".powerdns"));
+    g_powerdns = std::make_unique<std::ofstream>(string(argv[2]) + ".powerdns");
     string line;
     int count=0;
     vector<string> parts;

pdns/common_startup.cc

@@ -647,7 +647,7 @@ void mainthread()
   Utility::dropUserPrivs(newuid);
 
   if(::arg().mustDo("resolver")){
-    DP=std::unique_ptr<DNSProxy>(new DNSProxy(::arg()["resolver"]));
+    DP = std::make_unique<DNSProxy>(::arg()["resolver"]);
     DP->go();
   }
 

pdns/dbdnsseckeeper.cc

@@ -741,7 +741,7 @@ bool DNSSECKeeper::rectifyZone(const DNSName& zone, string& error, string& info,
     }
     // We don't have a *full* Ueberbackend, just a key-only one.
     // Let's create one and use it
-    b = std::unique_ptr<UeberBackend>(new UeberBackend());
+    b = std::make_unique<UeberBackend>();
     B = b.get();
   }
 

pdns/dnsdist-lua.cc

@@ -700,8 +700,8 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
         }
 
         // only works pre-startup, so no sync necessary
-        g_frontends.push_back(std::unique_ptr<ClientState>(new ClientState(loc, false, reusePort, tcpFastOpenQueueSize, interface, cpus)));
-        auto tcpCS = std::unique_ptr<ClientState>(new ClientState(loc, true, reusePort, tcpFastOpenQueueSize, interface, cpus));
+        g_frontends.push_back(std::make_unique<ClientState>(loc, false, reusePort, tcpFastOpenQueueSize, interface, cpus));
+        auto tcpCS = std::make_unique<ClientState>(loc, true, reusePort, tcpFastOpenQueueSize, interface, cpus);
         if (tcpListenQueueSize > 0) {
           tcpCS->tcpListenQueueSize = tcpListenQueueSize;
         }
@@ -740,8 +740,8 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
       try {
 	ComboAddress loc(addr, 53);
         // only works pre-startup, so no sync necessary
-        g_frontends.push_back(std::unique_ptr<ClientState>(new ClientState(loc, false, reusePort, tcpFastOpenQueueSize, interface, cpus)));
-        auto tcpCS = std::unique_ptr<ClientState>(new ClientState(loc, true, reusePort, tcpFastOpenQueueSize, interface, cpus));
+        g_frontends.push_back(std::make_unique<ClientState>(loc, false, reusePort, tcpFastOpenQueueSize, interface, cpus));
+        auto tcpCS = std::make_unique<ClientState>(loc, true, reusePort, tcpFastOpenQueueSize, interface, cpus);
         if (tcpListenQueueSize > 0) {
           tcpCS->tcpListenQueueSize = tcpListenQueueSize;
         }
@@ -1517,13 +1517,13 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
         auto ctx = std::make_shared<DNSCryptContext>(providerName, certKeys);
 
         /* UDP */
-        auto cs = std::unique_ptr<ClientState>(new ClientState(ComboAddress(addr, 443), false, reusePort, tcpFastOpenQueueSize, interface, cpus));
+        auto cs = std::make_unique<ClientState>(ComboAddress(addr, 443), false, reusePort, tcpFastOpenQueueSize, interface, cpus);
         cs->dnscryptCtx = ctx;
         g_dnsCryptLocals.push_back(ctx);
         g_frontends.push_back(std::move(cs));
 
         /* TCP */
-        cs = std::unique_ptr<ClientState>(new ClientState(ComboAddress(addr, 443), true, reusePort, tcpFastOpenQueueSize, interface, cpus));
+        cs = std::make_unique<ClientState>(ComboAddress(addr, 443), true, reusePort, tcpFastOpenQueueSize, interface, cpus);
         cs->dnscryptCtx = ctx;
         if (tcpListenQueueSize > 0) {
           cs->tcpListenQueueSize = tcpListenQueueSize;
@@ -2335,7 +2335,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
       parseTLSConfig(frontend->d_tlsConfig, "addDOHLocal", vars);
     }
     g_dohlocals.push_back(frontend);
-    auto cs = std::unique_ptr<ClientState>(new ClientState(frontend->d_local, true, reusePort, tcpFastOpenQueueSize, interface, cpus));
+    auto cs = std::make_unique<ClientState>(frontend->d_local, true, reusePort, tcpFastOpenQueueSize, interface, cpus);
     cs->dohFrontend = frontend;
     if (tcpListenQueueSize > 0) {
       cs->tcpListenQueueSize = tcpListenQueueSize;
@@ -2527,7 +2527,7 @@ ::vector<std::pair<int,std::string>>> keyFiles) {
 #endif
           }
           // only works pre-startup, so no sync necessary
-          auto cs = std::unique_ptr<ClientState>(new ClientState(frontend->d_addr, true, reusePort, tcpFastOpenQueueSize, interface, cpus));
+          auto cs = std::make_unique<ClientState>(frontend->d_addr, true, reusePort, tcpFastOpenQueueSize, interface, cpus);
           cs->tlsFrontend = frontend;
           if (tcpListenQueueSize > 0) {
             cs->tcpListenQueueSize = tcpListenQueueSize;

pdns/dnsdist-rings.hh

@@ -84,7 +84,7 @@ struct Rings {
 
     /* resize all the rings */
     for (auto& shard : d_shards) {
-      shard = std::unique_ptr<Shard>(new Shard());
+      shard = std::make_unique<Shard>();
       shard->queryRing.lock()->set_capacity(newCapacity / numberOfShards);
       shard->respRing.lock()->set_capacity(newCapacity / numberOfShards);
     }

pdns/dnsdist.cc

@@ -1594,9 +1594,9 @@ static void MultipleMessagesUDPClientThread(ClientState* cs, LocalHolders& holde
   };
   const size_t vectSize = g_udpVectorSize;
 
-  auto recvData = std::unique_ptr<MMReceiver[]>(new MMReceiver[vectSize]);
-  auto msgVec = std::unique_ptr<struct mmsghdr[]>(new struct mmsghdr[vectSize]);
-  auto outMsgVec = std::unique_ptr<struct mmsghdr[]>(new struct mmsghdr[vectSize]);
+  auto recvData = std::make_unique<MMReceiver[]>(vectSize);
+  auto msgVec = std::make_unique<struct mmsghdr[]>(vectSize);
+  auto outMsgVec = std::make_unique<struct mmsghdr[]>(vectSize);
 
   /* the actual buffer is larger because:
      - we may have to add EDNS and/or ECS

pdns/dnsdistdist/dnsdist-kvs.cc

@@ -190,7 +190,7 @@ CDBKVStore::~CDBKVStore() {
 
 bool CDBKVStore::reload(const struct stat& st)
 {
-  auto newCDB = std::unique_ptr<CDB>(new CDB(d_fname));
+  auto newCDB = std::make_unique<CDB>(d_fname);
   {
     *(d_cdb.write_lock()) = std::move(newCDB);
   }

pdns/dnsdistdist/doh.cc

@@ -823,7 +823,7 @@ static void doh_dispatch_query(DOHServerConfig* dsc, h2o_handler_t* self, h2o_re
     uint16_t qtype;
     DNSName qname(reinterpret_cast<const char*>(query.data()), query.size(), sizeof(dnsheader), false, &qtype);
 
-    auto du = std::unique_ptr<DOHUnit>(new DOHUnit);
+    auto du = std::make_unique<DOHUnit>();
     du->dsc = dsc;
     du->req = req;
     du->ids.origDest = local;
@@ -1440,7 +1440,7 @@ static void setupTLSContext(DOHAcceptContext& acceptCtx,
   auto ctx = libssl_init_server_context(tlsConfig, acceptCtx.d_ocspResponses);
 
   if (tlsConfig.d_enableTickets && tlsConfig.d_numberOfTicketsKeys > 0) {
-    acceptCtx.d_ticketKeys = std::unique_ptr<OpenSSLTLSTicketKeysRing>(new OpenSSLTLSTicketKeysRing(tlsConfig.d_numberOfTicketsKeys));
+    acceptCtx.d_ticketKeys = std::make_unique<OpenSSLTLSTicketKeysRing>(tlsConfig.d_numberOfTicketsKeys);
     SSL_CTX_set_tlsext_ticket_key_cb(ctx.get(), &ticket_key_callback);
     libssl_set_ticket_key_callback_data(ctx.get(), &acceptCtx);
   }

pdns/dnsdistdist/test-dnsdistkvs_cc.cc

@@ -354,11 +354,11 @@ BOOST_AUTO_TEST_CASE(test_LMDB) {
     transaction->commit();
   }
 
-  auto lmdb = std::unique_ptr<KeyValueStore>(new LMDBKVStore(dbPath, "db-name"));
+  std::unique_ptr<KeyValueStore> lmdb = std::make_unique<LMDBKVStore>(dbPath, "db-name");
   doKVSChecks(lmdb, lc, rem, dq, plaintextDomain);
   lmdb.reset();
 
-  lmdb = std::unique_ptr<KeyValueStore>(new LMDBKVStore(dbPath, "range-db-name"));
+  lmdb = std::make_unique<LMDBKVStore>(dbPath, "range-db-name");
   doKVSRangeChecks(lmdb);
   /*
   std::string value;
@@ -414,7 +414,7 @@ BOOST_AUTO_TEST_CASE(test_CDB) {
     writer.close();
   }
 
-  auto cdb = std::unique_ptr<KeyValueStore>(new CDBKVStore(db, 0));
+  std::unique_ptr<KeyValueStore> cdb = std::make_unique<CDBKVStore>(db, 0);
   doKVSChecks(cdb, lc, rem, dq, plaintextDomain);
 
   /*

pdns/dnsdistdist/test-dnsdistnghttp2_cc.cc

@@ -664,7 +664,7 @@ struct TestFixture
   {
     s_steps.clear();
     s_responses.clear();
-    s_mplexer = std::unique_ptr<FDMultiplexer>(new MockupFDMultiplexer());
+    s_mplexer = std::make_unique<MockupFDMultiplexer>();
   }
   ~TestFixture()
   {

pdns/dnsrecords.hh

@@ -595,15 +595,15 @@ public:
   NSECBitmap(const NSECBitmap& rhs): d_set(rhs.d_set)
   {
     if (rhs.d_bitset) {
-      d_bitset = std::unique_ptr<std::bitset<nbTypes>>(new std::bitset<nbTypes>(*(rhs.d_bitset)));
+      d_bitset = std::make_unique<std::bitset<nbTypes>>(*(rhs.d_bitset));
     }
   }
   NSECBitmap& operator=(const NSECBitmap& rhs)
   {
     d_set = rhs.d_set;
 
     if (rhs.d_bitset) {
-      d_bitset = std::unique_ptr<std::bitset<nbTypes>>(new std::bitset<nbTypes>(*(rhs.d_bitset)));
+      d_bitset = std::make_unique<std::bitset<nbTypes>>(*(rhs.d_bitset));
     }
 
     return *this;
@@ -652,7 +652,7 @@ private:
 
   void migrateToBitSet()
   {
-    d_bitset = std::unique_ptr<std::bitset<nbTypes>>(new std::bitset<nbTypes>());
+    d_bitset = std::make_unique<std::bitset<nbTypes>>();
     for (const auto& type : d_set) {
       d_bitset->set(type);
     }

pdns/dnsscope.cc

@@ -224,8 +224,8 @@ try
     PcapPacketReader pr(files[fno]);
     std::unique_ptr<PcapPacketWriter> pw=nullptr;
     if(!g_vm["write-failures"].as<string>().empty())
-      pw=std::unique_ptr<PcapPacketWriter>(new PcapPacketWriter(g_vm["write-failures"].as<string>(), pr));
- 
+      pw = std::make_unique<PcapPacketWriter>(g_vm["write-failures"].as<string>(), pr);
+
     EDNSOpts edo;
     while(pr.getUDPPacket()) {
 

pdns/dnstcpbench.cc

@@ -134,7 +134,7 @@ try
     throw PDNSException("tcp read failed");
 
   len=ntohs(len);
-  std::unique_ptr<char[]> creply(new char[len]);
+  auto creply = std::make_unique<char[]>(len);
   int n=0;
   int numread;
   while(n<len) {

pdns/dnswasher.cc

@@ -73,7 +73,7 @@ class IPSeqObfuscator : public IPObfuscator
 
   static std::unique_ptr<IPObfuscator> make()
   {
-    return std::unique_ptr<IPObfuscator>(new IPSeqObfuscator());
+    return std::make_unique<IPSeqObfuscator>();
   }
 
   uint32_t obf4(uint32_t orig) override
@@ -133,7 +133,7 @@ class IPCipherObfuscator : public IPObfuscator
   {}
   static std::unique_ptr<IPObfuscator> make(std::string key, bool decrypt)
   {
-    return std::unique_ptr<IPObfuscator>(new IPCipherObfuscator(key, decrypt));
+    return std::make_unique<IPCipherObfuscator>(key, decrypt);
   }
 
   uint32_t obf4(uint32_t orig) override

pdns/ixfrdist-web.cc

@@ -25,8 +25,8 @@
 #include "iputils.hh"
 #include "ixfrdist-stats.hh"
 
-IXFRDistWebServer::IXFRDistWebServer(const ComboAddress &listenAddress, const NetmaskGroup &acl, const string &loglevel) :
-  d_ws(std::unique_ptr<WebServer>(new WebServer(listenAddress.toString(), listenAddress.getPort())))
+IXFRDistWebServer::IXFRDistWebServer(const ComboAddress& listenAddress, const NetmaskGroup& acl, const string& loglevel) :
+  d_ws(std::make_unique<WebServer>(listenAddress.toString(), listenAddress.getPort()))
 {
   d_ws->setACL(acl);
   d_ws->setLogLevel(loglevel);

pdns/lua-base4.cc

@@ -37,7 +37,7 @@ void BaseLua4::loadString(const std::string &script) {
 void BaseLua4::getFeatures(Features &) { }
 
 void BaseLua4::prepareContext() {
-  d_lw = std::unique_ptr<LuaContext>(new LuaContext);
+  d_lw = std::make_unique<LuaContext>();
 
   // lua features available
   Features features;