（已解决，9楼是我的一些心得）如何添加自己的服务

wawxdyy

有这样一个C/S程序，server提供一个叫做ruptime的服务，功能是当有客户端连接时调用uptime程序，并将结果发送到client。可是现在的问题是，这个服务系统本来是没有的，所以调用getaddrinfo的时候会返回如下错误：

1. Servname not supported for ai_socktype

复制代码

我觉得可能是需要编辑/etc/service文件把自己这个服务加进去，可是我加了之后没管用(设的端口是4000)，开机的时候提示启动服务失败，所以我的问题就是如何开启我这个服务器程序提供的服务，谢谢。

PS：不知道这个帖子发到这个版合不合适，不合适的话麻烦版主帮忙转一下，不过代码是没有问题的。

roamingo

自己选一个端口号4000，直接bind, listen不行？服务不服务只是一个花头。

wawxdyy

早啊，兄弟，你说的方法当然可以，但关键是我想搞明白怎样以服务的形式运行这段代码，怎样做才能让getaddrinfo执行正确。下面这段是服务器代码：

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include <errno.h>
   
6. #include <unistd.h>
   
7. #include <syslog.h>
   
8. #include <netdb.h>
   
9. #include <sys/socket.h>
   
10. 
    
11. #ifndef        HOST_NAME_MAX
    
12. #define        HOST_NAME_MAX        64
    
13. #endif
    
14. 
    
15. #define        BUFLEN                128
    
16. #define        QLEN                10
    
17. 
    
18. extern int initserver(int, const struct sockaddr *, socklen_t, int);
    
19. extern void daemonize(const char *);
    
20. 
    
21. void
    
22. serve(int sockfd)
    
23. {
    
24.         int        clfd;
    
25.         pid_t        pid;
    
26.        
    
27.         for (;;) {
    
28.                 if ((clfd = accept(sockfd, NULL, NULL)) < 0) {
    
29.                         syslog(LOG_ERR, "accept error: %m\n");
    
30.                         exit(-1);
    
31.                 }
    
32.                 if ((pid = fork()) < 0) {
    
33.                         syslog(LOG_ERR, "fork error: %m\n");
    
34.                         exit(-1);
    
35.                 } else if (pid == 0) {
    
36.                         if ((dup2(clfd, STDOUT_FILENO) != STDOUT_FILENO) ||
    
37.                             (dup2(clfd, STDERR_FILENO) != STDERR_FILENO)) {
    
38.                                 syslog(LOG_ERR, "dup2 error: %m\n");
    
39.                                 exit(-1);
    
40.                         }
    
41.                         close(clfd);
    
42.                         execl("/usr/bin/uptime", "uptime", (char *)0);
    
43.                 } else {
    
44.                         close(clfd);
    
45.                         waitpid(pid, NULL, 0);
    
46.                 }
    
47.         }
    
48. }
    
49. 
    
50. int
    
51. main(void)
    
52. {
    
53.         struct addrinfo                *ailist, *aip;
    
54.         struct addrinfo                hint;
    
55.         int                        sockfd;
    
56.         int                        err, n;
    
57.         char                        *host;
    
58.        
    
59. #ifdef _SC_HOST_NAME_MAX
    
60.         n = sysconf(_SC_HOST_NAME_MAX);
    
61.         if (n < 0)
    
62. #endif
    
63.                 n = HOST_NAME_MAX;
    
64.        
    
65.         if ((host = malloc(n)) == NULL) {
    
66.                 printf("malloc error: %s\n", strerror(errno));
    
67.                 exit(-1);
    
68.         }
    
69.         if (gethostname(host, n) < 0) {
    
70.                 printf("gethostname error: %s\n", strerror(errno));
    
71.                 exit(-1);
    
72.         }
    
73.         daemonize("ruptimed");
    
74.        
    
75.         hint.ai_flags = AI_CANONNAME;
    
76.         hint.ai_family = 0;
    
77.         hint.ai_socktype = SOCK_STREAM;
    
78.         hint.ai_protocol = 0;
    
79.         hint.ai_addrlen = 0;
    
80.         hint.ai_addr = NULL;
    
81.         hint.ai_canonname = NULL;
    
82.         hint.ai_next = NULL;
    
83.         if ((err = getaddrinfo(host, "ruptimed", &hint, &ailist)) != 0) {
    
84.                 syslog(LOG_ERR, "getaddrinfo error: %s", gai_strerror(err));
    
85.                 exit(-1);
    
86.         }
    
87.         for (aip = ailist; aip != NULL; aip = aip->ai_next) {
    
88.                 if ((sockfd = initserver(aip->ai_socktype, aip->ai_addr,
    
89.                      aip->ai_addrlen, QLEN)) >= 0) {
    
90.                         serve(sockfd);
    
91.                         exit(0);
    
92.                 }
    
93.         }
    
94.         exit(-1);
    
95. }
    

