• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <ctype.h>
18 #include <limits.h>
19 #include <stdio.h>
20 #include <string.h>
21 
22 #include <log/log_read.h>
23 
24 #include "log_portability.h"
25 
26 LIBLOG_ABI_PRIVATE const char log_time::default_format[] = "%m-%d %H:%M:%S.%q";
27 LIBLOG_ABI_PRIVATE const timespec log_time::EPOCH = { 0, 0 };
28 
29 // Add %#q for fractional seconds to standard strptime function
30 
strptime(const char * s,const char * format)31 LIBLOG_ABI_PRIVATE char *log_time::strptime(const char *s, const char *format) {
32     time_t now;
33 #ifdef __linux__
34     *this = log_time(CLOCK_REALTIME);
35     now = tv_sec;
36 #else
37     time(&now);
38     tv_sec = now;
39     tv_nsec = 0;
40 #endif
41 
42     struct tm *ptm;
43 #if !defined(_WIN32)
44     struct tm tmBuf;
45     ptm = localtime_r(&now, &tmBuf);
46 #else
47     ptm = localtime(&now);
48 #endif
49 
50     char fmt[strlen(format) + 1];
51     strcpy(fmt, format);
52 
53     char *ret = const_cast<char *> (s);
54     char *cp;
55     for (char *f = cp = fmt; ; ++cp) {
56         if (!*cp) {
57             if (f != cp) {
58                 ret = ::strptime(ret, f, ptm);
59             }
60             break;
61         }
62         if (*cp != '%') {
63             continue;
64         }
65         char *e = cp;
66         ++e;
67 #if (defined(__BIONIC__))
68         if (*e == 's') {
69             *cp = '\0';
70             if (*f) {
71                 ret = ::strptime(ret, f, ptm);
72                 if (!ret) {
73                     break;
74                 }
75             }
76             tv_sec = 0;
77             while (isdigit(*ret)) {
78                 tv_sec = tv_sec * 10 + *ret - '0';
79                 ++ret;
80             }
81             now = tv_sec;
82 #if !defined(_WIN32)
83             ptm = localtime_r(&now, &tmBuf);
84 #else
85             ptm = localtime(&now);
86 #endif
87         } else
88 #endif
89         {
90             unsigned num = 0;
91             while (isdigit(*e)) {
92                 num = num * 10 + *e - '0';
93                 ++e;
94             }
95             if (*e != 'q') {
96                 continue;
97             }
98             *cp = '\0';
99             if (*f) {
100                 ret = ::strptime(ret, f, ptm);
101                 if (!ret) {
102                     break;
103                 }
104             }
105             unsigned long mul = NS_PER_SEC;
106             if (num == 0) {
107                 num = INT_MAX;
108             }
109             tv_nsec = 0;
110             while (isdigit(*ret) && num && (mul > 1)) {
111                 --num;
112                 mul /= 10;
113                 tv_nsec = tv_nsec + (*ret - '0') * mul;
114                 ++ret;
115             }
116         }
117         f = cp = e;
118         ++f;
119     }
120 
121     if (ret) {
122         tv_sec = mktime(ptm);
123         return ret;
124     }
125 
126     // Upon error, place a known value into the class, the current time.
127 #ifdef __linux__
128     *this = log_time(CLOCK_REALTIME);
129 #else
130     time(&now);
131     tv_sec = now;
132     tv_nsec = 0;
133 #endif
134     return ret;
135 }
136 
operator -=(const timespec & T)137 LIBLOG_ABI_PRIVATE log_time log_time::operator-= (const timespec &T) {
138     // No concept of negative time, clamp to EPOCH
139     if (*this <= T) {
140         return *this = EPOCH;
141     }
142 
143     if (this->tv_nsec < (unsigned long int)T.tv_nsec) {
144         --this->tv_sec;
145         this->tv_nsec = NS_PER_SEC + this->tv_nsec - T.tv_nsec;
146     } else {
147         this->tv_nsec -= T.tv_nsec;
148     }
149     this->tv_sec -= T.tv_sec;
150 
151     return *this;
152 }
153 
operator +=(const timespec & T)154 LIBLOG_ABI_PRIVATE log_time log_time::operator+= (const timespec &T) {
155     this->tv_nsec += (unsigned long int)T.tv_nsec;
156     if (this->tv_nsec >= NS_PER_SEC) {
157         this->tv_nsec -= NS_PER_SEC;
158         ++this->tv_sec;
159     }
160     this->tv_sec += T.tv_sec;
161 
162     return *this;
163 }
164 
operator -=(const log_time & T)165 LIBLOG_ABI_PRIVATE log_time log_time::operator-= (const log_time &T) {
166     // No concept of negative time, clamp to EPOCH
167     if (*this <= T) {
168         return *this = EPOCH;
169     }
170 
171     if (this->tv_nsec < T.tv_nsec) {
172         --this->tv_sec;
173         this->tv_nsec = NS_PER_SEC + this->tv_nsec - T.tv_nsec;
174     } else {
175         this->tv_nsec -= T.tv_nsec;
176     }
177     this->tv_sec -= T.tv_sec;
178 
179     return *this;
180 }
181 
operator +=(const log_time & T)182 LIBLOG_ABI_PRIVATE log_time log_time::operator+= (const log_time &T) {
183     this->tv_nsec += T.tv_nsec;
184     if (this->tv_nsec >= NS_PER_SEC) {
185         this->tv_nsec -= NS_PER_SEC;
186         ++this->tv_sec;
187     }
188     this->tv_sec += T.tv_sec;
189 
190     return *this;
191 }
192