C++ pfatal函数代码示例

/*
 * Check and potentially fix certain fields in the super block.
 */
static void
fixup_superblock(void)
{
	/*
	 * Kernel looks for FS_OPTTIME, and assumes that if that's not
	 * what's there, it must be FS_OPTSPACE, so not fixing does not
	 * require setting iscorrupt.
	 */
	if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
		pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
		if (reply("SET TO DEFAULT") == 1) {
			sblock.fs_optim = FS_OPTTIME;
			sbdirty();
		}
	}
	if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
		pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
		    sblock.fs_minfree);
		if (reply("SET TO DEFAULT") == 1) {
			sblock.fs_minfree = 10;
			sbdirty();
		} else if (sblock.fs_minfree < 0) {
			/*
			 * Kernel uses minfree without verification,
			 * and a negative value would do bad things.
			 */
			iscorrupt = 1;
		}
	}
}

/* Simulate a "/usr/bin/find . -print" */
void find(char *dirname)
{
	DIR *fd;
	struct dirent *d;

	if ((fd = opendir(dirname)) == NULL)
		pfatal("opendir");

	while ((d = readdir(fd)))
	{
		char fullname[MAXPATHLEN];
		struct stat statbuf;

		if (strcmp(".", d->d_name) == 0)
			continue;
		if (strcmp("..", d->d_name) == 0)
			continue;

		snprintf(fullname, MAXPATHLEN-1, "%s/%s", dirname, d->d_name);

		if (lstat(fullname, &statbuf) != 0)
			pfatal("lstat");

		printf("   %s\n", fullname);

		if (S_ISDIR(statbuf.st_mode))
			find(fullname);
	}

	closedir(fd);
}

static array_t
array_read (const char *filename)
{
  FILE *fd;
  array_t a;
  int size;
  int i, s;
  
  fd = fopen (filename, "r");
  if (!fd)
    pfatal ("Lecture tableau, ouverture du fichier");
  
  s = fscanf (fd, "%d\n", &size);
  if (s !=1) 
    pfatal ("Lecture tableau, taille du tableau");

  a = array_alloc (size);
  
  for (i=0 ; i<a.size ; i++) {
    s = fscanf (fd, "%e\n", a.val+i);
    if (s != 1) 
      pfatal ("Lecture tableau, manque de valeur");
  }
  
  s = fclose (fd);
  if (s)
    pfatal ("Lecture tableau, fermeture fichier");

  return a;
}

/*
 * Calculate a prototype superblock based on information in the disk label.
 * When done the cgsblock macro can be calculated and the fs_ncg field
 * can be used. Do NOT attempt to use other macros without verifying that
 * their needed information is available!
 */
static int
calcsb(char *dev, int devfd, struct fs *fs)
{
	struct disklabel *lp;
	struct partition *pp;
	char *cp;
	int i, nspf;

	cp = strchr(dev, '\0') - 1;
	if (cp == (char *)-1 || ((*cp < 'a' || *cp > 'h') && !isdigit(*cp))) {
		pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
		return (0);
	}
	lp = getdisklabel(dev, devfd);
	if (isdigit(*cp))
		pp = &lp->d_partitions[0];
	else
		pp = &lp->d_partitions[*cp - 'a'];
	if (pp->p_fstype != FS_BSDFFS) {
		pfatal("%s: NOT LABELED AS A BSD FILE SYSTEM (%s)\n",
			dev, pp->p_fstype < FSMAXTYPES ?
			fstypenames[pp->p_fstype] : "unknown");
		return (0);
	}
	if (pp->p_fsize == 0 || pp->p_frag == 0 ||
	    pp->p_cpg == 0 || pp->p_size == 0) {
		pfatal("%s: %s: type %s fsize %d, frag %d, cpg %d, size %d\n",
		    dev, "INCOMPLETE LABEL", fstypenames[pp->p_fstype],
		    pp->p_fsize, pp->p_frag, pp->p_cpg, pp->p_size);
		return (0);
	}
	memset(fs, 0, sizeof(struct fs));
	fs->fs_fsize = pp->p_fsize;
	fs->fs_frag = pp->p_frag;
	fs->fs_size = pp->p_size;
	fs->fs_sblkno = roundup(
		howmany(lp->d_bbsize + lp->d_sbsize, fs->fs_fsize),
		fs->fs_frag);
	nspf = fs->fs_fsize / lp->d_secsize;
	for (fs->fs_fsbtodb = 0, i = nspf; i > 1; i >>= 1)
		fs->fs_fsbtodb++;
	dev_bsize = lp->d_secsize;
	if (fs->fs_magic == FS_UFS2_MAGIC) {
		fs->fs_fpg = pp->p_cpg;
		fs->fs_ncg = howmany(fs->fs_size, fs->fs_fpg);
	} else /* if (fs->fs_magic == FS_UFS1_MAGIC) */ {
		fs->fs_old_cpg = pp->p_cpg;
		fs->fs_old_cgmask = 0xffffffff;
		for (i = lp->d_ntracks; i > 1; i >>= 1)
			fs->fs_old_cgmask <<= 1;
		if (!POWEROF2(lp->d_ntracks))
			fs->fs_old_cgmask <<= 1;
		fs->fs_old_cgoffset = roundup(howmany(lp->d_nsectors, nspf),
		    fs->fs_frag);
		fs->fs_fpg = (fs->fs_old_cpg * lp->d_secpercyl) / nspf;
		fs->fs_ncg = howmany(fs->fs_size / lp->d_secpercyl,
		    fs->fs_old_cpg);
	}
	return (1);
}