复制代码

roamingo

应该就是/etc/services
有没有试试这个老一点的函数：getservbyname()

wawxdyy

但是我不关心端口啊，用系统默认分配的就行，关键是getaddrinfo出错，得不到主机地址

wawxdyy

顶一下，请帮忙

roamingo

兄弟，我这里可以啊。

2.         // daemonize("ruptimed");
3.         
4.         hint.ai_flags = AI_CANONNAME;
5.         hint.ai_family = 0;
6.         hint.ai_socktype = SOCK_STREAM;
7.         hint.ai_protocol = 0;
8.         hint.ai_addrlen = 0;
9.         hint.ai_addr = NULL;
10.         hint.ai_canonname = NULL;
11.         hint.ai_next = NULL;
12.         if ((err = getaddrinfo(host, "ruptimed", &hint, &ailist)) != 0) {
13.                 printf("getaddrinfo error: %s\n", gai_strerror(err));
14.                 exit(-1);
15.         }
16. /*      for (aip = ailist; aip != NULL; aip = aip->ai_next) {
17.                 if ((sockfd = initserver(aip->ai_socktype, aip->ai_addr,
18.                      aip->ai_addrlen, QLEN)) >= 0) {
19.                         serve(sockfd);
20.                         exit(0);
21.                 }
22.         }
23.         */
24.         printf("OK\n");

复制代码

bumpy:~/tmp$ gcc a.c
bumpy:~/tmp$ ./a.out    <==== 没有改/etc/services 前
getaddrinfo error: Servname not supported for ai_socktype
bumpy:~/tmp$ vi a.c
bumpy:~/tmp$ sudo vi /etc/services  <==== 添加ruptimed   4000/tcp到合适的位置（你的服务里没有别的是4000吧）
bumpy:~/tmp$ ./a.out
OK

wawxdyy

谢谢关注啊，问题解决了，一开始不行是因为上面那个代码里有个笔误，就是pid == 0那个判断条件，我一开始写成fork，汗

wawxdyy

真是惭愧啊，本来是问问题的，竟然加精了，其实功劳多半是算roamingo兄弟的，我本来想在程序版再发一篇关于如何使用getsockaddr这个函数的，不过既然这样，我就在这里写吧，如果版主觉得不合适，也可以转到程序版，下面的代码是基于apue第十六章并自己加以修改，以前我以前都是在windows下开发的网络程序，而且中间隔了很长时间，而linux下的c编程又刚接触不久，所以有什么地方理解不到位，希望兄弟们指正。

getsockaddr这个函数的功能是将主机名映射成主机的地址，是个新的接口，以取代以前的gethostbyname这个函数，因为后者不能处理ipv6的地址，并且以被标记为废弃，关于参数的细节有兴趣的朋友可以查帮助，我这里主要说一下应该注意的问题，在使用中，最重要的是hint.ai_flags这个参数的设定问题，服务器端和客户端都分成两种情况，先说服务器端：

1，服务器端以服务的形式提供给用户，相关的代码在3楼，下面的代码是用到的库函数

