sanitizers: Add interceptors for getproto{ent,byname,bynumber}_r

[guiand]

Summary

This also allows intercepting these getprotoent functions on Linux as well, since Linux exposes them.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

7408

Move the common part into a helper function, ex. write_protoent().

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

550–551

Android has getprotoent, but not getprotoent_r.

[guiand]

Addressed comments

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

778

it's unrelated to description
should be in a different patch?

[guiand]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

778

Ah, looks like some changes snuck in that I meant to be in a different patchset. I'll split that out for sure.

[guiand]

Removed changes from separate patchset

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

7361

drop {}

7405

if (!res && *result)
    write_protoent(ctx, *result);

here and below

[krytarowski]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h

132

@guiand why did you remove it for NetBSD? This broke the build.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h

132

Hmm looks like confusion caused by the file naming (netbsd implements posix, right?) multiplied by the lack of buildbot coverage.

Sorry for the breakage.
I can restore this chunk, or feel free to commit the fix directly.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h

132

Ah I see you've done that already.
Good.

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

enum {
     CIMT_FILE
   } type;
   union {
     FileMetadata file;
   };
 };
 
 #if SI_POSIX
 typedef AddrHashMap<CommonInterceptorMetadata, 31051> MetadataHashMap;
 
 static MetadataHashMap *interceptor_metadata_map;
 
 UNUSED static void SetInterceptorMetadata(__sanitizer_FILE *addr,
                                           const FileMetadata &file) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr);
   CHECK(h.created());
   h->type = CommonInterceptorMetadata::CIMT_FILE;
   h->file = file;
 }
 
 UNUSED static const FileMetadata *GetInterceptorMetadata(
     __sanitizer_FILE *addr) {

 
 UNUSED static void DeleteInterceptorMetadata(void *addr) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr, true);
   CHECK(h.exists());
 }
 #endif  // SI_POSIX
 
 #if SANITIZER_INTERCEPT_STRLEN
 INTERCEPTOR(SIZE_T, strlen, const char *s) {
   // Sometimes strlen is called prior to InitializeCommonInterceptors,
   // in which case the REAL(strlen) typically used in
   // COMMON_INTERCEPTOR_ENTER will fail.  We use internal_strlen here
   // to handle that.
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_strlen(s);
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strlen, s);
   SIZE_T result = REAL(strlen)(s);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, result + 1);
   return result;
 }
 #define INIT_STRLEN COMMON_INTERCEPT_FUNCTION(strlen)
 #else
 #define INIT_STRLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNLEN
 INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T maxlen) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strnlen, s, maxlen);
   SIZE_T length = REAL(strnlen)(s, maxlen);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, Min(length + 1, maxlen));
   return length;
 }
 #define INIT_STRNLEN COMMON_INTERCEPT_FUNCTION(strnlen)
 #else
 #define INIT_STRNLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNDUP
 INTERCEPTOR(char*, strndup, const char *s, uptr size) {
   void *ctx;
   COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
 }
 #define INIT_STRNDUP COMMON_INTERCEPT_FUNCTION(strndup)
 #else
 #define INIT_STRNDUP
 #endif // SANITIZER_INTERCEPT_STRNDUP
 

 }
 
 #define INIT_STRPBRK COMMON_INTERCEPT_FUNCTION(strpbrk);
 #else
 #define INIT_STRPBRK
 #endif
 
 #if SANITIZER_INTERCEPT_STRSIGNAL
 INTERCEPTOR(char *, strsignal, int signal) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strsignal, signal);
   char *r = REAL(strsignal)(signal);
   COMMON_INTERCEPTOR_WRITE_RANGE(ctx, r, REAL(strlen)(r));
   return r;
 }
 
 #define INIT_STRSIGNAL COMMON_INTERCEPT_FUNCTION(strsignal);

 
 #if SANITIZER_INTERCEPT_STRMODE
 INTERCEPTOR(void, strmode, u32 mode, char *bp) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strmode, mode, bp);
   REAL(strmode)(mode, bp);
   if (bp)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, bp, REAL(strlen)(bp) + 1);
 }
 #define INIT_STRMODE COMMON_INTERCEPT_FUNCTION(strmode)
 #else
 #define INIT_STRMODE
 #endif
 
 #if SANITIZER_INTERCEPT_TTYENT
 INTERCEPTOR(struct __sanitizer_ttyent *, getttyent, void) {
   void *ctx;
#define INIT_TTYENT \
   COMMON_INTERCEPT_FUNCTION(getttyent); \
   COMMON_INTERCEPT_FUNCTION(getttynam); \
   COMMON_INTERCEPT_FUNCTION(setttyentpath)
 #else
 #define INIT_TTYENT
 #endif
 
 #if SANITIZER_INTERCEPT_PROTOENT
-INTERCEPTOR(struct __sanitizer_protoent *, getprotoent) {
-  void *ctx;
-  COMMON_INTERCEPTOR_ENTER(ctx, getprotoent);
-  struct __sanitizer_protoent *p = REAL(getprotoent)();
-  if (p) {
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(*p));
+static void write_protoent(void *ctx, struct __sanitizer_protoent *p) {
 
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_name, REAL(strlen)(p->p_name) + 1);
 
-    SIZE_T pp_size = 1; // One handles the trailing \0
 
-    for (char **pp = p->p_aliases; *pp; ++pp, ++pp_size)
-       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *pp, REAL(strlen)(*pp) + 1);
 
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_aliases,
-                                   pp_size * sizeof(char **));
-  }
+
+INTERCEPTOR(struct __sanitizer_protoent *, getprotoent) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getprotoent);
+  struct __sanitizer_protoent *p = REAL(getprotoent)();
+  if (p) {
+    write_protoent(ctx, p);
+  }
   return p;
 }
 
 INTERCEPTOR(struct __sanitizer_protoent *, getprotobyname, const char *name) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, getprotobyname, name);
   if (name)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
   struct __sanitizer_protoent *p = REAL(getprotobyname)(name);
   if (p) {
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(*p));
-
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_name, REAL(strlen)(p->p_name) + 1);
-
-    SIZE_T pp_size = 1; // One handles the trailing \0
-
-    for (char **pp = p->p_aliases; *pp; ++pp, ++pp_size)
-       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *pp, REAL(strlen)(*pp) + 1);
-
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_aliases,
-                                   pp_size * sizeof(char **));
+    write_protoent(ctx, p);
   }
   return p;
 }
 
 INTERCEPTOR(struct __sanitizer_protoent *, getprotobynumber, int proto) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, getprotobynumber, proto);
   struct __sanitizer_protoent *p = REAL(getprotobynumber)(proto);
   if (p) {
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p, sizeof(*p));
-
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_name, REAL(strlen)(p->p_name) + 1);
-
-    SIZE_T pp_size = 1; // One handles the trailing \0
-
-    for (char **pp = p->p_aliases; *pp; ++pp, ++pp_size)
-       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *pp, REAL(strlen)(*pp) + 1);
-
-    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_aliases,
-                                   pp_size * sizeof(char **));
+    write_protoent(ctx, p);
   }
   return p;
 }
 #define INIT_PROTOENT \
   COMMON_INTERCEPT_FUNCTION(getprotoent); \
   COMMON_INTERCEPT_FUNCTION(getprotobyname); \
   COMMON_INTERCEPT_FUNCTION(getprotobynumber)
 #else
 #define INIT_PROTOENT
 #endif
 
