示例#1
0
文件: test_find.c 项目: vanElden/burp
static void max_file_size(void)
{
	add_dir(     FOUND, "");
	add_file(    FOUND, "a", 1);
	add_file(    FOUND, "b", 2);
	add_file(NOT_FOUND, "c", 3);
	add_dir (    FOUND, "d");
	snprintf(extra_config, sizeof(extra_config),
		"include=%s\nmax_file_size=2", fullpath);
}
示例#2
0
文件: test_find.c 项目: vanElden/burp
static void exclude_dir(void)
{
	add_dir(     FOUND, "");
	add_file(    FOUND, "a",   1);
	add_dir (NOT_FOUND, "d");
	add_file(NOT_FOUND, "d/x", 1);
	add_file(    FOUND, "e",   3);
	snprintf(extra_config, sizeof(extra_config),
		"include=%s\n"
		"exclude=%s/d\n",
		fullpath, fullpath);
}
示例#3
0
文件: test_find.c 项目: vanElden/burp
static void exclude_extension(void)
{
	add_dir(     FOUND, "");
	add_file(NOT_FOUND, "a.c", 1);
	add_file(NOT_FOUND, "a.h", 2);
	add_file(    FOUND, "b",   2);
	add_file(    FOUND, "b.x", 2);
	add_file(NOT_FOUND, "c.c", 3);
	add_dir (    FOUND, "d");
	snprintf(extra_config, sizeof(extra_config),
		"include=%s\n"
		"exclude_ext=c\n"
		"exclude_ext=h\n", fullpath);
}
示例#4
0
GList *
category_group_list_get (void)
{
	GList *category_groups = NULL;
	GSList *dir_list = NULL, *sl;
	GList *categories, *l;
	FormatTemplateCategoryGroup *current_group;

	add_dir (&dir_list,
		 gnm_conf_get_autoformat_sys_dir (),
		 gnm_sys_data_dir ());
	add_dir (&dir_list,
		 gnm_conf_get_autoformat_usr_dir (),
		 gnm_usr_dir (FALSE));
	add_dir (&dir_list,
		 gnm_conf_get_autoformat_usr_dir (),
		 gnm_usr_dir (TRUE));

	for (sl = gnm_conf_get_autoformat_extra_dirs (); sl; sl = sl->next) {
		const char *dir = sl->data;
		add_dir (&dir_list, dir, g_get_home_dir ());
	}
	dir_list = g_slist_reverse (dir_list);
	categories = category_list_get_from_dir_list (dir_list);
	go_slist_free_custom (dir_list, g_free);

	categories = g_list_sort (categories, category_compare_name_and_dir);

	current_group = NULL;
	for (l = categories; l != NULL; l = l->next) {
		FormatTemplateCategory *category = l->data;
		if (current_group == NULL || strcmp (current_group->name, category->name) != 0) {
			if (current_group != NULL) {
				category_groups = g_list_prepend (category_groups, current_group);
			}
			current_group = g_new (FormatTemplateCategoryGroup, 1);
			current_group->categories = g_list_append (NULL, category);
			current_group->name = g_strdup (category->name);
			current_group->description = g_strdup (category->description);
		} else {
			current_group->categories = g_list_prepend (current_group->categories, category);
		}
	}
	if (current_group != NULL)
		category_groups = g_list_prepend (category_groups, current_group);

	g_list_free (categories);

	return category_groups;
}
示例#5
0
文件: test_find.c 项目: vanElden/burp
static void simple_entries(void)
{
	add_dir( FOUND, "");
	add_file(FOUND, "a", 1);
	add_file(FOUND, "b", 2);
	add_file(FOUND, "c", 3);
	add_dir (FOUND, "d");
	add_slnk(FOUND, "e", "a");
	add_hlnk(FOUND, "f", "a");
	add_hlnk(FOUND, "g", "a");
	add_fifo_special(FOUND, "h");
	add_sock(FOUND, "i");
	snprintf(extra_config, sizeof(extra_config), "include=%s", fullpath);
}
示例#6
0
文件: test_find.c 项目: vanElden/burp
static void exclude_regex(void)
{
	add_dir(     FOUND, "");
	add_file(    FOUND, "a", 1);
	add_file(    FOUND, "b", 1);
	add_file(    FOUND, "c", 1);
	add_file(NOT_FOUND, "dnotthisone", 1);
	add_dir (    FOUND, "e");
	add_dir (NOT_FOUND, "e/fexc");
	add_file(NOT_FOUND, "fnotthisone", 1);
	snprintf(extra_config, sizeof(extra_config),
		"include=%s\n"
		"exclude_regex=not\n"
		"exclude_regex=exc\n",
		fullpath);
}
示例#7
0
文件: mkfs.c 项目: cgchr9/v9-cpu
int main(int argc, char *argv[])
{
  struct direct *sp;
  static char cwd[PATH_MAX];
  //if (sizeof(struct dinode) != 4096) {
	//  dprintf(2, "sizeof(struct dinode) %d != 4096\n", sizeof(struct dinode));
	//  return -1;
  //}
  
  if (argc != 3) { dprintf(2, "Usage: mkfs fs rootdir\n"); return -1; }
  if ((disk = open(argv[1], O_RDWR | O_CREAT | O_TRUNC)) < 0) {
    dprintf(2, "open(%s) failed\n", argv[1]); return -1; }
  if ((int)(sp = (struct direct *) sbrk(16*1024*1024)) == -1) { dprintf(2, "sbrk() failed\n"); return -1; }

  // write zero bitmap
  write_disk(buf, BUFSZ);
  
  // populate file system
  getcwd(cwd, sizeof(cwd));
  chdir(argv[2]);
  add_dir(bn = 16, sp);
  chdir(cwd);

  // update bitmap
  memset(buf, 0xff, bn / 8);
  if (bn & 7) buf[bn / 8] = (1 << (bn & 7)) - 1;
  lseek(disk, 0, SEEK_SET);
  write_disk(buf, (bn + 7) / 8);
  close(disk);
  return 0;
}
示例#8
0
static int hello_mkdir(const char* path, mode_t mode)
{
	struct simple_directory *d = create_directory(path, S_IFDIR | mode);
	add_dir(root_directory, d);

	return 0;
}
return_type fsOpenDir(const int nparams, arg_type *a) {
    if (nparams != 1) {
        r.return_val = set_error(EINVAL);
        r.return_size = sizeof(int);
        r.in_error = 1;
        return r;
    }


    char * serverFolder = append_local_path(a->arg_val);
    DIR * dir = opendir(serverFolder);

    if (dir == NULL) {
        r.return_val = set_error(ENOTDIR);
        r.return_size = sizeof(int);
        r.in_error = 1;
    } else {
        int * id = malloc(sizeof(int));
        *id = add_dir(dir);

        r.return_val = (void *) id;
        r.return_size = sizeof(int);
        r.in_error = 0;
    }
    free(serverFolder);
    return r;

}
示例#10
0
文件: pathman.cpp 项目: xaberus/nih
  Error PathMan::read_dir(const char * path) {
    uint32_t len = strlen(path);
    char word[len+1];
    memcpy(word, path, len);
    word[len ] = 0;
    char * ppath[] = {word, 0};

    LookUp lu = lookup("/"), flu;

    if (lu.err)
      return lu.err;

    FTSENT *node;
    FTS *tree = fts_open(ppath, FTS_NOCHDIR, 0);

    if (!tree)
      return FAILURE;

    {
      size_t len;
      while ((node = fts_read(tree))) {
        char word[node->fts_pathlen + 3];

        if (node->fts_info & FTS_F) {
          mkword(node, word, len);
          flu = add_file(word, 0);

          if (flu.err)
            goto fout;

          flu.file->offset = 0;
          flu.file->size = node->fts_statp->st_size;
        } else if (node->fts_info & FTS_D) {
          mkword(node, word, len);
          if (len > 1) {
            if (word[len - 1] != '/') {
              word[len++] = '/';
            }
            word[len] = 0;

            lu = add_dir(word, 0);

            if (lu.err)
              goto dout;
          }
        }
      }
      fts_close(tree);
    }

    return SUCCESS;
  fout:
    fts_close(tree);
    return flu.err;
  dout:
    fts_close(tree);
    return lu.err;
  }
