[sanitizer] use the right type for sizeof

[yingcong-wu]

Summary

x_aliases is an array of string, so to calculate its size, it should
be <size-of-array> times <size-of-element>, which should be
sizeof(char*) instead of sizeof(char**).

[cchen15]

LGTM.

[vitalybuka]

Would you like to try to update compiler-rt/test/sanitizer_common/TestCases/Linux/netent.cpp ?

I guess check-msan should trigger if you try to print n_aliases

[yingcong-wu]

In D149242#4301021, @vitalybuka wrote:

Would you like to try to update compiler-rt/test/sanitizer_common/TestCases/Linux/netent.cpp ?

I guess check-msan should trigger if you try to print n_aliases

Sure, I will look into that.

[yingcong-wu]

Hi @vitalybuka, I think compiler-rt/test/sanitizer_common/TestCases/Linux/netent.cpp does not need updates. This patch does not change the functionality since sizeof(char**) == sizeof(char*), it just makes more sence using sizeof(char *) in the calculation of x_aliases's size.

[yingcong-wu]

Oh, I get your idea now, will add some access to n_aliases in a later commit.

[yingcong-wu]

• add some testes for x_aliases

[vitalybuka]

Thanks, LGTM
and yes, check-msan should NOT trigger trigger as size was not actually changed

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

static void write_protoent(void *ctx, struct __sanitizer_protoent *p) {
   COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_name, internal_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, internal_strlen(*pp) + 1);
 
   COMMON_INTERCEPTOR_WRITE_RANGE(ctx, p->p_aliases,
-                                  pp_size * sizeof(char **));
+                                  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);
if (n) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n->n_name, internal_strlen(n->n_name) + 1);
 
     SIZE_T nn_size = 1; // One handles the trailing \0
 
     for (char **nn = n->n_aliases; *nn; ++nn, ++nn_size)
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *nn, internal_strlen(*nn) + 1);
 
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n->n_aliases,
-                                   nn_size * sizeof(char **));
+                                   nn_size * sizeof(char *));
   }
   return n;
 }
 
 INTERCEPTOR(struct __sanitizer_netent *, getnetbyname, const char *name) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, getnetbyname, name);
   if (name)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, name, internal_strlen(name) + 1);
   struct __sanitizer_netent *n = REAL(getnetbyname)(name);
   if (n) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n, sizeof(*n));
 
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n->n_name, internal_strlen(n->n_name) + 1);
 
     SIZE_T nn_size = 1; // One handles the trailing \0
 
     for (char **nn = n->n_aliases; *nn; ++nn, ++nn_size)
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *nn, internal_strlen(*nn) + 1);
 
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n->n_aliases,
-                                   nn_size * sizeof(char **));
+                                   nn_size * sizeof(char *));
   }
   return n;
 }
 
 INTERCEPTOR(struct __sanitizer_netent *, getnetbyaddr, u32 net, int type) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, getnetbyaddr, net, type);
   struct __sanitizer_netent *n = REAL(getnetbyaddr)(net, type);
   if (n) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n, sizeof(*n));
 
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n->n_name, internal_strlen(n->n_name) + 1);
 
     SIZE_T nn_size = 1; // One handles the trailing \0
 
     for (char **nn = n->n_aliases; *nn; ++nn, ++nn_size)
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *nn, internal_strlen(*nn) + 1);
 
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, n->n_aliases,
-                                   nn_size * sizeof(char **));
+                                   nn_size * sizeof(char *));
   }
   return n;
 }
 #define INIT_NETENT \
   COMMON_INTERCEPT_FUNCTION(getnetent); \
   COMMON_INTERCEPT_FUNCTION(getnetbyname); \
   COMMON_INTERCEPT_FUNCTION(getnetbyaddr)
 #else

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

 #define LOOPBACK "your-net"
 #endif
 
 void test1() {
   struct netent *ntp = getnetent();
   assert(ntp && ntp->n_name);
   assert(ntp->n_addrtype == 2);
   assert(ntp->n_net == 127);
+  char **aliases = ntp->n_aliases;
+  while (aliases) {
+    printf("%s\n", *aliases);
+    aliases++;
+  }
   endnetent();
 }
 
 void test2() {
   struct netent *ntp = getnetbyname(LOOPBACK);
   assert(ntp && ntp->n_name);
   assert(ntp->n_addrtype == 2);
   assert(ntp->n_net == 127);
+  char **aliases = ntp->n_aliases;
+  while (aliases) {
+    printf("%s\n", *aliases);
+    aliases++;
+  }
   endnetent();
 }
 
 void test3() {
   struct netent *lb = getnetbyname(LOOPBACK);
   assert(lb);
   struct netent *ntp = getnetbyaddr(lb->n_net, lb->n_addrtype);
   assert(ntp && ntp->n_name);
   assert(ntp->n_addrtype == 2);
   assert(ntp->n_net == 127);
+  char **aliases = ntp->n_aliases;
+  while (aliases) {
+    printf("%s\n", *aliases);
+    aliases++;
+  }
   endnetent();
 }
 
 void test4() {
   setnetent(1);
 
   struct netent *ntp = getnetent();
   assert(ntp && ntp->n_name);

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 
 void test1() {
   struct protoent *ptp = getprotoent();
   assert(ptp && ptp->p_name);
   assert(ptp->p_proto == 0);
+  char **aliases = ptp->p_aliases;
+  while (aliases) {
+    printf("%s\n", *aliases);
+    aliases++;
+  }
   endprotoent();
 }
 
 void test2() {
   struct protoent *ptp = getprotobyname("tcp");
   assert(ptp && ptp->p_name);
   assert(ptp->p_proto == 6);
+  char **aliases = ptp->p_aliases;
+  while (aliases) {
+    printf("%s\n", *aliases);
+    aliases++;
+  }
   endprotoent();
 }
 
 void test3() {
   struct protoent *ptp = getprotobynumber(1);
   assert(ptp && ptp->p_name);
   assert(ptp->p_proto == 1);
+  char **aliases = ptp->p_aliases;
+  while (aliases) {
+    printf("%s\n", *aliases);
+    aliases++;
+  }
   endprotoent();
 }
 
 void test4() {
   setprotoent(1);
   struct protoent *ptp = getprotobynumber(1);
 
   ptp = getprotobynumber(2);