void cxc_setup(void)
{
cxc_class = class_new(gensym("cxc"), (t_newmethod)cxc_new, 0,
sizeof(t_cxc), 0,0);
ixprint_setup();
// binshift_setup();
ascwave_setup();
ascseq_setup();
// mixer_setup();
// makesymbol_setup();
bfilt_setup();
bfilt2_setup();
/* sendOSC_setup(); */
/* dumpOSC_setup(); */
/* routeOSC_setup(); */
cxc_counter_setup();
reson_tilde_setup();
//serialize_setup();
cxc_prepend_setup();
cxc_split_setup();
utime_setup();
// RNG's
random1_setup();
random1_tilde_setup();
random_fl_setup();
random_fl_tilde_setup();
random_icg_setup();
random_icg_tilde_setup();
random_tw_setup();
dist_normal_setup();
ENV_setup();
proc_setup();
cxmean_setup();
cxavgdev_setup();
cxstddev_setup();
mean_tilde_setup();
delta_tilde_setup();
post("c : [email protected] ========================================");
post(" x : ver: "VERSION" ============================================");
post(" c: compiled: "__DATE__" ==================================");
// post("\\");
// L;
}
static int
proc_read(struct pci_dev *d, int pos, byte *buf, int len)
{
int fd = proc_setup(d, 0);
int res;
if (fd < 0)
return 0;
res = do_read(d, fd, buf, len, pos);
if (res < 0)
{
d->access->warning("proc_read: read failed: %s", strerror(errno));
return 0;
}
else if (res != len)
return 0;
return 1;
}
void
proc_init(struct privsep *ps, struct privsep_proc *p, u_int nproc)
{
u_int i;
/*
* Called from parent
*/
privsep_process = PROC_PARENT;
ps->ps_title[PROC_PARENT] = "parent";
ps->ps_pid[PROC_PARENT] = getpid();
proc_setup(ps);
/* Engage! */
for (i = 0; i < nproc; i++, p++) {
ps->ps_title[p->p_id] = p->p_title;
ps->ps_pid[p->p_id] = (*p->p_init)(ps, p);
}
}
static int
proc_write(struct pci_dev *d, int pos, byte *buf, int len)
{
int fd = proc_setup(d, 1);
int res;
if (fd < 0)
return 0;
res = do_write(d, fd, buf, len, pos);
if (res < 0)
{
d->access->warning("proc_write: write failed: %s", strerror(errno));
return 0;
}
else if (res != len)
{
d->access->warning("proc_write: tried to write %d bytes at %d, but only %d succeeded", len, pos, res);
return 0;
}
return 1;
}
void
proc_init(struct privsep *ps, struct privsep_proc *procs, unsigned int nproc,
int argc, char **argv, enum privsep_procid proc_id)
{
struct privsep_proc *p = NULL;
unsigned int proc;
unsigned int src, dst;
if (proc_id == PROC_PARENT) {
privsep_process = PROC_PARENT;
proc_setup(ps, procs, nproc);
/* Open socketpair()s for everyone. */
for (src = 0; src < PROC_MAX; src++)
for (dst = 0; dst < PROC_MAX; dst++)
proc_open(ps, src, dst);
/* Engage! */
proc_exec(ps, procs, nproc, argc, argv);
return;
}
/* Initialize a child */
for (proc = 0; proc < nproc; proc++) {
if (procs[proc].p_id != proc_id)
continue;
p = &procs[proc];
break;
}
if (p == NULL || p->p_init == NULL)
fatalx("%s: process %d missing process initialization",
__func__, proc_id);
p->p_init(ps, p);
fatalx("failed to initiate child process");
}
void
proc_run(struct privsep *ps, struct privsep_proc *p,
struct privsep_proc *procs, unsigned int nproc,
void (*run)(struct privsep *, struct privsep_proc *, void *), void *arg)
{
struct passwd *pw;
const char *root;
struct control_sock *rcs;
log_procinit(p->p_title);
/* Set the process group of the current process */
setpgid(0, 0);
if (p->p_id == PROC_CONTROL && ps->ps_instance == 0) {
if (control_init(ps, &ps->ps_csock) == -1)
fatalx("%s: control_init", __func__);
TAILQ_FOREACH(rcs, &ps->ps_rcsocks, cs_entry)
if (control_init(ps, rcs) == -1)
fatalx("%s: control_init", __func__);
}
/* Use non-standard user */
if (p->p_pw != NULL)
pw = p->p_pw;
else
pw = ps->ps_pw;
/* Change root directory */
if (p->p_chroot != NULL)
root = p->p_chroot;
else
root = pw->pw_dir;
if (chroot(root) == -1)
fatal("%s: chroot", __func__);
if (chdir("/") == -1)
fatal("%s: chdir(\"/\")", __func__);
privsep_process = p->p_id;
setproctitle("%s", p->p_title);
if (setgroups(1, &pw->pw_gid) ||
setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
fatal("%s: cannot drop privileges", __func__);
event_init();
signal_set(&ps->ps_evsigint, SIGINT, proc_sig_handler, p);
signal_set(&ps->ps_evsigterm, SIGTERM, proc_sig_handler, p);
signal_set(&ps->ps_evsigchld, SIGCHLD, proc_sig_handler, p);
signal_set(&ps->ps_evsighup, SIGHUP, proc_sig_handler, p);
signal_set(&ps->ps_evsigpipe, SIGPIPE, proc_sig_handler, p);
signal_set(&ps->ps_evsigusr1, SIGUSR1, proc_sig_handler, p);
signal_add(&ps->ps_evsigint, NULL);
signal_add(&ps->ps_evsigterm, NULL);
signal_add(&ps->ps_evsigchld, NULL);
signal_add(&ps->ps_evsighup, NULL);
signal_add(&ps->ps_evsigpipe, NULL);
signal_add(&ps->ps_evsigusr1, NULL);
proc_setup(ps, procs, nproc);
proc_accept(ps, PROC_PARENT_SOCK_FILENO, PROC_PARENT, 0);
if (p->p_id == PROC_CONTROL && ps->ps_instance == 0) {
TAILQ_INIT(&ctl_conns);
if (control_listen(&ps->ps_csock) == -1)
fatalx("%s: control_listen", __func__);
TAILQ_FOREACH(rcs, &ps->ps_rcsocks, cs_entry)
if (control_listen(rcs) == -1)
fatalx("%s: control_listen", __func__);
}
void
proc_init(struct privsep *ps, struct privsep_proc *procs, unsigned int nproc,
int argc, char **argv, enum privsep_procid proc_id)
{
struct privsep_proc *p = NULL;
struct privsep_pipes *pa, *pb;
unsigned int proc;
unsigned int dst;
int fds[2];
/* Don't initiate anything if we are not really going to run. */
if (ps->ps_noaction)
return;
if (proc_id == PROC_PARENT) {
privsep_process = PROC_PARENT;
proc_setup(ps, procs, nproc);
/*
* Create the children sockets so we can use them
* to distribute the rest of the socketpair()s using
* proc_connect() later.
*/
for (dst = 0; dst < PROC_MAX; dst++) {
/* Don't create socket for ourselves. */
if (dst == PROC_PARENT)
continue;
for (proc = 0; proc < ps->ps_instances[dst]; proc++) {
pa = &ps->ps_pipes[PROC_PARENT][0];
pb = &ps->ps_pipes[dst][proc];
if (socketpair(AF_UNIX,
SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
PF_UNSPEC, fds) == -1)
fatal("%s: socketpair", __func__);
pa->pp_pipes[dst][proc] = fds[0];
pb->pp_pipes[PROC_PARENT][0] = fds[1];
}
}
/* Engage! */
proc_exec(ps, procs, nproc, argc, argv);
return;
}
/* Initialize a child */
for (proc = 0; proc < nproc; proc++) {
if (procs[proc].p_id != proc_id)
continue;
p = &procs[proc];
break;
}
if (p == NULL || p->p_init == NULL)
fatalx("%s: process %d missing process initialization",
__func__, proc_id);
p->p_init(ps, p);
fatalx("failed to initiate child process");
}