void
flush(int fd, struct bufarea *bp)
{
    int i, j;

    if (!bp->b_dirty)
        return;
    bp->b_dirty = 0;
    if (fswritefd < 0) {
        pfatal("WRITING IN READ_ONLY MODE.\n");
        return;
    }
    if (bp->b_errs != 0)
        pfatal("WRITING %sZERO'ED BLOCK %lld TO DISK\n",
               (bp->b_errs == bp->b_size / dev_bsize) ? "" : "PARTIALLY ",
               (long long)bp->b_bno);
    bp->b_errs = 0;
    blwrite(fd, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
    if (bp != &sblk)
        return;
    for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
        blwrite(fswritefd, (char *)sblock.fs_csp + i,
                fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
                sblock.fs_cssize - i < sblock.fs_bsize ?
                sblock.fs_cssize - i : sblock.fs_bsize);
    }
}

void
fileerror(ino_t cwd, ino_t ino, const char *errmesg)
{
	char pathbuf[MAXPATHLEN + 1];
	struct uvnode *vp;

	pwarn("%s ", errmesg);
	pinode(ino);
	printf("\n");
	pwarn("PARENT=%lld\n", (long long)cwd);
	getpathname(pathbuf, sizeof(pathbuf), cwd, ino);
	if (ino < ULFS_ROOTINO || ino >= maxino) {
		pfatal("NAME=%s\n", pathbuf);
		return;
	}
	vp = vget(fs, ino);
	if (vp == NULL)
		pfatal("INO is NULL\n");
	else {
		if (ftypeok(VTOD(vp)))
			pfatal("%s=%s\n",
			    (lfs_dino_getmode(fs, VTOI(vp)->i_din) & LFS_IFMT) == LFS_IFDIR ?
			    "DIR" : "FILE", pathbuf);
		else
			pfatal("NAME=%s\n", pathbuf);
	}
}

/*******************************************************************************
 * Labeling
 ******************************************************************************/
void dolabel(mdl_t *mdl) {
	// First, load the model provided by the user. This is mandatory to
	// label new datas ;-)
	if (mdl->opt->model == NULL)
		fatal("you must specify a model");
	info("* Load model\n");
	FILE *file = fopen(mdl->opt->model, "r");
	if (file == NULL)
		pfatal("cannot open input model file");
	mdl_load(mdl, file);
	// Open input and output files
	FILE *fin = stdin, *fout = stdout;
	if (mdl->opt->input != NULL) {
		fin = fopen(mdl->opt->input, "r");
		if (fin == NULL)
			pfatal("cannot open input data file");
	}
	if (mdl->opt->output != NULL) {
		fout = fopen(mdl->opt->output, "w");
		if (fout == NULL)
			pfatal("cannot open output data file");
	}
	// Do the labelling
	info("* Label sequences\n");
	tag_label(mdl, fin, fout);
	info("* Done\n");
	// And close files
	if (mdl->opt->input != NULL)
		fclose(fin);
	if (mdl->opt->output != NULL)
		fclose(fout);
}

