int ifc_set_mask(const char *name, in_addr_t mask)
{
    struct ifreq ifr;
    int ret;

    ifc_init_ifr(name, &ifr);
    init_sockaddr_in(&ifr.ifr_addr, mask);

    ret = ioctl(ifc_ctl_sock, SIOCSIFNETMASK, &ifr);
    if (DBG) printerr("ifc_set_mask(%s, xx) = %d", name, ret);
    return ret;
}
Exemple #2
0
/* perform create command */
static int proccreate(const char *path, int width, int64_t limsiz) {
    TCFDB *fdb = tcfdbnew();
    if (!INVALIDHANDLE(g_dbgfd)) tcfdbsetdbgfd(fdb, g_dbgfd);
    if (!tcfdbtune(fdb, width, limsiz)) {
        printerr(fdb);
        tcfdbdel(fdb);
        return 1;
    }
    if (!tcfdbopen(fdb, path, FDBOWRITER | FDBOCREAT | FDBOTRUNC)) {
        printerr(fdb);
        tcfdbdel(fdb);
        return 1;
    }
    bool err = false;
    if (!tcfdbclose(fdb)) {
        printerr(fdb);
        err = true;
    }
    tcfdbdel(fdb);
    return err ? 1 : 0;
}
Exemple #3
0
/* perform out command */
static int procout(const char *path, const char *pkbuf, int pksiz, int omode){
  TCTDB *tdb = tctdbnew();
  if(g_dbgfd != INVALID_HANDLE_VALUE) tctdbsetdbgfd(tdb, g_dbgfd);
  if(!tctdbsetcodecfunc(tdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(tdb);
  if(!tctdbopen(tdb, path, TDBOWRITER | omode)){
    printerr(tdb);
    tctdbdel(tdb);
    return 1;
  }
  bool err = false;
  if(!tctdbout(tdb, pkbuf, pksiz)){
    printerr(tdb);
    err = true;
  }
  if(!tctdbclose(tdb)){
    if(!err) printerr(tdb);
    err = true;
  }
  tctdbdel(tdb);
  return err ? 1 : 0;
}
Exemple #4
0
void lgssd_mutex_get(int semid)
{
	struct sembuf	op[1] = { {0, -1, SEM_UNDO} };
	int		rc;

	rc = semop(semid, op, 1);
	if (rc != 0) {
		printerr(0, "exit on mutex_get err %d: %s\n",
			 rc, strerror(errno));
		exit(1);
	}
}
Exemple #5
0
static int lgssd_create_mutex(int *semid)
{
	int		id;
	int		arg;

	id = semget(IPC_PRIVATE, 1, IPC_CREAT);
	if (id == -1) {
		printerr(0, "semget: %s\n", strerror(errno));
		return -1;
	}

	arg = 1;
	if (semctl(id, 0, SETVAL, arg) != 0) {
		printerr(0, "semctl: %s\n", strerror(errno));
		semctl(id, 1, IPC_RMID, arg);
		return -1;
	}

	*semid = id;
	return 0;
}
Exemple #6
0
/* perform out command */
static int procout(const char *path, const char *kbuf, int ksiz, int omode){
  TCHDB *hdb = tchdbnew();
  if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
  if(!tchdbsetcodecfunc(hdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(hdb);
  if(!tchdbopen(hdb, path, HDBOWRITER | omode)){
    printerr(hdb);
    tchdbdel(hdb);
    return 1;
  }
  bool err = false;
  if(!tchdbout(hdb, kbuf, ksiz)){
    printerr(hdb);
    err = true;
  }
  if(!tchdbclose(hdb)){
    if(!err) printerr(hdb);
    err = true;
  }
  tchdbdel(hdb);
  return err ? 1 : 0;
}
int ifc_set_addr(const char *name, in_addr_t addr)
{
    struct ifreq ifr;
    int ret;

    ifc_init_ifr(name, &ifr);
    init_sockaddr_in(&ifr.ifr_addr, addr);

    ret = ioctl(ifc_ctl_sock, SIOCSIFADDR, &ifr);
    if (DBG) printerr("ifc_set_addr(%s, xx) = %d", name, ret);
    return ret;
}
Exemple #8
0
/* perform optimize command */
static int procoptimize(const char *path, int lmemb, int nmemb,
        int bnum, int apow, int fpow, TCCMP cmp, int opts, int omode, bool df) {
    TCBDB *bdb = tcbdbnew();
    if (!INVALIDHANDLE(g_dbgfd)) tcbdbsetdbgfd(bdb, g_dbgfd);
    if (cmp && !tcbdbsetcmpfunc(bdb, cmp, NULL)) printerr(bdb);
    if (!tcbdbsetcodecfunc(bdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(bdb);
    if (!tcbdbopen(bdb, path, BDBOWRITER | omode)) {
        printerr(bdb);
        tcbdbdel(bdb);
        return 1;
    }
    bool err = false;
    if (df) {
        if (!tcbdbdefrag(bdb, INT64_MAX)) {
            printerr(bdb);
            err = true;
        }
    } else {
        if (!tcbdboptimize(bdb, lmemb, nmemb, bnum, apow, fpow, opts)) {
            printerr(bdb);
            err = true;
        }
    }
    if (!tcbdbclose(bdb)) {
        if (!err) printerr(bdb);
        err = true;
    }
    tcbdbdel(bdb);
    return err ? 1 : 0;
}
Exemple #9
0
/* perform put command */
static int procput(const char *path, const char *kbuf, int ksiz, const char *vbuf, int vsiz,
                   int omode, int dmode){
  TCHDB *hdb = tchdbnew();
  if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
  if(!tchdbsetcodecfunc(hdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(hdb);
  if(!tchdbopen(hdb, path, HDBOWRITER | omode)){
    printerr(hdb);
    tchdbdel(hdb);
    return 1;
  }
  bool err = false;
  switch(dmode){
  case -1:
    if(!tchdbputkeep(hdb, kbuf, ksiz, vbuf, vsiz)){
      printerr(hdb);
      err = true;
    }
    break;
  case 1:
    if(!tchdbputcat(hdb, kbuf, ksiz, vbuf, vsiz)){
      printerr(hdb);
      err = true;
    }
    break;
  case 10:
    if(tchdbaddint(hdb, kbuf, ksiz, tcatoi(vbuf)) == INT_MIN){
      printerr(hdb);
      err = true;
    }
    break;
  case 11:
    if(isnan(tchdbadddouble(hdb, kbuf, ksiz, tcatof(vbuf)))){
      printerr(hdb);
      err = true;
    }
    break;
  default:
    if(!tchdbput(hdb, kbuf, ksiz, vbuf, vsiz)){
      printerr(hdb);
      err = true;
    }
    break;
  }
  if(!tchdbclose(hdb)){
    if(!err) printerr(hdb);
    err = true;
  }
  tchdbdel(hdb);
  return err ? 1 : 0;
}
Exemple #10
0
int
dentfill(char *path, struct entry **dents,
	 int (*filter)(regex_t *, char *), regex_t *re)
{
	DIR *dirp;
	struct dirent *dp;
	struct stat sb;
	char *newpath;
	int r, n = 0;

	dirp = opendir(path);
	if (dirp == NULL)
		return 0;

	while ((dp = readdir(dirp)) != NULL) {
		/* Skip self and parent */
		if (strcmp(dp->d_name, ".") == 0
		    || strcmp(dp->d_name, "..") == 0)
			continue;
		if (filter(re, dp->d_name) == 0)
			continue;
		*dents = xrealloc(*dents, (n + 1) * sizeof(**dents));
		(*dents)[n].name = xstrdup(dp->d_name);
		/* Get mode flags */
		newpath = mkpath(path, dp->d_name);
		r = lstat(newpath, &sb);
		if (r == -1)
			printerr(1, "lstat");
		(*dents)[n].mode = sb.st_mode;
		(*dents)[n].t = sb.st_mtime;
		n++;
	}

	/* Should never be null */
	r = closedir(dirp);
	if (r == -1)
		printerr(1, "closedir");

	return n;
}
int free_symlink_tree(void)
{
	int i;
	char tmppath[PATH_MAX];

	/* Remove the symlinks from the test tree */
	for (i =  num_tree_symlinks - 1; i > -1; i--) {
		snprintf(tmppath, PATH_MAX, "%s/%s",
				tree_origin, tree_symlinks[i].orig);

		if (unlink(tmppath) != 0) {
			snprintf(errmsg, ERRSIZE, "unlink %s", tmppath);
			printerr(errmsg);
			goto error;
		}
	}

	/* Remove the directories from the test tree */
	for (i = num_tree_dirs - 1; i > -1; i--) {
		snprintf(tmppath, PATH_MAX, "%s/%s", tree_origin, tree_dirs[i]);

		if (rmdir(tmppath) != 0) {
			snprintf(errmsg, ERRSIZE, "rmdir %s", tmppath);
			printerr(errmsg);
			goto error;
		}
	}

	/* Remove the temporary directory */
	if (rmdir(tree_origin) != 0) {
		snprintf(errmsg, ERRSIZE, "rmdir %s", tree_origin);
		printerr(errmsg);
		goto error;
	}

	return 0;

error:
	return 1;
}
int prepare_symlink_tree(void)
{
	int i;
	char tmppath[PATH_MAX];

	/* Create the temporary directory */
	if (mkdtemp(tree_origin) == NULL) {
		printerr("mkdtemp");
		goto error;
	}

	/* Create the directories of the test tree */
	for (i = 0; i < num_tree_dirs; i++) {
		snprintf(tmppath, PATH_MAX, "%s/%s", tree_origin, tree_dirs[i]);

		if (mkdir(tmppath, 0755) != 0) {
			snprintf(errmsg, ERRSIZE, "mkdir %s", tmppath);
			printerr(errmsg);
			goto error;
		}
	}

	/* Create the symlinks of the test tree */
	for (i = 0; i < num_tree_symlinks; i++) {
		snprintf(tmppath, PATH_MAX, "%s/%s",
				tree_origin, tree_symlinks[i].orig);

		if (symlink(tree_symlinks[i].dest, tmppath) != 0) {
			snprintf(errmsg, ERRSIZE, "symlink %s to %s",
					tmppath, tree_symlinks[i].dest);
			printerr(errmsg);
			goto error;
		}
	}

	return 0;

error:
	return 1;
}
Exemple #13
0
/* perform out command */
static int procout(const char *path, const char *kbuf, int ksiz, TCCMP cmp, int omode) {
    TCBDB *bdb = tcbdbnew();
    if (!INVALIDHANDLE(g_dbgfd)) tcbdbsetdbgfd(bdb, g_dbgfd);
    if (cmp && !tcbdbsetcmpfunc(bdb, cmp, NULL)) printerr(bdb);
    if (!tcbdbsetcodecfunc(bdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(bdb);
    if (!tcbdbopen(bdb, path, BDBOWRITER | omode)) {
        printerr(bdb);
        tcbdbdel(bdb);
        return 1;
    }
    bool err = false;
    if (!tcbdbout(bdb, kbuf, ksiz)) {
        printerr(bdb);
        err = true;
    }
    if (!tcbdbclose(bdb)) {
        if (!err) printerr(bdb);
        err = true;
    }
    tcbdbdel(bdb);
    return err ? 1 : 0;
}
Exemple #14
0
/* perform create command */
static int proccreate(const char *path, int bnum, int apow, int fpow, int opts){
  TCTDB *tdb = tctdbnew();
  if(g_dbgfd != INVALID_HANDLE_VALUE) tctdbsetdbgfd(tdb, g_dbgfd);
  if(!tctdbsetcodecfunc(tdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(tdb);
  if(!tctdbtune(tdb, bnum, apow, fpow, opts)){
    printerr(tdb);
    tctdbdel(tdb);
    return 1;
  }
  if(!tctdbopen(tdb, path, TDBOWRITER | TDBOCREAT | TDBOTRUNC)){
    printerr(tdb);
    tctdbdel(tdb);
    return 1;
  }
  bool err = false;
  if(!tctdbclose(tdb)){
    printerr(tdb);
    err = true;
  }
  tctdbdel(tdb);
  return err ? 1 : 0;
}
Exemple #15
0
static int
do_error_downcall(int k5_fd, uid_t uid, int err)
{
	char	buf[1024];
	char	*p = buf, *end = buf + 1024;
	unsigned int timeout = 0;
	int	zero = 0;

	printerr(2, "doing error downcall\n");

	if (WRITE_BYTES(&p, end, uid)) goto out_err;
	if (WRITE_BYTES(&p, end, timeout)) goto out_err;
	/* use seq_win = 0 to indicate an error: */
	if (WRITE_BYTES(&p, end, zero)) goto out_err;
	if (WRITE_BYTES(&p, end, err)) goto out_err;

	if (write(k5_fd, buf, p - buf) < p - buf) goto out_err;
	return 0;
out_err:
	printerr(1, "Failed to write error downcall!\n");
	return -1;
}
Exemple #16
0
static void
do_downcall(int k5_fd, uid_t uid, struct authgss_private_data *pd,
	    gss_buffer_desc *context_token, OM_uint32 lifetime_rec,
	    gss_buffer_desc *acceptor)
{
	char    *buf = NULL, *p = NULL, *end = NULL;
	unsigned int timeout = context_timeout;
	unsigned int buf_size = 0;

	printerr(2, "doing downcall: lifetime_rec=%u acceptor=%.*s\n",
		lifetime_rec, acceptor->length, acceptor->value);
	buf_size = sizeof(uid) + sizeof(timeout) + sizeof(pd->pd_seq_win) +
		sizeof(pd->pd_ctx_hndl.length) + pd->pd_ctx_hndl.length +
		sizeof(context_token->length) + context_token->length +
		sizeof(acceptor->length) + acceptor->length;
	p = buf = malloc(buf_size);
	if (!buf)
		goto out_err;

	end = buf + buf_size;

	/* context_timeout set by -t option overrides context lifetime */
	if (timeout == 0)
		timeout = lifetime_rec;
	if (WRITE_BYTES(&p, end, uid)) goto out_err;
	if (WRITE_BYTES(&p, end, timeout)) goto out_err;
	if (WRITE_BYTES(&p, end, pd->pd_seq_win)) goto out_err;
	if (write_buffer(&p, end, &pd->pd_ctx_hndl)) goto out_err;
	if (write_buffer(&p, end, context_token)) goto out_err;
	if (write_buffer(&p, end, acceptor)) goto out_err;

	if (write(k5_fd, buf, p - buf) < p - buf) goto out_err;
	free(buf);
	return;
out_err:
	free(buf);
	printerr(1, "Failed to write downcall!\n");
	return;
}
Exemple #17
0
/* perform create command */
static int proccreate(const char *path, int bnum, int apow, int fpow, int opts){
  TCHDB *hdb = tchdbnew();
  if(g_dbgfd >= 0) tchdbsetdbgfd(hdb, g_dbgfd);
  if(!tchdbsetcodecfunc(hdb, _tc_recencode, NULL, _tc_recdecode, NULL)) printerr(hdb);
  if(!tchdbtune(hdb, bnum, apow, fpow, opts)){
    printerr(hdb);
    tchdbdel(hdb);
    return 1;
  }
  if(!tchdbopen(hdb, path, HDBOWRITER | HDBOCREAT | HDBOTRUNC)){
    printerr(hdb);
    tchdbdel(hdb);
    return 1;
  }
  bool err = false;
  if(!tchdbclose(hdb)){
    printerr(hdb);
    err = true;
  }
  tchdbdel(hdb);
  return err ? 1 : 0;
}
Exemple #18
0
static void
display_status_1(char *m, u_int32_t code, int type, const gss_OID mech)
{
	u_int32_t maj_stat, min_stat;
	gss_buffer_desc msg = GSS_C_EMPTY_BUFFER;
	u_int32_t msg_ctx = 0;
	char *typestr;

	switch (type) {
	case GSS_C_GSS_CODE:
		typestr = "GSS";
		break;
	case GSS_C_MECH_CODE:
		typestr = "mechanism";
		break;
	default:
		return;
		/* NOTREACHED */
	}

	for (;;) {
		maj_stat = gss_display_status(&min_stat, code,
		    type, mech, &msg_ctx, &msg);
		if (maj_stat != GSS_S_COMPLETE) {
			printerr(0, "ERROR: in call to "
				"gss_display_status called from %s\n", m);
			break;
		} else {
			printerr(0, "ERROR: GSS-API: (%s) error in %s(): %s\n",
			    typestr, m, (char *)msg.value);
		}

		if (msg.length != 0)
			(void) gss_release_buffer(&min_stat, &msg);

		if (msg_ctx == 0)
			break;
	}
}
Exemple #19
0
static void trace_dup(int oldfd, int newfd) {
    debug("trace_dup %d %d", oldfd, newfd);

    if (oldfd == newfd) {
        printerr("trace_dup: duplicating the same fd %d\n", oldfd);
        return;
    }

    Descriptor *o = get_descriptor(oldfd);
    if (o == NULL) {
        return;
    }

    /* Not a descriptor we are tracing */
    if (o->path == NULL) {
        return;
    }

    /* Just in case newfd is already open */
    trace_close(newfd);

    char *temp = strdup(o->path);
    if (temp == NULL) {
        printerr("strdup: %s\n", strerror(errno));
        return;
    }

    /* Copy the old descriptor into the new */
    Descriptor *n = get_descriptor(newfd);
    n->type = o->type;
    n->path = temp;
    n->bread = 0;
    n->bwrite = 0;
    n->nread = 0;
    n->nwrite = 0;
    n->bseek = 0;
    n->nseek = 0;
}
Exemple #20
0
static void trace_file(const char *path, int fd) {
    debug("trace_file %s %d", path, fd);

    Descriptor *f = get_descriptor(fd);
    if (f == NULL) {
        return;
    }

    if (!should_trace(path)) {
        return;
    }

    struct stat s;
    if (fstat(fd, &s) != 0) {
        printerr("fstat: %s\n", strerror(errno));
        return;
    }

    /* Skip directories */
    if (s.st_mode & S_IFDIR) {
        return;
    }

    char *temp = strdup(path);
    if (temp == NULL) {
        printerr("strdup: %s\n", strerror(errno));
        return;
    }

    f->type = DTYPE_FILE;
    f->path = temp;
    f->bread = 0;
    f->bwrite = 0;
    f->nread = 0;
    f->nwrite = 0;
    f->bseek = 0;
    f->nseek = 0;
}
Exemple #21
0
void* initMachine(void) {
    /* purpose: initialize the data structure.
     * returns: initialized MachineLinuxInfo structure.
     */
    unsigned long version;
    MachineLinuxInfo* p = (MachineLinuxInfo*) calloc(1, sizeof(MachineLinuxInfo));
    if (p == NULL) {
        printerr("calloc: %s\n", strerror(errno));
        return NULL;
    }

    /* name of this provider -- overwritten by importers */
    p->basic = initBasicMachine();
    p->basic->provider = "linux";

    gather_meminfo(&p->ram_total, &p->ram_free,
                   &p->ram_shared, &p->ram_buffer,
                   &p->swap_total, &p->swap_free);
    gather_loadavg(p->load);
    gather_proc_cpuinfo(p);
    gather_proc_uptime(&p->boottime, &p->idletime);

    version = extract_version(p->basic->uname.release);
    /* This used to have an upper limit of 3.2 from PM-571, but it was 
     * removed because the Linux kernel is changing version numbers too
     * fast to keep updating it.
     */
    if (version >= 2006000) {
        gather_linux_proc26(&p->procs, &p->tasks);
    } else if (version >= 2004000 && version <= 2004999) {
        gather_linux_proc24(&p->procs, &p->tasks);
    } else {
        printerr("Info: Kernel v%lu.%lu.%lu is not supported for proc stats gathering\n",
                 version / 1000000, (version % 1000000) / 1000, version % 1000);
    }

    return p;
}
Exemple #22
0
static void trace_openat(int fd) {
    debug("trace_openat %d", fd);

    char linkpath[64];
    snprintf(linkpath, 64, "/proc/%d/fd/%d", getpid(), fd);

    char fullpath[BUFSIZ];
    int len = readlink(linkpath, fullpath, BUFSIZ);
    if (len <= 0) {
        printerr("Unable to get real path for fd %d: %s\n",
                 fd, strerror(errno));
        return;
    }
    if (len == BUFSIZ) {
        printerr("Path too long for fd %d: %s\n",
                 fd, strerror(errno));
        return;
    }
    /* readlink doesn't add a null byte */
    fullpath[len] = '\0';

    trace_file(fullpath, fd);
}
Exemple #23
0
static void trace_truncate(const char *path, off_t length) {
    debug("trace_truncate %s %lu", path, length);

    char *fullpath = realpath(path, NULL);
    if (fullpath == NULL) {
        printerr("Unable to get real path for '%s': %s\n",
                 path, strerror(errno));
        return;
    }

    tprintf("file: '%s' %lu 0 0 0 0\n", fullpath, length);

    free(fullpath);
}
Exemple #24
0
void cart_reinit (void)
{
	// Re/Initialize all global library settings.
	
	check_endianness();

	if (!cartio.setup)
	{
		printerr("Internal error, cart input/output functions not initialized.\n");
		exit(1);
	}

	cartio.linker_reinit();
}
// Write HID report
static int d16_write_rep(USBDEVHANDLE dev, int reportnum, char buffer[8+1])
{
    int err;
    int len = 8 + 1; /* report id 1 byte + 8 bytes data */

    buffer[0] = (char)reportnum;
    err = usbhidSetReport(dev, buffer, len);
    if ( err ) {
        printerr("error writing hid report: %s\n", usbErrorMessage(err));
        return -1;
    }

    return err;
}
Exemple #26
0
int gssd_check_mechs(void)
{
	u_int32_t maj_stat, min_stat;
	gss_OID_set supported_mechs = GSS_C_NO_OID_SET;
	int retval = -1;

	maj_stat = gss_indicate_mechs(&min_stat, &supported_mechs);
	if (maj_stat != GSS_S_COMPLETE) {
		printerr(0, "Unable to obtain list of supported mechanisms. "
			 "Check that gss library is properly configured.\n");
		goto out;
	}
	if (supported_mechs == GSS_C_NO_OID_SET ||
	    supported_mechs->count == 0) {
		printerr(0, "Unable to obtain list of supported mechanisms. "
			 "Check that gss library is properly configured.\n");
		goto out;
	}
	maj_stat = gss_release_oid_set(&min_stat, &supported_mechs);
	retval = 0;
out:
	return retval;
}
Exemple #27
0
static void trace_open(const char *path, int fd) {
    debug("trace_open %s %d", path, fd);

    char *fullpath = realpath(path, NULL);
    if (fullpath == NULL) {
        printerr("Unable to get real path for '%s': %s\n",
                 path, strerror(errno));
        return;
    }

    trace_file(fullpath, fd);

    free(fullpath);
}
Exemple #28
0
DWORD WINAPI feedback(LPVOID arg)
{
    feedback_args_t *feed = (feedback_args_t*)arg;
    char *str[1024];
    DWORD len;

    while (ReadFile(feed->in, str, sizeof(str), &len, NULL))
        if (!len || !WriteFile(feed->out, str, len, &len, NULL))
            break;

    printerr("[EOF] from Console (%d)\n", GetLastError());

    return 0;
}
Exemple #29
0
//a function to unset the variable
void unset_sish(int argc, char *argv[]){
    if (argc < 2) {
	printerr(debugLevel, "usage: set name\n");
	return;
    }
    for (int i = 0; i < 100; ++i) {
	//go over the struct array and set the empty flag 
	//of the struct with found key to 1
	if (!strcmp(variables[i].key,argv[1])) {
	    variables[i].empty = 1;
	    break;
	}
    }
}
Exemple #30
0
int main(int argc, char *argv[]) {
	if (argc < 2) {
		printerr();
	}

	unsigned long randseed = (unsigned long)time(NULL); //random up to seconds;
	int num_rands = 1;

	int i = 1;
	int error;
	while(i < argc) {
		if (!strcmp(argv[i],"-s")) {
			i++;
			error = sscanf(argv[i], "%lu", &(randseed)); 
			if(error<1) { fprintf(stderr, "Error in specified randoom seed.\n"); exit(1);}
		}
		else if (!strcmp(argv[i],"-n")) {
			i++;
			error = sscanf(argv[i], "%d", &(num_rands));
			if(error<1) { fprintf(stderr, "Error in -n value\n"); exit(1);}
		}
		else {
			fprintf(stderr, "Unknown command: %s\n", argv[i]);
			printerr();
		}
		i++;
	}

	fprintf(stderr, "Random seed: %lu\n", randseed);
	sRandom(randseed);

	for(int i = 0; i < num_rands; i++) {
		printf("%lf\n", Random());
	}

	return 0;
}