LCOV - code coverage report
Current view: top level - strace - sockaddr.c (source / functions) Hit Total Coverage
Test: strace-4.18.0.129.97bbb Code Coverage Lines: 99 102 97.1 %
Date: 2017-07-31 03:46:08 Functions: 10 10 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 44 51 86.3 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
       3                 :            :  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
       4                 :            :  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
       5                 :            :  * Copyright (c) 1996-2000 Wichert Akkerman <wichert@cistron.nl>
       6                 :            :  * Copyright (c) 2005-2016 Dmitry V. Levin <ldv@altlinux.org>
       7                 :            :  * All rights reserved.
       8                 :            :  *
       9                 :            :  * Redistribution and use in source and binary forms, with or without
      10                 :            :  * modification, are permitted provided that the following conditions
      11                 :            :  * are met:
      12                 :            :  * 1. Redistributions of source code must retain the above copyright
      13                 :            :  *    notice, this list of conditions and the following disclaimer.
      14                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      15                 :            :  *    notice, this list of conditions and the following disclaimer in the
      16                 :            :  *    documentation and/or other materials provided with the distribution.
      17                 :            :  * 3. The name of the author may not be used to endorse or promote products
      18                 :            :  *    derived from this software without specific prior written permission.
      19                 :            :  *
      20                 :            :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
      21                 :            :  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
      22                 :            :  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
      23                 :            :  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
      24                 :            :  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
      25                 :            :  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      26                 :            :  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      27                 :            :  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      28                 :            :  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
      29                 :            :  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      30                 :            :  */
      31                 :            : 
      32                 :            : #include "defs.h"
      33                 :            : #include "print_fields.h"
      34                 :            : 
      35                 :            : #include <sys/socket.h>
      36                 :            : #include <sys/un.h>
      37                 :            : #include <netinet/in.h>
      38                 :            : #include <arpa/inet.h>
      39                 :            : 
      40                 :            : #include "netlink.h"
      41                 :            : #include <linux/if_packet.h>
      42                 :            : #include <linux/if_arp.h>
      43                 :            : #include <linux/if_ether.h>
      44                 :            : 
      45                 :            : #ifdef HAVE_NETIPX_IPX_H
      46                 :            : # include <netipx/ipx.h>
      47                 :            : #else
      48                 :            : # include <linux/ipx.h>
      49                 :            : #endif
      50                 :            : 
      51                 :            : #include "xlat/addrfams.h"
      52                 :            : #include "xlat/arp_hardware_types.h"
      53                 :            : #include "xlat/ethernet_protocols.h"
      54                 :            : #include "xlat/af_packet_types.h"
      55                 :            : 
      56                 :            : #ifdef HAVE_BLUETOOTH_BLUETOOTH_H
      57                 :            : # include <bluetooth/bluetooth.h>
      58                 :            : # include <bluetooth/hci.h>
      59                 :            : # include <bluetooth/l2cap.h>
      60                 :            : # include <bluetooth/rfcomm.h>
      61                 :            : # include <bluetooth/sco.h>
      62                 :            : 
      63                 :            : # include "xlat/hci_channels.h"
      64                 :            : #endif
      65                 :            : 
      66                 :            : #define SIZEOF_SA_FAMILY sizeof(((struct sockaddr *) 0)->sa_family)
      67                 :            : 
      68                 :            : static void
      69                 :       2812 : print_sockaddr_data_un(const void *const buf, const int addrlen)
      70                 :            : {
      71                 :       2812 :         const struct sockaddr_un *const sa_un = buf;
      72                 :       2812 :         const int un_len = addrlen > (int) sizeof(*sa_un)
      73                 :            :                            ? (int) sizeof(*sa_un) : addrlen;
      74                 :       2812 :         const int path_len = un_len - SIZEOF_SA_FAMILY;
      75                 :            : 
      76                 :       2812 :         tprints("sun_path=");
      77         [ +  + ]:       2812 :         if (sa_un->sun_path[0]) {
      78                 :       2798 :                 print_quoted_string(sa_un->sun_path, path_len + 1,
      79                 :            :                                     QUOTE_0_TERMINATED);
      80                 :            :         } else {
      81                 :         14 :                 tprints("@");
      82                 :         14 :                 print_quoted_string(sa_un->sun_path + 1, path_len - 1, 0);
      83                 :            :         }
      84                 :       2812 : }
      85                 :            : 
      86                 :            : bool
      87                 :        246 : print_inet_addr(const int af,
      88                 :            :                 const void *const addr,
      89                 :            :                 const unsigned int len,
      90                 :            :                 const char *const var_name)
      91                 :            : {
      92                 :            :         char buf[INET6_ADDRSTRLEN];
      93                 :            : 
      94      [ +  +  - ]:        246 :         switch (af) {
      95                 :            :         case AF_INET:
      96         [ +  - ]:        202 :                 if (inet_ntop(af, addr, buf, sizeof(buf))) {
      97                 :        202 :                         tprintf("%s=inet_addr(\"%s\")", var_name, buf);
      98                 :        202 :                         return true;
      99                 :            :                 }
     100                 :            :                 break;
     101                 :            :         case AF_INET6:
     102         [ +  - ]:         44 :                 if (inet_ntop(af, addr, buf, sizeof(buf))) {
     103                 :         44 :                         tprintf("inet_pton(%s, \"%s\", &%s)",
     104                 :            :                                 "AF_INET6", buf, var_name);
     105                 :         44 :                         return true;
     106                 :            :                 }
     107                 :            :                 break;
     108                 :            :         }
     109                 :            : 
     110                 :          0 :         tprintf("%s=", var_name);
     111                 :          0 :         print_quoted_string(addr, len, 0);
     112                 :          0 :         return false;
     113                 :            : }
     114                 :            : 
     115                 :            : static void
     116                 :         33 : print_sockaddr_data_in(const void *const buf, const int addrlen)
     117                 :            : {
     118                 :         33 :         const struct sockaddr_in *const sa_in = buf;
     119                 :            : 
     120         [ -  + ]:         33 :         PRINT_FIELD_NET_PORT("", *sa_in, sin_port);
     121                 :         33 :         PRINT_FIELD_INET4_ADDR(", ", *sa_in, sin_addr);
     122                 :         33 : }
     123                 :            : 
     124                 :            : #define SIN6_MIN_LEN offsetof(struct sockaddr_in6, sin6_scope_id)
     125                 :            : 
     126                 :            : static void
     127                 :         22 : print_sockaddr_data_in6(const void *const buf, const int addrlen)
     128                 :            : {
     129                 :         22 :         const struct sockaddr_in6 *const sa_in6 = buf;
     130                 :            : 
     131         [ -  + ]:         22 :         PRINT_FIELD_NET_PORT("", *sa_in6, sin6_port);
     132                 :         22 :         PRINT_FIELD_INET_ADDR(", ", *sa_in6, sin6_addr, AF_INET6);
     133                 :         22 :         tprintf(", sin6_flowinfo=htonl(%u)", ntohl(sa_in6->sin6_flowinfo));
     134                 :            : 
     135         [ +  + ]:         22 :         if (addrlen <= (int) SIN6_MIN_LEN)
     136                 :         22 :                 return;
     137                 :            : 
     138                 :            : #if defined IN6_IS_ADDR_LINKLOCAL && defined IN6_IS_ADDR_MC_LINKLOCAL
     139         [ +  + ]:         20 :         if (IN6_IS_ADDR_LINKLOCAL(&sa_in6->sin6_addr)
     140 [ +  + ][ +  + ]:         16 :             || IN6_IS_ADDR_MC_LINKLOCAL(&sa_in6->sin6_addr))
     141                 :          8 :                 PRINT_FIELD_IFINDEX(", ", *sa_in6, sin6_scope_id);
     142                 :            :         else
     143                 :            : #endif
     144                 :         12 :                 PRINT_FIELD_U(", ", *sa_in6, sin6_scope_id);
     145                 :            : }
     146                 :            : 
     147                 :            : static void
     148                 :          2 : print_sockaddr_data_ipx(const void *const buf, const int addrlen)
     149                 :            : {
     150                 :          2 :         const struct sockaddr_ipx *const sa_ipx = buf;
     151                 :            :         unsigned int i;
     152                 :            : 
     153         [ -  + ]:          2 :         PRINT_FIELD_NET_PORT("", *sa_ipx, sipx_port);
     154                 :          4 :         tprintf(", sipx_network=htonl(%#08x)"
     155                 :            :                 ", sipx_node=[",
     156                 :            :                 ntohl(sa_ipx->sipx_network));
     157         [ +  + ]:         14 :         for (i = 0; i < IPX_NODE_LEN; ++i) {
     158         [ +  + ]:         12 :                 tprintf("%s%#02x", i ? ", " : "",
     159                 :         12 :                         sa_ipx->sipx_node[i]);
     160                 :            :         }
     161                 :          2 :         PRINT_FIELD_0X("], ", *sa_ipx, sipx_type);
     162                 :          2 : }
     163                 :            : 
     164                 :            : static void
     165                 :          8 : print_sockaddr_data_nl(const void *const buf, const int addrlen)
     166                 :            : {
     167                 :          8 :         const struct sockaddr_nl *const sa_nl = buf;
     168                 :            : 
     169                 :          8 :         PRINT_FIELD_D("", *sa_nl, nl_pid);
     170                 :          8 :         PRINT_FIELD_0X(", ", *sa_nl, nl_groups);
     171                 :          8 : }
     172                 :            : 
     173                 :            : static void
     174                 :          8 : print_sockaddr_data_ll(const void *const buf, const int addrlen)
     175                 :            : {
     176                 :          8 :         const struct sockaddr_ll *const sa_ll = buf;
     177                 :            : 
     178                 :          8 :         tprints("sll_protocol=htons(");
     179         [ -  + ]:          8 :         printxval(ethernet_protocols, ntohs(sa_ll->sll_protocol), "ETH_P_???");
     180                 :          8 :         PRINT_FIELD_IFINDEX("), ", *sa_ll, sll_ifindex);
     181                 :          8 :         tprints(", sll_hatype=");
     182                 :          8 :         printxval(arp_hardware_types, sa_ll->sll_hatype, "ARPHRD_???");
     183                 :          8 :         tprints(", sll_pkttype=");
     184                 :          8 :         printxval(af_packet_types, sa_ll->sll_pkttype, "PACKET_???");
     185                 :          8 :         tprintf(", sll_halen=%u", sa_ll->sll_halen);
     186         [ +  + ]:          8 :         if (sa_ll->sll_halen) {
     187                 :          4 :                 const unsigned int oob_halen =
     188                 :            :                         addrlen - offsetof(struct sockaddr_ll, sll_addr);
     189                 :            :                 unsigned int i;
     190                 :            : 
     191                 :          4 :                 tprints(", sll_addr=[");
     192         [ +  + ]:         36 :                 for (i = 0; i < sa_ll->sll_halen; ++i) {
     193         [ +  + ]:         34 :                         if (i)
     194                 :         30 :                                 tprints(", ");
     195         [ +  + ]:         34 :                         if (i >= oob_halen) {
     196                 :          2 :                                 tprints("...");
     197                 :          2 :                                 break;
     198                 :            :                         }
     199                 :         32 :                         tprintf("%#02x", sa_ll->sll_addr[i]);
     200                 :            :                 }
     201                 :          4 :                 tprints("]");
     202                 :            :         }
     203                 :          8 : }
     204                 :            : 
     205                 :            : static void
     206                 :         10 : print_sockaddr_data_raw(const void *const buf, const int addrlen)
     207                 :            : {
     208                 :         10 :         const char *const data = buf + SIZEOF_SA_FAMILY;
     209                 :         10 :         const int datalen = addrlen - SIZEOF_SA_FAMILY;
     210                 :            : 
     211                 :         10 :         tprints("sa_data=");
     212                 :         10 :         print_quoted_string(data, datalen, 0);
     213                 :         10 : }
     214                 :            : 
     215                 :            : #ifdef HAVE_BLUETOOTH_BLUETOOTH_H
     216                 :            : static void
     217                 :            : print_sockaddr_data_bt(const void *const buf, const int addrlen)
     218                 :            : {
     219                 :            :         switch (addrlen) {
     220                 :            :                 case sizeof(struct sockaddr_hci): {
     221                 :            :                         const struct sockaddr_hci *const hci = buf;
     222                 :            :                         tprintf("hci_dev=htobs(%hu), hci_channel=",
     223                 :            :                                 btohs(hci->hci_dev));
     224                 :            :                         printxval(hci_channels, hci->hci_channel,
     225                 :            :                                   "HCI_CHANNEL_???");
     226                 :            :                         break;
     227                 :            :                 }
     228                 :            :                 case sizeof(struct sockaddr_sco): {
     229                 :            :                         const struct sockaddr_sco *const sco = buf;
     230                 :            :                         tprintf("sco_bdaddr=%02x:%02x:%02x:%02x:%02x:%02x",
     231                 :            :                                 sco->sco_bdaddr.b[0], sco->sco_bdaddr.b[1],
     232                 :            :                                 sco->sco_bdaddr.b[2], sco->sco_bdaddr.b[3],
     233                 :            :                                 sco->sco_bdaddr.b[4], sco->sco_bdaddr.b[5]);
     234                 :            :                         break;
     235                 :            :                 }
     236                 :            :                 case sizeof(struct sockaddr_rc): {
     237                 :            :                         const struct sockaddr_rc *const rc = buf;
     238                 :            :                         tprintf("rc_bdaddr=%02x:%02x:%02x:%02x:%02x:%02x"
     239                 :            :                                 ", rc_channel=%u",
     240                 :            :                                 rc->rc_bdaddr.b[0], rc->rc_bdaddr.b[1],
     241                 :            :                                 rc->rc_bdaddr.b[2], rc->rc_bdaddr.b[3],
     242                 :            :                                 rc->rc_bdaddr.b[4], rc->rc_bdaddr.b[5],
     243                 :            :                                 rc->rc_channel);
     244                 :            :                         break;
     245                 :            :                 }
     246                 :            :                 case sizeof(struct sockaddr_l2): {
     247                 :            :                         const struct sockaddr_l2 *const l2 = buf;
     248                 :            :                         tprintf("l2_psm=htobs(%hu)"
     249                 :            :                                 ", l2_bdaddr=%02x:%02x:%02x:%02x:%02x:%02x"
     250                 :            :                                 ", l2_cid=htobs(%hu), l2_bdaddr_type=%u",
     251                 :            :                                 btohs(l2->l2_psm),
     252                 :            :                                 l2->l2_bdaddr.b[0], l2->l2_bdaddr.b[1],
     253                 :            :                                 l2->l2_bdaddr.b[2], l2->l2_bdaddr.b[3],
     254                 :            :                                 l2->l2_bdaddr.b[4], l2->l2_bdaddr.b[5],
     255                 :            :                                 btohs(l2->l2_cid), l2->l2_bdaddr_type);
     256                 :            :                         break;
     257                 :            :                 }
     258                 :            :                 default:
     259                 :            :                         print_sockaddr_data_raw(buf, addrlen);
     260                 :            :                         break;
     261                 :            :         }
     262                 :            : }
     263                 :            : #endif /* HAVE_BLUETOOTH_BLUETOOTH_H */
     264                 :            : 
     265                 :            : typedef void (* const sockaddr_printer)(const void *const, const int);
     266                 :            : 
     267                 :            : static const struct {
     268                 :            :         const sockaddr_printer printer;
     269                 :            :         const int min_len;
     270                 :            : } sa_printers[] = {
     271                 :            :         [AF_UNIX] = { print_sockaddr_data_un, SIZEOF_SA_FAMILY + 1 },
     272                 :            :         [AF_INET] = { print_sockaddr_data_in, sizeof(struct sockaddr_in) },
     273                 :            :         [AF_IPX] = { print_sockaddr_data_ipx, sizeof(struct sockaddr_ipx) },
     274                 :            :         [AF_INET6] = { print_sockaddr_data_in6, SIN6_MIN_LEN },
     275                 :            :         [AF_NETLINK] = { print_sockaddr_data_nl, SIZEOF_SA_FAMILY + 1 },
     276                 :            :         [AF_PACKET] = { print_sockaddr_data_ll, sizeof(struct sockaddr_ll) },
     277                 :            : #ifdef HAVE_BLUETOOTH_BLUETOOTH_H
     278                 :            :         [AF_BLUETOOTH] = { print_sockaddr_data_bt, SIZEOF_SA_FAMILY + 1 },
     279                 :            : #endif
     280                 :            : };
     281                 :            : 
     282                 :            : void
     283                 :       2921 : print_sockaddr(const void *const buf, const int addrlen)
     284                 :            : {
     285                 :       2921 :         const struct sockaddr *const sa = buf;
     286                 :            : 
     287                 :       2921 :         tprints("{sa_family=");
     288                 :       2921 :         printxval(addrfams, sa->sa_family, "AF_???");
     289                 :            : 
     290         [ +  + ]:       2921 :         if (addrlen > (int) SIZEOF_SA_FAMILY) {
     291                 :       2895 :                 tprints(", ");
     292                 :            : 
     293         [ +  + ]:       2895 :                 if (sa->sa_family < ARRAY_SIZE(sa_printers)
     294         [ +  + ]:       2891 :                     && sa_printers[sa->sa_family].printer
     295         [ +  + ]:       2889 :                     && addrlen >= sa_printers[sa->sa_family].min_len) {
     296                 :       2885 :                         sa_printers[sa->sa_family].printer(buf, addrlen);
     297                 :            :                 } else {
     298                 :         10 :                         print_sockaddr_data_raw(buf, addrlen);
     299                 :            :                 }
     300                 :            :         }
     301                 :            : 
     302                 :       2921 :         tprints("}");
     303                 :       2921 : }
     304                 :            : 
     305                 :            : int
     306                 :      70522 : decode_sockaddr(struct tcb *const tcp, const kernel_ulong_t addr, int addrlen)
     307                 :            : {
     308         [ +  + ]:      70522 :         if (addrlen < 2) {
     309                 :      67616 :                 printaddr(addr);
     310                 :      67616 :                 return -1;
     311                 :            :         }
     312                 :            : 
     313                 :            :         union {
     314                 :            :                 struct sockaddr sa;
     315                 :            :                 struct sockaddr_storage storage;
     316                 :            :                 char pad[sizeof(struct sockaddr_storage) + 1];
     317                 :            :         } addrbuf;
     318                 :            : 
     319         [ +  + ]:       2906 :         if ((unsigned) addrlen > sizeof(addrbuf.storage))
     320                 :       1798 :                 addrlen = sizeof(addrbuf.storage);
     321                 :            : 
     322         [ +  + ]:       2906 :         if (umoven_or_printaddr(tcp, addr, addrlen, addrbuf.pad))
     323                 :            :                 return -1;
     324                 :            : 
     325                 :       2898 :         memset(&addrbuf.pad[addrlen], 0, sizeof(addrbuf.pad) - addrlen);
     326                 :            : 
     327                 :       2898 :         print_sockaddr(&addrbuf, addrlen);
     328                 :            : 
     329                 :       2898 :         return addrbuf.sa.sa_family;
     330                 :            : }

Generated by: LCOV version 1.11