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
17#include <endian.h>
18#include <errno.h>
19#include <fcntl.h>
20#include <inttypes.h>
21#include <poll.h>
22#include <stdarg.h>
23#include <stdatomic.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <sys/socket.h>
28#include <sys/stat.h>
29#include <sys/types.h>
30#include <sys/un.h>
31#include <time.h>
32#include <unistd.h>
33
34#include <cutils/sockets.h>
35#include <private/android_filesystem_config.h>
36#include <private/android_logger.h>
37
38#include "config_read.h"
39#include "log_portability.h"
40#include "logd_reader.h"
41#include "logger.h"
42
43/* branchless on many architectures. */
44#define min(x, y) ((y) ^ (((x) ^ (y)) & -((x) < (y))))
45
46static int logdAvailable(log_id_t LogId);
47static int logdVersion(struct android_log_logger* logger,
48                       struct android_log_transport_context* transp);
49static int logdRead(struct android_log_logger_list* logger_list,
50                    struct android_log_transport_context* transp,
51                    struct log_msg* log_msg);
52static int logdPoll(struct android_log_logger_list* logger_list,
53                    struct android_log_transport_context* transp);
54static void logdClose(struct android_log_logger_list* logger_list,
55                      struct android_log_transport_context* transp);
56static int logdClear(struct android_log_logger* logger,
57                     struct android_log_transport_context* transp);
58static ssize_t logdSetSize(struct android_log_logger* logger,
59                           struct android_log_transport_context* transp,
60                           size_t size);
61static ssize_t logdGetSize(struct android_log_logger* logger,
62                           struct android_log_transport_context* transp);
63static ssize_t logdGetReadableSize(struct android_log_logger* logger,
64                                   struct android_log_transport_context* transp);
65static ssize_t logdGetPrune(struct android_log_logger_list* logger,
66                            struct android_log_transport_context* transp,
67                            char* buf, size_t len);
68static ssize_t logdSetPrune(struct android_log_logger_list* logger,
69                            struct android_log_transport_context* transp,
70                            char* buf, size_t len);
71static ssize_t logdGetStats(struct android_log_logger_list* logger,
72                            struct android_log_transport_context* transp,
73                            char* buf, size_t len);
74
75LIBLOG_HIDDEN struct android_log_transport_read logdLoggerRead = {
76  .node = { &logdLoggerRead.node, &logdLoggerRead.node },
77  .name = "logd",
78  .available = logdAvailable,
79  .version = logdVersion,
80  .read = logdRead,
81  .poll = logdPoll,
82  .close = logdClose,
83  .clear = logdClear,
84  .getSize = logdGetSize,
85  .setSize = logdSetSize,
86  .getReadableSize = logdGetReadableSize,
87  .getPrune = logdGetPrune,
88  .setPrune = logdSetPrune,
89  .getStats = logdGetStats,
90};
91
92static int logdAvailable(log_id_t logId) {
93  if (logId >= LOG_ID_MAX) {
94    return -EINVAL;
95  }
96  if (logId == LOG_ID_SECURITY) {
97    uid_t uid = __android_log_uid();
98    if (uid != AID_SYSTEM) {
99      return -EPERM;
100    }
101  }
102  if (access("/dev/socket/logdw", W_OK) == 0) {
103    return 0;
104  }
105  return -EBADF;
106}
107
108/* Private copy of ../libcutils/socket_local_client.c prevent library loops */
109
110#if defined(_WIN32)
111
112LIBLOG_WEAK int socket_local_client(const char* name, int namespaceId,
113                                    int type) {
114  errno = ENOSYS;
115  return -ENOSYS;
116}
117
118#else /* !_WIN32 */
119
120#include <sys/select.h>
121#include <sys/socket.h>
122#include <sys/types.h>
123#include <sys/un.h>
124
125/* Private copy of ../libcutils/socket_local.h prevent library loops */
126#define FILESYSTEM_SOCKET_PREFIX "/tmp/"
127#define ANDROID_RESERVED_SOCKET_PREFIX "/dev/socket/"
128/* End of ../libcutils/socket_local.h */
129
130#define LISTEN_BACKLOG 4
131
132/* Documented in header file. */
133LIBLOG_WEAK int socket_make_sockaddr_un(const char* name, int namespaceId,
134                                        struct sockaddr_un* p_addr,
135                                        socklen_t* alen) {
136  memset(p_addr, 0, sizeof(*p_addr));
137  size_t namelen;
138
139  switch (namespaceId) {
140    case ANDROID_SOCKET_NAMESPACE_ABSTRACT:
141#if defined(__linux__)
142      namelen = strlen(name);
143
144      /* Test with length +1 for the *initial* '\0'. */
145      if ((namelen + 1) > sizeof(p_addr->sun_path)) {
146        goto error;
147      }
148
149      /*
150       * Note: The path in this case is *not* supposed to be
151       * '\0'-terminated. ("man 7 unix" for the gory details.)
152       */
153
154      p_addr->sun_path[0] = 0;
155      memcpy(p_addr->sun_path + 1, name, namelen);
156#else
157      /* this OS doesn't have the Linux abstract namespace */
158
159      namelen = strlen(name) + strlen(FILESYSTEM_SOCKET_PREFIX);
160      /* unix_path_max appears to be missing on linux */
161      if (namelen >
162          sizeof(*p_addr) - offsetof(struct sockaddr_un, sun_path) - 1) {
163        goto error;
164      }
165
166      strcpy(p_addr->sun_path, FILESYSTEM_SOCKET_PREFIX);
167      strcat(p_addr->sun_path, name);
168#endif
169      break;
170
171    case ANDROID_SOCKET_NAMESPACE_RESERVED:
172      namelen = strlen(name) + strlen(ANDROID_RESERVED_SOCKET_PREFIX);
173      /* unix_path_max appears to be missing on linux */
174      if (namelen >
175          sizeof(*p_addr) - offsetof(struct sockaddr_un, sun_path) - 1) {
176        goto error;
177      }
178
179      strcpy(p_addr->sun_path, ANDROID_RESERVED_SOCKET_PREFIX);
180      strcat(p_addr->sun_path, name);
181      break;
182
183    case ANDROID_SOCKET_NAMESPACE_FILESYSTEM:
184      namelen = strlen(name);
185      /* unix_path_max appears to be missing on linux */
186      if (namelen >
187          sizeof(*p_addr) - offsetof(struct sockaddr_un, sun_path) - 1) {
188        goto error;
189      }
190
191      strcpy(p_addr->sun_path, name);
192      break;
193
194    default:
195      /* invalid namespace id */
196      return -1;
197  }
198
199  p_addr->sun_family = AF_LOCAL;
200  *alen = namelen + offsetof(struct sockaddr_un, sun_path) + 1;
201  return 0;
202error:
203  return -1;
204}
205
206/**
207 * connect to peer named "name" on fd
208 * returns same fd or -1 on error.
209 * fd is not closed on error. that's your job.
210 *
211 * Used by AndroidSocketImpl
212 */
213LIBLOG_WEAK int socket_local_client_connect(int fd, const char* name,
214                                            int namespaceId, int type __unused) {
215  struct sockaddr_un addr;
216  socklen_t alen;
217  int err;
218
219  err = socket_make_sockaddr_un(name, namespaceId, &addr, &alen);
220
221  if (err < 0) {
222    goto error;
223  }
224
225  if (connect(fd, (struct sockaddr*)&addr, alen) < 0) {
226    goto error;
227  }
228
229  return fd;
230
231error:
232  return -1;
233}
234
235/**
236 * connect to peer named "name"
237 * returns fd or -1 on error
238 */
239LIBLOG_WEAK int socket_local_client(const char* name, int namespaceId,
240                                    int type) {
241  int s;
242
243  s = socket(AF_LOCAL, type, 0);
244  if (s < 0) return -1;
245
246  if (0 > socket_local_client_connect(s, name, namespaceId, type)) {
247    close(s);
248    return -1;
249  }
250
251  return s;
252}
253
254#endif /* !_WIN32 */
255/* End of ../libcutils/socket_local_client.c */
256
257/* worker for sending the command to the logger */
258static ssize_t send_log_msg(struct android_log_logger* logger, const char* msg,
259                            char* buf, size_t buf_size) {
260  ssize_t ret;
261  size_t len;
262  char* cp;
263  int errno_save = 0;
264  int sock = socket_local_client("logd", ANDROID_SOCKET_NAMESPACE_RESERVED,
265                                 SOCK_STREAM);
266  if (sock < 0) {
267    return sock;
268  }
269
270  if (msg) {
271    snprintf(buf, buf_size, msg, logger ? logger->logId : (unsigned)-1);
272  }
273
274  len = strlen(buf) + 1;
275  ret = TEMP_FAILURE_RETRY(write(sock, buf, len));
276  if (ret <= 0) {
277    goto done;
278  }
279
280  len = buf_size;
281  cp = buf;
282  while ((ret = TEMP_FAILURE_RETRY(read(sock, cp, len))) > 0) {
283    struct pollfd p;
284
285    if (((size_t)ret == len) || (buf_size < PAGE_SIZE)) {
286      break;
287    }
288
289    len -= ret;
290    cp += ret;
291
292    memset(&p, 0, sizeof(p));
293    p.fd = sock;
294    p.events = POLLIN;
295
296    /* Give other side 20ms to refill pipe */
297    ret = TEMP_FAILURE_RETRY(poll(&p, 1, 20));
298
299    if (ret <= 0) {
300      break;
301    }
302
303    if (!(p.revents & POLLIN)) {
304      ret = 0;
305      break;
306    }
307  }
308
309  if (ret >= 0) {
310    ret += buf_size - len;
311  }
312
313done:
314  if ((ret == -1) && errno) {
315    errno_save = errno;
316  }
317  close(sock);
318  if (errno_save) {
319    errno = errno_save;
320  }
321  return ret;
322}
323
324LIBLOG_HIDDEN ssize_t __send_log_msg(char* buf, size_t buf_size) {
325  return send_log_msg(NULL, NULL, buf, buf_size);
326}
327
328static int check_log_success(char* buf, ssize_t ret) {
329  if (ret < 0) {
330    return ret;
331  }
332
333  if (strncmp(buf, "success", 7)) {
334    errno = EINVAL;
335    return -1;
336  }
337
338  return 0;
339}
340
341static int logdClear(struct android_log_logger* logger,
342                     struct android_log_transport_context* transp __unused) {
343  char buf[512];
344
345  return check_log_success(buf,
346                           send_log_msg(logger, "clear %d", buf, sizeof(buf)));
347}
348
349/* returns the total size of the log's ring buffer */
350static ssize_t logdGetSize(struct android_log_logger* logger,
351                           struct android_log_transport_context* transp __unused) {
352  char buf[512];
353
354  ssize_t ret = send_log_msg(logger, "getLogSize %d", buf, sizeof(buf));
355  if (ret < 0) {
356    return ret;
357  }
358
359  if ((buf[0] < '0') || ('9' < buf[0])) {
360    return -1;
361  }
362
363  return atol(buf);
364}
365
366static ssize_t logdSetSize(struct android_log_logger* logger,
367                           struct android_log_transport_context* transp __unused,
368                           size_t size) {
369  char buf[512];
370
371  snprintf(buf, sizeof(buf), "setLogSize %d %zu", logger->logId, size);
372
373  return check_log_success(buf, send_log_msg(NULL, NULL, buf, sizeof(buf)));
374}
375
376/*
377 * returns the readable size of the log's ring buffer (that is, amount of the
378 * log consumed)
379 */
380static ssize_t logdGetReadableSize(struct android_log_logger* logger,
381                                   struct android_log_transport_context* transp
382                                       __unused) {
383  char buf[512];
384
385  ssize_t ret = send_log_msg(logger, "getLogSizeUsed %d", buf, sizeof(buf));
386  if (ret < 0) {
387    return ret;
388  }
389
390  if ((buf[0] < '0') || ('9' < buf[0])) {
391    return -1;
392  }
393
394  return atol(buf);
395}
396
397/*
398 * returns the logger version
399 */
400static int logdVersion(struct android_log_logger* logger __unused,
401                       struct android_log_transport_context* transp __unused) {
402  uid_t uid = __android_log_uid();
403  return ((uid != AID_ROOT) && (uid != AID_LOG) && (uid != AID_SYSTEM)) ? 3 : 4;
404}
405
406/*
407 * returns statistics
408 */
409static ssize_t logdGetStats(struct android_log_logger_list* logger_list,
410                            struct android_log_transport_context* transp __unused,
411                            char* buf, size_t len) {
412  struct android_log_logger* logger;
413  char* cp = buf;
414  size_t remaining = len;
415  size_t n;
416
417  n = snprintf(cp, remaining, "getStatistics");
418  n = min(n, remaining);
419  remaining -= n;
420  cp += n;
421
422  logger_for_each(logger, logger_list) {
423    n = snprintf(cp, remaining, " %d", logger->logId);
424    n = min(n, remaining);
425    remaining -= n;
426    cp += n;
427  }
428
429  if (logger_list->pid) {
430    snprintf(cp, remaining, " pid=%u", logger_list->pid);
431  }
432
433  return send_log_msg(NULL, NULL, buf, len);
434}
435
436static ssize_t logdGetPrune(struct android_log_logger_list* logger_list __unused,
437                            struct android_log_transport_context* transp __unused,
438                            char* buf, size_t len) {
439  return send_log_msg(NULL, "getPruneList", buf, len);
440}
441
442static ssize_t logdSetPrune(struct android_log_logger_list* logger_list __unused,
443                            struct android_log_transport_context* transp __unused,
444                            char* buf, size_t len) {
445  const char cmd[] = "setPruneList ";
446  const size_t cmdlen = sizeof(cmd) - 1;
447
448  if (strlen(buf) > (len - cmdlen)) {
449    return -ENOMEM; /* KISS */
450  }
451  memmove(buf + cmdlen, buf, len - cmdlen);
452  buf[len - 1] = '\0';
453  memcpy(buf, cmd, cmdlen);
454
455  return check_log_success(buf, send_log_msg(NULL, NULL, buf, len));
456}
457
458static void caught_signal(int signum __unused) {
459}
460
461static int logdOpen(struct android_log_logger_list* logger_list,
462                    struct android_log_transport_context* transp) {
463  struct android_log_logger* logger;
464  struct sigaction ignore;
465  struct sigaction old_sigaction;
466  unsigned int old_alarm = 0;
467  char buffer[256], *cp, c;
468  int e, ret, remaining, sock;
469
470  if (!logger_list) {
471    return -EINVAL;
472  }
473
474  sock = atomic_load(&transp->context.sock);
475  if (sock > 0) {
476    return sock;
477  }
478
479  sock = socket_local_client("logdr", ANDROID_SOCKET_NAMESPACE_RESERVED,
480                             SOCK_SEQPACKET);
481  if (sock == 0) {
482    /* Guarantee not file descriptor zero */
483    int newsock = socket_local_client(
484        "logdr", ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET);
485    close(sock);
486    sock = newsock;
487  }
488  if (sock <= 0) {
489    if ((sock == -1) && errno) {
490      return -errno;
491    }
492    return sock;
493  }
494
495  strcpy(buffer, (logger_list->mode & ANDROID_LOG_NONBLOCK) ? "dumpAndClose"
496                                                            : "stream");
497  cp = buffer + strlen(buffer);
498
499  strcpy(cp, " lids");
500  cp += 5;
501  c = '=';
502  remaining = sizeof(buffer) - (cp - buffer);
503  logger_for_each(logger, logger_list) {
504    ret = snprintf(cp, remaining, "%c%u", c, logger->logId);
505    ret = min(ret, remaining);
506    remaining -= ret;
507    cp += ret;
508    c = ',';
509  }
510
511  if (logger_list->tail) {
512    ret = snprintf(cp, remaining, " tail=%u", logger_list->tail);
513    ret = min(ret, remaining);
514    remaining -= ret;
515    cp += ret;
516  }
517
518  if (logger_list->start.tv_sec || logger_list->start.tv_nsec) {
519    if (logger_list->mode & ANDROID_LOG_WRAP) {
520      // ToDo: alternate API to allow timeout to be adjusted.
521      ret = snprintf(cp, remaining, " timeout=%u",
522                     ANDROID_LOG_WRAP_DEFAULT_TIMEOUT);
523      ret = min(ret, remaining);
524      remaining -= ret;
525      cp += ret;
526    }
527    ret = snprintf(cp, remaining, " start=%" PRIu32 ".%09" PRIu32,
528                   logger_list->start.tv_sec, logger_list->start.tv_nsec);
529    ret = min(ret, remaining);
530    remaining -= ret;
531    cp += ret;
532  }
533
534  if (logger_list->pid) {
535    ret = snprintf(cp, remaining, " pid=%u", logger_list->pid);
536    ret = min(ret, remaining);
537    cp += ret;
538  }
539
540  if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
541    /* Deal with an unresponsive logd */
542    memset(&ignore, 0, sizeof(ignore));
543    ignore.sa_handler = caught_signal;
544    sigemptyset(&ignore.sa_mask);
545    /* particularily useful if tombstone is reporting for logd */
546    sigaction(SIGALRM, &ignore, &old_sigaction);
547    old_alarm = alarm(30);
548  }
549  ret = write(sock, buffer, cp - buffer);
550  e = errno;
551  if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
552    if (e == EINTR) {
553      e = ETIMEDOUT;
554    }
555    alarm(old_alarm);
556    sigaction(SIGALRM, &old_sigaction, NULL);
557  }
558
559  if (ret <= 0) {
560    close(sock);
561    if ((ret == -1) && e) {
562      return -e;
563    }
564    if (ret == 0) {
565      return -EIO;
566    }
567    return ret;
568  }
569
570  ret = atomic_exchange(&transp->context.sock, sock);
571  if ((ret > 0) && (ret != sock)) {
572    close(ret);
573  }
574  return sock;
575}
576
577/* Read from the selected logs */
578static int logdRead(struct android_log_logger_list* logger_list,
579                    struct android_log_transport_context* transp,
580                    struct log_msg* log_msg) {
581  int ret, e;
582  struct sigaction ignore;
583  struct sigaction old_sigaction;
584  unsigned int old_alarm = 0;
585
586  ret = logdOpen(logger_list, transp);
587  if (ret < 0) {
588    return ret;
589  }
590
591  memset(log_msg, 0, sizeof(*log_msg));
592
593  if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
594    memset(&ignore, 0, sizeof(ignore));
595    ignore.sa_handler = caught_signal;
596    sigemptyset(&ignore.sa_mask);
597    /* particularily useful if tombstone is reporting for logd */
598    sigaction(SIGALRM, &ignore, &old_sigaction);
599    old_alarm = alarm(30);
600  }
601
602  /* NOTE: SOCK_SEQPACKET guarantees we read exactly one full entry */
603  ret = recv(ret, log_msg, LOGGER_ENTRY_MAX_LEN, 0);
604  e = errno;
605
606  if (logger_list->mode & ANDROID_LOG_NONBLOCK) {
607    if ((ret == 0) || (e == EINTR)) {
608      e = EAGAIN;
609      ret = -1;
610    }
611    alarm(old_alarm);
612    sigaction(SIGALRM, &old_sigaction, NULL);
613  }
614
615  if ((ret == -1) && e) {
616    return -e;
617  }
618  return ret;
619}
620
621static int logdPoll(struct android_log_logger_list* logger_list,
622                    struct android_log_transport_context* transp) {
623  struct pollfd p;
624
625  int ret = logdOpen(logger_list, transp);
626  if (ret < 0) {
627    return ret;
628  }
629
630  memset(&p, 0, sizeof(p));
631  p.fd = ret;
632  p.events = POLLIN;
633  ret = poll(&p, 1, 20);
634  if ((ret > 0) && !(p.revents & POLLIN)) {
635    ret = 0;
636  }
637  if ((ret == -1) && errno) {
638    return -errno;
639  }
640  return ret;
641}
642
643/* Close all the logs */
644static void logdClose(struct android_log_logger_list* logger_list __unused,
645                      struct android_log_transport_context* transp) {
646  int sock = atomic_exchange(&transp->context.sock, -1);
647  if (sock > 0) {
648    close(sock);
649  }
650}
651