Remove the AI_ADDRCONFIG hint flag to getaddrinfo() when it's
[nfs-utils.git] / utils / nfsd / nfssvc.c
1 /*
2  * utils/nfsd/nfssvc.c
3  *
4  * Run an NFS daemon.
5  *
6  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7  */
8
9 #ifdef HAVE_CONFIG_H
10 #include <config.h>
11 #endif
12
13 #include <sys/types.h>
14 #include <sys/socket.h>
15 #include <netdb.h>
16 #include <netinet/in.h>
17 #include <arpa/inet.h>
18 #include <unistd.h>
19 #include <fcntl.h>
20 #include <errno.h>
21
22 #include "nfslib.h"
23 #include "xlog.h"
24
25 /*
26  * IPv6 support for nfsd was finished before some of the other daemons (mountd
27  * and statd in particular). That could be a problem in the future if someone
28  * were to boot a kernel that supports IPv6 serving with an older nfs-utils. For
29  * now, hardcode the IPv6 switch into the off position until the other daemons
30  * are functional.
31  */
32 #undef IPV6_SUPPORTED
33
34 #define NFSD_PORTS_FILE     "/proc/fs/nfsd/portlist"
35 #define NFSD_VERS_FILE    "/proc/fs/nfsd/versions"
36 #define NFSD_THREAD_FILE  "/proc/fs/nfsd/threads"
37
38 /*
39  * declaring a common static scratch buffer here keeps us from having to
40  * continually thrash the stack. The value of 128 bytes here is really just a
41  * SWAG and can be increased if necessary. It ought to be enough for the
42  * routines below however.
43  */
44 char buf[128];
45
46 /*
47  * Are there already sockets configured? If not, then it is safe to try to
48  * open some and pass them through.
49  *
50  * Note: If the user explicitly asked for 'udp', then we should probably check
51  * if that is open, and should open it if not. However we don't yet. All
52  * sockets have to be opened when the first daemon is started.
53  */
54 int
55 nfssvc_inuse(void)
56 {
57         int fd, n;
58
59         fd = open(NFSD_PORTS_FILE, O_RDONLY);
60
61         /* problem opening file, assume that nothing is configured */
62         if (fd < 0)
63                 return 0;
64
65         n = read(fd, buf, sizeof(buf));
66         close(fd);
67
68         xlog(D_GENERAL, "knfsd is currently %s", (n > 0) ? "up" : "down");
69
70         return (n > 0);
71 }
72
73 static int
74 nfssvc_setfds(const struct addrinfo *hints, const char *node, const char *port)
75 {
76         int fd, on = 1, fac = L_ERROR;
77         int sockfd = -1, rc = 0;
78         struct addrinfo *addrhead = NULL, *addr;
79         char *proto, *family;
80
81         /*
82          * if file can't be opened, then assume that it's not available and
83          * that the caller should just fall back to the old nfsctl interface
84          */
85         fd = open(NFSD_PORTS_FILE, O_WRONLY);
86         if (fd < 0)
87                 return 0;
88
89         switch(hints->ai_family) {
90         case AF_INET:
91                 family = "inet";
92                 break;
93 #ifdef IPV6_SUPPORTED
94         case AF_INET6:
95                 family = "inet6";
96                 break;
97 #endif /* IPV6_SUPPORTED */
98         default:
99                 xlog(L_ERROR, "Unknown address family specified: %d\n",
100                                 hints->ai_family);
101                 rc = EAFNOSUPPORT;
102                 goto error;
103         }
104
105         rc = getaddrinfo(node, port, hints, &addrhead);
106         if (rc == EAI_NONAME && !strcmp(port, "nfs")) {
107                 snprintf(buf, sizeof(buf), "%d", NFS_PORT);
108                 rc = getaddrinfo(node, buf, hints, &addrhead);
109         }
110
111         if (rc != 0) {
112                 xlog(L_ERROR, "unable to resolve %s:%s to %s address: "
113                                 "%s", node ? node : "ANYADDR", port, family,
114                                 rc == EAI_SYSTEM ? strerror(errno) :
115                                         gai_strerror(rc));
116                 goto error;
117         }
118
119         addr = addrhead;
120         while(addr) {
121                 /* skip non-TCP / non-UDP sockets */
122                 switch(addr->ai_protocol) {
123                 case IPPROTO_UDP:
124                         proto = "UDP";
125                         break;
126                 case IPPROTO_TCP:
127                         proto = "TCP";
128                         break;
129                 default:
130                         addr = addr->ai_next;
131                         continue;
132                 }
133
134                 xlog(D_GENERAL, "Creating %s %s socket.", family, proto);
135
136                 /* open socket and prepare to hand it off to kernel */
137                 sockfd = socket(addr->ai_family, addr->ai_socktype,
138                                 addr->ai_protocol);
139                 if (sockfd < 0) {
140                         xlog(L_ERROR, "unable to create %s %s socket: "
141                                 "errno %d (%m)", family, proto, errno);
142                         rc = errno;
143                         goto error;
144                 }
145 #ifdef IPV6_SUPPORTED
146                 if (addr->ai_family == AF_INET6 &&
147                     setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on))) {
148                         xlog(L_ERROR, "unable to set IPV6_V6ONLY: "
149                                 "errno %d (%m)\n", errno);
150                         rc = errno;
151                         goto error;
152                 }
153 #endif /* IPV6_SUPPORTED */
154                 if (addr->ai_protocol == IPPROTO_TCP &&
155                     setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))) {
156                         xlog(L_ERROR, "unable to set SO_REUSEADDR on %s "
157                                 "socket: errno %d (%m)", family, errno);
158                         rc = errno;
159                         goto error;
160                 }
161                 if (bind(sockfd, addr->ai_addr, addr->ai_addrlen)) {
162                         xlog(L_ERROR, "unable to bind %s %s socket: "
163                                 "errno %d (%m)", family, proto, errno);
164                         rc = errno;
165                         goto error;
166                 }
167                 if (addr->ai_protocol == IPPROTO_TCP && listen(sockfd, 64)) {
168                         xlog(L_ERROR, "unable to create listening socket: "
169                                 "errno %d (%m)", errno);
170                         rc = errno;
171                         goto error;
172                 }
173
174                 if (fd < 0)
175                         fd = open(NFSD_PORTS_FILE, O_WRONLY);
176
177                 if (fd < 0) {
178                         xlog(L_ERROR, "couldn't open ports file: errno "
179                                       "%d (%m)", errno);
180                         goto error;
181                 }
182
183                 snprintf(buf, sizeof(buf), "%d\n", sockfd); 
184                 if (write(fd, buf, strlen(buf)) != strlen(buf)) {
185                         /*
186                          * this error may be common on older kernels that don't
187                          * support IPv6, so turn into a debug message.
188                          */
189                         if (errno == EAFNOSUPPORT)
190                                 fac = D_ALL;
191                         xlog(fac, "writing fd to kernel failed: errno %d (%m)",
192                                   errno);
193                         rc = errno;
194                         goto error;
195                 }
196                 close(fd);
197                 close(sockfd);
198                 sockfd = fd = -1;
199                 addr = addr->ai_next;
200         }
201 error:
202         if (fd >= 0)
203                 close(fd);
204         if (sockfd >= 0)
205                 close(sockfd);
206         if (addrhead)
207                 freeaddrinfo(addrhead);
208         return rc;
209 }
210
211 int
212 nfssvc_set_sockets(const int family, const unsigned int protobits,
213                    const char *host, const char *port)
214 {
215         struct addrinfo hints = { .ai_flags = AI_PASSIVE };
216
217         hints.ai_family = family;
218
219         if (!NFSCTL_ANYPROTO(protobits))
220                 return EPROTOTYPE;
221         else if (!NFSCTL_UDPISSET(protobits))
222                 hints.ai_protocol = IPPROTO_TCP;
223         else if (!NFSCTL_TCPISSET(protobits))
224                 hints.ai_protocol = IPPROTO_UDP;
225
226         return nfssvc_setfds(&hints, host, port);
227 }
228
229 void
230 nfssvc_setvers(unsigned int ctlbits, int minorvers4)
231 {
232         int fd, n, off;
233         char *ptr;
234
235         ptr = buf;
236         off = 0;
237         fd = open(NFSD_VERS_FILE, O_WRONLY);
238         if (fd < 0)
239                 return;
240
241         for (n = NFSD_MINVERS; n <= NFSD_MAXVERS; n++) {
242                 if (NFSCTL_VERISSET(ctlbits, n))
243                     off += snprintf(ptr+off, sizeof(buf) - off, "+%d ", n);
244                 else
245                     off += snprintf(ptr+off, sizeof(buf) - off, "-%d ", n);
246         }
247         n = minorvers4 >= 0 ? minorvers4 : -minorvers4;
248         if (n >= NFSD_MINMINORVERS4 && n <= NFSD_MAXMINORVERS4)
249                     off += snprintf(ptr+off, sizeof(buf) - off, "%c4.%d",
250                                     minorvers4 > 0 ? '+' : '-',
251                                     n);
252         xlog(D_GENERAL, "Writing version string to kernel: %s", buf);
253         snprintf(ptr+off, sizeof(buf) - off, "\n");
254         if (write(fd, buf, strlen(buf)) != strlen(buf))
255                 xlog(L_ERROR, "Setting version failed: errno %d (%m)", errno);
256
257         close(fd);
258
259         return;
260 }
261
262 int
263 nfssvc_threads(unsigned short port, const int nrservs)
264 {
265         struct nfsctl_arg       arg;
266         struct servent *ent;
267         ssize_t n;
268         int fd;
269
270         fd = open(NFSD_THREAD_FILE, O_WRONLY);
271         if (fd < 0)
272                 fd = open("/proc/fs/nfs/threads", O_WRONLY);
273         if (fd >= 0) {
274                 /* 2.5+ kernel with nfsd filesystem mounted.
275                  * Just write the number of threads.
276                  */
277                 snprintf(buf, sizeof(buf), "%d\n", nrservs);
278                 n = write(fd, buf, strlen(buf));
279                 close(fd);
280                 if (n != strlen(buf))
281                         return -1;
282                 else
283                         return 0;
284         }
285
286         if (!port) {
287                 ent = getservbyname("nfs", "udp");
288                 if (ent != NULL)
289                         port = ntohs(ent->s_port);
290                 else
291                         port = NFS_PORT;
292         }
293
294         arg.ca_version = NFSCTL_VERSION;
295         arg.ca_svc.svc_nthreads = nrservs;
296         arg.ca_svc.svc_port = port;
297         return nfsctl(NFSCTL_SVC, &arg, NULL);
298 }