C getaddrinfo不'；无法获取ipv6地址

我正在尝试获取ipv4和ipv6地址并使用它们连接到服务器，但我只能使用ipv4地址连接。它实际上是一个标准代码。 ipv4和ipv6地址都位于/etc/hosts中

192.155.112.18 hostname.site hostname
fe80::a00:28ff:fe23:47a0 hostname.site hostname

当我同时运行服务器和客户端时，输出是 服务器：

客户：

client: connecting to 192.155.112.18
client: connecting to 192.155.112.18
client: received 'Hello, world!'

getaddrinfo也获取ipv6地址，但没有我需要获取的接口 fe80:a00:28ff:fe23:47a0%eth0诸如此类的东西。如何使标准代码获得ipv4和ipv6（带接口）

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义端口“3490”//用户将连接到的端口
无效错误（常量字符*消息）
{
佩罗尔（味精）；
出口（1）；
}
int gHostIP；
#定义BACKLOG 10//队列将容纳多少个挂起的连接
void sigchld_处理程序（int s）
{
而（waitpid（-1，NULL，WNOHANG）>0）；
}
//获取sockaddr、IPv4或IPv6：
void*get\u in\u addr（结构sockaddr*sa）
{
如果（sa->sa_族==AF_INET）
{
return&（（（struct sockaddr_in*）sa）->sin_addr）；
}
返回（（结构sockaddr_in6*）sa）->sin6_addr）；
}
int main（）
{
int sockfd，new\u fd；//在sock\u fd上侦听，在new\u fd上新建连接
结构addrinfo提示，*servinfo，*p；
struct sockaddr\u存储它们的地址；//连接器的地址信息
袜子的大小；
struct-sigaction-sa；
int yes=1；
字符s[INET6_ADDRSTRLEN]；
int-rv；
char*arg；
arg=（char*）malloc（20*sizeof（char））；
fprintf（stderr，“用法：showip主机名\n”）；
memset（&hints，0，sizeof（hints））；
hits.ai_family=AF_unsec；//AF_INET或AF_INET6强制版本
hits.ai_socktype=SOCK_流；
if（（rv=getaddrinfo（“我的主机名”、端口、提示和服务信息））！=0）{
fprintf（标准，“getaddrinfo:%s\n”，gai_strerror（rv））；
返回1；
}
for（p=servinfo；p！=NULL；p=p->ai_next）{
如果（（sockfd=socket（p->ai_族，p->ai_socktype，
p->ai_协议）=-1）{
perror（“服务器：套接字”）；
继续；
}
如果（设置sockopt）（sockfd，SOL_SOCKET，SO_REUSEADDR，&yes，
sizeof（int））==-1）{
perror（“setsockopt”）；
出口（1）；
}
/*如果（p->ai_族==AF_INET6）
strcat（p->ai_addr，“%eth3”）*/
如果（绑定（sockfd，p->ai_addr，p->ai_addrlen）=-1）{
关闭（sockfd）；
perror（“服务器：绑定”）；
继续；
}
打破
}
if（p==NULL）{
fprintf（stderr，“服务器：绑定失败\n”）；
返回2；
}
freeaddrinfo（servinfo）；//所有操作都使用此结构完成
如果（侦听（sockfd，BACKLOG）=-1）{
佩罗尔（“倾听”）；
出口（1）；
}
sa.sa_handler=sigchld_handler；//获取所有死进程
sigemptyset（和sa.sa_面具）；
sa.sa_标志=sa_重启；
if（sigaction（SIGCHLD，&sa，NULL）=-1）{
佩罗尔（“sigaction”）；
出口（1）；
}
printf（“服务器：正在等待连接…\n”）；
而(1)
{//main accept（）循环
sin_size=其地址的大小；
新地址=接受（sockfd，（结构sockaddr*）及其地址和大小）；
如果（新的_fd==-1）{
佩罗（“接受”）；
继续；
}
inet_ntop（他们的地址、家庭、，
获取地址（（struct sockaddr*）及其地址，
s、 尺寸（s）；
printf（“服务器：已从%s获得连接\n”，s）；
如果（！fork（））{//这是子进程
close（sockfd）；//孩子不需要侦听器
如果（发送（新的“你好，世界！”，13，0）=-1）
佩罗（“发送”）；
关闭（新的_fd）；
出口（0）；
}
close（new_fd）；//父级不需要此
}
返回0；
}

客户c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/resource.h>
#include <sched.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <signal.h>
#include <ifaddrs.h>

#define PORT "3490" // the port client will be connecting to

#define MAXDATASIZE 100 // max number of bytes we can get at once
int gHostIP;

// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
    if (sa->sa_family == AF_INET) {
        return &(((struct sockaddr_in*)sa)->sin_addr);
    }

    return &(((struct sockaddr_in6*)sa)->sin6_addr);
}



int main(int argc, char *argv[])
{
    int sockfd, numbytes;
    char buf[MAXDATASIZE];
    struct addrinfo hints, *servinfo, *p;
    int rv;
    char s[INET6_ADDRSTRLEN];
    char *arg;
    arg = (char*)malloc(20*sizeof(char));

    struct ifaddrs *ifaddr, *ifa;
    int family, s1;
    char host[NI_MAXHOST];


    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;


    if ((rv = getaddrinfo("myhostname", PORT, &hints, &servinfo)) != 0)
    {
      fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
      return 1;
    }


    for (p = servinfo; p != NULL; p = p->ai_next)
    {
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
            p->ai_protocol)) == -1) {
        perror("client: socket");
        continue;
        } 
        inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
               s, sizeof s);
         printf("\nclient: connecting to %s\n", s);
         if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
        close(sockfd);
        perror("\nclient: connect");
        continue;
         }

         break;
    }

    if (p == NULL) {
        fprintf(stderr, "client: failed to connect\n");
        return 2;
    }

    inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
        s, sizeof s);
    printf("client: connecting to %s\n", s);

    freeaddrinfo(servinfo);

    if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
            perror("recv");
            exit(1);
    }

    buf[numbytes] = '\0';

    printf("client: received '%s'\n",buf);

    close(sockfd);

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义端口“3490”//客户端将连接到的端口
#定义MAXDATASIZE 100//一次可获取的最大字节数
int gHostIP；
//获取sockaddr、IPv4或IPv6：
void*get\u in\u addr（结构sockaddr*sa）
{
如果（sa->sa_族==AF_INET）{
return&（（（struct sockaddr_in*）sa）->sin_addr）；
}
返回（（结构sockaddr_in6*）sa）->sin6_addr）；
}
int main（int argc，char*argv[]）
{
int sockfd，numbytes；
char buf[MAXDATASIZE]；
结构addrinfo提示，*servinfo，*p；
int-rv；
字符s[INET6_ADDRSTRLEN]；
char*arg；
arg=（char*）malloc（20*sizeof（char））；
结构ifaddrs*ifaddr，*ifa；
int家族，s1；
字符主机[NI_MAXHOST]；
memset（提示和提示，0，提示大小）；
hits.ai_family=AF_unsec；
hits.ai_socktype=SOCK_流；
if（（rv=getaddrinfo（“我的主机名”、端口、提示和服务信息））！=0）
{
fprintf（标准，“getaddrinfo:%s\n”，gai_strerror（rv））；
返回1；
}
for（p=servinfo；p！=NULL；p=p->ai_next）
{
如果（（sockfd=socket（p->ai_族，p->ai_socktype，
p->ai_协议）=-1）{
perror（“客户端：套接字”）；
继续；
} 
inet_ntop（p->ai_族，get_in_addr（（struct sockaddr*）p->ai_addr），
s、 尺寸（s）；
printf（“\n客户端：连接到%s\n”，s）；
如果（连接（sockfd，p->ai_addr，p->ai_addrlen）=-1）{
关闭（sockfd）；
perror（“\n客户端：连接”）；
继续；
}
打破
}
if（p==NULL）{
fprintf（stderr，“客户端：连接失败\n”）；
返回2；
}
inet_ntop（p->ai_族，get_in_addr（（struct sockaddr*）p->ai_addr），
s、 尺寸（s）；
printf（“客户端：连接到%s\n”，s）；
freeaddrinfo（servinfo）；
如果（（numbytes=recv（sockfd，buf，MAXDATASIZE-1，0））=-1）{
perror（“recv”）；
出口（1）；
}
buf[numbytes]='\0'；
printf（“客户端：收到“%s”\n”，buf）；
关闭（sockfd）；
返回0；
}

您正在使用本地链接

#include <unistd.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <signal.h>
#include <ifaddrs.h>

#define PORT "3490"  // the port users will be connecting to

void error(const char *msg)
{
    perror(msg);
    exit(1);
}
int gHostIP;
#define BACKLOG 10     // how many pending connections queue will hold

void sigchld_handler(int s)
{
   while(waitpid(-1, NULL, WNOHANG) > 0);
}

// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
  if (sa->sa_family == AF_INET) 
  {
    return &(((struct sockaddr_in*)sa)->sin_addr);
   }

   return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

