// Close file f. (Decrement ref count, close when reaches 0.)
void
fileclose(struct file *f)
{
struct file ff;
acquire(&ftable.lock);
if(f->ref < 1)
panic("fileclose");
if(--f->ref > 0){
release(&ftable.lock);
return;
}
ff = *f;
f->ref = 0;
f->type = FD_NONE;
release(&ftable.lock);
if(ff.type == FD_PIPE)
pipeclose(ff.pipe, ff.writable);
else if(ff.type == FD_INODE){
begin_trans();
iput(ff.ip);
commit_trans();
}
}
static void
job_done_cb (evutil_socket_t fd, short event, void *vdata)
{
CcnetJob *job = vdata;
char buf[1];
if (pipereadn (job->pipefd[0], buf, 1) != 1) {
/* g_warning ("[Job Manager] read pipe error: %s\n", strerror(errno)); */
}
pipeclose (job->pipefd[0]);
pipeclose (job->pipefd[1]);
if (job->done_func) {
job->done_func (job->result);
}
ccnet_job_manager_remove_job (job->manager, job->id);
}
/* ARGSUSED */
int
pipe_close(struct file *fp, struct proc *p)
{
struct pipe *cpipe = (struct pipe *)fp->f_data;
fp->f_ops = NULL;
fp->f_data = NULL;
pipeclose(cpipe);
return (0);
}
Zone *zonegen(Rng *r, int depth)
{
ignframetime();
FILE *fin = inzone;
if (!fin)
fin = zpipe(r, depth);
Zone *z = zoneread(fin);
if (!z)
die("Failed to read the zone: %s", miderrstr());
if (inzone) {
fclose(fin);
inzone = NULL;
} else {
int ret = pipeclose(fin);
if (ret == -1)
die("Zone gen pipeline exited with failure: %s", miderrstr());
}
return z;
}
// Close file f. (Decrement ref count, close when reaches 0.)
void
fileclose(struct file *f)
{
struct file ff;
acquire(&file_table_lock);
if(f->ref < 1 || f->type == FD_CLOSED)
panic("fileclose");
if(--f->ref > 0){
release(&file_table_lock);
return;
}
ff = *f;
f->ref = 0;
f->type = FD_CLOSED;
release(&file_table_lock);
if(ff.type == FD_PIPE)
pipeclose(ff.pipe, ff.writable);
else if(ff.type == FD_INODE)
iput(ff.ip);
else
panic("fileclose");
}
/* ARGSUSED */
int
sys_pipe(struct proc *p, void *v, register_t *retval)
{
struct sys_pipe_args /* {
syscallarg(int *) fdp;
} */ *uap = v;
struct filedesc *fdp = p->p_fd;
struct file *rf, *wf;
struct pipe *rpipe, *wpipe = NULL;
int fds[2], error;
rpipe = pool_get(&pipe_pool, PR_WAITOK);
error = pipe_create(rpipe);
if (error != 0)
goto free1;
wpipe = pool_get(&pipe_pool, PR_WAITOK);
error = pipe_create(wpipe);
if (error != 0)
goto free1;
fdplock(fdp);
error = falloc(p, &rf, &fds[0]);
if (error != 0)
goto free2;
rf->f_flag = FREAD | FWRITE;
rf->f_type = DTYPE_PIPE;
rf->f_data = rpipe;
rf->f_ops = &pipeops;
error = falloc(p, &wf, &fds[1]);
if (error != 0)
goto free3;
wf->f_flag = FREAD | FWRITE;
wf->f_type = DTYPE_PIPE;
wf->f_data = wpipe;
wf->f_ops = &pipeops;
rpipe->pipe_peer = wpipe;
wpipe->pipe_peer = rpipe;
FILE_SET_MATURE(rf, p);
FILE_SET_MATURE(wf, p);
error = copyout(fds, SCARG(uap, fdp), sizeof(fds));
if (error != 0) {
fdrelease(p, fds[0]);
fdrelease(p, fds[1]);
}
fdpunlock(fdp);
return (error);
free3:
fdremove(fdp, fds[0]);
closef(rf, p);
rpipe = NULL;
free2:
fdpunlock(fdp);
free1:
pipeclose(wpipe);
pipeclose(rpipe);
return (error);
}
int
main(int argc, char *argv[])
{
pid_t pager_pid = -1;
int c;
while ((c = getopt(argc, argv, "If:nv")) != -1)
switch (c) {
case 'I': Iflag++; break;
case 'f': fflag = optarg; break;
case 'n': nflag = 1; break;
case 'v': vflag = 1; break;
default:
fprintf(stderr, "Usage: mscan [-Inv] [-f format] [msgs...]\n");
exit(1);
}
if (nflag) {
if (argc == optind && isatty(0))
blaze822_loop1(":", numline);
else
blaze822_loop(argc-optind, argv+optind, numline);
return 0;
}
now = time(0);
struct tm *tm = localtime(&now);
curyear = tm->tm_year;
setlocale(LC_ALL, ""); // for wcwidth later
if (wcwidth(0xfffd) > 0)
replacement = 0xfffd;
struct winsize w;
int ttyfd = open("/dev/tty", O_RDONLY | O_NOCTTY);
if (ttyfd >= 0 && ioctl(ttyfd, TIOCGWINSZ, &w) == 0) {
cols = w.ws_col;
char *pg;
pg = getenv("MBLAZE_PAGER");
if (!pg)
pg = getenv("PAGER");
if (pg && *pg && strcmp(pg, "cat") != 0) {
pager_pid = pipeto(pg);
if (pager_pid < 0)
fprintf(stderr,
"mscan: spawning pager '%s': %s\n",
pg, strerror(errno));
}
}
if (ttyfd >= 0)
close(ttyfd);
if (getenv("COLUMNS"))
cols = atoi(getenv("COLUMNS"));
if (cols <= 40)
cols = 80;
char *f = blaze822_home_file("profile");
struct message *config = blaze822(f);
if (config) {
char *v, *d, *a;
if ((v = blaze822_hdr(config, "local-mailbox")))
while (alias_idx < (int)(sizeof aliases / sizeof aliases[0]) &&
(v = blaze822_addr(v, &d, &a)))
if (a)
aliases[alias_idx++] = strdup(a);
if ((v = blaze822_hdr(config, "alternate-mailboxes")))
while (alias_idx < (int)(sizeof aliases / sizeof aliases[0]) &&
(v = blaze822_addr(v, &d, &a)))
if (a)
aliases[alias_idx++] = strdup(a);
if ((v = blaze822_hdr(config, "scan-format")))
if (fflag == default_fflag) // NB. ==
fflag = v;
}
long i;
if (argc == optind && isatty(0))
i = blaze822_loop1(":", oneline);
else
i = blaze822_loop(argc-optind, argv+optind, oneline);
if (pager_pid > 0)
pipeclose(pager_pid);
if (vflag)
fprintf(stderr, "%ld mails scanned\n", i);
return 0;
}
int
dopipe(struct proc *p, int *ufds, int flags)
{
struct filedesc *fdp = p->p_fd;
struct file *rf, *wf;
struct pipe *rpipe, *wpipe = NULL;
int fds[2], error;
rpipe = pool_get(&pipe_pool, PR_WAITOK);
error = pipe_create(rpipe);
if (error != 0)
goto free1;
wpipe = pool_get(&pipe_pool, PR_WAITOK);
error = pipe_create(wpipe);
if (error != 0)
goto free1;
fdplock(fdp);
error = falloc(p, &rf, &fds[0]);
if (error != 0)
goto free2;
rf->f_flag = FREAD | FWRITE | (flags & FNONBLOCK);
rf->f_type = DTYPE_PIPE;
rf->f_data = rpipe;
rf->f_ops = &pipeops;
error = falloc(p, &wf, &fds[1]);
if (error != 0)
goto free3;
wf->f_flag = FREAD | FWRITE | (flags & FNONBLOCK);
wf->f_type = DTYPE_PIPE;
wf->f_data = wpipe;
wf->f_ops = &pipeops;
if (flags & O_CLOEXEC) {
fdp->fd_ofileflags[fds[0]] |= UF_EXCLOSE;
fdp->fd_ofileflags[fds[1]] |= UF_EXCLOSE;
}
rpipe->pipe_peer = wpipe;
wpipe->pipe_peer = rpipe;
FILE_SET_MATURE(rf, p);
FILE_SET_MATURE(wf, p);
error = copyout(fds, ufds, sizeof(fds));
if (error != 0) {
fdrelease(p, fds[0]);
fdrelease(p, fds[1]);
}
fdpunlock(fdp);
return (error);
free3:
fdremove(fdp, fds[0]);
closef(rf, p);
rpipe = NULL;
free2:
fdpunlock(fdp);
free1:
pipeclose(wpipe);
pipeclose(rpipe);
return (error);
}
/* ARGSUSED */
int
pipe(proc_t p, __unused struct pipe_args *uap, int32_t *retval)
{
struct fileproc *rf, *wf;
struct pipe *rpipe, *wpipe;
lck_mtx_t *pmtx;
int fd, error;
if ((pmtx = lck_mtx_alloc_init(pipe_mtx_grp, pipe_mtx_attr)) == NULL)
return (ENOMEM);
rpipe = wpipe = NULL;
if (pipe_create(&rpipe) || pipe_create(&wpipe)) {
error = ENFILE;
goto freepipes;
}
/*
* allocate the space for the normal I/O direction up
* front... we'll delay the allocation for the other
* direction until a write actually occurs (most likely it won't)...
*/
error = pipespace(rpipe, choose_pipespace(rpipe->pipe_buffer.size, 0));
if (error)
goto freepipes;
TAILQ_INIT(&rpipe->pipe_evlist);
TAILQ_INIT(&wpipe->pipe_evlist);
error = falloc(p, &rf, &fd, vfs_context_current());
if (error) {
goto freepipes;
}
retval[0] = fd;
/*
* for now we'll create half-duplex pipes(refer returns section above).
* this is what we've always supported..
*/
rf->f_flag = FREAD;
rf->f_data = (caddr_t)rpipe;
rf->f_ops = &pipeops;
error = falloc(p, &wf, &fd, vfs_context_current());
if (error) {
fp_free(p, retval[0], rf);
goto freepipes;
}
wf->f_flag = FWRITE;
wf->f_data = (caddr_t)wpipe;
wf->f_ops = &pipeops;
rpipe->pipe_peer = wpipe;
wpipe->pipe_peer = rpipe;
/* both structures share the same mutex */
rpipe->pipe_mtxp = wpipe->pipe_mtxp = pmtx;
retval[1] = fd;
#if CONFIG_MACF
/*
* XXXXXXXX SHOULD NOT HOLD FILE_LOCK() XXXXXXXXXXXX
*
* struct pipe represents a pipe endpoint. The MAC label is shared
* between the connected endpoints. As a result mac_pipe_label_init() and
* mac_pipe_label_associate() should only be called on one of the endpoints
* after they have been connected.
*/
mac_pipe_label_init(rpipe);
mac_pipe_label_associate(kauth_cred_get(), rpipe);
wpipe->pipe_label = rpipe->pipe_label;
#endif
proc_fdlock_spin(p);
procfdtbl_releasefd(p, retval[0], NULL);
procfdtbl_releasefd(p, retval[1], NULL);
fp_drop(p, retval[0], rf, 1);
fp_drop(p, retval[1], wf, 1);
proc_fdunlock(p);
return (0);
freepipes:
pipeclose(rpipe);
pipeclose(wpipe);
lck_mtx_free(pmtx, pipe_mtx_grp);
return (error);
}