1. 
   
2. #include <sys/socket.h>
   
3. #include <sys/resource.h>
   
4. #include <sys/stat.h>
   
5. #include <errno.h>
   
6. #include <unistd.h>
   
7. #include <stdio.h>
   
8. #include <stdlib.h>
   
9. #include <string.h>
   
10. #include <signal.h>
    
11. #include <fcntl.h>
    
12. #include <syslog.h>
    
13. 
    
14. #define MAXSLEEP        128
    
15. 
    
16. int
    
17. connect_retry(int sockfd, const struct sockaddr *addr, socklen_t alen)
    
18. {
    
19.         int        nsec;
    
20.        
    
21.         for (nsec = 1; nsec <= MAXSLEEP; nsec <<= 1) {
    
22.                 if (connect(sockfd, addr, alen) == 0)
    
23.                         return(0);
    
24.                 if (nsec <= MAXSLEEP/2)
    
25.                         sleep(nsec);
    
26.         }
    
27.         return(-1);
    
28. }
    
29. 
    
30. int
    
31. initserver(int type, const struct sockaddr *addr, socklen_t alen, int qlen)
    
32. {
    
33.         int        fd;
    
34.         int        err = 0;
    
35.         int        reuse = 1;
    
36.        
    
37.         if ((fd = socket(addr->sa_family, type, 0)) < 0)
    
38.                     return(-1);
    
39.         if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int)) < 0) {
    
40.                 err = errno;
    
41.                 goto errout;
    
42.         }
    
43.         if (bind(fd, addr, alen) < 0) {
    
44.                 err = errno;
    
45.                 goto errout;
    
46.         }
    
47.         if ((type == SOCK_STREAM) || (type == SOCK_SEQPACKET)) {
    
48.                 if (listen(fd, qlen) < 0) {
    
49.                         err = errno;
    
50.                         goto errout;
    
51.                 }
    
52.         }
    
53.         return(fd);
    
54. errout:
    
55.         close(fd);
    
56.         errno = err;
    
57.         return(-1);
    
58. }
    
59. 
    
60. void
    
61. daemonize(const char *cmd)
    
62. {
    
63.         int                        i, fd0, fd1, fd2;
    
64.         pid_t                        pid;
    
65.         struct rlimit                rl;
    
66.         struct sigaction        sa;
    
67.        
    
68.         umask(0);
    
69.        
    
70.         if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
    
71.                 printf("getrlimit failed");
    
72.                 exit(1);
    
73.         }
    
74.        
    
75.         if ((pid = fork()) < 0) {
    
76.                 printf("first fork failed");
    
77.                 exit(1);
    
78.         } else if (pid > 0) {
    
79.                 exit(0);
    
80.         }
    
81.        
    
82.         setsid();
    
83.        
    
84.         sa.sa_handler = SIG_IGN;
    
85.         sigemptyset(&sa.sa_mask);
    
86.         sa.sa_flags = 0;
    
87.         if (sigaction(SIGHUP, &sa, NULL) < 0) {
    
88.                 printf("sigaction failed");
    
89.                 exit(1);
    
90.         }
    
91.         if ((pid = fork()) < 0) {
    
92.                 printf("second fork failed");
    
93.                 exit(1);
    
94.         } else if (pid > 0) {
    
95.                 exit(0);
    
96.         }
    
97.        
    
98.         if (chdir("/") < 0) {
    
99.                 printf("chdir failed");
    
100.                 exit(1);
     
101.         }
     
102.        
     
103.         if (rl.rlim_max == RLIM_INFINITY)
     
104.                 rl.rlim_max = 1024;
     
105.         for (i = 0; i < rl.rlim_max; i++)
     
106.                 close(i);
     
107.                
     
108.         fd0 = open("/dev/null", O_RDWR);
     
109.         fd1 = dup(0);
     
110.         fd2 = dup(0);
     
111.        
     
