2a3f5cca4ae736a41075b1ad0d1a597d3a823235
[nfs-utils.git] / utils / nfsd / nfsd.c
1 /*
2  * nfsd
3  *
4  * This is the user level part of nfsd. This is very primitive, because
5  * all the work is now done in the kernel module.
6  *
7  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
8  */
9
10 #ifdef HAVE_CONFIG_H
11 #include <config.h>
12 #endif
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <unistd.h>
17 #include <fcntl.h>
18 #include <string.h>
19 #include <errno.h>
20 #include <getopt.h>
21 #include <netdb.h>
22 #include <sys/socket.h>
23 #include <netinet/in.h>
24 #include <arpa/inet.h>
25
26 #include "nfslib.h"
27 #include "nfssvc.h"
28 #include "xlog.h"
29
30 #ifndef NFSD_NPROC
31 #define NFSD_NPROC 8
32 #endif
33
34 static void     usage(const char *);
35
36 static struct option longopts[] =
37 {
38         { "host", 1, 0, 'H' },
39         { "help", 0, 0, 'h' },
40         { "no-nfs-version", 1, 0, 'N' },
41         { "no-tcp", 0, 0, 'T' },
42         { "no-udp", 0, 0, 'U' },
43         { "port", 1, 0, 'P' },
44         { "port", 1, 0, 'p' },
45         { "debug", 0, 0, 'd' },
46         { "syslog", 0, 0, 's' },
47         { NULL, 0, 0, 0 }
48 };
49
50 /* given a family and ctlbits, disable any that aren't listed in netconfig */
51 #ifdef HAVE_LIBTIRPC
52 static void
53 nfsd_enable_protos(unsigned int *proto4, unsigned int *proto6)
54 {
55         struct netconfig *nconf;
56         unsigned int *famproto;
57         void *handle;
58
59         xlog(D_GENERAL, "Checking netconfig for visible protocols.");
60
61         handle = setnetconfig();
62         while((nconf = getnetconfig(handle))) {
63                 if (!(nconf->nc_flag & NC_VISIBLE))
64                         continue;
65
66                 if (!strcmp(nconf->nc_protofmly, NC_INET))
67                         famproto = proto4;
68                 else if (!strcmp(nconf->nc_protofmly, NC_INET6))
69                         famproto = proto6;
70                 else
71                         continue;
72
73                 if (!strcmp(nconf->nc_proto, NC_TCP))
74                         NFSCTL_TCPSET(*famproto);
75                 else if (!strcmp(nconf->nc_proto, NC_UDP))
76                         NFSCTL_UDPSET(*famproto);
77
78                 xlog(D_GENERAL, "Enabling %s %s.", nconf->nc_protofmly,
79                         nconf->nc_proto);
80         }
81         endnetconfig(handle);
82         return;
83 }
84 #else /* HAVE_LIBTIRPC */
85 static void
86 nfsd_enable_protos(unsigned int *proto4, unsigned int *proto6)
87 {
88         /* Enable all IPv4 protocols if no TIRPC support */
89         *proto4 = NFSCTL_ALLBITS;
90         *proto6 = 0;
91 }
92 #endif /* HAVE_LIBTIRPC */
93
94 int
95 main(int argc, char **argv)
96 {
97         int     count = NFSD_NPROC, c, error = 0, portnum = 0, fd, found_one;
98         char *p, *progname, *port;
99         char *haddr = NULL;
100         int     socket_up = 0;
101         int minorvers41 = 0;    /* nfsv4 minor version */
102         unsigned int versbits = NFSCTL_ALLBITS;
103         unsigned int protobits = NFSCTL_ALLBITS;
104         unsigned int proto4 = 0;
105         unsigned int proto6 = 0;
106
107         progname = strdup(basename(argv[0]));
108         if (!progname) {
109                 fprintf(stderr, "%s: unable to allocate memory.\n", argv[0]);
110                 exit(1);
111         }
112
113         port = strdup("nfs");
114         if (!port) {
115                 fprintf(stderr, "%s: unable to allocate memory.\n", progname);
116                 exit(1);
117         }
118
119         xlog_syslog(0);
120         xlog_stderr(1);
121
122         while ((c = getopt_long(argc, argv, "dH:hN:p:P:sTU", longopts, NULL)) != EOF) {
123                 switch(c) {
124                 case 'd':
125                         xlog_config(D_ALL, 1);
126                         break;
127                 case 'H':
128                         /*
129                          * for now, this only handles one -H option. Use the
130                          * last one specified.
131                          */
132                         free(haddr);
133                         haddr = strdup(optarg);
134                         if (!haddr) {
135                                 fprintf(stderr, "%s: unable to allocate "
136                                         "memory.\n", progname);
137                                 exit(1);
138                         }
139                         break;
140                 case 'P':       /* XXX for nfs-server compatibility */
141                 case 'p':
142                         /* only the last -p option has any effect */
143                         portnum = atoi(optarg);
144                         if (portnum <= 0 || portnum > 65535) {
145                                 fprintf(stderr, "%s: bad port number: %s\n",
146                                         progname, optarg);
147                                 usage(progname);
148                         }
149                         free(port);
150                         port = strdup(optarg);
151                         if (!port) {
152                                 fprintf(stderr, "%s: unable to allocate "
153                                                 "memory.\n", progname);
154                                 exit(1);
155                         }
156                         break;
157                 case 'N':
158                         switch((c = strtol(optarg, &p, 0))) {
159                         case 4:
160                                 if (*p == '.') {
161                                         int i = atoi(p+1);
162                                         if (i != 1) {
163                                                 fprintf(stderr, "%s: unsupported minor version\n", optarg);
164                                                 exit(1);
165                                         }
166                                         minorvers41 = -1;
167                                         break;
168                                 }
169                         case 3:
170                         case 2:
171                                 NFSCTL_VERUNSET(versbits, c);
172                                 break;
173                         default:
174                                 fprintf(stderr, "%s: Unsupported version\n", optarg);
175                                 exit(1);
176                         }
177                         break;
178                 case 's':
179                         xlog_syslog(1);
180                         xlog_stderr(0);
181                         break;
182                 case 'T':
183                         NFSCTL_TCPUNSET(protobits);
184                         break;
185                 case 'U':
186                         NFSCTL_UDPUNSET(protobits);
187                         break;
188                 default:
189                         fprintf(stderr, "Invalid argument: '%c'\n", c);
190                 case 'h':
191                         usage(progname);
192                 }
193         }
194
195         if (optind < argc) {
196                 if ((count = atoi(argv[optind])) < 0) {
197                         /* insane # of servers */
198                         fprintf(stderr,
199                                 "%s: invalid server count (%d), using 1\n",
200                                 argv[0], count);
201                         count = 1;
202                 } else if (count == 0) {
203                         /*
204                          * don't bother setting anything else if the threads
205                          * are coming down anyway.
206                          */
207                         socket_up = 1;
208                         goto set_threads;
209                 }
210         }
211
212         xlog_open(progname);
213
214         nfsd_enable_protos(&proto4, &proto6);
215
216         if (!NFSCTL_TCPISSET(protobits)) {
217                 NFSCTL_TCPUNSET(proto4);
218                 NFSCTL_TCPUNSET(proto6);
219         }
220
221         if (!NFSCTL_UDPISSET(protobits)) {
222                 NFSCTL_UDPUNSET(proto4);
223                 NFSCTL_UDPUNSET(proto6);
224         }
225
226         /* make sure that at least one version is enabled */
227         found_one = 0;
228         for (c = NFSD_MINVERS; c <= NFSD_MAXVERS; c++) {
229                 if (NFSCTL_VERISSET(versbits, c))
230                         found_one = 1;
231         }
232         if (!found_one) {
233                 xlog(L_ERROR, "no version specified");
234                 exit(1);
235         }                       
236
237         if (NFSCTL_VERISSET(versbits, 4) &&
238             !NFSCTL_TCPISSET(proto4) &&
239             !NFSCTL_TCPISSET(proto6)) {
240                 xlog(L_ERROR, "version 4 requires the TCP protocol");
241                 exit(1);
242         }
243
244         if (chdir(NFS_STATEDIR)) {
245                 xlog(L_ERROR, "chdir(%s) failed: %m", NFS_STATEDIR);
246                 exit(1);
247         }
248
249         /* make sure nfsdfs is mounted if it's available */
250         nfssvc_mount_nfsdfs(progname);
251
252         /* can only change number of threads if nfsd is already up */
253         if (nfssvc_inuse()) {
254                 socket_up = 1;
255                 goto set_threads;
256         }
257
258         /*
259          * must set versions before the fd's so that the right versions get
260          * registered with rpcbind. Note that on older kernels w/o the right
261          * interfaces, these are a no-op.
262          */
263         nfssvc_setvers(versbits, minorvers41);
264  
265         error = nfssvc_set_sockets(AF_INET, proto4, haddr, port);
266         if (!error)
267                 socket_up = 1;
268
269 #ifdef IPV6_SUPPORTED
270         error = nfssvc_set_sockets(AF_INET6, proto6, haddr, port);
271         if (!error)
272                 socket_up = 1;
273 #endif /* IPV6_SUPPORTED */
274
275 set_threads:
276         /* don't start any threads if unable to hand off any sockets */
277         if (!socket_up) {
278                 xlog(L_ERROR, "unable to set any sockets for nfsd");
279                 goto out;
280         }
281         error = 0;
282
283         /*
284          * KLUDGE ALERT:
285          * Some kernels let nfsd kernel threads inherit open files
286          * from the program that spawns them (i.e. us).  So close
287          * everything before spawning kernel threads.  --Chip
288          */
289         fd = open("/dev/null", O_RDWR);
290         if (fd == -1)
291                 xlog(L_ERROR, "Unable to open /dev/null: %m");
292         else {
293                 /* switch xlog output to syslog since stderr is being closed */
294                 xlog_syslog(1);
295                 xlog_stderr(0);
296                 (void) dup2(fd, 0);
297                 (void) dup2(fd, 1);
298                 (void) dup2(fd, 2);
299         }
300         closeall(3);
301
302         if ((error = nfssvc_threads(portnum, count)) < 0)
303                 xlog(L_ERROR, "error starting threads: errno %d (%m)", errno);
304 out:
305         free(port);
306         free(haddr);
307         free(progname);
308         return (error != 0);
309 }
310
311 static void
312 usage(const char *prog)
313 {
314         fprintf(stderr, "Usage:\n"
315                 "%s [-d|--debug] [-H hostname] [-p|-P|--port port] [-N|--no-nfs-version version ] [-s|--syslog] [-T|--no-tcp] [-U|--no-udp] nrservs\n", 
316                 prog);
317         exit(2);
318 }