1 // Copyright 2015 The Android Open Source Project 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #ifndef WEBSERVER_WEBSERVD_DBUS_PROTOCOL_HANDLER_H_ 16 #define WEBSERVER_WEBSERVD_DBUS_PROTOCOL_HANDLER_H_ 17 18 #include <map> 19 #include <memory> 20 #include <set> 21 #include <string> 22 #include <tuple> 23 #include <vector> 24 25 #include <base/macros.h> 26 #include <base/memory/weak_ptr.h> 27 #include <brillo/dbus/dbus_object.h> 28 #include <dbus/bus.h> 29 30 #include "libwebserv/dbus-proxies.h" 31 #include "dbus_bindings/org.chromium.WebServer.ProtocolHandler.h" 32 33 namespace brillo { 34 namespace dbus_utils { 35 class ExportedObjectManager; 36 } // dbus_utils 37 } // brillo 38 39 namespace webservd { 40 41 class ProtocolHandler; 42 class Request; 43 class Server; 44 45 // This is a D-Bus interface object for the internal ProtocolHandler class. 46 class DBusProtocolHandler final 47 : public org::chromium::WebServer::ProtocolHandlerInterface { 48 public: 49 DBusProtocolHandler( 50 brillo::dbus_utils::ExportedObjectManager* object_manager, 51 const dbus::ObjectPath& object_path, 52 ProtocolHandler* protocol_handler, 53 Server* server); 54 ~DBusProtocolHandler(); 55 56 void RegisterAsync( 57 const brillo::dbus_utils::AsyncEventSequencer::CompletionAction& cb); 58 59 // Returns the instance of D-Bus exported object manager. 60 brillo::dbus_utils::ExportedObjectManager* GetObjectManager() const; 61 62 // Overrides from org::chromium::WebServer::DBusProtocolHandlerInterface. 63 bool AddRequestHandler( 64 brillo::ErrorPtr* error, 65 dbus::Message* message, 66 const std::string& in_url, 67 const std::string& in_method, 68 const std::string& in_service_name, 69 std::string* out_request_handler_id) override; 70 71 bool RemoveRequestHandler(brillo::ErrorPtr* error, 72 const std::string& in_request_handler_id) override; 73 74 bool GetRequestFileData(brillo::ErrorPtr* error, 75 const std::string& in_request_id, 76 int32_t in_file_id, 77 dbus::FileDescriptor* out_contents) override; 78 79 bool CompleteRequest( 80 brillo::ErrorPtr* error, 81 const std::string& in_request_id, 82 int32_t in_status_code, 83 const std::vector<std::tuple<std::string, std::string>>& in_headers, 84 int64_t in_data_size, 85 dbus::FileDescriptor* out_response_stream) override; 86 87 private: 88 using RequestHandlerProxy = org::chromium::WebServer::RequestHandlerProxy; 89 90 // Information about a request handler D-Bus back-end client. 91 struct DBusServiceData { 92 // D-Bus unique address of the process owning this service. 93 std::string owner; 94 // A D-Bus proxy to the client's request handler object that actually 95 // processes requests registered for this client. 96 std::unique_ptr<RequestHandlerProxy> handler_proxy; 97 // A list of handler IDs registered by this client. 98 std::set<std::string> handler_ids; 99 // Called when the owner of the well known service name associated with this 100 // client changes. Since clients start up, this is called for the first 101 // time when they die. 102 dbus::Bus::GetServiceOwnerCallback on_client_disconnected_callback; 103 }; 104 105 // Looks up a request with |request_id|. 106 // Returns nullptr and sets additional |error| information, if not found. 107 Request* GetRequest(const std::string& request_id, brillo::ErrorPtr* error); 108 109 // Callback invoked when a client owning |service_name| is changed. 110 void OnClientDisconnected(const std::string& service_name, 111 const std::string& service_owner); 112 113 // D-Bus object adaptor for ProtocolHandler D-Bus object. 114 org::chromium::WebServer::ProtocolHandlerAdaptor dbus_adaptor_{this}; 115 std::unique_ptr<brillo::dbus_utils::DBusObject> dbus_object_; 116 117 // Reference back to the real ProtocolHandler object. 118 ProtocolHandler* protocol_handler_{nullptr}; 119 // Reference back to the Server class. 120 Server* server_{nullptr}; 121 122 // Called when the owner of a service name changes. We're only interested in 123 // transitions to the empty string, indicating that a service name owner has 124 // died. 125 dbus::Bus::GetServiceOwnerCallback on_client_disconnected_callback_; 126 127 // A map that holds information regarding a server back-end client processing 128 // requests on the D-Bus service with the name used in the key of the map. 129 std::map<std::string, DBusServiceData> dbus_service_data_; 130 // Handler ID to service name map. 131 std::map<std::string, std::string> handler_to_service_name_map_; 132 133 base::WeakPtrFactory<DBusProtocolHandler> weak_ptr_factory_{this}; 134 DISALLOW_COPY_AND_ASSIGN(DBusProtocolHandler); 135 }; 136 137 } // namespace webservd 138 139 #endif // WEBSERVER_WEBSERVD_DBUS_PROTOCOL_HANDLER_H_ 140