1/*
2 * Copyright (C) 2021-2023 Huawei Device Co., Ltd.
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#include "dhcp_server_impl.h"
16#include "dhcp_server_proxy.h"
17#ifndef OHOS_ARCH_LITE
18#include "dhcp_sa_manager.h"
19#include "i_dhcp_server.h"
20#include "iremote_broker.h"
21#include "iremote_object.h"
22#include "iservice_registry.h"
23#endif
24#include "dhcp_logger.h"
25
26DEFINE_DHCPLOG_DHCP_LABEL("DhcpServerImpl");
27
28namespace OHOS {
29namespace DHCP {
30#define RETURN_IF_FAIL(cond)                          \
31    do {                                              \
32        if (!(cond)) {                                \
33            DHCP_LOGI("'%{public}s' failed.", #cond); \
34            return DHCP_E_FAILED;                     \
35        }                                             \
36    } while (0)
37
38DhcpServerImpl::DhcpServerImpl() : client_(nullptr)
39{
40    DHCP_LOGI("DhcpServerImpl()");
41}
42
43DhcpServerImpl::~DhcpServerImpl()
44{
45    DHCP_LOGI("~DhcpServerImpl()");
46#ifdef OHOS_ARCH_LITE
47    DhcpServerProxy::ReleaseInstance();
48#endif
49}
50
51bool DhcpServerImpl::Init(int systemAbilityId)
52{
53    DHCP_LOGI("DhcpServerImpl enter Init!");
54#ifdef OHOS_ARCH_LITE
55    DhcpServerProxy *serverProxy = DhcpServerProxy::GetInstance();
56    if (serverProxy == nullptr) {
57        DHCP_LOGE("get dhcp server proxy failed.");
58        return false;
59    }
60    if (clientProxy->Init() != DHCP_OPT_SUCCESS) {
61        DHCP_LOGE("dhcp server proxy init failed.");
62        DhcpServerProxy::ReleaseInstance();
63        return false;
64    }
65    client_ = clientProxy;
66    return true;
67#else
68    systemAbilityId_ = systemAbilityId;
69    return true;
70#endif
71}
72
73bool DhcpServerImpl::GetDhcpServerProxy()
74{
75#ifdef OHOS_ARCH_LITE
76    return (client_ != nullptr);
77#else
78    DhcpSaLoadManager::GetInstance().LoadWifiSa(systemAbilityId_);
79    if (IsRemoteDied() == false) {
80        DHCP_LOGE("remote died false, %{public}d", systemAbilityId_);
81        return true;
82    }
83    sptr<ISystemAbilityManager> sa_mgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
84    if (sa_mgr == nullptr) {
85        DHCP_LOGE("failed to get SystemAbilityManager");
86        return false;
87    }
88    sptr<IRemoteObject> object = sa_mgr->GetSystemAbility(systemAbilityId_);
89    if (object == nullptr) {
90        DHCP_LOGE("failed to get DEVICE_SERVICE");
91        return false;
92    }
93    client_ = iface_cast<OHOS::DHCP::IDhcpServer>(object);
94    if (client_ == nullptr) {
95        client_ = new (std::nothrow)DhcpServerProxy(object);
96    }
97
98    if (client_ == nullptr) {
99        DHCP_LOGE("wifi device init failed. %{public}d", systemAbilityId_);
100        return false;
101    }
102    DHCP_LOGI("DhcpServerImpl GetDhcpClientProxy ok");
103    return true;
104#endif
105}
106
107bool DhcpServerImpl::IsRemoteDied(void)
108{
109    return (client_ == nullptr) ? true : client_->IsRemoteDied();
110}
111
112#ifdef OHOS_ARCH_LITE
113ErrCode DhcpServerImpl::RegisterDhcpServerCallBack(const std::string& ifname,
114    const std::shared_ptr<IDhcpServerCallBack> &callback)
115#else
116ErrCode DhcpServerImpl::RegisterDhcpServerCallBack(const std::string& ifname,
117    const sptr<IDhcpServerCallBack> &callback)
118#endif
119{
120    std::lock_guard<std::mutex> lock(mutex_);
121    RETURN_IF_FAIL(GetDhcpServerProxy());
122    return client_->RegisterDhcpServerCallBack(ifname, callback);
123}
124
125ErrCode DhcpServerImpl::StartDhcpServer(const std::string& ifname)
126{
127    DHCP_LOGI("%{public}s  %{public}d  start", __func__, __LINE__);
128    std::lock_guard<std::mutex> lock(mutex_);
129    RETURN_IF_FAIL(GetDhcpServerProxy());
130    return client_->StartDhcpServer(ifname);
131}
132
133ErrCode DhcpServerImpl::StopDhcpServer(const std::string& ifname)
134{
135    std::lock_guard<std::mutex> lock(mutex_);
136    RETURN_IF_FAIL(GetDhcpServerProxy());
137    return client_->StopDhcpServer(ifname);
138}
139
140ErrCode DhcpServerImpl::PutDhcpRange(const std::string& tagName, const DhcpRange& range)
141{
142    std::lock_guard<std::mutex> lock(mutex_);
143    RETURN_IF_FAIL(GetDhcpServerProxy());
144    return client_->PutDhcpRange(tagName, range);
145}
146
147ErrCode DhcpServerImpl::RemoveDhcpRange(const std::string& tagName, const DhcpRange& range)
148{
149    std::lock_guard<std::mutex> lock(mutex_);
150    RETURN_IF_FAIL(GetDhcpServerProxy());
151    return client_->RemoveDhcpRange(tagName, range);
152}
153
154ErrCode DhcpServerImpl::RemoveAllDhcpRange(const std::string& tagName)
155{
156    std::lock_guard<std::mutex> lock(mutex_);
157    RETURN_IF_FAIL(GetDhcpServerProxy());
158    return client_->RemoveAllDhcpRange(tagName);
159}
160
161ErrCode DhcpServerImpl::SetDhcpRange(const std::string& ifname, const DhcpRange& range)
162{
163    std::lock_guard<std::mutex> lock(mutex_);
164    RETURN_IF_FAIL(GetDhcpServerProxy());
165    return client_->SetDhcpRange(ifname, range);
166}
167
168ErrCode DhcpServerImpl::SetDhcpName(const std::string& ifname, const std::string& tagName)
169{
170    std::lock_guard<std::mutex> lock(mutex_);
171    RETURN_IF_FAIL(GetDhcpServerProxy());
172    return client_->SetDhcpName(ifname, tagName);
173}
174
175ErrCode DhcpServerImpl::GetDhcpClientInfos(const std::string& ifname, std::vector<std::string>& dhcpClientInfo)
176{
177    std::lock_guard<std::mutex> lock(mutex_);
178    RETURN_IF_FAIL(GetDhcpServerProxy());
179    return client_->GetDhcpClientInfos(ifname, dhcpClientInfo);
180}
181
182ErrCode DhcpServerImpl::UpdateLeasesTime(const std::string& leaseTime)
183{
184    std::lock_guard<std::mutex> lock(mutex_);
185    RETURN_IF_FAIL(GetDhcpServerProxy());
186    return client_->UpdateLeasesTime(leaseTime);
187}
188}  // namespace DHCP
189}  // namespace OHOS
190