112.         openlog(cmd, LOG_CONS, LOG_DAEMON);
     
113.         if (fd0 != 0 || fd1 != 1 || fd2 != 2) {
     
114.                 syslog(LOG_ERR, "unexpected file descriptor %d %d %d", fd0, fd1, fd2);
     
115.                 exit(1);
     
116.         }
     
117. }
     

复制代码

首先说说什么是服务，端口号大家都知道，比如smtp这个就是服务，而它使用的端口号是25，但是系统怎么知道它需要使用端口25呢，就是通过在/etc/services这个文件里进行登记，打开它你会发现里面登记了几乎所有的像ftp,dns这样的公开的服务，同样的道理，如果我们要使用自己的服务，也需要在里面登记，但要注意端口号不能小于1024，并且不能和已登记的重复，还有一点是关于服务名，这个名字没有必要和程序名一样，比如上面的代码，程序名是ruptimed,而服务名是ruptime,只要你认为能代表程序的功能就行。现在大家应该知道了什么是服务了，就是程序的代号。现在再回到getaddrinfo这个函数，当我将第二个参数设为服务名（ruptime）时，返回的结果里的端口号就是在/etc/services里登记的端口号，有人会说了，那第一个参数呢？是这样的，大家可以打开/etc/hosts这个文件，在开头有几行主机名和地址的列表，下面是我的hosts文件的内容：

1. 
   
2. 127.0.0.1 localhost
   
3. 192.168.1.104 wawxdyy
   
4. 
   
5. # The following lines are desirable for IPv6 capable hosts
   
6. ::1     ip6-localhost ip6-loopback
   
7. fe00::0 ip6-localnet
   
8. ff00::0 ip6-mcastprefix
   
9. ff02::1 ip6-allnodes
   
10. ff02::2 ip6-allrouters
    
11. ff02::3 ip6-allhosts
    

复制代码

如果我将第一个参数设为localhost，那么返回的地址就是127.0.0.1，如果设为wawxdyy，返回的就是192.168.1.104。
如果要想以服务的形式运行服务器程序，这两个参数一定要明确指定，并且主机名不能是localhost，只有这样返回的结果才是有效的，才能用于后面的绑定。
2 服务器程序用端口号的形式发布：这种情况下就没有必要在/etc/services里登记了，但是hint结构的ai_flags的参数设定有注意的地方，在上面的那种情况，因为主机名和服务名都明确提供了，所以即使ai_flags设为0也能返回正确的结果，但是现在我们将第二个参数设为端口号，这样的话，我们必须将hint结构的ai_flags设为AI_PASSIVE，这样返回的结果才能用于后面的监听绑定，否则不能，因为AI_PASSIVE就是告诉getaddrinfo返回的地址是用于监听绑定的。下面是相关的代码：

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include <errno.h>
   
6. #include <unistd.h>
   
7. #include <syslog.h>
   
8. #include <netdb.h>
   
9. #include <sys/socket.h>
   
10. #include <netinet/in.h>
    
11. #include <arpa/inet.h>
    
12. #include <sys/wait.h>
    
13. #include <fcntl.h>
    
14. 
    
15. #ifndef        HOST_NAME_MAX
    
16. #define        HOST_NAME_MAX        64
    
17. #endif
    
18. 
    
19. #define        BUFLEN                128
    
20. #define        QLEN                10
    
21. 
    
22. extern int initserver(int, const struct sockaddr *, socklen_t, int);
    
23. extern void daemonize(const char *);
    
24. 
    
25. void
    
26. serve(int sockfd)
    