示例#11
0
void check_live()
{
    coord_s opentile[boardmaxw * boardmaxh];
    int n;
    int i, j;
    int x, y;
    int x1, y1;
    int tilecount = 0;
    int livecount;

    n = 2;
    opentile[0].x = sourcex;
    opentile[1].x = sourcex;
    opentile[0].y = sourceytop;
    opentile[1].y = sourceybottom;

    for (i=0; i<boardw; i++) {
	for (j=0; j<boardh; j++) {
	    if (board[i][j]) tilecount++;
	    board[i][j] &= ~16;
	}
    }
    board[sourcex][sourceytop] |= 16;
    board[sourcex][sourceybottom] |= 16;
    livecount = 2;

    while (n) {
	n--;
	x = opentile[n].x;
	y = opentile[n].y;

	for (j=0; j<4; j++) {
	    if (board[x][y] & (1 << j)) {
		add_dir(&x1, &y1, x, y, j);
		if (x1 < 0 || x1 >= boardw
			|| y1 < 0 || y1 >= boardh) {
		    continue;
		}

		i = board[x1][y1];
		if (i & (1 << ((j + 2) % 4))) {
		    if (!(i & 16)) {
			board[x1][y1] |= 16;
			livecount++;
			opentile[n].x = x1;
			opentile[n].y = y1;
			n++;
		    }
		}
	    }
	}
    }
    if (livecount == tilecount) {
	game_won = 1;
    }
}
示例#12
0
文件: test_find.c 项目: vanElden/burp
static void fifo_all(void)
{
	add_dir(     FOUND, "");
	add_fifo(    FOUND, "a");
	add_fifo(    FOUND, "b");
	snprintf(extra_config, sizeof(extra_config),
		"include=%s\n"
		"read_all_fifos=1\n",
		fullpath);
}
示例#13
0
文件: main.c 项目: stas/-junk
static int
add_dir_wrapper(const char *fpath, const struct stat *sp, int tf, struct FTW *pfwt)
{
    char *new_path = malloc( strlen(fpath)+1 );
    strncpy(new_path,fpath, strlen(fpath));
    if(tf == FTW_D && pfwt->level == 1) 
    {
        add_dir(new_path);
    }
    return 0;
}
示例#14
0
文件: test_find.c 项目: vanElden/burp
static void nobackup(void)
{
	add_dir(     FOUND, "");
	add_file(    FOUND, "a",   1);
	add_dir (NOT_FOUND, "d");
	add_file(NOT_FOUND, "d/.nobackup", 0);
	add_file(NOT_FOUND, "d/b", 1);
	add_dir (NOT_FOUND, "d/i");
	add_file(NOT_FOUND, "d/x", 1);
	add_file(    FOUND, "e",   3);
	add_dir (NOT_FOUND, "f");
	add_file(NOT_FOUND, "f/.exclude", 0);
	add_file(NOT_FOUND, "f/b", 1);
	add_dir (    FOUND, "g");
	snprintf(extra_config, sizeof(extra_config),
		"include=%s\n"
		"nobackup=.nobackup\n"
		"nobackup=.exclude\n",
		fullpath);
}
示例#15
0
文件: test_find.c 项目: vanElden/burp
static void fifo_individual(void)
{
	add_dir(     FOUND, "");
	add_fifo(    FOUND, "a");
	add_fifo(    FOUND, "b");
	add_fifo_special(FOUND, "c");
	snprintf(extra_config, sizeof(extra_config),
		"include=%s\n"
		"read_fifo=%s/a\n"
		"read_fifo=%s/b\n",
		fullpath, fullpath, fullpath);
}
示例#16
0
文件: test_find.c 项目: vanElden/burp
static void symlink_as_blockdev(void)
{
	add_dir(     FOUND, "");
	add_file(    FOUND, "a",   1);
	add_slnk_raw(FOUND, "e", "a");
	add_slnk_raw(FOUND, "f", "a");
	snprintf(extra_config, sizeof(extra_config),
		"include=%s\n"
		"read_blockdev=%s/e\n"
		"read_blockdev=%s/f\n",
		fullpath, fullpath, fullpath);
}
示例#17
0
void animate_pulse(widget_ptr wid)
{
    int i, dt, d;
    int x, y;
    SDL_Rect rect;
    int speed = 500;

    if (!pulse_count) {
	server_pulse();
    }

    rect.w = pipet + 2;
    rect.h = pipet + 2;
    i = 0;
    while (i<pulse_count) {
	x = pulse_list[i].x;
	y = pulse_list[i].y;
	d = pulse_list[i].dir;
	dt = tick - pulse_list[i].tick;
	if (dt > speed) {
	    pulse_count--;
	    memmove(&pulse_list[i], &pulse_list[i+1], sizeof(pulse_s) * (pulse_count - i));

	    add_dir(&x, &y, x, y, d);
	    new_pulse(x, y, (d + 2) % 4);
	} else {
	    //wrap cases:
	    if (dir[d].x == -1 && 2 * dt > speed && !x) {
		x += boardw;
	    }
	    if (dir[d].x == 1 && 2 * dt > speed && x == boardw - 1) {
		x -= boardw;
	    }
	    if (dir[d].y == -1 && 2 * dt > speed && !y) {
		y += boardh;
	    }
	    if (dir[d].y == 1 && 2 * dt > speed && y == boardh - 1) {
		y -= boardh;
	    }

	    rect.x = x * (cellw + border) + pipex - 1;
	    rect.x += dir[d].x * (cellw + border) * dt / speed;
	    rect.x += border + padding;

	    rect.y = y * (cellh + border) + border + padding;
	    rect.y += dir[d].y * (cellh + border) * dt / speed;
	    rect.y += pipey - 1;
	    widget_fillrect(wid, &rect, c_pulse);
	    i++;
	}
    }
}
void populatedb(fsal_posixdb_conn * p_conn, char *path)
{
  int rc;
  fsal_posixdb_fileinfo_t info;
  fsal_name_t fsalname;
  posixfsal_handle_t handle, handle_parent;
  struct stat buffstat;
  char *begin, *end, backup;

  if(path[0] != '/')
    {
      fputs("Error : you should provide a complete path", stderr);
      return;
    }

  if(path[strlen(path) - 1] != '/')
    strcat(path, "/");

  /* add the path (given in arguments) to the database */
  rc = lstat("/", &buffstat);
  fsal_internal_posix2posixdb_fileinfo(&buffstat, &info);
  fsal_internal_posixdb_add_entry(p_conn, NULL, &info, NULL, &handle_parent);

  begin = end = path;
  while(*end != '\0')
    {
      while(*begin == '/')
        begin++;
      if(*begin == '\0')
        break;
      end = begin + 1;
      while(*end != '/' && *end != '\0')
        end++;
      backup = *end;
      *end = '\0';

      rc = lstat(path, &buffstat);
      fsal_internal_posix2posixdb_fileinfo(&buffstat, &info);
      FSAL_str2name(begin, FSAL_MAX_NAME_LEN, &fsalname);
      fsal_internal_posixdb_add_entry(p_conn, &fsalname, &info, &handle_parent, &handle);
      memcpy(&handle_parent, &handle, sizeof(posixfsal_handle_t));

      *end = backup;
      begin = end;
    }

  /* add files */
  printf("Adding entries in %s... rc=%d ", path, rc);
  fflush(stdout);
  add_dir(p_conn, path, &handle_parent);
  puts("done");
}
示例#19
0
文件: test_find.c 项目: vanElden/burp
static void multi_includes(void)
{
	add_dir( NOT_FOUND, "");
	add_file(    FOUND, "a", 1);
	add_file(NOT_FOUND, "b", 2);
	add_file(NOT_FOUND, "c", 3);
	add_dir (    FOUND, "d");
	add_dir (    FOUND, "d/a");
	add_dir (NOT_FOUND, "d/a/b");
	add_dir (    FOUND, "d/a/b/c");
	add_nostat(  FOUND, "d/a/b/c/d");
	add_nostat(  FOUND, "d/a/b/c/d/e");
	add_slnk(NOT_FOUND, "e", "a");
	add_hlnk(NOT_FOUND, "g", "a");
	snprintf(extra_config, sizeof(extra_config),
		"include=%s/a\n"
		"include=%s/d\n"
		"exclude=%s/d/a/b\n"
		"include=%s/d/a/b/c\n"
		"include=%s/d/a/b/c/d\n"
		"include=%s/d/a/b/c/d/e\n",
		fullpath, fullpath, fullpath, fullpath, fullpath, fullpath);
}
示例#20
0
static int
check_dir (const char *name)
{
  int ret = -1;
  struct dirent *ent;
  char *cur = NULL;
  DIR *dir = opendir (name);
  if (dir == NULL)
    return -1;

  for (;;)
    {
      ent = readdir (dir);
      if (ent == NULL)
	break;

      if (ent->d_type != DT_DIR
	  || strcmp (ent->d_name, ".") == 0
	  || strcmp (ent->d_name, "..") == 0)
	continue;

      if (strcmp (ent->d_name, "cur") == 0 ||
	  strcmp (ent->d_name, "new") == 0 ||
	  strcmp (ent->d_name, "tmp") == 0)
	continue;

      asprintf (&cur, "%s/%s", name, ent->d_name);
      if (cur == NULL)
	error (EXIT_FAILURE, errno, "Could not allocate path for %s",
	       ent->d_name);

      if (access (cur, F_OK) < 0)
	goto cleanup;

      if (add_dir (ent->d_name, cur) < 0)
	error (EXIT_FAILURE, errno, "Could not add directory %s",
	       ent->d_name);

      free (cur);
      cur = NULL;
    }

  ret = 0;

cleanup:
  free (cur);
  closedir (dir);
  return ret;
}
示例#21
0
void
open_dir(struct sfs_fs *sfs, struct cache_inode *current, struct cache_inode *parent) {
    DIR *dir;
    if ((dir = opendir(".")) == NULL) {
        open_bug(sfs, NULL, "opendir failed.\n");
    }
    add_entry(sfs, current, current, ".");
    add_entry(sfs, current, parent, "..");
    struct dirent *direntp;
    while ((direntp = readdir(dir)) != NULL) {
        const char *name = direntp->d_name;
        if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
            continue ;
        }
        if (name[0] == '.') {
            continue ;
        }
        if (strlen(name) > SFS_MAX_FNAME_LEN) {
            open_bug(sfs, NULL, "file name is too long: %s\n", name);
        }
        struct stat *stat = safe_lstat(name);
        if (S_ISLNK(stat->st_mode)) {
            add_link(sfs, current, name, stat->st_ino);
        }
        else {
            int fd;
            if ((fd = open(name, O_RDONLY)) < 0) {
                open_bug(sfs, NULL, "open failed: %s\n", name);
            }
            if (S_ISDIR(stat->st_mode)) {
                add_dir(sfs, current, name, dirfd(dir), fd, stat->st_ino);
            }
            else if (S_ISREG(stat->st_mode)) {
                add_file(sfs, current, name, fd, stat->st_ino);
            }
            else {
                char mode = '?';
                if (S_ISFIFO(stat->st_mode)) mode = 'f';
                if (S_ISSOCK(stat->st_mode)) mode = 's';
                if (S_ISCHR(stat->st_mode)) mode = 'c';
                if (S_ISBLK(stat->st_mode)) mode = 'b';
                show_fullpath(sfs, NULL);
                warn("unsupported mode %07x (%c): file %s\n", stat->st_mode, mode, name);
            }
            close(fd);
        }
    }
    closedir(dir);
}
示例#22
0
void ffsb_createdir(ffsb_thread_t *ft, ffsb_fs_t *fs, unsigned opnum)
{
	struct benchfiles *bf = (struct benchfiles *)fs_get_opdata(fs, opnum);
	struct ffsb_file *newdir;
	randdata_t *rd = ft_get_randdata(ft);

	newdir = add_dir(bf, 0, rd);
	if (mkdir(newdir->name, S_IRWXU) < 0) {
		perror("mkdir");
		exit(1);
	}
	unlock_file_writer(newdir);

	ft_incr_op(ft, opnum, 1, 0);
}
示例#23
0
文件: main.c 项目: stas/-junk
int
main (int argc, char *argv[])
{
    pthread_t threads[NUM_THREADS];
    int thread_args[NUM_THREADS];
    int rc, i;
    char *search_p;

    /* read our arguments */
    if( argc >= 3 ) {
        search_s =  malloc( strlen( argv[1] )+1 );
        search_p =  malloc( strlen( argv[2] )+1 );
        if( search_s != 0 )
            search_s = argv[1];
        else {
            printf("main: Could not allocate memory.\n");
            exit(EXIT_FAILURE);
        }

        if( search_p != 0 )
            search_p = argv[2];
        else {
            printf("main: Could not allocate memory.\n");
            exit(EXIT_FAILURE);
        }
    } else {
        printf("Nothing to search for. Exiting...\n");
        exit(EXIT_SUCCESS);
    }

    printf("Searching for: '%s' in '%s', using %d threads...\n", search_s, search_p, NUM_THREADS);
    add_dir(search_p);

    /* create all threads */
    for (i=0; i<NUM_THREADS; ++i) {
        thread_args[i] = i;
        rc = pthread_create(&threads[i], NULL, do_search, (void *) &thread_args[i]);
        assert(0 == rc);
    }

    /* wait for all threads to complete */
    for (i=0; i<NUM_THREADS; ++i) {
        rc = pthread_join(threads[i], NULL);
        assert(0 == rc);
    }

    exit(EXIT_SUCCESS);
}
示例#24
0
文件: zip.cpp 项目: wingfiring/xirang
void add_dir(xirang::zip::reader_writer& zip, xirang::vfs::IVfs& vfs, const xirang::file_path& dir, const xirang::file_path& prefix){
	for(auto& i : vfs.children(dir)){
		auto filename = dir / i.path;
		auto st = vfs.state(filename);
		if (st.state == xirang::fs::st_dir){
			add_dir(zip, vfs, filename, prefix);
		}
		else if (st.state == xirang::fs::st_regular){
			auto fin = vfs.create<xirang::io::read_map>(filename, xirang::io::of_open);
			zip.append(fin.get<xirang::io::read_map>(), prefix / filename);
		}
		else {
			std::cout << "Unrecongnized file: " << filename.str() << std::endl;
		}

	}
}
void add_dir(fsal_posixdb_conn * p_conn, char *path, posixfsal_handle_t * p_dir_handle)
{
  DIR *dirp;
  struct dirent *dp;
  struct dirent dpe;
  posixfsal_handle_t new_handle;
  struct stat buffstat;
  char path_temp[FSAL_MAX_PATH_LEN];
  fsal_status_t st;
  fsal_posixdb_fileinfo_t info;
  fsal_name_t fsalname;

  if((dirp = opendir(path)))
    {
      while(!readdir_r(dirp, &dpe, &dp) && dp)
        {
          if(!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
            continue;
          if(!strcmp(dp->d_name, ".snapshot"))
            {
              fputs("(ignoring .snapshot)", stderr);
              continue;
            }
          strcpy(path_temp, path);
          strcat(path_temp, dp->d_name);
          lstat(path_temp, &buffstat);

          fsal_internal_posix2posixdb_fileinfo(&buffstat, &info);
          FSAL_str2name(dp->d_name, FSAL_MAX_NAME_LEN, &fsalname);
          st = fsal_internal_posixdb_add_entry(p_conn, &fsalname, &info, p_dir_handle,
                                               &new_handle);
          if(FSAL_IS_ERROR(st))
            {
              fprintf(stderr, "[Error %i/%i]\n", st.major, st.minor);
              return;
            }
          if(S_ISDIR(buffstat.st_mode))
            {
              strcat(path_temp, "/");
              add_dir(p_conn, path_temp, &new_handle);
            }
        };
      closedir(dirp);
    }
}
示例#26
0
/**
 * Handle a mkdir request
 *
 * @param msg client message data
 * @return Response data, NULL on allocation error
 */
resp_t *do_mkdir(msg_t *msg) {
    resp_t *resp = calloc(sizeof(resp_t));

    if (!resp) {
        debug("Failed to allocate response.\n");
        return NULL;
    }

    if (!add_dir(msg->buf)) {
        resp->type = MKDIR_OK;
        cgc_memset(resp->buf, 0, sizeof(resp->buf));
    } else {
        debug("Adding directory failed.\n");
        resp->type = MKDIR_FAIL;
    }

    return resp;
}
示例#27
0
文件: elfhints.c 项目: Absolight/pkg
static void
read_elf_hints(const char *hintsfile, int must_exist)
{
	int	 		 fd;
	struct stat		 s;
	void			*mapbase;
	struct elfhints_hdr	*hdr;
	char			*strtab;
	char			*dirlist;
	char			*p;

	if ((fd = open(hintsfile, O_RDONLY)) == -1) {
		if (errno == ENOENT && !must_exist)
			return;
		err(1, "Cannot open \"%s\"", hintsfile);
	}
	if (fstat(fd, &s) == -1)
		err(1, "Cannot stat \"%s\"", hintsfile);
	if (s.st_size > MAXFILESIZE)
		errx(1, "\"%s\" is unreasonably large", hintsfile);
	/*
	 * We use a read-write, private mapping so that we can null-terminate
	 * some strings in it without affecting the underlying file.
	 */
	mapbase = mmap(NULL, s.st_size, PROT_READ|PROT_WRITE,
	    MAP_PRIVATE, fd, 0);
	if (mapbase == MAP_FAILED)
		err(1, "Cannot mmap \"%s\"", hintsfile);
	close(fd);

	hdr = (struct elfhints_hdr *)mapbase;
	if (hdr->magic != ELFHINTS_MAGIC)
		errx(1, "\"%s\": invalid file format", hintsfile);
	if (hdr->version != 1)
		errx(1, "\"%s\": unrecognized file version (%d)", hintsfile,
		    hdr->version);

	strtab = (char *)mapbase + hdr->strtab;
	dirlist = strtab + hdr->dirlist;

	if (*dirlist != '\0')
		while ((p = strsep(&dirlist, ":")) != NULL)
			add_dir(hintsfile, p, 1);
}
示例#28
0
文件: elfhints.c 项目: Absolight/pkg
void
update_elf_hints(const char *hintsfile, int argc, char **argv, int merge)
{
	int	i;

	if (merge)
		read_elf_hints(hintsfile, 0);
	for (i = 0;  i < argc;  i++) {
		struct stat	s;

		if (stat(argv[i], &s) == -1)
			warn("warning: %s", argv[i]);
		else if (S_ISREG(s.st_mode))
			read_dirs_from_file(hintsfile, argv[i]);
		else
			add_dir(hintsfile, argv[i], 0);
	}
	write_elf_hints(hintsfile);
}
示例#29
0
void getfilelist(const char ***files, int *numfiles, const char *dirname,
	int sort_by_ext,
	const char **ignore_patterns, int num_ignore_patterns)
{
	assert(fnams == NULL);
	assert(nfnams == 0);
	assert(sfnams == 0);

	ignores = ignore_patterns;
	num_ignores = num_ignore_patterns;

	add_dir(dirname, "");

	qsort(fnams, nfnams, sizeof fnams[0],
		sort_by_ext ? extstrcmp : mystrcmp);

	*files = (const char **)fnams;
	*numfiles = nfnams;
}
示例#30
0
static void
read_dirs_from_file(const char *hintsfile, const char *listfile)
{
	FILE	*fp;
	char	 buf[MAXPATHLEN];
	int	 linenum;

	if ((fp = fopen(listfile, "r")) == NULL)
		err(1, "%s", listfile);

	linenum = 0;
	while (fgets(buf, sizeof buf, fp) != NULL) {
		char	*cp, *sp;

		linenum++;
		cp = buf;
		/* Skip leading white space. */
		while (isspace(*cp))
			cp++;
		if (*cp == '#' || *cp == '\0')
			continue;
		sp = cp;
		/* Advance over the directory name. */
		while (!isspace(*cp) && *cp != '\0')
			cp++;
		/* Terminate the string and skip trailing white space. */
		if (*cp != '\0') {
			*cp++ = '\0';
			while (isspace(*cp))
				cp++;
		}
		/* Now we had better be at the end of the line. */
		if (*cp != '\0')
			warnx("%s:%d: trailing characters ignored",
			    listfile, linenum);

		if ((sp = strdup(sp)) == NULL)
			errx(1, "Out of memory");
		add_dir(hintsfile, sp, 0);
	}

	fclose(fp);
}