1 /*
2 * Copyright (C) 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
17 #include <errno.h>
18 #include <inttypes.h>
19 #include <stdbool.h>
20 #include <stdint.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include <log/log.h>
26 #include <log/logger.h>
27
28 #include "log_portability.h"
29
30 #define MAX_EVENT_PAYLOAD (LOGGER_ENTRY_MAX_PAYLOAD - sizeof(int32_t))
31
32 typedef struct {
33 uint32_t tag;
34 unsigned pos; /* Read/write position into buffer */
35 unsigned count[ANDROID_MAX_LIST_NEST_DEPTH + 1]; /* Number of elements */
36 unsigned list[ANDROID_MAX_LIST_NEST_DEPTH + 1]; /* pos for list counter */
37 unsigned list_nest_depth;
38 unsigned len; /* Length or raw buffer. */
39 bool overflow;
40 bool list_stop; /* next call decrement list_nest_depth and issue a stop */
41 enum {
42 kAndroidLoggerRead = 1,
43 kAndroidLoggerWrite = 2,
44 } read_write_flag;
45 uint8_t storage[LOGGER_ENTRY_MAX_PAYLOAD];
46 } android_log_context_internal;
47
create_android_logger(uint32_t tag)48 LIBLOG_ABI_PUBLIC android_log_context create_android_logger(uint32_t tag) {
49 size_t needed, i;
50 android_log_context_internal *context;
51
52 context = calloc(1, sizeof(android_log_context_internal));
53 if (!context) {
54 return NULL;
55 }
56 context->tag = tag;
57 context->read_write_flag = kAndroidLoggerWrite;
58 needed = sizeof(uint8_t) + sizeof(uint8_t);
59 if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
60 context->overflow = true;
61 }
62 /* Everything is a list */
63 context->storage[context->pos + 0] = EVENT_TYPE_LIST;
64 context->list[0] = context->pos + 1;
65 context->pos += needed;
66
67 return (android_log_context)context;
68 }
69
create_android_log_parser(const char * msg,size_t len)70 LIBLOG_ABI_PUBLIC android_log_context create_android_log_parser(
71 const char *msg,
72 size_t len) {
73 android_log_context_internal *context;
74 size_t i;
75
76 context = calloc(1, sizeof(android_log_context_internal));
77 if (!context) {
78 return NULL;
79 }
80 len = (len <= MAX_EVENT_PAYLOAD) ? len : MAX_EVENT_PAYLOAD;
81 context->len = len;
82 memcpy(context->storage, msg, len);
83 context->read_write_flag = kAndroidLoggerRead;
84
85 return (android_log_context)context;
86 }
87
android_log_destroy(android_log_context * ctx)88 LIBLOG_ABI_PUBLIC int android_log_destroy(android_log_context *ctx) {
89 android_log_context_internal *context;
90
91 context = (android_log_context_internal *)*ctx;
92 if (!context) {
93 return -EBADF;
94 }
95 memset(context, 0, sizeof(*context));
96 free(context);
97 *ctx = NULL;
98 return 0;
99 }
100
android_log_write_list_begin(android_log_context ctx)101 LIBLOG_ABI_PUBLIC int android_log_write_list_begin(android_log_context ctx) {
102 size_t needed;
103 android_log_context_internal *context;
104
105 context = (android_log_context_internal *)ctx;
106 if (!context ||
107 (kAndroidLoggerWrite != context->read_write_flag)) {
108 return -EBADF;
109 }
110 if (context->list_nest_depth > ANDROID_MAX_LIST_NEST_DEPTH) {
111 context->overflow = true;
112 return -EOVERFLOW;
113 }
114 needed = sizeof(uint8_t) + sizeof(uint8_t);
115 if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
116 context->overflow = true;
117 return -EIO;
118 }
119 context->count[context->list_nest_depth]++;
120 context->list_nest_depth++;
121 if (context->list_nest_depth > ANDROID_MAX_LIST_NEST_DEPTH) {
122 context->overflow = true;
123 return -EOVERFLOW;
124 }
125 if (context->overflow) {
126 return -EIO;
127 }
128 context->storage[context->pos + 0] = EVENT_TYPE_LIST;
129 context->storage[context->pos + 1] = 0;
130 context->list[context->list_nest_depth] = context->pos + 1;
131 context->count[context->list_nest_depth] = 0;
132 context->pos += needed;
133 return 0;
134 }
135
copy4LE(uint8_t * buf,uint32_t val)136 static inline void copy4LE(uint8_t *buf, uint32_t val)
137 {
138 buf[0] = val & 0xFF;
139 buf[1] = (val >> 8) & 0xFF;
140 buf[2] = (val >> 16) & 0xFF;
141 buf[3] = (val >> 24) & 0xFF;
142 }
143
android_log_write_int32(android_log_context ctx,int32_t value)144 LIBLOG_ABI_PUBLIC int android_log_write_int32(android_log_context ctx,
145 int32_t value) {
146 size_t needed;
147 android_log_context_internal *context;
148
149 context = (android_log_context_internal *)ctx;
150 if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
151 return -EBADF;
152 }
153 if (context->overflow) {
154 return -EIO;
155 }
156 needed = sizeof(uint8_t) + sizeof(value);
157 if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
158 context->overflow = true;
159 return -EIO;
160 }
161 context->count[context->list_nest_depth]++;
162 context->storage[context->pos + 0] = EVENT_TYPE_INT;
163 copy4LE(&context->storage[context->pos + 1], value);
164 context->pos += needed;
165 return 0;
166 }
167
copy8LE(uint8_t * buf,uint64_t val)168 static inline void copy8LE(uint8_t *buf, uint64_t val)
169 {
170 buf[0] = val & 0xFF;
171 buf[1] = (val >> 8) & 0xFF;
172 buf[2] = (val >> 16) & 0xFF;
173 buf[3] = (val >> 24) & 0xFF;
174 buf[4] = (val >> 32) & 0xFF;
175 buf[5] = (val >> 40) & 0xFF;
176 buf[6] = (val >> 48) & 0xFF;
177 buf[7] = (val >> 56) & 0xFF;
178 }
179
android_log_write_int64(android_log_context ctx,int64_t value)180 LIBLOG_ABI_PUBLIC int android_log_write_int64(android_log_context ctx,
181 int64_t value) {
182 size_t needed;
183 android_log_context_internal *context;
184
185 context = (android_log_context_internal *)ctx;
186 if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
187 return -EBADF;
188 }
189 if (context->overflow) {
190 return -EIO;
191 }
192 needed = sizeof(uint8_t) + sizeof(value);
193 if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
194 context->overflow = true;
195 return -EIO;
196 }
197 context->count[context->list_nest_depth]++;
198 context->storage[context->pos + 0] = EVENT_TYPE_LONG;
199 copy8LE(&context->storage[context->pos + 1], value);
200 context->pos += needed;
201 return 0;
202 }
203
android_log_write_string8_len(android_log_context ctx,const char * value,size_t maxlen)204 LIBLOG_ABI_PUBLIC int android_log_write_string8_len(android_log_context ctx,
205 const char *value,
206 size_t maxlen) {
207 size_t needed;
208 ssize_t len;
209 android_log_context_internal *context;
210
211 context = (android_log_context_internal *)ctx;
212 if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
213 return -EBADF;
214 }
215 if (context->overflow) {
216 return -EIO;
217 }
218 if (!value) {
219 value = "";
220 }
221 len = strnlen(value, maxlen);
222 needed = sizeof(uint8_t) + sizeof(int32_t) + len;
223 if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
224 /* Truncate string for delivery */
225 len = MAX_EVENT_PAYLOAD - context->pos - 1 - sizeof(int32_t);
226 if (len <= 0) {
227 context->overflow = true;
228 return -EIO;
229 }
230 }
231 context->count[context->list_nest_depth]++;
232 context->storage[context->pos + 0] = EVENT_TYPE_STRING;
233 copy4LE(&context->storage[context->pos + 1], len);
234 if (len) {
235 memcpy(&context->storage[context->pos + 5], value, len);
236 }
237 context->pos += needed;
238 return len;
239 }
240
android_log_write_string8(android_log_context ctx,const char * value)241 LIBLOG_ABI_PUBLIC int android_log_write_string8(android_log_context ctx,
242 const char *value) {
243 return android_log_write_string8_len(ctx, value, MAX_EVENT_PAYLOAD);
244 }
245
android_log_write_float32(android_log_context ctx,float value)246 LIBLOG_ABI_PUBLIC int android_log_write_float32(android_log_context ctx,
247 float value) {
248 size_t needed;
249 uint32_t ivalue;
250 android_log_context_internal *context;
251
252 context = (android_log_context_internal *)ctx;
253 if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
254 return -EBADF;
255 }
256 if (context->overflow) {
257 return -EIO;
258 }
259 needed = sizeof(uint8_t) + sizeof(ivalue);
260 if ((context->pos + needed) > MAX_EVENT_PAYLOAD) {
261 context->overflow = true;
262 return -EIO;
263 }
264 ivalue = *(uint32_t *)&value;
265 context->count[context->list_nest_depth]++;
266 context->storage[context->pos + 0] = EVENT_TYPE_FLOAT;
267 copy4LE(&context->storage[context->pos + 1], ivalue);
268 context->pos += needed;
269 return 0;
270 }
271
android_log_write_list_end(android_log_context ctx)272 LIBLOG_ABI_PUBLIC int android_log_write_list_end(android_log_context ctx) {
273 android_log_context_internal *context;
274
275 context = (android_log_context_internal *)ctx;
276 if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
277 return -EBADF;
278 }
279 if (context->list_nest_depth > ANDROID_MAX_LIST_NEST_DEPTH) {
280 context->overflow = true;
281 context->list_nest_depth--;
282 return -EOVERFLOW;
283 }
284 if (!context->list_nest_depth) {
285 context->overflow = true;
286 return -EOVERFLOW;
287 }
288 if (context->list[context->list_nest_depth] <= 0) {
289 context->list_nest_depth--;
290 context->overflow = true;
291 return -EOVERFLOW;
292 }
293 context->storage[context->list[context->list_nest_depth]] =
294 context->count[context->list_nest_depth];
295 context->list_nest_depth--;
296 return 0;
297 }
298
299 /*
300 * Logs the list of elements to the event log.
301 */
android_log_write_list(android_log_context ctx,log_id_t id)302 LIBLOG_ABI_PUBLIC int android_log_write_list(android_log_context ctx,
303 log_id_t id) {
304 android_log_context_internal *context;
305 const char *msg;
306 ssize_t len;
307
308 if ((id != LOG_ID_EVENTS) && (id != LOG_ID_SECURITY)) {
309 return -EINVAL;
310 }
311
312 context = (android_log_context_internal *)ctx;
313 if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {
314 return -EBADF;
315 }
316 if (context->list_nest_depth) {
317 return -EIO;
318 }
319 /* NB: if there was overflow, then log is truncated. Nothing reported */
320 context->storage[1] = context->count[0];
321 len = context->len = context->pos;
322 msg = (const char *)context->storage;
323 /* it'snot a list */
324 if (context->count[0] <= 1) {
325 len -= sizeof(uint8_t) + sizeof(uint8_t);
326 if (len < 0) {
327 len = 0;
328 }
329 msg += sizeof(uint8_t) + sizeof(uint8_t);
330 }
331 return (id == LOG_ID_EVENTS) ?
332 __android_log_bwrite(context->tag, msg, len) :
333 __android_log_security_bwrite(context->tag, msg, len);
334 }
335
336 /*
337 * Extract a 4-byte value from a byte stream.
338 */
get4LE(const uint8_t * src)339 static inline uint32_t get4LE(const uint8_t* src)
340 {
341 return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
342 }
343
344 /*
345 * Extract an 8-byte value from a byte stream.
346 */
get8LE(const uint8_t * src)347 static inline uint64_t get8LE(const uint8_t* src)
348 {
349 uint32_t low = src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
350 uint32_t high = src[4] | (src[5] << 8) | (src[6] << 16) | (src[7] << 24);
351 return ((uint64_t) high << 32) | (uint64_t) low;
352 }
353
354 /*
355 * Gets the next element. Parsing errors result in an EVENT_TYPE_UNKNOWN type.
356 * If there is nothing to process, the complete field is set to non-zero. If
357 * an EVENT_TYPE_UNKNOWN type is returned once, and the caller does not check
358 * this and continues to call this function, the behavior is undefined
359 * (although it won't crash).
360 */
android_log_read_next_internal(android_log_context ctx,int peek)361 static android_log_list_element android_log_read_next_internal(
362 android_log_context ctx, int peek) {
363 android_log_list_element elem;
364 unsigned pos;
365 android_log_context_internal *context;
366
367 context = (android_log_context_internal *)ctx;
368
369 memset(&elem, 0, sizeof(elem));
370
371 /* Nothing to parse from this context, so return complete. */
372 if (!context || (kAndroidLoggerRead != context->read_write_flag) ||
373 (context->list_nest_depth > ANDROID_MAX_LIST_NEST_DEPTH) ||
374 (context->count[context->list_nest_depth] >=
375 (MAX_EVENT_PAYLOAD / (sizeof(uint8_t) + sizeof(uint8_t))))) {
376 elem.type = EVENT_TYPE_UNKNOWN;
377 if (context &&
378 (context->list_stop ||
379 ((context->list_nest_depth <= ANDROID_MAX_LIST_NEST_DEPTH) &&
380 !context->count[context->list_nest_depth]))) {
381 elem.type = EVENT_TYPE_LIST_STOP;
382 }
383 elem.complete = true;
384 return elem;
385 }
386
387 /*
388 * Use a different variable to update the position in case this
389 * operation is a "peek".
390 */
391 pos = context->pos;
392 if (context->list_stop) {
393 elem.type = EVENT_TYPE_LIST_STOP;
394 elem.complete = !context->count[0] && (!context->list_nest_depth ||
395 ((context->list_nest_depth == 1) && !context->count[1]));
396 if (!peek) {
397 /* Suck in superfluous stop */
398 if (context->storage[pos] == EVENT_TYPE_LIST_STOP) {
399 context->pos = pos + 1;
400 }
401 if (context->list_nest_depth) {
402 --context->list_nest_depth;
403 if (context->count[context->list_nest_depth]) {
404 context->list_stop = false;
405 }
406 } else {
407 context->list_stop = false;
408 }
409 }
410 return elem;
411 }
412 if ((pos + 1) > context->len) {
413 elem.type = EVENT_TYPE_UNKNOWN;
414 elem.complete = true;
415 return elem;
416 }
417
418 elem.type = context->storage[pos++];
419 switch ((int)elem.type) {
420 case EVENT_TYPE_FLOAT:
421 /* Rely on union to translate elem.data.int32 into elem.data.float32 */
422 /* FALLTHRU */
423 case EVENT_TYPE_INT:
424 elem.len = sizeof(int32_t);
425 if ((pos + elem.len) > context->len) {
426 elem.type = EVENT_TYPE_UNKNOWN;
427 return elem;
428 }
429 elem.data.int32 = get4LE(&context->storage[pos]);
430 /* common tangeable object suffix */
431 pos += elem.len;
432 elem.complete = !context->list_nest_depth && !context->count[0];
433 if (!peek) {
434 if (!context->count[context->list_nest_depth] ||
435 !--(context->count[context->list_nest_depth])) {
436 context->list_stop = true;
437 }
438 context->pos = pos;
439 }
440 return elem;
441
442 case EVENT_TYPE_LONG:
443 elem.len = sizeof(int64_t);
444 if ((pos + elem.len) > context->len) {
445 elem.type = EVENT_TYPE_UNKNOWN;
446 return elem;
447 }
448 elem.data.int64 = get8LE(&context->storage[pos]);
449 /* common tangeable object suffix */
450 pos += elem.len;
451 elem.complete = !context->list_nest_depth && !context->count[0];
452 if (!peek) {
453 if (!context->count[context->list_nest_depth] ||
454 !--(context->count[context->list_nest_depth])) {
455 context->list_stop = true;
456 }
457 context->pos = pos;
458 }
459 return elem;
460
461 case EVENT_TYPE_STRING:
462 if ((pos + sizeof(int32_t)) > context->len) {
463 elem.type = EVENT_TYPE_UNKNOWN;
464 elem.complete = true;
465 return elem;
466 }
467 elem.len = get4LE(&context->storage[pos]);
468 pos += sizeof(int32_t);
469 if ((pos + elem.len) > context->len) {
470 elem.len = context->len - pos; /* truncate string */
471 elem.complete = true;
472 if (!elem.len) {
473 elem.type = EVENT_TYPE_UNKNOWN;
474 return elem;
475 }
476 }
477 elem.data.string = (char *)&context->storage[pos];
478 /* common tangeable object suffix */
479 pos += elem.len;
480 elem.complete = !context->list_nest_depth && !context->count[0];
481 if (!peek) {
482 if (!context->count[context->list_nest_depth] ||
483 !--(context->count[context->list_nest_depth])) {
484 context->list_stop = true;
485 }
486 context->pos = pos;
487 }
488 return elem;
489
490 case EVENT_TYPE_LIST:
491 if ((pos + sizeof(uint8_t)) > context->len) {
492 elem.type = EVENT_TYPE_UNKNOWN;
493 elem.complete = true;
494 return elem;
495 }
496 elem.complete = context->list_nest_depth >= ANDROID_MAX_LIST_NEST_DEPTH;
497 if (peek) {
498 return elem;
499 }
500 if (context->count[context->list_nest_depth]) {
501 context->count[context->list_nest_depth]--;
502 }
503 context->list_stop = !context->storage[pos];
504 context->list_nest_depth++;
505 if (context->list_nest_depth <= ANDROID_MAX_LIST_NEST_DEPTH) {
506 context->count[context->list_nest_depth] = context->storage[pos];
507 }
508 context->pos = pos + sizeof(uint8_t);
509 return elem;
510
511 case EVENT_TYPE_LIST_STOP: /* Suprise Newline terminates lists. */
512 if (!peek) {
513 context->pos = pos;
514 }
515 elem.type = EVENT_TYPE_UNKNOWN;
516 elem.complete = !context->list_nest_depth;
517 if (context->list_nest_depth > 0) {
518 elem.type = EVENT_TYPE_LIST_STOP;
519 if (!peek) {
520 context->list_nest_depth--;
521 }
522 }
523 return elem;
524
525 default:
526 elem.type = EVENT_TYPE_UNKNOWN;
527 return elem;
528 }
529 }
530
android_log_read_next(android_log_context ctx)531 LIBLOG_ABI_PUBLIC android_log_list_element android_log_read_next(
532 android_log_context ctx) {
533 return android_log_read_next_internal(ctx, 0);
534 }
535
android_log_peek_next(android_log_context ctx)536 LIBLOG_ABI_PUBLIC android_log_list_element android_log_peek_next(
537 android_log_context ctx) {
538 return android_log_read_next_internal(ctx, 1);
539 }
540