support/support_format_addrinfo.c

   1 /* Convert struct addrinfo values to a string.
   2    Copyright (C) 2016-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <support/format_nss.h>
  20
  21 #include <arpa/inet.h>
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <support/support.h>
  26 #include <support/xmemstream.h>
  27
  28 static size_t
  29 socket_address_length (int family)
  30 {
  31   switch (family)
  32     {
  33     case AF_INET:
  34       return sizeof (struct sockaddr_in);
  35     case AF_INET6:
  36       return sizeof (struct sockaddr_in6);
  37     default:
  38       return -1;
  39     }
  40 }
  41
  42 static void
  43 format_ai_flags_1 (FILE *out, struct addrinfo *ai, int flag, const char *name,
  44                    int * flags_printed)
  45 {
  46   if ((ai->ai_flags & flag) != 0)
  47     fprintf (out, " %s", name);
  48   *flags_printed |= flag;
  49 }
  50
  51 static void
  52 format_ai_flags (FILE *out, struct addrinfo *ai)
  53 {
  54   if (ai == NULL)
  55     return;
  56
  57   if (ai->ai_flags != 0)
  58     {
  59       fprintf (out, "flags:");
  60       int flags_printed = 0;
  61 #define FLAG(flag) format_ai_flags_1 (out, ai, flag, #flag, &flags_printed)
  62       FLAG (AI_PASSIVE);
  63       FLAG (AI_CANONNAME);
  64       FLAG (AI_NUMERICHOST);
  65       FLAG (AI_V4MAPPED);
  66       FLAG (AI_ALL);
  67       FLAG (AI_ADDRCONFIG);
  68       FLAG (AI_IDN);
  69       FLAG (AI_CANONIDN);
  70       FLAG (AI_NUMERICSERV);
  71 #undef FLAG
  72       int remaining = ai->ai_flags & ~flags_printed;
  73       if (remaining != 0)
  74         fprintf (out, " %08x", remaining);
  75       fprintf (out, "\n");
  76     }
  77
  78   /* Report flag mismatches within the list.  */
  79   int flags = ai->ai_flags;
  80   int index = 1;
  81   ai = ai->ai_next;
  82   while (ai != NULL)
  83     {
  84       if (ai->ai_flags != flags)
  85         fprintf (out, "error: flags at %d: 0x%x expected, 0x%x actual\n",
  86                  index, flags, ai->ai_flags);
  87       ai = ai->ai_next;
  88       ++index;
  89     }
  90 }
  91
  92 static void
  93 format_ai_canonname (FILE *out, struct addrinfo *ai)
  94 {
  95   if (ai == NULL)
  96     return;
  97   if (ai->ai_canonname != NULL)
  98     fprintf (out, "canonname: %s\n", ai->ai_canonname);
  99
 100   /* Report incorrectly set ai_canonname fields on subsequent list
 101      entries.  */
 102   int index = 1;
 103   ai = ai->ai_next;
 104   while (ai != NULL)
 105     {
 106       if (ai->ai_canonname != NULL)
 107         fprintf (out, "error: canonname set at %d: %s\n",
 108                  index, ai->ai_canonname);
 109       ai = ai->ai_next;
 110       ++index;
 111     }
 112 }
 113
 114 static void
 115 format_ai_one (FILE *out, struct addrinfo *ai)
 116 {
 117   {
 118     char type_buf[32];
 119     const char *type_str;
 120     char proto_buf[32];
 121     const char *proto_str;
 122
 123     /* ai_socktype */
 124     switch (ai->ai_socktype)
 125       {
 126       case SOCK_RAW:
 127         type_str = "RAW";
 128         break;
 129       case SOCK_DGRAM:
 130         type_str = "DGRAM";
 131         break;
 132       case SOCK_STREAM:
 133         type_str = "STREAM";
 134         break;
 135       default:
 136         snprintf (type_buf, sizeof (type_buf), "%d", ai->ai_socktype);
 137         type_str = type_buf;
 138       }
 139
 140     /* ai_protocol */
 141     switch (ai->ai_protocol)
 142       {
 143       case IPPROTO_IP:
 144         proto_str = "IP";
 145         break;
 146       case IPPROTO_UDP:
 147         proto_str = "UDP";
 148         break;
 149       case IPPROTO_TCP:
 150         proto_str = "TCP";
 151         break;
 152       default:
 153         snprintf (proto_buf, sizeof (proto_buf), "%d", ai->ai_protocol);
 154         proto_str = proto_buf;
 155       }
 156     fprintf (out, "address: %s/%s", type_str, proto_str);
 157   }
 158
 159   /* ai_addrlen */
 160   if (ai->ai_addrlen != socket_address_length (ai->ai_family))
 161     {
 162       char *family = support_format_address_family (ai->ai_family);
 163       fprintf (out, "error: invalid address length %d for %s\n",
 164                ai->ai_addrlen, family);
 165       free (family);
 166     }
 167
 168   /* ai_addr */
 169   {
 170     char buf[128];
 171     uint16_t port;
 172     const char *ret;
 173     switch (ai->ai_family)
 174       {
 175       case AF_INET:
 176         {
 177           struct sockaddr_in *sin = (struct sockaddr_in *) ai->ai_addr;
 178           ret = inet_ntop (AF_INET, &sin->sin_addr, buf, sizeof (buf));
 179           port = sin->sin_port;
 180         }
 181         break;
 182       case AF_INET6:
 183         {
 184           struct sockaddr_in6 *sin = (struct sockaddr_in6 *) ai->ai_addr;
 185           ret = inet_ntop (AF_INET6, &sin->sin6_addr, buf, sizeof (buf));
 186           port = sin->sin6_port;
 187         }
 188         break;
 189       default:
 190         errno = EAFNOSUPPORT;
 191         ret = NULL;
 192       }
 193     if (ret == NULL)
 194         fprintf (out, "error: inet_top failed: %m\n");
 195     else
 196       fprintf (out, " %s %u\n", buf, ntohs (port));
 197   }
 198 }
 199
 200 /* Format all the addresses in one address family.  */
 201 static void
 202 format_ai_family (FILE *out, struct addrinfo *ai, int family)
 203 {
 204   while (ai)
 205     {
 206       if (ai->ai_family == family)
 207         format_ai_one (out, ai);
 208       ai = ai->ai_next;
 209     }
 210 }
 211
 212 char *
 213 support_format_addrinfo (struct addrinfo *ai, int ret)
 214 {
 215   int errno_copy = errno;
 216
 217   struct xmemstream mem;
 218   xopen_memstream (&mem);
 219   if (ret != 0)
 220     {
 221       const char *errmsg = gai_strerror (ret);
 222       if (strcmp (errmsg, "Unknown error") == 0)
 223         fprintf (mem.out, "error: Unknown error %d\n", ret);
 224       else
 225         fprintf (mem.out, "error: %s\n", errmsg);
 226       if (ret == EAI_SYSTEM)
 227         {
 228           errno = errno_copy;
 229           fprintf (mem.out, "error: %m\n");
 230         }
 231     }
 232   else
 233     {
 234       format_ai_flags (mem.out, ai);
 235       format_ai_canonname (mem.out, ai);
 236       format_ai_family (mem.out, ai, AF_INET);
 237       format_ai_family (mem.out, ai, AF_INET6);
 238     }
 239
 240   xfclose_memstream (&mem);
 241   return mem.buffer;
 242 }