PurpleI2P/i2pd
1
0
Fork 0
mirror of https://github.com/PurpleI2P/i2pd.git synced 2025-01-15 17:59:58 +00:00
Code Issues Releases Activity

use std::string_view instead const std::string&

Browse Source
This commit is contained in:
orignal 2025-01-12 12:23:26 -05:00
parent efd8e6e65b
commit 634ceceb1c
8 changed files with 58 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libi2pd/Blinding.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2022, The PurpleI2P Project * Copyright (c) 2013-2025, The PurpleI2P Project
* *
* This file is part of Purple i2pd project and licensed under BSD3 * This file is part of Purple i2pd project and licensed under BSD3
* *
@ -152,11 +152,11 @@ namespace data
m_BlindedSigType = m_SigType; m_BlindedSigType = m_SigType;
} }
BlindedPublicKey::BlindedPublicKey (const std::string& b33): BlindedPublicKey::BlindedPublicKey (std::string_view b33):
m_SigType (0) // 0 means invalid, we can't blind DSA, set it later m_SigType (0) // 0 means invalid, we can't blind DSA, set it later
{ {
uint8_t addr[40]; // TODO: define length from b33 uint8_t addr[40]; // TODO: define length from b33
size_t l = i2p::data::Base32ToByteStream (b33.c_str (), b33.length (), addr, 40); size_t l = i2p::data::Base32ToByteStream (b33.data (), b33.length (), addr, 40);
if (l < 32) if (l < 32)
{ {
LogPrint (eLogError, "Blinding: Malformed b33 ", b33); LogPrint (eLogError, "Blinding: Malformed b33 ", b33);

5
libi2pd/Blinding.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2020, The PurpleI2P Project * Copyright (c) 2013-2025, The PurpleI2P Project
* *
* This file is part of Purple i2pd project and licensed under BSD3 * This file is part of Purple i2pd project and licensed under BSD3
* *
@ -11,6 +11,7 @@
#include <inttypes.h> #include <inttypes.h>
#include <string> #include <string>
#include <string_view>
#include <vector> #include <vector>
#include "Identity.h" #include "Identity.h"
@ -23,7 +24,7 @@ namespace data
public: public:
BlindedPublicKey (std::shared_ptr<const IdentityEx> identity, bool clientAuth = false); BlindedPublicKey (std::shared_ptr<const IdentityEx> identity, bool clientAuth = false);
BlindedPublicKey (const std::string& b33); // from b33 without .b32.i2p BlindedPublicKey (std::string_view b33); // from b33 without .b32.i2p
std::string ToB33 () const; std::string ToB33 () const;
const uint8_t * GetPublicKey () const { return m_PublicKey.data (); }; const uint8_t * GetPublicKey () const { return m_PublicKey.data (); };

8
libi2pd/Identity.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2024, The PurpleI2P Project * Copyright (c) 2013-2025, The PurpleI2P Project
* *
* This file is part of Purple i2pd project and licensed under BSD3 * This file is part of Purple i2pd project and licensed under BSD3
* *
@ -262,11 +262,11 @@ namespace data
return fullLen; return fullLen;
} }
size_t IdentityEx::FromBase64(const std::string& s) size_t IdentityEx::FromBase64(std::string_view s)
{ {
const size_t slen = s.length(); const size_t slen = s.length();
std::vector<uint8_t> buf(slen); // binary data can't exceed base64 std::vector<uint8_t> buf(slen); // binary data can't exceed base64
const size_t len = Base64ToByteStream (s.c_str(), slen, buf.data(), slen); const size_t len = Base64ToByteStream (s.data(), slen, buf.data(), slen);
return FromBuffer (buf.data(), len); return FromBuffer (buf.data(), len);
} }
@ -728,9 +728,7 @@ namespace data
case SIGNING_KEY_TYPE_RSA_SHA384_3072: case SIGNING_KEY_TYPE_RSA_SHA384_3072:
case SIGNING_KEY_TYPE_RSA_SHA512_4096: case SIGNING_KEY_TYPE_RSA_SHA512_4096:
LogPrint (eLogWarning, "Identity: RSA signature type is not supported. Creating EdDSA"); LogPrint (eLogWarning, "Identity: RSA signature type is not supported. Creating EdDSA");
#if (__cplusplus >= 201703L) // C++ 17 or higher
[[fallthrough]]; [[fallthrough]];
#endif
// no break here // no break here
case SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519: case SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
i2p::crypto::CreateEDDSA25519RandomKeys (priv, pub); i2p::crypto::CreateEDDSA25519RandomKeys (priv, pub);

5
libi2pd/Identity.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2024, The PurpleI2P Project * Copyright (c) 2013-2025, The PurpleI2P Project
* *
* This file is part of Purple i2pd project and licensed under BSD3 * This file is part of Purple i2pd project and licensed under BSD3
* *
@ -12,6 +12,7 @@
#include <inttypes.h> #include <inttypes.h>
#include <string.h> #include <string.h>
#include <string> #include <string>
#include <string_view>
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "Base.h" #include "Base.h"
@ -99,7 +100,7 @@ namespace data
size_t FromBuffer (const uint8_t * buf, size_t len); size_t FromBuffer (const uint8_t * buf, size_t len);
size_t ToBuffer (uint8_t * buf, size_t len) const; size_t ToBuffer (uint8_t * buf, size_t len) const;
size_t FromBase64(const std::string& s); size_t FromBase64(std::string_view s);
std::string ToBase64 () const; std::string ToBase64 () const;
const Identity& GetStandardIdentity () const { return m_StandardIdentity; }; const Identity& GetStandardIdentity () const { return m_StandardIdentity; };

18
libi2pd/Tag.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2023, The PurpleI2P Project * Copyright (c) 2013-2025, The PurpleI2P Project
* *
* This file is part of Purple i2pd project and licensed under BSD3 * This file is part of Purple i2pd project and licensed under BSD3
* *
@ -12,10 +12,14 @@
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
#include <string.h> #include <string.h>
#include <openssl/rand.h> #include <openssl/rand.h>
#include <string>
#include <string_view>
#include "Base.h" #include "Base.h"
namespace i2p { namespace i2p
namespace data { {
namespace data
{
template<size_t sz> template<size_t sz>
class Tag class Tag
{ {
@ -70,14 +74,14 @@ namespace data {
return std::string (str, str + l); return std::string (str, str + l);
} }
size_t FromBase32 (const std::string& s) size_t FromBase32 (std::string_view s)
{ {
return i2p::data::Base32ToByteStream (s.c_str (), s.length (), m_Buf, sz); return i2p::data::Base32ToByteStream (s.data (), s.length (), m_Buf, sz);
} }
size_t FromBase64 (const std::string& s) size_t FromBase64 (std::string_view s)
{ {
return i2p::data::Base64ToByteStream (s.c_str (), s.length (), m_Buf, sz); return i2p::data::Base64ToByteStream (s.data (), s.length (), m_Buf, sz);
} }
uint8_t GetBit (int i) const uint8_t GetBit (int i) const

44
libi2pd_client/AddressBook.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2024, The PurpleI2P Project * Copyright (c) 2013-2025, The PurpleI2P Project
* *
* This file is part of Purple i2pd project and licensed under BSD3 * This file is part of Purple i2pd project and licensed under BSD3
* *
@ -49,22 +49,22 @@ namespace client
if (m_IsPersist) if (m_IsPersist)
i2p::config::GetOption("addressbook.hostsfile", m_HostsFile); i2p::config::GetOption("addressbook.hostsfile", m_HostsFile);
} }
std::shared_ptr<const i2p::data::IdentityEx> GetAddress (const i2p::data::IdentHash& ident) const; std::shared_ptr<const i2p::data::IdentityEx> GetAddress (const i2p::data::IdentHash& ident) const override;
void AddAddress (std::shared_ptr<const i2p::data::IdentityEx> address); void AddAddress (std::shared_ptr<const i2p::data::IdentityEx> address) override;
void RemoveAddress (const i2p::data::IdentHash& ident); void RemoveAddress (const i2p::data::IdentHash& ident) override;
bool Init (); bool Init () override;
int Load (std::map<std::string, std::shared_ptr<Address> > & addresses); int Load (Addresses& addresses) override;
int LoadLocal (std::map<std::string, std::shared_ptr<Address> >& addresses); int LoadLocal (Addresses& addresses) override;
int Save (const std::map<std::string, std::shared_ptr<Address> >& addresses); int Save (const Addresses& addresses) override;
void SaveEtag (const i2p::data::IdentHash& subsciption, const std::string& etag, const std::string& lastModified); void SaveEtag (const i2p::data::IdentHash& subsciption, const std::string& etag, const std::string& lastModified) override;
bool GetEtag (const i2p::data::IdentHash& subscription, std::string& etag, std::string& lastModified); bool GetEtag (const i2p::data::IdentHash& subscription, std::string& etag, std::string& lastModified) override;
void ResetEtags (); void ResetEtags () override;
private: private:
int LoadFromFile (const std::string& filename, std::map<std::string, std::shared_ptr<Address> >& addresses); // returns -1 if can't open file, otherwise number of records int LoadFromFile (const std::string& filename, Addresses& addresses); // returns -1 if can't open file, otherwise number of records
private: private:
@ -142,7 +142,7 @@ namespace client
storage.Remove( ident.ToBase32() ); storage.Remove( ident.ToBase32() );
} }
int AddressBookFilesystemStorage::LoadFromFile (const std::string& filename, std::map<std::string, std::shared_ptr<Address> >& addresses) int AddressBookFilesystemStorage::LoadFromFile (const std::string& filename, Addresses& addresses)
{ {
int num = 0; int num = 0;
std::ifstream f (filename, std::ifstream::in); // in text mode std::ifstream f (filename, std::ifstream::in); // in text mode
@ -168,7 +168,7 @@ namespace client
return num; return num;
} }
int AddressBookFilesystemStorage::Load (std::map<std::string, std::shared_ptr<Address> >& addresses) int AddressBookFilesystemStorage::Load (Addresses& addresses)
{ {
int num = LoadFromFile (indexPath, addresses); int num = LoadFromFile (indexPath, addresses);
if (num < 0) if (num < 0)
@ -182,7 +182,7 @@ namespace client
return num; return num;
} }
int AddressBookFilesystemStorage::LoadLocal (std::map<std::string, std::shared_ptr<Address> >& addresses) int AddressBookFilesystemStorage::LoadLocal (Addresses& addresses)
{ {
int num = LoadFromFile (localPath, addresses); int num = LoadFromFile (localPath, addresses);
if (num < 0) return 0; if (num < 0) return 0;
@ -190,7 +190,7 @@ namespace client
return num; return num;
} }
int AddressBookFilesystemStorage::Save (const std::map<std::string, std::shared_ptr<Address> >& addresses) int AddressBookFilesystemStorage::Save (const Addresses& addresses)
{ {
if (addresses.empty()) if (addresses.empty())
{ {
@ -283,7 +283,7 @@ namespace client
//--------------------------------------------------------------------- //---------------------------------------------------------------------
Address::Address (const std::string& b32): Address::Address (std::string_view b32):
addressType (eAddressInvalid) addressType (eAddressInvalid)
{ {
if (b32.length () <= B33_ADDRESS_THRESHOLD) if (b32.length () <= B33_ADDRESS_THRESHOLD)
@ -377,7 +377,7 @@ namespace client
m_Subscriptions.clear (); m_Subscriptions.clear ();
} }
std::shared_ptr<const Address> AddressBook::GetAddress (const std::string& address) std::shared_ptr<const Address> AddressBook::GetAddress (std::string_view address)
{ {
auto pos = address.find(".b32.i2p"); auto pos = address.find(".b32.i2p");
if (pos != std::string::npos) if (pos != std::string::npos)
@ -404,7 +404,7 @@ namespace client
return std::make_shared<const Address>(dest.GetIdentHash ()); return std::make_shared<const Address>(dest.GetIdentHash ());
} }
std::shared_ptr<const Address> AddressBook::FindAddress (const std::string& address) std::shared_ptr<const Address> AddressBook::FindAddress (std::string_view address)
{ {
auto it = m_Addresses.find (address); auto it = m_Addresses.find (address);
if (it != m_Addresses.end ()) if (it != m_Addresses.end ())
@ -609,7 +609,7 @@ namespace client
void AddressBook::LoadLocal () void AddressBook::LoadLocal ()
{ {
if (!m_Storage) return; if (!m_Storage) return;
std::map<std::string, std::shared_ptr<Address>> localAddresses; AddressBookStorage::Addresses localAddresses;
m_Storage->LoadLocal (localAddresses); m_Storage->LoadLocal (localAddresses);
for (const auto& it: localAddresses) for (const auto& it: localAddresses)
{ {
@ -766,7 +766,7 @@ namespace client
} }
} }
void AddressBook::LookupAddress (const std::string& address) void AddressBook::LookupAddress (std::string_view address)
{ {
std::shared_ptr<const Address> addr; std::shared_ptr<const Address> addr;
auto dot = address.find ('.'); auto dot = address.find ('.');
@ -796,7 +796,7 @@ namespace client
memset (buf, 0, 4); memset (buf, 0, 4);
htobe32buf (buf + 4, nonce); htobe32buf (buf + 4, nonce);
buf[8] = address.length (); buf[8] = address.length ();
memcpy (buf + 9, address.c_str (), address.length ()); memcpy (buf + 9, address.data (), address.length ());
datagram->SendDatagramTo (buf, len, addr->identHash, ADDRESS_RESPONSE_DATAGRAM_PORT, ADDRESS_RESOLVER_DATAGRAM_PORT); datagram->SendDatagramTo (buf, len, addr->identHash, ADDRESS_RESPONSE_DATAGRAM_PORT, ADDRESS_RESOLVER_DATAGRAM_PORT);
delete[] buf; delete[] buf;
} }

22
libi2pd_client/AddressBook.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2024, The PurpleI2P Project * Copyright (c) 2013-2025, The PurpleI2P Project
* *
* This file is part of Purple i2pd project and licensed under BSD3 * This file is part of Purple i2pd project and licensed under BSD3
* *
@ -47,7 +47,7 @@ namespace client
i2p::data::IdentHash identHash; i2p::data::IdentHash identHash;
std::shared_ptr<i2p::data::BlindedPublicKey> blindedPublicKey; std::shared_ptr<i2p::data::BlindedPublicKey> blindedPublicKey;
Address (const std::string& b32); Address (std::string_view b32);
Address (const i2p::data::IdentHash& hash); Address (const i2p::data::IdentHash& hash);
bool IsIdentHash () const { return addressType == eAddressIndentHash; }; bool IsIdentHash () const { return addressType == eAddressIndentHash; };
bool IsValid () const { return addressType != eAddressInvalid; }; bool IsValid () const { return addressType != eAddressInvalid; };
@ -59,15 +59,17 @@ namespace client
{ {
public: public:
typedef std::map<std::string, std::shared_ptr<Address>, std::less<> > Addresses;
virtual ~AddressBookStorage () {}; virtual ~AddressBookStorage () {};
virtual std::shared_ptr<const i2p::data::IdentityEx> GetAddress (const i2p::data::IdentHash& ident) const = 0; virtual std::shared_ptr<const i2p::data::IdentityEx> GetAddress (const i2p::data::IdentHash& ident) const = 0;
virtual void AddAddress (std::shared_ptr<const i2p::data::IdentityEx> address) = 0; virtual void AddAddress (std::shared_ptr<const i2p::data::IdentityEx> address) = 0;
virtual void RemoveAddress (const i2p::data::IdentHash& ident) = 0; virtual void RemoveAddress (const i2p::data::IdentHash& ident) = 0;
virtual bool Init () = 0; virtual bool Init () = 0;
virtual int Load (std::map<std::string, std::shared_ptr<Address> >& addresses) = 0; virtual int Load (Addresses& addresses) = 0;
virtual int LoadLocal (std::map<std::string, std::shared_ptr<Address> >& addresses) = 0; virtual int LoadLocal (Addresses& addresses) = 0;
virtual int Save (const std::map<std::string, std::shared_ptr<Address> >& addresses) = 0; virtual int Save (const Addresses& addresses) = 0;
virtual void SaveEtag (const i2p::data::IdentHash& subscription, const std::string& etag, const std::string& lastModified) = 0; virtual void SaveEtag (const i2p::data::IdentHash& subscription, const std::string& etag, const std::string& lastModified) = 0;
virtual bool GetEtag (const i2p::data::IdentHash& subscription, std::string& etag, std::string& lastModified) = 0; virtual bool GetEtag (const i2p::data::IdentHash& subscription, std::string& etag, std::string& lastModified) = 0;
@ -79,16 +81,16 @@ namespace client
class AddressBook class AddressBook
{ {
public: public:
AddressBook (); AddressBook ();
~AddressBook (); ~AddressBook ();
void Start (); void Start ();
void StartResolvers (); void StartResolvers ();
void Stop (); void Stop ();
std::shared_ptr<const Address> GetAddress (const std::string& address); std::shared_ptr<const Address> GetAddress (std::string_view address);
std::shared_ptr<const i2p::data::IdentityEx> GetFullAddress (const std::string& address); std::shared_ptr<const i2p::data::IdentityEx> GetFullAddress (const std::string& address);
std::shared_ptr<const Address> FindAddress (const std::string& address); std::shared_ptr<const Address> FindAddress (std::string_view address);
void LookupAddress (const std::string& address); void LookupAddress (std::string_view address);
void InsertAddress (const std::string& address, const std::string& jump); // for jump links void InsertAddress (const std::string& address, const std::string& jump); // for jump links
void InsertFullAddress (std::shared_ptr<const i2p::data::IdentityEx> address); void InsertFullAddress (std::shared_ptr<const i2p::data::IdentityEx> address);
@ -121,7 +123,7 @@ namespace client
private: private:
std::mutex m_AddressBookMutex; std::mutex m_AddressBookMutex;
std::map<std::string, std::shared_ptr<Address> > m_Addresses; AddressBookStorage::Addresses m_Addresses;
std::map<i2p::data::IdentHash, std::shared_ptr<AddressResolver> > m_Resolvers; // local destination->resolver std::map<i2p::data::IdentHash, std::shared_ptr<AddressResolver> > m_Resolvers; // local destination->resolver
std::mutex m_LookupsMutex; std::mutex m_LookupsMutex;
std::map<uint32_t, std::string> m_Lookups; // nonce -> address std::map<uint32_t, std::string> m_Lookups; // nonce -> address

2
libi2pd_client/I2CP.cpp
View File

@ -921,7 +921,7 @@ namespace client
case 1: // address case 1: // address
{ {
auto name = ExtractString (buf + 11, len - 11); auto name = ExtractString (buf + 11, len - 11);
auto addr = i2p::client::context.GetAddressBook ().GetAddress (std::string (name)); // TODO: GetAddress should take string_view auto addr = i2p::client::context.GetAddressBook ().GetAddress (name);
if (!addr || !addr->IsIdentHash ()) if (!addr || !addr->IsIdentHash ())
{ {
// TODO: handle blinded addresses // TODO: handle blinded addresses