int main()
{
   int sockfd, new_fd;  // listen on sock_fd, new connection on new_fd
   struct addrinfo hints, *servinfo, *p;
   struct sockaddr_storage their_addr; // connector's address information
   socklen_t sin_size;
   struct sigaction sa;
   int yes=1;
   char s[INET6_ADDRSTRLEN];
   int rv;
       char *arg;

       arg = (char*)malloc(20*sizeof(char));

       fprintf(stderr,"usage: showip hostname\n");

       memset(&hints, 0, sizeof(hints));
       hints.ai_family = AF_UNSPEC; // AF_INET or AF_INET6 to force version
       hints.ai_socktype = SOCK_STREAM;


       if ((rv = getaddrinfo("myhostname", PORT, &hints, &servinfo)) != 0) {
         fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
         return 1;
       }
       for(p = servinfo; p != NULL; p = p->ai_next) {
          if ((sockfd = socket(p->ai_family, p->ai_socktype,
                  p->ai_protocol)) == -1) {
              perror("server: socket");
            continue;
          }

          if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
                  sizeof(int)) == -1) {
              perror("setsockopt");
              exit(1);
          }
           /*if(p->ai_family == AF_INET6)
              strcat(p->ai_addr,"%eth3");*/
           if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
              close(sockfd);
              perror("server: bind");
              continue;
            }

          break;
       }

    if (p == NULL)  {
      fprintf(stderr, "server: failed to bind\n");
      return 2;
     }

     freeaddrinfo(servinfo); // all done with this structure

     if (listen(sockfd, BACKLOG) == -1) {
    perror("listen");
    exit(1);
     }

    sa.sa_handler = sigchld_handler; // reap all dead processes
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
      perror("sigaction");
      exit(1);
    }

    printf("server: waiting for connections...\n");

    while(1)
    {  // main accept() loop
      sin_size = sizeof their_addr;
      new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
      if (new_fd == -1) {
          perror("accept");
          continue;
      }

      inet_ntop(their_addr.ss_family,
          get_in_addr((struct sockaddr *)&their_addr),
          s, sizeof s);
      printf("server: got connection from %s\n", s);

      if (!fork()) { // this is the child process
          close(sockfd); // child doesn't need the listener
          if (send(new_fd, "Hello, world!", 13, 0) == -1)
            perror("send");
          close(new_fd);
          exit(0);
      }
      close(new_fd);  // parent doesn't need this
     }

     return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/resource.h>
#include <sched.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <signal.h>
#include <ifaddrs.h>

#define PORT "3490" // the port client will be connecting to

#define MAXDATASIZE 100 // max number of bytes we can get at once
int gHostIP;

// get sockaddr, IPv4 or IPv6:
void *get_in_addr(struct sockaddr *sa)
{
    if (sa->sa_family == AF_INET) {
        return &(((struct sockaddr_in*)sa)->sin_addr);
    }

    return &(((struct sockaddr_in6*)sa)->sin6_addr);
}



int main(int argc, char *argv[])
{
    int sockfd, numbytes;
    char buf[MAXDATASIZE];
    struct addrinfo hints, *servinfo, *p;
    int rv;
    char s[INET6_ADDRSTRLEN];
    char *arg;
    arg = (char*)malloc(20*sizeof(char));

    struct ifaddrs *ifaddr, *ifa;
    int family, s1;
    char host[NI_MAXHOST];


    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;


    if ((rv = getaddrinfo("myhostname", PORT, &hints, &servinfo)) != 0)
    {
      fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
      return 1;
    }


    for (p = servinfo; p != NULL; p = p->ai_next)
    {
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
            p->ai_protocol)) == -1) {
        perror("client: socket");
        continue;
        } 
        inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
               s, sizeof s);
         printf("\nclient: connecting to %s\n", s);
         if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
        close(sockfd);
        perror("\nclient: connect");
        continue;
         }

         break;
    }

    if (p == NULL) {
        fprintf(stderr, "client: failed to connect\n");
        return 2;
    }

    inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
        s, sizeof s);
    printf("client: connecting to %s\n", s);

    freeaddrinfo(servinfo);

    if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
            perror("recv");
            exit(1);
    }

    buf[numbytes] = '\0';

    printf("client: received '%s'\n",buf);

    close(sockfd);

    return 0;
}

ip -6 addr add 2001:db8:1::1/64 dev eth0

ip -6 addr add 2001:db8:1::2/64 dev eth0

for (p = res; p!= NULL; p = p->ai_next) {
    if (p->ai_family == AF_INET6 && (sock = socket(p->ai_family, p-
        ai_socktype, p->ai_protocol)) < 0
    ) {}
}