1 /*
2  * Copyright (C) 2012-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 <endian.h>
19 #include <fcntl.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <time.h>
23 #include <unistd.h>
24 
25 #include <private/android_logger.h>
26 
27 #include "LogBuffer.h"
28 #include "LogBufferElement.h"
29 #include "LogCommand.h"
30 #include "LogReader.h"
31 #include "LogUtils.h"
32 
33 const log_time LogBufferElement::FLUSH_ERROR((uint32_t)-1, (uint32_t)-1);
34 atomic_int_fast64_t LogBufferElement::sequence(1);
35 
LogBufferElement(log_id_t log_id,log_time realtime,uid_t uid,pid_t pid,pid_t tid,const char * msg,unsigned short len)36 LogBufferElement::LogBufferElement(log_id_t log_id, log_time realtime,
37                                    uid_t uid, pid_t pid, pid_t tid,
38                                    const char* msg, unsigned short len)
39     : mUid(uid),
40       mPid(pid),
41       mTid(tid),
42       mRealTime(realtime),
43       mMsgLen(len),
44       mLogId(log_id),
45       mDropped(false) {
46     mMsg = new char[len];
47     memcpy(mMsg, msg, len);
48 }
49 
LogBufferElement(const LogBufferElement & elem)50 LogBufferElement::LogBufferElement(const LogBufferElement& elem)
51     : mUid(elem.mUid),
52       mPid(elem.mPid),
53       mTid(elem.mTid),
54       mRealTime(elem.mRealTime),
55       mMsgLen(elem.mMsgLen),
56       mLogId(elem.mLogId),
57       mDropped(elem.mDropped) {
58     mMsg = new char[mMsgLen];
59     memcpy(mMsg, elem.mMsg, mMsgLen);
60 }
61 
~LogBufferElement()62 LogBufferElement::~LogBufferElement() {
63     delete[] mMsg;
64 }
65 
getTag() const66 uint32_t LogBufferElement::getTag() const {
67     return (isBinary() &&
68             ((mDropped && mMsg != nullptr) ||
69              (!mDropped && mMsgLen >= sizeof(android_event_header_t))))
70                ? reinterpret_cast<const android_event_header_t*>(mMsg)->tag
71                : 0;
72 }
73 
setDropped(unsigned short value)74 unsigned short LogBufferElement::setDropped(unsigned short value) {
75     // The tag information is saved in mMsg data, if the tag is non-zero
76     // save only the information needed to get the tag.
77     if (getTag() != 0) {
78         if (mMsgLen > sizeof(android_event_header_t)) {
79             char* truncated_msg = new char[sizeof(android_event_header_t)];
80             memcpy(truncated_msg, mMsg, sizeof(android_event_header_t));
81             delete[] mMsg;
82             mMsg = truncated_msg;
83         }  // mMsgLen == sizeof(android_event_header_t), already at minimum.
84     } else {
85         delete[] mMsg;
86         mMsg = nullptr;
87     }
88     mDropped = true;
89     return mDroppedCount = value;
90 }
91 
92 // caller must own and free character string
tidToName(pid_t tid)93 char* android::tidToName(pid_t tid) {
94     char* retval = NULL;
95     char buffer[256];
96     snprintf(buffer, sizeof(buffer), "/proc/%u/comm", tid);
97     int fd = open(buffer, O_RDONLY);
98     if (fd >= 0) {
99         ssize_t ret = read(fd, buffer, sizeof(buffer));
100         if (ret >= (ssize_t)sizeof(buffer)) {
101             ret = sizeof(buffer) - 1;
102         }
103         while ((ret > 0) && isspace(buffer[ret - 1])) {
104             --ret;
105         }
106         if (ret > 0) {
107             buffer[ret] = '\0';
108             retval = strdup(buffer);
109         }
110         close(fd);
111     }
112 
113     // if nothing for comm, check out cmdline
114     char* name = android::pidToName(tid);
115     if (!retval) {
116         retval = name;
117         name = NULL;
118     }
119 
120     // check if comm is truncated, see if cmdline has full representation
121     if (name) {
122         // impossible for retval to be NULL if name not NULL
123         size_t retval_len = strlen(retval);
124         size_t name_len = strlen(name);
125         // KISS: ToDo: Only checks prefix truncated, not suffix, or both
126         if ((retval_len < name_len) &&
127             !fastcmp<strcmp>(retval, name + name_len - retval_len)) {
128             free(retval);
129             retval = name;
130         } else {
131             free(name);
132         }
133     }
134     return retval;
135 }
136 
137 // assumption: mMsg == NULL
populateDroppedMessage(char * & buffer,LogBuffer * parent,bool lastSame)138 size_t LogBufferElement::populateDroppedMessage(char*& buffer, LogBuffer* parent,
139                                                 bool lastSame) {
140     static const char tag[] = "chatty";
141 
142     if (!__android_log_is_loggable_len(ANDROID_LOG_INFO, tag, strlen(tag),
143                                        ANDROID_LOG_VERBOSE)) {
144         return 0;
145     }
146 
147     static const char format_uid[] = "uid=%u%s%s %s %u line%s";
148     parent->wrlock();
149     const char* name = parent->uidToName(mUid);
150     parent->unlock();
151     const char* commName = android::tidToName(mTid);
152     if (!commName && (mTid != mPid)) {
153         commName = android::tidToName(mPid);
154     }
155     if (!commName) {
156         parent->wrlock();
157         commName = parent->pidToName(mPid);
158         parent->unlock();
159     }
160     if (name && name[0] && commName && (name[0] == commName[0])) {
161         size_t len = strlen(name + 1);
162         if (!strncmp(name + 1, commName + 1, len)) {
163             if (commName[len + 1] == '\0') {
164                 free(const_cast<char*>(commName));
165                 commName = NULL;
166             } else {
167                 free(const_cast<char*>(name));
168                 name = NULL;
169             }
170         }
171     }
172     if (name) {
173         char* buf = NULL;
174         asprintf(&buf, "(%s)", name);
175         if (buf) {
176             free(const_cast<char*>(name));
177             name = buf;
178         }
179     }
180     if (commName) {
181         char* buf = NULL;
182         asprintf(&buf, " %s", commName);
183         if (buf) {
184             free(const_cast<char*>(commName));
185             commName = buf;
186         }
187     }
188     // identical to below to calculate the buffer size required
189     const char* type = lastSame ? "identical" : "expire";
190     size_t len = snprintf(NULL, 0, format_uid, mUid, name ? name : "",
191                           commName ? commName : "", type, getDropped(),
192                           (getDropped() > 1) ? "s" : "");
193 
194     size_t hdrLen;
195     if (isBinary()) {
196         hdrLen = sizeof(android_log_event_string_t);
197     } else {
198         hdrLen = 1 + sizeof(tag);
199     }
200 
201     buffer = static_cast<char*>(calloc(1, hdrLen + len + 1));
202     if (!buffer) {
203         free(const_cast<char*>(name));
204         free(const_cast<char*>(commName));
205         return 0;
206     }
207 
208     size_t retval = hdrLen + len;
209     if (isBinary()) {
210         android_log_event_string_t* event =
211             reinterpret_cast<android_log_event_string_t*>(buffer);
212 
213         event->header.tag = htole32(CHATTY_LOG_TAG);
214         event->type = EVENT_TYPE_STRING;
215         event->length = htole32(len);
216     } else {
217         ++retval;
218         buffer[0] = ANDROID_LOG_INFO;
219         strcpy(buffer + 1, tag);
220     }
221 
222     snprintf(buffer + hdrLen, len + 1, format_uid, mUid, name ? name : "",
223              commName ? commName : "", type, getDropped(),
224              (getDropped() > 1) ? "s" : "");
225     free(const_cast<char*>(name));
226     free(const_cast<char*>(commName));
227 
228     return retval;
229 }
230 
flushTo(SocketClient * reader,LogBuffer * parent,bool privileged,bool lastSame)231 log_time LogBufferElement::flushTo(SocketClient* reader, LogBuffer* parent,
232                                    bool privileged, bool lastSame) {
233     struct logger_entry_v4 entry;
234 
235     memset(&entry, 0, sizeof(struct logger_entry_v4));
236 
237     entry.hdr_size = privileged ? sizeof(struct logger_entry_v4)
238                                 : sizeof(struct logger_entry_v3);
239     entry.lid = mLogId;
240     entry.pid = mPid;
241     entry.tid = mTid;
242     entry.uid = mUid;
243     entry.sec = mRealTime.tv_sec;
244     entry.nsec = mRealTime.tv_nsec;
245 
246     struct iovec iovec[2];
247     iovec[0].iov_base = &entry;
248     iovec[0].iov_len = entry.hdr_size;
249 
250     char* buffer = NULL;
251 
252     if (mDropped) {
253         entry.len = populateDroppedMessage(buffer, parent, lastSame);
254         if (!entry.len) return mRealTime;
255         iovec[1].iov_base = buffer;
256     } else {
257         entry.len = mMsgLen;
258         iovec[1].iov_base = mMsg;
259     }
260     iovec[1].iov_len = entry.len;
261 
262     log_time retval = reader->sendDatav(iovec, 1 + (entry.len != 0))
263                           ? FLUSH_ERROR
264                           : mRealTime;
265 
266     if (buffer) free(buffer);
267 
268     return retval;
269 }
270