27. {
    
28.         int        clfd, status;
    
29.         pid_t        pid;
    
30.        
    
31.         for (;;) {
    
32.                 if ((clfd = accept(sockfd, NULL, NULL)) < 0) {
    
33.                         syslog(LOG_ERR, "accept error: %m\n");
    
34.                         exit(-1);
    
35.                 }
    
36.                
    
37.                 if ((pid = fork()) < 0) {
    
38.                         syslog(LOG_ERR, "fork error: %m\n");
    
39.                         exit(-1);
    
40.                 } else if (pid == 0) {
    
41.                         if (dup2(clfd, STDOUT_FILENO) != STDOUT_FILENO ||
    
42.                             dup2(clfd, STDERR_FILENO) != STDERR_FILENO) {
    
43.                                 syslog(LOG_ERR, "dup2 error: %m\n");
    
44.                                 exit(-1);
    
45.                         }
    
46.                         close(clfd);
    
47.                         execl("/usr/bin/uptime", "uptime", (char *)0);
    
48.                         syslog(LOG_ERR, "unexpected return from execl: %m");
    
49.                 } else {
    
50.                         close(clfd);
    
51.                         waitpid(pid, &status, 0);
    
52.                 }
    
53.         }
    
54. }
    
55. 
    
56. int
    
57. main(void)
    
58. {
    
59.         struct addrinfo                *ailist, *aip;
    
60.         struct addrinfo                hint;
    
61.         struct sockaddr_in        *sinp;
    
62.         int                        sockfd;
    
63.         int                        err, n;
    
64.         char                        *host;
    
65.         char                        buf[INET_ADDRSTRLEN];
    
66.        
    
67. #ifdef _SC_HOST_NAME_MAX
    
68.         n = sysconf(_SC_HOST_NAME_MAX);
    
69.         if (n < 0)
    
70. #endif
    
71.                 n = HOST_NAME_MAX;
    
72.        
    
73.         if ((host = malloc(n)) == NULL) {
    
74.                 printf("malloc error: %s\n", strerror(errno));
    
75.                 exit(-1);
    
76.         }
    
77.         if (gethostname(host, n) < 0) {
    
78.                 printf("gethostname error: %s\n", strerror(errno));
    
79.                 exit(-1);
    
80.         }
    
81.         syslog(LOG_ERR, "hostname is %s", host);
    
82.         daemonize("ruptimed");
    
83.        
    
84.         hint.ai_flags = AI_PASSIVE;
    
85.         hint.ai_family = 0;
    
86.         hint.ai_socktype = SOCK_STREAM;
    
87.         hint.ai_protocol = 0;
    
88.         hint.ai_addrlen = 0;
    
89.         hint.ai_addr = NULL;
    
90.         hint.ai_canonname = NULL;
    
91.         hint.ai_next = NULL;
    
92.         if ((err = getaddrinfo(NULL, "2000", &hint, &ailist)) != 0) {
    
93.                 syslog(LOG_ERR, "getaddrinfo error: %s", gai_strerror(err));
    
94.                 exit(-1);
    
95.         }
    
96.         for (aip = ailist; aip != NULL; aip = aip->ai_next) {
    
97.                 sinp = (struct sockaddr_in *)aip->ai_addr;
    
98.                 short port = ntohs(sinp->sin_port);
    
99.                 syslog(LOG_ERR, "port is %d\n", port);
    
100.                 if (inet_ntop(aip->ai_family, &sinp->sin_addr, buf, INET_ADDRSTRLEN) != NULL)
     
101.                         syslog(LOG_ERR, "addr is %s\n", buf);
     
102.                 if ((sockfd = initserver(aip->ai_socktype, aip->ai_addr,
     
103.                      aip->ai_addrlen, QLEN)) >= 0) {
     
104.                         serve(sockfd);
     
105.                         exit(0);
     
106.                 }
     
107.         }
     
108.         exit(-1);
     
109. }
     

复制代码

再来说说客户端：相似地也有两种情况：
1 以服务的方式连接服务器：如果用户只知道服务器提供的服务，而不知道其端口号，就用这种方式，并且我们也需要在/etc/services里登记，否则也会出现“Servname not supported for ai_socktype”这样的错误，但是端口号不必于服务器端一样,下面是代码：

1. 
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <errno.h>
   
7. #include <netdb.h>
   
8. #include <sys/socket.h>
   
