1 /*
2 * Copyright (C) 2022 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
16 #include <cstdint>
17 #include <cinttypes>
18 #include <cstdio>
19 #include <cstring>
20 #include <unistd.h>
21 #include <securec.h>
22 #include "time_common.h"
23 #include "sntp_client.h"
24 #include "ntp_trusted_time.h"
25
26 namespace OHOS {
27 namespace MiscServices {
28 namespace {
29 constexpr int64_t INVALID_MILLIS = -1;
30 constexpr int64_t HALF = 2;
31 }
32
NtpTrustedTime()33 NtpTrustedTime::NtpTrustedTime() {}
~NtpTrustedTime()34 NtpTrustedTime::~NtpTrustedTime() {}
35
ForceRefresh(std::string ntpServer)36 bool NtpTrustedTime::ForceRefresh(std::string ntpServer)
37 {
38 TIME_HILOGD(TIME_MODULE_SERVICE, "start.");
39 SNTPClient client;
40 if (client.RequestTime(ntpServer)) {
41 if (mTimeResult != nullptr) {
42 mTimeResult->Clear();
43 }
44 int64_t ntpCertainty = client.getRoundTripTime() / HALF;
45 mTimeResult = std::make_shared<TimeResult>(client.getNtpTIme(), client.getNtpTimeReference(), ntpCertainty);
46 TIME_HILOGD(TIME_MODULE_SERVICE, "Get Ntp time result");
47 TIME_HILOGD(TIME_MODULE_SERVICE, "true end.");
48 return true;
49 } else {
50 if (client.RequestTime(ntpServer)) {
51 if (mTimeResult != nullptr) {
52 mTimeResult->Clear();
53 }
54 int64_t ntpCertnR = client.getRoundTripTime() / HALF;
55 mTimeResult = std::make_shared<TimeResult>(client.getNtpTIme(), client.getNtpTimeReference(), ntpCertnR);
56 TIME_HILOGD(TIME_MODULE_SERVICE, "Re Get Ntp time result");
57 TIME_HILOGD(TIME_MODULE_SERVICE, "Re true end.");
58 return true;
59 } else {
60 TIME_HILOGD(TIME_MODULE_SERVICE, "false end.");
61 return false;
62 }
63 }
64 }
65
CurrentTimeMillis()66 int64_t NtpTrustedTime::CurrentTimeMillis()
67 {
68 TIME_HILOGD(TIME_MODULE_SERVICE, "start.");
69 if (mTimeResult == nullptr) {
70 TIME_HILOGD(TIME_MODULE_SERVICE, "Missing authoritative time source");
71 return INVALID_MILLIS;
72 }
73 TIME_HILOGD(TIME_MODULE_SERVICE, "end.");
74 return mTimeResult->CurrentTimeMillis();
75 }
76
HasCache()77 bool NtpTrustedTime::HasCache()
78 {
79 return mTimeResult == nullptr;
80 }
81
GetCacheAge()82 int64_t NtpTrustedTime::GetCacheAge()
83 {
84 if (mTimeResult != nullptr) {
85 return std::chrono::duration_cast<std::chrono::milliseconds>
86 (std::chrono::steady_clock::now().time_since_epoch()).count() - mTimeResult->GetElapsedRealtimeMillis();
87 } else {
88 return INT_MAX;
89 }
90 }
91
GetCachedNtpTime()92 int64_t NtpTrustedTime::GetCachedNtpTime()
93 {
94 return mTimeResult == nullptr ? 0 : mTimeResult->GetTimeMillis();
95 }
96
GetCachedNtpTimeReference()97 int64_t NtpTrustedTime::GetCachedNtpTimeReference()
98 {
99 return mTimeResult == nullptr ? 0 : mTimeResult->GetElapsedRealtimeMillis();
100 }
101
GetTimeMillis()102 int64_t NtpTrustedTime::TimeResult::GetTimeMillis()
103 {
104 return mTimeMillis;
105 }
106
GetElapsedRealtimeMillis()107 int64_t NtpTrustedTime::TimeResult::GetElapsedRealtimeMillis()
108 {
109 return mElapsedRealtimeMillis;
110 }
111
GetCertaintyMillis()112 int64_t NtpTrustedTime::TimeResult::GetCertaintyMillis()
113 {
114 return mCertaintyMillis;
115 }
116
CurrentTimeMillis()117 int64_t NtpTrustedTime::TimeResult::CurrentTimeMillis()
118 {
119 return mTimeMillis + GetAgeMillis();
120 }
121
GetAgeMillis()122 int64_t NtpTrustedTime::TimeResult::GetAgeMillis()
123 {
124 return std::chrono::duration_cast<std::chrono::milliseconds>
125 (std::chrono::steady_clock::now().time_since_epoch()).count() - this->mElapsedRealtimeMillis;
126 }
127
TimeResult()128 NtpTrustedTime::TimeResult::TimeResult() {}
~TimeResult()129 NtpTrustedTime::TimeResult::~TimeResult() {}
130
TimeResult(int64_t mTimeMillis,int64_t mElapsedRealtimeMills,int64_t mCertaintyMillis)131 NtpTrustedTime::TimeResult::TimeResult(int64_t mTimeMillis, int64_t mElapsedRealtimeMills, int64_t mCertaintyMillis)
132 {
133 this->mTimeMillis = mTimeMillis;
134 this->mElapsedRealtimeMillis = mElapsedRealtimeMills;
135 this->mCertaintyMillis = mCertaintyMillis;
136 TIME_HILOGD(TIME_MODULE_SERVICE, "mTimeMillis %{public}" PRId64 "", mTimeMillis);
137 TIME_HILOGD(TIME_MODULE_SERVICE, "mElapsedRealtimeMills %{public}" PRId64 "", mElapsedRealtimeMills);
138 TIME_HILOGD(TIME_MODULE_SERVICE, "mCertaintyMillis %{public}" PRId64 "", mCertaintyMillis);
139 }
140
Clear()141 void NtpTrustedTime::TimeResult::Clear()
142 {
143 TIME_HILOGD(TIME_MODULE_SERVICE, "start.");
144 (void)memset_s(this, sizeof(*this), 0, sizeof(*this));
145 TIME_HILOGD(TIME_MODULE_SERVICE, "end.");
146 }
147 } // MiscServices
148 } // OHOS