diff '--color=auto' -Naur kea-2.4.1-orig/src/lib/asiolink/io_address.cc kea-2.4.1/src/lib/asiolink/io_address.cc
--- kea-2.4.1-orig/src/lib/asiolink/io_address.cc	2024-12-16 07:50:28.421296859 +0100
+++ kea-2.4.1/src/lib/asiolink/io_address.cc	2024-12-16 08:04:53.822815117 +0100
@@ -37,7 +37,7 @@
 // because we'd like to throw our own exception on failure.
 IOAddress::IOAddress(const std::string& address_str) {
     boost::system::error_code err;
-    asio_address_ = ip::address::from_string(address_str, err);
+    asio_address_ = ip::make_address(address_str, err);
     if (err) {
         isc_throw(IOError, "Failed to convert string to address '"
                   << address_str << "': " << err.message());
@@ -117,7 +117,12 @@
 uint32_t
 IOAddress::toUint32() const {
     if (asio_address_.is_v4()) {
+#if BOOST_VERSION < 108000        
         return (asio_address_.to_v4().to_ulong());
+#else
+        return (asio_address_.to_v4().to_uint());
+#endif
+
     } else {
         isc_throw(BadValue, "Can't convert " << toText()
                   << " address to IPv4.");
diff '--color=auto' -Naur kea-2.4.1-orig/src/lib/asiolink/io_service.cc kea-2.4.1/src/lib/asiolink/io_service.cc
--- kea-2.4.1-orig/src/lib/asiolink/io_service.cc	2024-12-16 07:50:28.421296859 +0100
+++ kea-2.4.1/src/lib/asiolink/io_service.cc	2024-12-16 08:16:54.801301079 +0100
@@ -24,8 +24,7 @@
 public:
     /// \brief The constructor
     IOServiceImpl() :
-        io_service_(),
-        work_(new boost::asio::io_service::work(io_service_)) {
+        io_context_() {
     };
 
     /// \brief The destructor.
@@ -37,7 +36,7 @@
     /// This method does not return control to the caller until
     /// the \c stop() method is called via some handler.
     void run() {
-        io_service_.run();
+        io_context_.run();
     };
 
     /// \brief Run the underlying event loop for a single event.
@@ -46,7 +45,7 @@
     /// first handler has completed.  (If no handlers are ready when
     /// it is run, it will block until one is.)
     void run_one() {
-        io_service_.run_one();
+        io_context_.run_one();
     };
 
     /// \brief Run the underlying event loop for a ready events.
@@ -54,32 +53,32 @@
     /// This method executes handlers for all ready events and returns.
     /// It will return immediately if there are no ready events.
     void poll() {
-        io_service_.poll();
+        io_context_.poll();
     };
 
     /// \brief Stop the underlying event loop.
     ///
     /// This will return the control to the caller of the \c run() method.
     void stop() {
-        io_service_.stop();
+        io_context_.stop();
     }
 
     /// \brief Indicates if the IOService has been stopped.
     ///
     /// \return true if the IOService has been stopped, false otherwise.
     bool stopped() const {
-        return (io_service_.stopped());
+        return (io_context_.stopped());
     }
 
     /// \brief Restarts the IOService in preparation for a subsequent \c run() invocation.
     void restart() {
-        io_service_.reset();
+        io_context_.restart();
     }
 
     /// \brief Removes IO service work object to let it finish running
     /// when all handlers have been invoked.
     void stopWork() {
-        work_.reset();
+        io_context_.stop();
     }
 
     /// \brief Return the native \c io_service object used in this wrapper.
@@ -88,20 +87,19 @@
     /// that share the same \c io_service with the authoritative server.
     /// It will eventually be removed once the wrapper interface is
     /// generalized.
-    boost::asio::io_service& get_io_service() {
-        return (io_service_);
+    boost::asio::io_context& get_io_context() {
+        return (io_context_);
     }
 
     /// \brief Post a callback on the IO service
     ///
     /// \param callback The callback to be run on the IO service.
     void post(const std::function<void ()>& callback) {
-        io_service_.post(callback);
+        boost::asio::post(io_context_, callback);
     }
 
 private:
-    boost::asio::io_service io_service_;
-    boost::shared_ptr<boost::asio::io_service::work> work_;
+    boost::asio::io_context io_context_;
 };
 
 IOService::IOService() : io_impl_(new IOServiceImpl()) {
@@ -147,7 +145,7 @@
 
 boost::asio::io_service&
 IOService::get_io_service() {
-    return (io_impl_->get_io_service());
+    return (io_impl_->get_io_context());
 }
 
 void
diff '--color=auto' -Naur kea-2.4.1-orig/src/lib/asiolink/tcp_endpoint.h kea-2.4.1/src/lib/asiolink/tcp_endpoint.h
--- kea-2.4.1-orig/src/lib/asiolink/tcp_endpoint.h	2024-12-16 07:50:28.421296859 +0100
+++ kea-2.4.1/src/lib/asiolink/tcp_endpoint.h	2024-12-16 08:01:31.086666399 +0100
@@ -42,7 +42,12 @@
     /// \param port The TCP port number of the endpoint.
     TCPEndpoint(const IOAddress& address, const unsigned short port) :
         asio_endpoint_placeholder_(
+#if BOOST_VERSION < 108000
             new boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(address.toText()),
+#else
+            new boost::asio::ip::tcp::endpoint(boost::asio::ip::make_address(address.toText()),
+#endif
+
                               port)),
         asio_endpoint_(*asio_endpoint_placeholder_)
     {}
diff '--color=auto' -Naur kea-2.4.1-orig/src/lib/asiolink/udp_endpoint.h kea-2.4.1/src/lib/asiolink/udp_endpoint.h
--- kea-2.4.1-orig/src/lib/asiolink/udp_endpoint.h	2024-12-16 07:50:28.421296859 +0100
+++ kea-2.4.1/src/lib/asiolink/udp_endpoint.h	2024-12-16 08:02:41.744111248 +0100
@@ -42,7 +42,11 @@
     /// \param port The UDP port number of the endpoint.
     UDPEndpoint(const IOAddress& address, const unsigned short port) :
         asio_endpoint_placeholder_(
+#if BOOST_VERSION < 108000
             new boost::asio::ip::udp::endpoint(boost::asio::ip::address::from_string(address.toText()),
+#else                
+            new boost::asio::ip::udp::endpoint(boost::asio::ip::make_address(address.toText()),
+#endif               
                               port)),
         asio_endpoint_(*asio_endpoint_placeholder_)
     {}
diff '--color=auto' -Naur kea-2.4.1-orig/src/lib/asiolink/unix_domain_socket.cc kea-2.4.1/src/lib/asiolink/unix_domain_socket.cc
--- kea-2.4.1-orig/src/lib/asiolink/unix_domain_socket.cc	2024-12-16 07:50:28.421296859 +0100
+++ kea-2.4.1/src/lib/asiolink/unix_domain_socket.cc	2024-12-16 08:30:23.473497371 +0100
@@ -83,9 +83,13 @@
     /// @param buffer Buffers holding the data to be sent.
     /// @param handler User supplied callback to be invoked when data have
     /// been sent or sending error is signalled.
+#if BOOST_VERSION < 108000
     void doSend(const boost::asio::const_buffers_1& buffer,
                 const UnixDomainSocket::Handler& handler);
-
+#else
+    void doSend(const boost::asio::const_buffer& buffer,
+                const UnixDomainSocket::Handler& handler);
+#endif
 
     /// @brief Local handler invoked as a result of asynchronous send.
     ///
@@ -102,10 +106,17 @@
     /// @param buffer Buffers holding the data to be sent.
     /// @param ec Error code returned as a result of sending the data.
     /// @param length Length of the data sent.
+#if BOOST_VERSION < 108000
     void sendHandler(const UnixDomainSocket::Handler& remote_handler,
                      const boost::asio::const_buffers_1& buffer,
                      const boost::system::error_code& ec,
                      size_t length);
+#else
+    void sendHandler(const UnixDomainSocket::Handler& remote_handler,
+                     const boost::asio::const_buffer& buffer,
+                     const boost::system::error_code& ec,
+                     size_t length);
+#endif
 
     /// @brief Asynchronously receive data over the socket.
     ///
@@ -127,9 +138,13 @@
     /// @param buffer A buffer into which the data should be received.
     /// @param handler User supplied callback invoked when data have been
     /// received on an error is signalled.
+#if BOOST_VERSION < 108000
     void doReceive(const boost::asio::mutable_buffers_1& buffer,
                    const UnixDomainSocket::Handler& handler);
-
+#else
+    void doReceive(const boost::asio::mutable_buffer& buffer,
+                   const UnixDomainSocket::Handler& handler);
+#endif
     /// @brief Local handler invoked as a result of asynchronous receive.
     ///
     /// This handler is invoked as a result of asynchronous receive. It is a
@@ -145,11 +160,17 @@
     /// @param buffer Buffer into which the data are received.
     /// @param ec Error code returned as a result of asynchronous receive.
     /// @param length Size of the received data.
+#if BOOST_VERSION < 108000
     void receiveHandler(const UnixDomainSocket::Handler& remote_handler,
                         const boost::asio::mutable_buffers_1& buffer,
                         const boost::system::error_code& ec,
                         size_t length);
-
+#else
+    void receiveHandler(const UnixDomainSocket::Handler& remote_handler,
+                        const boost::asio::mutable_buffer& buffer,
+                        const boost::system::error_code& ec,
+                        size_t length);
+#endif
     /// @brief Disables read and write operations on the socket.
     void shutdown();
 
@@ -193,20 +214,34 @@
     doSend(boost::asio::buffer(data, length), handler);
 }
 
+#if BOOST_VERSION < 108000
 void
 UnixDomainSocketImpl::doSend(const boost::asio::const_buffers_1& buffer,
                              const UnixDomainSocket::Handler& handler) {
+#else
+void
+UnixDomainSocketImpl::doSend(const boost::asio::const_buffer& buffer,
+                             const UnixDomainSocket::Handler& handler) {
+#endif
     auto local_handler = std::bind(&UnixDomainSocketImpl::sendHandler,
                                    shared_from_this(),
                                    handler, buffer, ph::_1, ph::_2);
     socket_.async_send(buffer, local_handler);
 }
 
+#if BOOST_VERSION < 108000
 void
 UnixDomainSocketImpl::sendHandler(const UnixDomainSocket::Handler& remote_handler,
                                   const boost::asio::const_buffers_1& buffer,
                                   const boost::system::error_code& ec,
                                   size_t length) {
+#else
+void
+UnixDomainSocketImpl::sendHandler(const UnixDomainSocket::Handler& remote_handler,
+                                  const boost::asio::const_buffer& buffer,
+                                  const boost::system::error_code& ec,
+                                  size_t length) {
+#endif
     // The asynchronous send may return EWOULDBLOCK or EAGAIN on some
     // operating systems. In this case, we simply retry hoping that it
     // will succeed next time. The user's callback never sees these
@@ -226,20 +261,35 @@
     doReceive(boost::asio::buffer(data, length), handler);
 }
 
+#if BOOST_VERSION < 108000
 void
 UnixDomainSocketImpl::doReceive(const boost::asio::mutable_buffers_1& buffer,
                                 const UnixDomainSocket::Handler& handler) {
+#else
+void
+UnixDomainSocketImpl::doReceive(const boost::asio::mutable_buffer& buffer,
+                                const UnixDomainSocket::Handler& handler) {
+#endif
     auto local_handler = std::bind(&UnixDomainSocketImpl::receiveHandler,
                                    shared_from_this(),
                                    handler, buffer, ph::_1, ph::_2);
     socket_.async_receive(buffer, 0, local_handler);
 }
 
+#if BOOST_VERSION < 108000
 void
 UnixDomainSocketImpl::receiveHandler(const UnixDomainSocket::Handler& remote_handler,
                                      const boost::asio::mutable_buffers_1& buffer,
                                      const boost::system::error_code& ec,
                                      size_t length) {
+#else
+void
+UnixDomainSocketImpl::receiveHandler(const UnixDomainSocket::Handler& remote_handler,
+                                     const boost::asio::mutable_buffer& buffer,
+                                     const boost::system::error_code& ec,
+                                     size_t length) {
+#endif
+
     // The asynchronous receive may return EWOULDBLOCK or EAGAIN on some
     // operating systems. In this case, we simply retry hoping that it
     // will succeed next time. The user's callback never sees these
diff '--color=auto' -Naur kea-2.4.1-orig/src/lib/dhcp/iface_mgr.cc kea-2.4.1/src/lib/dhcp/iface_mgr.cc
--- kea-2.4.1-orig/src/lib/dhcp/iface_mgr.cc	2024-12-16 07:50:28.385296185 +0100
+++ kea-2.4.1/src/lib/dhcp/iface_mgr.cc	2024-12-16 08:56:35.318068282 +0100
@@ -1021,9 +1021,14 @@
     }
 
     // Create socket that will be used to connect to remote endpoint.
+#if BOOST_VERSION < 108000
     boost::asio::io_service io_service;
+#else
+    boost::asio::io_context io_service;
+#endif
     boost::asio::ip::udp::socket sock(io_service);
 
+
     boost::system::error_code err_code;
     // If remote address is broadcast address we have to
     // allow this on the socket.