9. #include <arpa/inet.h>
   
10. #include <netinet/in.h>
    
11. 
    
12. #define BUFLEN                128
    
13. 
    
14. extern connect_retry(int sockfd, const struct sockaddr *addr, socklen_t alen);
    
15. 
    
16. int
    
17. print_uptime(int sockfd)
    
18. {
    
19.         int        n;
    
20.         char        buf[BUFLEN];
    
21.        
    
22.         while ((n= recv(sockfd, buf, BUFLEN, 0)) > 0) {
    
23.                 if (write(STDOUT_FILENO, buf, n) != n)
    
24.                         return(-1);
    
25.         }
    
26.         if (n < 0)
    
27.                 return(-1);
    
28.         if (n == 0)
    
29.                 printf("nothing received\n");
    
30.         return(0);
    
31. }
    
32. 
    
33. int
    
34. main(int argc, char *argv[])
    
35. {
    
36.         struct addrinfo                *ailist, *aip;
    
37.         struct addrinfo                hint;
    
38.         struct sockaddr_in        *sinp;
    
39.         int                        sockfd;
    
40.         int                        err;
    
41.         char                        seraddr[INET_ADDRSTRLEN];
    
42.         short                        serport;
    
43.        
    
44.         if (argc != 2) {
    
45.                 printf("usage: %s <hostname>\n", argv[0]);
    
46.                 exit(-1);
    
47.         }
    
48.        
    
49.         hint.ai_family = 0;
    
50.         hint.ai_socktype = SOCK_STREAM;
    
51.         hint.ai_flags = AI_CANONNAME;
    
52.         hint.ai_protocol = 0;
    
53.         hint.ai_addrlen = 0;
    
54.         hint.ai_addr = NULL;
    
55.         hint.ai_canonname = NULL;
    
56.         hint.ai_next = NULL;
    
57.         if ((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0) {
    
58.                 printf("getaddrinfo error: %s\n", gai_strerror(err));
    
59.                 exit(-1);
    
60.         }
    
61.         printf("getaddrinfo ok\n");
    
62.         for (aip = ailist; aip != NULL; aip = aip->ai_next) {
    
63.                
    
64.                 sinp = (struct sockaddr_in *)aip->ai_addr;
    
65.                 if (inet_ntop(sinp->sin_family, &sinp->sin_addr, seraddr, INET_ADDRSTRLEN) != NULL)
    
66.                 {
    
67.                         printf("server address is %s\n", seraddr);
    
68.                 }
    
69.                 serport = ntohs(sinp->sin_port);
    
70.                 printf("server port is %d\n", serport);
    
71.                
    
72.                 if ((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0) {
    
73.                         printf("create socket failed: %s\n", strerror(errno));
    
74.                         exit(-1);
    
75.                 }printf("create socket ok\n");
    
76.                 if (connect_retry(sockfd, aip->ai_addr, aip->ai_addrlen) < 0) {
    
77.                         printf("can't connect to %s: %s\n", argv[1], strerror(errno));
    
78.                         exit(-1);
    
79.                 } else {
    
80.                         printf("connect ok\n");
    
81.                         if (print_uptime(sockfd) < 0) {
    
82.                                 printf("print_uptime error: %s\n", strerror(errno));
    
83.                                 exit(-1);
    
84.                         }
    
85.                 }
    
86.         }
    
87.         exit(0);
    
88. }
    

复制代码

2 以端口号的方式连接服务器：这个就有一点需要注意，hint的ai_flags不要设为AI_PASSIVE，因为返回的地址不是用来监听绑定的，一般设为AI_CANONNAME，代码就不贴了，照这上面的改改就可以了。

我自认为不太会写东西，并且由于种种原因，已经24小时没睡了，脑袋有点晕，再加上水平有限，所以有错误的地方兄弟们请指出来，另外有看不太明白的地方就跟帖，最后谢谢版主给我这个精，大家互相学习。

mascot

我毫不犹豫地收藏了