u_long findsrc(u_long dest)
{
	struct sockaddr_in sinsrc, sindest;
	int s, size;

	if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
		pfatal("socket error");

	memset(&sinsrc, 0, sizeof(struct sockaddr_in));
	memset(&sindest, 0, sizeof(struct sockaddr_in));

	sindest.sin_family = AF_INET;
	sindest.sin_addr.s_addr = dest;
	sindest.sin_port = htons(53); /* can be anything but zero */

	if (connect(s, (struct sockaddr *)&sindest, sizeof(sindest)) < 0)
		pfatal("connect");

	size = sizeof(sinsrc);
	if (getsockname(s, (struct sockaddr *)&sinsrc, &size) < 0)
		pfatal("getsockname");

	close(s);
	debug("Determined source address of %s to reach %s\n",
		iptos(sinsrc.sin_addr.s_addr), iptos(dest));
	return sinsrc.sin_addr.s_addr;
}

void
copy_file (char const *from, char const *to, struct stat *tost,
	   int to_flags, mode_t mode, bool to_dir_known_to_exist)
{
  int tofd;

  if (debug & 4)
    say ("Copying %s %s to %s\n",
	 S_ISLNK (mode) ? "symbolic link" : "file",
	 quotearg_n (0, from), quotearg_n (1, to));

  if (S_ISLNK (mode))
    {
      char *buffer = xmalloc (PATH_MAX);

      if (readlink (from, buffer, PATH_MAX) < 0)
	pfatal ("Can't read %s %s", "symbolic link", from);
      if (symlink (buffer, to) != 0)
	pfatal ("Can't create %s %s", "symbolic link", to);
      if (tost && lstat (to, tost) != 0)
	pfatal ("Can't get file attributes of %s %s", "symbolic link", to);
      free (buffer);
    }
  else
    {
      assert (S_ISREG (mode));
      tofd = create_file (to, O_WRONLY | O_BINARY | to_flags, mode,
			  to_dir_known_to_exist);
      copy_to_fd (from, tofd);
      if (tost && fstat (tofd, tost) != 0)
	pfatal ("Can't get file attributes of %s %s", "file", to);
      if (close (tofd) != 0)
	write_fatal ();
    }
}

/*
 * Fetch a line from the input file, \n terminated, not necessarily \0.
 */
char *
ifetch(LINENUM line, int whichbuf)
{
	if (line < 1 || line > input_lines) {
		if (warn_on_invalid_line) {
			say("No such line %ld in input file, ignoring\n", line);
			warn_on_invalid_line = false;
		}
		return NULL;
	}
	if (using_plan_a)
		return i_ptr[line];
	else {
		LINENUM	offline = line % lines_per_buf;
		LINENUM	baseline = line - offline;

		if (tiline[0] == baseline)
			whichbuf = 0;
		else if (tiline[1] == baseline)
			whichbuf = 1;
		else {
			tiline[whichbuf] = baseline;

			if (lseek(tifd, (off_t) (baseline / lines_per_buf *
			    tibuflen), SEEK_SET) < 0)
				pfatal("cannot seek in the temporary input file");

			if (read(tifd, tibuf[whichbuf], tibuflen) !=
			    (ssize_t) tibuflen)
				pfatal("error reading tmp file %s", TMPINNAME);
		}
		return tibuf[whichbuf] + (tireclen * offline);
	}
}

/* check if (arg) is a valid wordlist file */
void parser_wordlist(char *arg)
{
	struct stat wrd_stat;
#ifdef HAVE_LIBMAGIC
	const char *target_mime = "text/plain;";
#endif

	if(arg == NULL)
		fatal("called with NULL argument.");
	else if(globals.options.dict == false)
		fatal("dictionary features OFF. unable to parse wordlist.");
	else if( stat(arg,&wrd_stat) ) // if can't get file stats
		pfatal(arg);
	else if( S_ISREG(wrd_stat.st_mode) == 0 ) // if isn't a regular file
		fatal_long("\"%s\" is not a regular file.",arg);
	else if( access(arg,R_OK))
		pfatal(arg);
	else
	{
#ifdef HAVE_LIBMAGIC
		if(strncmp(get_mime(arg),target_mime,strlen(target_mime)+1) != 0)
			report(warning,"\"%s\" is not a \"%s\" file.",arg,target_mime);
#endif
		if((globals.wordlist = (const char *) get_full_path(arg)) == NULL)
			fatal("unable to resolve full path for wordlist.");
	}
	return;
}

