anet.c

Bug Summary

File:	src/anet.c
Warning:	line 624, column 22 The left operand of '==' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name anet.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D REDIS_STATIC= -I ../deps/hiredis -I ../deps/linenoise -I ../deps/lua/src -I ../deps/hdr_histogram -D USE_JEMALLOC -I ../deps/jemalloc/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-c11-extensions -Wno-missing-field-initializers -std=c11 -fdebug-compilation-dir /home/netto/Desktop/redis-6.2.1/src -ferror-limit 19 -fmessage-length 0 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-03-14-133648-8817-1 -x c anet.c

1/* anet.c -- Basic TCP socket stuff made a bit less boring
*
* Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez at gmail dot com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
*   * Redistributions of source code must retain the above copyright notice,
*     this list of conditions and the following disclaimer.
*   * Redistributions in binary form must reproduce the above copyright
*     notice, this list of conditions and the following disclaimer in the
*     documentation and/or other materials provided with the distribution.
*   * Neither the name of Redis nor the names of its contributors may be used
*     to endorse or promote products derived from this software without
*     specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

31#include "fmacros.h"

33#include <sys/types.h>
34#include <sys/socket.h>
35#include <sys/stat.h>
36#include <sys/un.h>
37#include <sys/time.h>
38#include <netinet/in.h>
39#include <netinet/tcp.h>
40#include <arpa/inet.h>
41#include <unistd.h>
42#include <fcntl.h>
43#include <string.h>
44#include <netdb.h>
45#include <errno(*__errno_location ()).h>
46#include <stdarg.h>
47#include <stdio.h>

49#include "anet.h"

51static void anetSetError(char *err, const char *fmt, ...)
52{
  va_list ap;

  if (!err) return;
  va_start(ap, fmt)__builtin_va_start(ap, fmt);
  vsnprintf(err, ANET_ERR_LEN256, fmt, ap);
  va_end(ap)__builtin_va_end(ap);
59}

61int anetSetBlock(char *err, int fd, int non_block) {
  int flags;

  /* Set the socket blocking (if non_block is zero) or non-blocking.
   * Note that fcntl(2) for F_GETFL and F_SETFL can't be
   * interrupted by a signal. */
  if ((flags = fcntl(fd, F_GETFL3)) == -1) {
      anetSetError(err, "fcntl(F_GETFL): %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }

  /* Check if this flag has been set or unset, if so, 
   * then there is no need to call fcntl to set/unset it again. */
  if (!!(flags & O_NONBLOCK04000) == !!non_block)
      return ANET_OK0;

  if (non_block)
      flags |= O_NONBLOCK04000;
  else
      flags &= ~O_NONBLOCK04000;

  if (fcntl(fd, F_SETFL4, flags) == -1) {
      anetSetError(err, "fcntl(F_SETFL,O_NONBLOCK): %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
  return ANET_OK0;
87}

89int anetNonBlock(char *err, int fd) {
  return anetSetBlock(err,fd,1);
91}

93int anetBlock(char *err, int fd) {
  return anetSetBlock(err,fd,0);
95}

97/* Enable the FD_CLOEXEC on the given fd to avoid fd leaks. 
* This function should be invoked for fd's on specific places 
* where fork + execve system calls are called. */
100int anetCloexec(int fd) {
  int r;
  int flags;

  do {
      r = fcntl(fd, F_GETFD1);
  } while (r == -1 && errno(*__errno_location ()) == EINTR4);

  if (r == -1 || (r & FD_CLOEXEC1))
      return r;

  flags = r | FD_CLOEXEC1;

  do {
      r = fcntl(fd, F_SETFD2, flags);
  } while (r == -1 && errno(*__errno_location ()) == EINTR4);

  return r;
118}

120/* Set TCP keep alive option to detect dead peers. The interval option
* is only used for Linux as we are using Linux-specific APIs to set
* the probe send time, interval, and count. */
123int anetKeepAlive(char *err, int fd, int interval)
124{
  int val = 1;

  if (setsockopt(fd, SOL_SOCKET1, SO_KEEPALIVE9, &val, sizeof(val)) == -1)
  {
      anetSetError(err, "setsockopt SO_KEEPALIVE: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }

133#ifdef __linux__1
  /* Default settings are more or less garbage, with the keepalive time
   * set to 7200 by default on Linux. Modify settings to make the feature
   * actually useful. */

  /* Send first probe after interval. */
  val = interval;
  if (setsockopt(fd, IPPROTO_TCPIPPROTO_TCP, TCP_KEEPIDLE4, &val, sizeof(val)) < 0) {
      anetSetError(err, "setsockopt TCP_KEEPIDLE: %s\n", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }

  /* Send next probes after the specified interval. Note that we set the
   * delay as interval / 3, as we send three probes before detecting
   * an error (see the next setsockopt call). */
  val = interval/3;
  if (val == 0) val = 1;
  if (setsockopt(fd, IPPROTO_TCPIPPROTO_TCP, TCP_KEEPINTVL5, &val, sizeof(val)) < 0) {
      anetSetError(err, "setsockopt TCP_KEEPINTVL: %s\n", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }

  /* Consider the socket in error state after three we send three ACK
   * probes without getting a reply. */
  val = 3;
  if (setsockopt(fd, IPPROTO_TCPIPPROTO_TCP, TCP_KEEPCNT6, &val, sizeof(val)) < 0) {
      anetSetError(err, "setsockopt TCP_KEEPCNT: %s\n", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
162#else
  ((void) interval); /* Avoid unused var warning for non Linux systems. */
164#endif

  return ANET_OK0;
167}

169static int anetSetTcpNoDelay(char *err, int fd, int val)
170{
  if (setsockopt(fd, IPPROTO_TCPIPPROTO_TCP, TCP_NODELAY1, &val, sizeof(val)) == -1)
  {
      anetSetError(err, "setsockopt TCP_NODELAY: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
  return ANET_OK0;
177}

179int anetEnableTcpNoDelay(char *err, int fd)
180{
  return anetSetTcpNoDelay(err, fd, 1);
182}

184int anetDisableTcpNoDelay(char *err, int fd)
185{
  return anetSetTcpNoDelay(err, fd, 0);
187}


190int anetSetSendBuffer(char *err, int fd, int buffsize)
191{
  if (setsockopt(fd, SOL_SOCKET1, SO_SNDBUF7, &buffsize, sizeof(buffsize)) == -1)
  {
      anetSetError(err, "setsockopt SO_SNDBUF: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
  return ANET_OK0;
198}

200int anetTcpKeepAlive(char *err, int fd)
201{
  int yes = 1;
  if (setsockopt(fd, SOL_SOCKET1, SO_KEEPALIVE9, &yes, sizeof(yes)) == -1) {
      anetSetError(err, "setsockopt SO_KEEPALIVE: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
  return ANET_OK0;
208}

210/* Set the socket send timeout (SO_SNDTIMEO socket option) to the specified
* number of milliseconds, or disable it if the 'ms' argument is zero. */
212int anetSendTimeout(char *err, int fd, long long ms) {
  struct timeval tv;

  tv.tv_sec = ms/1000;
  tv.tv_usec = (ms%1000)*1000;
  if (setsockopt(fd, SOL_SOCKET1, SO_SNDTIMEO21, &tv, sizeof(tv)) == -1) {
      anetSetError(err, "setsockopt SO_SNDTIMEO: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
  return ANET_OK0;
222}

224/* Set the socket receive timeout (SO_RCVTIMEO socket option) to the specified
* number of milliseconds, or disable it if the 'ms' argument is zero. */
226int anetRecvTimeout(char *err, int fd, long long ms) {
  struct timeval tv;

  tv.tv_sec = ms/1000;
  tv.tv_usec = (ms%1000)*1000;
  if (setsockopt(fd, SOL_SOCKET1, SO_RCVTIMEO20, &tv, sizeof(tv)) == -1) {
      anetSetError(err, "setsockopt SO_RCVTIMEO: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
  return ANET_OK0;
236}

238/* Resolve the hostname "host" and set the string representation of the
* IP address into the buffer pointed by "ipbuf".
*
* If flags is set to ANET_IP_ONLY the function only resolves hostnames
* that are actually already IPv4 or IPv6 addresses. This turns the function
* into a validating / normalizing function. */
244int anetResolve(char *err, char *host, char *ipbuf, size_t ipbuf_len,
                     int flags)
246{
  struct addrinfo hints, *info;
  int rv;

  memset(&hints,0,sizeof(hints));
  if (flags & ANET_IP_ONLY(1<<0)) hints.ai_flags = AI_NUMERICHOST0x0004;
  hints.ai_family = AF_UNSPEC0;
  hints.ai_socktype = SOCK_STREAMSOCK_STREAM;  /* specify socktype to avoid dups */

  if ((rv = getaddrinfo(host, NULL((void*)0), &hints, &info)) != 0) {
      anetSetError(err, "%s", gai_strerror(rv));
      return ANET_ERR-1;
  }
  if (info->ai_family == AF_INET2) {
      struct sockaddr_in *sa = (struct sockaddr_in *)info->ai_addr;
      inet_ntop(AF_INET2, &(sa->sin_addr), ipbuf, ipbuf_len);
  } else {
      struct sockaddr_in6 *sa = (struct sockaddr_in6 *)info->ai_addr;
      inet_ntop(AF_INET610, &(sa->sin6_addr), ipbuf, ipbuf_len);
  }

  freeaddrinfo(info);
  return ANET_OK0;
269}

271static int anetSetReuseAddr(char *err, int fd) {
  int yes = 1;
  /* Make sure connection-intensive things like the redis benchmark
   * will be able to close/open sockets a zillion of times */
  if (setsockopt(fd, SOL_SOCKET1, SO_REUSEADDR2, &yes, sizeof(yes)) == -1) {
      anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
  return ANET_OK0;
280}

282static int anetCreateSocket(char *err, int domain) {
  int s;
  if ((s = socket(domain, SOCK_STREAMSOCK_STREAM, 0)) == -1) {
      anetSetError(err, "creating socket: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }

  /* Make sure connection-intensive things like the redis benchmark
   * will be able to close/open sockets a zillion of times */
  if (anetSetReuseAddr(err,s) == ANET_ERR-1) {
      close(s);
      return ANET_ERR-1;
  }
  return s;
296}

298#define ANET_CONNECT_NONE0 0
299#define ANET_CONNECT_NONBLOCK1 1
300#define ANET_CONNECT_BE_BINDING2 2 /* Best effort binding. */
301static int anetTcpGenericConnect(char *err, const char *addr, int port,
                               const char *source_addr, int flags)
303{
  int s = ANET_ERR-1, rv;
  char portstr[6];  /* strlen("65535") + 1; */
  struct addrinfo hints, *servinfo, *bservinfo, *p, *b;

  snprintf(portstr,sizeof(portstr),"%d",port);
  memset(&hints,0,sizeof(hints));
  hints.ai_family = AF_UNSPEC0;
  hints.ai_socktype = SOCK_STREAMSOCK_STREAM;

  if ((rv = getaddrinfo(addr,portstr,&hints,&servinfo)) != 0) {
      anetSetError(err, "%s", gai_strerror(rv));
      return ANET_ERR-1;
  }
  for (p = servinfo; p != NULL((void*)0); p = p->ai_next) {
      /* Try to create the socket and to connect it.
       * If we fail in the socket() call, or on connect(), we retry with
       * the next entry in servinfo. */
      if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)
          continue;
      if (anetSetReuseAddr(err,s) == ANET_ERR-1) goto error;
      if (flags & ANET_CONNECT_NONBLOCK1 && anetNonBlock(err,s) != ANET_OK0)
          goto error;
      if (source_addr) {
          int bound = 0;
          /* Using getaddrinfo saves us from self-determining IPv4 vs IPv6 */
          if ((rv = getaddrinfo(source_addr, NULL((void*)0), &hints, &bservinfo)) != 0)
          {
              anetSetError(err, "%s", gai_strerror(rv));
              goto error;
          }
          for (b = bservinfo; b != NULL((void*)0); b = b->ai_next) {
              if (bind(s,b->ai_addr,b->ai_addrlen) != -1) {
                  bound = 1;
                  break;
              }
          }
          freeaddrinfo(bservinfo);
          if (!bound) {
              anetSetError(err, "bind: %s", strerror(errno(*__errno_location ())));
              goto error;
          }
      }
      if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {
          /* If the socket is non-blocking, it is ok for connect() to
           * return an EINPROGRESS error here. */
          if (errno(*__errno_location ()) == EINPROGRESS115 && flags & ANET_CONNECT_NONBLOCK1)
              goto end;
          close(s);
          s = ANET_ERR-1;
          continue;
      }

      /* If we ended an iteration of the for loop without errors, we
       * have a connected socket. Let's return to the caller. */
      goto end;
  }
  if (p == NULL((void*)0))
      anetSetError(err, "creating socket: %s", strerror(errno(*__errno_location ())));

363error:
  if (s != ANET_ERR-1) {
      close(s);
      s = ANET_ERR-1;
  }

369end:
  freeaddrinfo(servinfo);

  /* Handle best effort binding: if a binding address was used, but it is
   * not possible to create a socket, try again without a binding address. */
  if (s == ANET_ERR-1 && source_addr && (flags & ANET_CONNECT_BE_BINDING2)) {
      return anetTcpGenericConnect(err,addr,port,NULL((void*)0),flags);
  } else {
      return s;
  }
379}

381int anetTcpConnect(char *err, const char *addr, int port)
382{
  return anetTcpGenericConnect(err,addr,port,NULL((void*)0),ANET_CONNECT_NONE0);
384}

386int anetTcpNonBlockConnect(char *err, const char *addr, int port)
387{
  return anetTcpGenericConnect(err,addr,port,NULL((void*)0),ANET_CONNECT_NONBLOCK1);
389}

391int anetTcpNonBlockBindConnect(char *err, const char *addr, int port,
                             const char *source_addr)
393{
  return anetTcpGenericConnect(err,addr,port,source_addr,
          ANET_CONNECT_NONBLOCK1);
396}

398int anetTcpNonBlockBestEffortBindConnect(char *err, const char *addr, int port,
                                       const char *source_addr)
400{
  return anetTcpGenericConnect(err,addr,port,source_addr,
          ANET_CONNECT_NONBLOCK1|ANET_CONNECT_BE_BINDING2);
403}

405int anetUnixGenericConnect(char *err, const char *path, int flags)
406{
  int s;
  struct sockaddr_un sa;

  if ((s = anetCreateSocket(err,AF_LOCAL1)) == ANET_ERR-1)
      return ANET_ERR-1;

  sa.sun_family = AF_LOCAL1;
  strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
  if (flags & ANET_CONNECT_NONBLOCK1) {
      if (anetNonBlock(err,s) != ANET_OK0) {
          close(s);
          return ANET_ERR-1;
      }
  }
  if (connect(s,(struct sockaddr*)&sa,sizeof(sa)) == -1) {
      if (errno(*__errno_location ()) == EINPROGRESS115 &&
          flags & ANET_CONNECT_NONBLOCK1)
          return s;

      anetSetError(err, "connect: %s", strerror(errno(*__errno_location ())));
      close(s);
      return ANET_ERR-1;
  }
  return s;
431}

433int anetUnixConnect(char *err, const char *path)
434{
  return anetUnixGenericConnect(err,path,ANET_CONNECT_NONE0);
436}

438int anetUnixNonBlockConnect(char *err, const char *path)
439{
  return anetUnixGenericConnect(err,path,ANET_CONNECT_NONBLOCK1);
441}

443/* Like read(2) but make sure 'count' is read before to return
* (unless error or EOF condition is encountered) */
445int anetRead(int fd, char *buf, int count)
446{
  ssize_t nread, totlen = 0;
  while(totlen != count) {
      nread = read(fd,buf,count-totlen);
      if (nread == 0) return totlen;
      if (nread == -1) return -1;
      totlen += nread;
      buf += nread;
  }
  return totlen;
456}

458/* Like write(2) but make sure 'count' is written before to return
* (unless error is encountered) */
460int anetWrite(int fd, char *buf, int count)
461{
  ssize_t nwritten, totlen = 0;
  while(totlen != count) {
      nwritten = write(fd,buf,count-totlen);
      if (nwritten == 0) return totlen;
      if (nwritten == -1) return -1;
      totlen += nwritten;
      buf += nwritten;
  }
  return totlen;
471}

473static int anetListen(char *err, int s, struct sockaddr *sa, socklen_t len, int backlog) {
  if (bind(s,sa,len) == -1) {
      anetSetError(err, "bind: %s", strerror(errno(*__errno_location ())));
      close(s);
      return ANET_ERR-1;
  }

  if (listen(s, backlog) == -1) {
      anetSetError(err, "listen: %s", strerror(errno(*__errno_location ())));
      close(s);
      return ANET_ERR-1;
  }
  return ANET_OK0;
486}

488static int anetV6Only(char *err, int s) {
  int yes = 1;
  if (setsockopt(s,IPPROTO_IPV6IPPROTO_IPV6,IPV6_V6ONLY26,&yes,sizeof(yes)) == -1) {
      anetSetError(err, "setsockopt: %s", strerror(errno(*__errno_location ())));
      return ANET_ERR-1;
  }
  return ANET_OK0;
495}

497static int _anetTcpServer(char *err, int port, char *bindaddr, int af, int backlog)
498{
  int s = -1, rv;
  char _port[6];  /* strlen("65535") */
  struct addrinfo hints, *servinfo, *p;

  snprintf(_port,6,"%d",port);
  memset(&hints,0,sizeof(hints));
  hints.ai_family = af;
  hints.ai_socktype = SOCK_STREAMSOCK_STREAM;
  hints.ai_flags = AI_PASSIVE0x0001;    /* No effect if bindaddr != NULL */
  if (bindaddr && !strcmp("*", bindaddr))
      bindaddr = NULL((void*)0);
  if (af == AF_INET610 && bindaddr && !strcmp("::*", bindaddr))
      bindaddr = NULL((void*)0);

  if ((rv = getaddrinfo(bindaddr,_port,&hints,&servinfo)) != 0) {
      anetSetError(err, "%s", gai_strerror(rv));
      return ANET_ERR-1;
  }
  for (p = servinfo; p != NULL((void*)0); p = p->ai_next) {
      if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)
          continue;

      if (af == AF_INET610 && anetV6Only(err,s) == ANET_ERR-1) goto error;
      if (anetSetReuseAddr(err,s) == ANET_ERR-1) goto error;
      if (anetListen(err,s,p->ai_addr,p->ai_addrlen,backlog) == ANET_ERR-1) s = ANET_ERR-1;
      goto end;
  }
  if (p == NULL((void*)0)) {
      anetSetError(err, "unable to bind socket, errno: %d", errno(*__errno_location ()));
      goto error;
  }

531error:
  if (s != -1) close(s);
  s = ANET_ERR-1;
534end:
  freeaddrinfo(servinfo);
  return s;
537}

539int anetTcpServer(char *err, int port, char *bindaddr, int backlog)
540{
  return _anetTcpServer(err, port, bindaddr, AF_INET2, backlog);
542}

544int anetTcp6Server(char *err, int port, char *bindaddr, int backlog)
545{
  return _anetTcpServer(err, port, bindaddr, AF_INET610, backlog);
547}

549int anetUnixServer(char *err, char *path, mode_t perm, int backlog)
550{
  int s;
  struct sockaddr_un sa;

  if ((s = anetCreateSocket(err,AF_LOCAL1)) == ANET_ERR-1)
      return ANET_ERR-1;

  memset(&sa,0,sizeof(sa));
  sa.sun_family = AF_LOCAL1;
  strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
  if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa),backlog) == ANET_ERR-1)
      return ANET_ERR-1;
  if (perm)
      chmod(sa.sun_path, perm);
  return s;
565}

567static int anetGenericAccept(char *err, int s, struct sockaddr *sa, socklen_t *len) {
  int fd;
  while(1) {
      fd = accept(s,sa,len);
      if (fd == -1) {
          if (errno(*__errno_location ()) == EINTR4)
              continue;
          else {
              anetSetError(err, "accept: %s", strerror(errno(*__errno_location ())));
              return ANET_ERR-1;
          }
      }
      break;
  }
  return fd;
582}

584int anetTcpAccept(char *err, int s, char *ip, size_t ip_len, int *port) {
  int fd;
  struct sockaddr_storage sa;
  socklen_t salen = sizeof(sa);
  if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == -1)
      return ANET_ERR-1;

  if (sa.ss_family == AF_INET2) {
      struct sockaddr_in *s = (struct sockaddr_in *)&sa;
      if (ip) inet_ntop(AF_INET2,(void*)&(s->sin_addr),ip,ip_len);
      if (port) *port = ntohs(s->sin_port)__bswap_16 (s->sin_port);
  } else {
      struct sockaddr_in6 *s = (struct sockaddr_in6 *)&sa;
      if (ip) inet_ntop(AF_INET610,(void*)&(s->sin6_addr),ip,ip_len);
      if (port) *port = ntohs(s->sin6_port)__bswap_16 (s->sin6_port);
  }
  return fd;
601}

603int anetUnixAccept(char *err, int s) {
  int fd;
  struct sockaddr_un sa;
  socklen_t salen = sizeof(sa);
  if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == -1)
      return ANET_ERR-1;

  return fd;
611}

613int anetFdToString(int fd, char *ip, size_t ip_len, int *port, int fd_to_str_type) {
  struct sockaddr_storage sa;
  socklen_t salen = sizeof(sa);

  if (fd_to_str_type == FD_TO_PEER_NAME0) {
2
←
Assuming 'fd_to_str_type' is not equal to FD_TO_PEER_NAME→
3
←
Taking false branch→
      if (getpeername(fd, (struct sockaddr *)&sa, &salen) == -1) goto error;
  } else {
      if (getsockname(fd, (struct sockaddr *)&sa, &salen) == -1) goto error;
4
←
Assuming the condition is false→
5
←
Taking false branch→
  }
  if (ip_len5.1
'ip_len' is not equal to 0
 == 0) goto error;
6
←
Taking false branch→

  if (sa.ss_family == AF_INET2) {
7
←
The left operand of '==' is a garbage value
      struct sockaddr_in *s = (struct sockaddr_in *)&sa;
      if (ip) inet_ntop(AF_INET2,(void*)&(s->sin_addr),ip,ip_len);
      if (port) *port = ntohs(s->sin_port)__bswap_16 (s->sin_port);
  } else if (sa.ss_family == AF_INET610) {
      struct sockaddr_in6 *s = (struct sockaddr_in6 *)&sa;
      if (ip) inet_ntop(AF_INET610,(void*)&(s->sin6_addr),ip,ip_len);
      if (port) *port = ntohs(s->sin6_port)__bswap_16 (s->sin6_port);
  } else if (sa.ss_family == AF_UNIX1) {
      if (ip) snprintf(ip, ip_len, "/unixsocket");
      if (port) *port = 0;
  } else {
      goto error;
  }
  return 0;

640error:
  if (ip) {
      if (ip_len >= 2) {
          ip[0] = '?';
          ip[1] = '\0';
      } else if (ip_len == 1) {
          ip[0] = '\0';
      }
  }
  if (port) *port = 0;
  return -1;
651}

653/* Format an IP,port pair into something easy to parse. If IP is IPv6
* (matches for ":"), the ip is surrounded by []. IP and port are just
* separated by colons. This the standard to display addresses within Redis. */
656int anetFormatAddr(char *buf, size_t buf_len, char *ip, int port) {
  return snprintf(buf,buf_len, strchr(ip,':') ?
         "[%s]:%d" : "%s:%d", ip, port);
659}

661/* Like anetFormatAddr() but extract ip and port from the socket's peer/sockname. */
662int anetFormatFdAddr(int fd, char *buf, size_t buf_len, int fd_to_str_type) {
  char ip[INET6_ADDRSTRLEN46];
  int port;

  anetFdToString(fd,ip,sizeof(ip),&port,fd_to_str_type);
1
Calling 'anetFdToString'→
  return anetFormatAddr(buf, buf_len, ip, port);
668}