/* A translator for returning FS_RETRY_MAGIC strings. Copyright (C) 1999 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include const char *argp_program_version = STANDARD_HURD_VERSION (magic); static char args_doc[] = "MAGIC"; static char doc[] = "A translator that returns the magic retry result MAGIC"; static const struct argp_option options[] = { {"directory", 'd', 0, 0, "Provide virtual (empty) directory node"}, {0} }; /* The magic string we return for lookups. */ static char *magic; static int directory; /* --directory flag */ /* Pre-fab contents of dummy directory for dir_readdir. Set up only under --directory. */ static void *dirbuf; static size_t dirbufsize; /* Trivfs hooks */ int trivfs_fstype = FSTYPE_DEV; int trivfs_fsid = 0; int trivfs_support_read = 0; int trivfs_support_write = 0; int trivfs_support_exec = 0; int trivfs_allow_open = O_READ; void trivfs_modify_stat (struct trivfs_protid *cred, struct stat *st) { st->st_size = dirbufsize; st->st_blocks = getpagesize () / S_BLKSIZE; st->st_mode = ((st->st_mode & ~S_IFMT & ~ALLPERMS) | S_IFDIR | S_IXUSR|S_IXGRP|S_IXOTH | (st->st_mode & (S_IRUSR|S_IRGRP|S_IROTH))); } error_t trivfs_goaway (struct trivfs_control *fsys, int flags) { exit (0); } /* This hook is used when running without --directory; it circumvents basically all the trivfs machinery. */ static error_t magic_getroot (struct trivfs_control *cntl, mach_port_t reply_port, mach_msg_type_name_t reply_port_type, mach_port_t dotdot, uid_t *uids, u_int nuids, uid_t *gids, u_int ngids, int flags, retry_type *do_retry, char *retry_name, mach_port_t *node, mach_msg_type_name_t *node_type) { strcpy (retry_name, magic); *do_retry = FS_RETRY_MAGICAL; *node = MACH_PORT_NULL; *node_type = MACH_MSG_TYPE_COPY_SEND; return 0; } /* This hook is used when running with --directory, when we do use all the normal trivfs machinery. We just use the normal trivfs open, but then stash the DOTDOT port in the trivfs_peropen. */ static error_t magic_open (struct trivfs_control *cntl, struct iouser *user, mach_port_t dotdot, int flags, mach_port_t realnode, struct trivfs_protid **cred) { error_t err = trivfs_open (cntl, user, flags, realnode, cred); if (!err) { (*cred)->po->hook = (void *) dotdot; err = mach_port_mod_refs (mach_task_self (), dotdot, MACH_PORT_RIGHT_SEND, +1); assert_perror (err); err = mach_port_deallocate (mach_task_self (), dotdot); assert_perror (err); } return err; } /* Do a directory lookup. */ error_t trivfs_S_dir_lookup (struct trivfs_protid *cred, mach_port_t reply, mach_msg_type_name_t reply_type, char *name, int flags, mode_t mode, retry_type *retry_type, char *retry_name, mach_port_t *retrypt, mach_msg_type_name_t *retrypt_type) { int perms; error_t err; struct trivfs_protid *newcred; mach_port_t dotdot; struct iouser *user; if (!cred) return EOPNOTSUPP; if (name[0] != '\0') { if (!directory) return ENOTDIR; else { /* We have a real lookup in the dummy directory. Handle `.' and `..' specially, and anything else gets redirected to the magical retry. */ while (*name == '/') ++name; while (!strncmp (name, "./", 2)) { name += 2; while (*name == '/') ++name; } if (!strcmp (name, "..") || !strncmp (name, "../", 3)) { name += 2; while (*name == '/') ++name; strcpy (retry_name, name); *retry_type = FS_RETRY_REAUTH; *retrypt = (mach_port_t) cred->po->hook; *retrypt_type = MACH_MSG_TYPE_COPY_SEND; return 0; } else if (name[0] != '\0' && strcmp (name, ".")) { char *p = stpcpy (retry_name, magic); *p++ = '/'; strcpy (p, name); *retry_type = FS_RETRY_MAGICAL; *retrypt = MACH_PORT_NULL; *retrypt_type = MACH_MSG_TYPE_COPY_SEND; return 0; } } } /* This is a null-pathname "reopen" call; do the right thing. */ /* Burn off flags we don't actually implement */ flags &= O_HURD; flags &= ~(O_CREAT|O_EXCL|O_NOLINK|O_NOTRANS); /* Validate permissions */ if (! trivfs_check_access_hook) file_check_access (cred->realnode, &perms); else (*trivfs_check_access_hook) (cred->po->cntl, cred->user, cred->realnode, &perms); if ((flags & (O_READ|O_WRITE|O_EXEC) & perms) != (flags & (O_READ|O_WRITE|O_EXEC))) return EACCES; /* Execute the open */ dotdot = (mach_port_t) cred->po->hook; user = iohelp_dup_iouser (cred->user); err = magic_open (cred->po->cntl, user, dotdot, flags, cred->realnode, &newcred); if (err) { iohelp_free_iouser (user); return err; } err = mach_port_mod_refs (mach_task_self (), dotdot, MACH_PORT_RIGHT_SEND, +1); assert_perror (err); err = mach_port_mod_refs (mach_task_self (), cred->realnode, MACH_PORT_RIGHT_SEND, +1); assert_perror (err); *retry_type = FS_RETRY_NORMAL; *retry_name = '\0'; *retrypt = ports_get_right (newcred); *retrypt_type = MACH_MSG_TYPE_MAKE_SEND; ports_port_deref (newcred); return 0; } error_t trivfs_S_dir_readdir (struct trivfs_protid *cred, mach_port_t reply, mach_msg_type_name_t reply_type, char **data, u_int *datalen, boolean_t *data_dealloc, int entry, int nentries, vm_size_t bufsiz, int *amount) { if (!cred) return EOPNOTSUPP; if (entry > 0) { void *p; int i; i = 0; for (p = dirbuf; p < dirbuf + dirbufsize; p += ((struct dirent *) p)->d_reclen) if (++i == entry) break; *data = p; *datalen = dirbuf + dirbufsize - p; *amount = 2 - entry; } else { *data = dirbuf; *datalen = dirbufsize; *amount = 2; } *data_dealloc = 0; return 0; } static error_t parse_opt (int opt, char *arg, struct argp_state *state) { switch (opt) { case 'd': directory = 1; return 0; case ARGP_KEY_NO_ARGS: argp_usage (state); return EINVAL; case ARGP_KEY_ARGS: if (state->next != state->argc - 1) { argp_usage (state); return EINVAL; } else { magic = state->argv[state->next]; return 0; } break; } return ARGP_ERR_UNKNOWN; } error_t trivfs_append_args (struct trivfs_control *fsys, char **argz, size_t *argz_len) { return ((directory ? argz_add (argz, argz_len, "--directory") : 0) ?: argz_add (argz, argz_len, magic)); } int main (int argc, char **argv) { error_t err; mach_port_t bootstrap; struct trivfs_control *fsys; struct argp argp = { options, parse_opt, args_doc, doc }; argp_parse (&argp, argc, argv, 0, 0, 0); task_get_bootstrap_port (mach_task_self (), &bootstrap); if (bootstrap == MACH_PORT_NULL) error (1, 0, "Must be started as a translator"); /* Reply to our parent */ err = trivfs_startup (bootstrap, 0, 0, 0, 0, 0, &fsys); mach_port_deallocate (mach_task_self (), bootstrap); if (err) error (3, err, "Contacting parent"); if (directory) { inline struct dirent *add (struct dirent *d, const char *name) { d->d_fileno = 2; /* random */ d->d_type = DT_DIR; d->d_namlen = strlen (name); strcpy (d->d_name, name); d->d_name[d->d_namlen] = '\0'; d->d_reclen = &d->d_name[d->d_namlen + 1] - (char *) d; d->d_reclen = ((d->d_reclen + __alignof (struct dirent) - 1) & ~(__alignof (struct dirent) - 1)); return (struct dirent *) ((char *) d + d->d_reclen); } struct dirent *d; dirbuf = mmap (0, getpagesize (), PROT_READ|PROT_WRITE, MAP_ANON, 0, 0); d = add (dirbuf, "."); d = add (d, ".."); dirbufsize = (char *) d - (char *) dirbuf; trivfs_open_hook = &magic_open; } else trivfs_getroot_hook = &magic_getroot; /* Launch. */ ports_manage_port_operations_one_thread (fsys->pi.bucket, trivfs_demuxer, 2 * 60 * 1000); return 0; }