/*
 * It would be nice to use some of the infrastructure in network.c,
 * but ServerNetInit only sets up UDP sockets. Maybe when we revisit
 * and refactor...
 */
static void
net_init(void)
{
	struct sockaddr_in name;
	
	if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
		pfatal("Could not allocate socket");

	name.sin_family = AF_INET;
	name.sin_addr.s_addr = clientif.s_addr;
	name.sin_port = htons(portnum);
	if (bind(sock, (struct sockaddr *)&name, sizeof(name)) < 0) {
		/*
		 * We reproduce ServerNetInit behavior here: if we cannot
		 * bind to the indicated port we exit with a special status
		 * so that the master server which invoked us can pick
		 * another.
		 */
		perror("Binding to socket");
		close(sock);
		exit(EADDRINUSE);
	}
	if (listen(sock, 128) < 0) {
		close(sock);
		pfatal("Could not listen on socket");
	}
}

/*******************************************************************************
 * Dumping
 ******************************************************************************/
static void dodump(mdl_t *mdl) {
    // Load input model file
    info("* Load model\n");
    FILE *fin = stdin;
    if (mdl->opt->input != NULL) {
        fin = fopen(mdl->opt->input, "r");
        if (fin == NULL)
            pfatal("cannot open input data file");
    }
    mdl_load(mdl, fin);
    if (mdl->opt->input != NULL)
        fclose(fin);
    // Open output file
    FILE *fout = stdout;
    if (mdl->opt->output != NULL) {
        fout = fopen(mdl->opt->output, "w");
        if (fout == NULL)
            pfatal("cannot open output data file");
    }
    // Dump model
    info("* Dump model\n");
    const uint32_t Y = mdl->nlbl;
    const uint64_t O = mdl->nobs;
    const qrk_t *Qlbl = mdl->reader->lbl;
    const qrk_t *Qobs = mdl->reader->obs;
    char fmt[16];
    sprintf(fmt, "%%.%df\n", mdl->opt->prec);
    for (uint64_t o = 0; o < O; o++) {
        const char *obs = qrk_id2str(Qobs, o);
        bool empty = true;
        if (mdl->kind[o] & 1) {
            const double *w = mdl->theta + mdl->uoff[o];
            for (uint32_t y = 0; y < Y; y++) {
                if (!mdl->opt->all && w[y] == 0.0)
                    continue;
                const char *ly = qrk_id2str(Qlbl, y);
                fprintf(fout, "%s\t#\t%s\t", obs, ly);
                fprintf(fout, fmt, w[y]);
                empty = false;
            }
        }
        if (mdl->kind[o] & 2) {
            const double *w = mdl->theta + mdl->boff[o];
            for (uint32_t d = 0; d < Y * Y; d++) {
                if (!mdl->opt->all && w[d] == 0.0)
                    continue;
                const char *ly  = qrk_id2str(Qlbl, d % Y);
                const char *lyp = qrk_id2str(Qlbl, d / Y);
                fprintf(fout, "%s\t%s\t%s\t", obs, lyp, ly);
                fprintf(fout, fmt, w[d]);
                empty = false;
            }
        }
        if (!empty)
            fprintf(fout, "\n");
    }
    if (mdl->opt->output != NULL)
        fclose(fout);
}

