Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2007-2016 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 | |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 17 | #include <ctype.h> |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 18 | #include <errno.h> |
| 19 | #include <fcntl.h> |
| 20 | #include <stdbool.h> |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 21 | #include <stdlib.h> |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 22 | #include <string.h> |
| 23 | #include <sys/types.h> |
| 24 | |
| 25 | #include <private/android_filesystem_config.h> |
| 26 | #include <private/android_logger.h> |
| 27 | |
| 28 | #include "config_read.h" |
| 29 | #include "logger.h" |
| 30 | |
| 31 | static int pmsgAvailable(log_id_t logId); |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 32 | static int pmsgVersion(struct android_log_logger* logger, |
| 33 | struct android_log_transport_context* transp); |
| 34 | static int pmsgRead(struct android_log_logger_list* logger_list, |
| 35 | struct android_log_transport_context* transp, |
| 36 | struct log_msg* log_msg); |
| 37 | static void pmsgClose(struct android_log_logger_list* logger_list, |
| 38 | struct android_log_transport_context* transp); |
| 39 | static int pmsgClear(struct android_log_logger* logger, |
| 40 | struct android_log_transport_context* transp); |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 41 | |
| 42 | LIBLOG_HIDDEN struct android_log_transport_read pmsgLoggerRead = { |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 43 | .node = { &pmsgLoggerRead.node, &pmsgLoggerRead.node }, |
| 44 | .name = "pmsg", |
| 45 | .available = pmsgAvailable, |
| 46 | .version = pmsgVersion, |
| 47 | .read = pmsgRead, |
| 48 | .poll = NULL, |
| 49 | .close = pmsgClose, |
| 50 | .clear = pmsgClear, |
| 51 | .setSize = NULL, |
| 52 | .getSize = NULL, |
| 53 | .getReadableSize = NULL, |
| 54 | .getPrune = NULL, |
| 55 | .setPrune = NULL, |
| 56 | .getStats = NULL, |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 57 | }; |
| 58 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 59 | static int pmsgAvailable(log_id_t logId) { |
| 60 | if (logId > LOG_ID_SECURITY) { |
| 61 | return -EINVAL; |
| 62 | } |
| 63 | if (access("/dev/pmsg0", W_OK) == 0) { |
| 64 | return 0; |
| 65 | } |
| 66 | return -EBADF; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | /* Determine the credentials of the caller */ |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 70 | static bool uid_has_log_permission(uid_t uid) { |
| 71 | return (uid == AID_SYSTEM) || (uid == AID_LOG) || (uid == AID_ROOT) || |
| 72 | (uid == AID_LOGD); |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 73 | } |
| 74 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 75 | static uid_t get_best_effective_uid() { |
| 76 | uid_t euid; |
| 77 | uid_t uid; |
| 78 | gid_t gid; |
| 79 | ssize_t i; |
| 80 | static uid_t last_uid = (uid_t)-1; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 81 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 82 | if (last_uid != (uid_t)-1) { |
| 83 | return last_uid; |
| 84 | } |
| 85 | uid = __android_log_uid(); |
| 86 | if (uid_has_log_permission(uid)) { |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 87 | return last_uid = uid; |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 88 | } |
| 89 | euid = geteuid(); |
| 90 | if (uid_has_log_permission(euid)) { |
| 91 | return last_uid = euid; |
| 92 | } |
| 93 | gid = getgid(); |
| 94 | if (uid_has_log_permission(gid)) { |
| 95 | return last_uid = gid; |
| 96 | } |
| 97 | gid = getegid(); |
| 98 | if (uid_has_log_permission(gid)) { |
| 99 | return last_uid = gid; |
| 100 | } |
| 101 | i = getgroups((size_t)0, NULL); |
| 102 | if (i > 0) { |
| 103 | gid_t list[i]; |
| 104 | |
| 105 | getgroups(i, list); |
| 106 | while (--i >= 0) { |
| 107 | if (uid_has_log_permission(list[i])) { |
| 108 | return last_uid = list[i]; |
| 109 | } |
| 110 | } |
| 111 | } |
| 112 | return last_uid = uid; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 113 | } |
| 114 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 115 | static int pmsgClear(struct android_log_logger* logger __unused, |
| 116 | struct android_log_transport_context* transp __unused) { |
| 117 | if (uid_has_log_permission(get_best_effective_uid())) { |
| 118 | return unlink("/sys/fs/pstore/pmsg-ramoops-0"); |
| 119 | } |
| 120 | errno = EPERM; |
| 121 | return -1; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 122 | } |
| 123 | |
| 124 | /* |
| 125 | * returns the logger version |
| 126 | */ |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 127 | static int pmsgVersion(struct android_log_logger* logger __unused, |
| 128 | struct android_log_transport_context* transp __unused) { |
| 129 | return 4; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 130 | } |
| 131 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 132 | static int pmsgRead(struct android_log_logger_list* logger_list, |
| 133 | struct android_log_transport_context* transp, |
| 134 | struct log_msg* log_msg) { |
| 135 | ssize_t ret; |
| 136 | off_t current, next; |
| 137 | uid_t uid; |
| 138 | struct android_log_logger* logger; |
| 139 | struct __attribute__((__packed__)) { |
| 140 | android_pmsg_log_header_t p; |
| 141 | android_log_header_t l; |
| 142 | uint8_t prio; |
| 143 | } buf; |
| 144 | static uint8_t preread_count; |
| 145 | bool is_system; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 146 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 147 | memset(log_msg, 0, sizeof(*log_msg)); |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 148 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 149 | if (atomic_load(&transp->context.fd) <= 0) { |
| 150 | int i, fd = open("/sys/fs/pstore/pmsg-ramoops-0", O_RDONLY | O_CLOEXEC); |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 151 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 152 | if (fd < 0) { |
| 153 | return -errno; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 154 | } |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 155 | if (fd == 0) { /* Argggg */ |
| 156 | fd = open("/sys/fs/pstore/pmsg-ramoops-0", O_RDONLY | O_CLOEXEC); |
| 157 | close(0); |
| 158 | if (fd < 0) { |
| 159 | return -errno; |
| 160 | } |
| 161 | } |
| 162 | i = atomic_exchange(&transp->context.fd, fd); |
| 163 | if ((i > 0) && (i != fd)) { |
| 164 | close(i); |
| 165 | } |
| 166 | preread_count = 0; |
| 167 | } |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 168 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 169 | while (1) { |
| 170 | int fd; |
Mark Salyzyn | 7740d1b | 2016-10-10 07:27:42 -0700 | [diff] [blame] | 171 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 172 | if (preread_count < sizeof(buf)) { |
| 173 | fd = atomic_load(&transp->context.fd); |
| 174 | if (fd <= 0) { |
| 175 | return -EBADF; |
| 176 | } |
| 177 | ret = TEMP_FAILURE_RETRY( |
| 178 | read(fd, &buf.p.magic + preread_count, sizeof(buf) - preread_count)); |
| 179 | if (ret < 0) { |
| 180 | return -errno; |
| 181 | } |
| 182 | preread_count += ret; |
| 183 | } |
| 184 | if (preread_count != sizeof(buf)) { |
| 185 | return preread_count ? -EIO : -EAGAIN; |
| 186 | } |
| 187 | if ((buf.p.magic != LOGGER_MAGIC) || (buf.p.len <= sizeof(buf)) || |
| 188 | (buf.p.len > (sizeof(buf) + LOGGER_ENTRY_MAX_PAYLOAD)) || |
| 189 | (buf.l.id >= LOG_ID_MAX) || (buf.l.realtime.tv_nsec >= NS_PER_SEC) || |
| 190 | ((buf.l.id != LOG_ID_EVENTS) && (buf.l.id != LOG_ID_SECURITY) && |
| 191 | ((buf.prio == ANDROID_LOG_UNKNOWN) || |
| 192 | (buf.prio == ANDROID_LOG_DEFAULT) || |
| 193 | (buf.prio >= ANDROID_LOG_SILENT)))) { |
| 194 | do { |
| 195 | memmove(&buf.p.magic, &buf.p.magic + 1, --preread_count); |
| 196 | } while (preread_count && (buf.p.magic != LOGGER_MAGIC)); |
| 197 | continue; |
| 198 | } |
| 199 | preread_count = 0; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 200 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 201 | if ((transp->logMask & (1 << buf.l.id)) && |
| 202 | ((!logger_list->start.tv_sec && !logger_list->start.tv_nsec) || |
| 203 | ((logger_list->start.tv_sec <= buf.l.realtime.tv_sec) && |
| 204 | ((logger_list->start.tv_sec != buf.l.realtime.tv_sec) || |
| 205 | (logger_list->start.tv_nsec <= buf.l.realtime.tv_nsec)))) && |
| 206 | (!logger_list->pid || (logger_list->pid == buf.p.pid))) { |
| 207 | uid = get_best_effective_uid(); |
| 208 | is_system = uid_has_log_permission(uid); |
| 209 | if (is_system || (uid == buf.p.uid)) { |
| 210 | char* msg = is_system ? log_msg->entry_v4.msg : log_msg->entry_v3.msg; |
| 211 | *msg = buf.prio; |
Mark Salyzyn | 7740d1b | 2016-10-10 07:27:42 -0700 | [diff] [blame] | 212 | fd = atomic_load(&transp->context.fd); |
| 213 | if (fd <= 0) { |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 214 | return -EBADF; |
Mark Salyzyn | 7740d1b | 2016-10-10 07:27:42 -0700 | [diff] [blame] | 215 | } |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 216 | ret = TEMP_FAILURE_RETRY( |
| 217 | read(fd, msg + sizeof(buf.prio), buf.p.len - sizeof(buf))); |
| 218 | if (ret < 0) { |
| 219 | return -errno; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 220 | } |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 221 | if (ret != (ssize_t)(buf.p.len - sizeof(buf))) { |
| 222 | return -EIO; |
Mark Salyzyn | 7740d1b | 2016-10-10 07:27:42 -0700 | [diff] [blame] | 223 | } |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 224 | |
| 225 | log_msg->entry_v4.len = buf.p.len - sizeof(buf) + sizeof(buf.prio); |
| 226 | log_msg->entry_v4.hdr_size = |
| 227 | is_system ? sizeof(log_msg->entry_v4) : sizeof(log_msg->entry_v3); |
| 228 | log_msg->entry_v4.pid = buf.p.pid; |
| 229 | log_msg->entry_v4.tid = buf.l.tid; |
| 230 | log_msg->entry_v4.sec = buf.l.realtime.tv_sec; |
| 231 | log_msg->entry_v4.nsec = buf.l.realtime.tv_nsec; |
| 232 | log_msg->entry_v4.lid = buf.l.id; |
| 233 | if (is_system) { |
| 234 | log_msg->entry_v4.uid = buf.p.uid; |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 235 | } |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 236 | |
| 237 | return ret + sizeof(buf.prio) + log_msg->entry_v4.hdr_size; |
| 238 | } |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 239 | } |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 240 | |
| 241 | fd = atomic_load(&transp->context.fd); |
| 242 | if (fd <= 0) { |
| 243 | return -EBADF; |
| 244 | } |
| 245 | current = TEMP_FAILURE_RETRY(lseek(fd, (off_t)0, SEEK_CUR)); |
| 246 | if (current < 0) { |
| 247 | return -errno; |
| 248 | } |
| 249 | fd = atomic_load(&transp->context.fd); |
| 250 | if (fd <= 0) { |
| 251 | return -EBADF; |
| 252 | } |
| 253 | next = TEMP_FAILURE_RETRY( |
| 254 | lseek(fd, (off_t)(buf.p.len - sizeof(buf)), SEEK_CUR)); |
| 255 | if (next < 0) { |
| 256 | return -errno; |
| 257 | } |
| 258 | if ((next - current) != (ssize_t)(buf.p.len - sizeof(buf))) { |
| 259 | return -EIO; |
| 260 | } |
| 261 | } |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 262 | } |
| 263 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 264 | static void pmsgClose(struct android_log_logger_list* logger_list __unused, |
| 265 | struct android_log_transport_context* transp) { |
| 266 | int fd = atomic_exchange(&transp->context.fd, 0); |
| 267 | if (fd > 0) { |
| 268 | close(fd); |
| 269 | } |
Mark Salyzyn | c5ae20f | 2016-03-01 13:45:42 -0800 | [diff] [blame] | 270 | } |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 271 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 272 | LIBLOG_ABI_PRIVATE ssize_t |
| 273 | __android_log_pmsg_file_read(log_id_t logId, char prio, const char* prefix, |
| 274 | __android_log_pmsg_file_read_fn fn, void* arg) { |
| 275 | ssize_t ret; |
| 276 | struct android_log_logger_list logger_list; |
| 277 | struct android_log_transport_context transp; |
| 278 | struct content { |
| 279 | struct listnode node; |
| 280 | union { |
| 281 | struct logger_entry_v4 entry; |
| 282 | struct logger_entry_v4 entry_v4; |
| 283 | struct logger_entry_v3 entry_v3; |
| 284 | struct logger_entry_v2 entry_v2; |
| 285 | struct logger_entry entry_v1; |
| 286 | }; |
| 287 | } * content; |
| 288 | struct names { |
| 289 | struct listnode node; |
| 290 | struct listnode content; |
| 291 | log_id_t id; |
| 292 | char prio; |
| 293 | char name[]; |
| 294 | } * names; |
| 295 | struct listnode name_list; |
| 296 | struct listnode *node, *n; |
| 297 | size_t len, prefix_len; |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 298 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 299 | if (!fn) { |
| 300 | return -EINVAL; |
| 301 | } |
| 302 | |
| 303 | /* Add just enough clues in logger_list and transp to make API function */ |
| 304 | memset(&logger_list, 0, sizeof(logger_list)); |
| 305 | memset(&transp, 0, sizeof(transp)); |
| 306 | |
| 307 | logger_list.mode = |
| 308 | ANDROID_LOG_PSTORE | ANDROID_LOG_NONBLOCK | ANDROID_LOG_RDONLY; |
| 309 | transp.logMask = (unsigned)-1; |
| 310 | if (logId != LOG_ID_ANY) { |
| 311 | transp.logMask = (1 << logId); |
| 312 | } |
| 313 | transp.logMask &= |
| 314 | ~((1 << LOG_ID_KERNEL) | (1 << LOG_ID_EVENTS) | (1 << LOG_ID_SECURITY)); |
| 315 | if (!transp.logMask) { |
| 316 | return -EINVAL; |
| 317 | } |
| 318 | |
| 319 | /* Initialize name list */ |
| 320 | list_init(&name_list); |
| 321 | |
| 322 | ret = SSIZE_MAX; |
| 323 | |
| 324 | /* Validate incoming prefix, shift until it contains only 0 or 1 : or / */ |
| 325 | prefix_len = 0; |
| 326 | if (prefix) { |
| 327 | const char *prev = NULL, *last = NULL, *cp = prefix; |
| 328 | while ((cp = strpbrk(cp, "/:"))) { |
| 329 | prev = last; |
| 330 | last = cp; |
| 331 | cp = cp + 1; |
| 332 | } |
| 333 | if (prev) { |
| 334 | prefix = prev + 1; |
| 335 | } |
| 336 | prefix_len = strlen(prefix); |
| 337 | } |
| 338 | |
| 339 | /* Read the file content */ |
| 340 | while (pmsgRead(&logger_list, &transp, &transp.logMsg) > 0) { |
| 341 | char* cp; |
| 342 | size_t hdr_size = transp.logMsg.entry.hdr_size |
| 343 | ? transp.logMsg.entry.hdr_size |
| 344 | : sizeof(transp.logMsg.entry_v1); |
| 345 | char* msg = (char*)&transp.logMsg + hdr_size; |
| 346 | char* split = NULL; |
| 347 | |
| 348 | if ((hdr_size < sizeof(transp.logMsg.entry_v1)) || |
| 349 | (hdr_size > sizeof(transp.logMsg.entry))) { |
| 350 | continue; |
| 351 | } |
| 352 | /* Check for invalid sequence number */ |
| 353 | if ((transp.logMsg.entry.nsec % ANDROID_LOG_PMSG_FILE_SEQUENCE) || |
| 354 | ((transp.logMsg.entry.nsec / ANDROID_LOG_PMSG_FILE_SEQUENCE) >= |
| 355 | ANDROID_LOG_PMSG_FILE_MAX_SEQUENCE)) { |
| 356 | continue; |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 357 | } |
| 358 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 359 | /* Determine if it has <dirbase>:<filebase> format for tag */ |
| 360 | len = transp.logMsg.entry.len - sizeof(prio); |
| 361 | for (cp = msg + sizeof(prio); *cp && isprint(*cp) && !isspace(*cp) && --len; |
| 362 | ++cp) { |
| 363 | if (*cp == ':') { |
| 364 | if (split) { |
| 365 | break; |
| 366 | } |
| 367 | split = cp; |
| 368 | } |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 369 | } |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 370 | if (*cp || !split) { |
| 371 | continue; |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 372 | } |
| 373 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 374 | /* Filters */ |
| 375 | if (prefix_len && strncmp(msg + sizeof(prio), prefix, prefix_len)) { |
| 376 | size_t offset; |
| 377 | /* |
| 378 | * Allow : to be a synonym for / |
| 379 | * Things we do dealing with const char * and do not alloc |
| 380 | */ |
| 381 | split = strchr(prefix, ':'); |
| 382 | if (split) { |
| 383 | continue; |
| 384 | } |
| 385 | split = strchr(prefix, '/'); |
| 386 | if (!split) { |
| 387 | continue; |
| 388 | } |
| 389 | offset = split - prefix; |
| 390 | if ((msg[offset + sizeof(prio)] != ':') || |
| 391 | strncmp(msg + sizeof(prio), prefix, offset)) { |
| 392 | continue; |
| 393 | } |
| 394 | ++offset; |
| 395 | if ((prefix_len > offset) && strncmp(&msg[offset + sizeof(prio)], |
| 396 | split + 1, prefix_len - offset)) { |
| 397 | continue; |
| 398 | } |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 399 | } |
| 400 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 401 | if ((prio != ANDROID_LOG_ANY) && (*msg < prio)) { |
| 402 | continue; |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 403 | } |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 404 | |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 405 | /* check if there is an existing entry */ |
| 406 | list_for_each(node, &name_list) { |
| 407 | names = node_to_item(node, struct names, node); |
| 408 | if (!strcmp(names->name, msg + sizeof(prio)) && |
| 409 | (names->id == transp.logMsg.entry.lid) && (names->prio == *msg)) { |
| 410 | break; |
| 411 | } |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 412 | } |
Mark Salyzyn | a2d59f8 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 413 | |
| 414 | /* We do not have an existing entry, create and add one */ |
| 415 | if (node == &name_list) { |
| 416 | static const char numbers[] = "0123456789"; |
| 417 | unsigned long long nl; |
| 418 | |
| 419 | len = strlen(msg + sizeof(prio)) + 1; |
| 420 | names = calloc(1, sizeof(*names) + len); |
| 421 | if (!names) { |
| 422 | ret = -ENOMEM; |
| 423 | break; |
| 424 | } |
| 425 | strcpy(names->name, msg + sizeof(prio)); |
| 426 | names->id = transp.logMsg.entry.lid; |
| 427 | names->prio = *msg; |
| 428 | list_init(&names->content); |
| 429 | /* |
| 430 | * Insert in reverse numeric _then_ alpha sorted order as |
| 431 | * representative of log rotation: |
| 432 | * |
| 433 | * log.10 |
| 434 | * klog.10 |
| 435 | * . . . |
| 436 | * log.2 |
| 437 | * klog.2 |
| 438 | * log.1 |
| 439 | * klog.1 |
| 440 | * log |
| 441 | * klog |
| 442 | * |
| 443 | * thus when we present the content, we are provided the oldest |
| 444 | * first, which when 'refreshed' could spill off the end of the |
| 445 | * pmsg FIFO but retaining the newest data for last with best |
| 446 | * chances to survive. |
| 447 | */ |
| 448 | nl = 0; |
| 449 | cp = strpbrk(names->name, numbers); |
| 450 | if (cp) { |
| 451 | nl = strtoull(cp, NULL, 10); |
| 452 | } |
| 453 | list_for_each_reverse(node, &name_list) { |
| 454 | struct names* a_name = node_to_item(node, struct names, node); |
| 455 | const char* r = a_name->name; |
| 456 | int compare = 0; |
| 457 | |
| 458 | unsigned long long nr = 0; |
| 459 | cp = strpbrk(r, numbers); |
| 460 | if (cp) { |
| 461 | nr = strtoull(cp, NULL, 10); |
| 462 | } |
| 463 | if (nr != nl) { |
| 464 | compare = (nl > nr) ? 1 : -1; |
| 465 | } |
| 466 | if (compare == 0) { |
| 467 | compare = strcmp(names->name, r); |
| 468 | } |
| 469 | if (compare <= 0) { |
| 470 | break; |
| 471 | } |
| 472 | } |
| 473 | list_add_head(node, &names->node); |
| 474 | } |
| 475 | |
| 476 | /* Remove any file fragments that match our sequence number */ |
| 477 | list_for_each_safe(node, n, &names->content) { |
| 478 | content = node_to_item(node, struct content, node); |
| 479 | if (transp.logMsg.entry.nsec == content->entry.nsec) { |
| 480 | list_remove(&content->node); |
| 481 | free(content); |
| 482 | } |
| 483 | } |
| 484 | |
| 485 | /* Add content */ |
| 486 | content = |
| 487 | calloc(1, sizeof(content->node) + hdr_size + transp.logMsg.entry.len); |
| 488 | if (!content) { |
| 489 | ret = -ENOMEM; |
| 490 | break; |
| 491 | } |
| 492 | memcpy(&content->entry, &transp.logMsg.entry, |
| 493 | hdr_size + transp.logMsg.entry.len); |
| 494 | |
| 495 | /* Insert in sequence number sorted order, to ease reconstruction */ |
| 496 | list_for_each_reverse(node, &names->content) { |
| 497 | if ((node_to_item(node, struct content, node))->entry.nsec < |
| 498 | transp.logMsg.entry.nsec) { |
| 499 | break; |
| 500 | } |
| 501 | } |
| 502 | list_add_head(node, &content->node); |
| 503 | } |
| 504 | pmsgClose(&logger_list, &transp); |
| 505 | |
| 506 | /* Progress through all the collected files */ |
| 507 | list_for_each_safe(node, n, &name_list) { |
| 508 | struct listnode *content_node, *m; |
| 509 | char* buf; |
| 510 | size_t sequence, tag_len; |
| 511 | |
| 512 | names = node_to_item(node, struct names, node); |
| 513 | |
| 514 | /* Construct content into a linear buffer */ |
| 515 | buf = NULL; |
| 516 | len = 0; |
| 517 | sequence = 0; |
| 518 | tag_len = strlen(names->name) + sizeof(char); /* tag + nul */ |
| 519 | list_for_each_safe(content_node, m, &names->content) { |
| 520 | ssize_t add_len; |
| 521 | |
| 522 | content = node_to_item(content_node, struct content, node); |
| 523 | add_len = content->entry.len - tag_len - sizeof(prio); |
| 524 | if (add_len <= 0) { |
| 525 | list_remove(content_node); |
| 526 | free(content); |
| 527 | continue; |
| 528 | } |
| 529 | |
| 530 | if (!buf) { |
| 531 | buf = malloc(sizeof(char)); |
| 532 | if (!buf) { |
| 533 | ret = -ENOMEM; |
| 534 | list_remove(content_node); |
| 535 | free(content); |
| 536 | continue; |
| 537 | } |
| 538 | *buf = '\0'; |
| 539 | } |
| 540 | |
| 541 | /* Missing sequence numbers */ |
| 542 | while (sequence < content->entry.nsec) { |
| 543 | /* plus space for enforced nul */ |
| 544 | buf = realloc(buf, len + sizeof(char) + sizeof(char)); |
| 545 | if (!buf) { |
| 546 | break; |
| 547 | } |
| 548 | buf[len] = '\f'; /* Mark missing content with a form feed */ |
| 549 | buf[++len] = '\0'; |
| 550 | sequence += ANDROID_LOG_PMSG_FILE_SEQUENCE; |
| 551 | } |
| 552 | if (!buf) { |
| 553 | ret = -ENOMEM; |
| 554 | list_remove(content_node); |
| 555 | free(content); |
| 556 | continue; |
| 557 | } |
| 558 | /* plus space for enforced nul */ |
| 559 | buf = realloc(buf, len + add_len + sizeof(char)); |
| 560 | if (!buf) { |
| 561 | ret = -ENOMEM; |
| 562 | list_remove(content_node); |
| 563 | free(content); |
| 564 | continue; |
| 565 | } |
| 566 | memcpy(buf + len, |
| 567 | (char*)&content->entry + content->entry.hdr_size + tag_len + |
| 568 | sizeof(prio), |
| 569 | add_len); |
| 570 | len += add_len; |
| 571 | buf[len] = '\0'; /* enforce trailing hidden nul */ |
| 572 | sequence = content->entry.nsec + ANDROID_LOG_PMSG_FILE_SEQUENCE; |
| 573 | |
| 574 | list_remove(content_node); |
| 575 | free(content); |
| 576 | } |
| 577 | if (buf) { |
| 578 | if (len) { |
| 579 | /* Buffer contains enforced trailing nul just beyond length */ |
| 580 | ssize_t r; |
| 581 | *strchr(names->name, ':') = '/'; /* Convert back to filename */ |
| 582 | r = (*fn)(names->id, names->prio, names->name, buf, len, arg); |
| 583 | if ((ret >= 0) && (r > 0)) { |
| 584 | if (ret == SSIZE_MAX) { |
| 585 | ret = r; |
| 586 | } else { |
| 587 | ret += r; |
| 588 | } |
| 589 | } else if (r < ret) { |
| 590 | ret = r; |
| 591 | } |
| 592 | } |
| 593 | free(buf); |
| 594 | } |
| 595 | list_remove(node); |
| 596 | free(names); |
| 597 | } |
| 598 | return (ret == SSIZE_MAX) ? -ENOENT : ret; |
Mark Salyzyn | 4457e6b | 2016-03-14 14:15:50 -0700 | [diff] [blame] | 599 | } |