1 #pragma once
2 
3 #include "dhcp_configuration.hpp"
4 #include "ethernet_interface.hpp"
5 #include "system_configuration.hpp"
6 #include "vlan_interface.hpp"
7 #include "xyz/openbmc_project/Network/VLAN/Create/server.hpp"
8 
9 #include <filesystem>
10 #include <list>
11 #include <memory>
12 #include <sdbusplus/bus.hpp>
13 #include <string>
14 #include <vector>
15 #include <xyz/openbmc_project/Common/FactoryReset/server.hpp>
16 
17 namespace phosphor
18 {
19 namespace network
20 {
21 
22 using SystemConfPtr = std::unique_ptr<SystemConfiguration>;
23 using DHCPConfPtr = std::unique_ptr<dhcp::Configuration>;
24 
25 namespace fs = std::filesystem;
26 namespace details
27 {
28 
29 template <typename T, typename U>
30 using ServerObject = typename sdbusplus::server::object::object<T, U>;
31 
32 using VLANCreateIface = details::ServerObject<
33     sdbusplus::xyz::openbmc_project::Network::VLAN::server::Create,
34     sdbusplus::xyz::openbmc_project::Common::server::FactoryReset>;
35 
36 } // namespace details
37 
38 /** @class Manager
39  *  @brief OpenBMC network manager implementation.
40  */
41 class Manager : public details::VLANCreateIface
42 {
43   public:
44     Manager() = delete;
45     Manager(const Manager&) = delete;
46     Manager& operator=(const Manager&) = delete;
47     Manager(Manager&&) = delete;
48     Manager& operator=(Manager&&) = delete;
49     virtual ~Manager() = default;
50 
51     /** @brief Constructor to put object onto bus at a dbus path.
52      *  @param[in] bus - Bus to attach to.
53      *  @param[in] objPath - Path to attach at.
54      *  @param[in] dir - Network Configuration directory path.
55      */
56     Manager(sdbusplus::bus::bus& bus, const char* objPath,
57             const std::string& dir);
58 
59     ObjectPath vlan(IntfName interfaceName, uint32_t id) override;
60 
61     /** @brief write the network conf file with the in-memory objects.
62      */
63     void writeToConfigurationFile();
64 
65     /** @brief Fetch the interface and the ipaddress details
66      *         from the system and create the ethernet interraces
67      *         dbus object.
68      */
69     virtual void createInterfaces();
70 
71     /** @brief create child interface object and the system conf object.
72      */
73     void createChildObjects();
74 
75     /** @brief sets the network conf directory.
76      *  @param[in] dirName - Absolute path of the directory.
77      */
78     void setConfDir(const fs::path& dir);
79 
80     /** @brief gets the network conf directory.
81      */
82     fs::path getConfDir()
83     {
84         return confDir;
85     }
86 
87     /** @brief gets the system conf object.
88      *
89      */
90     const SystemConfPtr& getSystemConf()
91     {
92         return systemConf;
93     }
94 
95     /** @brief gets the dhcp conf object.
96      *
97      */
98     const DHCPConfPtr& getDHCPConf()
99     {
100         return dhcpConf;
101     }
102 
103     /** @brief create the default network files for each interface
104      *  @detail if force param is true then forcefully create the network
105      *          files otherwise if network file doesn't exist then
106      *          create it.
107      *  @param[in] force - forcefully create the file
108      *  @return true if network file created else false
109      */
110     bool createDefaultNetworkFiles(bool force);
111 
112     /** @brief restart the network timers. */
113     void restartTimers();
114 
115     /** @brief This function gets the MAC address from the VPD and
116      *  sets it on the corresponding ethernet interface during first
117      *  Boot, once it sets the MAC from VPD, it creates a file named
118      *  firstBoot under /var/lib to make sure we dont run this function
119      *  again.
120      *
121      *  @param[in] ethPair - Its a pair of ethernet interface name & the
122      * corresponding MAC Address from the VPD
123      *
124      *  return - NULL
125      */
126     void setFistBootMACOnInterface(
127         const std::pair<std::string, std::string>& ethPair);
128 
129     /** @brief Restart the systemd unit
130      *  @param[in] unit - systemd unit name which needs to be
131      *                    restarted.
132      */
133     virtual void restartSystemdUnit(const std::string& unit);
134 
135     /** @brief Returns the number of interfaces under this manager.
136      *
137      * @return the number of interfaces managed by this manager.
138      */
139     int getInterfaceCount()
140     {
141         return interfaces.size();
142     }
143 
144     /** @brief Does the requested interface exist under this manager?
145      *
146      * @param[in] intf - the interface name to check.
147      * @return true if found, false otherwise.
148      */
149     bool hasInterface(const std::string& intf)
150     {
151         return (interfaces.find(intf) != interfaces.end());
152     }
153 
154   protected:
155     /** @brief Persistent sdbusplus DBus bus connection. */
156     sdbusplus::bus::bus& bus;
157 
158     /** @brief Persistent map of EthernetInterface dbus objects and their names
159      */
160     std::map<IntfName, std::shared_ptr<EthernetInterface>> interfaces;
161 
162     /** @brief BMC network reset - resets network configuration for BMC. */
163     void reset() override;
164 
165     /** @brief Path of Object. */
166     std::string objectPath;
167 
168     /** @brief pointer to system conf object. */
169     SystemConfPtr systemConf = nullptr;
170 
171     /** @brief pointer to dhcp conf object. */
172     DHCPConfPtr dhcpConf = nullptr;
173 
174     /** @brief Network Configuration directory. */
175     fs::path confDir;
176 };
177 
178 } // namespace network
179 } // namespace phosphor
180