void
load_conf(struct opts *opts)
{
  FILE *f;
  struct conf_entry *conf, *e;
  char *conf_file = opts->conf_file;
  if (!opts->conf_file)
    conf_file = DEFAULT_CONF_FILE;
  f = fopen (conf_file, "r");
  if (!f) {
    if (opts->conf_file) {
      pfatal ("can't open conf file '%s'", opts->conf_file);
    } else {
      pinfo ("can't open conf file '%s'", conf_file);
      return;
    }
  }
  conf = conf_parse (f);
  if (!conf)
    pfatal ("can't parse config file");

  for (e = conf; e; e = e->next) {
    if (!strcmp (e->key, "max-tries") && e->value) {
      opts->max_tries = atoi (e->value);
    } else if (!strcmp (e->key, "min-steady-state-interval") && e->value) {
      opts->min_steady_state_interval = atoi (e->value);
    } else if (!strcmp (e->key, "wait-between-tries") && e->value) {
      opts->wait_between_tries = atoi (e->value);
    } else if (!strcmp (e->key, "subprocess-tries") && e->value) {
      opts->subprocess_tries = atoi (e->value);
    } else if (!strcmp (e->key, "subprocess-wait-between-tries") && e->value) {
      opts->subprocess_wait_between_tries = atoi (e->value);
    } else if (!strcmp (e->key, "steady-state-interval") && e->value) {
      opts->steady_state_interval = atoi (e->value);
    } else if (!strcmp (e->key, "base-path") && e->value) {
      opts->base_path = strdup (e->value);
      if (!opts->base_path)
        fatal ("out of memory for base path");
    } else if (!strcmp (e->key, "should-sync-hwclock")) {
      opts->should_sync_hwclock = e->value ? !strcmp(e->value, "yes") : 1;
    } else if (!strcmp (e->key, "should-load-disk")) {
      opts->should_load_disk = e->value ? !strcmp(e->value, "yes") : 1;
    } else if (!strcmp (e->key, "should-save-disk")) {
      opts->should_save_disk = e->value ? !strcmp(e->value, "yes") : 1;
    } else if (!strcmp (e->key, "should-netlink")) {
      opts->should_netlink = e->value ? !strcmp(e->value, "yes") : 1;
    } else if (!strcmp (e->key, "dry-run")) {
      opts->dry_run = e->value ? !strcmp(e->value, "yes") : 1;
    } else if (!strcmp (e->key, "jitter") && e->value) {
      opts->jitter = atoi (e->value);
    } else if (!strcmp (e->key, "verbose")) {
      verbose = e->value ? !strcmp(e->value, "yes") : 1;
    } else if (!strcmp (e->key, "source")) {
      e = parse_source(opts, e);
    }
  }
}

void
route(const char * gw)
{
	int ret;
	struct uinet_socket * so;
	struct rt_msghdr * rtm;
	struct uinet_sockaddr * sa;
	struct uinet_sockaddr_in * sin;
	char buf[4096];

	errno = 0;
	ret = uinet_socreate(uinet_instance_default(), UINET_PF_ROUTE, &so, UINET_SOCK_RAW, 0);
	if (ret) {
		errno = ret;
		pfatal("uinet_socreate");
	}

	memset(buf, 0, sizeof(buf));

	rtm = (struct rt_msghdr *)buf;
	rtm->rtm_version = RTM_VERSION;
	rtm->rtm_type = RTM_ADD;
	rtm->rtm_flags = RTF_GATEWAY;
	rtm->rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK;
	rtm->rtm_pid = getpid();
	rtm->rtm_seq = 1234;

	sa = (struct uinet_sockaddr *)(rtm + 1);
	sin = (struct uinet_sockaddr_in *)(sa);
	sin->sin_len = sizeof(struct uinet_sockaddr_in);
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = inet_addr("0.0.0.0");

	sa = (struct uinet_sockaddr *)((unsigned char *)(sa) + ROUNDUP(sa->sa_len));
	sin = (struct uinet_sockaddr_in *)(sa);
	sin->sin_len = sizeof(struct uinet_sockaddr_in);
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = inet_addr(gw);

	sa = (struct uinet_sockaddr *)((unsigned char *)(sa) + ROUNDUP(sa->sa_len));
	sin = (struct uinet_sockaddr_in *)(sa);
	sin->sin_len = 0;
	sin->sin_family = AF_INET;

	sa = (struct uinet_sockaddr *)((unsigned char *)(sa) + ROUNDUP(sa->sa_len));
	rtm->rtm_msglen = (char *)sa - buf;

	errno = socket_write(so, buf, rtm->rtm_msglen);
	if (errno) pfatal("socket_write");

	/* probably should loop through reply messages and see whether 
	   the setting of the route succeeded; right now we just assume
	   it worked. */

	return;
}