+#if SANITIZER_INTERCEPT_PROTOENT_R
+INTERCEPTOR(int, getprotoent_r, struct __sanitizer_protoent *result_buf, char *buf, SIZE_T buflen, struct __sanitizer_protoent **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getprotoent_r, result_buf, buf, buflen, result);
+  int res = REAL(getprotoent_r)(result_buf, buf, buflen, result);
+
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof *result);
+  if (!res && *result) {
+    struct __sanitizer_protoent *p = *result;
+    write_protoent(ctx, p);
+  }
+  return res;
+}
+
+INTERCEPTOR(int, getprotobyname_r, const char *name, struct __sanitizer_protoent *result_buf, char *buf, SIZE_T buflen, struct __sanitizer_protoent **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getprotobyname_r, name, result_buf, buf, buflen, result);
+  if (name)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, name, REAL(strlen)(name) + 1);
+  int res = REAL(getprotobyname_r)(name, result_buf, buf, buflen, result);
+
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof *result);
+  if (!res && *result) {
+    struct __sanitizer_protoent *p = *result;
+    write_protoent(ctx, p);
+  }
+  return res;
+}
+
+INTERCEPTOR(int, getprotobynumber_r, int num, struct __sanitizer_protoent *result_buf, char *buf, SIZE_T buflen, struct __sanitizer_protoent **result) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, getprotobynumber_r, num, result_buf, buf, buflen, result);
+  int res = REAL(getprotobynumber_r)(num, result_buf, buf, buflen, result);
+
+  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, result, sizeof *result);
+  if (!res && *result) {
+    struct __sanitizer_protoent *p = *result;
+    write_protoent(ctx, p);
+  }
+  return res;
+}
+
+#define INIT_PROTOENT_R \
+  COMMON_INTERCEPT_FUNCTION(getprotoent_r); \
+  COMMON_INTERCEPT_FUNCTION(getprotobyname_r); \
+  COMMON_INTERCEPT_FUNCTION(getprotobynumber_r);
+#else
+#define INIT_PROTOENT_R
+#endif
+
 #if SANITIZER_INTERCEPT_NETENT
 INTERCEPTOR(struct __sanitizer_netent *, getnetent) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, getnetent);
   struct __sanitizer_netent *n = REAL(getnetent)();
   if (n) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n, sizeof(*n));
 
#endif
   INIT_OPEN_BY_HANDLE_AT;
   INIT_STRLCPY;
   INIT_DEVNAME;
   INIT_DEVNAME_R;
   INIT_FGETLN;
   INIT_STRMODE;
   INIT_TTYENT;
   INIT_PROTOENT;
