int main(int argc, char **argv) { int ch, mntflags; char mntpath[MAXPATHLEN]; struct vfsconf vfc; int error; /* * XXX * mount(8) calls the mount programs with an argv[0] which is * /just/ the filesystem name. So, if there is no underscore * in argv[0], we assume that we are being called from mount(8) * and that argv[0] is thus the name of the filesystem type. */ fsname = strrchr(argv[0], '_'); if (fsname) { if (strcmp(fsname, "_std") == 0) errx(EX_USAGE, "argv[0] must end in _fsname"); fsname++; } else { fsname = argv[0]; } mntflags = 0; while ((ch = getopt(argc, argv, "o:")) != -1) switch (ch) { case 'o': getmntopts(optarg, mopts, &mntflags, 0); break; case '?': default: usage(); } argc -= optind; argv += optind; if (argc != 2) usage(); error = getvfsbyname(fsname, &vfc); if (error && vfsisloadable(fsname)) { if(vfsload(fsname)) err(EX_OSERR, "vfsload(%s)", fsname); endvfsent(); error = getvfsbyname(fsname, &vfc); } if (error) errx(EX_OSERR, "%s filesystem not available", fsname); /* resolve the mountpoint with realpath(3) */ checkpath(argv[1], mntpath); if (mount(vfc.vfc_name, mntpath, mntflags, NULL)) err(EX_OSERR, NULL); exit(0); }
int main(int argc, char **argv) { struct portal_args args; struct sockaddr_un un; char *conf; char mountpt[MAXPATHLEN]; int mntflags = 0; char tag[32]; struct vfsconf vfc; mode_t um; qelem q; int rc; int so; int error = 0; /* * Crack command line args */ int ch; while ((ch = getopt(argc, argv, "o:")) != -1) { switch (ch) { case 'o': getmntopts(optarg, mopts, &mntflags, 0); break; default: error = 1; break; } } if (optind != (argc - 2)) error = 1; if (error) usage(); /* * Get config file and mount point */ conf = argv[optind]; /* resolve the mountpoint with realpath(3) */ checkpath(argv[optind+1], mountpt); /* * Construct the listening socket */ un.sun_family = AF_UNIX; if (sizeof(_PATH_TMPPORTAL) >= sizeof(un.sun_path)) { errx(EX_SOFTWARE, "portal socket name too long"); } strcpy(un.sun_path, _PATH_TMPPORTAL); mktemp(un.sun_path); un.sun_len = strlen(un.sun_path); so = socket(AF_UNIX, SOCK_STREAM, 0); if (so < 0) { err(EX_OSERR, "socket"); } um = umask(077); unlink(un.sun_path); if (bind(so, (struct sockaddr *) &un, sizeof(un)) < 0) err(1, NULL); unlink(un.sun_path); umask(um); listen(so, 5); args.pa_socket = so; sprintf(tag, "portal:%d", getpid()); args.pa_config = tag; error = getvfsbyname("portal", &vfc); if (error && vfsisloadable("portal")) { if (vfsload("portal")) err(EX_OSERR, "vfsload(portal)"); endvfsent(); error = getvfsbyname("portal", &vfc); } if (error) errx(EX_OSERR, "portal filesystem is not available"); rc = mount(vfc.vfc_name, mountpt, mntflags, &args); if (rc < 0) err(1, NULL); /* * Everything is ready to go - now is a good time to fork */ #ifndef DEBUG daemon(0, 0); #endif /* * Start logging (and change name) */ openlog("portald", LOG_CONS|LOG_PID, LOG_DAEMON); q.q_forw = q.q_back = &q; readcf = 1; signal(SIGCHLD, sigchld); signal(SIGHUP, sighup); /* * Just loop waiting for new connections and activating them */ for (;;) { struct sockaddr_un un2; int len2 = sizeof(un2); int so2; pid_t pid; fd_set fdset; /* * Check whether we need to re-read the configuration file */ if (readcf) { #ifdef DEBUG printf ("re-reading configuration file\n"); #endif readcf = 0; conf_read(&q, conf); continue; } /* * Accept a new connection * Will get EINTR if a signal has arrived, so just * ignore that error code */ FD_ZERO(&fdset); FD_SET(so, &fdset); rc = select(so+1, &fdset, NULL, NULL, NULL); if (rc < 0) { if (errno == EINTR) continue; syslog(LOG_ERR, "select: %s", strerror(errno)); exit(EX_OSERR); } if (rc == 0) break; so2 = accept(so, (struct sockaddr *) &un2, &len2); if (so2 < 0) { /* * The unmount function does a shutdown on the socket * which will generated ECONNABORTED on the accept. */ if (errno == ECONNABORTED) break; if (errno != EINTR) { syslog(LOG_ERR, "accept: %s", strerror(errno)); exit(EX_OSERR); } continue; } /* * Now fork a new child to deal with the connection */ eagain:; switch (pid = fork()) { case -1: if (errno == EAGAIN) { sleep(1); goto eagain; } syslog(LOG_ERR, "fork: %s", strerror(errno)); break; case 0: close(so); activate(&q, so2); exit(0); default: close(so2); break; } } syslog(LOG_INFO, "%s unmounted", mountpt); exit(0); }
/* * Nfs server daemon mostly just a user context for nfssvc() * * 1 - do file descriptor and signal cleanup * 2 - fork the nfsd(s) * 3 - create server socket(s) * 4 - register socket with rpcbind * * For connectionless protocols, just pass the socket into the kernel via. * nfssvc(). * For connection based sockets, loop doing accepts. When you get a new * socket from accept, pass the msgsock into the kernel via. nfssvc(). * The arguments are: * -r - reregister with rpcbind * -d - unregister with rpcbind * -t - support tcp nfs clients * -u - support udp nfs clients * followed by "n" which is the number of nfsds' to fork off */ int main(int argc, char **argv) { struct nfsd_args nfsdargs; struct addrinfo *ai_udp, *ai_tcp, *ai_udp6, *ai_tcp6, hints; struct netconfig *nconf_udp, *nconf_tcp, *nconf_udp6, *nconf_tcp6; struct netbuf nb_udp, nb_tcp, nb_udp6, nb_tcp6; struct sockaddr_in inetpeer; struct sockaddr_in6 inet6peer; fd_set ready, sockbits; fd_set v4bits, v6bits; int ch, connect_type_cnt, i, maxsock, msgsock; socklen_t len; int on = 1, unregister, reregister, sock; int tcp6sock, ip6flag, tcpflag, tcpsock; int udpflag, ecode, s, srvcnt; int bindhostc, bindanyflag, rpcbreg, rpcbregcnt; char **bindhost = NULL; pid_t pid; struct vfsconf vfc; int error; error = getvfsbyname("nfs", &vfc); if (error && vfsisloadable("nfs")) { if (vfsload("nfs")) err(1, "vfsload(nfs)"); endvfsent(); /* flush cache */ error = getvfsbyname("nfs", &vfc); } if (error) errx(1, "NFS is not available in the running kernel"); nfsdcnt = DEFNFSDCNT; unregister = reregister = tcpflag = maxsock = 0; bindanyflag = udpflag = connect_type_cnt = bindhostc = 0; #define GETOPT "ah:n:rdtu" #define USAGE "[-ardtu] [-n num_servers] [-h bindip]" while ((ch = getopt(argc, argv, GETOPT)) != -1) switch (ch) { case 'a': bindanyflag = 1; break; case 'n': nfsdcnt = atoi(optarg); if (nfsdcnt < 1 || nfsdcnt > MAXNFSDCNT) { warnx("nfsd count %d; reset to %d", nfsdcnt, DEFNFSDCNT); nfsdcnt = DEFNFSDCNT; } break; case 'h': bindhostc++; bindhost = realloc(bindhost,sizeof(char *)*bindhostc); if (bindhost == NULL) errx(1, "Out of memory"); bindhost[bindhostc-1] = strdup(optarg); if (bindhost[bindhostc-1] == NULL) errx(1, "Out of memory"); break; case 'r': reregister = 1; break; case 'd': unregister = 1; break; case 't': tcpflag = 1; break; case 'u': udpflag = 1; break; default: case '?': usage(); }; if (!tcpflag && !udpflag) udpflag = 1; argv += optind; argc -= optind; /* * XXX * Backward compatibility, trailing number is the count of daemons. */ if (argc > 1) usage(); if (argc == 1) { nfsdcnt = atoi(argv[0]); if (nfsdcnt < 1 || nfsdcnt > MAXNFSDCNT) { warnx("nfsd count %d; reset to %d", nfsdcnt, DEFNFSDCNT); nfsdcnt = DEFNFSDCNT; } } ip6flag = 1; s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); if (s == -1) { if (errno != EPROTONOSUPPORT) err(1, "socket"); ip6flag = 0; } else if (getnetconfigent("udp6") == NULL || getnetconfigent("tcp6") == NULL) { ip6flag = 0; } if (s != -1) close(s); if (bindhostc == 0 || bindanyflag) { bindhostc++; bindhost = realloc(bindhost,sizeof(char *)*bindhostc); if (bindhost == NULL) errx(1, "Out of memory"); bindhost[bindhostc-1] = strdup("*"); if (bindhost[bindhostc-1] == NULL) errx(1, "Out of memory"); } if (unregister) { unregistration(); exit (0); } if (reregister) { if (udpflag) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp); if (ecode != 0) err(1, "getaddrinfo udp: %s", gai_strerror(ecode)); nconf_udp = getnetconfigent("udp"); if (nconf_udp == NULL) err(1, "getnetconfigent udp failed"); nb_udp.buf = ai_udp->ai_addr; nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen; if ((!rpcb_set(RPCPROG_NFS, 2, nconf_udp, &nb_udp)) || (!rpcb_set(RPCPROG_NFS, 3, nconf_udp, &nb_udp))) err(1, "rpcb_set udp failed"); freeaddrinfo(ai_udp); } if (udpflag && ip6flag) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6); if (ecode != 0) err(1, "getaddrinfo udp6: %s", gai_strerror(ecode)); nconf_udp6 = getnetconfigent("udp6"); if (nconf_udp6 == NULL) err(1, "getnetconfigent udp6 failed"); nb_udp6.buf = ai_udp6->ai_addr; nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen; if ((!rpcb_set(RPCPROG_NFS, 2, nconf_udp6, &nb_udp6)) || (!rpcb_set(RPCPROG_NFS, 3, nconf_udp6, &nb_udp6))) err(1, "rpcb_set udp6 failed"); freeaddrinfo(ai_udp6); } if (tcpflag) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp); if (ecode != 0) err(1, "getaddrinfo tcp: %s", gai_strerror(ecode)); nconf_tcp = getnetconfigent("tcp"); if (nconf_tcp == NULL) err(1, "getnetconfigent tcp failed"); nb_tcp.buf = ai_tcp->ai_addr; nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen; if ((!rpcb_set(RPCPROG_NFS, 2, nconf_tcp, &nb_tcp)) || (!rpcb_set(RPCPROG_NFS, 3, nconf_tcp, &nb_tcp))) err(1, "rpcb_set tcp failed"); freeaddrinfo(ai_tcp); } if (tcpflag && ip6flag) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6); if (ecode != 0) err(1, "getaddrinfo tcp6: %s", gai_strerror(ecode)); nconf_tcp6 = getnetconfigent("tcp6"); if (nconf_tcp6 == NULL) err(1, "getnetconfigent tcp6 failed"); nb_tcp6.buf = ai_tcp6->ai_addr; nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen; if ((!rpcb_set(RPCPROG_NFS, 2, nconf_tcp6, &nb_tcp6)) || (!rpcb_set(RPCPROG_NFS, 3, nconf_tcp6, &nb_tcp6))) err(1, "rpcb_set tcp6 failed"); freeaddrinfo(ai_tcp6); } exit (0); } if (debug == 0) { daemon(0, 0); signal(SIGHUP, SIG_IGN); signal(SIGINT, SIG_IGN); /* * nfsd sits in the kernel most of the time. It needs * to ignore SIGTERM/SIGQUIT in order to stay alive as long * as possible during a shutdown, otherwise loopback * mounts will not be able to unmount. */ signal(SIGTERM, SIG_IGN); signal(SIGQUIT, SIG_IGN); } signal(SIGSYS, nonfs); signal(SIGCHLD, reapchild); openlog("nfsd", LOG_PID, LOG_DAEMON); /* If we use UDP only, we start the last server below. */ srvcnt = tcpflag ? nfsdcnt : nfsdcnt - 1; for (i = 0; i < srvcnt; i++) { switch ((pid = fork())) { case -1: syslog(LOG_ERR, "fork: %m"); nfsd_exit(1); case 0: break; default: children[i] = pid; continue; } signal(SIGUSR1, child_cleanup); setproctitle("server"); start_server(0); } signal(SIGUSR1, cleanup); FD_ZERO(&v4bits); FD_ZERO(&v6bits); FD_ZERO(&sockbits); rpcbregcnt = 0; /* Set up the socket for udp and rpcb register it. */ if (udpflag) { rpcbreg = 0; for (i = 0; i < bindhostc; i++) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; if (setbindhost(&ai_udp, bindhost[i], hints) == 0) { rpcbreg = 1; rpcbregcnt++; if ((sock = socket(ai_udp->ai_family, ai_udp->ai_socktype, ai_udp->ai_protocol)) < 0) { syslog(LOG_ERR, "can't create udp socket"); nfsd_exit(1); } if (bind(sock, ai_udp->ai_addr, ai_udp->ai_addrlen) < 0) { syslog(LOG_ERR, "can't bind udp addr %s: %m", bindhost[i]); nfsd_exit(1); } freeaddrinfo(ai_udp); nfsdargs.sock = sock; nfsdargs.name = NULL; nfsdargs.namelen = 0; if (nfssvc(NFSSVC_ADDSOCK, &nfsdargs) < 0) { syslog(LOG_ERR, "can't Add UDP socket"); nfsd_exit(1); } close(sock); } } if (rpcbreg == 1) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp); if (ecode != 0) { syslog(LOG_ERR, "getaddrinfo udp: %s", gai_strerror(ecode)); nfsd_exit(1); } nconf_udp = getnetconfigent("udp"); if (nconf_udp == NULL) err(1, "getnetconfigent udp failed"); nb_udp.buf = ai_udp->ai_addr; nb_udp.len = nb_udp.maxlen = ai_udp->ai_addrlen; if ((!rpcb_set(RPCPROG_NFS, 2, nconf_udp, &nb_udp)) || (!rpcb_set(RPCPROG_NFS, 3, nconf_udp, &nb_udp))) err(1, "rpcb_set udp failed"); freeaddrinfo(ai_udp); } } /* Set up the socket for udp6 and rpcb register it. */ if (udpflag && ip6flag) { rpcbreg = 0; for (i = 0; i < bindhostc; i++) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; if (setbindhost(&ai_udp6, bindhost[i], hints) == 0) { rpcbreg = 1; rpcbregcnt++; if ((sock = socket(ai_udp6->ai_family, ai_udp6->ai_socktype, ai_udp6->ai_protocol)) < 0) { syslog(LOG_ERR, "can't create udp6 socket"); nfsd_exit(1); } if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof on) < 0) { syslog(LOG_ERR, "can't set v6-only binding for " "udp6 socket: %m"); nfsd_exit(1); } if (bind(sock, ai_udp6->ai_addr, ai_udp6->ai_addrlen) < 0) { syslog(LOG_ERR, "can't bind udp6 addr %s: %m", bindhost[i]); nfsd_exit(1); } freeaddrinfo(ai_udp6); nfsdargs.sock = sock; nfsdargs.name = NULL; nfsdargs.namelen = 0; if (nfssvc(NFSSVC_ADDSOCK, &nfsdargs) < 0) { syslog(LOG_ERR, "can't add UDP6 socket"); nfsd_exit(1); } close(sock); } } if (rpcbreg == 1) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; ecode = getaddrinfo(NULL, "nfs", &hints, &ai_udp6); if (ecode != 0) { syslog(LOG_ERR, "getaddrinfo udp6: %s", gai_strerror(ecode)); nfsd_exit(1); } nconf_udp6 = getnetconfigent("udp6"); if (nconf_udp6 == NULL) err(1, "getnetconfigent udp6 failed"); nb_udp6.buf = ai_udp6->ai_addr; nb_udp6.len = nb_udp6.maxlen = ai_udp6->ai_addrlen; if ((!rpcb_set(RPCPROG_NFS, 2, nconf_udp6, &nb_udp6)) || (!rpcb_set(RPCPROG_NFS, 3, nconf_udp6, &nb_udp6))) err(1, "rpcb_set udp6 failed"); freeaddrinfo(ai_udp6); } } /* Set up the socket for tcp and rpcb register it. */ if (tcpflag) { rpcbreg = 0; for (i = 0; i < bindhostc; i++) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; if (setbindhost(&ai_tcp, bindhost[i], hints) == 0) { rpcbreg = 1; rpcbregcnt++; if ((tcpsock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { syslog(LOG_ERR, "can't create tpc socket"); nfsd_exit(1); } if (setsockopt(tcpsock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0) syslog(LOG_ERR, "setsockopt SO_REUSEADDR: %m"); if (bind(tcpsock, ai_tcp->ai_addr, ai_tcp->ai_addrlen) < 0) { syslog(LOG_ERR, "can't bind tcp addr %s: %m", bindhost[i]); nfsd_exit(1); } if (listen(tcpsock, 64) < 0) { syslog(LOG_ERR, "listen failed"); nfsd_exit(1); } freeaddrinfo(ai_tcp); FD_SET(tcpsock, &sockbits); FD_SET(tcpsock, &v4bits); maxsock = tcpsock; connect_type_cnt++; } } if (rpcbreg == 1) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp); if (ecode != 0) { syslog(LOG_ERR, "getaddrinfo tcp: %s", gai_strerror(ecode)); nfsd_exit(1); } nconf_tcp = getnetconfigent("tcp"); if (nconf_tcp == NULL) err(1, "getnetconfigent tcp failed"); nb_tcp.buf = ai_tcp->ai_addr; nb_tcp.len = nb_tcp.maxlen = ai_tcp->ai_addrlen; if ((!rpcb_set(RPCPROG_NFS, 2, nconf_tcp, &nb_tcp)) || (!rpcb_set(RPCPROG_NFS, 3, nconf_tcp, &nb_tcp))) err(1, "rpcb_set tcp failed"); freeaddrinfo(ai_tcp); } } /* Set up the socket for tcp6 and rpcb register it. */ if (tcpflag && ip6flag) { rpcbreg = 0; for (i = 0; i < bindhostc; i++) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; if (setbindhost(&ai_tcp6, bindhost[i], hints) == 0) { rpcbreg = 1; rpcbregcnt++; if ((tcp6sock = socket(ai_tcp6->ai_family, ai_tcp6->ai_socktype, ai_tcp6->ai_protocol)) < 0) { syslog(LOG_ERR, "can't create tcp6 socket"); nfsd_exit(1); } if (setsockopt(tcp6sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0) syslog(LOG_ERR, "setsockopt SO_REUSEADDR: %m"); if (setsockopt(tcp6sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof on) < 0) { syslog(LOG_ERR, "can't set v6-only binding for tcp6 " "socket: %m"); nfsd_exit(1); } if (bind(tcp6sock, ai_tcp6->ai_addr, ai_tcp6->ai_addrlen) < 0) { syslog(LOG_ERR, "can't bind tcp6 addr %s: %m", bindhost[i]); nfsd_exit(1); } if (listen(tcp6sock, 64) < 0) { syslog(LOG_ERR, "listen failed"); nfsd_exit(1); } freeaddrinfo(ai_tcp6); FD_SET(tcp6sock, &sockbits); FD_SET(tcp6sock, &v6bits); if (maxsock < tcp6sock) maxsock = tcp6sock; connect_type_cnt++; } } if (rpcbreg == 1) { memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; ecode = getaddrinfo(NULL, "nfs", &hints, &ai_tcp6); if (ecode != 0) { syslog(LOG_ERR, "getaddrinfo tcp6: %s", gai_strerror(ecode)); nfsd_exit(1); } nconf_tcp6 = getnetconfigent("tcp6"); if (nconf_tcp6 == NULL) err(1, "getnetconfigent tcp6 failed"); nb_tcp6.buf = ai_tcp6->ai_addr; nb_tcp6.len = nb_tcp6.maxlen = ai_tcp6->ai_addrlen; if ((!rpcb_set(RPCPROG_NFS, 2, nconf_tcp6, &nb_tcp6)) || (!rpcb_set(RPCPROG_NFS, 3, nconf_tcp6, &nb_tcp6))) err(1, "rpcb_set tcp6 failed"); freeaddrinfo(ai_tcp6); } } if (rpcbregcnt == 0) { syslog(LOG_ERR, "rpcb_set() failed, nothing to do: %m"); nfsd_exit(1); } if (tcpflag && connect_type_cnt == 0) { syslog(LOG_ERR, "tcp connects == 0, nothing to do: %m"); nfsd_exit(1); } setproctitle("master"); /* * We always want a master to have a clean way to to shut nfsd down * (with unregistration): if the master is killed, it unregisters and * kills all children. If we run for UDP only (and so do not have to * loop waiting waiting for accept), we instead make the parent * a "server" too. start_server will not return. */ if (!tcpflag) start_server(1); /* * Loop forever accepting connections and passing the sockets * into the kernel for the mounts. */ for (;;) { ready = sockbits; if (connect_type_cnt > 1) { if (select(maxsock + 1, &ready, NULL, NULL, NULL) < 1) { syslog(LOG_ERR, "select failed: %m"); if (errno == EINTR) continue; nfsd_exit(1); } } for (tcpsock = 0; tcpsock <= maxsock; tcpsock++) { if (FD_ISSET(tcpsock, &ready)) { if (FD_ISSET(tcpsock, &v4bits)) { len = sizeof(inetpeer); if ((msgsock = accept(tcpsock, (struct sockaddr *)&inetpeer, &len)) < 0) { syslog(LOG_ERR, "accept failed: %m"); if (errno == ECONNABORTED || errno == EINTR) continue; nfsd_exit(1); } memset(inetpeer.sin_zero, 0, sizeof(inetpeer.sin_zero)); if (setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0) syslog(LOG_ERR, "setsockopt SO_KEEPALIVE: %m"); nfsdargs.sock = msgsock; nfsdargs.name = (caddr_t)&inetpeer; nfsdargs.namelen = len; nfssvc(NFSSVC_ADDSOCK, &nfsdargs); close(msgsock); } else if (FD_ISSET(tcpsock, &v6bits)) { len = sizeof(inet6peer); if ((msgsock = accept(tcpsock, (struct sockaddr *)&inet6peer, &len)) < 0) { syslog(LOG_ERR, "accept failed: %m"); if (errno == ECONNABORTED || errno == EINTR) continue; nfsd_exit(1); } if (setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0) syslog(LOG_ERR, "setsockopt " "SO_KEEPALIVE: %m"); nfsdargs.sock = msgsock; nfsdargs.name = (caddr_t)&inet6peer; nfsdargs.namelen = len; nfssvc(NFSSVC_ADDSOCK, &nfsdargs); close(msgsock); } } } } }
int main(int ac, char **av) { struct hammer_mount_info info; struct vfsconf vfc; struct hammer_volume_ondisk *od; int mount_flags = 0; int error; int ch; int init_flags = 0; int ax; int fd; int pr; int fdevs_size; char *mountpt; char *ptr; char *fdevs; bzero(&info, sizeof(info)); info.asof = 0; mount_flags = 0; info.hflags = 0; while ((ch = getopt(ac, av, "o:T:u")) != -1) { switch(ch) { case 'T': info.asof = strtoull(optarg, NULL, 0); break; case 'o': getmntopts(optarg, mopts, &mount_flags, &info.hflags); /* * Handle extended flags with parameters. */ if (info.hflags & HMNT_MASTERID) { ptr = strstr(optarg, "master="); if (ptr) { info.master_id = strtol(ptr + 7, NULL, 0); if (info.master_id == 0) { fprintf(stderr, "hammer_mount: Warning: a master id of 0 is the default, explicit\n" "settings should probably use 1-15\n"); } } ptr = strstr(optarg, "nomirror"); if (ptr) info.master_id = -1; } break; case 'u': init_flags |= MNT_UPDATE; break; default: usage(); /* not reached */ } } ac -= optind; av += optind; mount_flags |= init_flags; /* * Only the mount point need be specified in update mode. */ if (init_flags & MNT_UPDATE) { if (ac != 1) { usage(); /* not reached */ } mountpt = av[0]; if (mount(vfc.vfc_name, mountpt, mount_flags, &info)) err(1, "mountpoint %s", mountpt); exit(0); } if (ac < 2) { usage(); /* not reached */ } /* * Mount arguments: vol [vol...] mountpt */ extract_volumes(&info.volumes, &info.nvolumes, av, ac - 1); mountpt = av[ac - 1]; /* * Load the hammer module if necessary (this bit stolen from * mount_null). */ error = getvfsbyname("hammer", &vfc); if (error && vfsisloadable("hammer")) { if (vfsload("hammer") != 0) err(1, "vfsload(hammer)"); endvfsent(); error = getvfsbyname("hammer", &vfc); } if (error) errx(1, "hammer filesystem is not available"); if (mount(vfc.vfc_name, mountpt, mount_flags, &info)) { /* Build fdevs in case of error to report failed devices */ fdevs_size = ac * PATH_MAX; fdevs = malloc(fdevs_size); for (ax = 0; ax < ac - 1; ax++) { fd = open(info.volumes[ax], O_RDONLY); if (fd < 0 ) { printf ("%s: open failed\n", info.volumes[ax]); strlcat(fdevs, info.volumes[ax], fdevs_size); if (ax < ac - 2) strlcat(fdevs, " ", fdevs_size); continue; } od = malloc(HAMMER_BUFSIZE); if (od == NULL) { close (fd); perror("malloc"); continue; } bzero(od, HAMMER_BUFSIZE); pr = pread(fd, od, HAMMER_BUFSIZE, 0); if (pr != HAMMER_BUFSIZE || od->vol_signature != HAMMER_FSBUF_VOLUME) { printf("%s: Not a valid HAMMER filesystem\n", info.volumes[ax]); strlcat(fdevs, info.volumes[ax], fdevs_size); if (ax < ac - 2) strlcat(fdevs, " ", fdevs_size); } close(fd); } err(1,"mount %s on %s", fdevs, mountpt); } exit (0); }
KMountPoint::List KMountPoint::currentMountPoints(int infoNeeded) { KMountPoint::List result; #ifdef HAVE_GETMNTINFO #ifdef GETMNTINFO_USES_STATVFS struct statvfs *mounted; #else struct statfs *mounted; #endif int num_fs = getmntinfo(&mounted, MNT_NOWAIT); for (int i=0;i<num_fs;i++) { KMountPoint *mp = new KMountPoint(); mp->m_mountedFrom = TQFile::decodeName(mounted[i].f_mntfromname); mp->m_mountPoint = TQFile::decodeName(mounted[i].f_mntonname); #ifdef __osf__ mp->m_mountType = TQFile::decodeName(mnt_names[mounted[i].f_type]); #else mp->m_mountType = TQFile::decodeName(mounted[i].f_fstypename); #endif if (infoNeeded & NeedMountOptions) { struct fstab *ft = getfsfile(mounted[i].f_mntonname); TQString options = TQFile::decodeName(ft->fs_mntops); mp->m_mountOptions = TQStringList::split(',', options); } if (infoNeeded & NeedRealDeviceName) { if (mp->m_mountedFrom.startsWith("/")) mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom); } // TODO: Strip trailing '/' ? result.append(mp); } #elif defined(_AIX) struct vmount *mntctl_buffer; struct vmount *vm; char *mountedfrom; char *mountedto; int fsname_len, num; int buf_sz = 4096; mntctl_buffer = (struct vmount*)malloc(buf_sz); num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer); if (num == 0) { buf_sz = *(int*)mntctl_buffer; free(mntctl_buffer); mntctl_buffer = (struct vmount*)malloc(buf_sz); num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer); } if (num > 0) { /* iterate through items in the vmount structure: */ vm = (struct vmount *)mntctl_buffer; for ( ; num > 0; num-- ) { /* get the name of the mounted file systems: */ fsname_len = vmt2datasize(vm, VMT_STUB); mountedto = (char*)malloc(fsname_len + 1); mountedto[fsname_len] = '\0'; strncpy(mountedto, (char *)vmt2dataptr(vm, VMT_STUB), fsname_len); fsname_len = vmt2datasize(vm, VMT_OBJECT); mountedfrom = (char*)malloc(fsname_len + 1); mountedfrom[fsname_len] = '\0'; strncpy(mountedfrom, (char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len); /* Look up the string for the file system type, * as listed in /etc/vfs. * ex.: nfs,jfs,afs,cdrfs,sfs,cachefs,nfs3,autofs */ struct vfs_ent* ent = getvfsbytype(vm->vmt_gfstype); KMountPoint *mp = new KMountPoint(); mp->m_mountedFrom = TQFile::decodeName(mountedfrom); mp->m_mountPoint = TQFile::decodeName(mountedto); mp->m_mountType = TQFile::decodeName(ent->vfsent_name); free(mountedfrom); free(mountedto); if (infoNeeded & NeedMountOptions) { // TODO } if (infoNeeded & NeedRealDeviceName) { if (mp->m_mountedFrom.startsWith("/")) mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom); } result.append(mp); /* goto the next vmount structure: */ vm = (struct vmount *)((char *)vm + vm->vmt_length); } endvfsent( ); } free( mntctl_buffer ); #elif defined(Q_WS_WIN) //TODO? #else STRUCT_SETMNTENT mnttab; if ((mnttab = SETMNTENT(MNTTAB, "r")) == 0) return result; STRUCT_MNTENT fe; while (GETMNTENT(mnttab, fe)) { KMountPoint *mp = new KMountPoint(); mp->m_mountedFrom = TQFile::decodeName(FSNAME(fe)); mp->m_mountPoint = TQFile::decodeName(MOUNTPOINT(fe)); mp->m_mountType = TQFile::decodeName(MOUNTTYPE(fe)); //Devices using supermount have their device names in the mount options //instead of the device field. That's why we need to read the mount options if (infoNeeded & NeedMountOptions || (mp->m_mountType == "supermount")) { TQString options = TQFile::decodeName(MOUNTOPTIONS(fe)); mp->m_mountOptions = TQStringList::split(',', options); } if (mp->m_mountType == "supermount") mp->m_mountedFrom = devNameFromOptions(mp->m_mountOptions); if (infoNeeded & NeedRealDeviceName) { if (mp->m_mountedFrom.startsWith("/")) mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom); } // TODO: Strip trailing '/' ? result.append(mp); } ENDMNTENT(mnttab); #endif return result; }