+  INIT_PROTOENT_R;
   INIT_NETENT;
   INIT_GETMNTINFO;
   INIT_MI_VECTOR_HASH;
   INIT_SETVBUF;
   INIT_GETVFSSTAT;
   INIT_REGEX;
   INIT_REGEXSUB;
   INIT_FTS;

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_READLINKAT \
   (SI_POSIX && !SI_MAC_DEPLOYMENT_BELOW_10_10)
 
 #define SANITIZER_INTERCEPT_DEVNAME (SI_NETBSD || SI_OPENBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_DEVNAME_R (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_FGETLN (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_STRMODE (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_TTYENT SI_NETBSD
-#define SANITIZER_INTERCEPT_PROTOENT SI_NETBSD
+#define SANITIZER_INTERCEPT_PROTOENT (SI_NETBSD || SI_LINUX)
+#define SANITIZER_INTERCEPT_PROTOENT_R (SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_NETENT SI_NETBSD
 #define SANITIZER_INTERCEPT_SETVBUF (SI_NETBSD || SI_FREEBSD || \
   SI_LINUX || SI_MAC)
 #define SANITIZER_INTERCEPT_GETMNTINFO (SI_NETBSD || SI_FREEBSD || SI_MAC)
 #define SANITIZER_INTERCEPT_MI_VECTOR_HASH SI_NETBSD
 #define SANITIZER_INTERCEPT_GETVFSSTAT SI_NETBSD
 #define SANITIZER_INTERCEPT_REGEX (SI_NETBSD || SI_FREEBSD || SI_LINUX)
 #define SANITIZER_INTERCEPT_REGEXSUB SI_NETBSD

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h

struct __sanitizer_shmid_ds {
   u32 shm_cpid;
   unsigned int shm_nattch;
   u64 shm_atime;
   u64 shm_dtime;
   u64 shm_ctime;
   void *_shm_internal;
 };
 
-struct __sanitizer_protoent {
-  char *p_name;
-  char **p_aliases;
-  int p_proto;
-};
-
 struct __sanitizer_netent {
   char *n_name;
   char **n_aliases;
   int n_addrtype;
   u32 n_net;
 };
 
 extern unsigned struct_msqid_ds_sz;

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

struct __sanitizer_dl_phdr_info {
   const char *dlpi_name;
   const void *dlpi_phdr;
   short dlpi_phnum;
 };
 
 extern unsigned struct_ElfW_Phdr_sz;
 #endif
 
+struct __sanitizer_protoent {
+  char *p_name;
+  char **p_aliases;
+  int p_proto;
+};
+
 struct __sanitizer_addrinfo {
   int ai_flags;
   int ai_family;
   int ai_socktype;
   int ai_protocol;
 #if SANITIZER_ANDROID || SANITIZER_MAC
   unsigned ai_addrlen;
   char *ai_canonname;

compiler-rt/test/sanitizer_common/TestCases/Linux/protoent.cpp

+// RUN: %clangxx -std=c++11 -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <errno.h>
+#include <netdb.h>
+#include <stdio.h>
+
+void print_protoent(protoent *curr_entry) {
+  fprintf(stderr, "%s (%d)\n", curr_entry->p_name, curr_entry->p_proto);
+
+  char **aliases = curr_entry->p_aliases;
+  while (char *alias = *aliases++) {
+    fprintf(stderr, "  alias %s\n", alias);
+  }
+}
+
+void print_all_protoent() {
+  protoent entry;
+  char buf[1024];
+  protoent *curr_entry;
+
+  while (getprotoent_r(&entry, buf, sizeof(buf), &curr_entry) != ENOENT && curr_entry) {
+    print_protoent(curr_entry);
+  }
+}
+
+void print_protoent_by_name(const char *name) {
+  protoent entry;
+  char buf[1024];
+  protoent *curr_entry;
+
+  int res = getprotobyname_r(name, &entry, buf, sizeof(buf), &curr_entry);
+  assert(!res && curr_entry);
+  print_protoent(curr_entry);
+}
+
+void print_protoent_by_num(int num) {
+  protoent entry;
+  char buf[1024];
+  protoent *curr_entry;
+
+  int res = getprotobynumber_r(num, &entry, buf, sizeof(buf), &curr_entry);
+  assert(!res && curr_entry);
+  print_protoent(curr_entry);
+}
+
+int main() {
+  // CHECK: ip (0)
+  // CHECK-NEXT: alias IP
+  // CHECK: ipv6 (41)
+  // CHECK-NEXT: alias IPv6
+  print_all_protoent();
+
+  // CHECK: rdp (27)
+  // CHECK-NEXT: alias RDP
+  print_protoent_by_name("rdp");
+
+  // CHECK: udp (17)
+  // CHECK-NEXT: alias UDP
+  print_protoent_by_num(17);
+  return 0;
+}